ic
/
magnum
mirror of https://github.com/mosra/magnum.git
6
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

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).
pull/556/head
Vladimír Vondruš 4 years ago
parent
e779c0a3e7
commit
a5bc6be094
6 changed files with 244 additions and 136 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 1
      doc/snippets/MagnumDebugTools-gl.cpp
  2. 1
      doc/snippets/MagnumDebugTools.cpp
  3. 8
      doc/snippets/debugtools-compareimage.cpp
  4. 46
      src/Magnum/DebugTools/CompareImage.cpp
  5. 40
      src/Magnum/DebugTools/CompareImage.h
  6. 284
      src/Magnum/DebugTools/Test/CompareImageTest.cpp

1
doc/snippets/MagnumDebugTools-gl.cpp
Unescape View File

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

1
doc/snippets/MagnumDebugTools.cpp
Unescape View File

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

8
doc/snippets/debugtools-compareimage.cpp
Unescape View File

@ -24,9 +24,11 @@
*/ */
#include <Corrade/Containers/Optional.h> #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/PluginManager/Manager.h>
#include <Corrade/TestSuite/Tester.h> #include <Corrade/TestSuite/Tester.h>
#include <Corrade/Utility/Directory.h> #include <Corrade/Utility/Path.h>
#include "Magnum/Image.h" #include "Magnum/Image.h"
#include "Magnum/ImageView.h" #include "Magnum/ImageView.h"
@ -45,7 +47,7 @@ namespace {
Image2D doProcessing() { Image2D doProcessing() {
PluginManager::Manager<Trade::AbstractImporter> manager{MAGNUM_PLUGINS_IMPORTER_DIR}; PluginManager::Manager<Trade::AbstractImporter> manager{MAGNUM_PLUGINS_IMPORTER_DIR};
Containers::Pointer<Trade::AbstractImporter> importer = manager.loadAndInstantiate("TgaImporter"); 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); auto image = importer->image2D(0);
CORRADE_INTERNAL_ASSERT(image); CORRADE_INTERNAL_ASSERT(image);
return Image2D{image->storage(), image->format(), image->size(), image->release()}; return Image2D{image->storage(), image->format(), image->size(), image->release()};
@ -54,7 +56,7 @@ Image2D doProcessing() {
Image2D loadExpectedImage() { Image2D loadExpectedImage() {
PluginManager::Manager<Trade::AbstractImporter> manager{MAGNUM_PLUGINS_IMPORTER_DIR}; PluginManager::Manager<Trade::AbstractImporter> manager{MAGNUM_PLUGINS_IMPORTER_DIR};
Containers::Pointer<Trade::AbstractImporter> importer = manager.loadAndInstantiate("TgaImporter"); 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); auto image = importer->image2D(0);
CORRADE_INTERNAL_ASSERT(image); CORRADE_INTERNAL_ASSERT(image);
return Image2D{image->storage(), image->format(), image->size(), image->release()}; return Image2D{image->storage(), image->format(), image->size(), image->release()};

46
src/Magnum/DebugTools/CompareImage.cpp
Unescape View File

@ -28,13 +28,15 @@
#include <map> #include <map>
#include <sstream> #include <sstream>
#include <Corrade/Containers/Array.h> #include <Corrade/Containers/Array.h>
#include <Corrade/Containers/Pair.h>
#include <Corrade/Containers/StridedArrayView.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/Containers/Optional.h>
#include <Corrade/PluginManager/Manager.h> #include <Corrade/PluginManager/Manager.h>
#include <Corrade/TestSuite/Comparator.h> #include <Corrade/TestSuite/Comparator.h>
#include <Corrade/Utility/DebugStl.h> #include <Corrade/Utility/DebugStl.h>
#include <Corrade/Utility/Directory.h> #include <Corrade/Utility/Path.h>
#include "Magnum/ImageView.h" #include "Magnum/ImageView.h"
#include "Magnum/PixelFormat.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)))]; const char c = Math::isNan(blockMax) ? Characters.back() : Characters[Int(Math::round(Math::min(1.0f, blockMax/max)*(Characters.size() - 1)))];
if(blockMax > maxThreshold) 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) else if(blockMax > meanThreshold)
out << Debug::boldColor(Debug::Color::Yellow) << Debug::nospace << std::string{c} << Debug::resetColor; out << Debug::boldColor(Debug::Color::Yellow) << Debug::nospace << Containers::StringView{&c, 1} << Debug::resetColor;
else out << Debug::nospace << std::string{c}; else out << Debug::nospace << Containers::StringView{&c, 1};
} }
out << Debug::nospace << "|"; out << Debug::nospace << "|";
@ -434,7 +436,9 @@ class ImageComparatorBase::State {
PluginManager::Manager<Trade::AbstractImageConverter>* _converterManager{}; PluginManager::Manager<Trade::AbstractImageConverter>* _converterManager{};
public: 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; Containers::Optional<Trade::ImageData2D> actualImageData, expectedImageData;
PixelFormat actualFormat; PixelFormat actualFormat;
Containers::StridedArrayView3D<const char> actualPixels; Containers::StridedArrayView3D<const char> actualPixels;
@ -511,7 +515,7 @@ TestSuite::ComparisonStatusFlags ImageComparatorBase::operator()(const ImageView
return compare(actual.format(), actual.pixels(), expected); 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->actualFilename = actual;
_state->expectedFilename = expected; _state->expectedFilename = expected;
@ -570,7 +574,7 @@ TestSuite::ComparisonStatusFlags ImageComparatorBase::operator()(const std::stri
return flags; 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; _state->expectedFilename = expected;
Containers::Pointer<Trade::AbstractImporter> importer; Containers::Pointer<Trade::AbstractImporter> importer;
@ -615,11 +619,11 @@ TestSuite::ComparisonStatusFlags ImageComparatorBase::compare(const PixelFormat
return flags; 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); 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; _state->actualFilename = actual;
/* Here we are comparing against a view, not a file, so we cannot save /* 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); 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) { if(_state->result == Result::PluginLoadFailed) {
out << "AnyImageImporter plugin could not be loaded."; out << "AnyImageImporter plugin could not be loaded.";
return; 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 /* 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 it -- the array view might have totally arbitrary strides that can't
be represented in an Image */ 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 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, /* 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 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);
}
}}

40
src/Magnum/DebugTools/CompareImage.h
Unescape View File

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

284
src/Magnum/DebugTools/Test/CompareImageTest.cpp
Unescape View File

@ -28,13 +28,14 @@
#include <Corrade/Containers/Array.h> #include <Corrade/Containers/Array.h>
#include <Corrade/Containers/StridedArrayView.h> #include <Corrade/Containers/StridedArrayView.h>
#include <Corrade/Containers/Optional.h> #include <Corrade/Containers/Optional.h>
#include <Corrade/Containers/String.h>
#include <Corrade/PluginManager/Manager.h> #include <Corrade/PluginManager/Manager.h>
#include <Corrade/TestSuite/Tester.h> #include <Corrade/TestSuite/Tester.h>
#include <Corrade/TestSuite/Compare/Container.h> #include <Corrade/TestSuite/Compare/Container.h>
#include <Corrade/TestSuite/Compare/File.h> #include <Corrade/TestSuite/Compare/File.h>
#include <Corrade/Utility/DebugStl.h> #include <Corrade/Utility/DebugStl.h>
#include <Corrade/Utility/Directory.h>
#include <Corrade/Utility/FormatStl.h> #include <Corrade/Utility/FormatStl.h>
#include <Corrade/Utility/Path.h>
#include <Corrade/Utility/String.h> #include <Corrade/Utility/String.h>
#include "Magnum/ImageView.h" #include "Magnum/ImageView.h"
@ -1026,16 +1027,17 @@ void CompareImageTest::imageFileZeroDelta() {
!(_importerManager->loadState("TgaImporter") & PluginManager::LoadState::Loaded)) !(_importerManager->loadState("TgaImporter") & PluginManager::LoadState::Loaded))
CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found."); CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found.");
CORRADE_COMPARE_WITH( /* The filenames are referenced as string views as the assumption is that
Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga"), the whole comparison and diagnostic printing gets done in a single
Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga"), 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})); (CompareImageFile{*_importerManager, 40.0f, 20.0f}));
/* No diagnostic as there's no error */ /* No diagnostic as there's no error */
TestSuite::Comparator<CompareImageFile> compare{&*_importerManager, nullptr, 40.0f, 20.0f}; TestSuite::Comparator<CompareImageFile> compare{&*_importerManager, nullptr, 40.0f, 20.0f};
CORRADE_COMPARE(compare( CORRADE_COMPARE(compare(expectedFilename, expectedFilename),
Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga"),
Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga")),
TestSuite::ComparisonStatusFlag{}); TestSuite::ComparisonStatusFlag{});
} }
@ -1044,19 +1046,21 @@ void CompareImageTest::imageFileNonZeroDelta() {
!(_importerManager->loadState("TgaImporter") & PluginManager::LoadState::Loaded)) !(_importerManager->loadState("TgaImporter") & PluginManager::LoadState::Loaded))
CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found."); 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 */ /* This will produce output if --verbose is specified */
CORRADE_COMPARE_WITH( CORRADE_COMPARE_WITH(actualFilename, expectedFilename,
Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageActual.tga"),
Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga"),
(CompareImageFile{*_importerManager, 40.0f, 20.0f})); (CompareImageFile{*_importerManager, 40.0f, 20.0f}));
std::ostringstream out; std::ostringstream out;
{ {
TestSuite::Comparator<CompareImageFile> compare{&*_importerManager, nullptr, 40.0f, 20.0f}; TestSuite::Comparator<CompareImageFile> compare{&*_importerManager, nullptr, 40.0f, 20.0f};
TestSuite::ComparisonStatusFlags flags = compare( TestSuite::ComparisonStatusFlags flags = compare(actualFilename, expectedFilename);
Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageActual.tga"),
Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga"));
/* No diagnostic as there's no error */ /* No diagnostic as there's no error */
CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Verbose); CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Verbose);
Debug d{&out, Debug::Flag::DisableColors}; Debug d{&out, Debug::Flag::DisableColors};
@ -1074,9 +1078,13 @@ void CompareImageTest::imageFileError() {
std::stringstream out; std::stringstream out;
TestSuite::Comparator<CompareImageFile> compare{&*_importerManager, &*_converterManager, 20.0f, 10.0f}; TestSuite::Comparator<CompareImageFile> compare{&*_importerManager, &*_converterManager, 20.0f, 10.0f};
TestSuite::ComparisonStatusFlags flags = compare( /* The filenames are referenced as string views as the assumption is that
Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageActual.tga"), the whole comparison and diagnostic printing gets done in a single
Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga")); 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 /* The diagnostic flag should be slapped on the failure coming from the
operator() comparing two ImageViews */ operator() comparing two ImageViews */
CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Failed|TestSuite::ComparisonStatusFlag::Diagnostic); 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 /* Create the output dir if it doesn't exist, but avoid stale files making
false positives */ false positives */
CORRADE_VERIFY(Utility::Directory::mkpath(COMPAREIMAGETEST_SAVE_DIR)); CORRADE_VERIFY(Utility::Path::make(COMPAREIMAGETEST_SAVE_DIR));
std::string filename = Utility::Directory::join(COMPAREIMAGETEST_SAVE_DIR, "CompareImageExpected.tga"); Containers::String filename = Utility::Path::join(COMPAREIMAGETEST_SAVE_DIR, "CompareImageExpected.tga");
if(Utility::Directory::exists(filename)) if(Utility::Path::exists(filename))
CORRADE_VERIFY(Utility::Directory::rm(filename)); CORRADE_VERIFY(Utility::Path::remove(filename));
if(!(_converterManager->loadState("AnyImageConverter") & PluginManager::LoadState::Loaded) || if(!(_converterManager->loadState("AnyImageConverter") & PluginManager::LoadState::Loaded) ||
!(_converterManager->loadState("TgaImageConverter") & PluginManager::LoadState::Loaded)) !(_converterManager->loadState("TgaImageConverter") & PluginManager::LoadState::Loaded))
@ -1110,7 +1118,7 @@ void CompareImageTest::imageFileError() {
file. */ file. */
CORRADE_COMPARE(out.str(), Utility::formatString("-> {}\n", filename)); CORRADE_COMPARE(out.str(), Utility::formatString("-> {}\n", filename));
CORRADE_COMPARE_AS(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() { void CompareImageTest::imageFilePluginLoadFailed() {
@ -1122,9 +1130,13 @@ void CompareImageTest::imageFilePluginLoadFailed() {
{ {
TestSuite::Comparator<CompareImageFile> compare{&manager, nullptr, 20.0f, 10.0f}; TestSuite::Comparator<CompareImageFile> compare{&manager, nullptr, 20.0f, 10.0f};
TestSuite::ComparisonStatusFlags flags = compare( /* The filenames are referenced as string views as the assumption is
Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageActual.tga"), that the whole comparison and diagnostic printing gets done in a
Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga")); 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 /* Can't load a plugin, so we can't open the file, so we can't save
it either and thus no diagnostic */ it either and thus no diagnostic */
CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Failed); CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Failed);
@ -1144,8 +1156,12 @@ void CompareImageTest::imageFileActualLoadFailed() {
{ {
TestSuite::Comparator<CompareImageFile> compare{&*_importerManager, nullptr, 20.0f, 10.0f}; TestSuite::Comparator<CompareImageFile> compare{&*_importerManager, nullptr, 20.0f, 10.0f};
TestSuite::ComparisonStatusFlags flags = compare("nonexistent.tga", /* The filenames are referenced as string views as the assumption is
Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga")); 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 /* We can't open the file, so we can't save it either and thus no
diagnostic */ diagnostic */
CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Failed); CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Failed);
@ -1164,9 +1180,12 @@ void CompareImageTest::imageFileExpectedLoadFailed() {
std::stringstream out; std::stringstream out;
TestSuite::Comparator<CompareImageFile> compare{&*_importerManager, &*_converterManager, 20.0f, 10.0f}; TestSuite::Comparator<CompareImageFile> compare{&*_importerManager, &*_converterManager, 20.0f, 10.0f};
TestSuite::ComparisonStatusFlags flags = compare( /* The filenames are referenced as string views as the assumption is that
Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageActual.tga"), the whole comparison and diagnostic printing gets done in a single
"nonexistent.tga"); 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! */ /* Actual file *could* be loaded, so save it! */
CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Failed|TestSuite::ComparisonStatusFlag::Diagnostic); 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 /* Create the output dir if it doesn't exist, but avoid stale files making
false positives */ false positives */
CORRADE_VERIFY(Utility::Directory::mkpath(COMPAREIMAGETEST_SAVE_DIR)); CORRADE_VERIFY(Utility::Path::make(COMPAREIMAGETEST_SAVE_DIR));
std::string filename = Utility::Directory::join(COMPAREIMAGETEST_SAVE_DIR, "nonexistent.tga"); Containers::String filename = Utility::Path::join(COMPAREIMAGETEST_SAVE_DIR, "nonexistent.tga");
if(Utility::Directory::exists(filename)) if(Utility::Path::exists(filename))
CORRADE_VERIFY(Utility::Directory::rm(filename)); CORRADE_VERIFY(Utility::Path::remove(filename));
if(!(_converterManager->loadState("AnyImageConverter") & PluginManager::LoadState::Loaded) || if(!(_converterManager->loadState("AnyImageConverter") & PluginManager::LoadState::Loaded) ||
!(_converterManager->loadState("TgaImageConverter") & PluginManager::LoadState::Loaded)) !(_converterManager->loadState("TgaImageConverter") & PluginManager::LoadState::Loaded))
@ -1199,7 +1218,7 @@ void CompareImageTest::imageFileExpectedLoadFailed() {
file. */ file. */
CORRADE_COMPARE(out.str(), Utility::formatString("-> {}\n", filename)); CORRADE_COMPARE(out.str(), Utility::formatString("-> {}\n", filename));
CORRADE_COMPARE_AS(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() { void CompareImageTest::imageFileActualIsCompressed() {
@ -1212,9 +1231,13 @@ void CompareImageTest::imageFileActualIsCompressed() {
{ {
TestSuite::Comparator<CompareImageFile> compare{&manager, nullptr, 20.0f, 10.0f}; TestSuite::Comparator<CompareImageFile> compare{&manager, nullptr, 20.0f, 10.0f};
TestSuite::ComparisonStatusFlags flags = compare( /* The filenames are referenced as string views as the assumption is
Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageCompressed.dds"), that the whole comparison and diagnostic printing gets done in a
Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga")); 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 /* We most probably couldn't save the file because it's in a different
format, so no diagnostic */ format, so no diagnostic */
CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Failed); CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Failed);
@ -1234,9 +1257,13 @@ void CompareImageTest::imageFileExpectedIsCompressed() {
std::stringstream out; std::stringstream out;
TestSuite::Comparator<CompareImageFile> compare{&manager, nullptr, 20.0f, 10.0f}; TestSuite::Comparator<CompareImageFile> compare{&manager, nullptr, 20.0f, 10.0f};
TestSuite::ComparisonStatusFlags flags = compare( /* The filenames are referenced as string views as the assumption is that
Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageActual.tga"), the whole comparison and diagnostic printing gets done in a single
Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageCompressed.dds")); 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! */ /* Actual file is not, so save it! */
CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Failed|TestSuite::ComparisonStatusFlag::Diagnostic); 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 /* Create the output dir if it doesn't exist, but avoid stale files making
false positives */ false positives */
CORRADE_VERIFY(Utility::Directory::mkpath(COMPAREIMAGETEST_SAVE_DIR)); CORRADE_VERIFY(Utility::Path::make(COMPAREIMAGETEST_SAVE_DIR));
std::string filename = Utility::Directory::join(COMPAREIMAGETEST_SAVE_DIR, "CompareImageCompressed.dds"); Containers::String filename = Utility::Path::join(COMPAREIMAGETEST_SAVE_DIR, "CompareImageCompressed.dds");
if(Utility::Directory::exists(filename)) if(Utility::Path::exists(filename))
CORRADE_VERIFY(Utility::Directory::rm(filename)); CORRADE_VERIFY(Utility::Path::remove(filename));
/* This will attempt to save a DDS and then fails, because we have no DDS /* This will attempt to save a DDS and then fails, because we have no DDS
exporter. */ exporter. */
Debug d; Debug d;
compare.saveDiagnostic(flags, d, COMPAREIMAGETEST_SAVE_DIR); compare.saveDiagnostic(flags, d, COMPAREIMAGETEST_SAVE_DIR);
CORRADE_VERIFY(!Utility::Directory::exists(filename)); CORRADE_VERIFY(!Utility::Path::exists(filename));
} }
void CompareImageTest::imageToFileZeroDelta() { void CompareImageTest::imageToFileZeroDelta() {
@ -1264,13 +1291,18 @@ void CompareImageTest::imageToFileZeroDelta() {
!(_importerManager->loadState("TgaImporter") & PluginManager::LoadState::Loaded)) !(_importerManager->loadState("TgaImporter") & PluginManager::LoadState::Loaded))
CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found."); CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found.");
CORRADE_COMPARE_WITH(ExpectedRgb, /* The filenames are referenced as string views as the assumption is that
Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga"), 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})); (CompareImageToFile{*_importerManager, 40.0f, 20.0f}));
/* No diagnostic as there's no error */ /* No diagnostic as there's no error */
TestSuite::Comparator<CompareImageToFile> compare{&*_importerManager, nullptr, 40.0f, 20.0f}; 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{}); TestSuite::ComparisonStatusFlags{});
} }
@ -1279,16 +1311,21 @@ void CompareImageTest::imageToFileNonZeroDelta() {
!(_importerManager->loadState("TgaImporter") & PluginManager::LoadState::Loaded)) !(_importerManager->loadState("TgaImporter") & PluginManager::LoadState::Loaded))
CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found."); 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 */ /* This will produce output if --verbose is specified */
CORRADE_COMPARE_WITH(ActualRgb, CORRADE_COMPARE_WITH(ActualRgb, expectedFilename,
Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga"),
(CompareImageToFile{*_importerManager, 40.0f, 20.0f})); (CompareImageToFile{*_importerManager, 40.0f, 20.0f}));
std::ostringstream out; std::ostringstream out;
{ {
TestSuite::Comparator<CompareImageToFile> compare{&*_importerManager, nullptr, 40.0f, 20.0f}; 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 */ /* No diagnostic as there's no error */
CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Verbose); CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Verbose);
Debug d{&out, Debug::Flag::DisableColors}; Debug d{&out, Debug::Flag::DisableColors};
@ -1306,8 +1343,12 @@ void CompareImageTest::imageToFileError() {
std::stringstream out; std::stringstream out;
TestSuite::Comparator<CompareImageToFile> compare{&*_importerManager, &*_converterManager, 20.0f, 10.0f}; TestSuite::Comparator<CompareImageToFile> compare{&*_importerManager, &*_converterManager, 20.0f, 10.0f};
TestSuite::ComparisonStatusFlags flags = compare(ActualRgb, /* The filenames are referenced as string views as the assumption is that
Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga")); 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 /* The diagnostic flag should be slapped on the failure coming from the
operator() comparing two ImageViews */ operator() comparing two ImageViews */
CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Failed|TestSuite::ComparisonStatusFlag::Diagnostic); 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 /* Create the output dir if it doesn't exist, but avoid stale files making
false positives */ false positives */
CORRADE_VERIFY(Utility::Directory::mkpath(COMPAREIMAGETEST_SAVE_DIR)); CORRADE_VERIFY(Utility::Path::make(COMPAREIMAGETEST_SAVE_DIR));
std::string filename = Utility::Directory::join(COMPAREIMAGETEST_SAVE_DIR, "CompareImageExpected.tga"); Containers::String filename = Utility::Path::join(COMPAREIMAGETEST_SAVE_DIR, "CompareImageExpected.tga");
if(Utility::Directory::exists(filename)) if(Utility::Path::exists(filename))
CORRADE_VERIFY(Utility::Directory::rm(filename)); CORRADE_VERIFY(Utility::Path::remove(filename));
if(!(_converterManager->loadState("AnyImageConverter") & PluginManager::LoadState::Loaded) || if(!(_converterManager->loadState("AnyImageConverter") & PluginManager::LoadState::Loaded) ||
!(_converterManager->loadState("TgaImageConverter") & PluginManager::LoadState::Loaded)) !(_converterManager->loadState("TgaImageConverter") & PluginManager::LoadState::Loaded))
@ -1341,7 +1382,7 @@ void CompareImageTest::imageToFileError() {
file. */ file. */
CORRADE_COMPARE(out.str(), Utility::formatString("-> {}\n", filename)); CORRADE_COMPARE(out.str(), Utility::formatString("-> {}\n", filename));
CORRADE_COMPARE_AS(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() { void CompareImageTest::imageToFilePluginLoadFailed() {
@ -1353,8 +1394,12 @@ void CompareImageTest::imageToFilePluginLoadFailed() {
{ {
TestSuite::Comparator<CompareImageToFile> compare{&manager, nullptr, 20.0f, 10.0f}; TestSuite::Comparator<CompareImageToFile> compare{&manager, nullptr, 20.0f, 10.0f};
TestSuite::ComparisonStatusFlags flags = compare(ActualRgb, /* The filenames are referenced as string views as the assumption is
Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga")); 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 /* Can't load a plugin, so we can't open the file, so we can't save
it either and thus no diagnostic */ it either and thus no diagnostic */
CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Failed); 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 /* Create the output dir if it doesn't exist, but avoid stale files making
false positives */ false positives */
CORRADE_VERIFY(Utility::Directory::mkpath(COMPAREIMAGETEST_SAVE_DIR)); CORRADE_VERIFY(Utility::Path::make(COMPAREIMAGETEST_SAVE_DIR));
std::string filename = Utility::Directory::join(COMPAREIMAGETEST_SAVE_DIR, "nonexistent.tga"); Containers::String filename = Utility::Path::join(COMPAREIMAGETEST_SAVE_DIR, "nonexistent.tga");
if(Utility::Directory::exists(filename)) if(Utility::Path::exists(filename))
CORRADE_VERIFY(Utility::Directory::rm(filename)); CORRADE_VERIFY(Utility::Path::remove(filename));
if(!(_converterManager->loadState("AnyImageConverter") & PluginManager::LoadState::Loaded) || if(!(_converterManager->loadState("AnyImageConverter") & PluginManager::LoadState::Loaded) ||
!(_converterManager->loadState("TgaImageConverter") & PluginManager::LoadState::Loaded)) !(_converterManager->loadState("TgaImageConverter") & PluginManager::LoadState::Loaded))
@ -1406,7 +1451,7 @@ void CompareImageTest::imageToFileExpectedLoadFailed() {
file. */ file. */
CORRADE_COMPARE(out.str(), Utility::formatString("-> {}\n", filename)); CORRADE_COMPARE(out.str(), Utility::formatString("-> {}\n", filename));
CORRADE_COMPARE_AS(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() { void CompareImageTest::imageToFileExpectedIsCompressed() {
@ -1418,8 +1463,12 @@ void CompareImageTest::imageToFileExpectedIsCompressed() {
std::stringstream out; std::stringstream out;
TestSuite::Comparator<CompareImageToFile> compare{&manager, nullptr, 20.0f, 10.0f}; TestSuite::Comparator<CompareImageToFile> compare{&manager, nullptr, 20.0f, 10.0f};
TestSuite::ComparisonStatusFlags flags = compare(ActualRgb, /* The filenames are referenced as string views as the assumption is that
Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageCompressed.dds")); 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! */ /* Actual file is not, so save it! */
CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Failed|TestSuite::ComparisonStatusFlag::Diagnostic); 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 /* Create the output dir if it doesn't exist, but avoid stale files making
false positives */ false positives */
CORRADE_VERIFY(Utility::Directory::mkpath(COMPAREIMAGETEST_SAVE_DIR)); CORRADE_VERIFY(Utility::Path::make(COMPAREIMAGETEST_SAVE_DIR));
std::string filename = Utility::Directory::join(COMPAREIMAGETEST_SAVE_DIR, "CompareImageCompressed.dds"); Containers::String filename = Utility::Path::join(COMPAREIMAGETEST_SAVE_DIR, "CompareImageCompressed.dds");
if(Utility::Directory::exists(filename)) if(Utility::Path::exists(filename))
CORRADE_VERIFY(Utility::Directory::rm(filename)); CORRADE_VERIFY(Utility::Path::remove(filename));
/* This will attempt to save a DDS and then fails, because we have no DDS /* This will attempt to save a DDS and then fails, because we have no DDS
exporter. */ exporter. */
Debug d; Debug d;
compare.saveDiagnostic(flags, d, COMPAREIMAGETEST_SAVE_DIR); compare.saveDiagnostic(flags, d, COMPAREIMAGETEST_SAVE_DIR);
CORRADE_VERIFY(!Utility::Directory::exists(filename)); CORRADE_VERIFY(!Utility::Path::exists(filename));
} }
void CompareImageTest::fileToImageZeroDelta() { void CompareImageTest::fileToImageZeroDelta() {
@ -1450,15 +1499,18 @@ void CompareImageTest::fileToImageZeroDelta() {
!(_importerManager->loadState("TgaImporter") & PluginManager::LoadState::Loaded)) !(_importerManager->loadState("TgaImporter") & PluginManager::LoadState::Loaded))
CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found."); CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found.");
CORRADE_COMPARE_WITH( /* The filenames are referenced as string views as the assumption is that
Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga"), the whole comparison and diagnostic printing gets done in a single
ExpectedRgb, 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})); (CompareFileToImage{*_importerManager, 40.0f, 20.0f}));
/* No diagnostic as there's no error */ /* No diagnostic as there's no error */
TestSuite::Comparator<CompareFileToImage> compare{&*_importerManager, 40.0f, 20.0f}; TestSuite::Comparator<CompareFileToImage> compare{&*_importerManager, 40.0f, 20.0f};
CORRADE_COMPARE(compare(Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga"), CORRADE_COMPARE(compare(expectedFilename, ExpectedRgb), TestSuite::ComparisonStatusFlags{});
ExpectedRgb), TestSuite::ComparisonStatusFlags{});
} }
void CompareImageTest::fileToImageNonZeroDelta() { void CompareImageTest::fileToImageNonZeroDelta() {
@ -1466,18 +1518,21 @@ void CompareImageTest::fileToImageNonZeroDelta() {
!(_importerManager->loadState("TgaImporter") & PluginManager::LoadState::Loaded)) !(_importerManager->loadState("TgaImporter") & PluginManager::LoadState::Loaded))
CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found."); 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 */ /* This will produce output if --verbose is specified */
CORRADE_COMPARE_WITH( CORRADE_COMPARE_WITH(actualFilename, ExpectedRgb,
Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageActual.tga"),
ExpectedRgb,
(CompareFileToImage{*_importerManager, 40.0f, 20.0f})); (CompareFileToImage{*_importerManager, 40.0f, 20.0f}));
std::ostringstream out; std::ostringstream out;
{ {
TestSuite::Comparator<CompareFileToImage> compare{&*_importerManager, 40.0f, 20.0f}; TestSuite::Comparator<CompareFileToImage> compare{&*_importerManager, 40.0f, 20.0f};
TestSuite::ComparisonStatusFlags flags = compare(Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageActual.tga"), TestSuite::ComparisonStatusFlags flags = compare(actualFilename, ExpectedRgb);
ExpectedRgb);
/* No diagnostic as there's no error */ /* No diagnostic as there's no error */
CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Verbose); CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Verbose);
Debug d{&out, Debug::Flag::DisableColors}; Debug d{&out, Debug::Flag::DisableColors};
@ -1496,9 +1551,12 @@ void CompareImageTest::fileToImageError() {
{ {
TestSuite::Comparator<CompareFileToImage> compare{&*_importerManager, 20.0f, 10.0f}; TestSuite::Comparator<CompareFileToImage> compare{&*_importerManager, 20.0f, 10.0f};
TestSuite::ComparisonStatusFlags flags = compare( /* The filenames are referenced as string views as the assumption is
Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageActual.tga"), that the whole comparison and diagnostic printing gets done in a
ExpectedRgb); 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 */ /* No diagnostic as we don't have any expected filename */
CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Failed); CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Failed);
Debug d{&out, Debug::Flag::DisableColors}; Debug d{&out, Debug::Flag::DisableColors};
@ -1517,9 +1575,12 @@ void CompareImageTest::fileToImagePluginLoadFailed() {
{ {
TestSuite::Comparator<CompareFileToImage> compare{&manager, 20.0f, 10.0f}; TestSuite::Comparator<CompareFileToImage> compare{&manager, 20.0f, 10.0f};
TestSuite::ComparisonStatusFlags flags = compare( /* The filenames are referenced as string views as the assumption is
Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageActual.tga"), that the whole comparison and diagnostic printing gets done in a
ExpectedRgb); 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 */ /* No diagnostic as we don't have any expected filename */
CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Failed); CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Failed);
Debug d{&out, Debug::Flag::DisableColors}; Debug d{&out, Debug::Flag::DisableColors};
@ -1558,7 +1619,12 @@ void CompareImageTest::fileToImageActualIsCompressed() {
{ {
TestSuite::Comparator<CompareFileToImage> compare{&manager, 20.0f, 10.0f}; 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 */ /* No diagnostic as we don't have any expected filename */
CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Failed); CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Failed);
Debug d{&out, Debug::Flag::DisableColors}; Debug d{&out, Debug::Flag::DisableColors};
@ -1625,13 +1691,18 @@ void CompareImageTest::pixelsToFileZeroDelta() {
!(_importerManager->loadState("TgaImporter") & PluginManager::LoadState::Loaded)) !(_importerManager->loadState("TgaImporter") & PluginManager::LoadState::Loaded))
CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found."); CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found.");
CORRADE_COMPARE_WITH(ExpectedRgb.pixels<Color3ub>(), /* The filenames are referenced as string views as the assumption is that
Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga"), 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})); (CompareImageToFile{*_importerManager, 40.0f, 20.0f}));
/* No diagnostic as there's no error */ /* No diagnostic as there's no error */
TestSuite::Comparator<CompareImageToFile> compare{&*_importerManager, nullptr, 40.0f, 20.0f}; 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{}); TestSuite::ComparisonStatusFlags{});
} }
@ -1642,15 +1713,21 @@ void CompareImageTest::pixelsToFileNonZeroDelta() {
!(_importerManager->loadState("TgaImporter") & PluginManager::LoadState::Loaded)) !(_importerManager->loadState("TgaImporter") & PluginManager::LoadState::Loaded))
CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found."); 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>(), CORRADE_COMPARE_WITH(ActualRgb.pixels<Color3ub>(),
Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga"), expectedFilename,
(CompareImageToFile{*_importerManager, 40.0f, 20.0f})); (CompareImageToFile{*_importerManager, 40.0f, 20.0f}));
std::ostringstream out; std::ostringstream out;
{ {
TestSuite::Comparator<CompareImageToFile> compare{&*_importerManager, nullptr, 40.0f, 20.0f}; 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 */ /* No diagnostic as there's no error */
CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Verbose); CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Verbose);
Debug d{&out, Debug::Flag::DisableColors}; Debug d{&out, Debug::Flag::DisableColors};
@ -1667,11 +1744,16 @@ void CompareImageTest::pixelsToFileError() {
!(_importerManager->loadState("TgaImporter") & PluginManager::LoadState::Loaded)) !(_importerManager->loadState("TgaImporter") & PluginManager::LoadState::Loaded))
CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found."); 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; std::stringstream out;
TestSuite::Comparator<CompareImageToFile> compare{&*_importerManager, &*_converterManager, 20.0f, 10.0f}; TestSuite::Comparator<CompareImageToFile> compare{&*_importerManager, &*_converterManager, 20.0f, 10.0f};
TestSuite::ComparisonStatusFlags flags = compare(ActualRgb.pixels<Color3ub>(), TestSuite::ComparisonStatusFlags flags = compare(ActualRgb.pixels<Color3ub>(), expectedFilename);
Utility::Directory::join(DEBUGTOOLS_TEST_DIR, "CompareImageExpected.tga"));
/* The diagnostic flag should be slapped on the failure coming from the /* The diagnostic flag should be slapped on the failure coming from the
operator() comparing two ImageViews */ operator() comparing two ImageViews */
CORRADE_COMPARE(flags, TestSuite::ComparisonStatusFlag::Failed|TestSuite::ComparisonStatusFlag::Diagnostic); 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 /* Create the output dir if it doesn't exist, but avoid stale files making
false positives */ false positives */
CORRADE_VERIFY(Utility::Directory::mkpath(COMPAREIMAGETEST_SAVE_DIR)); CORRADE_VERIFY(Utility::Path::make(COMPAREIMAGETEST_SAVE_DIR));
std::string filename = Utility::Directory::join(COMPAREIMAGETEST_SAVE_DIR, "CompareImageExpected.tga"); Containers::String filename = Utility::Path::join(COMPAREIMAGETEST_SAVE_DIR, "CompareImageExpected.tga");
if(Utility::Directory::exists(filename)) if(Utility::Path::exists(filename))
CORRADE_VERIFY(Utility::Directory::rm(filename)); CORRADE_VERIFY(Utility::Path::remove(filename));
if(!(_converterManager->loadState("AnyImageConverter") & PluginManager::LoadState::Loaded) || if(!(_converterManager->loadState("AnyImageConverter") & PluginManager::LoadState::Loaded) ||
!(_converterManager->loadState("TgaImageConverter") & PluginManager::LoadState::Loaded)) !(_converterManager->loadState("TgaImageConverter") & PluginManager::LoadState::Loaded))
@ -1705,7 +1787,7 @@ void CompareImageTest::pixelsToFileError() {
file. */ file. */
CORRADE_COMPARE(out.str(), Utility::formatString("-> {}\n", filename)); CORRADE_COMPARE(out.str(), Utility::formatString("-> {}\n", filename));
CORRADE_COMPARE_AS(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);
} }
}}}} }}}}

Write Preview
Loading…
Cancel
Save