Text,Trade: properly test that close() is called from open*().

This was apparently never tested, so accidentally omitting the close()
call during a refactor wouldn't trigger any test failure until
accidental discovery months later. 100% coverage and yet.

src/Magnum/Text/Test/AbstractFontTest.cpp

@@ -196,6 +196,17 @@ struct AbstractFontTest: TestSuite::Tester {
     #endif
 };
 
+const struct {
+    const char* name;
+    bool openedBefore;
+    /** @todo remove this once the deprecated APIs are gone */
+    UnsignedInt fontId;
+} OpenDataFileData[]{
+    {"", false, 0},
+    {"opened before", true, 0},
+    {"non-zero font ID", false, 1}
+};
+
 /** @todo remove this once the deprecated APIs are gone */
 const struct {
     const char* name;
@@ -256,7 +267,7 @@ AbstractFontTest::AbstractFontTest() {
               &AbstractFontTest::dataFontCountNotSupported});
 
     addInstancedTests({&AbstractFontTest::openData},
-        Containers::arraySize(OpenData));
+        Containers::arraySize(OpenDataFileData));
 
     #ifdef MAGNUM_BUILD_DEPRECATED
     addTests({&AbstractFontTest::openDataDeprecated,
@@ -271,7 +282,7 @@ AbstractFontTest::AbstractFontTest() {
     #endif
 
     addInstancedTests({&AbstractFontTest::openFile},
-        Containers::arraySize(OpenData));
+        Containers::arraySize(OpenDataFileData));
 
     #ifdef MAGNUM_BUILD_DEPRECATED
     addTests({&AbstractFontTest::openFileDeprecated,
@@ -900,24 +911,25 @@ void AbstractFontTest::dataFontCountNotSupported() {
 }
 
 void AbstractFontTest::openData() {
-    auto&& data = OpenData[testCaseInstanceId()];
+    auto&& data = OpenDataFileData[testCaseInstanceId()];
     setTestCaseDescription(data.name);
 
     struct: AbstractFont {
         FontFeatures doFeatures() const override { return FontFeature::OpenData; }
-        bool doIsOpened() const override { return _opened; }
+        bool doIsOpened() const override { return opened; }
         void doClose() override {
-            CORRADE_VERIFY(_opened);
-            _opened = false;
+            CORRADE_VERIFY(opened);
+            opened = false;
         }
 
         void doOpenData(Containers::ArrayView<const char> data, Float size, UnsignedInt fontId) override {
+            CORRADE_VERIFY(!opened);
             CORRADE_COMPARE_AS(data,
                 Containers::arrayView({'\xa5'}),
                 TestSuite::Compare::Container);
             CORRADE_COMPARE(size, 13.0f);
             CORRADE_COMPARE(fontId, expectedFontId);
-            _opened = true;
+            opened = true;
         }
 
         Properties doProperties() override {
@@ -930,13 +942,12 @@ void AbstractFontTest::openData() {
         Containers::Pointer<AbstractShaper> doCreateShaper() override { return {}; }
 
         UnsignedInt expectedFontId;
-
-        private:
-            bool _opened = false;
+        bool opened;
     } font;
     font.expectedFontId = data.fontId;
+    font.opened = data.openedBefore;
+    CORRADE_COMPARE(font.isOpened(), data.openedBefore);
 
-    CORRADE_VERIFY(!font.isOpened());
     const char a5[]{'\xa5'};
     /* Verify that even with font ID 0 it delegates to the non-deprecated
        doOpenData() overload */
@@ -1103,22 +1114,22 @@ void AbstractFontTest::openDataFailedDeprecated() {
 #endif
 
 void AbstractFontTest::openFile() {
-    auto&& data = OpenData[testCaseInstanceId()];
+    auto&& data = OpenDataFileData[testCaseInstanceId()];
     setTestCaseDescription(data.name);
 
     struct: AbstractFont {
         FontFeatures doFeatures() const override { return {}; }
-        bool doIsOpened() const override { return _opened; }
+        bool doIsOpened() const override { return opened; }
         void doClose() override {
-            CORRADE_VERIFY(_opened);
-            _opened = false;
+            CORRADE_VERIFY(opened);
+            opened = false;
         }
 
         void doOpenFile(Containers::StringView filename, Float size, UnsignedInt fontId) override {
             CORRADE_COMPARE(filename, "hello.ttf");
             CORRADE_COMPARE(size, 13.0f);
             CORRADE_COMPARE(fontId, expectedFontId);
-            _opened = true;
+            opened = true;
         }
 
         Properties doProperties() override {
@@ -1131,13 +1142,12 @@ void AbstractFontTest::openFile() {
         Containers::Pointer<AbstractShaper> doCreateShaper() override { return {}; }
 
         UnsignedInt expectedFontId;
-
-        private:
-            bool _opened = false;
+        bool opened;
     } font;
     font.expectedFontId = data.fontId;
+    font.opened = data.openedBefore;
+    CORRADE_COMPARE(font.isOpened(), data.openedBefore);
 
-    CORRADE_VERIFY(!font.isOpened());
     /* Verify that even with font ID 0 it delegates to the non-deprecated
        doOpenFile() overload */
     /** @todo remove the instanced font ID once the deprecated APIs are gone,

src/Magnum/Trade/Test/AbstractImporterTest.cpp

@@ -395,10 +395,29 @@ struct AbstractImporterTest: TestSuite::Tester {
 const struct {
     const char* name;
     bool openMemory;
+    bool openedBefore;
     DataFlags expectedFlags;
 } OpenDataMemoryData[]{
-    {"open data", false, {}},
-    {"open memory", true, DataFlag::ExternallyOwned},
+    {"open data", false, false, {}},
+    {"open data, opened before", false, true, {}},
+    {"open memory", true, false, DataFlag::ExternallyOwned},
+    {"open memory, opened before", true, true, DataFlag::ExternallyOwned},
+};
+
+const struct {
+    const char* name;
+    bool openMemory;
+} OpenDataMemoryFailedData[]{
+    {"open data", false},
+    {"open memory", true},
+};
+
+const struct {
+    const char* name;
+    bool openedBefore;
+} OpenFileStateData[]{
+    {"", false},
+    {"opened before", true},
 };
 
 const struct {
@@ -429,22 +448,29 @@ AbstractImporterTest::AbstractImporterTest() {
               &AbstractImporterTest::setFlagsFileOpened,
               &AbstractImporterTest::setFlagsNotImplemented});
 
-    addInstancedTests({&AbstractImporterTest::openDataMemory,
-                       &AbstractImporterTest::openDataMemoryFailed},
+    addInstancedTests({&AbstractImporterTest::openDataMemory},
         Containers::arraySize(OpenDataMemoryData));
 
+    addInstancedTests({&AbstractImporterTest::openDataMemoryFailed},
+        Containers::arraySize(OpenDataMemoryFailedData));
+
     #ifdef MAGNUM_BUILD_DEPRECATED
     addTests({&AbstractImporterTest::openDataDeprecatedFallback,
               &AbstractImporterTest::openDataDeprecatedFallbackFailed});
     #endif
 
-    addTests({&AbstractImporterTest::openFile,
-              &AbstractImporterTest::openFileFailed,
+    addInstancedTests({&AbstractImporterTest::openFile},
+        Containers::arraySize(OpenFileStateData));
+
+    addTests({&AbstractImporterTest::openFileFailed,
               &AbstractImporterTest::openFileAsData,
               &AbstractImporterTest::openFileAsDataNotFound,
-              &AbstractImporterTest::openFileAsDataFailed,
-              &AbstractImporterTest::openState,
-              &AbstractImporterTest::openStateFailed,
+              &AbstractImporterTest::openFileAsDataFailed});
+
+    addInstancedTests({&AbstractImporterTest::openState},
+        Containers::arraySize(OpenFileStateData));
+
+    addTests({&AbstractImporterTest::openStateFailed,
 
               &AbstractImporterTest::openFileNotImplemented,
               &AbstractImporterTest::openDataNotSupported,
@@ -903,30 +929,30 @@ void AbstractImporterTest::openDataMemory() {
 
     struct: AbstractImporter {
         ImporterFeatures doFeatures() const override { return ImporterFeature::OpenData; }
-        bool doIsOpened() const override { return _opened; }
+        bool doIsOpened() const override { return opened; }
         void doClose() override {
-            CORRADE_VERIFY(_opened);
-            _opened = false;
+            CORRADE_VERIFY(opened);
+            opened = false;
         }
 
         void doOpenData(Containers::Array<char>&& data, DataFlags dataFlags) override {
+            CORRADE_VERIFY(!opened);
             CORRADE_COMPARE_AS(data,
                 Containers::arrayView({'\xa5'}),
                 TestSuite::Compare::Container);
             CORRADE_COMPARE(dataFlags, expectedFlags);
             /* The array should have a custom no-op deleter */
             CORRADE_VERIFY(data.deleter());
-            _opened = true;
+            opened = true;
         }
 
         DataFlags expectedFlags;
-
-        private:
-            bool _opened = false;
+        bool opened;
     } importer;
     importer.expectedFlags = data.expectedFlags;
+    importer.opened = data.openedBefore;
+    CORRADE_COMPARE(importer.isOpened(), data.openedBefore);
 
-    CORRADE_VERIFY(!importer.isOpened());
     const char a5 = '\xa5';
     if(data.openMemory)
         CORRADE_VERIFY(importer.openMemory({&a5, 1}));
@@ -939,7 +965,7 @@ void AbstractImporterTest::openDataMemory() {
 }
 
 void AbstractImporterTest::openDataMemoryFailed() {
-    auto&& data = OpenDataMemoryData[testCaseInstanceId()];
+    auto&& data = OpenDataMemoryFailedData[testCaseInstanceId()];
     setTestCaseDescription(data.name);
 
     struct: AbstractImporter {
@@ -1023,23 +1049,28 @@ void AbstractImporterTest::openDataDeprecatedFallbackFailed() {
 #endif
 
 void AbstractImporterTest::openFile() {
+    auto&& data = OpenFileStateData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
+
     struct: AbstractImporter {
         ImporterFeatures doFeatures() const override { return {}; }
-        bool doIsOpened() const override { return _opened; }
+        bool doIsOpened() const override { return opened; }
         void doClose() override {
-            CORRADE_VERIFY(_opened);
-            _opened = false;
+            CORRADE_VERIFY(opened);
+            opened = false;
         }
 
         void doOpenFile(Containers::StringView filename) override {
+            CORRADE_VERIFY(!opened);
             CORRADE_COMPARE(filename, "yello.foo");
-            _opened = true;
+            opened = true;
         }
 
-        bool _opened = false;
+        bool opened;
     } importer;
+    importer.opened = data.openedBefore;
+    CORRADE_COMPARE(importer.isOpened(), data.openedBefore);
 
-    CORRADE_VERIFY(!importer.isOpened());
     CORRADE_VERIFY(importer.openFile("yello.foo"));
     CORRADE_VERIFY(importer.isOpened());
 
@@ -1148,26 +1179,31 @@ void AbstractImporterTest::openFileAsDataFailed() {
 }
 
 void AbstractImporterTest::openState() {
+    auto&& data = OpenFileStateData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
+
     struct: AbstractImporter {
         ImporterFeatures doFeatures() const override {
             return ImporterFeature::OpenState;
         }
-        bool doIsOpened() const override { return _opened; }
+        bool doIsOpened() const override { return opened; }
         void doClose() override {
-            CORRADE_VERIFY(_opened);
-            _opened = false;
+            CORRADE_VERIFY(opened);
+            opened = false;
         }
 
         void doOpenState(const void* state, Containers::StringView filePath) override {
+            CORRADE_VERIFY(!opened);
             CORRADE_COMPARE(state, reinterpret_cast<const void*>(std::size_t{0xbadcafe}));
             CORRADE_COMPARE(filePath, "yello/foo/");
-            _opened = true;
+            opened = true;
         }
 
-        bool _opened = false;
+        bool opened;
     } importer;
+    importer.opened = data.openedBefore;
+    CORRADE_COMPARE(importer.isOpened(), data.openedBefore);
 
-    CORRADE_VERIFY(!importer.isOpened());
     CORRADE_VERIFY(importer.openState(reinterpret_cast<const void*>(std::size_t{0xbadcafe}), "yello/foo/"));
     CORRADE_VERIFY(importer.isOpened());