diff --git a/src/mesh/MeshEdgeBoundary.cpp b/src/mesh/MeshEdgeBoundary.cpp
index 00ece5864c622b9e62d50afba09380d6022dfaef..cb522e5b01d3b2498459ec4bdd187693f8cf809f 100644
--- a/src/mesh/MeshEdgeBoundary.cpp
+++ b/src/mesh/MeshEdgeBoundary.cpp
@@ -7,7 +7,7 @@
 
 template <size_t Dimension>
 MeshEdgeBoundary<Dimension>::MeshEdgeBoundary(const Mesh<Connectivity<Dimension>>&, const RefEdgeList& ref_edge_list)
-  : m_ref_edge_list(ref_edge_list), m_boundary_name(ref_edge_list.refId().tagName())
+  : m_ref_edge_list(ref_edge_list)
 {}
 
 template MeshEdgeBoundary<1>::MeshEdgeBoundary(const Mesh<Connectivity<1>>&, const RefEdgeList&);
@@ -17,7 +17,6 @@ template MeshEdgeBoundary<3>::MeshEdgeBoundary(const Mesh<Connectivity<3>>&, con
 template <size_t Dimension>
 MeshEdgeBoundary<Dimension>::MeshEdgeBoundary(const Mesh<Connectivity<Dimension>>& mesh,
                                               const RefFaceList& ref_face_list)
-  : m_boundary_name(ref_face_list.refId().tagName())
 {
   const Array<const FaceId>& face_list = ref_face_list.list();
   static_assert(Dimension > 1, "conversion from to edge from face is valid in dimension > 1");
diff --git a/src/mesh/MeshEdgeBoundary.hpp b/src/mesh/MeshEdgeBoundary.hpp
index 012579bb065ec697d7d7aa97cd1bec0664b076ff..2f2cd9a5222dd2e09e063965c2949c392bde12b0 100644
--- a/src/mesh/MeshEdgeBoundary.hpp
+++ b/src/mesh/MeshEdgeBoundary.hpp
@@ -17,7 +17,6 @@ class [[nodiscard]] MeshEdgeBoundary   // clazy:exclude=copyable-polymorphic
 {
  protected:
   RefEdgeList m_ref_edge_list;
-  std::string m_boundary_name;
 
   std::array<TinyVector<Dimension>, Dimension*(Dimension - 1)> _getBounds(const Mesh<Connectivity<Dimension>>& mesh)
     const;
diff --git a/src/mesh/MeshFaceBoundary.cpp b/src/mesh/MeshFaceBoundary.cpp
index 2aeaa4b9db806605886cf529247a9db5e4ced0d4..ce18bd150ebb0810ae00b15bb7fc59ea919be7bd 100644
--- a/src/mesh/MeshFaceBoundary.cpp
+++ b/src/mesh/MeshFaceBoundary.cpp
@@ -6,7 +6,7 @@
 
 template <size_t Dimension>
 MeshFaceBoundary<Dimension>::MeshFaceBoundary(const Mesh<Connectivity<Dimension>>&, const RefFaceList& ref_face_list)
-  : m_ref_face_list(ref_face_list), m_boundary_name(ref_face_list.refId().tagName())
+  : m_ref_face_list(ref_face_list)
 {}
 
 template MeshFaceBoundary<1>::MeshFaceBoundary(const Mesh<Connectivity<1>>&, const RefFaceList&);
diff --git a/src/mesh/MeshFaceBoundary.hpp b/src/mesh/MeshFaceBoundary.hpp
index 6ef09579717e87511a99ef5867cda59b299a1be5..fd52128a3c960b43c5e432416c7e46a900d8eade 100644
--- a/src/mesh/MeshFaceBoundary.hpp
+++ b/src/mesh/MeshFaceBoundary.hpp
@@ -17,7 +17,6 @@ class [[nodiscard]] MeshFaceBoundary   // clazy:exclude=copyable-polymorphic
 {
  protected:
   RefFaceList m_ref_face_list;
-  std::string m_boundary_name;
 
   std::array<TinyVector<Dimension>, Dimension*(Dimension - 1)> _getBounds(const Mesh<Connectivity<Dimension>>& mesh)
     const;
diff --git a/src/mesh/MeshFlatNodeBoundary.cpp b/src/mesh/MeshFlatNodeBoundary.cpp
index 4c094045402ae97c866117a1eee28d55e05cc47d..b7de42715eff88510119b54507ed32323365c817 100644
--- a/src/mesh/MeshFlatNodeBoundary.cpp
+++ b/src/mesh/MeshFlatNodeBoundary.cpp
@@ -25,7 +25,7 @@ MeshFlatNodeBoundary<Dimension>::_checkBoundaryIsFlat(const TinyVector<Dimension
 
   if (parallel::allReduceOr(is_bad)) {
     std::ostringstream ost;
-    ost << "invalid boundary \"" << rang::fgB::yellow << this->m_boundary_name << rang::style::reset
+    ost << "invalid boundary \"" << rang::fgB::yellow << this->m_ref_node_list.refId() << rang::style::reset
         << "\": boundary is not flat!";
     throw NormalError(ost.str());
   }
@@ -49,7 +49,7 @@ MeshFlatNodeBoundary<1>::_getNormal(const Mesh<Connectivity<1>>& mesh)
 
   if (number_of_bc_nodes != 1) {
     std::ostringstream ost;
-    ost << "invalid boundary " << rang::fgB::yellow << m_boundary_name << rang::style::reset
+    ost << "invalid boundary " << rang::fgB::yellow << m_ref_node_list.refId() << rang::style::reset
         << ": node boundaries in 1D require to have exactly 1 node";
     throw NormalError(ost.str());
   }
@@ -70,7 +70,7 @@ MeshFlatNodeBoundary<2>::_getNormal(const Mesh<Connectivity<2>>& mesh)
 
   if (xmin == xmax) {
     std::ostringstream ost;
-    ost << "invalid boundary \"" << rang::fgB::yellow << this->m_boundary_name << rang::style::reset
+    ost << "invalid boundary \"" << rang::fgB::yellow << m_ref_node_list.refId() << rang::style::reset
         << "\": unable to compute normal";
     throw NormalError(ost.str());
   }
@@ -128,7 +128,7 @@ MeshFlatNodeBoundary<3>::_getNormal(const Mesh<Connectivity<3>>& mesh)
 
   if (normal_l2 == 0) {
     std::ostringstream ost;
-    ost << "invalid boundary \"" << rang::fgB::yellow << this->m_boundary_name << rang::style::reset
+    ost << "invalid boundary \"" << rang::fgB::yellow << m_ref_node_list.refId() << rang::style::reset
         << "\": unable to compute normal";
     throw NormalError(ost.str());
   }
diff --git a/src/mesh/MeshLineNodeBoundary.cpp b/src/mesh/MeshLineNodeBoundary.cpp
index 87425c616f9accab96db214f13b79b18013bf290..1b126f6207719d648415edbc41be6bb83c36abe7 100644
--- a/src/mesh/MeshLineNodeBoundary.cpp
+++ b/src/mesh/MeshLineNodeBoundary.cpp
@@ -29,7 +29,7 @@ MeshLineNodeBoundary<Dimension>::_checkBoundaryIsLine(const TinyVector<Dimension
 
   if (parallel::allReduceOr(is_bad)) {
     std::ostringstream ost;
-    ost << "invalid boundary \"" << rang::fgB::yellow << this->m_boundary_name << rang::style::reset
+    ost << "invalid boundary \"" << rang::fgB::yellow << this->m_ref_node_list.refId() << rang::style::reset
         << "\": boundary is not a line!";
     throw NormalError(ost.str());
   }
@@ -49,7 +49,7 @@ MeshLineNodeBoundary<2>::_getDirection(const Mesh<Connectivity<2>>& mesh)
 
   if (xmin == xmax) {
     std::ostringstream ost;
-    ost << "invalid boundary \"" << rang::fgB::yellow << this->m_boundary_name << rang::style::reset
+    ost << "invalid boundary \"" << rang::fgB::yellow << m_ref_node_list.refId() << rang::style::reset
         << "\": unable to compute direction";
     throw NormalError(ost.str());
   }
@@ -95,7 +95,7 @@ MeshLineNodeBoundary<3>::_getDirection(const Mesh<Connectivity<3>>& mesh)
   const double length = l2Norm(direction);
   if (length == 0) {
     std::ostringstream ost;
-    ost << "invalid boundary \"" << rang::fgB::yellow << this->m_boundary_name << rang::style::reset
+    ost << "invalid boundary \"" << rang::fgB::yellow << this->m_ref_node_list.refId() << rang::style::reset
         << "\": unable to compute direction";
     throw NormalError(ost.str());
   }
diff --git a/src/mesh/MeshNodeBoundary.cpp b/src/mesh/MeshNodeBoundary.cpp
index 649936f9b8e51a4aba76a8a8e266ca0f87b434b7..3e01616c66670706449018107aa3d417ab1d5007 100644
--- a/src/mesh/MeshNodeBoundary.cpp
+++ b/src/mesh/MeshNodeBoundary.cpp
@@ -173,12 +173,11 @@ MeshNodeBoundary<3>::_getBounds(const Mesh<Connectivity<3>>& mesh) const
 template <size_t Dimension>
 MeshNodeBoundary<Dimension>::MeshNodeBoundary(const Mesh<Connectivity<Dimension>>& mesh,
                                               const RefFaceList& ref_face_list)
-  : m_boundary_name(ref_face_list.refId().tagName())
 {
   const Array<const FaceId>& face_list = ref_face_list.list();
   if (not ref_face_list.isBoundary()) {
     std::ostringstream ost;
-    ost << "invalid boundary \"" << rang::fgB::yellow << this->m_boundary_name << rang::style::reset
+    ost << "invalid boundary \"" << rang::fgB::yellow << ref_face_list.refId() << rang::style::reset
         << "\": inner faces cannot be used to define mesh boundaries";
     throw NormalError(ost.str());
   }
@@ -220,12 +219,11 @@ MeshNodeBoundary<Dimension>::MeshNodeBoundary(const Mesh<Connectivity<Dimension>
 template <size_t Dimension>
 MeshNodeBoundary<Dimension>::MeshNodeBoundary(const Mesh<Connectivity<Dimension>>& mesh,
                                               const RefEdgeList& ref_edge_list)
-  : m_boundary_name(ref_edge_list.refId().tagName())
 {
   const Array<const EdgeId>& edge_list = ref_edge_list.list();
   if (not ref_edge_list.isBoundary()) {
     std::ostringstream ost;
-    ost << "invalid boundary \"" << rang::fgB::yellow << this->m_boundary_name << rang::style::reset
+    ost << "invalid boundary \"" << rang::fgB::yellow << ref_edge_list.refId() << rang::style::reset
         << "\": inner edges cannot be used to define mesh boundaries";
     throw NormalError(ost.str());
   }
@@ -265,11 +263,11 @@ MeshNodeBoundary<Dimension>::MeshNodeBoundary(const Mesh<Connectivity<Dimension>
 
 template <size_t Dimension>
 MeshNodeBoundary<Dimension>::MeshNodeBoundary(const Mesh<Connectivity<Dimension>>&, const RefNodeList& ref_node_list)
-  : m_ref_node_list(ref_node_list), m_boundary_name(ref_node_list.refId().tagName())
+  : m_ref_node_list(ref_node_list)
 {
   if (not ref_node_list.isBoundary()) {
     std::ostringstream ost;
-    ost << "invalid boundary \"" << rang::fgB::yellow << this->m_boundary_name << rang::style::reset
+    ost << "invalid boundary \"" << rang::fgB::yellow << this->m_ref_node_list.refId() << rang::style::reset
         << "\": inner nodes cannot be used to define mesh boundaries";
     throw NormalError(ost.str());
   }
diff --git a/src/mesh/MeshNodeBoundary.hpp b/src/mesh/MeshNodeBoundary.hpp
index 719ec08129b287f4925f20078e9ec268f4d83075..ce56579e853171e4b5be0d1f195936a75b838f78 100644
--- a/src/mesh/MeshNodeBoundary.hpp
+++ b/src/mesh/MeshNodeBoundary.hpp
@@ -17,7 +17,6 @@ class [[nodiscard]] MeshNodeBoundary   // clazy:exclude=copyable-polymorphic
 {
  protected:
   RefNodeList m_ref_node_list;
-  std::string m_boundary_name;
 
   std::array<TinyVector<Dimension>, Dimension*(Dimension - 1)> _getBounds(const Mesh<Connectivity<Dimension>>& mesh)
     const;
diff --git a/tests/test_MeshFlatEdgeBoundary.cpp b/tests/test_MeshFlatEdgeBoundary.cpp
index aebe2e01eafaacfa1d387ab3d8792f2edd4abde3..94700598238232b1e2a5e98692f57291f568dc39 100644
--- a/tests/test_MeshFlatEdgeBoundary.cpp
+++ b/tests/test_MeshFlatEdgeBoundary.cpp
@@ -1196,7 +1196,7 @@ TEST_CASE("MeshFlatEdgeBoundary", "[mesh]")
           {
             NumberedBoundaryDescriptor numbered_boundary_descriptor(3);
             REQUIRE_THROWS_WITH(getMeshFlatEdgeBoundary(mesh, numbered_boundary_descriptor),
-                                "error: invalid boundary \"YMAX\": boundary is not flat!");
+                                "error: invalid boundary \"YMAX(3)\": boundary is not flat!");
           }
         }
 
@@ -1229,7 +1229,7 @@ TEST_CASE("MeshFlatEdgeBoundary", "[mesh]")
           {
             NamedBoundaryDescriptor named_boundary_descriptor("YMAX");
             REQUIRE_THROWS_WITH(getMeshFlatEdgeBoundary(mesh, named_boundary_descriptor),
-                                "error: invalid boundary \"YMAX\": boundary is not flat!");
+                                "error: invalid boundary \"YMAX(3)\": boundary is not flat!");
           }
         }
       }
@@ -1304,13 +1304,13 @@ TEST_CASE("MeshFlatEdgeBoundary", "[mesh]")
           {
             NumberedBoundaryDescriptor numbered_boundary_descriptor(3);
             REQUIRE_THROWS_WITH(getMeshFlatEdgeBoundary(mesh, numbered_boundary_descriptor),
-                                "error: invalid boundary \"YMAX\": boundary is not flat!");
+                                "error: invalid boundary \"YMAX(3)\": boundary is not flat!");
           }
 
           {
             NumberedBoundaryDescriptor numbered_boundary_descriptor(5);
             REQUIRE_THROWS_WITH(getMeshFlatEdgeBoundary(mesh, numbered_boundary_descriptor),
-                                "error: invalid boundary \"ZMAX\": boundary is not flat!");
+                                "error: invalid boundary \"ZMAX(5)\": boundary is not flat!");
           }
         }
 
@@ -1345,13 +1345,13 @@ TEST_CASE("MeshFlatEdgeBoundary", "[mesh]")
           {
             NamedBoundaryDescriptor named_boundary_descriptor("YMAX");
             REQUIRE_THROWS_WITH(getMeshFlatEdgeBoundary(mesh, named_boundary_descriptor),
-                                "error: invalid boundary \"YMAX\": boundary is not flat!");
+                                "error: invalid boundary \"YMAX(3)\": boundary is not flat!");
           }
 
           {
             NamedBoundaryDescriptor named_boundary_descriptor("ZMAX");
             REQUIRE_THROWS_WITH(getMeshFlatEdgeBoundary(mesh, named_boundary_descriptor),
-                                "error: invalid boundary \"ZMAX\": boundary is not flat!");
+                                "error: invalid boundary \"ZMAX(5)\": boundary is not flat!");
           }
         }
       }
@@ -1415,13 +1415,13 @@ TEST_CASE("MeshFlatEdgeBoundary", "[mesh]")
           {
             NumberedBoundaryDescriptor numbered_boundary_descriptor(24);
             REQUIRE_THROWS_WITH(getMeshFlatEdgeBoundary(mesh, numbered_boundary_descriptor),
-                                "error: invalid boundary \"ZMAX\": boundary is not flat!");
+                                "error: invalid boundary \"ZMAX(24)\": boundary is not flat!");
           }
 
           {
             NumberedBoundaryDescriptor numbered_boundary_descriptor(26);
             REQUIRE_THROWS_WITH(getMeshFlatEdgeBoundary(mesh, numbered_boundary_descriptor),
-                                "error: invalid boundary \"YMAX\": boundary is not flat!");
+                                "error: invalid boundary \"YMAX(26)\": boundary is not flat!");
           }
         }
 
@@ -1456,13 +1456,13 @@ TEST_CASE("MeshFlatEdgeBoundary", "[mesh]")
           {
             NamedBoundaryDescriptor named_boundary_descriptor("YMAX");
             REQUIRE_THROWS_WITH(getMeshFlatEdgeBoundary(mesh, named_boundary_descriptor),
-                                "error: invalid boundary \"YMAX\": boundary is not flat!");
+                                "error: invalid boundary \"YMAX(26)\": boundary is not flat!");
           }
 
           {
             NamedBoundaryDescriptor named_boundary_descriptor("ZMAX");
             REQUIRE_THROWS_WITH(getMeshFlatEdgeBoundary(mesh, named_boundary_descriptor),
-                                "error: invalid boundary \"ZMAX\": boundary is not flat!");
+                                "error: invalid boundary \"ZMAX(24)\": boundary is not flat!");
           }
         }
       }
diff --git a/tests/test_MeshFlatFaceBoundary.cpp b/tests/test_MeshFlatFaceBoundary.cpp
index 446c9b478b5048109ee39d71449c44169ca461eb..e01d79d1dc456f6f193d42db86c4f1f5ce08b75f 100644
--- a/tests/test_MeshFlatFaceBoundary.cpp
+++ b/tests/test_MeshFlatFaceBoundary.cpp
@@ -976,7 +976,7 @@ TEST_CASE("MeshFlatFaceBoundary", "[mesh]")
           {
             NumberedBoundaryDescriptor numbered_boundary_descriptor(3);
             REQUIRE_THROWS_WITH(getMeshFlatFaceBoundary(mesh, numbered_boundary_descriptor),
-                                "error: invalid boundary \"YMAX\": boundary is not flat!");
+                                "error: invalid boundary \"YMAX(3)\": boundary is not flat!");
           }
         }
 
@@ -1009,7 +1009,7 @@ TEST_CASE("MeshFlatFaceBoundary", "[mesh]")
           {
             NamedBoundaryDescriptor named_boundary_descriptor("YMAX");
             REQUIRE_THROWS_WITH(getMeshFlatFaceBoundary(mesh, named_boundary_descriptor),
-                                "error: invalid boundary \"YMAX\": boundary is not flat!");
+                                "error: invalid boundary \"YMAX(3)\": boundary is not flat!");
           }
         }
       }
@@ -1084,13 +1084,13 @@ TEST_CASE("MeshFlatFaceBoundary", "[mesh]")
           {
             NumberedBoundaryDescriptor numbered_boundary_descriptor(3);
             REQUIRE_THROWS_WITH(getMeshFlatFaceBoundary(mesh, numbered_boundary_descriptor),
-                                "error: invalid boundary \"YMAX\": boundary is not flat!");
+                                "error: invalid boundary \"YMAX(3)\": boundary is not flat!");
           }
 
           {
             NumberedBoundaryDescriptor numbered_boundary_descriptor(5);
             REQUIRE_THROWS_WITH(getMeshFlatFaceBoundary(mesh, numbered_boundary_descriptor),
-                                "error: invalid boundary \"ZMAX\": boundary is not flat!");
+                                "error: invalid boundary \"ZMAX(5)\": boundary is not flat!");
           }
         }
 
@@ -1125,13 +1125,13 @@ TEST_CASE("MeshFlatFaceBoundary", "[mesh]")
           {
             NamedBoundaryDescriptor named_boundary_descriptor("YMAX");
             REQUIRE_THROWS_WITH(getMeshFlatFaceBoundary(mesh, named_boundary_descriptor),
-                                "error: invalid boundary \"YMAX\": boundary is not flat!");
+                                "error: invalid boundary \"YMAX(3)\": boundary is not flat!");
           }
 
           {
             NamedBoundaryDescriptor named_boundary_descriptor("ZMAX");
             REQUIRE_THROWS_WITH(getMeshFlatFaceBoundary(mesh, named_boundary_descriptor),
-                                "error: invalid boundary \"ZMAX\": boundary is not flat!");
+                                "error: invalid boundary \"ZMAX(5)\": boundary is not flat!");
           }
         }
       }
@@ -1195,13 +1195,13 @@ TEST_CASE("MeshFlatFaceBoundary", "[mesh]")
           {
             NumberedBoundaryDescriptor numbered_boundary_descriptor(24);
             REQUIRE_THROWS_WITH(getMeshFlatFaceBoundary(mesh, numbered_boundary_descriptor),
-                                "error: invalid boundary \"ZMAX\": boundary is not flat!");
+                                "error: invalid boundary \"ZMAX(24)\": boundary is not flat!");
           }
 
           {
             NumberedBoundaryDescriptor numbered_boundary_descriptor(26);
             REQUIRE_THROWS_WITH(getMeshFlatFaceBoundary(mesh, numbered_boundary_descriptor),
-                                "error: invalid boundary \"YMAX\": boundary is not flat!");
+                                "error: invalid boundary \"YMAX(26)\": boundary is not flat!");
           }
         }
 
@@ -1236,13 +1236,13 @@ TEST_CASE("MeshFlatFaceBoundary", "[mesh]")
           {
             NamedBoundaryDescriptor named_boundary_descriptor("YMAX");
             REQUIRE_THROWS_WITH(getMeshFlatFaceBoundary(mesh, named_boundary_descriptor),
-                                "error: invalid boundary \"YMAX\": boundary is not flat!");
+                                "error: invalid boundary \"YMAX(26)\": boundary is not flat!");
           }
 
           {
             NamedBoundaryDescriptor named_boundary_descriptor("ZMAX");
             REQUIRE_THROWS_WITH(getMeshFlatFaceBoundary(mesh, named_boundary_descriptor),
-                                "error: invalid boundary \"ZMAX\": boundary is not flat!");
+                                "error: invalid boundary \"ZMAX(24)\": boundary is not flat!");
           }
         }
       }
diff --git a/tests/test_MeshFlatNodeBoundary.cpp b/tests/test_MeshFlatNodeBoundary.cpp
index f0327319b9b256845d20472f0fa0e8a66b788eda..29b0110569a14a6612a8b50cc76bc892c476d1ad 100644
--- a/tests/test_MeshFlatNodeBoundary.cpp
+++ b/tests/test_MeshFlatNodeBoundary.cpp
@@ -237,13 +237,13 @@ TEST_CASE("MeshFlatNodeBoundary", "[mesh]")
 
           {
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NumberedBoundaryDescriptor(10)),
-                                "error: invalid boundary \"XMINYMIN\": unable to compute normal");
+                                "error: invalid boundary \"XMINYMIN(10)\": unable to compute normal");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NumberedBoundaryDescriptor(11)),
-                                "error: invalid boundary \"XMAXYMIN\": unable to compute normal");
+                                "error: invalid boundary \"XMAXYMIN(11)\": unable to compute normal");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NumberedBoundaryDescriptor(12)),
-                                "error: invalid boundary \"XMAXYMAX\": unable to compute normal");
+                                "error: invalid boundary \"XMAXYMAX(12)\": unable to compute normal");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NumberedBoundaryDescriptor(13)),
-                                "error: invalid boundary \"XMINYMAX\": unable to compute normal");
+                                "error: invalid boundary \"XMINYMAX(13)\": unable to compute normal");
           }
         }
 
@@ -276,13 +276,13 @@ TEST_CASE("MeshFlatNodeBoundary", "[mesh]")
 
           {
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NamedBoundaryDescriptor("XMINYMIN")),
-                                "error: invalid boundary \"XMINYMIN\": unable to compute normal");
+                                "error: invalid boundary \"XMINYMIN(10)\": unable to compute normal");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NamedBoundaryDescriptor("XMINYMAX")),
-                                "error: invalid boundary \"XMINYMAX\": unable to compute normal");
+                                "error: invalid boundary \"XMINYMAX(13)\": unable to compute normal");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NamedBoundaryDescriptor("XMAXYMIN")),
-                                "error: invalid boundary \"XMAXYMIN\": unable to compute normal");
+                                "error: invalid boundary \"XMAXYMIN(11)\": unable to compute normal");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NamedBoundaryDescriptor("XMAXYMAX")),
-                                "error: invalid boundary \"XMAXYMAX\": unable to compute normal");
+                                "error: invalid boundary \"XMAXYMAX(12)\": unable to compute normal");
           }
         }
       }
@@ -333,13 +333,13 @@ TEST_CASE("MeshFlatNodeBoundary", "[mesh]")
 
           {
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NumberedBoundaryDescriptor(8)),
-                                "error: invalid boundary \"XMINYMIN\": unable to compute normal");
+                                "error: invalid boundary \"XMINYMIN(8)\": unable to compute normal");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NumberedBoundaryDescriptor(9)),
-                                "error: invalid boundary \"XMINYMAX\": unable to compute normal");
+                                "error: invalid boundary \"XMINYMAX(9)\": unable to compute normal");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NumberedBoundaryDescriptor(10)),
-                                "error: invalid boundary \"XMAXYMIN\": unable to compute normal");
+                                "error: invalid boundary \"XMAXYMIN(10)\": unable to compute normal");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NumberedBoundaryDescriptor(11)),
-                                "error: invalid boundary \"XMAXYMAX\": unable to compute normal");
+                                "error: invalid boundary \"XMAXYMAX(11)\": unable to compute normal");
           }
         }
 
@@ -373,13 +373,13 @@ TEST_CASE("MeshFlatNodeBoundary", "[mesh]")
 
           {
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NamedBoundaryDescriptor("XMINYMIN")),
-                                "error: invalid boundary \"XMINYMIN\": unable to compute normal");
+                                "error: invalid boundary \"XMINYMIN(8)\": unable to compute normal");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NamedBoundaryDescriptor("XMINYMAX")),
-                                "error: invalid boundary \"XMINYMAX\": unable to compute normal");
+                                "error: invalid boundary \"XMINYMAX(9)\": unable to compute normal");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NamedBoundaryDescriptor("XMAXYMIN")),
-                                "error: invalid boundary \"XMAXYMIN\": unable to compute normal");
+                                "error: invalid boundary \"XMAXYMIN(10)\": unable to compute normal");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NamedBoundaryDescriptor("XMAXYMAX")),
-                                "error: invalid boundary \"XMAXYMAX\": unable to compute normal");
+                                "error: invalid boundary \"XMAXYMAX(11)\": unable to compute normal");
           }
         }
       }
@@ -473,21 +473,21 @@ TEST_CASE("MeshFlatNodeBoundary", "[mesh]")
                                 "error: cannot find surface with name \"31\"");
 
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NumberedBoundaryDescriptor(10)),
-                                "error: invalid boundary \"XMINYMINZMIN\": unable to compute normal");
+                                "error: invalid boundary \"XMINYMINZMIN(10)\": unable to compute normal");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NumberedBoundaryDescriptor(11)),
-                                "error: invalid boundary \"XMAXYMINZMIN\": unable to compute normal");
+                                "error: invalid boundary \"XMAXYMINZMIN(11)\": unable to compute normal");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NumberedBoundaryDescriptor(12)),
-                                "error: invalid boundary \"XMAXYMAXZMIN\": unable to compute normal");
+                                "error: invalid boundary \"XMAXYMAXZMIN(12)\": unable to compute normal");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NumberedBoundaryDescriptor(13)),
-                                "error: invalid boundary \"XMINYMAXZMIN\": unable to compute normal");
+                                "error: invalid boundary \"XMINYMAXZMIN(13)\": unable to compute normal");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NumberedBoundaryDescriptor(14)),
-                                "error: invalid boundary \"XMINYMINZMAX\": unable to compute normal");
+                                "error: invalid boundary \"XMINYMINZMAX(14)\": unable to compute normal");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NumberedBoundaryDescriptor(15)),
-                                "error: invalid boundary \"XMAXYMINZMAX\": unable to compute normal");
+                                "error: invalid boundary \"XMAXYMINZMAX(15)\": unable to compute normal");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NumberedBoundaryDescriptor(16)),
-                                "error: invalid boundary \"XMAXYMAXZMAX\": unable to compute normal");
+                                "error: invalid boundary \"XMAXYMAXZMAX(16)\": unable to compute normal");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NumberedBoundaryDescriptor(17)),
-                                "error: invalid boundary \"XMINYMAXZMAX\": unable to compute normal");
+                                "error: invalid boundary \"XMINYMAXZMAX(17)\": unable to compute normal");
           }
         }
 
@@ -550,21 +550,21 @@ TEST_CASE("MeshFlatNodeBoundary", "[mesh]")
                                 "error: cannot find surface with name \"YMINZMAX\"");
 
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NamedBoundaryDescriptor("XMINYMINZMIN")),
-                                "error: invalid boundary \"XMINYMINZMIN\": unable to compute normal");
+                                "error: invalid boundary \"XMINYMINZMIN(10)\": unable to compute normal");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NamedBoundaryDescriptor("XMAXYMINZMIN")),
-                                "error: invalid boundary \"XMAXYMINZMIN\": unable to compute normal");
+                                "error: invalid boundary \"XMAXYMINZMIN(11)\": unable to compute normal");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NamedBoundaryDescriptor("XMAXYMAXZMIN")),
-                                "error: invalid boundary \"XMAXYMAXZMIN\": unable to compute normal");
+                                "error: invalid boundary \"XMAXYMAXZMIN(12)\": unable to compute normal");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NamedBoundaryDescriptor("XMINYMAXZMIN")),
-                                "error: invalid boundary \"XMINYMAXZMIN\": unable to compute normal");
+                                "error: invalid boundary \"XMINYMAXZMIN(13)\": unable to compute normal");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NamedBoundaryDescriptor("XMINYMINZMAX")),
-                                "error: invalid boundary \"XMINYMINZMAX\": unable to compute normal");
+                                "error: invalid boundary \"XMINYMINZMAX(14)\": unable to compute normal");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NamedBoundaryDescriptor("XMAXYMINZMAX")),
-                                "error: invalid boundary \"XMAXYMINZMAX\": unable to compute normal");
+                                "error: invalid boundary \"XMAXYMINZMAX(15)\": unable to compute normal");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NamedBoundaryDescriptor("XMAXYMAXZMAX")),
-                                "error: invalid boundary \"XMAXYMAXZMAX\": unable to compute normal");
+                                "error: invalid boundary \"XMAXYMAXZMAX(16)\": unable to compute normal");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NamedBoundaryDescriptor("XMINYMAXZMAX")),
-                                "error: invalid boundary \"XMINYMAXZMAX\": unable to compute normal");
+                                "error: invalid boundary \"XMINYMAXZMAX(17)\": unable to compute normal");
           }
         }
       }
@@ -648,21 +648,21 @@ TEST_CASE("MeshFlatNodeBoundary", "[mesh]")
                                 "error: cannot find surface with name \"39\"");
 
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NumberedBoundaryDescriptor(40)),
-                                "error: invalid boundary \"XMINYMINZMIN\": unable to compute normal");
+                                "error: invalid boundary \"XMINYMINZMIN(40)\": unable to compute normal");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NumberedBoundaryDescriptor(41)),
-                                "error: invalid boundary \"XMAXYMINZMIN\": unable to compute normal");
+                                "error: invalid boundary \"XMAXYMINZMIN(41)\": unable to compute normal");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NumberedBoundaryDescriptor(42)),
-                                "error: invalid boundary \"XMINYMAXZMIN\": unable to compute normal");
+                                "error: invalid boundary \"XMINYMAXZMIN(42)\": unable to compute normal");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NumberedBoundaryDescriptor(43)),
-                                "error: invalid boundary \"XMINYMAXZMAX\": unable to compute normal");
+                                "error: invalid boundary \"XMINYMAXZMAX(43)\": unable to compute normal");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NumberedBoundaryDescriptor(44)),
-                                "error: invalid boundary \"XMINYMINZMAX\": unable to compute normal");
+                                "error: invalid boundary \"XMINYMINZMAX(44)\": unable to compute normal");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NumberedBoundaryDescriptor(45)),
-                                "error: invalid boundary \"XMAXYMINZMAX\": unable to compute normal");
+                                "error: invalid boundary \"XMAXYMINZMAX(45)\": unable to compute normal");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NumberedBoundaryDescriptor(47)),
-                                "error: invalid boundary \"XMAXYMAXZMAX\": unable to compute normal");
+                                "error: invalid boundary \"XMAXYMAXZMAX(47)\": unable to compute normal");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NumberedBoundaryDescriptor(51)),
-                                "error: invalid boundary \"XMAXYMAXZMIN\": unable to compute normal");
+                                "error: invalid boundary \"XMAXYMAXZMIN(51)\": unable to compute normal");
           }
         }
 
@@ -725,21 +725,21 @@ TEST_CASE("MeshFlatNodeBoundary", "[mesh]")
                                 "error: cannot find surface with name \"YMINZMAX\"");
 
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NamedBoundaryDescriptor("XMINYMINZMIN")),
-                                "error: invalid boundary \"XMINYMINZMIN\": unable to compute normal");
+                                "error: invalid boundary \"XMINYMINZMIN(40)\": unable to compute normal");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NamedBoundaryDescriptor("XMAXYMINZMIN")),
-                                "error: invalid boundary \"XMAXYMINZMIN\": unable to compute normal");
+                                "error: invalid boundary \"XMAXYMINZMIN(41)\": unable to compute normal");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NamedBoundaryDescriptor("XMAXYMAXZMIN")),
-                                "error: invalid boundary \"XMAXYMAXZMIN\": unable to compute normal");
+                                "error: invalid boundary \"XMAXYMAXZMIN(51)\": unable to compute normal");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NamedBoundaryDescriptor("XMINYMAXZMIN")),
-                                "error: invalid boundary \"XMINYMAXZMIN\": unable to compute normal");
+                                "error: invalid boundary \"XMINYMAXZMIN(42)\": unable to compute normal");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NamedBoundaryDescriptor("XMINYMINZMAX")),
-                                "error: invalid boundary \"XMINYMINZMAX\": unable to compute normal");
+                                "error: invalid boundary \"XMINYMINZMAX(44)\": unable to compute normal");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NamedBoundaryDescriptor("XMAXYMINZMAX")),
-                                "error: invalid boundary \"XMAXYMINZMAX\": unable to compute normal");
+                                "error: invalid boundary \"XMAXYMINZMAX(45)\": unable to compute normal");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NamedBoundaryDescriptor("XMAXYMAXZMAX")),
-                                "error: invalid boundary \"XMAXYMAXZMAX\": unable to compute normal");
+                                "error: invalid boundary \"XMAXYMAXZMAX(47)\": unable to compute normal");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, NamedBoundaryDescriptor("XMINYMAXZMAX")),
-                                "error: invalid boundary \"XMINYMAXZMAX\": unable to compute normal");
+                                "error: invalid boundary \"XMINYMAXZMAX(43)\": unable to compute normal");
           }
         }
       }
@@ -1196,7 +1196,7 @@ TEST_CASE("MeshFlatNodeBoundary", "[mesh]")
           {
             NumberedBoundaryDescriptor numbered_boundary_descriptor(3);
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, numbered_boundary_descriptor),
-                                "error: invalid boundary \"YMAX\": boundary is not flat!");
+                                "error: invalid boundary \"YMAX(3)\": boundary is not flat!");
           }
         }
 
@@ -1229,7 +1229,7 @@ TEST_CASE("MeshFlatNodeBoundary", "[mesh]")
           {
             NamedBoundaryDescriptor named_boundary_descriptor("YMAX");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, named_boundary_descriptor),
-                                "error: invalid boundary \"YMAX\": boundary is not flat!");
+                                "error: invalid boundary \"YMAX(3)\": boundary is not flat!");
           }
         }
       }
@@ -1304,13 +1304,13 @@ TEST_CASE("MeshFlatNodeBoundary", "[mesh]")
           {
             NumberedBoundaryDescriptor numbered_boundary_descriptor(3);
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, numbered_boundary_descriptor),
-                                "error: invalid boundary \"YMAX\": boundary is not flat!");
+                                "error: invalid boundary \"YMAX(3)\": boundary is not flat!");
           }
 
           {
             NumberedBoundaryDescriptor numbered_boundary_descriptor(5);
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, numbered_boundary_descriptor),
-                                "error: invalid boundary \"ZMAX\": boundary is not flat!");
+                                "error: invalid boundary \"ZMAX(5)\": boundary is not flat!");
           }
         }
 
@@ -1345,13 +1345,13 @@ TEST_CASE("MeshFlatNodeBoundary", "[mesh]")
           {
             NamedBoundaryDescriptor named_boundary_descriptor("YMAX");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, named_boundary_descriptor),
-                                "error: invalid boundary \"YMAX\": boundary is not flat!");
+                                "error: invalid boundary \"YMAX(3)\": boundary is not flat!");
           }
 
           {
             NamedBoundaryDescriptor named_boundary_descriptor("ZMAX");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, named_boundary_descriptor),
-                                "error: invalid boundary \"ZMAX\": boundary is not flat!");
+                                "error: invalid boundary \"ZMAX(5)\": boundary is not flat!");
           }
         }
       }
@@ -1415,13 +1415,13 @@ TEST_CASE("MeshFlatNodeBoundary", "[mesh]")
           {
             NumberedBoundaryDescriptor numbered_boundary_descriptor(24);
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, numbered_boundary_descriptor),
-                                "error: invalid boundary \"ZMAX\": boundary is not flat!");
+                                "error: invalid boundary \"ZMAX(24)\": boundary is not flat!");
           }
 
           {
             NumberedBoundaryDescriptor numbered_boundary_descriptor(26);
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, numbered_boundary_descriptor),
-                                "error: invalid boundary \"YMAX\": boundary is not flat!");
+                                "error: invalid boundary \"YMAX(26)\": boundary is not flat!");
           }
         }
 
@@ -1456,13 +1456,13 @@ TEST_CASE("MeshFlatNodeBoundary", "[mesh]")
           {
             NamedBoundaryDescriptor named_boundary_descriptor("YMAX");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, named_boundary_descriptor),
-                                "error: invalid boundary \"YMAX\": boundary is not flat!");
+                                "error: invalid boundary \"YMAX(26)\": boundary is not flat!");
           }
 
           {
             NamedBoundaryDescriptor named_boundary_descriptor("ZMAX");
             REQUIRE_THROWS_WITH(getMeshFlatNodeBoundary(mesh, named_boundary_descriptor),
-                                "error: invalid boundary \"ZMAX\": boundary is not flat!");
+                                "error: invalid boundary \"ZMAX(24)\": boundary is not flat!");
           }
         }
       }
diff --git a/tests/test_MeshLineFaceBoundary.cpp b/tests/test_MeshLineFaceBoundary.cpp
index a41b9e80ac2308955cca4e71c0d6b0af2e23d60a..f5cb9eb18714f668d63a0a4c2fd40a04b7cbeee9 100644
--- a/tests/test_MeshLineFaceBoundary.cpp
+++ b/tests/test_MeshLineFaceBoundary.cpp
@@ -494,7 +494,7 @@ TEST_CASE("MeshLineFaceBoundary", "[mesh]")
           {
             NumberedBoundaryDescriptor numbered_boundary_descriptor(3);
             REQUIRE_THROWS_WITH(getMeshLineFaceBoundary(mesh, numbered_boundary_descriptor),
-                                "error: invalid boundary \"YMAX\": boundary is not a line!");
+                                "error: invalid boundary \"YMAX(3)\": boundary is not a line!");
           }
         }
 
@@ -527,7 +527,7 @@ TEST_CASE("MeshLineFaceBoundary", "[mesh]")
           {
             NamedBoundaryDescriptor named_boundary_descriptor("YMAX");
             REQUIRE_THROWS_WITH(getMeshLineFaceBoundary(mesh, named_boundary_descriptor),
-                                "error: invalid boundary \"YMAX\": boundary is not a line!");
+                                "error: invalid boundary \"YMAX(3)\": boundary is not a line!");
           }
         }
       }
diff --git a/tests/test_MeshLineNodeBoundary.cpp b/tests/test_MeshLineNodeBoundary.cpp
index af3bb4e66ecbbb6f107a2ee3a97a08f3917db2d0..36c151e2d4ddf14e21ad5defed6774a06cf6394e 100644
--- a/tests/test_MeshLineNodeBoundary.cpp
+++ b/tests/test_MeshLineNodeBoundary.cpp
@@ -101,13 +101,13 @@ TEST_CASE("MeshLineNodeBoundary", "[mesh]")
 
           {
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(10)),
-                                "error: invalid boundary \"XMINYMIN\": unable to compute direction");
+                                "error: invalid boundary \"XMINYMIN(10)\": unable to compute direction");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(11)),
-                                "error: invalid boundary \"XMAXYMIN\": unable to compute direction");
+                                "error: invalid boundary \"XMAXYMIN(11)\": unable to compute direction");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(12)),
-                                "error: invalid boundary \"XMAXYMAX\": unable to compute direction");
+                                "error: invalid boundary \"XMAXYMAX(12)\": unable to compute direction");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(13)),
-                                "error: invalid boundary \"XMINYMAX\": unable to compute direction");
+                                "error: invalid boundary \"XMINYMAX(13)\": unable to compute direction");
           }
         }
 
@@ -140,13 +140,13 @@ TEST_CASE("MeshLineNodeBoundary", "[mesh]")
 
           {
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("XMINYMIN")),
-                                "error: invalid boundary \"XMINYMIN\": unable to compute direction");
+                                "error: invalid boundary \"XMINYMIN(10)\": unable to compute direction");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("XMINYMAX")),
-                                "error: invalid boundary \"XMINYMAX\": unable to compute direction");
+                                "error: invalid boundary \"XMINYMAX(13)\": unable to compute direction");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("XMAXYMIN")),
-                                "error: invalid boundary \"XMAXYMIN\": unable to compute direction");
+                                "error: invalid boundary \"XMAXYMIN(11)\": unable to compute direction");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("XMAXYMAX")),
-                                "error: invalid boundary \"XMAXYMAX\": unable to compute direction");
+                                "error: invalid boundary \"XMAXYMAX(12)\": unable to compute direction");
           }
         }
       }
@@ -197,13 +197,13 @@ TEST_CASE("MeshLineNodeBoundary", "[mesh]")
 
           {
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(8)),
-                                "error: invalid boundary \"XMINYMIN\": unable to compute direction");
+                                "error: invalid boundary \"XMINYMIN(8)\": unable to compute direction");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(9)),
-                                "error: invalid boundary \"XMINYMAX\": unable to compute direction");
+                                "error: invalid boundary \"XMINYMAX(9)\": unable to compute direction");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(10)),
-                                "error: invalid boundary \"XMAXYMIN\": unable to compute direction");
+                                "error: invalid boundary \"XMAXYMIN(10)\": unable to compute direction");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(11)),
-                                "error: invalid boundary \"XMAXYMAX\": unable to compute direction");
+                                "error: invalid boundary \"XMAXYMAX(11)\": unable to compute direction");
           }
         }
 
@@ -237,13 +237,13 @@ TEST_CASE("MeshLineNodeBoundary", "[mesh]")
 
           {
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("XMINYMIN")),
-                                "error: invalid boundary \"XMINYMIN\": unable to compute direction");
+                                "error: invalid boundary \"XMINYMIN(8)\": unable to compute direction");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("XMINYMAX")),
-                                "error: invalid boundary \"XMINYMAX\": unable to compute direction");
+                                "error: invalid boundary \"XMINYMAX(9)\": unable to compute direction");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("XMAXYMIN")),
-                                "error: invalid boundary \"XMAXYMIN\": unable to compute direction");
+                                "error: invalid boundary \"XMAXYMIN(10)\": unable to compute direction");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("XMAXYMAX")),
-                                "error: invalid boundary \"XMAXYMAX\": unable to compute direction");
+                                "error: invalid boundary \"XMAXYMAX(11)\": unable to compute direction");
           }
         }
       }
@@ -308,34 +308,34 @@ TEST_CASE("MeshLineNodeBoundary", "[mesh]")
           }
 
           REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(0)),
-                              "error: invalid boundary \"XMIN\": boundary is not a line!");
+                              "error: invalid boundary \"XMIN(0)\": boundary is not a line!");
           REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(1)),
-                              "error: invalid boundary \"XMAX\": boundary is not a line!");
+                              "error: invalid boundary \"XMAX(1)\": boundary is not a line!");
           REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(2)),
-                              "error: invalid boundary \"YMIN\": boundary is not a line!");
+                              "error: invalid boundary \"YMIN(2)\": boundary is not a line!");
           REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(3)),
-                              "error: invalid boundary \"YMAX\": boundary is not a line!");
+                              "error: invalid boundary \"YMAX(3)\": boundary is not a line!");
           REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(4)),
-                              "error: invalid boundary \"ZMIN\": boundary is not a line!");
+                              "error: invalid boundary \"ZMIN(4)\": boundary is not a line!");
           REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(5)),
-                              "error: invalid boundary \"ZMAX\": boundary is not a line!");
+                              "error: invalid boundary \"ZMAX(5)\": boundary is not a line!");
 
           REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(10)),
-                              "error: invalid boundary \"XMINYMINZMIN\": unable to compute direction");
+                              "error: invalid boundary \"XMINYMINZMIN(10)\": unable to compute direction");
           REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(11)),
-                              "error: invalid boundary \"XMAXYMINZMIN\": unable to compute direction");
+                              "error: invalid boundary \"XMAXYMINZMIN(11)\": unable to compute direction");
           REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(12)),
-                              "error: invalid boundary \"XMAXYMAXZMIN\": unable to compute direction");
+                              "error: invalid boundary \"XMAXYMAXZMIN(12)\": unable to compute direction");
           REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(13)),
-                              "error: invalid boundary \"XMINYMAXZMIN\": unable to compute direction");
+                              "error: invalid boundary \"XMINYMAXZMIN(13)\": unable to compute direction");
           REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(14)),
-                              "error: invalid boundary \"XMINYMINZMAX\": unable to compute direction");
+                              "error: invalid boundary \"XMINYMINZMAX(14)\": unable to compute direction");
           REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(15)),
-                              "error: invalid boundary \"XMAXYMINZMAX\": unable to compute direction");
+                              "error: invalid boundary \"XMAXYMINZMAX(15)\": unable to compute direction");
           REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(16)),
-                              "error: invalid boundary \"XMAXYMAXZMAX\": unable to compute direction");
+                              "error: invalid boundary \"XMAXYMAXZMAX(16)\": unable to compute direction");
           REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(17)),
-                              "error: invalid boundary \"XMINYMAXZMAX\": unable to compute direction");
+                              "error: invalid boundary \"XMINYMAXZMAX(17)\": unable to compute direction");
         }
 
         {
@@ -368,34 +368,34 @@ TEST_CASE("MeshLineNodeBoundary", "[mesh]")
 
           {
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("XMIN")),
-                                "error: invalid boundary \"XMIN\": boundary is not a line!");
+                                "error: invalid boundary \"XMIN(0)\": boundary is not a line!");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("XMAX")),
-                                "error: invalid boundary \"XMAX\": boundary is not a line!");
+                                "error: invalid boundary \"XMAX(1)\": boundary is not a line!");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("YMIN")),
-                                "error: invalid boundary \"YMIN\": boundary is not a line!");
+                                "error: invalid boundary \"YMIN(2)\": boundary is not a line!");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("YMAX")),
-                                "error: invalid boundary \"YMAX\": boundary is not a line!");
+                                "error: invalid boundary \"YMAX(3)\": boundary is not a line!");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("ZMIN")),
-                                "error: invalid boundary \"ZMIN\": boundary is not a line!");
+                                "error: invalid boundary \"ZMIN(4)\": boundary is not a line!");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("ZMAX")),
-                                "error: invalid boundary \"ZMAX\": boundary is not a line!");
+                                "error: invalid boundary \"ZMAX(5)\": boundary is not a line!");
 
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("XMINYMINZMIN")),
-                                "error: invalid boundary \"XMINYMINZMIN\": unable to compute direction");
+                                "error: invalid boundary \"XMINYMINZMIN(10)\": unable to compute direction");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("XMAXYMINZMIN")),
-                                "error: invalid boundary \"XMAXYMINZMIN\": unable to compute direction");
+                                "error: invalid boundary \"XMAXYMINZMIN(11)\": unable to compute direction");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("XMAXYMAXZMIN")),
-                                "error: invalid boundary \"XMAXYMAXZMIN\": unable to compute direction");
+                                "error: invalid boundary \"XMAXYMAXZMIN(12)\": unable to compute direction");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("XMINYMAXZMIN")),
-                                "error: invalid boundary \"XMINYMAXZMIN\": unable to compute direction");
+                                "error: invalid boundary \"XMINYMAXZMIN(13)\": unable to compute direction");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("XMINYMINZMAX")),
-                                "error: invalid boundary \"XMINYMINZMAX\": unable to compute direction");
+                                "error: invalid boundary \"XMINYMINZMAX(14)\": unable to compute direction");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("XMAXYMINZMAX")),
-                                "error: invalid boundary \"XMAXYMINZMAX\": unable to compute direction");
+                                "error: invalid boundary \"XMAXYMINZMAX(15)\": unable to compute direction");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("XMAXYMAXZMAX")),
-                                "error: invalid boundary \"XMAXYMAXZMAX\": unable to compute direction");
+                                "error: invalid boundary \"XMAXYMAXZMAX(16)\": unable to compute direction");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("XMINYMAXZMAX")),
-                                "error: invalid boundary \"XMINYMAXZMAX\": unable to compute direction");
+                                "error: invalid boundary \"XMINYMAXZMAX(17)\": unable to compute direction");
           }
         }
       }
@@ -451,34 +451,34 @@ TEST_CASE("MeshLineNodeBoundary", "[mesh]")
 
           {
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(22)),
-                                "error: invalid boundary \"XMIN\": boundary is not a line!");
+                                "error: invalid boundary \"XMIN(22)\": boundary is not a line!");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(23)),
-                                "error: invalid boundary \"XMAX\": boundary is not a line!");
+                                "error: invalid boundary \"XMAX(23)\": boundary is not a line!");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(24)),
-                                "error: invalid boundary \"ZMAX\": boundary is not a line!");
+                                "error: invalid boundary \"ZMAX(24)\": boundary is not a line!");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(25)),
-                                "error: invalid boundary \"ZMIN\": boundary is not a line!");
+                                "error: invalid boundary \"ZMIN(25)\": boundary is not a line!");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(26)),
-                                "error: invalid boundary \"YMAX\": boundary is not a line!");
+                                "error: invalid boundary \"YMAX(26)\": boundary is not a line!");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(27)),
-                                "error: invalid boundary \"YMIN\": boundary is not a line!");
+                                "error: invalid boundary \"YMIN(27)\": boundary is not a line!");
 
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(40)),
-                                "error: invalid boundary \"XMINYMINZMIN\": unable to compute direction");
+                                "error: invalid boundary \"XMINYMINZMIN(40)\": unable to compute direction");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(41)),
-                                "error: invalid boundary \"XMAXYMINZMIN\": unable to compute direction");
+                                "error: invalid boundary \"XMAXYMINZMIN(41)\": unable to compute direction");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(42)),
-                                "error: invalid boundary \"XMINYMAXZMIN\": unable to compute direction");
+                                "error: invalid boundary \"XMINYMAXZMIN(42)\": unable to compute direction");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(43)),
-                                "error: invalid boundary \"XMINYMAXZMAX\": unable to compute direction");
+                                "error: invalid boundary \"XMINYMAXZMAX(43)\": unable to compute direction");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(44)),
-                                "error: invalid boundary \"XMINYMINZMAX\": unable to compute direction");
+                                "error: invalid boundary \"XMINYMINZMAX(44)\": unable to compute direction");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(45)),
-                                "error: invalid boundary \"XMAXYMINZMAX\": unable to compute direction");
+                                "error: invalid boundary \"XMAXYMINZMAX(45)\": unable to compute direction");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(47)),
-                                "error: invalid boundary \"XMAXYMAXZMAX\": unable to compute direction");
+                                "error: invalid boundary \"XMAXYMAXZMAX(47)\": unable to compute direction");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(51)),
-                                "error: invalid boundary \"XMAXYMAXZMIN\": unable to compute direction");
+                                "error: invalid boundary \"XMAXYMAXZMIN(51)\": unable to compute direction");
           }
         }
 
@@ -512,34 +512,34 @@ TEST_CASE("MeshLineNodeBoundary", "[mesh]")
 
           {
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("XMIN")),
-                                "error: invalid boundary \"XMIN\": boundary is not a line!");
+                                "error: invalid boundary \"XMIN(22)\": boundary is not a line!");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("XMAX")),
-                                "error: invalid boundary \"XMAX\": boundary is not a line!");
+                                "error: invalid boundary \"XMAX(23)\": boundary is not a line!");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("YMIN")),
-                                "error: invalid boundary \"YMIN\": boundary is not a line!");
+                                "error: invalid boundary \"YMIN(27)\": boundary is not a line!");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("YMAX")),
-                                "error: invalid boundary \"YMAX\": boundary is not a line!");
+                                "error: invalid boundary \"YMAX(26)\": boundary is not a line!");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("ZMIN")),
-                                "error: invalid boundary \"ZMIN\": boundary is not a line!");
+                                "error: invalid boundary \"ZMIN(25)\": boundary is not a line!");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("ZMAX")),
-                                "error: invalid boundary \"ZMAX\": boundary is not a line!");
+                                "error: invalid boundary \"ZMAX(24)\": boundary is not a line!");
 
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("XMINYMINZMIN")),
-                                "error: invalid boundary \"XMINYMINZMIN\": unable to compute direction");
+                                "error: invalid boundary \"XMINYMINZMIN(40)\": unable to compute direction");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("XMAXYMINZMIN")),
-                                "error: invalid boundary \"XMAXYMINZMIN\": unable to compute direction");
+                                "error: invalid boundary \"XMAXYMINZMIN(41)\": unable to compute direction");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("XMAXYMAXZMIN")),
-                                "error: invalid boundary \"XMAXYMAXZMIN\": unable to compute direction");
+                                "error: invalid boundary \"XMAXYMAXZMIN(51)\": unable to compute direction");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("XMINYMAXZMIN")),
-                                "error: invalid boundary \"XMINYMAXZMIN\": unable to compute direction");
+                                "error: invalid boundary \"XMINYMAXZMIN(42)\": unable to compute direction");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("XMINYMINZMAX")),
-                                "error: invalid boundary \"XMINYMINZMAX\": unable to compute direction");
+                                "error: invalid boundary \"XMINYMINZMAX(44)\": unable to compute direction");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("XMAXYMINZMAX")),
-                                "error: invalid boundary \"XMAXYMINZMAX\": unable to compute direction");
+                                "error: invalid boundary \"XMAXYMINZMAX(45)\": unable to compute direction");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("XMAXYMAXZMAX")),
-                                "error: invalid boundary \"XMAXYMAXZMAX\": unable to compute direction");
+                                "error: invalid boundary \"XMAXYMAXZMAX(47)\": unable to compute direction");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("XMINYMAXZMAX")),
-                                "error: invalid boundary \"XMINYMAXZMAX\": unable to compute direction");
+                                "error: invalid boundary \"XMINYMAXZMAX(43)\": unable to compute direction");
           }
         }
       }
@@ -982,7 +982,7 @@ TEST_CASE("MeshLineNodeBoundary", "[mesh]")
           {
             NumberedBoundaryDescriptor numbered_boundary_descriptor(3);
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, numbered_boundary_descriptor),
-                                "error: invalid boundary \"YMAX\": boundary is not a line!");
+                                "error: invalid boundary \"YMAX(3)\": boundary is not a line!");
           }
         }
 
@@ -1015,7 +1015,7 @@ TEST_CASE("MeshLineNodeBoundary", "[mesh]")
           {
             NamedBoundaryDescriptor named_boundary_descriptor("YMAX");
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, named_boundary_descriptor),
-                                "error: invalid boundary \"YMAX\": boundary is not a line!");
+                                "error: invalid boundary \"YMAX(3)\": boundary is not a line!");
           }
         }
       }
@@ -1091,13 +1091,13 @@ TEST_CASE("MeshLineNodeBoundary", "[mesh]")
 
           {
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(29)),
-                                "error: invalid boundary \"YMINZMAX\": boundary is not a line!");
+                                "error: invalid boundary \"YMINZMAX(29)\": boundary is not a line!");
 
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(30)),
-                                "error: invalid boundary \"YMAXZMAX\": boundary is not a line!");
+                                "error: invalid boundary \"YMAXZMAX(30)\": boundary is not a line!");
 
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(31)),
-                                "error: invalid boundary \"YMAXZMIN\": boundary is not a line!");
+                                "error: invalid boundary \"YMAXZMIN(31)\": boundary is not a line!");
           }
         }
 
@@ -1130,13 +1130,13 @@ TEST_CASE("MeshLineNodeBoundary", "[mesh]")
 
           {
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("YMAXZMAX")),
-                                "error: invalid boundary \"YMAXZMAX\": boundary is not a line!");
+                                "error: invalid boundary \"YMAXZMAX(30)\": boundary is not a line!");
 
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("YMINZMAX")),
-                                "error: invalid boundary \"YMINZMAX\": boundary is not a line!");
+                                "error: invalid boundary \"YMINZMAX(29)\": boundary is not a line!");
 
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("YMAXZMIN")),
-                                "error: invalid boundary \"YMAXZMIN\": boundary is not a line!");
+                                "error: invalid boundary \"YMAXZMIN(31)\": boundary is not a line!");
           }
         }
       }
@@ -1204,13 +1204,13 @@ TEST_CASE("MeshLineNodeBoundary", "[mesh]")
 
           {
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(37)),
-                                "error: invalid boundary \"YMINZMAX\": boundary is not a line!");
+                                "error: invalid boundary \"YMINZMAX(37)\": boundary is not a line!");
 
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(38)),
-                                "error: invalid boundary \"YMAXZMIN\": boundary is not a line!");
+                                "error: invalid boundary \"YMAXZMIN(38)\": boundary is not a line!");
 
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NumberedBoundaryDescriptor(39)),
-                                "error: invalid boundary \"YMAXZMAX\": boundary is not a line!");
+                                "error: invalid boundary \"YMAXZMAX(39)\": boundary is not a line!");
           }
         }
 
@@ -1243,13 +1243,13 @@ TEST_CASE("MeshLineNodeBoundary", "[mesh]")
 
           {
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("YMAXZMAX")),
-                                "error: invalid boundary \"YMAXZMAX\": boundary is not a line!");
+                                "error: invalid boundary \"YMAXZMAX(39)\": boundary is not a line!");
 
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("YMINZMAX")),
-                                "error: invalid boundary \"YMINZMAX\": boundary is not a line!");
+                                "error: invalid boundary \"YMINZMAX(37)\": boundary is not a line!");
 
             REQUIRE_THROWS_WITH(getMeshLineNodeBoundary(mesh, NamedBoundaryDescriptor("YMAXZMIN")),
-                                "error: invalid boundary \"YMAXZMIN\": boundary is not a line!");
+                                "error: invalid boundary \"YMAXZMIN(38)\": boundary is not a line!");
           }
         }
       }
diff --git a/tests/test_MeshNodeBoundary.cpp b/tests/test_MeshNodeBoundary.cpp
index ba36ad53f6860523e42f65c33143eb66bd8047bf..2639e6370f9681024f0dab87367468a1df2a5002 100644
--- a/tests/test_MeshNodeBoundary.cpp
+++ b/tests/test_MeshNodeBoundary.cpp
@@ -311,7 +311,7 @@ TEST_CASE("MeshNodeBoundary", "[mesh]")
         NamedBoundaryDescriptor named_boundary_descriptor("INTERFACE");
 
         REQUIRE_THROWS_WITH(getMeshNodeBoundary(mesh, named_boundary_descriptor),
-                            "error: invalid boundary \"INTERFACE\": inner nodes cannot be used to define mesh "
+                            "error: invalid boundary \"INTERFACE(3)\": inner nodes cannot be used to define mesh "
                             "boundaries");
       }
 
@@ -328,7 +328,7 @@ TEST_CASE("MeshNodeBoundary", "[mesh]")
         NamedBoundaryDescriptor named_boundary_descriptor("INTERFACE");
 
         REQUIRE_THROWS_WITH(getMeshNodeBoundary(mesh, named_boundary_descriptor),
-                            "error: invalid boundary \"INTERFACE\": inner edges cannot be used to define mesh "
+                            "error: invalid boundary \"INTERFACE(5)\": inner edges cannot be used to define mesh "
                             "boundaries");
       }
 
@@ -345,7 +345,7 @@ TEST_CASE("MeshNodeBoundary", "[mesh]")
         NamedBoundaryDescriptor named_boundary_descriptor("INTERFACE1");
 
         REQUIRE_THROWS_WITH(getMeshNodeBoundary(mesh, named_boundary_descriptor),
-                            "error: invalid boundary \"INTERFACE1\": inner faces cannot be used to define mesh "
+                            "error: invalid boundary \"INTERFACE1(55)\": inner faces cannot be used to define mesh "
                             "boundaries");
       }
     }