diff --git a/mesh_handle/competence_pack.hxx b/mesh_handle/competence_pack.hxx
index 258e93f66a..8c61c025ec 100644
--- a/mesh_handle/competence_pack.hxx
+++ b/mesh_handle/competence_pack.hxx
@@ -45,7 +45,12 @@ struct competence_pack
 };
 
 /** Predefined competence pack combining all caching competences. */
-using cache_competences = competence_pack<cache_volume, cache_vertex_coordinates, cache_centroid, cache_neighbors>;
+using all_cache_competences = competence_pack<cache_volume, cache_diameter, cache_vertex_coordinates, cache_centroid,
+                                              cache_face_area, cache_face_centroid, cache_face_normal, cache_neighbors>;
+
+/** Predefined competence pack combining all competences related to faces. */
+using cache_face_competences
+  = competence_pack<cache_face_area, cache_face_centroid, cache_face_normal, cache_neighbors>;
 
 }  // namespace t8_mesh_handle
 #endif /* !T8_COMPETENCE_PACK_HXX */
diff --git a/mesh_handle/competences.hxx b/mesh_handle/competences.hxx
index c265c53035..a7a2616912 100644
--- a/mesh_handle/competences.hxx
+++ b/mesh_handle/competences.hxx
@@ -71,6 +71,29 @@ struct cache_volume: public t8_crtp_operator<TUnderlying, cache_volume>
     m_volume; /**< Cache for the volume. Use optional to allow no value if cache is not filled. */
 };
 
+/**
+ * Competence to cache the diameter of an element at the first function call.
+ * \tparam TUnderlying Use the \ref element with specified competences as template parameter.
+ */
+template <typename TUnderlying>
+struct cache_diameter: public t8_crtp_operator<TUnderlying, cache_diameter>
+{
+ public:
+  /**
+   * Function that checks if the cache for the diameter has been filled.
+   * \return true if the cache has been filled, false otherwise.
+   */
+  bool
+  diameter_cache_filled () const
+  {
+    return m_diameter.has_value ();
+  }
+
+ protected:
+  mutable std::optional<double>
+    m_diameter; /**< Cache for the diameter. Use optional to allow no value if cache is not filled. */
+};
+
 /**
  * Competence to cache the vertex coordinates of an element at the first function call.
  * \tparam TUnderlying Use the \ref element with specified competences as template parameter.
@@ -117,12 +140,81 @@ struct cache_centroid: public t8_crtp_operator<TUnderlying, cache_centroid>
     m_centroid; /**< Cache for the coordinates of the centroid. Use optional to allow no value if cache is not filled. */
 };
 
+/**
+ * Competence to cache the area of a specific face at the first function call.
+ * \tparam TUnderlying Use the \ref element with specified competences as template parameter.
+ */
+template <typename TUnderlying>
+struct cache_face_area: t8_crtp_operator<TUnderlying, cache_face_area>
+{
+ public:
+  /**
+   * Function that checks if the cache for a face has been filled.
+   * \param [in] face The face for which the cache should be checked.
+   * \return true if the cache has been filled, false otherwise.
+   */
+  bool
+  face_area_cache_filled (int face) const
+  {
+    return m_face_area[face].has_value ();
+  }
+
+ protected:
+  mutable std::vector<std::optional<double>> m_face_area; /**< Vector with the face area each face. */
+};
+
+/**
+ * Competence to cache the centroid of a specific face at the first function call.
+ * \tparam TUnderlying Use the \ref element with specified competences as template parameter.
+ */
+template <typename TUnderlying>
+struct cache_face_centroid: t8_crtp_operator<TUnderlying, cache_face_centroid>
+{
+ public:
+  /**
+   * Function that checks if the cache for a face has been filled.
+   * \param [in] face The face for which the cache should be checked.
+   * \return true if the cache has been filled, false otherwise.
+   */
+  bool
+  face_centroid_cache_filled (int face) const
+  {
+    return m_face_centroid[face].has_value ();
+  }
+
+ protected:
+  mutable std::vector<std::optional<t8_3D_point>> m_face_centroid; /**< Vector with the face centroid each face. */
+};
+
+/**
+ * Competence to cache the normal of a specific face at the first function call.
+ * \tparam TUnderlying Use the \ref element with specified competences as template parameter.
+ */
+template <typename TUnderlying>
+struct cache_face_normal: t8_crtp_operator<TUnderlying, cache_face_normal>
+{
+ public:
+  /**
+   * Function that checks if the cache for a face has been filled.
+   * \param [in] face The face for which the cache should be checked.
+   * \return true if the cache has been filled, false otherwise.
+   */
+  bool
+  face_normal_cache_filled (int face) const
+  {
+    return m_face_normal[face].has_value ();
+  }
+
+ protected:
+  mutable std::vector<std::optional<t8_3D_vec>> m_face_normal; /**< Vector with the face normal each face. */
+};
+
 /**
  * Competence to cache the neighbors of an element at a specific face at the first function call.
  * \tparam TUnderlying Use the \ref element with specified competences as template parameter.
  */
 template <typename TUnderlying>
-struct cache_neighbors: t8_crtp_operator<TUnderlying, cache_centroid>
+struct cache_neighbors: t8_crtp_operator<TUnderlying, cache_neighbors>
 {
  public:
   /**
diff --git a/mesh_handle/constructor_wrapper.hxx b/mesh_handle/constructor_wrapper.hxx
new file mode 100644
index 0000000000..56d366a8f3
--- /dev/null
+++ b/mesh_handle/constructor_wrapper.hxx
@@ -0,0 +1,99 @@
+/*
+  This file is part of t8code.
+  t8code is a C library to manage a collection (a forest) of multiple
+  connected adaptive space-trees of general element classes in parallel.
+
+  Copyright (C) 2025 the developers
+
+  t8code is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2 of the License, or
+  (at your option) any later version.
+
+  t8code is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with t8code; if not, write to the Free Software Foundation, Inc.,
+  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*/
+
+/** \file constructor_wrapper.hxx
+ * Construct a mesh handle instance from a cmesh and some default mesh handles.
+ */
+
+#ifndef T8_CONSTRUCTOR_WRAPPER_HXX
+#define T8_CONSTRUCTOR_WRAPPER_HXX
+
+#include <t8.h>
+#include <t8_forest/t8_forest_general.h>
+#include <t8_cmesh/t8_cmesh.h>
+#include <t8_schemes/t8_default/t8_default.hxx>
+#include <t8_cmesh/t8_cmesh_examples.h>
+#include <memory>
+
+namespace t8_mesh_handle
+{
+
+/** Build a uniformly refined mesh handle on a coarse mesh using a default scheme.
+ * \param [in] cmesh         A coarse mesh.
+ * \param [in] level         An initial uniform refinement level.
+ * \param [in] comm          MPI communicator to use.
+ * \param [in] do_face_ghost If true, a layer of ghost elements is created.
+ * \tparam TMesh             The mesh handle class.
+ * \return Unique pointer to a uniformly refined mesh handle with coarse mesh \a cmesh and refinement level \a level.
+ */
+template <typename TMesh>
+std::unique_ptr<TMesh>
+handle_new_uniform_default (const t8_cmesh_t cmesh, const int level, const sc_MPI_Comm comm,
+                            const bool do_face_ghost = false)
+{
+  const t8_scheme *scheme = t8_scheme_new_default ();
+  t8_forest_t forest = t8_forest_new_uniform (cmesh, scheme, level, do_face_ghost, sc_MPI_COMM_WORLD);
+  return std::make_unique<TMesh> (forest);
+}
+
+/** Hybercube with 6 Tets, 6 Prism, 4 Hex. Refined uniformly to given level using the default scheme.
+ * \param [in] level         An initial uniform refinement level.
+ * \param [in] comm          MPI communicator to use.
+ * \param [in] do_partition  If non-zero create a partitioned cmesh.
+ * \param [in] do_face_ghost If true, a layer of ghost elements is created.
+ * \param [in] periodic      If non-zero create a periodic cmesh in each direction.
+ * \tparam TMesh             The mesh handle class.
+ * \return Unique pointer to a uniformly refined mesh handle initially consisting of 6 Tets, 6 prism and 4 hex.
+ *         Together, they form a cube.
+*/
+template <typename TMesh>
+std::unique_ptr<TMesh>
+handle_hybrid_hypercube_uniform_default (const int level, const sc_MPI_Comm comm, const bool do_partition = false,
+                                         const bool do_face_ghost = false, const bool periodic = false)
+{
+  t8_cmesh_t cmesh = t8_cmesh_new_hypercube_hybrid (comm, do_partition, periodic);
+  return handle_new_uniform_default<TMesh> (cmesh, level, comm, do_face_ghost);
+}
+
+/** Construct hybercube from one primitive tree class. Refined uniformly to given level using the default scheme.
+ * \param [in] eclass        This element class determines the dimension and the number of trees needed to construct a cube.
+ * \param [in] level         An initial uniform refinement level.
+ * \param [in] comm          MPI communicator to use.
+ * \param [in] do_partition  If non-zero create a partitioned cmesh.
+ * \param [in] do_face_ghost If true, a layer of ghost elements is created.
+ * \param [in] periodic      If non-zero create a periodic cmesh in each direction. Not possible with \a eclass pyramid.
+ * \tparam TMesh             The mesh handle class.
+ * \return Unique pointer to a uniformly refined mesh handle hypercube.
+*/
+template <typename TMesh>
+std::unique_ptr<TMesh>
+handle_hypercube_uniform_default (t8_eclass_t eclass, const int level, const sc_MPI_Comm comm,
+                                  const bool do_partition = false, const bool do_face_ghost = false,
+                                  const bool periodic = false)
+{
+  // Broadcast option is hidden from the user.
+  t8_cmesh_t cmesh = t8_cmesh_new_hypercube (eclass, comm, 0, do_partition, periodic);
+  return handle_new_uniform_default<TMesh> (cmesh, level, comm, do_face_ghost);
+}
+
+}  // namespace t8_mesh_handle
+#endif /* !T8_CONSTRUCTOR_WRAPPER_HXX */
diff --git a/mesh_handle/element.hxx b/mesh_handle/element.hxx
index cb74480d3e..8f627457f3 100644
--- a/mesh_handle/element.hxx
+++ b/mesh_handle/element.hxx
@@ -21,7 +21,7 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 */
 
 /** \file element.hxx
- * Definition of the element class of the \ref t8_mesh_handle::mesh handle (can be ghost or mesh elements).
+ *  Definition of the element class of the \ref t8_mesh_handle::mesh handle (can be ghost or mesh elements).
  */
 
 #ifndef T8_ELEMENT_HXX
@@ -64,9 +64,8 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
     = element<mesh_class, TCompetence...>; /**< Type of the current class with all template parameters specified. */
   friend mesh_class; /**< Define mesh_class as friend to be able to access e.g. the constructor. */
 
-  /**
-   * Private constructor for an element of a mesh. This could be a simple mesh element or a ghost element.
-   * This constructor should only be called by the mesh_class (and invisible for the user).
+  /** Private constructor for an element of a mesh. This could be a simple mesh element or a ghost element.
+   *  This constructor should only be called by the mesh_class (and invisible for the user).
    * \param [in] mesh             Pointer to the mesh the element should belong to.
    * \param [in] tree_id          The tree id of the element in the forest defining the mesh.
    * \param [in] element_id       The element id of the element in the forest defining the mesh.
@@ -75,6 +74,7 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
   element (mesh_class* mesh, t8_locidx_t tree_id, t8_locidx_t element_id, bool is_ghost_element = false)
     : m_mesh (mesh), m_tree_id (tree_id), m_element_id (element_id), m_is_ghost_element (is_ghost_element)
   {
+    // Cache the t8_element_t from the forest as it is often used.
     if (m_is_ghost_element) {
       // The local ghost tree id is per definition the local tree id - number of local (non-ghost) trees.
       m_element = t8_forest_ghost_get_leaf_element (
@@ -84,136 +84,141 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
       m_element = t8_forest_get_leaf_element_in_tree (m_mesh->m_forest, m_tree_id, m_element_id);
     }
 
+    // Resize caches for clean access where the cache vector may not be filled completely at once.
     if constexpr (has_face_neighbor_cache ()) {
-      // Resize neighbor caches for clean access to the caches.
-      const int num_faces = this->get_num_faces ();
+      const int num_faces = get_num_faces ();
       this->m_num_neighbors.resize (num_faces);
       this->m_dual_faces.resize (num_faces);
       this->m_neighbors.resize (num_faces);
     }
+    if constexpr (has_face_area_cache ()) {
+      const int num_faces = get_num_faces ();
+      this->m_face_area.resize (num_faces);
+    }
+    if constexpr (has_face_centroid_cache ()) {
+      const int num_faces = get_num_faces ();
+      this->m_face_centroid.resize (num_faces);
+    }
+    if constexpr (has_face_normal_cache ()) {
+      const int num_faces = get_num_faces ();
+      this->m_face_normal.resize (num_faces);
+    }
   }
 
-  // --- Variables to check which functionality is defined in TCompetence. ---
-  /** Helper function to check if class T implements the function volume_cache_filled.
-   * \tparam T The competence to be checked.
-   * \return true if T implements the function, false if not.
+ public:
+  // --- Public functions to check if caches exist. ---
+  /** Function that checks if a cache for the element's volume exists.
+   * \return true if a cache exists, false otherwise.
    */
-  template <template <typename> class T>
   static constexpr bool
-  volume_cache_defined ()
+  has_volume_cache ()
   {
-    return requires (T<SelfType>& competence) { competence.volume_cache_filled (); };
+    return (false || ... || volume_cache_defined<TCompetence> ());
   }
-  /** Helper function to check if class T implements the function vertex_cache_filled.
-   * \tparam T The competence to be checked.
-   * \return true if T implements the function, false if not.
+  /** Function that checks if a cache for the element's diameter exists.
+   * \return true if a cache exists, false otherwise.
    */
-  template <template <typename> class T>
   static constexpr bool
-  vertex_cache_defined ()
+  has_diameter_cache ()
   {
-    return requires (T<SelfType>& competence) { competence.vertex_cache_filled (); };
+    return (false || ... || diameter_cache_defined<TCompetence> ());
   }
-  /** Helper function to check if class T implements the function centroid_cache_filled.
-   * \tparam T The competence to be checked.
-   * \return true if T implements the function, false if not.
+  /** Function that checks if a cache for the vertex coordinates exists.
+   * \return true if a cache for the vertex coordinates exists, false otherwise.
    */
-  template <template <typename> class T>
   static constexpr bool
-  centroid_cache_defined ()
+  has_vertex_cache ()
   {
-    return requires (T<SelfType>& competence) { competence.centroid_cache_filled (); };
+    return (false || ... || vertex_cache_defined<TCompetence> ());
   }
-  /** Helper function to check if class T implements the function neighbor_cache_filled.
-   * \tparam T The competence to be checked.
-   * \return true if T implements the function, false if not.
+
+  /** Function that checks if a cache for the centroid exists.
+   * \return true if a cache for the centroid exists, false otherwise.
    */
-  template <template <typename> class T>
   static constexpr bool
-  neighbor_cache_defined ()
+  has_centroid_cache ()
   {
-    return requires (T<SelfType>& competence) { competence.neighbor_cache_filled (0); };
+    return (false || ... || centroid_cache_defined<TCompetence> ());
   }
 
- public:
-  // --- Public functions to check if caches exist. ---
-  /**
-   * Function that checks if a cache for the element's volume exists.
+  /** Function that checks if a cache for the face neighbors exists.
    * \return true if a cache exists, false otherwise.
    */
   static constexpr bool
-  has_volume_cache ()
+  has_face_neighbor_cache ()
   {
-    return (false || ... || volume_cache_defined<TCompetence> ());
+    return (false || ... || neighbor_cache_defined<TCompetence> ());
   }
-  /**
-   * Function that checks if a cache for the vertex coordinates exists.
-   * \return true if a cache for the vertex coordinates exists, false otherwise.
+  /** Function that checks if a cache for the element's face area exists.
+   * \return true if a cache exists, false otherwise.
    */
   static constexpr bool
-  has_vertex_cache ()
+  has_face_area_cache ()
   {
-    return (false || ... || vertex_cache_defined<TCompetence> ());
+    return (false || ... || face_area_cache_defined<TCompetence> ());
   }
 
-  /**
-   * Function that checks if a cache for the centroid exists.
-   * \return true if a cache for the centroid exists, false otherwise.
+  /** Function that checks if a cache for the element's face centroid exists.
+   * \return true if a cache exists, false otherwise.
    */
   static constexpr bool
-  has_centroid_cache ()
+  has_face_centroid_cache ()
   {
-    return (false || ... || centroid_cache_defined<TCompetence> ());
+    return (false || ... || face_centroid_cache_defined<TCompetence> ());
   }
 
-  /**
-   * Function that checks if a cache for the face neighbors exists.
+  /** Function that checks if a cache for the element's face normal exists.
    * \return true if a cache exists, false otherwise.
    */
   static constexpr bool
-  has_face_neighbor_cache ()
+  has_face_normal_cache ()
   {
-    return (false || ... || neighbor_cache_defined<TCompetence> ());
+    return (false || ... || face_normal_cache_defined<TCompetence> ());
   }
 
   // --- Functionality of the element. In each function, it is checked if a cached version exists (and is used then). ---
-  /**
-   * Getter for the refinement level of the element.
-   * For this easily accessible variable, it makes no sense to provide a cached version.
+  /** Getter for the refinement level of the element.
+   *  For this easily accessible variable, it makes no sense to provide a cached version.
    * \return Refinement level of the element.
    */
   t8_element_level
   get_level () const
   {
-    const t8_eclass_t eclass = get_tree_class ();
-    const t8_element_t* element = get_element ();
-    return t8_forest_get_scheme (m_mesh->m_forest)->element_get_level (eclass, element);
+    return t8_forest_get_scheme (m_mesh->m_forest)->element_get_level (get_tree_class (), m_element);
   }
 
-  /**
-   * Getter for the number of faces of the element.
-   * For this easily accessible variable, it makes no sense to provide a cached version.
+  /** Getter for the number of faces of the element.
+   *  For this easily accessible variable, it makes no sense to provide a cached version.
    * \return Number of faces of the element.
    */
   int
   get_num_faces () const
   {
-    return t8_forest_get_scheme (m_mesh->m_forest)->element_get_num_faces (get_tree_class (), get_element ());
+    return t8_forest_get_scheme (m_mesh->m_forest)->element_get_num_faces (get_tree_class (), m_element);
   }
 
-  /**
-   * Getter for the element's shape.
-   * For this easily accessible variable, it makes no sense to provide a cached version.
+  /** Getter for the number of vertices of the element.
+   *  For this easily accessible variable, it makes no sense to provide a cached version.
+   * \return Number of vertices of the element.
+   */
+  int
+  get_num_vertices () const
+  {
+    return t8_forest_get_scheme (m_mesh->m_forest)->element_get_num_corners (get_tree_class (), m_element);
+  }
+
+  /** Getter for the element's shape.
+   *  For this easily accessible variable, it makes no sense to provide a cached version.
    * \return The shape of the element.
    */
   t8_element_shape_t
   get_shape () const
   {
-    return t8_forest_get_scheme (m_mesh->m_forest)->element_get_shape (get_tree_class (), get_element ());
+    return t8_forest_get_scheme (m_mesh->m_forest)->element_get_shape (get_tree_class (), m_element);
   }
 
-  /**
-   * Getter for the element's volume.
+  /** Getter for the element's volume.
+   *  This is only an approximation.
    *  This function uses or sets the cached version defined in TCompetence if available and calculates if not.
    * \return The volume of the element.
    */
@@ -221,37 +226,51 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
   get_volume () const
   {
     if constexpr (has_volume_cache ()) {
-      if (this->volume_cache_filled ()) {
-        return this->m_volume.value ();
+      if (!this->volume_cache_filled ()) {
+        // Fill cache.
+        this->m_volume = t8_forest_element_volume (m_mesh->m_forest, m_tree_id, m_element);
       }
-      // Fill cache.
-      this->m_volume = t8_forest_element_volume (m_mesh->m_forest, m_tree_id, get_element ());
       return this->m_volume.value ();
     }
-    return t8_forest_element_volume (m_mesh->m_forest, m_tree_id, get_element ());
+    return t8_forest_element_volume (m_mesh->m_forest, m_tree_id, m_element);
   }
 
-  /**
-   * Getter for the vertex coordinates of the element.
-   * This function uses or sets the cached version defined in TCompetence if available and calculates if not.
+  /** Getter for the element's diameter.
+   *  This is only an approximation.
+   *  This function uses or sets the cached version defined in TCompetence if available and calculates if not.
+   * \return The diameter of the element.
+   */
+  double
+  get_diameter () const
+  {
+    if constexpr (has_diameter_cache ()) {
+      if (!this->diameter_cache_filled ()) {
+        // Fill cache.
+        this->m_diameter = t8_forest_element_diam (m_mesh->m_forest, m_tree_id, m_element);
+      }
+      return this->m_diameter.value ();
+    }
+    return t8_forest_element_diam (m_mesh->m_forest, m_tree_id, m_element);
+  }
+
+  /** Getter for the vertex coordinates of the element.
+   *  This function uses or sets the cached version defined in TCompetence if available and calculates if not.
    * \return Vector with one coordinate array for each vertex of the element.
    */
   std::vector<t8_3D_point>
   get_vertex_coordinates () const
   {
-    // Check if we have a cached version and if the cache has already been filled.
     if constexpr (has_vertex_cache ()) {
       if (this->vertex_cache_filled ()) {
         return this->m_vertex_coordinates;
       }
     }
     // Calculate the vertex coordinates.
-    const t8_element_t* element = get_element ();
-    const int num_corners
-      = t8_forest_get_scheme (m_mesh->m_forest)->element_get_num_corners (get_tree_class (), element);
+    const int num_corners = get_num_vertices ();
     std::vector<t8_3D_point> vertex_coordinates (num_corners);
     for (int icorner = 0; icorner < num_corners; ++icorner) {
-      t8_forest_element_coordinate (m_mesh->m_forest, m_tree_id, element, icorner, vertex_coordinates[icorner].data ());
+      t8_forest_element_coordinate (m_mesh->m_forest, m_tree_id, m_element, icorner,
+                                    vertex_coordinates[icorner].data ());
     }
     // Fill the cache in the cached version.
     if constexpr (has_vertex_cache ()) {
@@ -261,8 +280,29 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
     return vertex_coordinates;
   }
 
-  /**
-   * Getter for the center of mass of the element.
+  /** Getter for the coordinates of one specific vertex of the element.
+   *  This function uses or sets the cached version defined in TCompetence if available and calculates if not.
+   *  The cache is filled for all vertices simultaneously.
+   * \param [in] vertex Index of the vertex.
+   * \return Coordinates of the vertex.
+   */
+  t8_3D_point
+  get_vertex_coordinates (int vertex) const
+  {
+    T8_ASSERT (vertex < get_num_vertices ());
+    // Check if we have a cached version and if the cache has already been filled.
+    if constexpr (has_vertex_cache ()) {
+      if (!this->vertex_cache_filled ()) {
+        get_vertex_coordinates ();
+      }
+      return this->m_vertex_coordinates[vertex];
+    }
+    t8_3D_point coordinates;
+    t8_forest_element_coordinate (m_mesh->m_forest, m_tree_id, m_element, vertex, coordinates.data ());
+    return coordinates;
+  }
+
+  /** Getter for the center of mass of the element.
    * This function uses the cached version defined in TCompetence if available and calculates if not.
    * \return Coordinates of the center.
    */
@@ -276,7 +316,7 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
       }
     }
     t8_3D_point coordinates;
-    t8_forest_element_centroid (m_mesh->m_forest, m_tree_id, get_element (), coordinates.data ());
+    t8_forest_element_centroid (m_mesh->m_forest, m_tree_id, m_element, coordinates.data ());
     // Fill the cache in the cached version.
     if constexpr (has_centroid_cache ()) {
       this->m_centroid = coordinates;
@@ -293,6 +333,7 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
   std::vector<const SelfType*>
   get_face_neighbors (int face, std::optional<std::reference_wrapper<std::vector<int>>> dual_faces = std::nullopt) const
   {
+    T8_ASSERT (face < get_num_faces ());
     SC_CHECK_ABORT (!m_is_ghost_element, "get_face_neighbors is not implemented for ghost elements.\n");
     if constexpr (has_face_neighbor_cache ()) {
       if (this->neighbor_cache_filled (face)) {
@@ -302,14 +343,14 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
         return this->m_neighbors[face];
       }
     }
-    std::vector<std::reference_wrapper<SelfType>> neighbor_elements;
+
     t8_element_t** neighbors; /**< Neighboring elements. */
     int* dual_faces_internal; /**< Face indices of the neighbor elements. */
     int num_neighbors;        /**< Number of neighboring elements. */
     t8_locidx_t* neighids;    /**< Neighboring elements ids. */
     t8_eclass_t neigh_class;  /**< Neighboring elements tree class. */
 
-    t8_forest_leaf_face_neighbors (m_mesh->m_forest, m_tree_id, get_element (), &neighbors, face, &dual_faces_internal,
+    t8_forest_leaf_face_neighbors (m_mesh->m_forest, m_tree_id, m_element, &neighbors, face, &dual_faces_internal,
                                    &num_neighbors, &neighids, &neigh_class, t8_forest_is_balanced (m_mesh->m_forest));
     if (dual_faces) {
       dual_faces->get ().assign (dual_faces_internal, dual_faces_internal + num_neighbors);
@@ -337,8 +378,7 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
     return neighbors_handle;
   }
 
-  /**
-   * Function to fill the face neighbor cache for all faces of the mesh element.
+  /** Function to fill the face neighbor cache for all faces of the mesh element.
    */
   void
   fill_face_neighbor_cache () const
@@ -349,9 +389,97 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
     }
   }
 
+  // --- Getter for face properties. ---
+  /** The area of a face of the element.
+   *  This is only an approximation.
+   *  This function uses the cached version defined in TCompetence if available and calculates if not.
+   * \param [in] face Index of a face of the element.
+   * \return The area of \a face.
+   */
+  double
+  get_face_area (int face) const
+  {
+    T8_ASSERT (face < get_num_faces ());
+    if constexpr (has_face_area_cache ()) {
+      if (!this->face_area_cache_filled (face)) {
+        this->m_face_area[face] = t8_forest_element_face_area (m_mesh->m_forest, m_tree_id, m_element, face);
+      }
+      return this->m_face_area[face].value ();
+    }
+    return t8_forest_element_face_area (m_mesh->m_forest, m_tree_id, m_element, face);
+  }
+
+  /** The centroid of a face of the element.
+   *  This function uses the cached version defined in TCompetence if available and calculates if not.
+   * \param [in] face Index of a face of the element.
+   * \return The centroid of \a face.
+   */
+  t8_3D_point
+  get_face_centroid (int face) const
+  {
+    T8_ASSERT (face < get_num_faces ());
+    if constexpr (has_face_centroid_cache ()) {
+      if (this->face_centroid_cache_filled (face)) {
+        return this->m_face_centroid[face].value ();
+      }
+    }
+    t8_3D_point coordinates;
+    t8_forest_element_face_centroid (m_mesh->m_forest, m_tree_id, m_element, face, coordinates.data ());
+    if constexpr (has_face_centroid_cache ()) {
+      this->m_face_centroid[face] = coordinates;
+    }
+    return coordinates;
+  }
+
+  /** The normal vector of a face of the element.
+   *  This function uses the cached version defined in TCompetence if available and calculates if not.
+   * \param [in] face Index of a face of the element.
+   * \return The normal vector of \a face.
+   */
+  t8_3D_vec
+  get_face_normal (int face) const
+  {
+    T8_ASSERT (face < get_num_faces ());
+    if constexpr (has_face_normal_cache ()) {
+      if (this->face_normal_cache_filled (face)) {
+        return this->m_face_normal[face].value ();
+      }
+    }
+    t8_3D_vec normal;
+    t8_forest_element_face_normal (m_mesh->m_forest, m_tree_id, m_element, face, normal.data ());
+    if constexpr (has_face_normal_cache ()) {
+      this->m_face_normal[face] = normal;
+    }
+    return normal;
+  }
+
+  /** Getter for the element's face shape.
+   *  For this easily accessible variable, it makes no sense to provide a cached version.
+   * \param [in] face Index of a face of the element.
+   * \return The shape of the face of the element.
+   */
+  t8_element_shape_t
+  get_face_shape (int face) const
+  {
+    T8_ASSERT (face < get_num_faces ());
+    return t8_forest_get_scheme (m_mesh->m_forest)->element_get_face_shape (get_tree_class (), m_element, face);
+  }
+
+  // --- Print for the element for debugging purpose. ---
+#if T8_ENABLE_DEBUG
+  /** Print the element. 
+   *  For example, print the coordinates and level of a triangle.  
+   *  This function is only available in the debugging configuration.
+   */
+  void
+  print_element_debug () const
+  {
+    t8_forest_get_scheme (m_mesh->m_forest)->element_debug_print (get_tree_class (), m_element);
+  }
+#endif
+
   // --- Function to access mesh specific id. ---
-  /**
-   * Getter for the index of the element in the mesh to which the element belongs.
+  /** Getter for the index of the element in the mesh to which the element belongs.
    * \return The local element id of the element in the mesh.
    */
   t8_locidx_t
@@ -367,10 +495,9 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
   }
 
   //--- Getter for the member variables. ---
-  /**
-   * Getter for the tree id of the element in the forest related to the mesh.
-   * \warning This is related to t8code's tree structure and should not be confused with \ref mesh specific ids.
-   * This function is mainly relevant for writing custom competences that need to access t8code functionality.
+  /** Getter for the tree id of the element in the forest related to the mesh.
+   *  \warning This is related to t8code's tree structure and should not be confused with \ref mesh specific ids.
+   *  This function is mainly relevant for writing custom competences that need to access t8code functionality.
    * \return The element's local tree id in the forest.
    */
   t8_locidx_t
@@ -379,11 +506,10 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
     return m_tree_id;
   }
 
-  /**
-   * Getter for the local element id in the tree of the element in the forest related to the mesh.
-   * \warning This is related to t8code's tree structure and should not be confused with \ref mesh specific ids.
-   * For mesh specific id use \ref get_element_handle_id. 
-   * This function is mainly relevant for writing custom competences that need to access t8code functionality.
+  /** Getter for the local element id in the tree of the element in the forest related to the mesh.
+   *  \warning This is related to t8code's tree structure and should not be confused with \ref mesh specific ids.
+   *  For mesh specific id use \ref get_element_handle_id. 
+   *  This function is mainly relevant for writing custom competences that need to access t8code functionality.
    * \return The local element id in the tree of the element in the forest.
    */
   t8_locidx_t
@@ -392,8 +518,7 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
     return m_element_id;
   }
 
-  /**
-   * Getter for the mesh to which the element belongs.
+  /** Getter for the mesh to which the element belongs.
    * \return Reference to the mesh.
    */
   const mesh_class*
@@ -402,8 +527,7 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
     return m_mesh;
   }
 
-  /**
-   * Function to check if the element is a ghost element.
+  /** Function to check if the element is a ghost element.
    * \return true if the element is a ghost element, false otherwise.
    */
   bool
@@ -414,8 +538,8 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
 
   // --- Getter and setter for element data. ---
   /** Getter for the element data.
-   * For ghost elements ensure that \ref mesh::exchange_ghost_data is called on each process first.
-   * Element data for non-ghost elements can be accessed (if set) directly.
+   *  For ghost elements ensure that \ref mesh::exchange_ghost_data is called on each process first.
+   *  Element data for non-ghost elements can be accessed (if set) directly.
    * \return Element data with data of Type mesh_class::ElementDataType.
    */
   template <typename E = typename mesh_class::ElementDataType, typename = std::enable_if_t<!std::is_void<E>::value>>
@@ -425,9 +549,8 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
     return m_mesh->m_element_data[get_element_handle_id ()];
   }
 
-  /** 
-   * Set the element data for the element. 
-   * \note You can only set element data for non-ghost elements.
+  /** Set the element data for the element. 
+   *  \note You can only set element data for non-ghost elements.
    * \param [in] element_data The element data to be set.
    */
   template <typename E = typename mesh_class::ElementDataType, typename = std::enable_if_t<!std::is_void<E>::value>>
@@ -441,19 +564,15 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
   }
 
  private:
-  //--- Private getter for internal use. ---
-  /**
-   * Getter for the leaf element of the element.
-   * \return The leaf element.
-   */
-  const t8_element_t*
-  get_element () const
-  {
-    return m_element;
-  }
+  // --- Private member variables. ---
+  mesh_class* m_mesh;             /**< Pointer to the mesh the element is defined for. */
+  const t8_locidx_t m_tree_id;    /**< The tree id of the element in the forest defined in the mesh. */
+  const t8_locidx_t m_element_id; /**< The element id of the element in the forest defined in the mesh. */
+  const bool m_is_ghost_element;  /**< Flag to indicate if the element is a ghost element. */
+  const t8_element_t* m_element;  /**< Cache the pointer to element in the forest as this is often needed. */
 
-  /**
-   * Getter for the eclass of the tree of the element.
+  // --- Private helper function. ---
+  /** Getter for the eclass of the tree of the element.
    * \return The eclass of the element's tree.
    */
   t8_eclass_t
@@ -462,11 +581,87 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
     return t8_forest_get_tree_class (m_mesh->m_forest, m_tree_id);
   }
 
-  mesh_class* m_mesh;             /**< Pointer to the mesh the element is defined for. */
-  const t8_locidx_t m_tree_id;    /**< The tree id of the element in the forest defined in the mesh. */
-  const t8_locidx_t m_element_id; /**< The element id of the element in the forest defined in the mesh. */
-  const bool m_is_ghost_element;  /**< Flag to indicate if the element is a ghost element. */
-  const t8_element_t* m_element;  /**< Cache the pointer to element in the forest as this is often needed. */
+  // --- Private variables to check which functionality is defined in TCompetence. ---
+  /** Helper function to check if class T implements the function volume_cache_filled.
+   * \tparam T The competence to be checked.
+   * \return true if T implements the function, false if not.
+   */
+  template <template <typename> class T>
+  static constexpr bool
+  volume_cache_defined ()
+  {
+    return requires (T<SelfType>& competence) { competence.volume_cache_filled (); };
+  }
+  /** Helper function to check if class T implements the function diameter_cache_defined.
+   * \tparam T The competence to be checked.
+   * \return true if T implements the function, false if not.
+   */
+  template <template <typename> class T>
+  static constexpr bool
+  diameter_cache_defined ()
+  {
+    return requires (T<SelfType>& competence) { competence.diameter_cache_filled (); };
+  }
+  /** Helper function to check if class T implements the function vertex_cache_filled.
+   * \tparam T The competence to be checked.
+   * \return true if T implements the function, false if not.
+   */
+  template <template <typename> class T>
+  static constexpr bool
+  vertex_cache_defined ()
+  {
+    return requires (T<SelfType>& competence) { competence.vertex_cache_filled (); };
+  }
+  /** Helper function to check if class T implements the function centroid_cache_filled.
+   * \tparam T The competence to be checked.
+   * \return true if T implements the function, false if not.
+   */
+  template <template <typename> class T>
+  static constexpr bool
+  centroid_cache_defined ()
+  {
+    return requires (T<SelfType>& competence) { competence.centroid_cache_filled (); };
+  }
+  /** Helper function to check if class T implements the function neighbor_cache_filled.
+   * \tparam T The competence to be checked.
+   * \return true if T implements the function, false if not.
+   */
+  template <template <typename> class T>
+  static constexpr bool
+  neighbor_cache_defined ()
+  {
+    return requires (T<SelfType>& competence) { competence.neighbor_cache_filled (0); };
+  }
+  /** Helper function to check if class T implements the function face_area_cache_filled.
+   * \tparam T The competence to be checked.
+   * \return true if T implements the function, false if not.
+   */
+  template <template <typename> class T>
+  static constexpr bool
+  face_area_cache_defined ()
+  {
+    return requires (T<SelfType>& competence) { competence.face_area_cache_filled (0); };
+  }
+  /** Helper function to check if class T implements the function face_centroid_cache_filled.
+   * \tparam T The competence to be checked.
+   * \return true if T implements the function, false if not.
+   */
+  template <template <typename> class T>
+  static constexpr bool
+  face_centroid_cache_defined ()
+  {
+    return requires (T<SelfType>& competence) { competence.face_centroid_cache_filled (0); };
+  }
+  /** Helper function to check if class T implements the function face_normal_cache_filled.
+   * \tparam T The competence to be checked.
+   * \return true if T implements the function, false if not.
+   */
+  template <template <typename> class T>
+  static constexpr bool
+  face_normal_cache_defined ()
+  {
+    return requires (T<SelfType>& competence) { competence.face_normal_cache_filled (0); };
+  }
 };
 
 }  // namespace t8_mesh_handle
diff --git a/test/mesh_handle/README.md b/test/mesh_handle/README.md
new file mode 100644
index 0000000000..af37422be6
--- /dev/null
+++ b/test/mesh_handle/README.md
@@ -0,0 +1,13 @@
+# mesh_handle testing concept #
+
+In this folder, we test the mesh handle functionality. 
+The tests are structured as follow: 
+
+- [t8_gtest_mesh_handle.cxx](t8_gtest_mesh_handle.cxx) tests some basic functionality, e.g., if the mesh handle generally works with default competences. The handle's functionality is not tested in detail, but instead using some *exemplary functions*. The predefined competence packs are checked.
+- [t8_gtest_custom_competence.cxx](t8_gtest_custom_competence.cxx) checks that user defined competences can be used for the mesh handle.
+- [t8_gtest_compare_handle_to_forest.cxx](t8_gtest_compare_handle_to_forest.cxx) tests that the functionality of the handle gives the same results as if worked with the forest directly. This test checks *all functions*. 
+- [t8_gtest_cache_competence.cxx](t8_gtest_cache_competence.cxx) tests that *all predefined caching competences* work as intended.
+- [t8_gtest_ghost.cxx](t8_gtest_ghost.cxx) checks ghosts and the neighbor algorithm. Furthermore tests if *all functions work also for ghost cells* if applicable.
+- [t8_gtest_handle_data.cxx](t8_gtest_handle_data.cxx) defines tests for user and element data.
+- [t8_gtest_adapt.cxx](t8_gtest_adapt.cxx) checks that the adapt routine works as intended and compares it with the result of an adapted forest.
+
diff --git a/test/mesh_handle/t8_gtest_adapt.cxx b/test/mesh_handle/t8_gtest_adapt.cxx
index 344415576c..acc311cafd 100644
--- a/test/mesh_handle/t8_gtest_adapt.cxx
+++ b/test/mesh_handle/t8_gtest_adapt.cxx
@@ -118,7 +118,7 @@ TEST (t8_gtest_handle_adapt, compare_adapt_with_forest)
   t8_cmesh_t cmesh = t8_cmesh_new_hypercube_hybrid (sc_MPI_COMM_WORLD, 0, 0);
   const t8_scheme *init_scheme = t8_scheme_new_default ();
   t8_forest_t forest = t8_forest_new_uniform (cmesh, init_scheme, level, 0, sc_MPI_COMM_WORLD);
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<>, dummy_user_data>;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::all_cache_competences, dummy_user_data>;
   mesh_class mesh_handle = mesh_class (forest);
   struct dummy_user_data user_data = {
     t8_3D_point ({ 0.5, 0.5, 1 }), /* Midpoints of the sphere. */
diff --git a/test/mesh_handle/t8_gtest_cache_competence.cxx b/test/mesh_handle/t8_gtest_cache_competence.cxx
index d037af9138..38b7e439d2 100644
--- a/test/mesh_handle/t8_gtest_cache_competence.cxx
+++ b/test/mesh_handle/t8_gtest_cache_competence.cxx
@@ -31,10 +31,7 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 #include <mesh_handle/mesh.hxx>
 #include <mesh_handle/competences.hxx>
 #include <mesh_handle/competence_pack.hxx>
-#include <t8_cmesh/t8_cmesh.h>
-#include <t8_cmesh/t8_cmesh_examples.h>
-#include <t8_forest/t8_forest_general.h>
-#include <t8_schemes/t8_default/t8_default.hxx>
+#include <mesh_handle/constructor_wrapper.hxx>
 #include <t8_types/t8_vec.hxx>
 #include <vector>
 
@@ -42,7 +39,6 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 template <typename TUnderlying>
 struct cache_volume_overwrite: public t8_mesh_handle::cache_volume<TUnderlying>
 {
- public:
   /** Overwrites the cache variable for the volume.
    * \param [in] new_volume New volume. 
    */
@@ -53,11 +49,24 @@ struct cache_volume_overwrite: public t8_mesh_handle::cache_volume<TUnderlying>
   }
 };
 
+/** Child class of \ref t8_mesh_handle::cache_diameter that allows to modify the cache variable for test purposes. */
+template <typename TUnderlying>
+struct cache_diameter_overwrite: public t8_mesh_handle::cache_diameter<TUnderlying>
+{
+  /** Overwrites the cache variable for the diameter.
+   * \param [in] new_diameter New diameter. 
+   */
+  void
+  overwrite_cache (double new_diameter) const
+  {
+    this->m_diameter = new_diameter;
+  }
+};
+
 /** Child class of \ref t8_mesh_handle::cache_vertex_coordinates that allows to modify the cache variable for test purposes. */
 template <typename TUnderlying>
 struct cache_vertex_coordinates_overwrite: public t8_mesh_handle::cache_vertex_coordinates<TUnderlying>
 {
- public:
   /** Overwrites the cache variable for the vertex coordinates.
    * \param [in] new_vec New cache vector. 
    */
@@ -72,7 +81,6 @@ struct cache_vertex_coordinates_overwrite: public t8_mesh_handle::cache_vertex_c
 template <typename TUnderlying>
 struct cache_centroid_overwrite: public t8_mesh_handle::cache_centroid<TUnderlying>
 {
- public:
   /** Overwrites the cache variable for the centroid.
    * \param [in] new_vec New point for the cache. 
    */
@@ -83,43 +91,66 @@ struct cache_centroid_overwrite: public t8_mesh_handle::cache_centroid<TUnderlyi
   }
 };
 
-/** Test fixture for cache competence tests. */
-class t8_gtest_cache_competence: public testing::Test {
- protected:
+// --- Face related caches. ---
+/** Child class of \ref t8_mesh_handle::cache_face_area that allows to modify the cache variables for test purposes. */
+template <typename TUnderlying>
+struct cache_face_area_overwrite: public t8_mesh_handle::cache_face_area<TUnderlying>
+{
+  /** Overwrites the cache variable for the face area.
+   * \param [in] face The face for which the cache should be set.
+   * \param [in] new_face_area New face area. 
+   */
   void
-  SetUp () override
+  overwrite_cache (int face, double new_face_area) const
   {
-    level = 1;
-    t8_cmesh_t cmesh = t8_cmesh_new_hypercube_hybrid (sc_MPI_COMM_WORLD, 0, 0);
-    const t8_scheme *scheme = t8_scheme_new_default ();
-    forest = t8_forest_new_uniform (cmesh, scheme, level, 0, sc_MPI_COMM_WORLD);
+    this->m_face_area[face] = new_face_area;
   }
+};
 
+/** Child class of \ref t8_mesh_handle::cache_face_centroid that allows to modify the cache variables for test purposes. */
+template <typename TUnderlying>
+struct cache_face_centroid_overwrite: public t8_mesh_handle::cache_face_centroid<TUnderlying>
+{
+  /** Overwrites the cache variable for the face centroid.
+   * \param [in] face The face for which the cache should be set.
+   * \param [in] new_face_centroid New face centroid. 
+   */
   void
-  TearDown () override
+  overwrite_cache (int face, t8_3D_point new_face_centroid) const
   {
-    if (forest->rc.refcount > 0) {
-      t8_forest_unref (&forest);
-    }
+    this->m_face_centroid[face] = new_face_centroid;
   }
+};
 
-  t8_forest_t forest;
-  int level;
+/** Child class of \ref t8_mesh_handle::cache_face_normal that allows to modify the cache variables for test purposes. */
+template <typename TUnderlying>
+struct cache_face_normal_overwrite: public t8_mesh_handle::cache_face_normal<TUnderlying>
+{
+  /** Overwrites the cache variable for the face normal.
+   * \param [in] face The face for which the cache should be set.
+   * \param [in] new_face_normal New face normal. 
+   */
+  void
+  overwrite_cache (int face, t8_3D_vec new_face_normal) const
+  {
+    this->m_face_normal[face] = new_face_normal;
+  }
 };
 
 /** Use child class of \ref t8_mesh_handle::cache_volume class to check that the cache is actually set 
  * and accessed correctly. This is done by modifying the cache to an unrealistic value and 
  * checking that the functionality actually outputs this unrealistic value.
  */
-TEST_F (t8_gtest_cache_competence, cache_volume)
+TEST (t8_gtest_cache_competence, cache_volume)
 {
+  const int level = 1;
   using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_volume_overwrite>>;
   using element_class = typename mesh_class::element_class;
-  const mesh_class mesh = mesh_class (forest);
+  const auto mesh = t8_mesh_handle::handle_hybrid_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
   EXPECT_TRUE (element_class::has_volume_cache ());
 
   double unrealistic_volume = -3000;
-  for (auto it = mesh.cbegin (); it != mesh.cend (); ++it) {
+  for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {
     // Check that cache is empty at the beginning.
     EXPECT_FALSE (it->volume_cache_filled ());
     // Fill cache and check that volume is valid.
@@ -133,34 +164,50 @@ TEST_F (t8_gtest_cache_competence, cache_volume)
   }
 }
 
+/** Use child class of \ref t8_mesh_handle::cache_diameter class to check that the cache is actually set 
+ * and accessed correctly. This is done by modifying the cache to an unrealistic value and 
+ * checking that the functionality actually outputs this unrealistic value.
+ */
+TEST (t8_gtest_cache_competence, cache_diameter)
+{
+  const int level = 1;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_diameter_overwrite>>;
+  using element_class = typename mesh_class::element_class;
+  auto mesh = t8_mesh_handle::handle_hybrid_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
+  EXPECT_TRUE (element_class::has_diameter_cache ());
+
+  double unrealistic_diameter = -3000;
+  for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {
+    EXPECT_FALSE (it->diameter_cache_filled ());
+    EXPECT_GE (it->get_diameter (), 0);
+    EXPECT_TRUE (it->diameter_cache_filled ());
+    it->overwrite_cache (unrealistic_diameter);
+    EXPECT_EQ (it->get_diameter (), unrealistic_diameter);
+  }
+}
+
 /** Use child class of \ref t8_mesh_handle::cache_vertex_coordinates class to check that the cache is actually set 
  * and accessed correctly. This is done by modifying the cache to an unrealistic value and 
  * checking that the functionality actually outputs this unrealistic value.
  */
-TEST_F (t8_gtest_cache_competence, cache_vertex_coordinates)
+TEST (t8_gtest_cache_competence, cache_vertex_coordinates)
 {
+  const int level = 1;
   using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_vertex_coordinates_overwrite>>;
   using element_class = typename mesh_class::element_class;
-  const mesh_class mesh = mesh_class (forest);
+  const auto mesh = t8_mesh_handle::handle_hybrid_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
   EXPECT_TRUE (element_class::has_vertex_cache ());
 
   std::vector<t8_3D_point> unrealistic_vertex = { t8_3D_point ({ 41, 42, 43 }), t8_3D_point ({ 99, 100, 101 }) };
-  for (auto it = mesh.cbegin (); it != mesh.cend (); ++it) {
-    // Check that cache is empty at the beginning.
+  for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {
     EXPECT_FALSE (it->vertex_cache_filled ());
-    // Check that values are valid.
-    auto vertex_coordinates = it->get_vertex_coordinates ();
-    for (int ivertex = 0; ivertex < (int) vertex_coordinates.size (); ++ivertex) {
-      for (const auto &coordinate : vertex_coordinates[ivertex]) {
-        EXPECT_GE (1, coordinate);
-        EXPECT_LE (0, coordinate);
+    for (int ivertex = 0; ivertex < it->get_num_vertices (); ++ivertex) {
+      for (const auto &coordinate : it->get_vertex_coordinates (ivertex)) {
+        EXPECT_TRUE (coordinate >= 0 && coordinate <= 1);
       }
     }
-    // Check that cache is set.
     EXPECT_TRUE (it->vertex_cache_filled ());
-    // Overwrite the cache with unrealistic values.
     it->overwrite_cache (unrealistic_vertex);
-    // Check that the cache is actually used.
     EXPECT_EQ (it->get_vertex_coordinates (), unrealistic_vertex);
   }
 }
@@ -169,28 +216,100 @@ TEST_F (t8_gtest_cache_competence, cache_vertex_coordinates)
  * and accessed correctly. This is done by modifying the cache to an unrealistic value and 
  * checking that the functionality actually outputs this unrealistic value.
  */
-TEST_F (t8_gtest_cache_competence, cache_centroid)
+TEST (t8_gtest_cache_competence, cache_centroid)
 {
+  const int level = 1;
   using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_centroid_overwrite>>;
   using element_class = mesh_class::element_class;
-  const mesh_class mesh = mesh_class (forest);
+  const auto mesh = t8_mesh_handle::handle_hybrid_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
   EXPECT_TRUE (element_class::has_centroid_cache ());
 
   t8_3D_point unrealistic_centroid ({ 999, 1000, 998 });
-  for (auto it = mesh.cbegin (); it != mesh.cend (); ++it) {
-    // Check that cache is empty at the beginning.
+  for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {
     EXPECT_FALSE (it->centroid_cache_filled ());
-    // Check that values are valid.
-    auto centroid = it->get_centroid ();
-    for (const auto &coordinate : centroid) {
-      EXPECT_GE (1, coordinate);
-      EXPECT_LE (0, coordinate);
+    for (const auto &coordinate : it->get_centroid ()) {
+      EXPECT_TRUE (coordinate >= 0 && coordinate <= 1);
     }
-    // Check that cache is set.
     EXPECT_TRUE (it->centroid_cache_filled ());
-    // Overwrite the cache with unrealistic values.
     it->overwrite_cache (unrealistic_centroid);
-    // Check that the cache is actually used.
     EXPECT_EQ (it->get_centroid (), unrealistic_centroid);
   }
 }
+
+// --- Face related caches. ---
+/** Use child class of \ref t8_mesh_handle::cache_face_area class to check that the cache is actually set 
+ * and accessed correctly. This is done by modifying the cache to an unrealistic value and 
+ * checking that the functionality actually outputs this unrealistic value.
+ */
+TEST (t8_gtest_cache_competence, cache_face_area)
+{
+  const int level = 1;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_face_area_overwrite>>;
+  using element_class = typename mesh_class::element_class;
+  auto mesh = t8_mesh_handle::handle_hybrid_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
+  EXPECT_TRUE (element_class::has_face_area_cache ());
+
+  double unrealistic_face_area = 41.1;
+  for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {
+    for (int iface = 0; iface < it->get_num_faces (); ++iface) {
+      EXPECT_FALSE (it->face_area_cache_filled (iface));
+      auto face_area = it->get_face_area (iface);
+      EXPECT_LE (0, face_area);
+      EXPECT_TRUE (it->face_area_cache_filled (iface));
+      it->overwrite_cache (iface, unrealistic_face_area + iface);
+      EXPECT_EQ (it->get_face_area (iface), unrealistic_face_area + iface);
+    }
+  }
+}
+
+/** Use child class of \ref t8_mesh_handle::cache_face_centroid class to check that the cache is actually set 
+ * and accessed correctly. This is done by modifying the cache to an unrealistic value and 
+ * checking that the functionality actually outputs this unrealistic value.
+ */
+TEST (t8_gtest_cache_competence, cache_face_centroid)
+{
+  const int level = 1;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_face_centroid_overwrite>>;
+  using element_class = typename mesh_class::element_class;
+  auto mesh = t8_mesh_handle::handle_hybrid_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
+  EXPECT_TRUE (element_class::has_face_centroid_cache ());
+
+  t8_3D_point unrealistic_face_centroid ({ 999, 1000, 998 });
+  for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {
+    for (int iface = 0; iface < it->get_num_faces (); ++iface) {
+      EXPECT_FALSE (it->face_centroid_cache_filled (iface));
+      for (const auto &coordinate : it->get_face_centroid (iface)) {
+        EXPECT_TRUE (coordinate >= 0 && coordinate <= 1);
+      }
+      EXPECT_TRUE (it->face_centroid_cache_filled (iface));
+      it->overwrite_cache (iface, unrealistic_face_centroid);
+      EXPECT_EQ (it->get_face_centroid (iface), unrealistic_face_centroid);
+    }
+  }
+}
+
+/** Use child class of \ref t8_mesh_handle::cache_face_normal class to check that the cache is actually set 
+ * and accessed correctly. This is done by modifying the cache to an unrealistic value and 
+ * checking that the functionality actually outputs this unrealistic value.
+ */
+TEST (t8_gtest_cache_competence, cache_face_normal)
+{
+  const int level = 1;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_face_normal_overwrite>>;
+  using element_class = typename mesh_class::element_class;
+  auto mesh = t8_mesh_handle::handle_hybrid_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
+  EXPECT_TRUE (element_class::has_face_normal_cache ());
+
+  t8_3D_vec unrealistic_face_normal ({ 41, 42, 43 });
+  for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {
+    for (int iface = 0; iface < it->get_num_faces (); ++iface) {
+      EXPECT_FALSE (it->face_normal_cache_filled (iface));
+      for (const auto &coordinate : it->get_face_normal (iface)) {
+        EXPECT_TRUE (coordinate >= -1 && coordinate <= 1);
+      }
+      EXPECT_TRUE (it->face_normal_cache_filled (iface));
+      it->overwrite_cache (iface, unrealistic_face_normal);
+      EXPECT_EQ (it->get_face_normal (iface), unrealistic_face_normal);
+    }
+  }
+}
diff --git a/test/mesh_handle/t8_gtest_compare_handle_to_forest.cxx b/test/mesh_handle/t8_gtest_compare_handle_to_forest.cxx
index 9bffb63ee5..300e4962b7 100644
--- a/test/mesh_handle/t8_gtest_compare_handle_to_forest.cxx
+++ b/test/mesh_handle/t8_gtest_compare_handle_to_forest.cxx
@@ -43,13 +43,15 @@ TEST (t8_gtest_compare_handle_to_forest, compare_handle_to_forest)
   // Define forest and mesh handle.
   const int level = 2;
   t8_cmesh_t cmesh = t8_cmesh_new_hypercube_hybrid (sc_MPI_COMM_WORLD, 0, 0);
-  const t8_scheme *init_scheme = t8_scheme_new_default ();
-  t8_forest_t forest = t8_forest_new_uniform (cmesh, init_scheme, level, 0, sc_MPI_COMM_WORLD);
+  const t8_scheme *scheme = t8_scheme_new_default ();
+  t8_forest_t forest = t8_forest_new_uniform (cmesh, scheme, level, 0, sc_MPI_COMM_WORLD);
 
   const t8_mesh_handle::mesh<> mesh = t8_mesh_handle::mesh<> (forest);
+  EXPECT_EQ (mesh.get_num_local_elements (), t8_forest_get_local_num_leaf_elements (forest));
+  EXPECT_EQ (mesh.get_num_ghosts (), t8_forest_get_num_ghosts (forest));
+  EXPECT_EQ (mesh.get_dimension (), t8_forest_get_dimension (forest));
 
   // Iterate over the elements of the forest and of the mesh handle simultaneously and compare results of different functions.
-  const t8_scheme *scheme = t8_forest_get_scheme (forest);
   // Use iterator for the mesh handle and two nested for-loops for the forest.
   auto mesh_iterator = mesh.cbegin ();
   for (t8_locidx_t itree = 0; itree < t8_forest_get_num_local_trees (forest); ++itree) {
@@ -59,21 +61,35 @@ TEST (t8_gtest_compare_handle_to_forest, compare_handle_to_forest)
       // --- Compare elements. ---
       EXPECT_EQ (mesh_iterator->get_local_tree_id (), itree);
       EXPECT_EQ (mesh_iterator->get_local_element_id (), ielem);
-      // --- Compare basics. ---
+      // --- Compare functionality. ---
       EXPECT_EQ (mesh_iterator->get_level (), scheme->element_get_level (tree_class, elem));
+      EXPECT_EQ (mesh_iterator->get_num_faces (), scheme->element_get_num_faces (tree_class, elem));
+      EXPECT_EQ (mesh_iterator->get_num_vertices (), scheme->element_get_num_corners (tree_class, elem));
       EXPECT_EQ (mesh_iterator->get_shape (), scheme->element_get_shape (tree_class, elem));
       EXPECT_EQ (mesh_iterator->get_volume (), t8_forest_element_volume (forest, itree, elem));
-      // --- Compare centroid. ---
-      t8_3D_point centroid;
-      t8_forest_element_centroid (forest, itree, elem, centroid.data ());
-      EXPECT_EQ (mesh_iterator->get_centroid (), centroid);
-      // --- Compare vertex coordinates. ---
+      EXPECT_EQ (mesh_iterator->get_diameter (), t8_forest_element_diam (forest, itree, elem));
+      // --- Vertex coordinates. ---
       auto vertex_coordinates = mesh_iterator->get_vertex_coordinates ();
-      for (int ivertex = 0; ivertex < (int) vertex_coordinates.size (); ++ivertex) {
+      for (int ivertex = 0; ivertex < mesh_iterator->get_num_vertices (); ++ivertex) {
         t8_3D_point vertex_forest;
         t8_forest_element_coordinate (forest, itree, elem, ivertex, vertex_forest.data ());
         EXPECT_EQ (vertex_forest, vertex_coordinates[ivertex]);
       }
+      // --- Centroid. ---
+      t8_3D_point centroid;
+      t8_forest_element_centroid (forest, itree, elem, centroid.data ());
+      EXPECT_EQ (mesh_iterator->get_centroid (), centroid);
+      // Face neighbor functionality is tested in t8_gtest_ghost.cxx.
+      for (int iface = 0; iface < mesh_iterator->get_num_faces (); ++iface) {
+        EXPECT_EQ (mesh_iterator->get_face_area (iface), t8_forest_element_face_area (forest, itree, elem, iface));
+        t8_3D_point coordinates;
+        t8_forest_element_face_centroid (forest, itree, elem, iface, coordinates.data ());
+        EXPECT_EQ (mesh_iterator->get_face_centroid (iface), coordinates);
+        t8_3D_vec normal;
+        t8_forest_element_face_normal (forest, itree, elem, iface, normal.data ());
+        EXPECT_EQ (mesh_iterator->get_face_normal (iface), normal);
+        EXPECT_EQ (mesh_iterator->get_face_shape (iface), scheme->element_get_face_shape (tree_class, elem, iface));
+      }
       // --- Evolve mesh iterator. ---
       mesh_iterator++;
     }
diff --git a/test/mesh_handle/t8_gtest_custom_competence.cxx b/test/mesh_handle/t8_gtest_custom_competence.cxx
index 6206d1cdc7..4a63e4e61d 100644
--- a/test/mesh_handle/t8_gtest_custom_competence.cxx
+++ b/test/mesh_handle/t8_gtest_custom_competence.cxx
@@ -31,10 +31,8 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 #include <mesh_handle/mesh.hxx>
 #include <mesh_handle/competences.hxx>
 #include <mesh_handle/competence_pack.hxx>
-#include <t8_cmesh/t8_cmesh.h>
-#include <t8_cmesh/t8_cmesh_examples.h>
+#include <mesh_handle/constructor_wrapper.hxx>
 #include <t8_forest/t8_forest_general.h>
-#include <t8_schemes/t8_default/t8_default.hxx>
 #include <t8_types/t8_operators.hxx>
 
 /**
@@ -46,9 +44,9 @@ struct dummy_get_level: public t8_crtp_operator<TUnderlying, dummy_get_level>
 {
  public:
   /** Getter for the level of the element. This function needs to access several members 
-  *     of the element such that we need the crtp structure here. 
-  * \return Level of the element.
-  */
+   *     of the element such that we need the crtp structure here. 
+   * \return Level of the element.
+   */
   t8_element_level
   get_level_dummy () const
   {
@@ -85,33 +83,29 @@ TEST (t8_gtest_custom_competence, custom_competence)
 {
   // Define forest to construct mesh.
   const int level = 1;
-  t8_cmesh_t cmesh = t8_cmesh_new_hypercube_hybrid (sc_MPI_COMM_WORLD, 0, 0);
-  const t8_scheme *scheme = t8_scheme_new_default ();
-  t8_forest_t forest = t8_forest_new_uniform (cmesh, scheme, level, 0, sc_MPI_COMM_WORLD);
 
   // Check mesh with custom defined competence.
   using mesh_class_custom = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<dummy_get_level>>;
-  const mesh_class_custom mesh = mesh_class_custom (forest);
+  const auto mesh
+    = t8_mesh_handle::handle_hybrid_hypercube_uniform_default<mesh_class_custom> (level, sc_MPI_COMM_WORLD);
 
-  for (auto it = mesh.cbegin (); it != mesh.cend (); ++it) {
+  for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {
     EXPECT_EQ (it->get_level (), it->get_level_dummy ());
     EXPECT_EQ (level, it->get_level_dummy ());
   }
 
-  t8_forest_ref (forest);
   // Test with two custom competences and a predefined competence.
   using competences = t8_mesh_handle::competence_pack<dummy_get_level, dummy_trivial, t8_mesh_handle::cache_centroid>;
   using mesh_class = t8_mesh_handle::mesh<competences>;
-  mesh_class mesh_more_competences = mesh_class (forest);
+  auto mesh_more_competences
+    = t8_mesh_handle::handle_hybrid_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
 
-  for (auto it = mesh_more_competences.cbegin (); it != mesh_more_competences.cend (); ++it) {
+  for (auto it = mesh_more_competences->cbegin (); it != mesh_more_competences->cend (); ++it) {
     EXPECT_EQ (it->get_level (), it->get_level_dummy ());
     EXPECT_EQ (it->get_value_dummy (), 1);
     EXPECT_FALSE (it->centroid_cache_filled ());
-    auto centroid = it->get_centroid ();
-    for (const auto &coordinate : centroid) {
-      EXPECT_GE (1, coordinate);
-      EXPECT_LE (0, coordinate);
+    for (const auto &coordinate : it->get_centroid ()) {
+      EXPECT_TRUE (coordinate >= 0 && coordinate <= 1);
     }
     EXPECT_TRUE (it->centroid_cache_filled ());
   }
diff --git a/test/mesh_handle/t8_gtest_ghost.cxx b/test/mesh_handle/t8_gtest_ghost.cxx
index 681afea2f7..6129c61ef0 100644
--- a/test/mesh_handle/t8_gtest_ghost.cxx
+++ b/test/mesh_handle/t8_gtest_ghost.cxx
@@ -32,6 +32,7 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 #include <mesh_handle/mesh.hxx>
 #include <mesh_handle/competences.hxx>
 #include <mesh_handle/competence_pack.hxx>
+#include <mesh_handle/constructor_wrapper.hxx>
 #include <t8_cmesh/t8_cmesh.h>
 #include <t8_cmesh/t8_cmesh_examples.h>
 #include <t8_forest/t8_forest_general.h>
@@ -41,84 +42,93 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 #include <vector>
 
 /** Parametrized test fixture for the ghost tests. */
+
 class t8_mesh_ghost_test: public testing::TestWithParam<std::tuple<t8_eclass_t, int>> {
  protected:
   void
   SetUp () override
   {
-    const t8_scheme* scheme = t8_scheme_new_default ();
-    t8_eclass_t eclass = std::get<0> (GetParam ());
+    eclass = std::get<0> (GetParam ());
     level = std::get<1> (GetParam ());
-    t8_cmesh_t cmesh = t8_cmesh_new_hypercube (eclass, sc_MPI_COMM_WORLD, 0, 1, 0);
-    forest = t8_forest_new_uniform (cmesh, scheme, level, 1, sc_MPI_COMM_WORLD);
-  }
-  void
-  TearDown () override
-  {
-    if (forest->rc.refcount > 0) {
-      t8_forest_unref (&forest);
-    }
   }
-  t8_forest_t forest;
+
+  t8_eclass_t eclass;
   int level;
 };
 
 /** Check the implementation of ghosts and all functions accessible by ghosts. */
 TEST_P (t8_mesh_ghost_test, check_ghosts)
 {
-  t8_forest_ghost_print (forest);
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::all_cache_competences>;
+  auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (eclass, level, sc_MPI_COMM_WORLD, true,
+                                                                            true, false);
 
-  const t8_mesh_handle::mesh<> mesh = t8_mesh_handle::mesh<> (forest);
-  EXPECT_EQ (mesh.get_num_ghosts (), t8_forest_get_num_ghosts (forest));
-  if ((mesh.get_dimension () > 1) && (mesh.get_num_local_elements () > 1)) {
+  EXPECT_EQ (mesh->get_num_ghosts (), t8_forest_get_num_ghosts (mesh->get_forest ()));
+  if ((mesh->get_dimension () > 1) && (mesh->get_num_local_elements () > 1)) {
     // Ensure that we actually have ghost elements in this test.
-    EXPECT_GT (mesh.get_num_ghosts (), 0);
+    EXPECT_GT (mesh->get_num_ghosts (), 0);
   }
   else {
     GTEST_SKIP () << "Skipping test as no ghost elements are created for 1D or single element meshes.";
   }
 
   // Check functions for ghost elements.
-  const t8_locidx_t num_local_elements = mesh.get_num_local_elements ();
-  const t8_locidx_t num_ghost_elements = mesh.get_num_ghosts ();
+  const t8_locidx_t num_local_elements = mesh->get_num_local_elements ();
+  const t8_locidx_t num_ghost_elements = mesh->get_num_ghosts ();
   for (t8_locidx_t ighost = num_local_elements; ighost < num_local_elements + num_ghost_elements; ++ighost) {
-    EXPECT_TRUE (mesh[ighost].is_ghost_element ());
-    EXPECT_EQ (level, mesh[ighost].get_level ());
-    auto centroid = mesh[ighost].get_centroid ();
-    for (const auto& coordinate : centroid) {
-      EXPECT_GE (1, coordinate);
-      EXPECT_LE (0, coordinate);
+    EXPECT_EQ (ighost, (*mesh)[ighost].get_element_handle_id ());
+    EXPECT_TRUE ((*mesh)[ighost].is_ghost_element ());
+    EXPECT_EQ (level, (*mesh)[ighost].get_level ());
+    EXPECT_LE (0, (*mesh)[ighost].get_num_faces ());
+    EXPECT_LE (0, (*mesh)[ighost].get_num_vertices ());
+    EXPECT_LE (0, (*mesh)[ighost].get_volume ());
+    EXPECT_LE (0, (*mesh)[ighost].get_diameter ());
+    for (const auto& coordinate : (*mesh)[ighost].get_centroid ()) {
+      EXPECT_TRUE (coordinate >= 0 && coordinate <= 1);
     }
-    auto vertex_coordinates = mesh[ighost].get_vertex_coordinates ();
-    for (int ivertex = 0; ivertex < (int) vertex_coordinates.size (); ++ivertex) {
-      for (const auto& coordinate : vertex_coordinates[ivertex]) {
-        EXPECT_GE (1, coordinate);
-        EXPECT_LE (0, coordinate);
+    for (int ivertex = 0; ivertex < (*mesh)[ighost].get_num_vertices (); ++ivertex) {
+      for (const auto& coordinate : (*mesh)[ighost].get_vertex_coordinates (ivertex)) {
+        EXPECT_TRUE (coordinate >= 0 && coordinate <= 1);
       }
     }
+    // Check face related functions exemplary for first face.
+    EXPECT_LE (0, (*mesh)[ighost].get_face_area (0));
+    for (const auto& coordinate : (*mesh)[ighost].get_face_centroid (0)) {
+      EXPECT_TRUE (coordinate >= 0 && coordinate <= 1);
+    }
+    for (const auto& coordinate : (*mesh)[ighost].get_face_normal (0)) {
+      EXPECT_TRUE (coordinate >= -1 && coordinate <= 1);
+    }
+    // Check exemplary that caches work for ghost elements.
+    EXPECT_TRUE ((*mesh)[ighost].volume_cache_filled ());
+    EXPECT_LE (0, (*mesh)[ighost].get_volume ());
   }
 }
 
 /** Check that the function \ref t8_mesh_handle::element::get_face_neighbors of the handle works as intended (equal results to forest).*/
 TEST_P (t8_mesh_ghost_test, compare_neighbors_to_forest)
 {
-  ASSERT_TRUE (t8_forest_is_committed (forest));
+  const t8_scheme* scheme = t8_scheme_new_default ();
+  t8_forest_t forest = t8_forest_new_uniform (t8_cmesh_new_hypercube (eclass, sc_MPI_COMM_WORLD, 0, 1, 0), scheme,
+                                              level, 1, sc_MPI_COMM_WORLD);
 
   const t8_mesh_handle::mesh<> mesh = t8_mesh_handle::mesh<> (forest);
   EXPECT_EQ (mesh.get_num_ghosts (), t8_forest_get_num_ghosts (forest));
+  if ((mesh.get_dimension () > 1) && (mesh.get_num_local_elements () > 1)) {
+    // Ensure that we have ghost elements in this test.
+    EXPECT_GT (mesh.get_num_ghosts (), 0);
+  }
 
   // Iterate over the elements of the forest and of the mesh handle simultaneously and compare results.
-  const t8_scheme* scheme = t8_forest_get_scheme (forest);
   auto mesh_iterator = mesh.cbegin ();
   for (t8_locidx_t itree = 0; itree < t8_forest_get_num_local_trees (forest); ++itree) {
-    const t8_eclass_t tree_class = t8_forest_get_tree_class (forest, itree);
     for (t8_locidx_t ielem = 0; ielem < t8_forest_get_tree_num_leaf_elements (forest, itree); ++ielem) {
       // --- Compare elements. ---
       EXPECT_EQ (mesh_iterator->get_local_tree_id (), itree);
       EXPECT_EQ (mesh_iterator->get_local_element_id (), ielem);
       // --- Compare neighbors. ---
       const t8_element_t* elem = t8_forest_get_leaf_element_in_tree (forest, itree, ielem);
-      const int num_faces = scheme->element_get_num_faces (tree_class, elem);
+      const int num_faces = scheme->element_get_num_faces (t8_forest_get_tree_class (forest, itree), elem);
       EXPECT_EQ (mesh_iterator->get_num_faces (), num_faces);
       for (int iface = 0; iface < num_faces; iface++) {
         // --- Get neighbors from forest. ---
@@ -175,24 +185,25 @@ struct cache_neighbors_overwrite: public t8_mesh_handle::cache_neighbors<TUnderl
   }
 };
 
-/** Use child class of \ref t8_mesh_handle::cache_neighbors class to check that the cache is actually set 
- * and accessed correctly. This is done by modifying the cache variables to a unrealistic values and 
+/** Use child class of \ref t8_mesh_handle::cache_neighbors class to check that the cache is actually set
+ * and accessed correctly. This is done by modifying the cache variables to a unrealistic values and
  * checking that the functionality actually outputs this unrealistic value.
  */
 TEST_P (t8_mesh_ghost_test, cache_neighbors)
 {
   using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_neighbors_overwrite>>;
   using element_class = typename mesh_class::element_class;
-  const mesh_class mesh = mesh_class (forest);
+  auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (eclass, level, sc_MPI_COMM_WORLD, true,
+                                                                            true, false);
   EXPECT_TRUE (element_class::has_face_neighbor_cache ());
 
-  if (mesh.get_num_local_elements () == 0) {
+  if (mesh->get_num_local_elements () == 0) {
     GTEST_SKIP () << "No local elements in the mesh to test the cache functionality.";
   }
   const std::vector<const element_class*> unrealistic_neighbors
-    = { &mesh[0], &mesh[mesh.get_num_local_elements () - 1] };
+    = { &((*mesh)[0]), &((*mesh)[mesh->get_num_local_elements () - 1]) };
   const std::vector<int> unrealistic_dual_faces = { 100, 1012000 };
-  for (auto it = mesh.cbegin (); it != mesh.cend (); ++it) {
+  for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {
     // Check that cache is empty at the beginning.
     EXPECT_FALSE (it->neighbor_cache_filled_any ());
     it->fill_face_neighbor_cache ();
diff --git a/test/mesh_handle/t8_gtest_handle_data.cxx b/test/mesh_handle/t8_gtest_handle_data.cxx
index 82ef2e99de..5c3c8668b3 100644
--- a/test/mesh_handle/t8_gtest_handle_data.cxx
+++ b/test/mesh_handle/t8_gtest_handle_data.cxx
@@ -30,10 +30,7 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 
 #include <mesh_handle/mesh.hxx>
 #include <mesh_handle/competence_pack.hxx>
-#include <t8_cmesh/t8_cmesh.h>
-#include <t8_cmesh/t8_cmesh_examples.h>
-#include <t8_forest/t8_forest_general.h>
-#include <t8_schemes/t8_default/t8_default.hxx>
+#include <mesh_handle/constructor_wrapper.hxx>
 #include <t8_types/t8_vec.hxx>
 #include <vector>
 
@@ -50,24 +47,20 @@ struct dummy_user_data
  */
 TEST (t8_gtest_handle_data, set_and_get_user_data)
 {
-  // Define forest and mesh handle.
+  // Define mesh handle.
   const int level = 2;
-  t8_cmesh_t cmesh = t8_cmesh_new_hypercube_hybrid (sc_MPI_COMM_WORLD, 0, 0);
-  const t8_scheme *init_scheme = t8_scheme_new_default ();
-  t8_forest_t forest = t8_forest_new_uniform (cmesh, init_scheme, level, 0, sc_MPI_COMM_WORLD);
-
   using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<>, dummy_user_data>;
-  mesh_class mesh = mesh_class (forest);
+  auto mesh = t8_mesh_handle::handle_hybrid_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
 
   struct dummy_user_data user_data = {
     t8_3D_point ({ 41, 42, 43 }), /* Midpoints of the sphere. */
-    0.2,                          /* Refine if inside this radius. */
-    0.4                           /* Coarsen if outside this radius. */
+    100,                          /* Refine if inside this radius. */
+    3                             /* Coarsen if outside this radius. */
   };
 
   // Set user data for the mesh handle and check that the getter returns the same data.
-  mesh.set_user_data (&user_data);
-  auto mesh_user_data = mesh.get_user_data ();
+  mesh->set_user_data (&user_data);
+  auto mesh_user_data = mesh->get_user_data ();
   EXPECT_EQ (mesh_user_data.midpoint, user_data.midpoint);
   EXPECT_EQ (mesh_user_data.refine_if_inside_radius, user_data.refine_if_inside_radius);
   EXPECT_EQ (mesh_user_data.coarsen_if_outside_radius, user_data.coarsen_if_outside_radius);
@@ -81,66 +74,66 @@ struct data_per_element
   double volume;
 };
 
-/** Check that element data can be set for the handle and 
- * that the getter has exchanged data for the ghosts.
- */
+/** Check that element data can be set for the handle and that the getter has exchanged data for the ghosts. */
 TEST (t8_gtest_handle_data, set_and_get_element_data)
 {
-  // Define forest and mesh handle.
+  // Define mesh handle.
   const int level = 2;
-  t8_cmesh_t cmesh = t8_cmesh_new_hypercube_hybrid (sc_MPI_COMM_WORLD, 0, 0);
-  const t8_scheme *init_scheme = t8_scheme_new_default ();
-  t8_forest_t forest = t8_forest_new_uniform (cmesh, init_scheme, level, 1, sc_MPI_COMM_WORLD);
-
   using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<>, void, data_per_element>;
-  mesh_class mesh = mesh_class (forest);
-  if ((mesh.get_dimension () > 1) && (mesh.get_num_local_elements () > 1)) {
+  auto mesh
+    = t8_mesh_handle::handle_hybrid_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD, true, true, false);
+  if ((mesh->get_dimension () > 1) && (mesh->get_num_local_elements () > 1)) {
     // Ensure that we actually test with ghost elements.
-    EXPECT_GT (mesh.get_num_ghosts (), 0);
+    EXPECT_GT (mesh->get_num_ghosts (), 0);
   }
+
   // Create element data for all local mesh elements.
   std::vector<data_per_element> element_data;
-  for (const auto &elem : mesh) {
+  for (const auto &elem : *mesh) {
     element_data.push_back ({ elem.get_level (), elem.get_volume () });
   }
-  mesh.set_element_data (element_data);
+  mesh->set_element_data (element_data);
   // Get element data and check that the data for all elements (including ghosts) is correct.
-  auto mesh_element_data = mesh.exchange_ghost_data ();
-  for (t8_locidx_t ielem = 0; ielem < mesh.get_num_local_elements () + mesh.get_num_ghosts (); ielem++) {
+  auto mesh_element_data = mesh->exchange_ghost_data ();
+  for (t8_locidx_t ielem = 0; ielem < mesh->get_num_local_elements () + mesh->get_num_ghosts (); ielem++) {
     EXPECT_EQ (mesh_element_data[ielem].level, level) << "ielem = " << ielem;
-    EXPECT_EQ (mesh_element_data[ielem].volume, mesh[ielem].get_volume ()) << "ielem = " << ielem;
+    EXPECT_EQ (mesh_element_data[ielem].volume, (*mesh)[ielem].get_volume ()) << "ielem = " << ielem;
   }
-  t8_gloidx_t barrier = t8_forest_get_num_global_trees (forest) / 2.0;
+
+  // Modify element data for elements that are in the first half of the global trees.
+  auto forest = mesh->get_forest ();
+  const t8_gloidx_t barrier = t8_forest_get_num_global_trees (forest) / 2.0;
   const int newlevel = 42;
   const double newvolume = 42.42;
-  for (auto &elem : mesh) {
-    if (t8_forest_global_tree_id (forest, elem.get_local_tree_id ()) < barrier) {
-      elem.set_element_data ({ newlevel, newvolume });
+  for (auto it = mesh->begin (); it != mesh->end (); ++it) {
+    if (t8_forest_global_tree_id (forest, it->get_local_tree_id ()) < barrier) {
+      it->set_element_data ({ newlevel, newvolume });
     }
   }
-  mesh.exchange_ghost_data ();
-  for (t8_locidx_t ielem = 0; ielem < mesh.get_num_local_elements (); ielem++) {
-    if (t8_forest_global_tree_id (forest, mesh[ielem].get_local_tree_id ()) < barrier) {
-      EXPECT_EQ (mesh[ielem].get_element_data ().level, newlevel) << "ielem = " << ielem;
-      EXPECT_EQ (mesh[ielem].get_element_data ().volume, newvolume) << "ielem = " << ielem;
+  mesh->exchange_ghost_data ();
+  // Check for mesh elements with updated data.
+  for (const auto &elem : *mesh) {
+    if (t8_forest_global_tree_id (forest, elem.get_local_tree_id ()) < barrier) {
+      EXPECT_EQ (elem.get_element_data ().level, newlevel);
+      EXPECT_EQ (elem.get_element_data ().volume, newvolume);
     }
     else {
-      EXPECT_EQ (mesh[ielem].get_element_data ().level, level) << "ielem = " << ielem;
-      EXPECT_EQ (mesh[ielem].get_element_data ().volume, mesh[ielem].get_volume ()) << "ielem = " << ielem;
+      EXPECT_EQ (elem.get_element_data ().level, level);
+      EXPECT_EQ (elem.get_element_data ().volume, elem.get_volume ());
     }
   }
-
-  for (t8_locidx_t ighost = mesh.get_num_local_elements ();
-       ighost < mesh.get_num_local_elements () + mesh.get_num_ghosts (); ighost++) {
-    if (t8_forest_ghost_get_global_treeid (forest,
-                                           mesh[ighost].get_local_tree_id () - t8_forest_get_num_local_trees (forest))
+  // Check for ghost elements with updated data.
+  for (t8_locidx_t ighost = mesh->get_num_local_elements ();
+       ighost < mesh->get_num_local_elements () + mesh->get_num_ghosts (); ighost++) {
+    if (t8_forest_ghost_get_global_treeid (
+          forest, (*mesh)[ighost].get_local_tree_id () - t8_forest_get_num_local_trees (forest))
         < barrier) {
-      EXPECT_EQ (mesh[ighost].get_element_data ().level, newlevel);
-      EXPECT_EQ (mesh[ighost].get_element_data ().volume, newvolume);
+      EXPECT_EQ ((*mesh)[ighost].get_element_data ().level, newlevel);
+      EXPECT_EQ ((*mesh)[ighost].get_element_data ().volume, newvolume);
     }
     else {
-      EXPECT_EQ (mesh[ighost].get_element_data ().level, level);
-      EXPECT_EQ (mesh[ighost].get_element_data ().volume, mesh[ighost].get_volume ());
+      EXPECT_EQ ((*mesh)[ighost].get_element_data ().level, level);
+      EXPECT_EQ ((*mesh)[ighost].get_element_data ().volume, (*mesh)[ighost].get_volume ());
     }
   }
 }
diff --git a/test/mesh_handle/t8_gtest_mesh_handle.cxx b/test/mesh_handle/t8_gtest_mesh_handle.cxx
index 12370ddb6e..874d6d60f5 100644
--- a/test/mesh_handle/t8_gtest_mesh_handle.cxx
+++ b/test/mesh_handle/t8_gtest_mesh_handle.cxx
@@ -22,7 +22,7 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 
 /**
  * \file t8_gtest_mesh_handle.cxx
- * Tests if the mesh class of the handle works as intended for different types of predefined template parameter classes. 
+ * Tests if the \ref t8_mesh_handle::mesh class of the handle works as intended for different types of template parameter classes. 
  */
 
 #include <gtest/gtest.h>
@@ -32,10 +32,7 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 #include <mesh_handle/mesh.hxx>
 #include <mesh_handle/competences.hxx>
 #include <mesh_handle/competence_pack.hxx>
-#include <t8_cmesh/t8_cmesh.h>
-#include <t8_cmesh/t8_cmesh_examples.h>
-#include <t8_forest/t8_forest_general.h>
-#include <t8_schemes/t8_default/t8_default.hxx>
+#include <mesh_handle/constructor_wrapper.hxx>
 
 /** Parametrized test fixture for the mesh handle tests. */
 class t8_mesh_handle_test: public testing::TestWithParam<std::tuple<t8_eclass_t, int>> {
@@ -43,176 +40,135 @@ class t8_mesh_handle_test: public testing::TestWithParam<std::tuple<t8_eclass_t,
   void
   SetUp () override
   {
-    const t8_scheme* scheme = t8_scheme_new_default ();
-    t8_eclass_t eclass = std::get<0> (GetParam ());
+    eclass = std::get<0> (GetParam ());
     level = std::get<1> (GetParam ());
-    t8_cmesh_t cmesh = t8_cmesh_new_hypercube (eclass, sc_MPI_COMM_WORLD, 0, 1, 0);
-    forest = t8_forest_new_uniform (cmesh, scheme, level, 0, sc_MPI_COMM_WORLD);
-  }
-  void
-  TearDown () override
-  {
-    if (forest->rc.refcount > 0) {
-      t8_forest_unref (&forest);
-    }
   }
 
-  t8_forest_t forest;
+  t8_eclass_t eclass;
   int level;
 };
 
-/** Test some default functionality and the iterator of \ref t8_mesh_handle::mesh class. */
-TEST_P (t8_mesh_handle_test, test_iterator)
+/** Test default \ref t8_mesh_handle::mesh handle class, the iterator and some exemplary functionality. */
+TEST_P (t8_mesh_handle_test, test_default_mesh_handle)
 {
-  // --- Check default functionality. ---
   using mesh_class = t8_mesh_handle::mesh<>;
   using element_class = typename mesh_class::element_class;
-  const mesh_class mesh = mesh_class (forest);
+  auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (eclass, level, sc_MPI_COMM_WORLD, true,
+                                                                            true, false);
   EXPECT_FALSE (element_class::has_vertex_cache ());
   EXPECT_FALSE (element_class::has_centroid_cache ());
 
-  // Iterate with the iterator over all mesh elements and check some functionality.
-  for (auto it = mesh.cbegin (); it != mesh.cend (); ++it) {
+  // Iterate with the constant iterator over all mesh elements and check some functionality.
+  for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {
     EXPECT_FALSE (it->has_vertex_cache ());
     EXPECT_FALSE (it->has_centroid_cache ());
     auto centroid = it->get_centroid ();
     for (const auto& coordinate : centroid) {
-      EXPECT_GE (1, coordinate);
-      EXPECT_LE (0, coordinate);
+      EXPECT_TRUE (coordinate >= 0 && coordinate <= 1);
     }
-    // Test dereference operator.
     auto vertex_coordinates = (*it).get_vertex_coordinates ();
     for (int ivertex = 0; ivertex < (int) vertex_coordinates.size (); ++ivertex) {
       for (const auto& coordinate : vertex_coordinates[ivertex]) {
-        EXPECT_GE (1, coordinate);
-        EXPECT_LE (0, coordinate);
+        EXPECT_TRUE (coordinate >= 0 && coordinate <= 1);
       }
     }
   }
 
   // Check loop with indices.
-  for (int ielement = 0; ielement < mesh.get_num_local_elements (); ielement++) {
-    EXPECT_EQ (level, mesh[ielement].get_level ());
+  for (int ielement = 0; ielement < mesh->get_num_local_elements (); ielement++) {
+    EXPECT_EQ (level, (*mesh)[ielement].get_level ());
+    EXPECT_EQ (ielement, (*mesh)[ielement].get_element_handle_id ());
   }
 }
 
-/** Test competences. */
-TEST_P (t8_mesh_handle_test, test_competences)
+/** Test mesh class with predefined competence pack using some exemplary functionality. */
+TEST_P (t8_mesh_handle_test, test_all_cache_competence_pack)
 {
-  // --- Version with cached vertex coordinates. ---
-  using competence_vertex_coordinates = t8_mesh_handle::competence_pack<t8_mesh_handle::cache_vertex_coordinates>;
-  using mesh_class_vertex = t8_mesh_handle::mesh<competence_vertex_coordinates>;
-  using element_class_vertex = typename mesh_class_vertex::element_class;
-  const mesh_class_vertex mesh_vertex = mesh_class_vertex (forest);
-  EXPECT_TRUE (element_class_vertex::has_vertex_cache ());
-  EXPECT_FALSE (element_class_vertex::has_centroid_cache ());
-
-  // Iterate with the iterator over all mesh elements and check functionality.
-  for (auto it = mesh_vertex.cbegin (); it != mesh_vertex.cend (); ++it) {
-    EXPECT_FALSE (it->vertex_cache_filled ());
-    EXPECT_EQ (level, it->get_level ());
-    auto centroid = it->get_centroid ();
-    for (const auto& coordinate : centroid) {
-      EXPECT_GE (1, coordinate);
-      EXPECT_LE (0, coordinate);
-    }
-    auto vertex_coordinates = it->get_vertex_coordinates ();
-    for (int ivertex = 0; ivertex < (int) vertex_coordinates.size (); ++ivertex) {
-      for (const auto& coordinate : vertex_coordinates[ivertex]) {
-        EXPECT_GE (1, coordinate);
-        EXPECT_LE (0, coordinate);
-      }
-    }
-  }
-  // Check cached value.
-  for (auto it = mesh_vertex.cbegin (); it != mesh_vertex.cend (); ++it) {
-    EXPECT_TRUE (it->vertex_cache_filled ());
-    auto vertex_coordinates = it->get_vertex_coordinates ();
-    for (int ivertex = 0; ivertex < (int) vertex_coordinates.size (); ++ivertex) {
-      for (const auto& coordinate : vertex_coordinates[ivertex]) {
-        EXPECT_GE (1, coordinate);
-        EXPECT_LE (0, coordinate);
-      }
-    }
-  }
-
-  // --- Version with cached centroid variable. ---
-  t8_forest_ref (forest);
-  using competence_centroid = t8_mesh_handle::competence_pack<t8_mesh_handle::cache_centroid>;
-  using mesh_class_centroid = t8_mesh_handle::mesh<competence_centroid>;
-  using element_class_centroid = typename mesh_class_centroid::element_class;
-  const mesh_class_centroid mesh_centroid = mesh_class_centroid (forest);
-  EXPECT_FALSE (element_class_centroid::has_vertex_cache ());
-  EXPECT_TRUE (element_class_centroid::has_centroid_cache ());
-
-  // Iterate with the iterator over all mesh elements.
-  for (auto it = mesh_centroid.cbegin (); it != mesh_centroid.cend (); ++it) {
-    EXPECT_FALSE (it->centroid_cache_filled ());
-    auto centroid = it->get_centroid ();
-    for (const auto& coordinate : centroid) {
-      EXPECT_GE (1, coordinate);
-      EXPECT_LE (0, coordinate);
-    }
-    EXPECT_TRUE (it->centroid_cache_filled ());
-    auto centroid_cached = it->get_centroid ();
-    for (const auto& coordinate : centroid_cached) {
-      EXPECT_GE (1, coordinate);
-      EXPECT_LE (0, coordinate);
-    }
-  }
-}
-
-/** Test mesh (element) class with more than one competence. */
-TEST_P (t8_mesh_handle_test, test_2_competences)
-{
-  // --- Use competences to cache level and centroid. ---
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::cache_competences>;
+  // --- Use predefined competence pack to use all available caching competences. ---
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::all_cache_competences>;
   using element_class = typename mesh_class::element_class;
-  const mesh_class mesh = mesh_class (forest);
+  auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (eclass, level, sc_MPI_COMM_WORLD, true,
+                                                                            true, false);
   EXPECT_TRUE (element_class::has_volume_cache ());
+  EXPECT_TRUE (element_class::has_diameter_cache ());
   EXPECT_TRUE (element_class::has_vertex_cache ());
   EXPECT_TRUE (element_class::has_centroid_cache ());
+  EXPECT_TRUE (element_class::has_face_area_cache ());
+  EXPECT_TRUE (element_class::has_face_centroid_cache ());
+  EXPECT_TRUE (element_class::has_face_normal_cache ());
+  EXPECT_TRUE (element_class::has_face_neighbor_cache ());
 
-  // Iterate with the iterator over all mesh elements.
-  for (auto it = mesh.cbegin (); it != mesh.cend (); ++it) {
+  // Iterate over all mesh elements and access some exemplary functionality which sets the caches.
+  for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {
     EXPECT_FALSE (it->volume_cache_filled ());
     EXPECT_FALSE (it->centroid_cache_filled ());
     EXPECT_FALSE (it->vertex_cache_filled ());
     EXPECT_EQ (level, it->get_level ());
     EXPECT_GE (it->get_volume (), 0);
-    auto centroid = it->get_centroid ();
-    for (const auto& coordinate : centroid) {
-      EXPECT_GE (1, coordinate);
-      EXPECT_LE (0, coordinate);
+    for (const auto& coordinate : it->get_centroid ()) {
+      EXPECT_TRUE (coordinate >= 0 && coordinate <= 1);
     }
-    auto vertex_coordinates = it->get_vertex_coordinates ();
-    for (int ivertex = 0; ivertex < (int) vertex_coordinates.size (); ++ivertex) {
-      for (const auto& coordinate : vertex_coordinates[ivertex]) {
-        EXPECT_GE (1, coordinate);
-        EXPECT_LE (0, coordinate);
+    for (int ivertex = 0; ivertex < it->get_num_vertices (); ++ivertex) {
+      for (const auto& coordinate : it->get_vertex_coordinates (ivertex)) {
+        EXPECT_TRUE (coordinate >= 0 && coordinate <= 1);
       }
     }
   }
-  // Test dereference operator. (Here the cached values should be used.)
-  for (auto it = mesh.cbegin (); it != mesh.cend (); ++it) {
+  // Check if caches are set. If caches are accessed correctly is checked in another test.
+  for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {
     EXPECT_TRUE (it->volume_cache_filled ());
     EXPECT_TRUE (it->centroid_cache_filled ());
     EXPECT_TRUE (it->vertex_cache_filled ());
-    EXPECT_EQ (level, (*it).get_level ());
-    EXPECT_GE (it->get_volume (), 0);
-    auto centroid = (*it).get_centroid ();
-    for (const auto& coordinate : centroid) {
-      EXPECT_GE (1, coordinate);
-      EXPECT_LE (0, coordinate);
+    EXPECT_FALSE (it->diameter_cache_filled ());
+    if (it->get_num_faces () > 0) {
+      EXPECT_FALSE (it->face_area_cache_filled (0));
+      EXPECT_FALSE (it->face_centroid_cache_filled (0));
+      EXPECT_FALSE (it->face_normal_cache_filled (0));
     }
-    auto vertex_coordinates = it->get_vertex_coordinates ();
-    for (int ivertex = 0; ivertex < (int) vertex_coordinates.size (); ++ivertex) {
-      for (const auto& coordinate : vertex_coordinates[ivertex]) {
-        EXPECT_GE (1, coordinate);
-        EXPECT_LE (0, coordinate);
+    EXPECT_FALSE (it->neighbor_cache_filled_any ());
+  }
+}
+
+/** Test mesh class with predefined face competence pack using some exemplary functionality. */
+TEST_P (t8_mesh_handle_test, test_cache_face_competences_pack)
+{
+  // --- Use predefined competence pack to use all available face caching competences. ---
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::cache_face_competences>;
+  using element_class = typename mesh_class::element_class;
+  auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (eclass, level, sc_MPI_COMM_WORLD, true,
+                                                                            true, false);
+  EXPECT_FALSE (element_class::has_volume_cache ());
+  EXPECT_FALSE (element_class::has_diameter_cache ());
+  EXPECT_FALSE (element_class::has_vertex_cache ());
+  EXPECT_FALSE (element_class::has_centroid_cache ());
+  EXPECT_TRUE (element_class::has_face_area_cache ());
+  EXPECT_TRUE (element_class::has_face_centroid_cache ());
+  EXPECT_TRUE (element_class::has_face_normal_cache ());
+  EXPECT_TRUE (element_class::has_face_neighbor_cache ());
+
+  // Iterate over all mesh elements and access some exemplary functionality which sets the caches.
+  for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {
+    if (it->get_num_faces () == 0) {
+      GTEST_SKIP () << "Skipping test as there are no faces to be tested.";
+    }
+    for (int iface = 0; iface < it->get_num_faces (); ++iface) {
+      EXPECT_FALSE (it->face_area_cache_filled (iface));
+      EXPECT_FALSE (it->face_normal_cache_filled (iface));
+      EXPECT_GE (it->get_face_area (iface), 0);
+      for (const auto& coordinate : it->get_face_normal (iface)) {
+        EXPECT_TRUE (coordinate >= -1 && coordinate <= 1);
       }
     }
   }
+  // Check if caches are set. If caches are accessed correctly is checked in another test.
+  for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {
+    for (int iface = 0; iface < it->get_num_faces (); ++iface) {
+      EXPECT_TRUE (it->face_area_cache_filled (iface));
+      EXPECT_FALSE (it->face_centroid_cache_filled (iface));
+      EXPECT_TRUE (it->face_normal_cache_filled (iface));
+    }
+    EXPECT_FALSE (it->neighbor_cache_filled_any ());
+  }
 }
 
 INSTANTIATE_TEST_SUITE_P (t8_gtest_mesh, t8_mesh_handle_test, testing::Combine (AllEclasses, testing::Range (2, 3)));