ObjImporter: clean up and deduplicate the tests.

Basically just making use of all APIs that got invented over the last 10
years, such as using instanced test cases instead of repeatedly having
the same test code with just different strings or accessing meshes
directly by name instead of meshForName().

Additionally the test files were renamed to better group them visually,
with invalid cases being separated from valid cases so it's possible to
have instanced tests for those.

src/MagnumPlugins/AnySceneImporter/Test/AnySceneImporterTest.cpp

@@ -78,7 +78,7 @@ const struct {
     const char* name;
     Containers::String filename;
 } LoadData[]{
-    {"OBJ", Utility::Path::join(OBJIMPORTER_TEST_DIR, "pointMesh.obj")},
+    {"OBJ", Utility::Path::join(OBJIMPORTER_TEST_DIR, "mesh-primitive-points.obj")},
 };
 
 constexpr struct {
@@ -157,7 +157,7 @@ void AnySceneImporterTest::loadDeprecatedMeshData() {
         CORRADE_SKIP("ObjImporter plugin not enabled, cannot test");
 
     Containers::Pointer<AbstractImporter> importer = _manager.instantiate("AnySceneImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "pointMesh.obj")));
+    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "mesh-primitive-points.obj")));
 
     /* Check only size, as it is good enough proof that it is working */
 
@@ -298,7 +298,7 @@ void AnySceneImporterTest::propagateFileCallback() {
 
     Containers::Array<char> storage;
     importer->setFileCallback([](const std::string&, InputFileCallbackPolicy, Containers::Array<char>& storage) -> Containers::Optional<Containers::ArrayView<const char>> {
-        Containers::Optional<Containers::Array<char>> data = Utility::Path::read(Utility::Path::join(OBJIMPORTER_TEST_DIR, "pointMesh.obj"));
+        Containers::Optional<Containers::Array<char>> data = Utility::Path::read(Utility::Path::join(OBJIMPORTER_TEST_DIR, "mesh-primitive-points.obj"));
         CORRADE_VERIFY(data);
         storage = *std::move(data);
         return Containers::ArrayView<const char>{storage};

src/MagnumPlugins/AnySceneImporter/Test/CMakeLists.txt

@@ -51,7 +51,7 @@ file(GENERATE OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>/configure.h
 corrade_add_test(AnySceneImporterTest AnySceneImporterTest.cpp
     LIBRARIES MagnumTrade
     FILES
-        ${PROJECT_SOURCE_DIR}/src/MagnumPlugins/ObjImporter/Test/pointMesh.obj
+        ${PROJECT_SOURCE_DIR}/src/MagnumPlugins/ObjImporter/Test/mesh-primitive-points.obj
         mesh-custom-attribute.gltf
         scene-custom-field.gltf
         triangle.ply)

src/MagnumPlugins/ObjImporter/Test/CMakeLists.txt

@@ -46,23 +46,26 @@ file(GENERATE OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>/configure.h
 corrade_add_test(ObjImporterTest ObjImporterTest.cpp
     LIBRARIES MagnumTrade
     FILES
-        emptyFile.obj
+        empty.obj
-        keywords.obj
+        invalid-incomplete-data.obj
-        lineMesh.obj
+        invalid-inconsistent-index-tuple.obj
-        missingData.obj
+        invalid-keyword.obj
-        mixedPrimitives.obj
+        invalid-mixed-primitives.obj
-        moreMeshes.obj
+        invalid-number-count.obj
-        namedMesh.obj
+        invalid-numbers.obj
-        normals.obj
+        invalid-optional-coordinate.obj
-        optionalCoordinates.obj
+        mesh-ignored-keyword.obj
-        pointMesh.obj
+        mesh-multiple.obj
-        textureCoordinatesNormals.obj
+        mesh-named-first-unnamed.obj
-        textureCoordinates.obj
+        mesh-named.obj
-        triangleMesh.obj
+        mesh-normals.obj
-        unnamedFirstMesh.obj
+        mesh-positions-optional-coordinate.obj
-        wrongIndexCount.obj
+        mesh-primitive-lines.obj
-        wrongNumberCount.obj
+        mesh-primitive-points.obj
-        wrongNumbers.obj)
+        mesh-primitive-triangles.obj
+        mesh-texture-coordinates.obj
+        mesh-texture-coordinates-normals.obj
+        mesh-texture-coordinates-optional-coordinate.obj)
 target_include_directories(ObjImporterTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>)
 if(MAGNUM_OBJIMPORTER_BUILD_STATIC)
     target_link_libraries(ObjImporterTest PRIVATE ObjImporter)

src/MagnumPlugins/ObjImporter/Test/ObjImporterTest.cpp

@@ -29,6 +29,7 @@
 #include <Corrade/TestSuite/Tester.h>
 #include <Corrade/TestSuite/Compare/Container.h>
 #include <Corrade/Utility/DebugStl.h>
+#include <Corrade/Utility/FormatStl.h>
 #include <Corrade/Utility/Path.h>
 
 #include "Magnum/Mesh.h"
@@ -43,55 +44,37 @@ namespace Magnum { namespace Trade { namespace Test { namespace {
 struct ObjImporterTest: TestSuite::Tester {
     explicit ObjImporterTest();
 
-    void pointMesh();
+    void empty();
-    void lineMesh();
-    void triangleMesh();
-    void mixedPrimitives();
 
-    void positionsOnly();
+    void meshPrimitivePoints();
-    void textureCoordinates();
+    void meshPrimitiveLines();
-    void normals();
+    void meshPrimitiveTriangles();
-    void textureCoordinatesNormals();
+
+    /* Positions alone are tested above */
+    void meshPositionsOptionalCoordinate();
+    void meshTextureCoordinates();
+    void meshTextureCoordinatesOptionalCoordinate();
+    void meshNormals();
+    void meshTextureCoordinatesNormals();
+
+    void meshIgnoredKeyword();
+
+    void meshNamed();
+    void meshNamedFirstUnnamed();
 
-    void emptyFile();
-    void unnamedMesh();
-    void namedMesh();
     void moreMeshes();
-    void unnamedFirstMesh();
+
-
+    /* Technically, all invalid cases could be put into a single file, but
-    void wrongFloat();
+       because the indexing is global, it would get increasingly hard to
-    void wrongInteger();
+       maintain. So it's instead grouped into files by a common error scenario
-    void unmergedIndexOutOfRange();
+       with each case testing one file and just the invalid() case testing
-    void mergedIndexOutOfRange();
+       separate files. */
-    void zeroIndex();
+    void invalid();
-
+    void invalidNumbers();
-    void explicitOptionalPositionCoordinate();
+    void invalidNumberCount();
-    void explicitOptionalTextureCoordinate();
+    void invalidInconsistentIndexTuple();
-    void unsupportedOptionalPositionCoordinate();
+    void invalidIncompleteData();
-    void unsupportedOptionalTextureCoordinate();
+    void invalidOptionalCoordinate();
-
-    void shortFloatData();
-    void longFloatData();
-    void longOptionalFloatData();
-
-    void longIndexData();
-    void wrongPointIndexData();
-    void wrongLineIndexData();
-    void wrongTriangleIndexData();
-    void polygonIndexData();
-
-    void missingPositionData();
-    void missingNormalData();
-    void missingTextureCoordinateData();
-    void missingPositionIndices();
-    void missingNormalIndices();
-    void missingTextureCoordinateIndices();
-
-    void wrongTextureCoordinateIndexCount();
-    void wrongNormalIndexCount();
-
-    void unsupportedKeyword();
-    void unknownKeyword();
 
     void openTwice();
     void importTwice();
@@ -100,58 +83,109 @@ struct ObjImporterTest: TestSuite::Tester {
     PluginManager::Manager<AbstractImporter> _manager{"nonexistent"};
 };
 
+const struct {
+    const char* name;
+    const char* filename;
+    const char* message;
+} InvalidData[]{
+    {"mixed primitives", "invalid-mixed-primitives.obj",
+        "mixed primitive MeshPrimitive::Points and MeshPrimitive::Lines"},
+    {"unknown keyword", "invalid-keyword.obj",
+        "unknown keyword bleh"}
+};
+
+const struct {
+    const char* name;
+    const char* message;
+} InvalidNumbersData[]{
+    {"WrongFloat", "error while converting numeric data"},
+    {"WrongInteger", "error while converting numeric data"},
+    {"PositionIndexOutOfRange", "index 1 out of range for 1 vertices"},
+    {"TextureIndexOutOfRange", "index 2 out of range for 1 vertices"},
+    {"ZeroIndex", "index 0 out of range for 1 vertices"}
+};
+
+const struct {
+    const char* name;
+    const char* message;
+} InvalidNumberCountData[]{
+    {"ShortFloat", "invalid float array size"},
+    {"LongFloat", "invalid float array size"},
+    {"LongOptionalFloat", "invalid float array size"},
+    {"InvalidIndices", "invalid index data"},
+    {"WrongPointIndices", "wrong index count for point"},
+    {"WrongLineIndices", "wrong index count for line"},
+    {"WrongTriangleIndices", "wrong index count for triangle"},
+    {"PolygonIndices", "polygons are not supported"}
+};
+
+const struct {
+    const char* name;
+    const char* message;
+} InvalidInconsistentIndexTupleData[]{
+    {"ShortNormalIndices", "some normal indices are missing"},
+    {"ShortTextureIndices", "some texture coordinate indices are missing"},
+};
+
+const struct {
+    const char* name;
+    const char* message;
+} InvalidIncompleteDataData[]{
+    {"MissingPositionData", "incomplete position data"},
+    {"MissingPositionIndices", "incomplete position data"},
+    {"MissingNormalData", "incomplete normal data"},
+    {"MissingNormalIndices", "incomplete normal data"},
+    {"MissingTextureData", "incomplete texture coordinate data"},
+    {"MissingTextureIndices", "incomplete texture coordinate data"},
+};
+
+const struct {
+    const char* name;
+    const char* message;
+} InvalidOptionalCoordinateData[]{
+    {"UnsupportedPositionW", "homogeneous coordinates are not supported"},
+    {"UnsupportedTextureW", "3D texture coordinates are not supported"}
+};
+
 ObjImporterTest::ObjImporterTest() {
-    addTests({&ObjImporterTest::pointMesh,
+    addTests({&ObjImporterTest::empty,
-              &ObjImporterTest::lineMesh,
+
-              &ObjImporterTest::triangleMesh,
+              &ObjImporterTest::meshPrimitivePoints,
-              &ObjImporterTest::mixedPrimitives,
+              &ObjImporterTest::meshPrimitiveLines,
-
+              &ObjImporterTest::meshPrimitiveTriangles,
-              &ObjImporterTest::positionsOnly,
+
-              &ObjImporterTest::textureCoordinates,
+              &ObjImporterTest::meshPositionsOptionalCoordinate,
-              &ObjImporterTest::normals,
+              &ObjImporterTest::meshTextureCoordinates,
-              &ObjImporterTest::textureCoordinatesNormals,
+              &ObjImporterTest::meshTextureCoordinatesOptionalCoordinate,
-
+              &ObjImporterTest::meshNormals,
-              &ObjImporterTest::emptyFile,
+              &ObjImporterTest::meshTextureCoordinatesNormals,
-              &ObjImporterTest::unnamedMesh,
+
-              &ObjImporterTest::namedMesh,
+              &ObjImporterTest::meshIgnoredKeyword,
-              &ObjImporterTest::moreMeshes,
+
-              &ObjImporterTest::unnamedFirstMesh,
+              &ObjImporterTest::meshNamed,
-
+              &ObjImporterTest::meshNamedFirstUnnamed,
-              &ObjImporterTest::wrongFloat,
+
-              &ObjImporterTest::wrongInteger,
+              &ObjImporterTest::moreMeshes});
-              &ObjImporterTest::unmergedIndexOutOfRange,
+
-              &ObjImporterTest::mergedIndexOutOfRange,
+    addInstancedTests({&ObjImporterTest::invalid},
-              &ObjImporterTest::zeroIndex,
+        Containers::arraySize(InvalidData));
-
+
-              &ObjImporterTest::explicitOptionalPositionCoordinate,
+    addInstancedTests({&ObjImporterTest::invalidNumbers},
-              &ObjImporterTest::explicitOptionalTextureCoordinate,
+        Containers::arraySize(InvalidNumbersData));
-              &ObjImporterTest::unsupportedOptionalPositionCoordinate,
+
-              &ObjImporterTest::unsupportedOptionalTextureCoordinate,
+    addInstancedTests({&ObjImporterTest::invalidNumberCount},
-
+        Containers::arraySize(InvalidNumberCountData));
-              &ObjImporterTest::shortFloatData,
+
-              &ObjImporterTest::longFloatData,
+    addInstancedTests({&ObjImporterTest::invalidInconsistentIndexTuple},
-              &ObjImporterTest::longOptionalFloatData,
+        Containers::arraySize(InvalidInconsistentIndexTupleData));
-
+
-              &ObjImporterTest::longIndexData,
+    addInstancedTests({&ObjImporterTest::invalidIncompleteData},
-              &ObjImporterTest::wrongPointIndexData,
+        Containers::arraySize(InvalidIncompleteDataData));
-              &ObjImporterTest::wrongLineIndexData,
+
-              &ObjImporterTest::wrongTriangleIndexData,
+    addInstancedTests({&ObjImporterTest::invalidOptionalCoordinate},
-              &ObjImporterTest::polygonIndexData,
+        Containers::arraySize(InvalidOptionalCoordinateData));
-
+
-              &ObjImporterTest::missingPositionData,
+    addTests({&ObjImporterTest::openTwice,
-              &ObjImporterTest::missingNormalData,
-              &ObjImporterTest::missingTextureCoordinateData,
-              &ObjImporterTest::missingPositionIndices,
-              &ObjImporterTest::missingNormalIndices,
-              &ObjImporterTest::missingTextureCoordinateIndices,
-
-              &ObjImporterTest::wrongTextureCoordinateIndexCount,
-              &ObjImporterTest::wrongNormalIndexCount,
-
-              &ObjImporterTest::unsupportedKeyword,
-              &ObjImporterTest::unknownKeyword,
-
-              &ObjImporterTest::openTwice,
               &ObjImporterTest::importTwice});
 
     #ifdef OBJIMPORTER_PLUGIN_FILENAME
@@ -159,9 +193,25 @@ ObjImporterTest::ObjImporterTest() {
     #endif
 }
 
-void ObjImporterTest::pointMesh() {
+void ObjImporterTest::empty() {
+    /* Duplicates what's in invalidIncompleteData(MissingPositionData), but
+       it's good to have such case explicit. It also tests for empty naming. */
+
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "empty.obj")));
+    CORRADE_COMPARE(importer->meshCount(), 1);
+    CORRADE_COMPARE(importer->meshName(0), "");
+    CORRADE_COMPARE(importer->meshForName(""), -1);
+
+    std::ostringstream out;
+    Error redirectError{&out};
+    CORRADE_VERIFY(!importer->mesh(0));
+    CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh(): incomplete position data\n");
+}
+
+void ObjImporterTest::meshPrimitivePoints() {
     Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "pointMesh.obj")));
+    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "mesh-primitive-points.obj")));
     CORRADE_COMPARE(importer->meshCount(), 1);
 
     const Containers::Optional<MeshData> data = importer->mesh(0);
@@ -183,9 +233,9 @@ void ObjImporterTest::pointMesh() {
         TestSuite::Compare::Container);
 }
 
-void ObjImporterTest::lineMesh() {
+void ObjImporterTest::meshPrimitiveLines() {
     Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "lineMesh.obj")));
+    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "mesh-primitive-lines.obj")));
     CORRADE_COMPARE(importer->meshCount(), 1);
 
     const Containers::Optional<MeshData> data = importer->mesh(0);
@@ -205,9 +255,9 @@ void ObjImporterTest::lineMesh() {
         TestSuite::Compare::Container);
 }
 
-void ObjImporterTest::triangleMesh() {
+void ObjImporterTest::meshPrimitiveTriangles() {
     Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "triangleMesh.obj")));
+    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "mesh-primitive-triangles.obj")));
     CORRADE_COMPARE(importer->meshCount(), 1);
 
     const Containers::Optional<MeshData> data = importer->mesh(0);
@@ -228,31 +278,23 @@ void ObjImporterTest::triangleMesh() {
         TestSuite::Compare::Container);
 }
 
-void ObjImporterTest::mixedPrimitives() {
+void ObjImporterTest::meshPositionsOptionalCoordinate() {
-    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "mixedPrimitives.obj")));
-    CORRADE_COMPARE(importer->meshCount(), 1);
-
-    std::ostringstream out;
-    Error redirectError{&out};
-    CORRADE_VERIFY(!importer->mesh(0));
-    CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh(): mixed primitive MeshPrimitive::Points and MeshPrimitive::Lines\n");
-}
-
-void ObjImporterTest::positionsOnly() {
     Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "triangleMesh.obj")));
+    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "mesh-positions-optional-coordinate.obj")));
     CORRADE_COMPARE(importer->meshCount(), 1);
 
     const Containers::Optional<MeshData> data = importer->mesh(0);
     CORRADE_VERIFY(data);
     CORRADE_COMPARE(data->attributeCount(), 1);
-    CORRADE_VERIFY(data->hasAttribute(MeshAttribute::Position));
+    CORRADE_COMPARE_AS(data->attribute<Vector3>(MeshAttribute::Position),
+        Containers::arrayView<Vector3>({
+            {1.5f, 2.0f, 3.0f}
+        }), TestSuite::Compare::Container);
 }
 
-void ObjImporterTest::textureCoordinates() {
+void ObjImporterTest::meshTextureCoordinates() {
     Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "textureCoordinates.obj")));
+    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "mesh-texture-coordinates.obj")));
     CORRADE_COMPARE(importer->meshCount(), 1);
 
     const Containers::Optional<MeshData> data = importer->mesh(0);
@@ -280,9 +322,23 @@ void ObjImporterTest::textureCoordinates() {
         TestSuite::Compare::Container);
 }
 
-void ObjImporterTest::normals() {
+void ObjImporterTest::meshTextureCoordinatesOptionalCoordinate() {
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "mesh-texture-coordinates-optional-coordinate.obj")));
+    CORRADE_COMPARE(importer->meshCount(), 1);
+
+    const Containers::Optional<MeshData> data = importer->mesh(0);
+    CORRADE_VERIFY(data);
+    CORRADE_COMPARE(data->attributeCount(MeshAttribute::TextureCoordinates), 1);
+    CORRADE_COMPARE_AS(data->attribute<Vector2>(MeshAttribute::TextureCoordinates),
+        Containers::arrayView<Vector2>({
+            {0.5f, 0.7f}
+        }), TestSuite::Compare::Container);
+}
+
+void ObjImporterTest::meshNormals() {
     Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "normals.obj")));
+    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "mesh-normals.obj")));
     CORRADE_COMPARE(importer->meshCount(), 1);
 
     const Containers::Optional<MeshData> data = importer->mesh(0);
@@ -310,9 +366,9 @@ void ObjImporterTest::normals() {
         TestSuite::Compare::Container);
 }
 
-void ObjImporterTest::textureCoordinatesNormals() {
+void ObjImporterTest::meshTextureCoordinatesNormals() {
     Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "textureCoordinatesNormals.obj")));
+    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "mesh-texture-coordinates-normals.obj")));
     CORRADE_COMPARE(importer->meshCount(), 1);
 
     const Containers::Optional<MeshData> data = importer->mesh(0);
@@ -350,31 +406,50 @@ void ObjImporterTest::textureCoordinatesNormals() {
         TestSuite::Compare::Container);
 }
 
-void ObjImporterTest::emptyFile() {
+void ObjImporterTest::meshIgnoredKeyword() {
     Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "emptyFile.obj")));
+    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "mesh-ignored-keyword.obj")));
     CORRADE_COMPARE(importer->meshCount(), 1);
-}
 
-void ObjImporterTest::unnamedMesh() {
+    /* Everything should be parsed properly */
-    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    const Containers::Optional<MeshData> data = importer->mesh(0);
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "emptyFile.obj")));
+    CORRADE_VERIFY(data);
-    CORRADE_COMPARE(importer->meshCount(), 1);
+    CORRADE_COMPARE(data->primitive(), MeshPrimitive::Points);
-    CORRADE_COMPARE(importer->meshName(0), "");
+    CORRADE_COMPARE(data->attributeCount(), 1);
-    CORRADE_COMPARE(importer->meshForName(""), -1);
+    CORRADE_COMPARE_AS(data->attribute<Vector3>(MeshAttribute::Position),
+        Containers::arrayView<Vector3>({
+            {0.0f, 1.0f, 2.0f}
+        }), TestSuite::Compare::Container);
+    CORRADE_VERIFY(data->isIndexed());
+    CORRADE_COMPARE(data->indexType(), MeshIndexType::UnsignedInt);
+    CORRADE_COMPARE_AS(data->indices<UnsignedInt>(),
+        Containers::arrayView<UnsignedInt>({0}),
+        TestSuite::Compare::Container);
 }
 
-void ObjImporterTest::namedMesh() {
+void ObjImporterTest::meshNamed() {
     Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "namedMesh.obj")));
+    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "mesh-named.obj")));
     CORRADE_COMPARE(importer->meshCount(), 1);
     CORRADE_COMPARE(importer->meshName(0), "MyMesh");
     CORRADE_COMPARE(importer->meshForName("MyMesh"), 0);
 }
 
+void ObjImporterTest::meshNamedFirstUnnamed() {
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "mesh-named-first-unnamed.obj")));
+    CORRADE_COMPARE(importer->meshCount(), 2);
+
+    CORRADE_COMPARE(importer->meshName(0), "");
+    CORRADE_COMPARE(importer->meshForName(""), -1);
+
+    CORRADE_COMPARE(importer->meshName(1), "SecondMesh");
+    CORRADE_COMPARE(importer->meshForName("SecondMesh"), 1);
+}
+
 void ObjImporterTest::moreMeshes() {
     Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "moreMeshes.obj")));
+    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "mesh-multiple.obj")));
     CORRADE_COMPARE(importer->meshCount(), 3);
 
     CORRADE_COMPARE(importer->meshName(0), "PointMesh");
@@ -452,370 +527,113 @@ void ObjImporterTest::moreMeshes() {
         TestSuite::Compare::Container);
 }
 
-void ObjImporterTest::unnamedFirstMesh() {
+void ObjImporterTest::invalid() {
-    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    auto&& data = InvalidData[testCaseInstanceId()];
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "unnamedFirstMesh.obj")));
+    setTestCaseDescription(data.name);
-    CORRADE_COMPARE(importer->meshCount(), 2);
-
-    CORRADE_COMPARE(importer->meshName(0), "");
-    CORRADE_COMPARE(importer->meshForName(""), -1);
-
-    CORRADE_COMPARE(importer->meshName(1), "SecondMesh");
-    CORRADE_COMPARE(importer->meshForName("SecondMesh"), 1);
-}
-
-void ObjImporterTest::wrongFloat() {
-    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "wrongNumbers.obj")));
-    const Int id = importer->meshForName("WrongFloat");
-    CORRADE_VERIFY(id > -1);
-
-    std::ostringstream out;
-    Error redirectError{&out};
-    CORRADE_VERIFY(!importer->mesh(id));
-    CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh(): error while converting numeric data\n");
-}
-
-void ObjImporterTest::wrongInteger() {
-    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "wrongNumbers.obj")));
-    const Int id = importer->meshForName("WrongInteger");
-    CORRADE_VERIFY(id > -1);
-
-    std::ostringstream out;
-    Error redirectError{&out};
-    CORRADE_VERIFY(!importer->mesh(id));
-    CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh(): error while converting numeric data\n");
-}
-
-void ObjImporterTest::unmergedIndexOutOfRange() {
-    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "wrongNumbers.obj")));
-    const Int id = importer->meshForName("PositionIndexOutOfRange");
-    CORRADE_VERIFY(id > -1);
-
-    std::ostringstream out;
-    Error redirectError{&out};
-    CORRADE_VERIFY(!importer->mesh(id));
-    CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh(): index 1 out of range for 1 vertices\n");
-}
-
-void ObjImporterTest::mergedIndexOutOfRange() {
-    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "wrongNumbers.obj")));
-    const Int id = importer->meshForName("TextureIndexOutOfRange");
-    CORRADE_VERIFY(id > -1);
-
-    std::ostringstream out;
-    Error redirectError{&out};
-    CORRADE_VERIFY(!importer->mesh(id));
-    CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh(): index 2 out of range for 1 vertices\n");
-}
-
-void ObjImporterTest::zeroIndex() {
-    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "wrongNumbers.obj")));
-    const Int id = importer->meshForName("ZeroIndex");
-    CORRADE_VERIFY(id > -1);
-
-    std::ostringstream out;
-    Error redirectError{&out};
-    CORRADE_VERIFY(!importer->mesh(id));
-    CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh(): index 0 out of range for 1 vertices\n");
-}
-
-void ObjImporterTest::explicitOptionalPositionCoordinate() {
-    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "optionalCoordinates.obj")));
-    const Int id = importer->meshForName("SupportedPositionW");
-    CORRADE_VERIFY(id > -1);
-
-    const Containers::Optional<MeshData> data = importer->mesh(id);
-    CORRADE_VERIFY(data);
-    CORRADE_COMPARE(data->attributeCount(), 1);
-    CORRADE_COMPARE_AS(data->attribute<Vector3>(MeshAttribute::Position),
-        Containers::arrayView<Vector3>({
-            {1.5f, 2.0f, 3.0f}
-        }), TestSuite::Compare::Container);
-}
-
-void ObjImporterTest::explicitOptionalTextureCoordinate() {
-    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "optionalCoordinates.obj")));
-    const Int id = importer->meshForName("SupportedTextureW");
-    CORRADE_VERIFY(id > -1);
-
-    const Containers::Optional<MeshData> data = importer->mesh(id);
-    CORRADE_VERIFY(data);
-    CORRADE_COMPARE(data->attributeCount(MeshAttribute::TextureCoordinates), 1);
-    CORRADE_COMPARE_AS(data->attribute<Vector2>(MeshAttribute::TextureCoordinates),
-        Containers::arrayView<Vector2>({
-            {0.5f, 0.7f}
-        }), TestSuite::Compare::Container);
-}
-
-void ObjImporterTest::unsupportedOptionalPositionCoordinate() {
-    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "optionalCoordinates.obj")));
-    const Int id = importer->meshForName("UnsupportedPositionW");
-    CORRADE_VERIFY(id > -1);
-
-    std::ostringstream out;
-    Error redirectError{&out};
-    CORRADE_VERIFY(!importer->mesh(id));
-    CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh(): homogeneous coordinates are not supported\n");
-}
-
-void ObjImporterTest::unsupportedOptionalTextureCoordinate() {
-    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "optionalCoordinates.obj")));
-    const Int id = importer->meshForName("UnsupportedTextureW");
-    CORRADE_VERIFY(id > -1);
-
-    std::ostringstream out;
-    Error redirectError{&out};
-    CORRADE_VERIFY(!importer->mesh(id));
-    CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh(): 3D texture coordinates are not supported\n");
-}
-
-void ObjImporterTest::shortFloatData() {
-    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "wrongNumberCount.obj")));
-    const Int id = importer->meshForName("ShortFloat");
-    CORRADE_VERIFY(id > -1);
-
-    std::ostringstream out;
-    Error redirectError{&out};
-    CORRADE_VERIFY(!importer->mesh(id));
-    CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh(): invalid float array size\n");
-}
 
-void ObjImporterTest::longFloatData() {
     Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "wrongNumberCount.obj")));
+    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, data.filename)));
-    const Int id = importer->meshForName("LongFloat");
-    CORRADE_VERIFY(id > -1);
 
-    std::ostringstream out;
+    CORRADE_COMPARE(importer->meshCount(), 1);
-    Error redirectError{&out};
-    CORRADE_VERIFY(!importer->mesh(id));
-    CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh(): invalid float array size\n");
-}
-
-void ObjImporterTest::longOptionalFloatData() {
-    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "wrongNumberCount.obj")));
-    const Int id = importer->meshForName("LongOptionalFloat");
-    CORRADE_VERIFY(id > -1);
 
     std::ostringstream out;
     Error redirectError{&out};
-    CORRADE_VERIFY(!importer->mesh(id));
+    CORRADE_VERIFY(!importer->mesh(0));
-    CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh(): invalid float array size\n");
+    CORRADE_COMPARE(out.str(), Utility::formatString("Trade::ObjImporter::mesh(): {}\n", data.message));
 }
 
-void ObjImporterTest::longIndexData() {
+void ObjImporterTest::invalidNumbers() {
-    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    auto&& data = InvalidNumbersData[testCaseInstanceId()];
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "wrongNumberCount.obj")));
+    setTestCaseDescription(data.name);
-    const Int id = importer->meshForName("InvalidIndices");
-    CORRADE_VERIFY(id > -1);
-
-    std::ostringstream out;
-    Error redirectError{&out};
-    CORRADE_VERIFY(!importer->mesh(id));
-    CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh(): invalid index data\n");
-}
 
-void ObjImporterTest::wrongPointIndexData() {
     Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "wrongNumberCount.obj")));
+    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "invalid-numbers.obj")));
-    const Int id = importer->meshForName("WrongPointIndices");
-    CORRADE_VERIFY(id > -1);
-
-    std::ostringstream out;
-    Error redirectError{&out};
-    CORRADE_VERIFY(!importer->mesh(id));
-    CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh(): wrong index count for point\n");
-}
 
-void ObjImporterTest::wrongLineIndexData() {
+    /* Ensure we didn't forget to test any case */
-    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_COMPARE(importer->meshCount(), Containers::arraySize(InvalidNumbersData));
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "wrongNumberCount.obj")));
-    const Int id = importer->meshForName("WrongLineIndices");
-    CORRADE_VERIFY(id > -1);
 
     std::ostringstream out;
     Error redirectError{&out};
-    CORRADE_VERIFY(!importer->mesh(id));
+    CORRADE_VERIFY(!importer->mesh(data.name));
-    CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh(): wrong index count for line\n");
+    CORRADE_COMPARE(out.str(), Utility::formatString("Trade::ObjImporter::mesh(): {}\n", data.message));
 }
 
-void ObjImporterTest::wrongTriangleIndexData() {
+void ObjImporterTest::invalidNumberCount() {
-    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    auto&& data = InvalidNumberCountData[testCaseInstanceId()];
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "wrongNumberCount.obj")));
+    setTestCaseDescription(data.name);
-    const Int id = importer->meshForName("WrongTriangleIndices");
-    CORRADE_VERIFY(id > -1);
 
-    std::ostringstream out;
-    Error redirectError{&out};
-    CORRADE_VERIFY(!importer->mesh(id));
-    CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh(): wrong index count for triangle\n");
-}
-
-void ObjImporterTest::polygonIndexData() {
     Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "wrongNumberCount.obj")));
+    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "invalid-number-count.obj")));
-    const Int id = importer->meshForName("PolygonIndices");
-    CORRADE_VERIFY(id > -1);
-
-    std::ostringstream out;
-    Error redirectError{&out};
-    CORRADE_VERIFY(!importer->mesh(id));
-    CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh(): polygons are not supported\n");
-}
 
-void ObjImporterTest::missingPositionData() {
+    /* Ensure we didn't forget to test any case */
-    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_COMPARE(importer->meshCount(), Containers::arraySize(InvalidNumberCountData));
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "missingData.obj")));
-    const Int id = importer->meshForName("MissingPositionData");
-    CORRADE_VERIFY(id > -1);
 
     std::ostringstream out;
     Error redirectError{&out};
-    CORRADE_VERIFY(!importer->mesh(id));
+    CORRADE_VERIFY(!importer->mesh(data.name));
-    CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh(): incomplete position data\n");
+    CORRADE_COMPARE(out.str(), Utility::formatString("Trade::ObjImporter::mesh(): {}\n", data.message));
 }
 
-void ObjImporterTest::missingPositionIndices() {
+void ObjImporterTest::invalidInconsistentIndexTuple() {
-    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    auto&& data = InvalidInconsistentIndexTupleData[testCaseInstanceId()];
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "missingData.obj")));
+    setTestCaseDescription(data.name);
-    const Int id = importer->meshForName("MissingPositionIndices");
-    CORRADE_VERIFY(id > -1);
 
-    std::ostringstream out;
-    Error redirectError{&out};
-    CORRADE_VERIFY(!importer->mesh(id));
-    CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh(): incomplete position data\n");
-}
-
-void ObjImporterTest::missingNormalData() {
     Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "missingData.obj")));
+    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "invalid-inconsistent-index-tuple.obj")));
-    const Int id = importer->meshForName("MissingNormalData");
-    CORRADE_VERIFY(id > -1);
 
-    std::ostringstream out;
+    /* Ensure we didn't forget to test any case */
-    Error redirectError{&out};
+    CORRADE_COMPARE(importer->meshCount(), Containers::arraySize(InvalidInconsistentIndexTupleData));
-    CORRADE_VERIFY(!importer->mesh(id));
-    CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh(): incomplete normal data\n");
-}
-
-void ObjImporterTest::missingNormalIndices() {
-    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "missingData.obj")));
-    const Int id = importer->meshForName("MissingNormalIndices");
-    CORRADE_VERIFY(id > -1);
 
     std::ostringstream out;
     Error redirectError{&out};
-    CORRADE_VERIFY(!importer->mesh(id));
+    CORRADE_VERIFY(!importer->mesh(data.name));
-    CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh(): incomplete normal data\n");
+    CORRADE_COMPARE(out.str(), Utility::formatString("Trade::ObjImporter::mesh(): {}\n", data.message));
 }
 
-void ObjImporterTest::missingTextureCoordinateData() {
+void ObjImporterTest::invalidIncompleteData() {
-    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    auto&& data = InvalidIncompleteDataData[testCaseInstanceId()];
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "missingData.obj")));
+    setTestCaseDescription(data.name);
-    const Int id = importer->meshForName("MissingTextureData");
-    CORRADE_VERIFY(id > -1);
-
-    std::ostringstream out;
-    Error redirectError{&out};
-    CORRADE_VERIFY(!importer->mesh(id));
-    CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh(): incomplete texture coordinate data\n");
-}
 
-void ObjImporterTest::missingTextureCoordinateIndices() {
     Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "missingData.obj")));
+    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "invalid-incomplete-data.obj")));
-    const Int id = importer->meshForName("MissingTextureIndices");
-    CORRADE_VERIFY(id > -1);
 
-    std::ostringstream out;
+    /* Ensure we didn't forget to test any case */
-    Error redirectError{&out};
+    CORRADE_COMPARE(importer->meshCount(), Containers::arraySize(InvalidIncompleteDataData));
-    CORRADE_VERIFY(!importer->mesh(id));
-    CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh(): incomplete texture coordinate data\n");
-}
-
-void ObjImporterTest::wrongNormalIndexCount() {
-    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "wrongIndexCount.obj")));
-    const Int id = importer->meshForName("ShortNormalIndices");
-    CORRADE_VERIFY(id > -1);
 
     std::ostringstream out;
     Error redirectError{&out};
-    CORRADE_VERIFY(!importer->mesh(id));
+    CORRADE_VERIFY(!importer->mesh(data.name));
-    CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh(): some normal indices are missing\n");
+    CORRADE_COMPARE(out.str(), Utility::formatString("Trade::ObjImporter::mesh(): {}\n", data.message));
 }
 
-void ObjImporterTest::wrongTextureCoordinateIndexCount() {
+void ObjImporterTest::invalidOptionalCoordinate() {
-    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    auto&& data = InvalidOptionalCoordinateData[testCaseInstanceId()];
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "wrongIndexCount.obj")));
+    setTestCaseDescription(data.name);
-    const Int id = importer->meshForName("ShortTextureIndices");
-    CORRADE_VERIFY(id > -1);
 
-    std::ostringstream out;
-    Error redirectError{&out};
-    CORRADE_VERIFY(!importer->mesh(id));
-    CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh(): some texture coordinate indices are missing\n");
-}
-
-void ObjImporterTest::unsupportedKeyword() {
     Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "keywords.obj")));
+    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "invalid-optional-coordinate.obj")));
-    const Int id = importer->meshForName("UnsupportedKeyword");
-    CORRADE_VERIFY(id > -1);
-
-    /* Everything should be parsed properly */
-    const Containers::Optional<MeshData> data = importer->mesh(id);
-    CORRADE_VERIFY(data);
-    CORRADE_COMPARE(data->primitive(), MeshPrimitive::Points);
-    CORRADE_COMPARE(data->attributeCount(), 1);
-    CORRADE_COMPARE_AS(data->attribute<Vector3>(MeshAttribute::Position),
-        Containers::arrayView<Vector3>({
-            {0.0f, 1.0f, 2.0f}
-        }), TestSuite::Compare::Container);
-    CORRADE_VERIFY(data->isIndexed());
-    CORRADE_COMPARE(data->indexType(), MeshIndexType::UnsignedInt);
-    CORRADE_COMPARE_AS(data->indices<UnsignedInt>(),
-        Containers::arrayView<UnsignedInt>({0}),
-        TestSuite::Compare::Container);
-}
 
-void ObjImporterTest::unknownKeyword() {
+    /* Ensure we didn't forget to test any case */
-    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_COMPARE(importer->meshCount(), Containers::arraySize(InvalidOptionalCoordinateData));
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "keywords.obj")));
-    const Int id = importer->meshForName("UnknownKeyword");
-    CORRADE_VERIFY(id > -1);
 
     std::ostringstream out;
     Error redirectError{&out};
-    CORRADE_VERIFY(!importer->mesh(id));
+    CORRADE_VERIFY(!importer->mesh(data.name));
-    CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh(): unknown keyword bleh\n");
+    CORRADE_COMPARE(out.str(), Utility::formatString("Trade::ObjImporter::mesh(): {}\n", data.message));
 }
 
 void ObjImporterTest::openTwice() {
     Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
 
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "pointMesh.obj")));
+    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "mesh-primitive-points.obj")));
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "pointMesh.obj")));
+    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "mesh-primitive-points.obj")));
 
     /* Shouldn't crash, leak or anything */
 }
 
 void ObjImporterTest::importTwice() {
     Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "pointMesh.obj")));
+    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "mesh-primitive-points.obj")));
 
     /* Verify that everything is working the same way on second use */
     {

src/MagnumPlugins/ObjImporter/Test/invalid-keyword.obj

@@ -0,0 +1 @@
+bleh

src/MagnumPlugins/ObjImporter/Test/invalid-optional-coordinate.obj

@@ -1,17 +1,8 @@
-o SupportedPositionW
-v 1.5 2 3 1.0
-p 1
-
-o SupportedTextureW
-v 1.5 2 3
-vt 0.5 0.7 0.0
-p 2/1
-
 o UnsupportedPositionW
 v 1.5 2 3 0.8
-p 3
+p 1
 
 o UnsupportedTextureW
 v 1.5 2 3
 vt 0.5 0.7 0.5
-p 4/2
+p 2/1

src/MagnumPlugins/ObjImporter/Test/keywords.obj

@@ -1,7 +0,0 @@
-o UnsupportedKeyword
-g VertexGroup
-v 0 1 2
-p 1
-
-o UnknownKeyword
-bleh

src/MagnumPlugins/ObjImporter/Test/mesh-ignored-keyword.obj

@@ -0,0 +1,3 @@
+g VertexGroup
+v 0 1 2
+p 1

src/MagnumPlugins/ObjImporter/Test/mesh-positions-optional-coordinate.obj

@@ -0,0 +1,2 @@
+v 1.5 2 3 1.0
+p 1

src/MagnumPlugins/ObjImporter/Test/mesh-texture-coordinates-optional-coordinate.obj

@@ -0,0 +1,3 @@
+v 1.5 2 3
+vt 0.5 0.7 0.0
+p 1/1