From a5bc6be094499b375537fada1fb53f0248d44713 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vladim=C3=ADr=20Vondru=C5=A1?= Date: Mon, 7 Mar 2022 19:16:01 +0100 Subject: [PATCH] DebugTools: port CompareImage to Utility::Path, remove all std::strings. Basically mirroring the changes done for Corrade::Compare::*File*, including storing the filenames as string views to avoid unnecessary copies (and then paying extra attention to not pass temporaries to them in its own tests). --- doc/snippets/MagnumDebugTools-gl.cpp | 1 + doc/snippets/MagnumDebugTools.cpp | 1 + doc/snippets/debugtools-compareimage.cpp | 8 +- src/Magnum/DebugTools/CompareImage.cpp | 46 ++- src/Magnum/DebugTools/CompareImage.h | 40 +-- .../DebugTools/Test/CompareImageTest.cpp | 284 +++++++++++------- 6 files changed, 244 insertions(+), 136 deletions(-) diff --git a/doc/snippets/MagnumDebugTools-gl.cpp b/doc/snippets/MagnumDebugTools-gl.cpp index 913d3da56..246615d57 100644 --- a/doc/snippets/MagnumDebugTools-gl.cpp +++ b/doc/snippets/MagnumDebugTools-gl.cpp @@ -24,6 +24,7 @@ */ #include +#include #include #include "Magnum/Image.h" diff --git a/doc/snippets/MagnumDebugTools.cpp b/doc/snippets/MagnumDebugTools.cpp index 816f46476..141902ce0 100644 --- a/doc/snippets/MagnumDebugTools.cpp +++ b/doc/snippets/MagnumDebugTools.cpp @@ -25,6 +25,7 @@ #include #include +#include #include #include diff --git a/doc/snippets/debugtools-compareimage.cpp b/doc/snippets/debugtools-compareimage.cpp index c855c600a..48b3fea29 100644 --- a/doc/snippets/debugtools-compareimage.cpp +++ b/doc/snippets/debugtools-compareimage.cpp @@ -24,9 +24,11 @@ */ #include +#include +#include /** @todo remove once AbstractImporter is -free */ #include #include -#include +#include #include "Magnum/Image.h" #include "Magnum/ImageView.h" @@ -45,7 +47,7 @@ namespace { Image2D doProcessing() { PluginManager::Manager manager{MAGNUM_PLUGINS_IMPORTER_DIR}; Containers::Pointer importer = manager.loadAndInstantiate("TgaImporter"); - importer->openFile(Utility::Directory::join(SNIPPETS_DIR, "image2.tga")); + importer->openFile(Utility::Path::join(SNIPPETS_DIR, "image2.tga")); auto image = importer->image2D(0); CORRADE_INTERNAL_ASSERT(image); return Image2D{image->storage(), image->format(), image->size(), image->release()}; @@ -54,7 +56,7 @@ Image2D doProcessing() { Image2D loadExpectedImage() { PluginManager::Manager manager{MAGNUM_PLUGINS_IMPORTER_DIR}; Containers::Pointer importer = manager.loadAndInstantiate("TgaImporter"); - importer->openFile(Utility::Directory::join(SNIPPETS_DIR, "image1.tga")); + importer->openFile(Utility::Path::join(SNIPPETS_DIR, "image1.tga")); auto image = importer->image2D(0); CORRADE_INTERNAL_ASSERT(image); return Image2D{image->storage(), image->format(), image->size(), image->release()}; diff --git a/src/Magnum/DebugTools/CompareImage.cpp b/src/Magnum/DebugTools/CompareImage.cpp index 3b33aed09..167b63b9e 100644 --- a/src/Magnum/DebugTools/CompareImage.cpp +++ b/src/Magnum/DebugTools/CompareImage.cpp @@ -28,13 +28,15 @@ #include #include #include +#include #include -#include /* for Directory */ +#include +#include /** @todo remove once AbstractImporter is -free */ #include #include #include #include -#include +#include #include "Magnum/ImageView.h" #include "Magnum/PixelFormat.h" @@ -244,10 +246,10 @@ void printDeltaImage(Debug& out, Containers::ArrayView deltas, cons const char c = Math::isNan(blockMax) ? Characters.back() : Characters[Int(Math::round(Math::min(1.0f, blockMax/max)*(Characters.size() - 1)))]; if(blockMax > maxThreshold) - out << Debug::boldColor(Debug::Color::Red) << Debug::nospace << std::string{c} << Debug::resetColor; + out << Debug::boldColor(Debug::Color::Red) << Debug::nospace << Containers::StringView{&c, 1} << Debug::resetColor; else if(blockMax > meanThreshold) - out << Debug::boldColor(Debug::Color::Yellow) << Debug::nospace << std::string{c} << Debug::resetColor; - else out << Debug::nospace << std::string{c}; + out << Debug::boldColor(Debug::Color::Yellow) << Debug::nospace << Containers::StringView{&c, 1} << Debug::resetColor; + else out << Debug::nospace << Containers::StringView{&c, 1}; } out << Debug::nospace << "|"; @@ -434,7 +436,9 @@ class ImageComparatorBase::State { PluginManager::Manager* _converterManager{}; public: - std::string actualFilename, expectedFilename; + /* The whole comparison is done in a single expression so the filenames + can stay as views */ + Containers::StringView actualFilename, expectedFilename; Containers::Optional actualImageData, expectedImageData; PixelFormat actualFormat; Containers::StridedArrayView3D actualPixels; @@ -511,7 +515,7 @@ TestSuite::ComparisonStatusFlags ImageComparatorBase::operator()(const ImageView return compare(actual.format(), actual.pixels(), expected); } -TestSuite::ComparisonStatusFlags ImageComparatorBase::operator()(const std::string& actual, const std::string& expected) { +TestSuite::ComparisonStatusFlags ImageComparatorBase::operator()(const Containers::StringView actual, const Containers::StringView expected) { _state->actualFilename = actual; _state->expectedFilename = expected; @@ -570,7 +574,7 @@ TestSuite::ComparisonStatusFlags ImageComparatorBase::operator()(const std::stri return flags; } -TestSuite::ComparisonStatusFlags ImageComparatorBase::compare(const PixelFormat actualFormat, const Containers::StridedArrayView3D& actualPixels, const std::string& expected) { +TestSuite::ComparisonStatusFlags ImageComparatorBase::compare(const PixelFormat actualFormat, const Containers::StridedArrayView3D& actualPixels, const Containers::StringView expected) { _state->expectedFilename = expected; Containers::Pointer importer; @@ -615,11 +619,11 @@ TestSuite::ComparisonStatusFlags ImageComparatorBase::compare(const PixelFormat return flags; } -TestSuite::ComparisonStatusFlags ImageComparatorBase::operator()(const ImageView2D& actual, const std::string& expected) { +TestSuite::ComparisonStatusFlags ImageComparatorBase::operator()(const ImageView2D& actual, const Containers::StringView expected) { return compare(actual.format(), actual.pixels(), expected); } -TestSuite::ComparisonStatusFlags ImageComparatorBase::operator()(const std::string& actual, const ImageView2D& expected) { +TestSuite::ComparisonStatusFlags ImageComparatorBase::operator()(const Containers::StringView actual, const ImageView2D& expected) { _state->actualFilename = actual; /* Here we are comparing against a view, not a file, so we cannot save @@ -647,7 +651,7 @@ TestSuite::ComparisonStatusFlags ImageComparatorBase::operator()(const std::stri return compare(_state->actualFormat, _state->actualPixels, expected); } -void ImageComparatorBase::printMessage(const TestSuite::ComparisonStatusFlags flags, Debug& out, const std::string& actual, const std::string& expected) const { +void ImageComparatorBase::printMessage(const TestSuite::ComparisonStatusFlags flags, Debug& out, const Containers::StringView actual, const Containers::StringView expected) const { if(_state->result == Result::PluginLoadFailed) { out << "AnyImageImporter plugin could not be loaded."; return; @@ -711,7 +715,7 @@ void ImageComparatorBase::printMessage(const TestSuite::ComparisonStatusFlags fl } } -void ImageComparatorBase::saveDiagnostic(TestSuite::ComparisonStatusFlags, Utility::Debug& out, const std::string& path) { +void ImageComparatorBase::saveDiagnostic(TestSuite::ComparisonStatusFlags, Utility::Debug& out, Containers::StringView path) { /* Tightly pack the actual pixels into a new array and create an image from it -- the array view might have totally arbitrary strides that can't be represented in an Image */ @@ -729,7 +733,7 @@ void ImageComparatorBase::saveDiagnostic(TestSuite::ComparisonStatusFlags, Utili } const ImageView2D image{PixelStorage{}.setAlignment(1), _state->actualFormat, Vector2i{Int(pixels.size()[1]), Int(pixels.size()[0])}, data}; - const std::string filename = Utility::Directory::join(path, Utility::Directory::filename(_state->expectedFilename)); + const Containers::String filename = Utility::Path::join(path, Utility::Path::split(_state->expectedFilename).second()); /* Export the data the base view/view comparator saved. Ignore failures, we're in the middle of a fail anyway (and everything will print messages @@ -740,3 +744,19 @@ void ImageComparatorBase::saveDiagnostic(TestSuite::ComparisonStatusFlags, Utili } }}} + +namespace Corrade { namespace TestSuite { + +ComparisonStatusFlags Comparator::operator()(const Containers::StringView actual, const Containers::StringView expected) { + return Magnum::DebugTools::Implementation::ImageComparatorBase::operator()(actual, expected); +} + +ComparisonStatusFlags Comparator::operator()(const Magnum::ImageView2D& actual, const Containers::StringView expected) { + return Magnum::DebugTools::Implementation::ImageComparatorBase::operator()(actual, expected); +} + +ComparisonStatusFlags Comparator::operator()(const Containers::StringView actual, const Magnum::ImageView2D& expected) { + return Magnum::DebugTools::Implementation::ImageComparatorBase::operator()(actual, expected); +} + +}} diff --git a/src/Magnum/DebugTools/CompareImage.h b/src/Magnum/DebugTools/CompareImage.h index 84a3f3534..e66ec4402 100644 --- a/src/Magnum/DebugTools/CompareImage.h +++ b/src/Magnum/DebugTools/CompareImage.h @@ -32,7 +32,6 @@ #include #include #include -#include #include #include "Magnum/Magnum.h" @@ -41,6 +40,12 @@ #include "Magnum/DebugTools/visibility.h" #include "Magnum/Trade/Trade.h" +#ifdef MAGNUM_BUILD_DEPRECATED +/* Some arguments used to be a std::string, so provide implicit conversion to a + StringView */ +#include "Corrade/Containers/StringStl.h" +#endif + namespace Magnum { namespace DebugTools { namespace Implementation { @@ -70,21 +75,21 @@ class MAGNUM_DEBUGTOOLS_EXPORT ImageComparatorBase { TestSuite::ComparisonStatusFlags operator()(const ImageView2D& actual, const ImageView2D& expected); - TestSuite::ComparisonStatusFlags operator()(const std::string& actual, const std::string& expected); + TestSuite::ComparisonStatusFlags operator()(Containers::StringView actual, Containers::StringView expected); - TestSuite::ComparisonStatusFlags operator()(const std::string& actual, const ImageView2D& expected); + TestSuite::ComparisonStatusFlags operator()(Containers::StringView actual, const ImageView2D& expected); - TestSuite::ComparisonStatusFlags operator()(const ImageView2D& actual, const std::string& expected); + TestSuite::ComparisonStatusFlags operator()(const ImageView2D& actual, Containers::StringView expected); /* Used in templated CompareImage::operator() */ TestSuite::ComparisonStatusFlags compare(PixelFormat actualFormat, const Containers::StridedArrayView3D& actualPixels, const ImageView2D& expected); /* Used in templated CompareImageToFile::operator() */ - TestSuite::ComparisonStatusFlags compare(PixelFormat actualFormat, const Containers::StridedArrayView3D& actualPixels, const std::string& expected); + TestSuite::ComparisonStatusFlags compare(PixelFormat actualFormat, const Containers::StridedArrayView3D& actualPixels, Containers::StringView expected); - void printMessage(TestSuite::ComparisonStatusFlags flags, Debug& out, const std::string& actual, const std::string& expected) const; + void printMessage(TestSuite::ComparisonStatusFlags flags, Debug& out, Containers::StringView actual, Containers::StringView expected) const; - void saveDiagnostic(TestSuite::ComparisonStatusFlags flags, Utility::Debug& out, const std::string& path); + void saveDiagnostic(TestSuite::ComparisonStatusFlags flags, Utility::Debug& out, Containers::StringView path); private: class MAGNUM_DEBUGTOOLS_LOCAL State; @@ -130,9 +135,7 @@ template<> class MAGNUM_DEBUGTOOLS_EXPORT Comparator class MAGNUM_DEBUGTOOLS_EXPORT Comparator: public Magnum::DebugTools::Implementation::ImageComparatorBase { @@ -141,11 +144,12 @@ template<> class MAGNUM_DEBUGTOOLS_EXPORT Comparator TestSuite::ComparisonStatusFlags operator()(const Containers::StridedArrayView2D& actualPixels, const std::string& expected) { + /* Unlike other functions, this one is using const StringView& to avoid + having to include it -- it's not needed when comparing just images + alone, not files */ + template TestSuite::ComparisonStatusFlags operator()(const Containers::StridedArrayView2D& actualPixels, const Containers::StringView& expected) { /** @todo do some tryFindCompatibleFormat() here */ return Magnum::DebugTools::Implementation::ImageComparatorBase::compare( Magnum::DebugTools::Implementation::pixelFormatFor(), @@ -159,9 +163,7 @@ template<> class MAGNUM_DEBUGTOOLS_EXPORT Comparator struct ComparatorTraits::operator() is overloaded */ template struct ComparatorTraits { typedef Magnum::ImageView2D ActualType; - typedef std::string ExpectedType; + typedef Containers::StringView ExpectedType; }; template struct ComparatorTraits: ComparatorTraits {}; template struct ComparatorTraits: ComparatorTraits {}; template struct ComparatorTraits, U> { typedef Containers::StridedArrayView2D ActualType; - typedef std::string ExpectedType; + typedef Containers::StringView ExpectedType; }; } diff --git a/src/Magnum/DebugTools/Test/CompareImageTest.cpp b/src/Magnum/DebugTools/Test/CompareImageTest.cpp index b0a40c828..3369f5828 100644 --- a/src/Magnum/DebugTools/Test/CompareImageTest.cpp +++ b/src/Magnum/DebugTools/Test/CompareImageTest.cpp @@ -28,13 +28,14 @@ #include #include #include +#include #include #include #include #include #include -#include #include +#include #include #include "Magnum/ImageView.h" @@ -1026,16 +1027,17 @@ void CompareImageTest::imageFileZeroDelta() { !(_importerManager->loadState("TgaImporter") & PluginManager::LoadState::Loaded)) CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found."); - CORRADE_COMPARE_WITH( - Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga"), - Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga"), + /* The filenames are referenced as string views as the assumption is that + the whole comparison and diagnostic printing gets done in a single + expression. Thus don't pass them as temporaries to avoid dangling + views. */ + Containers::String expectedFilename = Utility::Path::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga"); + CORRADE_COMPARE_WITH(expectedFilename, expectedFilename, (CompareImageFile{*_importerManager, 40.0f, 20.0f})); /* No diagnostic as there's no error */ TestSuite::Comparator compare{&*_importerManager, nullptr, 40.0f, 20.0f}; - CORRADE_COMPARE(compare( - Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga"), - Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga")), + CORRADE_COMPARE(compare(expectedFilename, expectedFilename), TestSuite::ComparisonStatusFlag{}); } @@ -1044,19 +1046,21 @@ void CompareImageTest::imageFileNonZeroDelta() { !(_importerManager->loadState("TgaImporter") & PluginManager::LoadState::Loaded)) CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found."); + /* The filenames are referenced as string views as the assumption is that + the whole comparison and diagnostic printing gets done in a single + expression. Thus don't pass them as temporaries to avoid dangling + views. */ + Containers::String actualFilename = Utility::Path::join(DEBUGTOOLS_TEST_DIR, "CompareImageActual.tga"); + Containers::String expectedFilename = Utility::Path::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga"); /* This will produce output if --verbose is specified */ - CORRADE_COMPARE_WITH( - Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageActual.tga"), - Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga"), + CORRADE_COMPARE_WITH(actualFilename, expectedFilename, (CompareImageFile{*_importerManager, 40.0f, 20.0f})); std::ostringstream out; { TestSuite::Comparator compare{&*_importerManager, nullptr, 40.0f, 20.0f}; - TestSuite::ComparisonStatusFlags flags = compare( - Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageActual.tga"), - Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga")); + TestSuite::ComparisonStatusFlags flags = compare(actualFilename, expectedFilename); /* No diagnostic as there's no error */ CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Verbose); Debug d{&out, Debug::Flag::DisableColors}; @@ -1074,9 +1078,13 @@ void CompareImageTest::imageFileError() { std::stringstream out; TestSuite::Comparator compare{&*_importerManager, &*_converterManager, 20.0f, 10.0f}; - TestSuite::ComparisonStatusFlags flags = compare( - Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageActual.tga"), - Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga")); + /* The filenames are referenced as string views as the assumption is that + the whole comparison and diagnostic printing gets done in a single + expression. Thus don't pass them as temporaries to avoid dangling + views. */ + Containers::String actualFilename = Utility::Path::join(DEBUGTOOLS_TEST_DIR, "CompareImageActual.tga"); + Containers::String expectedFilename = Utility::Path::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga"); + TestSuite::ComparisonStatusFlags flags = compare(actualFilename, expectedFilename); /* The diagnostic flag should be slapped on the failure coming from the operator() comparing two ImageViews */ CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Failed|TestSuite::ComparisonStatusFlag::Diagnostic); @@ -1090,10 +1098,10 @@ void CompareImageTest::imageFileError() { /* Create the output dir if it doesn't exist, but avoid stale files making false positives */ - CORRADE_VERIFY(Utility::Directory::mkpath(COMPAREIMAGETEST_SAVE_DIR)); - std::string filename = Utility::Directory::join(COMPAREIMAGETEST_SAVE_DIR, "CompareImageExpected.tga"); - if(Utility::Directory::exists(filename)) - CORRADE_VERIFY(Utility::Directory::rm(filename)); + CORRADE_VERIFY(Utility::Path::make(COMPAREIMAGETEST_SAVE_DIR)); + Containers::String filename = Utility::Path::join(COMPAREIMAGETEST_SAVE_DIR, "CompareImageExpected.tga"); + if(Utility::Path::exists(filename)) + CORRADE_VERIFY(Utility::Path::remove(filename)); if(!(_converterManager->loadState("AnyImageConverter") & PluginManager::LoadState::Loaded) || !(_converterManager->loadState("TgaImageConverter") & PluginManager::LoadState::Loaded)) @@ -1110,7 +1118,7 @@ void CompareImageTest::imageFileError() { file. */ CORRADE_COMPARE(out.str(), Utility::formatString("-> {}\n", filename)); CORRADE_COMPARE_AS(filename, - Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageActual.tga"), TestSuite::Compare::File); + Utility::Path::join(DEBUGTOOLS_TEST_DIR, "CompareImageActual.tga"), TestSuite::Compare::File); } void CompareImageTest::imageFilePluginLoadFailed() { @@ -1122,9 +1130,13 @@ void CompareImageTest::imageFilePluginLoadFailed() { { TestSuite::Comparator compare{&manager, nullptr, 20.0f, 10.0f}; - TestSuite::ComparisonStatusFlags flags = compare( - Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageActual.tga"), - Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga")); + /* The filenames are referenced as string views as the assumption is + that the whole comparison and diagnostic printing gets done in a + single expression. Thus don't pass them as temporaries to avoid + dangling views. */ + Containers::String actualFilename = Utility::Path::join(DEBUGTOOLS_TEST_DIR, "CompareImageActual.tga"); + Containers::String expectedFilename = Utility::Path::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga"); + TestSuite::ComparisonStatusFlags flags = compare(actualFilename, expectedFilename); /* Can't load a plugin, so we can't open the file, so we can't save it either and thus no diagnostic */ CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Failed); @@ -1144,8 +1156,12 @@ void CompareImageTest::imageFileActualLoadFailed() { { TestSuite::Comparator compare{&*_importerManager, nullptr, 20.0f, 10.0f}; - TestSuite::ComparisonStatusFlags flags = compare("nonexistent.tga", - Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga")); + /* The filenames are referenced as string views as the assumption is + that the whole comparison and diagnostic printing gets done in a + single expression. Thus don't pass them as temporaries to avoid + dangling views. */ + Containers::String expectedFilename = Utility::Path::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga"); + TestSuite::ComparisonStatusFlags flags = compare("nonexistent.tga", expectedFilename); /* We can't open the file, so we can't save it either and thus no diagnostic */ CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Failed); @@ -1164,9 +1180,12 @@ void CompareImageTest::imageFileExpectedLoadFailed() { std::stringstream out; TestSuite::Comparator compare{&*_importerManager, &*_converterManager, 20.0f, 10.0f}; - TestSuite::ComparisonStatusFlags flags = compare( - Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageActual.tga"), - "nonexistent.tga"); + /* The filenames are referenced as string views as the assumption is that + the whole comparison and diagnostic printing gets done in a single + expression. Thus don't pass them as temporaries to avoid dangling + views. */ + Containers::String actualFilename = Utility::Path::join(DEBUGTOOLS_TEST_DIR, "CompareImageActual.tga"); + TestSuite::ComparisonStatusFlags flags = compare(actualFilename, "nonexistent.tga"); /* Actual file *could* be loaded, so save it! */ CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Failed|TestSuite::ComparisonStatusFlag::Diagnostic); @@ -1179,10 +1198,10 @@ void CompareImageTest::imageFileExpectedLoadFailed() { /* Create the output dir if it doesn't exist, but avoid stale files making false positives */ - CORRADE_VERIFY(Utility::Directory::mkpath(COMPAREIMAGETEST_SAVE_DIR)); - std::string filename = Utility::Directory::join(COMPAREIMAGETEST_SAVE_DIR, "nonexistent.tga"); - if(Utility::Directory::exists(filename)) - CORRADE_VERIFY(Utility::Directory::rm(filename)); + CORRADE_VERIFY(Utility::Path::make(COMPAREIMAGETEST_SAVE_DIR)); + Containers::String filename = Utility::Path::join(COMPAREIMAGETEST_SAVE_DIR, "nonexistent.tga"); + if(Utility::Path::exists(filename)) + CORRADE_VERIFY(Utility::Path::remove(filename)); if(!(_converterManager->loadState("AnyImageConverter") & PluginManager::LoadState::Loaded) || !(_converterManager->loadState("TgaImageConverter") & PluginManager::LoadState::Loaded)) @@ -1199,7 +1218,7 @@ void CompareImageTest::imageFileExpectedLoadFailed() { file. */ CORRADE_COMPARE(out.str(), Utility::formatString("-> {}\n", filename)); CORRADE_COMPARE_AS(filename, - Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageActual.tga"), TestSuite::Compare::File); + Utility::Path::join(DEBUGTOOLS_TEST_DIR, "CompareImageActual.tga"), TestSuite::Compare::File); } void CompareImageTest::imageFileActualIsCompressed() { @@ -1212,9 +1231,13 @@ void CompareImageTest::imageFileActualIsCompressed() { { TestSuite::Comparator compare{&manager, nullptr, 20.0f, 10.0f}; - TestSuite::ComparisonStatusFlags flags = compare( - Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageCompressed.dds"), - Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga")); + /* The filenames are referenced as string views as the assumption is + that the whole comparison and diagnostic printing gets done in a + single expression. Thus don't pass them as temporaries to avoid + dangling views. */ + Containers::String actualFilename = Utility::Path::join(DEBUGTOOLS_TEST_DIR, "CompareImageCompressed.dds"); + Containers::String expectedFilename = Utility::Path::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga"); + TestSuite::ComparisonStatusFlags flags = compare(actualFilename, expectedFilename); /* We most probably couldn't save the file because it's in a different format, so no diagnostic */ CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Failed); @@ -1234,9 +1257,13 @@ void CompareImageTest::imageFileExpectedIsCompressed() { std::stringstream out; TestSuite::Comparator compare{&manager, nullptr, 20.0f, 10.0f}; - TestSuite::ComparisonStatusFlags flags = compare( - Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageActual.tga"), - Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageCompressed.dds")); + /* The filenames are referenced as string views as the assumption is that + the whole comparison and diagnostic printing gets done in a single + expression. Thus don't pass them as temporaries to avoid dangling + views. */ + Containers::String actualFilename = Utility::Path::join(DEBUGTOOLS_TEST_DIR, "CompareImageActual.tga"); + Containers::String expectedFilename = Utility::Path::join(DEBUGTOOLS_TEST_DIR, "CompareImageCompressed.dds"); + TestSuite::ComparisonStatusFlags flags = compare(actualFilename, expectedFilename); /* Actual file is not, so save it! */ CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Failed|TestSuite::ComparisonStatusFlag::Diagnostic); @@ -1247,16 +1274,16 @@ void CompareImageTest::imageFileExpectedIsCompressed() { /* Create the output dir if it doesn't exist, but avoid stale files making false positives */ - CORRADE_VERIFY(Utility::Directory::mkpath(COMPAREIMAGETEST_SAVE_DIR)); - std::string filename = Utility::Directory::join(COMPAREIMAGETEST_SAVE_DIR, "CompareImageCompressed.dds"); - if(Utility::Directory::exists(filename)) - CORRADE_VERIFY(Utility::Directory::rm(filename)); + CORRADE_VERIFY(Utility::Path::make(COMPAREIMAGETEST_SAVE_DIR)); + Containers::String filename = Utility::Path::join(COMPAREIMAGETEST_SAVE_DIR, "CompareImageCompressed.dds"); + if(Utility::Path::exists(filename)) + CORRADE_VERIFY(Utility::Path::remove(filename)); /* This will attempt to save a DDS and then fails, because we have no DDS exporter. */ Debug d; compare.saveDiagnostic(flags, d, COMPAREIMAGETEST_SAVE_DIR); - CORRADE_VERIFY(!Utility::Directory::exists(filename)); + CORRADE_VERIFY(!Utility::Path::exists(filename)); } void CompareImageTest::imageToFileZeroDelta() { @@ -1264,13 +1291,18 @@ void CompareImageTest::imageToFileZeroDelta() { !(_importerManager->loadState("TgaImporter") & PluginManager::LoadState::Loaded)) CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found."); - CORRADE_COMPARE_WITH(ExpectedRgb, - Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga"), + /* The filenames are referenced as string views as the assumption is that + the whole comparison and diagnostic printing gets done in a single + expression. Thus don't pass them as temporaries to avoid dangling + views. */ + Containers::String expectedFilename = Utility::Path::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga"); + + CORRADE_COMPARE_WITH(ExpectedRgb, expectedFilename, (CompareImageToFile{*_importerManager, 40.0f, 20.0f})); /* No diagnostic as there's no error */ TestSuite::Comparator compare{&*_importerManager, nullptr, 40.0f, 20.0f}; - CORRADE_COMPARE(compare(ExpectedRgb, Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga")), + CORRADE_COMPARE(compare(ExpectedRgb, expectedFilename), TestSuite::ComparisonStatusFlags{}); } @@ -1279,16 +1311,21 @@ void CompareImageTest::imageToFileNonZeroDelta() { !(_importerManager->loadState("TgaImporter") & PluginManager::LoadState::Loaded)) CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found."); + /* The filenames are referenced as string views as the assumption is that + the whole comparison and diagnostic printing gets done in a single + expression. Thus don't pass them as temporaries to avoid dangling + views. */ + Containers::String expectedFilename = Utility::Path::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga"); + /* This will produce output if --verbose is specified */ - CORRADE_COMPARE_WITH(ActualRgb, - Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga"), + CORRADE_COMPARE_WITH(ActualRgb, expectedFilename, (CompareImageToFile{*_importerManager, 40.0f, 20.0f})); std::ostringstream out; { TestSuite::Comparator compare{&*_importerManager, nullptr, 40.0f, 20.0f}; - TestSuite::ComparisonStatusFlags flags = compare(ActualRgb, Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga")); + TestSuite::ComparisonStatusFlags flags = compare(ActualRgb, expectedFilename); /* No diagnostic as there's no error */ CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Verbose); Debug d{&out, Debug::Flag::DisableColors}; @@ -1306,8 +1343,12 @@ void CompareImageTest::imageToFileError() { std::stringstream out; TestSuite::Comparator compare{&*_importerManager, &*_converterManager, 20.0f, 10.0f}; - TestSuite::ComparisonStatusFlags flags = compare(ActualRgb, - Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga")); + /* The filenames are referenced as string views as the assumption is that + the whole comparison and diagnostic printing gets done in a single + expression. Thus don't pass them as temporaries to avoid dangling + views. */ + Containers::String expectedFilename = Utility::Path::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga"); + TestSuite::ComparisonStatusFlags flags = compare(ActualRgb, expectedFilename); /* The diagnostic flag should be slapped on the failure coming from the operator() comparing two ImageViews */ CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Failed|TestSuite::ComparisonStatusFlag::Diagnostic); @@ -1321,10 +1362,10 @@ void CompareImageTest::imageToFileError() { /* Create the output dir if it doesn't exist, but avoid stale files making false positives */ - CORRADE_VERIFY(Utility::Directory::mkpath(COMPAREIMAGETEST_SAVE_DIR)); - std::string filename = Utility::Directory::join(COMPAREIMAGETEST_SAVE_DIR, "CompareImageExpected.tga"); - if(Utility::Directory::exists(filename)) - CORRADE_VERIFY(Utility::Directory::rm(filename)); + CORRADE_VERIFY(Utility::Path::make(COMPAREIMAGETEST_SAVE_DIR)); + Containers::String filename = Utility::Path::join(COMPAREIMAGETEST_SAVE_DIR, "CompareImageExpected.tga"); + if(Utility::Path::exists(filename)) + CORRADE_VERIFY(Utility::Path::remove(filename)); if(!(_converterManager->loadState("AnyImageConverter") & PluginManager::LoadState::Loaded) || !(_converterManager->loadState("TgaImageConverter") & PluginManager::LoadState::Loaded)) @@ -1341,7 +1382,7 @@ void CompareImageTest::imageToFileError() { file. */ CORRADE_COMPARE(out.str(), Utility::formatString("-> {}\n", filename)); CORRADE_COMPARE_AS(filename, - Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageActual.tga"), TestSuite::Compare::File); + Utility::Path::join(DEBUGTOOLS_TEST_DIR, "CompareImageActual.tga"), TestSuite::Compare::File); } void CompareImageTest::imageToFilePluginLoadFailed() { @@ -1353,8 +1394,12 @@ void CompareImageTest::imageToFilePluginLoadFailed() { { TestSuite::Comparator compare{&manager, nullptr, 20.0f, 10.0f}; - TestSuite::ComparisonStatusFlags flags = compare(ActualRgb, - Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga")); + /* The filenames are referenced as string views as the assumption is + that the whole comparison and diagnostic printing gets done in a + single expression. Thus don't pass them as temporaries to avoid + dangling views. */ + Containers::String expectedFilename = Utility::Path::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga"); + TestSuite::ComparisonStatusFlags flags = compare(ActualRgb, expectedFilename); /* Can't load a plugin, so we can't open the file, so we can't save it either and thus no diagnostic */ CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Failed); @@ -1386,10 +1431,10 @@ void CompareImageTest::imageToFileExpectedLoadFailed() { /* Create the output dir if it doesn't exist, but avoid stale files making false positives */ - CORRADE_VERIFY(Utility::Directory::mkpath(COMPAREIMAGETEST_SAVE_DIR)); - std::string filename = Utility::Directory::join(COMPAREIMAGETEST_SAVE_DIR, "nonexistent.tga"); - if(Utility::Directory::exists(filename)) - CORRADE_VERIFY(Utility::Directory::rm(filename)); + CORRADE_VERIFY(Utility::Path::make(COMPAREIMAGETEST_SAVE_DIR)); + Containers::String filename = Utility::Path::join(COMPAREIMAGETEST_SAVE_DIR, "nonexistent.tga"); + if(Utility::Path::exists(filename)) + CORRADE_VERIFY(Utility::Path::remove(filename)); if(!(_converterManager->loadState("AnyImageConverter") & PluginManager::LoadState::Loaded) || !(_converterManager->loadState("TgaImageConverter") & PluginManager::LoadState::Loaded)) @@ -1406,7 +1451,7 @@ void CompareImageTest::imageToFileExpectedLoadFailed() { file. */ CORRADE_COMPARE(out.str(), Utility::formatString("-> {}\n", filename)); CORRADE_COMPARE_AS(filename, - Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageActual.tga"), TestSuite::Compare::File); + Utility::Path::join(DEBUGTOOLS_TEST_DIR, "CompareImageActual.tga"), TestSuite::Compare::File); } void CompareImageTest::imageToFileExpectedIsCompressed() { @@ -1418,8 +1463,12 @@ void CompareImageTest::imageToFileExpectedIsCompressed() { std::stringstream out; TestSuite::Comparator compare{&manager, nullptr, 20.0f, 10.0f}; - TestSuite::ComparisonStatusFlags flags = compare(ActualRgb, - Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageCompressed.dds")); + /* The filenames are referenced as string views as the assumption is that + the whole comparison and diagnostic printing gets done in a single + expression. Thus don't pass them as temporaries to avoid dangling + views. */ + Containers::String expectedFilename = Utility::Path::join(DEBUGTOOLS_TEST_DIR, "CompareImageCompressed.dds"); + TestSuite::ComparisonStatusFlags flags = compare(ActualRgb, expectedFilename); /* Actual file is not, so save it! */ CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Failed|TestSuite::ComparisonStatusFlag::Diagnostic); @@ -1433,16 +1482,16 @@ void CompareImageTest::imageToFileExpectedIsCompressed() { /* Create the output dir if it doesn't exist, but avoid stale files making false positives */ - CORRADE_VERIFY(Utility::Directory::mkpath(COMPAREIMAGETEST_SAVE_DIR)); - std::string filename = Utility::Directory::join(COMPAREIMAGETEST_SAVE_DIR, "CompareImageCompressed.dds"); - if(Utility::Directory::exists(filename)) - CORRADE_VERIFY(Utility::Directory::rm(filename)); + CORRADE_VERIFY(Utility::Path::make(COMPAREIMAGETEST_SAVE_DIR)); + Containers::String filename = Utility::Path::join(COMPAREIMAGETEST_SAVE_DIR, "CompareImageCompressed.dds"); + if(Utility::Path::exists(filename)) + CORRADE_VERIFY(Utility::Path::remove(filename)); /* This will attempt to save a DDS and then fails, because we have no DDS exporter. */ Debug d; compare.saveDiagnostic(flags, d, COMPAREIMAGETEST_SAVE_DIR); - CORRADE_VERIFY(!Utility::Directory::exists(filename)); + CORRADE_VERIFY(!Utility::Path::exists(filename)); } void CompareImageTest::fileToImageZeroDelta() { @@ -1450,15 +1499,18 @@ void CompareImageTest::fileToImageZeroDelta() { !(_importerManager->loadState("TgaImporter") & PluginManager::LoadState::Loaded)) CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found."); - CORRADE_COMPARE_WITH( - Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga"), - ExpectedRgb, + /* The filenames are referenced as string views as the assumption is that + the whole comparison and diagnostic printing gets done in a single + expression. Thus don't pass them as temporaries to avoid dangling + views. */ + Containers::String expectedFilename = Utility::Path::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga"); + + CORRADE_COMPARE_WITH(expectedFilename, ExpectedRgb, (CompareFileToImage{*_importerManager, 40.0f, 20.0f})); /* No diagnostic as there's no error */ TestSuite::Comparator compare{&*_importerManager, 40.0f, 20.0f}; - CORRADE_COMPARE(compare(Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga"), - ExpectedRgb), TestSuite::ComparisonStatusFlags{}); + CORRADE_COMPARE(compare(expectedFilename, ExpectedRgb), TestSuite::ComparisonStatusFlags{}); } void CompareImageTest::fileToImageNonZeroDelta() { @@ -1466,18 +1518,21 @@ void CompareImageTest::fileToImageNonZeroDelta() { !(_importerManager->loadState("TgaImporter") & PluginManager::LoadState::Loaded)) CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found."); + /* The filenames are referenced as string views as the assumption is that + the whole comparison and diagnostic printing gets done in a single + expression. Thus don't pass them as temporaries to avoid dangling + views. */ + Containers::String actualFilename = Utility::Path::join(DEBUGTOOLS_TEST_DIR, "CompareImageActual.tga"); + /* This will produce output if --verbose is specified */ - CORRADE_COMPARE_WITH( - Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageActual.tga"), - ExpectedRgb, + CORRADE_COMPARE_WITH(actualFilename, ExpectedRgb, (CompareFileToImage{*_importerManager, 40.0f, 20.0f})); std::ostringstream out; { TestSuite::Comparator compare{&*_importerManager, 40.0f, 20.0f}; - TestSuite::ComparisonStatusFlags flags = compare(Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageActual.tga"), - ExpectedRgb); + TestSuite::ComparisonStatusFlags flags = compare(actualFilename, ExpectedRgb); /* No diagnostic as there's no error */ CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Verbose); Debug d{&out, Debug::Flag::DisableColors}; @@ -1496,9 +1551,12 @@ void CompareImageTest::fileToImageError() { { TestSuite::Comparator compare{&*_importerManager, 20.0f, 10.0f}; - TestSuite::ComparisonStatusFlags flags = compare( - Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageActual.tga"), - ExpectedRgb); + /* The filenames are referenced as string views as the assumption is + that the whole comparison and diagnostic printing gets done in a + single expression. Thus don't pass them as temporaries to avoid + dangling views. */ + Containers::String actualFilename = Utility::Path::join(DEBUGTOOLS_TEST_DIR, "CompareImageActual.tga"); + TestSuite::ComparisonStatusFlags flags = compare(actualFilename, ExpectedRgb); /* No diagnostic as we don't have any expected filename */ CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Failed); Debug d{&out, Debug::Flag::DisableColors}; @@ -1517,9 +1575,12 @@ void CompareImageTest::fileToImagePluginLoadFailed() { { TestSuite::Comparator compare{&manager, 20.0f, 10.0f}; - TestSuite::ComparisonStatusFlags flags = compare( - Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageActual.tga"), - ExpectedRgb); + /* The filenames are referenced as string views as the assumption is + that the whole comparison and diagnostic printing gets done in a + single expression. Thus don't pass them as temporaries to avoid + dangling views. */ + Containers::String actualFilename = Utility::Path::join(DEBUGTOOLS_TEST_DIR, "CompareImageActual.tga"); + TestSuite::ComparisonStatusFlags flags = compare(actualFilename, ExpectedRgb); /* No diagnostic as we don't have any expected filename */ CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Failed); Debug d{&out, Debug::Flag::DisableColors}; @@ -1558,7 +1619,12 @@ void CompareImageTest::fileToImageActualIsCompressed() { { TestSuite::Comparator compare{&manager, 20.0f, 10.0f}; - TestSuite::ComparisonStatusFlags flags = compare(Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageCompressed.dds"), ExpectedRgb); + /* The filenames are referenced as string views as the assumption is + that the whole comparison and diagnostic printing gets done in a + single expression. Thus don't pass them as temporaries to avoid + dangling views. */ + Containers::String actualFilename = Utility::Path::join(DEBUGTOOLS_TEST_DIR, "CompareImageCompressed.dds"); + TestSuite::ComparisonStatusFlags flags = compare(actualFilename, ExpectedRgb); /* No diagnostic as we don't have any expected filename */ CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Failed); Debug d{&out, Debug::Flag::DisableColors}; @@ -1625,13 +1691,18 @@ void CompareImageTest::pixelsToFileZeroDelta() { !(_importerManager->loadState("TgaImporter") & PluginManager::LoadState::Loaded)) CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found."); - CORRADE_COMPARE_WITH(ExpectedRgb.pixels(), - Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga"), + /* The filenames are referenced as string views as the assumption is that + the whole comparison and diagnostic printing gets done in a single + expression. Thus don't pass them as temporaries to avoid dangling + views. */ + Containers::String expectedFilename = Utility::Path::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga"); + + CORRADE_COMPARE_WITH(ExpectedRgb.pixels(), expectedFilename, (CompareImageToFile{*_importerManager, 40.0f, 20.0f})); /* No diagnostic as there's no error */ TestSuite::Comparator compare{&*_importerManager, nullptr, 40.0f, 20.0f}; - CORRADE_COMPARE(compare(ExpectedRgb.pixels(), Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga")), + CORRADE_COMPARE(compare(ExpectedRgb.pixels(), expectedFilename), TestSuite::ComparisonStatusFlags{}); } @@ -1642,15 +1713,21 @@ void CompareImageTest::pixelsToFileNonZeroDelta() { !(_importerManager->loadState("TgaImporter") & PluginManager::LoadState::Loaded)) CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found."); + /* The filenames are referenced as string views as the assumption is that + the whole comparison and diagnostic printing gets done in a single + expression. Thus don't pass them as temporaries to avoid dangling + views. */ + Containers::String expectedFilename = Utility::Path::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga"); + CORRADE_COMPARE_WITH(ActualRgb.pixels(), - Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga"), + expectedFilename, (CompareImageToFile{*_importerManager, 40.0f, 20.0f})); std::ostringstream out; { TestSuite::Comparator compare{&*_importerManager, nullptr, 40.0f, 20.0f}; - TestSuite::ComparisonStatusFlags flags = compare(ActualRgb.pixels(), Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga")); + TestSuite::ComparisonStatusFlags flags = compare(ActualRgb.pixels(), expectedFilename); /* No diagnostic as there's no error */ CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Verbose); Debug d{&out, Debug::Flag::DisableColors}; @@ -1667,11 +1744,16 @@ void CompareImageTest::pixelsToFileError() { !(_importerManager->loadState("TgaImporter") & PluginManager::LoadState::Loaded)) CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found."); + /* The filenames are referenced as string views as the assumption is that + the whole comparison and diagnostic printing gets done in a single + expression. Thus don't pass them as temporaries to avoid dangling + views. */ + Containers::String expectedFilename = Utility::Path::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga"); + std::stringstream out; TestSuite::Comparator compare{&*_importerManager, &*_converterManager, 20.0f, 10.0f}; - TestSuite::ComparisonStatusFlags flags = compare(ActualRgb.pixels(), - Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga")); + TestSuite::ComparisonStatusFlags flags = compare(ActualRgb.pixels(), expectedFilename); /* The diagnostic flag should be slapped on the failure coming from the operator() comparing two ImageViews */ CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Failed|TestSuite::ComparisonStatusFlag::Diagnostic); @@ -1685,10 +1767,10 @@ void CompareImageTest::pixelsToFileError() { /* Create the output dir if it doesn't exist, but avoid stale files making false positives */ - CORRADE_VERIFY(Utility::Directory::mkpath(COMPAREIMAGETEST_SAVE_DIR)); - std::string filename = Utility::Directory::join(COMPAREIMAGETEST_SAVE_DIR, "CompareImageExpected.tga"); - if(Utility::Directory::exists(filename)) - CORRADE_VERIFY(Utility::Directory::rm(filename)); + CORRADE_VERIFY(Utility::Path::make(COMPAREIMAGETEST_SAVE_DIR)); + Containers::String filename = Utility::Path::join(COMPAREIMAGETEST_SAVE_DIR, "CompareImageExpected.tga"); + if(Utility::Path::exists(filename)) + CORRADE_VERIFY(Utility::Path::remove(filename)); if(!(_converterManager->loadState("AnyImageConverter") & PluginManager::LoadState::Loaded) || !(_converterManager->loadState("TgaImageConverter") & PluginManager::LoadState::Loaded)) @@ -1705,7 +1787,7 @@ void CompareImageTest::pixelsToFileError() { file. */ CORRADE_COMPARE(out.str(), Utility::formatString("-> {}\n", filename)); CORRADE_COMPARE_AS(filename, - Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageActual.tga"), TestSuite::Compare::File); + Utility::Path::join(DEBUGTOOLS_TEST_DIR, "CompareImageActual.tga"), TestSuite::Compare::File); } }}}}