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

@@ -24,6 +24,7 @@
 */
 
 #include <Corrade/Containers/StridedArrayView.h>
+#include <Corrade/Containers/StringView.h>
 #include <Corrade/TestSuite/Tester.h>
 
 #include "Magnum/Image.h"

doc/snippets/MagnumDebugTools.cpp

@@ -25,6 +25,7 @@
 
 #include <chrono>
 #include <Corrade/Containers/StridedArrayView.h>
+#include <Corrade/Containers/StringView.h>
 #include <Corrade/TestSuite/Tester.h>
 #include <Corrade/PluginManager/Manager.h>
 

doc/snippets/debugtools-compareimage.cpp

@@ -24,9 +24,11 @@
 */
 
 #include <Corrade/Containers/Optional.h>
+#include <Corrade/Containers/String.h>
+#include <Corrade/Containers/StringStl.h> /** @todo remove once AbstractImporter is <string>-free */
 #include <Corrade/PluginManager/Manager.h>
 #include <Corrade/TestSuite/Tester.h>
-#include <Corrade/Utility/Directory.h>
+#include <Corrade/Utility/Path.h>
 
 #include "Magnum/Image.h"
 #include "Magnum/ImageView.h"
@@ -45,7 +47,7 @@ namespace {
 Image2D doProcessing() {
     PluginManager::Manager<Trade::AbstractImporter> manager{MAGNUM_PLUGINS_IMPORTER_DIR};
     Containers::Pointer<Trade::AbstractImporter> 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<Trade::AbstractImporter> manager{MAGNUM_PLUGINS_IMPORTER_DIR};
     Containers::Pointer<Trade::AbstractImporter> 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()};

src/Magnum/DebugTools/CompareImage.cpp

@@ -28,13 +28,15 @@
 #include <map>
 #include <sstream>
 #include <Corrade/Containers/Array.h>
+#include <Corrade/Containers/Pair.h>
 #include <Corrade/Containers/StridedArrayView.h>
-#include <Corrade/Containers/StringStl.h> /* for Directory */
+#include <Corrade/Containers/String.h>
+#include <Corrade/Containers/StringStl.h> /** @todo remove once AbstractImporter is <string>-free */
 #include <Corrade/Containers/Optional.h>
 #include <Corrade/PluginManager/Manager.h>
 #include <Corrade/TestSuite/Comparator.h>
 #include <Corrade/Utility/DebugStl.h>
-#include <Corrade/Utility/Directory.h>
+#include <Corrade/Utility/Path.h>
 
 #include "Magnum/ImageView.h"
 #include "Magnum/PixelFormat.h"
@@ -244,10 +246,10 @@ void printDeltaImage(Debug& out, Containers::ArrayView<const Float> 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<Trade::AbstractImageConverter>* _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<Trade::ImageData2D> actualImageData, expectedImageData;
         PixelFormat actualFormat;
         Containers::StridedArrayView3D<const char> 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<const char>& actualPixels, const std::string& expected) {
+TestSuite::ComparisonStatusFlags ImageComparatorBase::compare(const PixelFormat actualFormat, const Containers::StridedArrayView3D<const char>& actualPixels, const Containers::StringView expected) {
     _state->expectedFilename = expected;
 
     Containers::Pointer<Trade::AbstractImporter> 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<Magnum::DebugTools::CompareImageFile>::operator()(const Containers::StringView actual, const Containers::StringView expected) {
+    return Magnum::DebugTools::Implementation::ImageComparatorBase::operator()(actual, expected);
+}
+
+ComparisonStatusFlags Comparator<Magnum::DebugTools::CompareImageToFile>::operator()(const Magnum::ImageView2D& actual, const Containers::StringView expected) {
+    return Magnum::DebugTools::Implementation::ImageComparatorBase::operator()(actual, expected);
+}
+
+ComparisonStatusFlags Comparator<Magnum::DebugTools::CompareFileToImage>::operator()(const Containers::StringView actual, const Magnum::ImageView2D& expected) {
+    return Magnum::DebugTools::Implementation::ImageComparatorBase::operator()(actual, expected);
+}
+
+}}

src/Magnum/DebugTools/CompareImage.h

@@ -32,7 +32,6 @@
 #include <Corrade/Containers/Pointer.h>
 #include <Corrade/PluginManager/PluginManager.h>
 #include <Corrade/TestSuite/TestSuite.h>
-#include <Corrade/Utility/StlForwardString.h>
 #include <Corrade/Utility/StlForwardTuple.h>
 
 #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<const char>& actualPixels, const ImageView2D& expected);
 
         /* Used in templated CompareImageToFile::operator() */
-        TestSuite::ComparisonStatusFlags compare(PixelFormat actualFormat, const Containers::StridedArrayView3D<const char>& actualPixels, const std::string& expected);
+        TestSuite::ComparisonStatusFlags compare(PixelFormat actualFormat, const Containers::StridedArrayView3D<const char>& 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<Magnum::DebugTools::Compare
 
         /*implicit*/ Comparator(): Comparator{nullptr, nullptr, 0.0f, 0.0f} {}
 
-        ComparisonStatusFlags operator()(const std::string& actual, const std::string& expected) {
-            return Magnum::DebugTools::Implementation::ImageComparatorBase::operator()(actual, expected);
-        }
+        ComparisonStatusFlags operator()(Containers::StringView actual, const Containers::StringView expected);
 };
 
 template<> class MAGNUM_DEBUGTOOLS_EXPORT Comparator<Magnum::DebugTools::CompareImageToFile>: public Magnum::DebugTools::Implementation::ImageComparatorBase {
@@ -141,11 +144,12 @@ template<> class MAGNUM_DEBUGTOOLS_EXPORT Comparator<Magnum::DebugTools::Compare
 
         /*implicit*/ Comparator(): Comparator{nullptr, nullptr, 0.0f, 0.0f} {}
 
-        ComparisonStatusFlags operator()(const Magnum::ImageView2D& actual, const std::string& expected) {
-            return Magnum::DebugTools::Implementation::ImageComparatorBase::operator()(actual, expected);
-        }
+        ComparisonStatusFlags operator()(const Magnum::ImageView2D& actual, Containers::StringView expected);
 
-        template<class T> TestSuite::ComparisonStatusFlags operator()(const Containers::StridedArrayView2D<const T>& 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<class T> TestSuite::ComparisonStatusFlags operator()(const Containers::StridedArrayView2D<const T>& actualPixels, const Containers::StringView& expected) {
             /** @todo do some tryFindCompatibleFormat() here */
             return Magnum::DebugTools::Implementation::ImageComparatorBase::compare(
                 Magnum::DebugTools::Implementation::pixelFormatFor<T>(),
@@ -159,9 +163,7 @@ template<> class MAGNUM_DEBUGTOOLS_EXPORT Comparator<Magnum::DebugTools::Compare
 
         /*implicit*/ Comparator(): Comparator{nullptr, 0.0f, 0.0f} {}
 
-        ComparisonStatusFlags operator()(const std::string& actual, const Magnum::ImageView2D& expected) {
-            return Magnum::DebugTools::Implementation::ImageComparatorBase::operator()(actual, expected);
-        }
+        ComparisonStatusFlags operator()(Containers::StringView actual, const Magnum::ImageView2D& expected);
 };
 
 namespace Implementation {
@@ -183,13 +185,13 @@ template<class T, class U> struct ComparatorTraits<Magnum::DebugTools::CompareIm
    Comparator<CompareImageToFile>::operator() is overloaded */
 template<class T> struct ComparatorTraits<Magnum::DebugTools::CompareImageToFile, Magnum::ImageView2D, T> {
     typedef Magnum::ImageView2D ActualType;
-    typedef std::string ExpectedType;
+    typedef Containers::StringView ExpectedType;
 };
 template<class T> struct ComparatorTraits<Magnum::DebugTools::CompareImageToFile, Magnum::Image2D, T>: ComparatorTraits<Magnum::DebugTools::CompareImageToFile, Magnum::ImageView2D, T> {};
 template<class T> struct ComparatorTraits<Magnum::DebugTools::CompareImageToFile, Magnum::Trade::ImageData2D, T>: ComparatorTraits<Magnum::DebugTools::CompareImageToFile, Magnum::ImageView2D, T> {};
 template<class T, class U> struct ComparatorTraits<Magnum::DebugTools::CompareImageToFile, Containers::StridedArrayView2D<T>, U> {
     typedef Containers::StridedArrayView2D<const T> ActualType;
-    typedef std::string ExpectedType;
+    typedef Containers::StringView ExpectedType;
 };
 
 }

src/Magnum/DebugTools/Test/CompareImageTest.cpp

@@ -28,13 +28,14 @@
 #include <Corrade/Containers/Array.h>
 #include <Corrade/Containers/StridedArrayView.h>
 #include <Corrade/Containers/Optional.h>
+#include <Corrade/Containers/String.h>
 #include <Corrade/PluginManager/Manager.h>
 #include <Corrade/TestSuite/Tester.h>
 #include <Corrade/TestSuite/Compare/Container.h>
 #include <Corrade/TestSuite/Compare/File.h>
 #include <Corrade/Utility/DebugStl.h>
-#include <Corrade/Utility/Directory.h>
 #include <Corrade/Utility/FormatStl.h>
+#include <Corrade/Utility/Path.h>
 #include <Corrade/Utility/String.h>
 
 #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<CompareImageFile> 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<CompareImageFile> 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<CompareImageFile> 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<CompareImageFile> 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<CompareImageFile> 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<CompareImageFile> 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<CompareImageFile> 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<CompareImageFile> 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<CompareImageToFile> 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<CompareImageToFile> 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<CompareImageToFile> 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<CompareImageToFile> 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<CompareImageToFile> 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<CompareFileToImage> 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<CompareFileToImage> 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<CompareFileToImage> 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<CompareFileToImage> 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<CompareFileToImage> 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<Color3ub>(),
-        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<Color3ub>(), expectedFilename,
         (CompareImageToFile{*_importerManager, 40.0f, 20.0f}));
 
     /* No diagnostic as there's no error */
     TestSuite::Comparator<CompareImageToFile> compare{&*_importerManager, nullptr, 40.0f, 20.0f};
-    CORRADE_COMPARE(compare(ExpectedRgb.pixels<Color3ub>(), Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga")),
+    CORRADE_COMPARE(compare(ExpectedRgb.pixels<Color3ub>(), 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<Color3ub>(),
-        Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga"),
+        expectedFilename,
         (CompareImageToFile{*_importerManager, 40.0f, 20.0f}));
 
     std::ostringstream out;
 
     {
         TestSuite::Comparator<CompareImageToFile> compare{&*_importerManager, nullptr, 40.0f, 20.0f};
-        TestSuite::ComparisonStatusFlags flags = compare(ActualRgb.pixels<Color3ub>(), Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga"));
+        TestSuite::ComparisonStatusFlags flags = compare(ActualRgb.pixels<Color3ub>(), 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<CompareImageToFile> compare{&*_importerManager, &*_converterManager, 20.0f, 10.0f};
-    TestSuite::ComparisonStatusFlags flags = compare(ActualRgb.pixels<Color3ub>(),
-        Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga"));
+    TestSuite::ComparisonStatusFlags flags = compare(ActualRgb.pixels<Color3ub>(), 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);
 }
 
 }}}}