diff --git a/mesh_handle/competences.hxx b/mesh_handle/competences.hxx
index 69a2880868..a7a2616912 100644
--- a/mesh_handle/competences.hxx
+++ b/mesh_handle/competences.hxx
@@ -48,6 +48,52 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 namespace t8_mesh_handle
 {
 
+/**
+ * Competence to cache the volume 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_volume: public t8_crtp_operator<TUnderlying, cache_volume>
+{
+ public:
+  /**
+   * Function that checks if the cache for the volume has been filled.
+   * \return true if the cache has been filled, false otherwise.
+   */
+  bool
+  volume_cache_filled () const
+  {
+    return m_volume.has_value ();
+  }
+
+ protected:
+  mutable std::optional<double>
+    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.
@@ -94,6 +140,75 @@ 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.
diff --git a/mesh_handle/element.hxx b/mesh_handle/element.hxx
index 9c35440d54..1ab61b7c6f 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
@@ -69,9 +69,8 @@ class element: public TCompetence<element<TCompetence...>>... {
   using mesh_class = mesh<TCompetence...>;  /**< Type of the mesh class used. */
   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.
@@ -80,6 +79,7 @@ class element: public TCompetence<element<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 (
@@ -89,158 +89,225 @@ class element: public TCompetence<element<TCompetence...>>... {
       m_element = t8_forest_get_leaf_element_in_tree (m_mesh->m_forest, m_tree_id, m_element_id);
     }
 
-    if constexpr (neighbor_cache_exists) {
-      // Resize neighbor caches for clean access to the caches.
-      const int num_faces = this->get_num_faces ();
+    // Resize caches for clean access where the cache vector may not be filled completely at once.
+    if constexpr (has_face_neighbor_cache ()) {
+      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 vertex_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
-  vertex_cache_defined ()
+  has_volume_cache ()
   {
-    return requires (T<SelfType>& competence) { competence.vertex_cache_filled (); };
+    return (false || ... || volume_cache_defined<TCompetence> ());
   }
-  /** This variable is true if any of the given competences \a TCompetence implements 
-  a function vertex_cache_filled. */
-  static constexpr bool vertex_cache_exists = (false || ... || vertex_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 element's diameter exists.
+   * \return true if a cache exists, false otherwise.
    */
-  template <template <typename> class T>
   static constexpr bool
-  centroid_cache_defined ()
+  has_diameter_cache ()
   {
-    return requires (T<SelfType>& competence) { competence.centroid_cache_filled (); };
+    return (false || ... || diameter_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.
+   */
+  static constexpr bool
+  has_vertex_cache ()
+  {
+    return (false || ... || vertex_cache_defined<TCompetence> ());
   }
-  /** This variable is true if any of the given competences \a TCompetence implements 
-  a function centroid_cache_filled. */
-  static constexpr bool centroid_cache_exists = (false || ... || centroid_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> ());
   }
-  /** This variable is true if any of the given competences \a TCompetence implements 
-  a function neighbor_cache_filled. */
-  static constexpr bool neighbor_cache_exists = (false || ... || neighbor_cache_defined<TCompetence> ());
 
- public:
-  // --- Public functions to check if caches exist. ---
-  /**
-   * 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 face neighbors exists.
+   * \return true if a cache exists, false otherwise.
    */
   static constexpr bool
-  has_vertex_cache ()
+  has_face_neighbor_cache ()
   {
-    return vertex_cache_exists;
+    return (false || ... || neighbor_cache_defined<TCompetence> ());
+  }
+  /** 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_face_area_cache ()
+  {
+    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 centroid_cache_exists;
+    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 neighbor_cache_exists;
+    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 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.
+  /** 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.
+   *  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.
+   */
+  double
+  get_volume () const
+  {
+    if constexpr (has_volume_cache ()) {
+      if (!this->volume_cache_filled ()) {
+        // Fill cache.
+        this->m_volume = t8_forest_element_volume (m_mesh->m_forest, m_tree_id, m_element);
+      }
+      return this->m_volume.value ();
+    }
+    return t8_forest_element_volume (m_mesh->m_forest, m_tree_id, m_element);
+  }
+
+  /** 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.
+  /** 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 (vertex_cache_exists) {
+    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 (vertex_cache_exists) {
+    if constexpr (has_vertex_cache ()) {
       this->m_vertex_coordinates = std::move (vertex_coordinates);
       return this->m_vertex_coordinates;
     }
     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.
    */
@@ -248,15 +315,15 @@ class element: public TCompetence<element<TCompetence...>>... {
   get_centroid () const
   {
     // Check if we have a cached version and if the cache has already been filled.
-    if constexpr (centroid_cache_exists) {
+    if constexpr (has_centroid_cache ()) {
       if (this->centroid_cache_filled ()) {
         return this->m_centroid.value ();
       }
     }
     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 (centroid_cache_exists) {
+    if constexpr (has_centroid_cache ()) {
       this->m_centroid = coordinates;
     }
     return coordinates;
@@ -271,8 +338,9 @@ class element: public TCompetence<element<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 (neighbor_cache_exists) {
+    if constexpr (has_face_neighbor_cache ()) {
       if (this->neighbor_cache_filled (face)) {
         if (dual_faces) {
           dual_faces->get () = this->m_dual_faces[face];
@@ -280,14 +348,14 @@ class element: public TCompetence<element<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);
@@ -296,7 +364,7 @@ class element: public TCompetence<element<TCompetence...>>... {
     for (int ineighs = 0; ineighs < num_neighbors; ineighs++) {
       neighbors_handle.push_back (&((*m_mesh)[neighids[ineighs]]));
     }
-    if constexpr (neighbor_cache_exists) {
+    if constexpr (has_face_neighbor_cache ()) {
       // Also store num_neighbors in cache to indicate that the cache is filled if a face does not have any neighbor.
       this->m_num_neighbors[face] = num_neighbors;
       this->m_dual_faces[face].assign (dual_faces_internal, dual_faces_internal + num_neighbors);
@@ -309,27 +377,114 @@ class element: public TCompetence<element<TCompetence...>>... {
       T8_FREE (dual_faces_internal);
       T8_FREE (neighids);
     }
-    if constexpr (neighbor_cache_exists) {
+    if constexpr (has_face_neighbor_cache ()) {
       return this->m_neighbors[face];
     }
     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
-    requires (neighbor_cache_exists)
+    requires (has_face_neighbor_cache ())
   {
     for (int iface = 0; iface < get_num_faces (); iface++) {
       get_face_neighbors (iface);
     }
   }
 
+  // --- 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
@@ -345,10 +500,9 @@ class element: public TCompetence<element<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
@@ -357,11 +511,10 @@ class element: public TCompetence<element<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
@@ -370,8 +523,7 @@ class element: public TCompetence<element<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*
@@ -380,8 +532,7 @@ class element: public TCompetence<element<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
@@ -391,19 +542,15 @@ class element: public TCompetence<element<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
@@ -412,11 +559,87 @@ class element: public TCompetence<element<TCompetence...>>... {
     return t8_forest_get_tree_class (m_mesh->m_forest, m_tree_id);
   }
 
-  const 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..8e89ab5d85
--- /dev/null
+++ b/test/mesh_handle/README.md
@@ -0,0 +1,12 @@
+# mesh_handle testing concept #
+
+In this folder, we test the mesh handle functionality. 
+
+The testing strategy is written down here to ensure consistency.
+Therefore, the tests are structured as follows:
+
+- [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*.
+- [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.
diff --git a/test/mesh_handle/t8_gtest_cache_competence.cxx b/test/mesh_handle/t8_gtest_cache_competence.cxx
index 0201c3e96f..7f127614fd 100644
--- a/test/mesh_handle/t8_gtest_cache_competence.cxx
+++ b/test/mesh_handle/t8_gtest_cache_competence.cxx
@@ -34,11 +34,38 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 #include <t8_types/t8_vec.hxx>
 #include <vector>
 
+/** Child class of \ref t8_mesh_handle::cache_volume that allows to modify the cache variable for test purposes. */
+template <typename TUnderlying>
+struct cache_volume_overwrite: public t8_mesh_handle::cache_volume<TUnderlying>
+{
+  /** Overwrites the cache variable for the volume.
+   * \param [in] new_volume New volume. 
+   */
+  void
+  overwrite_cache (double new_volume) const
+  {
+    this->m_volume = new_volume;
+  }
+};
+
+/** 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. 
    */
@@ -53,7 +80,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. 
    */
@@ -64,6 +90,101 @@ struct cache_centroid_overwrite: public t8_mesh_handle::cache_centroid<TUnderlyi
   }
 };
 
+// --- 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
+  overwrite_cache (int face, double new_face_area) const
+  {
+    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
+  overwrite_cache (int face, t8_3D_point new_face_centroid) const
+  {
+    this->m_face_centroid[face] = new_face_centroid;
+  }
+};
+
+/** 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 (t8_gtest_cache_competence, cache_volume)
+{
+  const int level = 1;
+  using mesh_class = t8_mesh_handle::mesh<cache_volume_overwrite>;
+  using element_class = typename mesh_class::element_class;
+  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->begin (); it != mesh->end (); ++it) {
+    // Check that cache is empty at the beginning.
+    EXPECT_FALSE (it->volume_cache_filled ());
+    // Fill cache and check that volume is valid.
+    EXPECT_GE (it->get_volume (), 0);
+    // Check that cache is set.
+    EXPECT_TRUE (it->volume_cache_filled ());
+    // Overwrite the cache with unrealistic values.
+    it->overwrite_cache (unrealistic_volume);
+    // Check that the cache is actually used.
+    EXPECT_EQ (it->get_volume (), unrealistic_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<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->begin (); it != mesh->end (); ++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.
@@ -78,21 +199,14 @@ TEST (t8_gtest_cache_competence, cache_vertex_coordinates)
 
   std::vector<t8_3D_point> unrealistic_vertex = { t8_3D_point ({ 41, 42, 43 }), t8_3D_point ({ 99, 100, 101 }) };
   for (auto it = mesh->begin (); it != mesh->end (); ++it) {
-    // Check that cache is empty at the beginning.
     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);
   }
 }
@@ -111,19 +225,90 @@ TEST (t8_gtest_cache_competence, cache_centroid)
 
   t8_3D_point unrealistic_centroid ({ 999, 1000, 998 });
   for (auto it = mesh->begin (); it != mesh->end (); ++it) {
-    // Check that cache is empty at the beginning.
     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<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->begin (); it != mesh->end (); ++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<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->begin (); it != mesh->end (); ++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<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->begin (); it != mesh->end (); ++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 0007b0d9f3..5834c89dd6 100644
--- a/test/mesh_handle/t8_gtest_compare_handle_to_forest.cxx
+++ b/test/mesh_handle/t8_gtest_compare_handle_to_forest.cxx
@@ -32,6 +32,7 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 #include <t8_cmesh/t8_cmesh.h>
 #include <t8_cmesh/t8_cmesh_examples.h>
 #include <t8_forest/t8_forest_general.h>
+#include <t8_forest/t8_forest_geometrical.h>
 #include <t8_schemes/t8_default/t8_default.hxx>
 
 /** Tests that the functionality of the handle gives the same results as if worked with the forest directly.
@@ -42,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);
 
-  t8_mesh_handle::mesh<> mesh = t8_mesh_handle::mesh<> (forest);
+  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.begin ();
   for (t8_locidx_t itree = 0; itree < t8_forest_get_num_local_trees (forest); ++itree) {
@@ -58,20 +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));
-      // --- 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_volume (), t8_forest_element_volume (forest, itree, elem));
+      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 8d9fe89068..7382fe0685 100644
--- a/test/mesh_handle/t8_gtest_custom_competence.cxx
+++ b/test/mesh_handle/t8_gtest_custom_competence.cxx
@@ -80,10 +80,12 @@ struct dummy_trivial: public t8_crtp_operator<TUnderlying, dummy_trivial>
  */
 TEST (t8_gtest_custom_competence, custom_competence)
 {
-  // Check mesh with custom defined competence.
-  using mesh_class = t8_mesh_handle::mesh<dummy_get_level>;
   const int level = 1;
-  const auto mesh = t8_mesh_handle::handle_hybrid_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
+
+  // Check mesh with custom defined competence.
+  using mesh_class_custom = t8_mesh_handle::mesh<dummy_get_level>;
+  const auto mesh
+    = t8_mesh_handle::handle_hybrid_hypercube_uniform_default<mesh_class_custom> (level, sc_MPI_COMM_WORLD);
 
   for (auto it = mesh->begin (); it != mesh->end (); ++it) {
     EXPECT_EQ (it->get_level (), it->get_level_dummy ());
@@ -91,19 +93,16 @@ TEST (t8_gtest_custom_competence, custom_competence)
   }
 
   // Test with two custom competences and a predefined competence.
-  using mesh_class_more_cmpetences
-    = t8_mesh_handle::mesh<dummy_get_level, dummy_trivial, t8_mesh_handle::cache_centroid>;
+  using mesh_class = t8_mesh_handle::mesh<dummy_get_level, dummy_trivial, t8_mesh_handle::cache_centroid>;
   auto mesh_more_competences
-    = t8_mesh_handle::handle_hybrid_hypercube_uniform_default<mesh_class_more_cmpetences> (level, sc_MPI_COMM_WORLD);
+    = t8_mesh_handle::handle_hybrid_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
 
   for (auto it = mesh_more_competences->begin (); it != mesh_more_competences->end (); ++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_mesh_handle.cxx b/test/mesh_handle/t8_gtest_mesh_handle.cxx
index f2d57edea3..21f6a89131 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>
@@ -47,8 +47,8 @@ class t8_mesh_handle_test: public testing::TestWithParam<std::tuple<t8_eclass_t,
   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)
 {
   using mesh_class = t8_mesh_handle::mesh<>;
   using element_class = typename mesh_class::element_class;
@@ -63,15 +63,12 @@ TEST_P (t8_mesh_handle_test, test_iterator)
     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);
       }
     }
   }
@@ -79,122 +76,101 @@ TEST_P (t8_mesh_handle_test, test_iterator)
   // Check loop with indices.
   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 all competence available using some exemplary functionality. */
+TEST_P (t8_mesh_handle_test, test_all_cache_competence)
 {
-  // --- Version with cached vertex coordinates. ---
-  using mesh_class_vertex = t8_mesh_handle::mesh<t8_mesh_handle::cache_vertex_coordinates>;
-  using element_class_vertex = typename mesh_class_vertex::element_class;
-  auto mesh_vertex = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class_vertex> (
-    eclass, level, sc_MPI_COMM_WORLD, true, true, false);
-
-  EXPECT_TRUE (element_class_vertex::has_vertex_cache ());
-  EXPECT_FALSE (element_class_vertex::has_centroid_cache ());
+  // --- Use predefined competences to use all available caching competences. ---
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::cache_volume, t8_mesh_handle::cache_diameter,
+                                          t8_mesh_handle::cache_vertex_coordinates, t8_mesh_handle::cache_centroid,
+                                          t8_mesh_handle::cache_face_area, t8_mesh_handle::cache_face_centroid,
+                                          t8_mesh_handle::cache_face_normal, t8_mesh_handle::cache_neighbors>;
+  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_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 and check functionality.
-  for (auto it = mesh_vertex->begin (); it != mesh_vertex->end (); ++it) {
+  // Iterate over all mesh elements and access some exemplary functionality which sets the caches.
+  for (auto it = mesh->begin (); it != mesh->end (); ++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 ());
-    auto centroid = it->get_centroid ();
-    for (const auto& coordinate : centroid) {
-      EXPECT_GE (1, coordinate);
-      EXPECT_LE (0, coordinate);
+    EXPECT_GE (it->get_volume (), 0);
+    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);
       }
     }
   }
-  // Check cached value.
-  for (auto it = mesh_vertex->begin (); it != mesh_vertex->end (); ++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. ---
-  using mesh_class_centroid = t8_mesh_handle::mesh<t8_mesh_handle::cache_centroid>;
-  using element_class_centroid = typename mesh_class_centroid::element_class;
-  auto mesh_centroid = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class_centroid> (
-    eclass, level, sc_MPI_COMM_WORLD, true, true, false);
-  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->begin (); it != mesh_centroid->end (); ++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);
-    }
+  // Check if caches are set. If caches are accessed correctly is checked in another test.
+  for (auto it = mesh->begin (); it != mesh->end (); ++it) {
+    EXPECT_TRUE (it->volume_cache_filled ());
     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);
+    EXPECT_TRUE (it->vertex_cache_filled ());
+    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));
     }
+    EXPECT_FALSE (it->neighbor_cache_filled_any ());
   }
 }
 
-/** Test mesh (element) class with more than one competence. */
-TEST_P (t8_mesh_handle_test, test_2_competences)
+/** Test mesh class with all predefined face competences using some exemplary functionality. */
+TEST_P (t8_mesh_handle_test, test_cache_face_competences)
 {
-  // --- Use competences to cache level and centroid. ---
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::cache_vertex_coordinates, t8_mesh_handle::cache_centroid>;
+  // --- Use all predefined competences. ---
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::cache_face_area, t8_mesh_handle::cache_face_centroid,
+                                          t8_mesh_handle::cache_face_normal, t8_mesh_handle::cache_neighbors>;
   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 ());
 
-  EXPECT_TRUE (element_class::has_vertex_cache ());
-  EXPECT_TRUE (element_class::has_centroid_cache ());
-
-  // Iterate with the iterator over all mesh elements.
+  // Iterate over all mesh elements and access some exemplary functionality which sets the caches.
   for (auto it = mesh->begin (); it != mesh->end (); ++it) {
-    EXPECT_FALSE (it->centroid_cache_filled ());
-    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);
+    if (it->get_num_faces () == 0) {
+      GTEST_SKIP () << "Skipping test as there are no faces to be tested.";
     }
-    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 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);
       }
     }
   }
-  // Test dereference operator. (Here the cached values should be used.)
+  // Check if caches are set. If caches are accessed correctly is checked in another test.
   for (auto it = mesh->begin (); it != mesh->end (); ++it) {
-    EXPECT_TRUE (it->centroid_cache_filled ());
-    EXPECT_TRUE (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);
-      }
+    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 ());
   }
 }