diff --git a/src/MagnumPlugins/AnySceneImporter/Test/AnySceneImporterTest.cpp b/src/MagnumPlugins/AnySceneImporter/Test/AnySceneImporterTest.cpp
index 267916528..4887ae510 100644
--- a/src/MagnumPlugins/AnySceneImporter/Test/AnySceneImporterTest.cpp
+++ b/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};
diff --git a/src/MagnumPlugins/AnySceneImporter/Test/CMakeLists.txt b/src/MagnumPlugins/AnySceneImporter/Test/CMakeLists.txt
index aba0c51ff..48a5ce9aa 100644
--- a/src/MagnumPlugins/AnySceneImporter/Test/CMakeLists.txt
+++ b/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)
diff --git a/src/MagnumPlugins/ObjImporter/Test/CMakeLists.txt b/src/MagnumPlugins/ObjImporter/Test/CMakeLists.txt
index 833f15a65..6dc2f46a9 100644
--- a/src/MagnumPlugins/ObjImporter/Test/CMakeLists.txt
+++ b/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
-        keywords.obj
-        lineMesh.obj
-        missingData.obj
-        mixedPrimitives.obj
-        moreMeshes.obj
-        namedMesh.obj
-        normals.obj
-        optionalCoordinates.obj
-        pointMesh.obj
-        textureCoordinatesNormals.obj
-        textureCoordinates.obj
-        triangleMesh.obj
-        unnamedFirstMesh.obj
-        wrongIndexCount.obj
-        wrongNumberCount.obj
-        wrongNumbers.obj)
+        empty.obj
+        invalid-incomplete-data.obj
+        invalid-inconsistent-index-tuple.obj
+        invalid-keyword.obj
+        invalid-mixed-primitives.obj
+        invalid-number-count.obj
+        invalid-numbers.obj
+        invalid-optional-coordinate.obj
+        mesh-ignored-keyword.obj
+        mesh-multiple.obj
+        mesh-named-first-unnamed.obj
+        mesh-named.obj
+        mesh-normals.obj
+        mesh-positions-optional-coordinate.obj
+        mesh-primitive-lines.obj
+        mesh-primitive-points.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)
diff --git a/src/MagnumPlugins/ObjImporter/Test/ObjImporterTest.cpp b/src/MagnumPlugins/ObjImporter/Test/ObjImporterTest.cpp
index e89db9777..08b988f7e 100644
--- a/src/MagnumPlugins/ObjImporter/Test/ObjImporterTest.cpp
+++ b/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 lineMesh();
-    void triangleMesh();
-    void mixedPrimitives();
+    void empty();
 
-    void positionsOnly();
-    void textureCoordinates();
-    void normals();
-    void textureCoordinatesNormals();
+    void meshPrimitivePoints();
+    void meshPrimitiveLines();
+    void meshPrimitiveTriangles();
+
+    /* 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();
-
-    void wrongFloat();
-    void wrongInteger();
-    void unmergedIndexOutOfRange();
-    void mergedIndexOutOfRange();
-    void zeroIndex();
-
-    void explicitOptionalPositionCoordinate();
-    void explicitOptionalTextureCoordinate();
-    void unsupportedOptionalPositionCoordinate();
-    void unsupportedOptionalTextureCoordinate();
-
-    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();
+
+    /* Technically, all invalid cases could be put into a single file, but
+       because the indexing is global, it would get increasingly hard to
+       maintain. So it's instead grouped into files by a common error scenario
+       with each case testing one file and just the invalid() case testing
+       separate files. */
+    void invalid();
+    void invalidNumbers();
+    void invalidNumberCount();
+    void invalidInconsistentIndexTuple();
+    void invalidIncompleteData();
+    void invalidOptionalCoordinate();
 
     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,
-              &ObjImporterTest::lineMesh,
-              &ObjImporterTest::triangleMesh,
-              &ObjImporterTest::mixedPrimitives,
-
-              &ObjImporterTest::positionsOnly,
-              &ObjImporterTest::textureCoordinates,
-              &ObjImporterTest::normals,
-              &ObjImporterTest::textureCoordinatesNormals,
-
-              &ObjImporterTest::emptyFile,
-              &ObjImporterTest::unnamedMesh,
-              &ObjImporterTest::namedMesh,
-              &ObjImporterTest::moreMeshes,
-              &ObjImporterTest::unnamedFirstMesh,
-
-              &ObjImporterTest::wrongFloat,
-              &ObjImporterTest::wrongInteger,
-              &ObjImporterTest::unmergedIndexOutOfRange,
-              &ObjImporterTest::mergedIndexOutOfRange,
-              &ObjImporterTest::zeroIndex,
-
-              &ObjImporterTest::explicitOptionalPositionCoordinate,
-              &ObjImporterTest::explicitOptionalTextureCoordinate,
-              &ObjImporterTest::unsupportedOptionalPositionCoordinate,
-              &ObjImporterTest::unsupportedOptionalTextureCoordinate,
-
-              &ObjImporterTest::shortFloatData,
-              &ObjImporterTest::longFloatData,
-              &ObjImporterTest::longOptionalFloatData,
-
-              &ObjImporterTest::longIndexData,
-              &ObjImporterTest::wrongPointIndexData,
-              &ObjImporterTest::wrongLineIndexData,
-              &ObjImporterTest::wrongTriangleIndexData,
-              &ObjImporterTest::polygonIndexData,
-
-              &ObjImporterTest::missingPositionData,
-              &ObjImporterTest::missingNormalData,
-              &ObjImporterTest::missingTextureCoordinateData,
-              &ObjImporterTest::missingPositionIndices,
-              &ObjImporterTest::missingNormalIndices,
-              &ObjImporterTest::missingTextureCoordinateIndices,
-
-              &ObjImporterTest::wrongTextureCoordinateIndexCount,
-              &ObjImporterTest::wrongNormalIndexCount,
-
-              &ObjImporterTest::unsupportedKeyword,
-              &ObjImporterTest::unknownKeyword,
-
-              &ObjImporterTest::openTwice,
+    addTests({&ObjImporterTest::empty,
+
+              &ObjImporterTest::meshPrimitivePoints,
+              &ObjImporterTest::meshPrimitiveLines,
+              &ObjImporterTest::meshPrimitiveTriangles,
+
+              &ObjImporterTest::meshPositionsOptionalCoordinate,
+              &ObjImporterTest::meshTextureCoordinates,
+              &ObjImporterTest::meshTextureCoordinatesOptionalCoordinate,
+              &ObjImporterTest::meshNormals,
+              &ObjImporterTest::meshTextureCoordinatesNormals,
+
+              &ObjImporterTest::meshIgnoredKeyword,
+
+              &ObjImporterTest::meshNamed,
+              &ObjImporterTest::meshNamedFirstUnnamed,
+
+              &ObjImporterTest::moreMeshes});
+
+    addInstancedTests({&ObjImporterTest::invalid},
+        Containers::arraySize(InvalidData));
+
+    addInstancedTests({&ObjImporterTest::invalidNumbers},
+        Containers::arraySize(InvalidNumbersData));
+
+    addInstancedTests({&ObjImporterTest::invalidNumberCount},
+        Containers::arraySize(InvalidNumberCountData));
+
+    addInstancedTests({&ObjImporterTest::invalidInconsistentIndexTuple},
+        Containers::arraySize(InvalidInconsistentIndexTupleData));
+
+    addInstancedTests({&ObjImporterTest::invalidIncompleteData},
+        Containers::arraySize(InvalidIncompleteDataData));
+
+    addInstancedTests({&ObjImporterTest::invalidOptionalCoordinate},
+        Containers::arraySize(InvalidOptionalCoordinateData));
+
+    addTests({&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() {
-    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() {
+void ObjImporterTest::meshPositionsOptionalCoordinate() {
     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() {
-    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "emptyFile.obj")));
-    CORRADE_COMPARE(importer->meshCount(), 1);
-    CORRADE_COMPARE(importer->meshName(0), "");
-    CORRADE_COMPARE(importer->meshForName(""), -1);
+    /* Everything should be parsed properly */
+    const Containers::Optional<MeshData> data = importer->mesh(0);
+    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::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() {
-    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "unnamedFirstMesh.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::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::invalid() {
+    auto&& data = InvalidData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
-void ObjImporterTest::longFloatData() {
     Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "wrongNumberCount.obj")));
-    const Int id = importer->meshForName("LongFloat");
-    CORRADE_VERIFY(id > -1);
+    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, data.filename)));
 
-    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::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);
+    CORRADE_COMPARE(importer->meshCount(), 1);
 
     std::ostringstream out;
     Error redirectError{&out};
-    CORRADE_VERIFY(!importer->mesh(id));
-    CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh(): invalid float array size\n");
+    CORRADE_VERIFY(!importer->mesh(0));
+    CORRADE_COMPARE(out.str(), Utility::formatString("Trade::ObjImporter::mesh(): {}\n", data.message));
 }
 
-void ObjImporterTest::longIndexData() {
-    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "wrongNumberCount.obj")));
-    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::invalidNumbers() {
+    auto&& data = InvalidNumbersData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
-void ObjImporterTest::wrongPointIndexData() {
     Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "wrongNumberCount.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");
-}
+    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "invalid-numbers.obj")));
 
-void ObjImporterTest::wrongLineIndexData() {
-    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "wrongNumberCount.obj")));
-    const Int id = importer->meshForName("WrongLineIndices");
-    CORRADE_VERIFY(id > -1);
+    /* Ensure we didn't forget to test any case */
+    CORRADE_COMPARE(importer->meshCount(), Containers::arraySize(InvalidNumbersData));
 
     std::ostringstream out;
     Error redirectError{&out};
-    CORRADE_VERIFY(!importer->mesh(id));
-    CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh(): wrong index count for line\n");
+    CORRADE_VERIFY(!importer->mesh(data.name));
+    CORRADE_COMPARE(out.str(), Utility::formatString("Trade::ObjImporter::mesh(): {}\n", data.message));
 }
 
-void ObjImporterTest::wrongTriangleIndexData() {
-    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "wrongNumberCount.obj")));
-    const Int id = importer->meshForName("WrongTriangleIndices");
-    CORRADE_VERIFY(id > -1);
+void ObjImporterTest::invalidNumberCount() {
+    auto&& data = InvalidNumberCountData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
-    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")));
-    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");
-}
+    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "invalid-number-count.obj")));
 
-void ObjImporterTest::missingPositionData() {
-    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "missingData.obj")));
-    const Int id = importer->meshForName("MissingPositionData");
-    CORRADE_VERIFY(id > -1);
+    /* Ensure we didn't forget to test any case */
+    CORRADE_COMPARE(importer->meshCount(), Containers::arraySize(InvalidNumberCountData));
 
     std::ostringstream out;
     Error redirectError{&out};
-    CORRADE_VERIFY(!importer->mesh(id));
-    CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh(): incomplete position data\n");
+    CORRADE_VERIFY(!importer->mesh(data.name));
+    CORRADE_COMPARE(out.str(), Utility::formatString("Trade::ObjImporter::mesh(): {}\n", data.message));
 }
 
-void ObjImporterTest::missingPositionIndices() {
-    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "missingData.obj")));
-    const Int id = importer->meshForName("MissingPositionIndices");
-    CORRADE_VERIFY(id > -1);
+void ObjImporterTest::invalidInconsistentIndexTuple() {
+    auto&& data = InvalidInconsistentIndexTupleData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
-    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")));
-    const Int id = importer->meshForName("MissingNormalData");
-    CORRADE_VERIFY(id > -1);
+    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "invalid-inconsistent-index-tuple.obj")));
 
-    std::ostringstream out;
-    Error redirectError{&out};
-    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);
+    /* Ensure we didn't forget to test any case */
+    CORRADE_COMPARE(importer->meshCount(), Containers::arraySize(InvalidInconsistentIndexTupleData));
 
     std::ostringstream out;
     Error redirectError{&out};
-    CORRADE_VERIFY(!importer->mesh(id));
-    CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh(): incomplete normal data\n");
+    CORRADE_VERIFY(!importer->mesh(data.name));
+    CORRADE_COMPARE(out.str(), Utility::formatString("Trade::ObjImporter::mesh(): {}\n", data.message));
 }
 
-void ObjImporterTest::missingTextureCoordinateData() {
-    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "missingData.obj")));
-    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::invalidIncompleteData() {
+    auto&& data = InvalidIncompleteDataData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
-void ObjImporterTest::missingTextureCoordinateIndices() {
     Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "missingData.obj")));
-    const Int id = importer->meshForName("MissingTextureIndices");
-    CORRADE_VERIFY(id > -1);
+    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "invalid-incomplete-data.obj")));
 
-    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::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);
+    /* Ensure we didn't forget to test any case */
+    CORRADE_COMPARE(importer->meshCount(), Containers::arraySize(InvalidIncompleteDataData));
 
     std::ostringstream out;
     Error redirectError{&out};
-    CORRADE_VERIFY(!importer->mesh(id));
-    CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh(): some normal indices are missing\n");
+    CORRADE_VERIFY(!importer->mesh(data.name));
+    CORRADE_COMPARE(out.str(), Utility::formatString("Trade::ObjImporter::mesh(): {}\n", data.message));
 }
 
-void ObjImporterTest::wrongTextureCoordinateIndexCount() {
-    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "wrongIndexCount.obj")));
-    const Int id = importer->meshForName("ShortTextureIndices");
-    CORRADE_VERIFY(id > -1);
+void ObjImporterTest::invalidOptionalCoordinate() {
+    auto&& data = InvalidOptionalCoordinateData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
-    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")));
-    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);
-}
+    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "invalid-optional-coordinate.obj")));
 
-void ObjImporterTest::unknownKeyword() {
-    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
-    CORRADE_VERIFY(importer->openFile(Utility::Path::join(OBJIMPORTER_TEST_DIR, "keywords.obj")));
-    const Int id = importer->meshForName("UnknownKeyword");
-    CORRADE_VERIFY(id > -1);
+    /* Ensure we didn't forget to test any case */
+    CORRADE_COMPARE(importer->meshCount(), Containers::arraySize(InvalidOptionalCoordinateData));
 
     std::ostringstream out;
     Error redirectError{&out};
-    CORRADE_VERIFY(!importer->mesh(id));
-    CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh(): unknown keyword bleh\n");
+    CORRADE_VERIFY(!importer->mesh(data.name));
+    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, "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, "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 */
     {
diff --git a/src/MagnumPlugins/ObjImporter/Test/emptyFile.obj b/src/MagnumPlugins/ObjImporter/Test/empty.obj
similarity index 100%
rename from src/MagnumPlugins/ObjImporter/Test/emptyFile.obj
rename to src/MagnumPlugins/ObjImporter/Test/empty.obj
diff --git a/src/MagnumPlugins/ObjImporter/Test/missingData.obj b/src/MagnumPlugins/ObjImporter/Test/invalid-incomplete-data.obj
similarity index 100%
rename from src/MagnumPlugins/ObjImporter/Test/missingData.obj
rename to src/MagnumPlugins/ObjImporter/Test/invalid-incomplete-data.obj
diff --git a/src/MagnumPlugins/ObjImporter/Test/wrongIndexCount.obj b/src/MagnumPlugins/ObjImporter/Test/invalid-inconsistent-index-tuple.obj
similarity index 100%
rename from src/MagnumPlugins/ObjImporter/Test/wrongIndexCount.obj
rename to src/MagnumPlugins/ObjImporter/Test/invalid-inconsistent-index-tuple.obj
diff --git a/src/MagnumPlugins/ObjImporter/Test/invalid-keyword.obj b/src/MagnumPlugins/ObjImporter/Test/invalid-keyword.obj
new file mode 100644
index 000000000..3149e4c0a
--- /dev/null
+++ b/src/MagnumPlugins/ObjImporter/Test/invalid-keyword.obj
@@ -0,0 +1 @@
+bleh
diff --git a/src/MagnumPlugins/ObjImporter/Test/mixedPrimitives.obj b/src/MagnumPlugins/ObjImporter/Test/invalid-mixed-primitives.obj
similarity index 100%
rename from src/MagnumPlugins/ObjImporter/Test/mixedPrimitives.obj
rename to src/MagnumPlugins/ObjImporter/Test/invalid-mixed-primitives.obj
diff --git a/src/MagnumPlugins/ObjImporter/Test/wrongNumberCount.obj b/src/MagnumPlugins/ObjImporter/Test/invalid-number-count.obj
similarity index 100%
rename from src/MagnumPlugins/ObjImporter/Test/wrongNumberCount.obj
rename to src/MagnumPlugins/ObjImporter/Test/invalid-number-count.obj
diff --git a/src/MagnumPlugins/ObjImporter/Test/wrongNumbers.obj b/src/MagnumPlugins/ObjImporter/Test/invalid-numbers.obj
similarity index 100%
rename from src/MagnumPlugins/ObjImporter/Test/wrongNumbers.obj
rename to src/MagnumPlugins/ObjImporter/Test/invalid-numbers.obj
diff --git a/src/MagnumPlugins/ObjImporter/Test/optionalCoordinates.obj b/src/MagnumPlugins/ObjImporter/Test/invalid-optional-coordinate.obj
similarity index 50%
rename from src/MagnumPlugins/ObjImporter/Test/optionalCoordinates.obj
rename to src/MagnumPlugins/ObjImporter/Test/invalid-optional-coordinate.obj
index 7e9132465..205e2fef1 100644
--- a/src/MagnumPlugins/ObjImporter/Test/optionalCoordinates.obj
+++ b/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
diff --git a/src/MagnumPlugins/ObjImporter/Test/keywords.obj b/src/MagnumPlugins/ObjImporter/Test/keywords.obj
deleted file mode 100644
index c93dce27f..000000000
--- a/src/MagnumPlugins/ObjImporter/Test/keywords.obj
+++ /dev/null
@@ -1,7 +0,0 @@
-o UnsupportedKeyword
-g VertexGroup
-v 0 1 2
-p 1
-
-o UnknownKeyword
-bleh
diff --git a/src/MagnumPlugins/ObjImporter/Test/mesh-ignored-keyword.obj b/src/MagnumPlugins/ObjImporter/Test/mesh-ignored-keyword.obj
new file mode 100644
index 000000000..b0ccfc957
--- /dev/null
+++ b/src/MagnumPlugins/ObjImporter/Test/mesh-ignored-keyword.obj
@@ -0,0 +1,3 @@
+g VertexGroup
+v 0 1 2
+p 1
diff --git a/src/MagnumPlugins/ObjImporter/Test/moreMeshes.obj b/src/MagnumPlugins/ObjImporter/Test/mesh-multiple.obj
similarity index 100%
rename from src/MagnumPlugins/ObjImporter/Test/moreMeshes.obj
rename to src/MagnumPlugins/ObjImporter/Test/mesh-multiple.obj
diff --git a/src/MagnumPlugins/ObjImporter/Test/unnamedFirstMesh.obj b/src/MagnumPlugins/ObjImporter/Test/mesh-named-first-unnamed.obj
similarity index 100%
rename from src/MagnumPlugins/ObjImporter/Test/unnamedFirstMesh.obj
rename to src/MagnumPlugins/ObjImporter/Test/mesh-named-first-unnamed.obj
diff --git a/src/MagnumPlugins/ObjImporter/Test/namedMesh.obj b/src/MagnumPlugins/ObjImporter/Test/mesh-named.obj
similarity index 100%
rename from src/MagnumPlugins/ObjImporter/Test/namedMesh.obj
rename to src/MagnumPlugins/ObjImporter/Test/mesh-named.obj
diff --git a/src/MagnumPlugins/ObjImporter/Test/normals.obj b/src/MagnumPlugins/ObjImporter/Test/mesh-normals.obj
similarity index 100%
rename from src/MagnumPlugins/ObjImporter/Test/normals.obj
rename to src/MagnumPlugins/ObjImporter/Test/mesh-normals.obj
diff --git a/src/MagnumPlugins/ObjImporter/Test/mesh-positions-optional-coordinate.obj b/src/MagnumPlugins/ObjImporter/Test/mesh-positions-optional-coordinate.obj
new file mode 100644
index 000000000..b6c111625
--- /dev/null
+++ b/src/MagnumPlugins/ObjImporter/Test/mesh-positions-optional-coordinate.obj
@@ -0,0 +1,2 @@
+v 1.5 2 3 1.0
+p 1
diff --git a/src/MagnumPlugins/ObjImporter/Test/lineMesh.obj b/src/MagnumPlugins/ObjImporter/Test/mesh-primitive-lines.obj
similarity index 100%
rename from src/MagnumPlugins/ObjImporter/Test/lineMesh.obj
rename to src/MagnumPlugins/ObjImporter/Test/mesh-primitive-lines.obj
diff --git a/src/MagnumPlugins/ObjImporter/Test/pointMesh.obj b/src/MagnumPlugins/ObjImporter/Test/mesh-primitive-points.obj
similarity index 100%
rename from src/MagnumPlugins/ObjImporter/Test/pointMesh.obj
rename to src/MagnumPlugins/ObjImporter/Test/mesh-primitive-points.obj
diff --git a/src/MagnumPlugins/ObjImporter/Test/triangleMesh.obj b/src/MagnumPlugins/ObjImporter/Test/mesh-primitive-triangles.obj
similarity index 100%
rename from src/MagnumPlugins/ObjImporter/Test/triangleMesh.obj
rename to src/MagnumPlugins/ObjImporter/Test/mesh-primitive-triangles.obj
diff --git a/src/MagnumPlugins/ObjImporter/Test/textureCoordinatesNormals.obj b/src/MagnumPlugins/ObjImporter/Test/mesh-texture-coordinates-normals.obj
similarity index 100%
rename from src/MagnumPlugins/ObjImporter/Test/textureCoordinatesNormals.obj
rename to src/MagnumPlugins/ObjImporter/Test/mesh-texture-coordinates-normals.obj
diff --git a/src/MagnumPlugins/ObjImporter/Test/mesh-texture-coordinates-optional-coordinate.obj b/src/MagnumPlugins/ObjImporter/Test/mesh-texture-coordinates-optional-coordinate.obj
new file mode 100644
index 000000000..82933e5dc
--- /dev/null
+++ b/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
diff --git a/src/MagnumPlugins/ObjImporter/Test/textureCoordinates.obj b/src/MagnumPlugins/ObjImporter/Test/mesh-texture-coordinates.obj
similarity index 100%
rename from src/MagnumPlugins/ObjImporter/Test/textureCoordinates.obj
rename to src/MagnumPlugins/ObjImporter/Test/mesh-texture-coordinates.obj