ObjectPath XML errors feedback

src/coreComponents/common/Logger.cpp

@@ -29,16 +29,16 @@ std::string InputError::InsertExMsg( std::string const & originalMsg, std::strin
 
   size_t insertPos = 0;
   // for readability purposes, we try to insert the message after the "***** Rank N: " or after "***** " instead of at the top.
-  static auto constexpr rankLogStartStr =  "***** Rank ";
-  static auto constexpr rankLogEndStr =  ": ";
-  static auto constexpr simpleLogStartStr =  "***** ";
-  if( ( insertPos = newMsg.find( rankLogStartStr ) ) != std::string::npos )
+  static auto constexpr rankLogStart =  "***** Rank ";
+  static auto constexpr rankLogEnd =  ": ";
+  static auto constexpr simpleLogStart =  "***** ";
+  if( ( insertPos = newMsg.find( rankLogStart ) ) != std::string::npos )
   {
-    insertPos = newMsg.find( rankLogEndStr, insertPos + strlen( rankLogStartStr ) ) + strlen( rankLogEndStr );
+    insertPos = newMsg.find( rankLogEnd, insertPos + strlen( rankLogStart ) ) + strlen( rankLogEnd );
   }
-  else if( ( insertPos = newMsg.find_last_of( simpleLogStartStr ) ) != std::string::npos )
+  else if( ( insertPos = newMsg.find_last_of( simpleLogStart ) ) != std::string::npos )
   {
-    insertPos += strlen( simpleLogStartStr );
+    insertPos += strlen( simpleLogStart );
   }
   newMsg.insert( insertPos, msgToInsert );
 

src/coreComponents/common/Logger.hpp

@@ -490,7 +490,7 @@ struct InputError : public std::runtime_error
   /**
    * @brief Returns an exception message in which we insert another message.
    */
-  static std::string InsertExMsg( std::string const & originalMsg, std::string const & msgToInsert );
+  std::string InsertExMsg( std::string const & originalMsg, std::string const & msgToInsert );
 };
 
 /**

src/coreComponents/mesh/MeshObjectPath.cpp

@@ -111,25 +111,36 @@ MeshObjectPath::fillPathTokens( string const & path,
     {
       pathTokens.insert( pathTokens.begin(), "{*}" );
 
-      string existingMeshBodyAndLevel;
+      // searching if the mesh level exists
       bool levelNameFound = false;
       meshBodies.forSubGroups< MeshBody >( [&]( MeshBody const & meshBody )
       {
-        existingMeshBodyAndLevel += meshBody.getName() + ": ";
         meshBody.forMeshLevels( [&]( MeshLevel const & meshLevel )
         {
-          existingMeshBodyAndLevel += meshLevel.getName() + ", ";
-          levelNameFound = ( unidentifiedName==meshLevel.getName() ) ? true : levelNameFound;
+          levelNameFound |= ( unidentifiedName==meshLevel.getName() );
         } );
-        existingMeshBodyAndLevel += "/n";
       } );
 
-      GEOSX_THROW_IF( !levelNameFound,
-                      GEOSX_FMT( "Path {} specifies an invalid MeshBody or MeshLevel. ",
-                                 "existing MeshBodies: {} /n",
-                                 path,
-                                 existingMeshBodyAndLevel ),
-                      InputError );
+      if( !levelNameFound )
+      {
+        string existingMeshBodiesAndLevels;
+        meshBodies.forSubGroups< MeshBody >( [&]( MeshBody const & meshBody )
+        {
+          std::vector< string > meshLevelsNames;
+          existingMeshBodiesAndLevels += "  MeshBody "+meshBody.getName() + ": { ";
+          meshBody.forMeshLevels( [&]( MeshLevel const & meshLevel )
+          {
+            meshLevelsNames.push_back( meshLevel.getName() );
+          } );
+          existingMeshBodiesAndLevels += stringutilities::join( meshLevelsNames, ", " ) + " }\n";
+        } );
+
+        GEOSX_THROW( GEOSX_FMT( "Path {0} specifies an invalid MeshBody or MeshLevel. ",
+                                "existing MeshBodies: \n{1}\n",
+                                path,
+                                existingMeshBodiesAndLevels ),
+                     InputError );
+      }
       pathTokens.insert( pathTokens.begin()+1, unidentifiedName );
     }
   }

src/coreComponents/unitTests/dataRepositoryTests/testGroupPath.cpp

@@ -95,6 +95,24 @@ TEST( testGroupPath, testGlobalPaths )
     Group const & group = problem.getGroupByPath( path );
     ASSERT_STREQ( path.c_str(), group.getPath().c_str() );
   }
+
+  // test for a wrong path given to getGroupByPath()
+  bool trowHappened = false;
+  try
+  {
+    problem.getGroupByPath( "/Mesh/mesh2" );
+  }
+  catch( const std::domain_error & e )
+  {
+    static constexpr auto expectedMsg = "***** Controlling expression (should be false): true\n"
+                                        "***** Rank 0: Group /Mesh has no child named mesh2\n"
+                                        "The children of Mesh are: { mesh1 }";
+    // checks if the exception contains the expected message
+    ASSERT_TRUE( string( e.what() ).find( expectedMsg ) != string::npos );
+    trowHappened = true;
+  }
+  // checks if the exception has been thrown as expected
+  ASSERT_TRUE( trowHappened );
 }
 
 int main( int argc, char * * argv )