mirror of
https://github.com/overte-org/overte.git
synced 2025-04-25 20:16:16 +02:00
248 lines
9.6 KiB
C++
248 lines
9.6 KiB
C++
//
|
|
// QTestExtensions.hpp
|
|
// tests/
|
|
//
|
|
// Created by Seiji Emery on 6/20/15.
|
|
// Copyright 2015 High Fidelity, Inc.
|
|
//
|
|
// Distributed under the Apache License, Version 2.0.
|
|
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
|
|
//
|
|
|
|
#ifndef hifi_QTestExtensions_hpp
|
|
#define hifi_QTestExtensions_hpp
|
|
|
|
#include <QtTest/QtTest>
|
|
#include <functional>
|
|
|
|
// Implements several extensions to QtTest.
|
|
//
|
|
// Problems with QtTest:
|
|
// - QCOMPARE can compare float values (using a fuzzy compare), but uses an internal threshold
|
|
// that cannot be set explicitely (and we need explicit, adjustable error thresholds for our physics
|
|
// and math test code).
|
|
// - QFAIL takes a const char * failure message, and writing custom messages to it is complicated.
|
|
//
|
|
// To solve this, we have:
|
|
// - QFUZZY_COMPARE (compares floats, or *any other type* using explicitely defined error thresholds.
|
|
// To use it, you need to have a fuzzyCompare function ((T, T) -> V), and operator << for QTextStream).
|
|
// - QFAIL_WITH_MESSAGE("some " << streamed << " message"), which builds, writes to, and stringifies
|
|
// a QTextStream using black magic.
|
|
// - QCOMPARE_WITH_LAMBDA / QCOMPARE_WITH_FUNCTION, which implements QCOMPARE, but with a user-defined
|
|
// test function ((T, T) -> bool).
|
|
// - A simple framework to write additional custom test macros as needed (QCOMPARE is reimplemented
|
|
// from scratch using QTest::qFail, for example).
|
|
//
|
|
|
|
|
|
// Generates a QCOMPARE-style failure message that can be passed to QTest::qFail.
|
|
//
|
|
// Formatting looks like this:
|
|
// <qFail message> <failMessage....>
|
|
// Actual: (<stringified actual expr>) : <actual value>
|
|
// Expected: (<stringified expected expr>): <expected value>
|
|
// < additional messages (should be separated by "\n\t" for indent formatting)>
|
|
// Loc: [<file path....>(<linenum>)]
|
|
//
|
|
// Additional messages (after actual/expected) can be written using the std::function callback.
|
|
// If these messages span more than one line, wrap them with "\n\t" to get proper indentation / formatting)
|
|
//
|
|
template <typename T>
|
|
inline QString QTest_generateCompareFailureMessage (
|
|
const char * failMessage,
|
|
const T & actual, const T & expected,
|
|
const char * actual_expr, const char * expected_expr,
|
|
std::function<QTextStream & (QTextStream &)> writeAdditionalMessages
|
|
) {
|
|
QString s1 = actual_expr, s2 = expected_expr;
|
|
int pad1_ = qMax(s2.length() - s1.length(), 0);
|
|
int pad2_ = qMax(s1.length() - s2.length(), 0);
|
|
|
|
QString pad1 = QString(")").rightJustified(pad1_, ' ');
|
|
QString pad2 = QString(")").rightJustified(pad2_, ' ');
|
|
|
|
QString msg;
|
|
QTextStream stream (&msg);
|
|
stream << failMessage << "\n\t"
|
|
"Actual: (" << actual_expr << pad1 << ": " << actual << "\n\t"
|
|
"Expected: (" << expected_expr << pad2 << ": " << expected << "\n\t";
|
|
writeAdditionalMessages(stream);
|
|
return msg;
|
|
}
|
|
|
|
// Generates a QCOMPARE-style failure message that can be passed to QTest::qFail.
|
|
//
|
|
// Formatting looks like this:
|
|
// <qFail message> <failMessage....>
|
|
// Actual: (<stringified actual expr>) : <actual value>
|
|
// Expected: (<stringified expected expr>): <expected value>
|
|
// Loc: [<file path....>(<linenum>)]
|
|
// (no message callback)
|
|
//
|
|
template <typename T>
|
|
inline QString QTest_generateCompareFailureMessage (
|
|
const char * failMessage,
|
|
const T & actual, const T & expected,
|
|
const char * actual_expr, const char * expected_expr
|
|
) {
|
|
QString s1 = actual_expr, s2 = expected_expr;
|
|
int pad1_ = qMax(s2.length() - s1.length(), 0);
|
|
int pad2_ = qMax(s1.length() - s2.length(), 0);
|
|
|
|
QString pad1 = QString("): ").rightJustified(pad1_, ' ');
|
|
QString pad2 = QString("): ").rightJustified(pad2_, ' ');
|
|
|
|
QString msg;
|
|
QTextStream stream (&msg);
|
|
stream << failMessage << "\n\t"
|
|
"Actual: (" << actual_expr << pad1 << actual << "\n\t"
|
|
"Expected: (" << expected_expr << pad2 << expected;
|
|
return msg;
|
|
}
|
|
|
|
// Hacky function that can assemble a QString from a QTextStream via a callback
|
|
// (ie. stream operations w/out qDebug())
|
|
inline QString makeMessageFromStream (std::function<void(QTextStream &)> writeMessage) {
|
|
QString msg;
|
|
QTextStream stream(&msg);
|
|
writeMessage(stream);
|
|
return msg;
|
|
}
|
|
|
|
inline void QTest_failWithCustomMessage (
|
|
std::function<void(QTextStream &stream)> writeMessage, int line, const char *file
|
|
) {
|
|
QTest::qFail(qPrintable(makeMessageFromStream(writeMessage)), file, line);
|
|
}
|
|
|
|
// Equivalent to QFAIL, but takes a message that can be formatted using stream operators.
|
|
// Writes to a QTextStream internally, and calls QTest::qFail (the internal impl of QFAIL,
|
|
// with the current file and line number)
|
|
//
|
|
// example:
|
|
// inline void foo () {
|
|
// int thing = 2;
|
|
// QFAIL_WITH_MESSAGE("Message " << thing << ";");
|
|
// }
|
|
//
|
|
#define QFAIL_WITH_MESSAGE(...) \
|
|
do { \
|
|
QTest_failWithCustomMessage([&](QTextStream& stream) { stream << __VA_ARGS__; }, __LINE__, __FILE__); \
|
|
return; \
|
|
} while(0)
|
|
|
|
// Calls qFail using QTest_generateCompareFailureMessage.
|
|
// This is (usually) wrapped in macros, but if you call this directly you should return immediately to get QFAIL semantics.
|
|
template <typename T>
|
|
inline void QTest_failWithMessage(
|
|
const char * failMessage,
|
|
const T & actual, const T & expected,
|
|
const char * actualExpr, const char * expectedExpr,
|
|
int line, const char * file
|
|
) {
|
|
QTest::qFail(qPrintable(QTest_generateCompareFailureMessage(failMessage, actual, expected, actualExpr, expectedExpr)), file, line);
|
|
}
|
|
|
|
// Calls qFail using QTest_generateCompareFailureMessage.
|
|
// This is (usually) wrapped in macros, but if you call this directly you should return immediately to get QFAIL semantics.
|
|
template <typename T>
|
|
inline void QTest_failWithMessage(
|
|
const char * failMessage,
|
|
const T & actual, const T & expected,
|
|
const char * actualExpr, const char * expectedExpr,
|
|
int line, const char * file,
|
|
std::function<QTextStream &(QTextStream&)> writeAdditionalMessageLines
|
|
) {
|
|
QTest::qFail(qPrintable(QTest_generateCompareFailureMessage(failMessage, actual, expected, actualExpr, expectedExpr, writeAdditionalMessageLines)), file, line);
|
|
}
|
|
|
|
// Implements QFUZZY_COMPARE
|
|
template <typename T, typename V>
|
|
inline auto QTest_fuzzyCompare(const T & actual, const T & expected, const char * actual_expr, const char * expected_expr, int line, const char * file, const V & epsilon) -> decltype(fuzzyCompare(actual, expected))
|
|
{
|
|
if (fuzzyCompare(actual, expected) > epsilon) {
|
|
QTest_failWithMessage(
|
|
"Compared values are not the same (fuzzy compare)",
|
|
actual, expected, actual_expr, expected_expr, line, file,
|
|
[&] (QTextStream & stream) -> QTextStream & {
|
|
return stream << "Err tolerance: " << fuzzyCompare((actual), (expected)) << " > " << epsilon;
|
|
});
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Implements a fuzzy QCOMPARE using an explicit epsilon error value.
|
|
// If you use this, you must have the following functions defined for the types you're using:
|
|
// <T, V> V fuzzyCompare (const T& a, const T& b) (should return the absolute, max difference between a and b)
|
|
// <T> QTextStream & operator << (QTextStream& stream, const T& value)
|
|
//
|
|
// Here's an implementation for glm::vec3:
|
|
// inline float fuzzyCompare (const glm::vec3 & a, const glm::vec3 & b) { // returns
|
|
// return glm::distance(a, b);
|
|
// }
|
|
// inline QTextStream & operator << (QTextStream & stream, const T & v) {
|
|
// return stream << "glm::vec3 { " << v.x << ", " << v.y << ", " << v.z << " }"
|
|
// }
|
|
//
|
|
#define QFUZZY_COMPARE(actual, expected, epsilon) \
|
|
do { \
|
|
if (!QTest_fuzzyCompare(actual, expected, #actual, #expected, __LINE__, __FILE__, epsilon)) \
|
|
return; \
|
|
} while(0)
|
|
|
|
// Implements QCOMPARE using an explicit, externally defined test function.
|
|
// The advantage of this (over a manual check or what have you) is that the values of actual and
|
|
// expected are printed in the event that the test fails.
|
|
//
|
|
// testFunc(const T & actual, const T & expected) -> bool: true (test succeeds) | false (test fails)
|
|
//
|
|
#define QCOMPARE_WITH_FUNCTION(actual, expected, testFunc) \
|
|
do { \
|
|
if (!testFunc(actual, expected)) { \
|
|
QTest_failWithMessage("Compared values are not the same", actual, expected, #actual, #expected, __LINE__, __FILE__); \
|
|
return; \
|
|
} \
|
|
} while (0)
|
|
|
|
// Implements QCOMPARE using an explicit, externally defined test function.
|
|
// Unlike QCOMPARE_WITH_FUNCTION, this func / closure takes no arguments (which is much more convenient
|
|
// if you're using a c++11 closure / lambda).
|
|
//
|
|
// usage:
|
|
// QCOMPARE_WITH_LAMBDA(foo, expectedFoo, [&foo, &expectedFoo] () {
|
|
// return foo->isFooish() && foo->fooishness() >= expectedFoo->fooishness();
|
|
// });
|
|
// (fails if foo is not as fooish as expectedFoo)
|
|
//
|
|
#define QCOMPARE_WITH_LAMBDA(actual, expected, testClosure) \
|
|
do { \
|
|
if (!testClosure()) { \
|
|
QTest_failWithMessage("Compared values are not the same", actual, expected, #actual, #expected, __LINE__, __FILE__); \
|
|
return; \
|
|
} \
|
|
} while (0)
|
|
|
|
// Same as QCOMPARE_WITH_FUNCTION, but with a custom fail message
|
|
#define QCOMPARE_WITH_FUNCTION_AND_MESSAGE(actual, expected, testfunc, failMessage) \
|
|
do { \
|
|
if (!testFunc(actual, expected)) { \
|
|
QTest_failWithMessage(failMessage, actual, expected, #actual, #expected, __LINE__, __FILE__); \
|
|
return; \
|
|
} \
|
|
} while (0)
|
|
|
|
// Same as QCOMPARE_WITH_FUNCTION, but with a custom fail message
|
|
#define QCOMPARE_WITH_LAMBDA_AND_MESSAGE(actual, expected, testClosure, failMessage) \
|
|
do { \
|
|
if (!testClosure()) { \
|
|
QTest_failWithMessage(failMessage, actual, expected, #actual, #expected, __LINE__, __FILE__); \
|
|
return; \
|
|
} \
|
|
} while (0)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|