diff --git a/test/include/userobjects/ReadTripleIndex.h b/test/include/userobjects/ReadTripleIndex.h
index 9cb6dbbefee2..cc491230ab08 100644
--- a/test/include/userobjects/ReadTripleIndex.h
+++ b/test/include/userobjects/ReadTripleIndex.h
@@ -51,4 +51,26 @@ class ReadTripleIndex : public GeneralUserObject
       _vector_postprocessor_name_tri;
   const std::vector<std::vector<std::vector<OutputName>>> & _output_name_tri;
   const std::vector<std::vector<std::vector<MaterialPropertyName>>> & _material_property_name_tri;
+
+  template <typename T>
+  void
+  TripleIndexNumberVectorChecker(const std::vector<std::vector<std::vector<T>>> triple_index_vector,
+                                 const std::string vector_name,
+                                 const std::vector<std::vector<std::vector<Real>>> reference_values,
+                                 const bool index_flip = false,
+                                 const bool flip_direction = false,
+                                 const Real scale_factor = 1.0,
+                                 const Real offset_value = 0.0);
+
+  template <typename T>
+  void TripleIndexStringVectorChecker(
+      const T triple_index_vector,
+      const std::string vector_name,
+      const std::string prefix,
+      const std::vector<std::vector<std::vector<Real>>> reference_values);
 };
+
+void
+ReadTripleIndex::execute()
+{
+}
diff --git a/test/src/userobjects/ReadTripleIndex.C b/test/src/userobjects/ReadTripleIndex.C
index 16fd81dceda2..77b33cadf929 100644
--- a/test/src/userobjects/ReadTripleIndex.C
+++ b/test/src/userobjects/ReadTripleIndex.C
@@ -17,47 +17,47 @@ ReadTripleIndex::validParams()
 {
   InputParameters params = GeneralUserObject::validParams();
   params.addRequiredParam<std::vector<std::vector<std::vector<Real>>>>(
-      "real_tri", "A double index field of real numbers.");
+      "real_tri", "A triple-indexed vector of real numbers.");
   params.addRequiredParam<std::vector<std::vector<std::vector<unsigned int>>>>(
-      "uint_tri", "A double index field of unsigned integers.");
+      "uint_tri", "A triple-indexed vector of unsigned integers.");
   params.addRequiredParam<std::vector<std::vector<std::vector<int>>>>(
-      "int_tri", "A double index field of integers.");
+      "int_tri", "A triple-indexed vector of integers.");
   params.addRequiredParam<std::vector<std::vector<std::vector<long>>>>(
-      "long_tri", "A double index field of long integers.");
+      "long_tri", "A triple-indexed vector of long integers.");
   params.addRequiredParam<std::vector<std::vector<std::vector<SubdomainID>>>>(
-      "subid_tri", "A double index field of SubdomainID.");
+      "subid_tri", "A triple-indexed vector of SubdomainID.");
   params.addRequiredParam<std::vector<std::vector<std::vector<BoundaryID>>>>(
-      "bid_tri", "A double index field of SubdomainID.");
+      "bid_tri", "A triple-indexed vector of BoundaryID.");
   params.addRequiredParam<std::vector<std::vector<std::vector<std::string>>>>(
-      "str_tri", "A double index field of std::string.");
+      "str_tri", "A triple-indexed vector of std::string.");
   params.addRequiredParam<std::vector<std::vector<std::vector<FileName>>>>(
-      "file_tri", "A double index field of FileName.");
+      "file_tri", "A triple-indexed vector of FileName.");
   params.addRequiredParam<std::vector<std::vector<std::vector<FileNameNoExtension>>>>(
-      "file_no_tri", "A double index field of FileNameNoExtension.");
+      "file_no_tri", "A triple-indexed vector of FileNameNoExtension.");
   params.addRequiredParam<std::vector<std::vector<std::vector<MeshFileName>>>>(
-      "mesh_file_tri", "A double index field of MeshFileName.");
+      "mesh_file_tri", "A triple-indexed vector of MeshFileName.");
   params.addRequiredParam<std::vector<std::vector<std::vector<SubdomainName>>>>(
-      "subdomain_name_tri", "A double index field of SubdomainName.");
+      "subdomain_name_tri", "A triple-indexed vector of SubdomainName.");
   params.addRequiredParam<std::vector<std::vector<std::vector<BoundaryName>>>>(
-      "boundary_name_tri", "A double index field of BoundaryName.");
+      "boundary_name_tri", "A triple-indexed vector of BoundaryName.");
   params.addRequiredParam<std::vector<std::vector<std::vector<FunctionName>>>>(
-      "function_name_tri", "A double index field of FunctionName.");
+      "function_name_tri", "A triple-indexed vector of FunctionName.");
   params.addRequiredParam<std::vector<std::vector<std::vector<UserObjectName>>>>(
-      "userobject_name_tri", "A double index field of UserObjectName.");
+      "userobject_name_tri", "A triple-indexed vector of UserObjectName.");
   params.addRequiredParam<std::vector<std::vector<std::vector<IndicatorName>>>>(
-      "indicator_name_tri", "A double index field of IndicatorName.");
+      "indicator_name_tri", "A triple-indexed vector of IndicatorName.");
   params.addRequiredParam<std::vector<std::vector<std::vector<MarkerName>>>>(
-      "marker_name_tri", "A double index field of MarkerName.");
+      "marker_name_tri", "A triple-indexed vector of MarkerName.");
   params.addRequiredParam<std::vector<std::vector<std::vector<MultiAppName>>>>(
-      "multiapp_name_tri", "A double index field of MultiAppName.");
+      "multiapp_name_tri", "A triple-indexed vector of MultiAppName.");
   params.addRequiredParam<std::vector<std::vector<std::vector<PostprocessorName>>>>(
-      "postprocessor_name_tri", "A double index field of PostprocessorName.");
+      "postprocessor_name_tri", "A triple-indexed vector of PostprocessorName.");
   params.addRequiredParam<std::vector<std::vector<std::vector<VectorPostprocessorName>>>>(
-      "vector_postprocessor_name_tri", "A double index field of VectorPostprocessorName.");
+      "vector_postprocessor_name_tri", "A triple-indexed vector of VectorPostprocessorName.");
   params.addRequiredParam<std::vector<std::vector<std::vector<OutputName>>>>(
-      "output_name_tri", "A double index field of OutputName.");
+      "output_name_tri", "A triple-indexed vector of OutputName.");
   params.addRequiredParam<std::vector<std::vector<std::vector<MaterialPropertyName>>>>(
-      "material_property_name_tri", "A double index field of MaterialPropertyName.");
+      "material_property_name_tri", "A triple-indexed vector of MaterialPropertyName.");
   return params;
 }
 
@@ -105,414 +105,142 @@ ReadTripleIndex::ReadTripleIndex(const InputParameters & params)
       {{21.1, 21.2}, {22.1}, {23.1, 23.2, 23.3}}};
 
   // check real
-  if (_real_tri != reference_values)
-    mooseError("Error reading real_tri.");
+  TripleIndexNumberVectorChecker(_real_tri, "real_tri", reference_values);
 
   // check unsigned int
-  if (_uint_tri.size() != reference_values.size())
-    mooseError("Error reading uint_tri.");
-  for (unsigned int i = 0; i < _uint_tri.size(); i++)
-  {
-    if (_uint_tri[i].size() != reference_values[i].size())
-      mooseError("Error reading uint_tri.");
-    for (unsigned int j = 0; j < _uint_tri[i].size(); j++)
-    {
-      if (_uint_tri[i][j].size() != reference_values[i][j].size())
-        mooseError("Error reading uint_tri.");
-      for (unsigned int k = 0; k < _uint_tri[i][j].size(); k++)
-        if (_uint_tri[i][j][k] != static_cast<unsigned int>(reference_values[i][j][k] * 10.0))
-          mooseError("Error reading uint_tri.");
-    }
-  }
+  TripleIndexNumberVectorChecker(_uint_tri, "uint_tri", reference_values, false, false, 10.0);
 
   // check int
-  if (_int_tri.size() != reference_values.size())
-    mooseError("Error reading int_tri.");
-  for (unsigned int i = 0; i < _int_tri.size(); i++)
-  {
-    if (_int_tri[i].size() != reference_values[i].size())
-      mooseError("Error reading int_tri.");
-    for (unsigned int j = 0; j < _int_tri[i].size(); j++)
-    {
-      if (_int_tri[i][j].size() != reference_values[i][j].size())
-        mooseError("Error reading int_tri.");
-      for (unsigned int k = 0; k < _int_tri[i][j].size(); k++)
-        if (_int_tri[i][j][k] != (i % 2 ? 1 : -1) * (j % 2 ? 1 : -1) *
-                                     static_cast<int>(reference_values[i][j][k] * 10.0))
-          mooseError("Error reading int_tri.");
-    }
-  }
+  TripleIndexNumberVectorChecker(_int_tri, "int_tri", reference_values, true, true, 10.0);
 
   // check long
-  if (_long_tri.size() != reference_values.size())
-    mooseError("Error reading long_tri.");
-  for (unsigned int i = 0; i < _long_tri.size(); i++)
-  {
-    if (_long_tri[i].size() != reference_values[i].size())
-      mooseError("Error reading long_tri.");
-    for (unsigned int j = 0; j < _long_tri[i].size(); j++)
-    {
-      if (_long_tri[i][j].size() != reference_values[i][j].size())
-        mooseError("Error reading long_tri.");
-      for (unsigned int k = 0; k < _long_tri[i][j].size(); k++)
-        if (_long_tri[i][j][k] != (i % 2 ? 1 : -1) * (j % 2 ? -1 : 1) *
-                                      static_cast<long>(reference_values[i][j][k] * 10.0))
-          mooseError("Error reading long_tri.");
-    }
-  }
+  TripleIndexNumberVectorChecker(_long_tri, "long_tri", reference_values, true, false, 10.0);
 
   // check SubdomainID
-  if (_subid_tri.size() != reference_values.size())
-    mooseError("Error reading subid_tri.");
-  for (unsigned int i = 0; i < _subid_tri.size(); i++)
-  {
-    if (_subid_tri[i].size() != reference_values[i].size())
-      mooseError("Error reading subid_tri.");
-    for (unsigned int j = 0; j < _subid_tri[i].size(); j++)
-    {
-      if (_subid_tri[i][j].size() != reference_values[i][j].size())
-        mooseError("Error reading subid_tri.");
-      for (unsigned int k = 0; k < _subid_tri[i][j].size(); k++)
-        if (_subid_tri[i][j][k] !=
-            static_cast<SubdomainID>(reference_values[i][j][k] * 10.0 + 30.0))
-          mooseError("Error reading subid_tri.");
-    }
-  }
+  TripleIndexNumberVectorChecker(_subid_tri, "subid_tri", reference_values, false, false, 10.0, 30.0);
 
   // check BoundaryID
-  if (_bid_tri.size() != reference_values.size())
-    mooseError("Error reading bid_tri.");
-  for (unsigned int i = 0; i < _bid_tri.size(); i++)
-  {
-    if (_bid_tri[i].size() != reference_values[i].size())
-      mooseError("Error reading bid_tri.");
-    for (unsigned int j = 0; j < _bid_tri[i].size(); j++)
-    {
-      if (_bid_tri[i][j].size() != reference_values[i][j].size())
-        mooseError("Error reading bid_tri.");
-      for (unsigned int k = 0; k < _bid_tri[i][j].size(); k++)
-        if (_bid_tri[i][j][k] != static_cast<BoundaryID>(reference_values[i][j][k] * 10.0 + 35.0))
-          mooseError("Error reading bid_tri.");
-    }
-  }
+  TripleIndexNumberVectorChecker(_bid_tri, "bid_tri", reference_values, false, false, 10.0, 35.0);
 
   // check std::string
-  if (_str_tri.size() != reference_values.size())
-    mooseError("Error reading str_tri.");
-  for (unsigned int i = 0; i < _str_tri.size(); i++)
-  {
-    if (_str_tri[i].size() != reference_values[i].size())
-      mooseError("Error reading str_tri.");
-    for (unsigned int j = 0; j < _str_tri[i].size(); j++)
-    {
-      if (_str_tri[i][j].size() != reference_values[i][j].size())
-        mooseError("Error reading str_tri.");
-      for (unsigned int k = 0; k < _str_tri[i][j].size(); k++)
-      {
-        std::stringstream ss;
-        ss << "string" << i << j << k;
-        if (_str_tri[i][j][k] != ss.str())
-          mooseError("Error reading str_tri.");
-      }
-    }
-  }
+  TripleIndexStringVectorChecker(_str_tri, "str_tri", "string", reference_values);
 
   // check FileName
-  if (_file_tri.size() != reference_values.size())
-    mooseError("Error reading file_tri.");
-  for (unsigned int i = 0; i < _file_tri.size(); i++)
-  {
-    if (_file_tri[i].size() != reference_values[i].size())
-      mooseError("Error reading file_tri.");
-    for (unsigned int j = 0; j < _file_tri[i].size(); j++)
-    {
-      if (_file_tri[i][j].size() != reference_values[i][j].size())
-        mooseError("Error reading file_tri.");
-      for (unsigned int k = 0; k < _file_tri[i][j].size(); k++)
-      {
-        std::stringstream ss;
-        ss << "file" << i << j << k;
-        if (_file_tri[i][j][k] != ss.str())
-          mooseError("Error reading file_tri.");
-      }
-    }
-  }
+  TripleIndexStringVectorChecker(_file_tri, "file_tri", "file", reference_values);
 
   // check FileNameNoExtension
-  if (_file_no_tri.size() != reference_values.size())
-    mooseError("Error reading file_no_tri.");
-  for (unsigned int i = 0; i < _file_no_tri.size(); i++)
-  {
-    if (_file_no_tri[i].size() != reference_values[i].size())
-      mooseError("Error reading file_no_tri.");
-    for (unsigned int j = 0; j < _file_no_tri[i].size(); j++)
-    {
-      if (_file_no_tri[i][j].size() != reference_values[i][j].size())
-        mooseError("Error reading file_no_tri.");
-      for (unsigned int k = 0; k < _file_no_tri[i][j].size(); k++)
-      {
-        std::stringstream ss;
-        ss << "file_no" << i << j << k;
-        if (_file_no_tri[i][j][k] != ss.str())
-          mooseError("Error reading file_no_tri.");
-      }
-    }
-  }
+  TripleIndexStringVectorChecker(_file_no_tri, "file_no_tri", "file_no", reference_values);
 
   // check MeshFileName
-  if (_mesh_file_tri.size() != reference_values.size())
-    mooseError("Error reading mesh_file_tri.");
-  for (unsigned int i = 0; i < _mesh_file_tri.size(); i++)
-  {
-    if (_mesh_file_tri[i].size() != reference_values[i].size())
-      mooseError("Error reading mesh_file_tri.");
-    for (unsigned int j = 0; j < _mesh_file_tri[i].size(); j++)
-    {
-      if (_mesh_file_tri[i][j].size() != reference_values[i][j].size())
-        mooseError("Error reading mesh_file_tri.");
-      for (unsigned int k = 0; k < _mesh_file_tri[i][j].size(); k++)
-      {
-        std::stringstream ss;
-        ss << "mesh_file" << i << j << k;
-        if (_mesh_file_tri[i][j][k] != ss.str())
-          mooseError("Error reading mesh_file_tri.");
-      }
-    }
-  }
+  TripleIndexStringVectorChecker(_mesh_file_tri, "mesh_file_tri", "mesh_file", reference_values);
 
   // check SubdomainName
-  if (_subdomain_name_tri.size() != reference_values.size())
-    mooseError("Error reading subdomain_name_tri.");
-  for (unsigned int i = 0; i < _subdomain_name_tri.size(); i++)
-  {
-    if (_subdomain_name_tri[i].size() != reference_values[i].size())
-      mooseError("Error reading subdomain_name_tri.");
-    for (unsigned int j = 0; j < _subdomain_name_tri[i].size(); j++)
-    {
-      if (_subdomain_name_tri[i][j].size() != reference_values[i][j].size())
-        mooseError("Error reading subdomain_name_tri.");
-      for (unsigned int k = 0; k < _subdomain_name_tri[i][j].size(); k++)
-      {
-        std::stringstream ss;
-        ss << "subdomain_name" << i << j << k;
-        if (_subdomain_name_tri[i][j][k] != ss.str())
-          mooseError("Error reading subdomain_name_tri.");
-      }
-    }
-  }
+  TripleIndexStringVectorChecker(
+      _subdomain_name_tri, "subdomain_name_tri", "subdomain_name", reference_values);
 
   // check BoundaryName
-  if (_boundary_name_tri.size() != reference_values.size())
-    mooseError("Error reading boundary_name_tri.");
-  for (unsigned int i = 0; i < _boundary_name_tri.size(); i++)
-  {
-    if (_boundary_name_tri[i].size() != reference_values[i].size())
-      mooseError("Error reading boundary_name_tri.");
-    for (unsigned int j = 0; j < _boundary_name_tri[i].size(); j++)
-    {
-      if (_boundary_name_tri[i][j].size() != reference_values[i][j].size())
-        mooseError("Error reading boundary_name_tri.");
-      for (unsigned int k = 0; k < _boundary_name_tri[i][j].size(); k++)
-      {
-        std::stringstream ss;
-        ss << "boundary_name" << i << j << k;
-        if (_boundary_name_tri[i][j][k] != ss.str())
-          mooseError("Error reading boundary_name_tri.");
-      }
-    }
-  }
+  TripleIndexStringVectorChecker(
+      _boundary_name_tri, "boundary_name_tri", "boundary_name", reference_values);
 
   // check FunctionName
-  if (_function_name_tri.size() != reference_values.size())
-    mooseError("Error reading function_name_tri.");
-  for (unsigned int i = 0; i < _function_name_tri.size(); i++)
-  {
-    if (_function_name_tri[i].size() != reference_values[i].size())
-      mooseError("Error reading function_name_tri.");
-    for (unsigned int j = 0; j < _function_name_tri[i].size(); j++)
-    {
-      if (_function_name_tri[i][j].size() != reference_values[i][j].size())
-        mooseError("Error reading function_name_tri.");
-      for (unsigned int k = 0; k < _function_name_tri[i][j].size(); k++)
-      {
-        std::stringstream ss;
-        ss << "function_name" << i << j << k;
-        if (_function_name_tri[i][j][k] != ss.str())
-          mooseError("Error reading function_name_tri.");
-      }
-    }
-  }
+  TripleIndexStringVectorChecker(
+      _function_name_tri, "function_name_tri", "function_name", reference_values);
 
   // check UserObjectName
-  if (_userobject_name_tri.size() != reference_values.size())
-    mooseError("Error reading userobject_name_tri.");
-  for (unsigned int i = 0; i < _userobject_name_tri.size(); i++)
-  {
-    if (_userobject_name_tri[i].size() != reference_values[i].size())
-      mooseError("Error reading userobject_name_tri.");
-    for (unsigned int j = 0; j < _userobject_name_tri[i].size(); j++)
-    {
-      if (_userobject_name_tri[i][j].size() != reference_values[i][j].size())
-        mooseError("Error reading userobject_name_tri.");
-      for (unsigned int k = 0; k < _userobject_name_tri[i][j].size(); k++)
-      {
-        std::stringstream ss;
-        ss << "userobject_name" << i << j << k;
-        if (_userobject_name_tri[i][j][k] != ss.str())
-          mooseError("Error reading userobject_name_tri.");
-      }
-    }
-  }
+  TripleIndexStringVectorChecker(
+      _userobject_name_tri, "userobject_name_tri", "userobject_name", reference_values);
 
   // check IndicatorName
-  if (_indicator_name_tri.size() != reference_values.size())
-    mooseError("Error reading indicator_name_tri.");
-  for (unsigned int i = 0; i < _indicator_name_tri.size(); i++)
-  {
-    if (_indicator_name_tri[i].size() != reference_values[i].size())
-      mooseError("Error reading indicator_name_tri.");
-    for (unsigned int j = 0; j < _indicator_name_tri[i].size(); j++)
-    {
-      if (_indicator_name_tri[i][j].size() != reference_values[i][j].size())
-        mooseError("Error reading indicator_name_tri.");
-      for (unsigned int k = 0; k < _indicator_name_tri[i][j].size(); k++)
-      {
-        std::stringstream ss;
-        ss << "indicator_name" << i << j << k;
-        if (_indicator_name_tri[i][j][k] != ss.str())
-          mooseError("Error reading indicator_name_tri.");
-      }
-    }
-  }
+  TripleIndexStringVectorChecker(
+      _indicator_name_tri, "indicator_name_tri", "indicator_name", reference_values);
 
   // check MarkerName
-  if (_marker_name_tri.size() != reference_values.size())
-    mooseError("Error reading marker_name_tri.");
-  for (unsigned int i = 0; i < _marker_name_tri.size(); i++)
-  {
-    if (_marker_name_tri[i].size() != reference_values[i].size())
-      mooseError("Error reading marker_name_tri.");
-    for (unsigned int j = 0; j < _marker_name_tri[i].size(); j++)
-    {
-      if (_marker_name_tri[i][j].size() != reference_values[i][j].size())
-        mooseError("Error reading marker_name_tri.");
-      for (unsigned int k = 0; k < _marker_name_tri[i][j].size(); k++)
-      {
-        std::stringstream ss;
-        ss << "marker_name" << i << j << k;
-        if (_marker_name_tri[i][j][k] != ss.str())
-          mooseError("Error reading marker_name_tri.");
-      }
-    }
-  }
+  TripleIndexStringVectorChecker(
+      _marker_name_tri, "marker_name_tri", "marker_name", reference_values);
 
   // check MultiAppName
-  if (_multiapp_name_tri.size() != reference_values.size())
-    mooseError("Error reading multiapp_name_tri.");
-  for (unsigned int i = 0; i < _multiapp_name_tri.size(); i++)
-  {
-    if (_multiapp_name_tri[i].size() != reference_values[i].size())
-      mooseError("Error reading multiapp_name_tri.");
-    for (unsigned int j = 0; j < _multiapp_name_tri[i].size(); j++)
-    {
-      if (_multiapp_name_tri[i][j].size() != reference_values[i][j].size())
-        mooseError("Error reading multiapp_name_tri.");
-      for (unsigned int k = 0; k < _multiapp_name_tri[i][j].size(); k++)
-      {
-        std::stringstream ss;
-        ss << "multiapp_name" << i << j << k;
-        if (_multiapp_name_tri[i][j][k] != ss.str())
-          mooseError("Error reading multiapp_name_tri.");
-      }
-    }
-  }
+  TripleIndexStringVectorChecker(
+      _multiapp_name_tri, "multiapp_name_tri", "multiapp_name", reference_values);
 
   // check PostprocessorName
-  if (_postprocessor_name_tri.size() != reference_values.size())
-    mooseError("Error reading postprocessor_name_tri.");
-  for (unsigned int i = 0; i < _postprocessor_name_tri.size(); i++)
-  {
-    if (_postprocessor_name_tri[i].size() != reference_values[i].size())
-      mooseError("Error reading postprocessor_name_tri.");
-    for (unsigned int j = 0; j < _postprocessor_name_tri[i].size(); j++)
-    {
-      if (_postprocessor_name_tri[i][j].size() != reference_values[i][j].size())
-        mooseError("Error reading postprocessor_name_tri.");
-      for (unsigned int k = 0; k < _postprocessor_name_tri[i][j].size(); k++)
-      {
-        std::stringstream ss;
-        ss << "postprocessor_name" << i << j << k;
-        if (_postprocessor_name_tri[i][j][k] != ss.str())
-          mooseError("Error reading postprocessor_name_tri.");
-      }
-    }
-  }
+  TripleIndexStringVectorChecker(
+      _postprocessor_name_tri, "postprocessor_name_tri", "postprocessor_name", reference_values);
 
   // check VectorPostprocessorName
-  if (_vector_postprocessor_name_tri.size() != reference_values.size())
-    mooseError("Error reading vector_postprocessor_name_tri.");
-  for (unsigned int i = 0; i < _vector_postprocessor_name_tri.size(); i++)
-  {
-    if (_vector_postprocessor_name_tri[i].size() != reference_values[i].size())
-      mooseError("Error reading vector_postprocessor_name_tri.");
-    for (unsigned int j = 0; j < _vector_postprocessor_name_tri[i].size(); j++)
-    {
-      if (_vector_postprocessor_name_tri[i][j].size() != reference_values[i][j].size())
-        mooseError("Error reading vector_postprocessor_name_tri.");
-      for (unsigned int k = 0; k < _vector_postprocessor_name_tri[i][j].size(); k++)
-      {
-        std::stringstream ss;
-        ss << "vector_postprocessor_name" << i << j << k;
-        if (_vector_postprocessor_name_tri[i][j][k] != ss.str())
-          mooseError("Error reading vector_postprocessor_name_tri.");
-      }
-    }
-  }
+  TripleIndexStringVectorChecker(_vector_postprocessor_name_tri,
+                                 "vector_postprocessor_name_tri",
+                                 "vector_postprocessor_name",
+                                 reference_values);
 
   // check OutputName
-  if (_output_name_tri.size() != reference_values.size())
-    mooseError("Error reading output_name_tri.");
-  for (unsigned int i = 0; i < _output_name_tri.size(); i++)
-  {
-    if (_output_name_tri[i].size() != reference_values[i].size())
-      mooseError("Error reading output_name_tri.");
-    for (unsigned int j = 0; j < _output_name_tri[i].size(); j++)
-    {
-      if (_output_name_tri[i][j].size() != reference_values[i][j].size())
-        mooseError("Error reading output_name_tri.");
-      for (unsigned int k = 0; k < _output_name_tri[i][j].size(); k++)
-      {
-        std::stringstream ss;
-        ss << "output_name" << i << j << k;
-        if (_output_name_tri[i][j][k] != ss.str())
-          mooseError("Error reading output_name_tri.");
-      }
+  TripleIndexStringVectorChecker(
+      _output_name_tri, "output_name_tri", "output_name", reference_values);
+
+  // check MaterialPropertyName
+  TripleIndexStringVectorChecker(_material_property_name_tri,
+                                 "material_property_name_tri",
+                                 "material_property_name",
+                                 reference_values);
+}
+
+template <typename T>
+void
+ReadTripleIndex::TripleIndexNumberVectorChecker(
+    const std::vector<std::vector<std::vector<T>>> triple_index_vector,
+    const std::string vector_name,
+    const std::vector<std::vector<std::vector<Real>>> reference_values,
+    const bool index_flip,
+    const bool flip_direction,
+    const Real scale_factor,
+    const Real offset_value)
+{
+  if (triple_index_vector.size() != reference_values.size())
+    mooseError("Error reading ", vector_name, ".");
+  for (unsigned int i = 0; i < triple_index_vector.size(); i++)
+  {
+    if (triple_index_vector[i].size() != reference_values[i].size())
+      mooseError("Error reading ", vector_name, ".");
+    for (unsigned int j = 0; j < triple_index_vector[i].size(); j++)
+    {
+      if (triple_index_vector[i][j].size() != reference_values[i][j].size())
+        mooseError("Error reading ", vector_name, ".");
+      for (unsigned int k = 0; k < triple_index_vector[i][j].size(); k++)
+        if (triple_index_vector[i][j][k] !=
+            static_cast<T>((reference_values[i][j][k] * scale_factor + offset_value) *
+                           (index_flip
+                                ? (flip_direction ? ((i % 2 ? 1.0 : -1.0) * (j % 2 ? 1.0 : -1.0))
+                                                  : ((i % 2 ? 1.0 : -1.0) * (j % 2 ? -1.0 : 1.0)))
+                                : 1.0)))
+          mooseError("Error reading ", vector_name, ".");
     }
   }
+}
 
-  // check MaterialPropertyName
-  if (_material_property_name_tri.size() != reference_values.size())
-    mooseError("Error reading _material_property_name_tri.");
-  for (unsigned int i = 0; i < _material_property_name_tri.size(); i++)
+template <typename T>
+void
+ReadTripleIndex::TripleIndexStringVectorChecker(
+    const T triple_index_vector,
+    const std::string vector_name,
+    const std::string prefix,
+    const std::vector<std::vector<std::vector<Real>>> reference_values)
+{
+  if (triple_index_vector.size() != reference_values.size())
+    mooseError("Error reading ", vector_name, ".");
+  for (unsigned int i = 0; i < triple_index_vector.size(); i++)
   {
-    if (_material_property_name_tri[i].size() != reference_values[i].size())
-      mooseError("Error reading _material_property_name_tri.");
-    for (unsigned int j = 0; j < _material_property_name_tri[i].size(); j++)
+    if (triple_index_vector[i].size() != reference_values[i].size())
+      mooseError("Error reading ", vector_name, ".");
+    for (unsigned int j = 0; j < triple_index_vector[i].size(); j++)
     {
-      if (_material_property_name_tri[i][j].size() != reference_values[i][j].size())
-        mooseError("Error reading _material_property_name_tri.");
-      for (unsigned int k = 0; k < _material_property_name_tri[i][j].size(); k++)
+      if (triple_index_vector[i][j].size() != reference_values[i][j].size())
+        mooseError("Error reading ", vector_name, ".");
+      for (unsigned int k = 0; k < triple_index_vector[i][j].size(); k++)
       {
         std::stringstream ss;
-        ss << "material_property_name" << i << j << k;
-        if (_material_property_name_tri[i][j][k] != ss.str())
-          mooseError("Error reading _material_property_name_tri.");
+        ss << prefix << i << j << k;
+        if (triple_index_vector[i][j][k] != ss.str())
+          mooseError("Error reading ", vector_name, ".");
       }
     }
   }
 }
-
-void
-ReadTripleIndex::execute()
-{
-}