Merge branch 'master' into compatibility

Conflicts: src/CMakeLists.txt src/Math/Test/CMakeLists.txt src/Math/Test/MathTypeTraitsTest.cpp src/MeshTools/Test/TipsifyTest.h src/Physics/Test/ShapeGroupTest.cpp
14 years ago · e1fcfead7d
82 changed files with 822 additions and 615 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -29,12 +29,6 @@ if(WITH_EVERYTHING)
 endif()

 if(BUILD_TESTS)
-    find_package(Qt4)
-
-    if(NOT QT4_FOUND)
-        message(FATAL_ERROR "Qt4, required for building unit tests, was not found. Set BUILD_TESTS to OFF to skip building them.")
-    endif()
-
    enable_testing()
 endif()

--- a/2
+++ b/2
@ -7,7 +7,7 @@ arch=('i686' 'x86_64')
 url="https://github.com/mosra/magnum"
 license=('LGPLv3')
 depends=('corrade' 'glew')
-makedepends=('cmake' 'qt')
+makedepends=('cmake')
 options=(!strip)
 provides=('magnum-git')

--- a/README.md
+++ b/README.md
@ -56,8 +56,8 @@ Building and running unit tests
 -------------------------------

 If you want to build also unit tests (which are not built by default), pass
-`-DBUILD_TESTS=True` to CMake. Unit tests use QtTest framework (you need at
-least **Qt 4.6**) and can be run using
+`-DBUILD_TESTS=True` to CMake. Unit tests use Corrade's TestSuite framework
+and can be run using

    ctest -V

--- a/doc/building.dox
+++ b/doc/building.dox
@ -78,8 +78,8 @@ None of the context libraries is built by default, regardless to

@subsection building-tests Building and running unit tests
 If you want to build also unit tests (which are not built by default), pass
-`-DBUILD_TESTS=True` to CMake. Unit tests use QtTest framework (you need at
-least **Qt 4.6**) and can be run using
+`-DBUILD_TESTS=True` to CMake. Unit tests use Corrade's @ref Corrade::TestSuite
+"TestSuite" framework and can be run using

    ctest -V

--- a/modules/FindCorrade.cmake
+++ b/modules/FindCorrade.cmake
@ -1,59 +1,123 @@
-# Find Corrade - Corrade handling module for CMake
+# - Find Corrade
 #
-# This module defines:
+# Basic usage:
+#  find_package(Corrade [REQUIRED])
+# This module tries to find Corrade library and then defines:
+#  CORRADE_FOUND                    - True if Corrade library is found
+#  CORRADE_INCLUDE_DIR              - Include dir for Corrade
+#  CORRADE_LIBRARIES                - All Corrade libraries
+#  CORRADE_UTILITY_LIBRARY          - Corrade Utility library
+#  CORRADE_PLUGINMANAGER_LIBRARY    - Corrade Plugin manager library
+#  CORRADE_RC_EXECUTABLE            - Corrade resource compiler executable
+# If Corrade library is found, these macros and functions are defined:
 #
-# CORRADECORE_FOUND                 - True if Corrade library is found
 #
-# CORRADE_INCLUDE_DIR               - Include dir for Corrade
+# Add unit test using Corrade's TestSuite.
+#  corrade_add_test2(test_name
+#                    sources...
+#                    [LIBRARIES libraries...])
+# Test name is also executable name. You can also specify libraries to link
+# with instead of using target_link_libraries(). Note that the
+# enable_testing() must be called explicitly.
 #
-# CORRADE_LIBRARIES                 - All corrade libraries
-# CORRADE_UTILITY_LIBRARY           - Corrade Utility library
-# CORRADE_PLUGINMANAGER_LIBRARY     - Corrade Plugin manager library
-# CORRADE_RC_EXECUTABLE             - Corrade resource compiler executable
 #
-# CORRADE_BINARY_INSTALL_DIR        - Binary installation directory
-# CORRADE_LIBRARY_INSTALL_DIR       - Library installation directory
-# CORRADE_CMAKE_MODULE_INSTALL_DIR  - Installation dir for CMake modules
-# CORRADE_INCLUDE_INSTALL_DIR       - Include installation directory for Corrade headers
+# Add QtTest unit test.
+#  corrade_add_test(test_name moc_header source_file
+#                   [libraries...])
+# These tests contain mainly from one source file and one header, which is
+# processed by Qt meta-object compiler. The executable is then linked to QtCore
+# and QtTest library, more libraries can be specified as another parameters.
+# Test name is also executable name. Header file is processed with Qt's moc.
+#
+# Note: Before using this function you must find package Qt4. The
+# enable_testing() function must be also called explicitly.
+#
+#
+# Add QtTest unit test with multiple source files.
+#  corrade_add_multifile_test(test_name
+#                             moc_header_variable
+#                             source_files_variable)
+# Useful when there is need to compile more than one cpp/h file into the test.
+#
+# Example usage:
+#  set(test_headers ComplexTest.h MyObject.h)
+#  set(test_sources ComplexTest.cpp MyObject.cpp)
+#  corrade_add_test(MyComplexTest test_headers test_sources
+#                   CoreLibrary AnotherLibrary)
+#
+# Compile data resources into application binary.
+#  corrade_add_resource(name group_name
+#                       file [ALIAS alias]
+#                       [file1 [ALIAS alias1]...])
+# Depends on corrade-rc, which is part of Corrade utilities. This command
+# generates resource file with group group_name from given files in current
+# build directory. Argument name is name under which the resources can be
+# explicitly loaded. Variable 'name' contains compiled resource filename,
+# which is then used for compiling library / executable.
+#
+# Example usage:
+#  corrade_add_resource(name group_name file1 ALIAS alias1 file2 file3)
+#  add_executable(app source1 source2 ... ${name})
+#
+# Add dynamic plugin.
+#  corrade_add_plugin(plugin_name install_dir metadata_file
+#                     sources...)
+# The macro adds preprocessor directive CORRADE_DYNAMIC_PLUGIN. Additional
+# libraries can be linked in via target_link_libraries(plugin_name ...). If
+# install_dir is set to CMAKE_CURRENT_BINARY_DIR (e.g. for testing purposes),
+# the files are copied directly, without need to run 'make install'.
+#
+#
+# Add static plugin.
+#  corrade_add_static_plugin(static_plugins_variable
+#                            plugin_name metadata_file
+#                            sources...)
+# The macro adds preprocessor directive CORRADE_STATIC_PLUGIN. Additional
+# libraries can be linked in via target_link_libraries(plugin_name ...).
+#
+# Plugin library name will be added at the end of static_plugins_variable and
+# the variable is meant to be used for linking plugins to main
+# executable/library, e.g:
+#  target_link_libraries(app lib1 lib2 ... ${static_plugins_variable})
+#
+# This variable is set with parent scope to be available in parent directory.
+# If there are more intermediate directories between plugin directory and main
+# executable directory, the variable can be propagated to parent scope like
+# this:
+#  set(static_plugins_variable ${static_plugins_variable} PARENT_SCOPE)
+#
+# Find and install DLLs for bundling with Windows build.
+#  corrade_bundle_dlls(library_install_dir
+#                      dlls...
+#                      [PATHS paths...])
+# It is possible to specify also additional paths for searching. DLL names can
+# also contain paths, they will be installed into exact specified path. If an
+# DLL is not found, fatal error message is printed.
 #

-if (CORRADE_UTILITY_INCLUDE_DIR AND CORRADE_PLUGINMANAGER_INCLUDE_DIR AND CORRADE_UTILITY_LIBRARY AND CORRADE_PLUGINMANAGER_LIBRARY AND CORRADE_RC_EXECUTABLE)
-
-    # Already in cache
-    set(CORRADECORE_FOUND TRUE)
-
-else()
-    # Libraries
-    find_library(CORRADE_UTILITY_LIBRARY CorradeUtility)
-    find_library(CORRADE_PLUGINMANAGER_LIBRARY CorradePluginManager)
+# Libraries
+find_library(CORRADE_UTILITY_LIBRARY CorradeUtility)
+find_library(CORRADE_PLUGINMANAGER_LIBRARY CorradePluginManager)

-    # RC executable
-    find_program(CORRADE_RC_EXECUTABLE corrade-rc)
+# RC executable
+find_program(CORRADE_RC_EXECUTABLE corrade-rc)

-    # Paths
-    find_path(CORRADE_INCLUDE_DIR
-        NAMES PluginManager Utility
-        PATH_SUFFIXES Corrade
-    )
+# Paths
+find_path(CORRADE_INCLUDE_DIR
+    NAMES PluginManager Utility
+    PATH_SUFFIXES Corrade)

-    include(FindPackageHandleStandardArgs)
-    find_package_handle_standard_args("Corrade" DEFAULT_MSG
-        CORRADE_INCLUDE_DIR
-        CORRADE_UTILITY_LIBRARY
-        CORRADE_PLUGINMANAGER_LIBRARY
-        CORRADE_RC_EXECUTABLE
-    )
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(Corrade DEFAULT_MSG
+    CORRADE_INCLUDE_DIR
+    CORRADE_UTILITY_LIBRARY
+    CORRADE_PLUGINMANAGER_LIBRARY
+    CORRADE_RC_EXECUTABLE)

+if(NOT CORRADE_FOUND)
+    return()
 endif()

-if(CORRADE_FOUND)
-    include(CorradeMacros)
-
-    include(CorradeLibSuffix)
-    set_parent_scope(CORRADE_BINARY_INSTALL_DIR ${CMAKE_INSTALL_PREFIX}/bin)
-    set_parent_scope(CORRADE_LIBRARY_INSTALL_DIR ${CMAKE_INSTALL_PREFIX}/lib${LIB_SUFFIX})
-    set_parent_scope(CORRADE_CMAKE_MODULE_INSTALL_DIR ${CMAKE_ROOT}/Modules)
-    set_parent_scope(CORRADE_INCLUDE_INSTALL_DIR ${CMAKE_INSTALL_PREFIX}/include/Corrade)
-
-    set_parent_scope(CORRADE_LIBRARIES ${CORRADE_UTILITY_LIBRARY} ${CORRADE_PLUGINMANAGER_LIBRARY})
-endif()
+include(CorradeMacros)
+include(CorradeLibSuffix)
+set(CORRADE_LIBRARIES ${CORRADE_UTILITY_LIBRARY} ${CORRADE_PLUGINMANAGER_LIBRARY})
--- a/modules/FindMagnum.cmake
+++ b/modules/FindMagnum.cmake
@ -1,56 +1,51 @@
 # - Find Magnum
 #
 # Basic usage:
-#
 #  find_package(Magnum [REQUIRED])
-#
 # This command tries to find Magnum library and then defines:
-#
 #  MAGNUM_FOUND                 - Whether the library was found
-#  MAGNUM_TARGET_GLES           - Defined if Magnum was built for OpenGL ES,
-#   slightly reducing feature count. The same variable is also #defined in
-#   Magnum headers.
+#  MAGNUM_TARGET_GLES           - Defined if Magnum was built for OpenGL
+#   ES, slightly reducing feature count. The same variable is also
+#   #defined in Magnum headers.
 #  MAGNUM_LIBRARIES             - Magnum library and dependent libraries
 #  MAGNUM_INCLUDE_DIRS          - Root include dir and include dirs of
 #   dependencies
 #  MAGNUM_PLUGINS_IMPORTER_DIR  - Directory with importer plugins
-#
 # This command will try to find only the base library, not the optional
-# components. The base library depends on Corrade, OpenGL and GLEW libraries.
-# Additional dependencies are specified by the components. The optional
-# components are:
-#
+# components. The base library depends on Corrade, OpenGL and GLEW
+# libraries. Additional dependencies are specified by the components. The
+# optional components are:
 #  MeshTools     - MeshTools library
 #  Physics       - Physics library
 #  Primitives    - Library with stock geometric primitives (static)
 #  Shaders       - Library with stock shaders
-#
 #  EglContext    - EGL context (depends on EGL and X11 libraries)
 #  GlutContext   - GLUT context (depends on GLUT library)
 #  Sdl2Context   - SDL2 context (depends on SDL2 library)
-#
 # Example usage with specifying additional components is:
-#
-#  find_package(Magnum [REQUIRED|COMPONENTS] MeshTools Primitives GlutContext)
-#
+#  find_package(Magnum [REQUIRED|COMPONENTS]
+#               MeshTools Primitives GlutContext)
 # For each component is then defined:
-#
 #  MAGNUM_*_FOUND   - Whether the component was found
 #  MAGNUM_*_LIBRARIES - Component library and dependent libraries
 #  MAGNUM_*_INCLUDE_DIRS - Include dirs of module dependencies
 #
 # Additionally these variables are defined for internal usage:
-#
-#  MAGNUM_INCLUDE_DIR                   - Root include dir (w/o dependencies)
-#  MAGNUM_LIBRARY                       - Magnum library (w/o dependencies)
-#  MAGNUM_*_LIBRARY                     - Component libraries (w/o dependencies)
-#
+#  MAGNUM_INCLUDE_DIR                   - Root include dir (w/o
+#   dependencies)
+#  MAGNUM_LIBRARY                       - Magnum library (w/o
+#   dependencies)
+#  MAGNUM_*_LIBRARY                     - Component libraries (w/o
+#   dependencies)
 #  MAGNUM_LIBRARY_INSTALL_DIR           - Library installation directory
 #  MAGNUM_PLUGINS_INSTALL_DIR           - Plugin installation directory
-#  MAGNUM_PLUGINS_IMPORTER_INSTALL_DIR  - Importer plugin installation directory
-#  MAGNUM_CMAKE_MODULE_INSTALL_DIR      - Installation dir for CMake modules
+#  MAGNUM_PLUGINS_IMPORTER_INSTALL_DIR  - Importer plugin installation
+#   directory
+#  MAGNUM_CMAKE_MODULE_INSTALL_DIR      - Installation dir for CMake
+#   modules
 #  MAGNUM_INCLUDE_INSTALL_DIR           - Header installation directory
-#  MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR   - Plugin header installation directory
+#  MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR   - Plugin header installation
+#   directory
 #

 # Dependencies
--- a/package/archlinux/magnum-git/PKGBUILD
+++ b/package/archlinux/magnum-git/PKGBUILD
@ -35,6 +35,11 @@ build() {
    make
 }

+check() {
+    cd "$startdir/build"
+    ctest --output-on-failure -E Benchmark
+}
+
 package() {
    cd "$srcdir/build"
    make DESTDIR="$pkgdir/" install
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@ -1,4 +1,4 @@
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wold-style-cast -pedantic -std=c++0x -fvisibility=hidden -fno-exceptions")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wold-style-cast -pedantic -std=c++0x -fvisibility=hidden")

 if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wdouble-promotion")
--- a/src/Math/Geometry/Test/CMakeLists.txt
+++ b/src/Math/Geometry/Test/CMakeLists.txt
@ -1,2 +1,2 @@
-corrade_add_test(MathGeometryDistanceTest DistanceTest.h DistanceTest.cpp)
-corrade_add_test(MathGeometryIntersectionTest IntersectionTest.h IntersectionTest.cpp)
+corrade_add_test2(MathGeometryDistanceTest DistanceTest.cpp)
+corrade_add_test2(MathGeometryIntersectionTest IntersectionTest.cpp)
--- a/src/Math/Geometry/Test/DistanceTest.cpp
+++ b/src/Math/Geometry/Test/DistanceTest.cpp
@ -16,12 +16,11 @@
 #include "DistanceTest.h"

 #include <limits>
-#include <QtTest/QTest>

 #include "Math.h"
 #include "Distance.h"

-QTEST_APPLESS_MAIN(Magnum::Math::Geometry::Test::DistanceTest)
+CORRADE_TEST_MAIN(Magnum::Math::Geometry::Test::DistanceTest)

 using namespace std;

@ -29,17 +28,22 @@ namespace Magnum { namespace Math { namespace Geometry { namespace Test {

 typedef Magnum::Math::Vector3<float> Vector3;

+DistanceTest::DistanceTest() {
+    addTests(&DistanceTest::linePoint,
+             &DistanceTest::lineSegmentPoint);
+}
+
 void DistanceTest::linePoint() {
    Vector3 a(0.0f);
    Vector3 b(1.0f);

    /* Point on the line */
-    QCOMPARE((Distance::linePoint(a, b, Vector3(0.25f))), 0.0f);
+    CORRADE_COMPARE((Distance::linePoint(a, b, Vector3(0.25f))), 0.0f);

    /* The distance should be the same for all equidistant points */
-    QCOMPARE((Distance::linePoint(a, b, Vector3(1.0f, 0.0f, 1.0f))),
+    CORRADE_COMPARE((Distance::linePoint(a, b, Vector3(1.0f, 0.0f, 1.0f))),
        Constants<float>::sqrt2()/Constants<float>::sqrt3());
-    QCOMPARE((Distance::linePoint(a, b, Vector3(1.0f, 0.0f, 1.0f)+Vector3(100.0f))),
+    CORRADE_COMPARE((Distance::linePoint(a, b, Vector3(1.0f, 0.0f, 1.0f)+Vector3(100.0f))),
        Constants<float>::sqrt2()/Constants<float>::sqrt3());
 }

@ -48,23 +52,23 @@ void DistanceTest::lineSegmentPoint() {
    Vector3 b(1.0f);

    /* Point on the line segment */
-    QCOMPARE((Distance::lineSegmentPoint(a, b, Vector3(0.25f))), 0.0f);
+    CORRADE_COMPARE((Distance::lineSegmentPoint(a, b, Vector3(0.25f))), 0.0f);

    /* Point on the line, outside the segment, closer to A */
-    QCOMPARE((Distance::lineSegmentPoint(a, b, Vector3(-1.0f))), +Constants<float>::sqrt3());
+    CORRADE_COMPARE((Distance::lineSegmentPoint(a, b, Vector3(-1.0f))), +Constants<float>::sqrt3());

    /* Point on the line, outside the segment, closer to B */
-    QCOMPARE((Distance::lineSegmentPoint(a, b, Vector3(1.0f+1.0f/Constants<float>::sqrt3()))), 1.0f);
+    CORRADE_COMPARE((Distance::lineSegmentPoint(a, b, Vector3(1.0f+1.0f/Constants<float>::sqrt3()))), 1.0f);

    /* Point next to the line segment */
-    QCOMPARE((Distance::lineSegmentPoint(a, b, Vector3(1.0f, 0.0f, 1.0f))),
+    CORRADE_COMPARE((Distance::lineSegmentPoint(a, b, Vector3(1.0f, 0.0f, 1.0f))),
        Constants<float>::sqrt2()/Constants<float>::sqrt3());

    /* Point outside the line segment, closer to A */
-    QCOMPARE((Distance::lineSegmentPoint(a, b, Vector3(1.0f, 0.0f, 1.0f)-Vector3(1.0f))), 1.0f);
+    CORRADE_COMPARE((Distance::lineSegmentPoint(a, b, Vector3(1.0f, 0.0f, 1.0f)-Vector3(1.0f))), 1.0f);

    /* Point outside the line segment, closer to B */
-    QCOMPARE((Distance::lineSegmentPoint(a, b, Vector3(1.0f, 0.0f, 1.0f)+Vector3(1.0f))), +Constants<float>::sqrt2());
+    CORRADE_COMPARE((Distance::lineSegmentPoint(a, b, Vector3(1.0f, 0.0f, 1.0f)+Vector3(1.0f))), +Constants<float>::sqrt2());
 }

 }}}}
--- a/src/Math/Geometry/Test/DistanceTest.h
+++ b/src/Math/Geometry/Test/DistanceTest.h
@ -15,14 +15,14 @@
    GNU Lesser General Public License version 3 for more details.
 */

-#include <QtCore/QObject>
+#include <TestSuite/Tester.h>

 namespace Magnum { namespace Math { namespace Geometry { namespace Test {

-class DistanceTest: public QObject {
-    Q_OBJECT
+class DistanceTest: public Corrade::TestSuite::Tester<DistanceTest> {
+    public:
+        DistanceTest();

-    private slots:
        void linePoint();
        void lineSegmentPoint();
 };
--- a/src/Math/Geometry/Test/IntersectionTest.cpp
+++ b/src/Math/Geometry/Test/IntersectionTest.cpp
@ -16,11 +16,10 @@
 #include "IntersectionTest.h"

 #include <limits>
-#include <QtTest/QTest>

 #include "Intersection.h"

-QTEST_APPLESS_MAIN(Magnum::Math::Geometry::Test::IntersectionTest)
+CORRADE_TEST_MAIN(Magnum::Math::Geometry::Test::IntersectionTest)

 using namespace std;

@ -28,26 +27,29 @@ namespace Magnum { namespace Math { namespace Geometry { namespace Test {

 typedef Magnum::Math::Vector3<float> Vector3;

+IntersectionTest::IntersectionTest() {
+    addTests(&IntersectionTest::planeLine);
+}
+
 void IntersectionTest::planeLine() {
    Vector3 planePosition(-1.0f, 1.0f, 0.5f);
    Vector3 planeNormal(0.0f, 0.0f, 1.0f);

    /* Inside line segment */
-    QCOMPARE((Intersection::planeLine(planePosition, planeNormal,
+    CORRADE_COMPARE((Intersection::planeLine(planePosition, planeNormal,
        Vector3(0.0f, 0.0f, -1.0f), Vector3(0.0f, 0.0f, 1.0f))), 0.75f);

    /* Outside line segment */
-    QCOMPARE((Intersection::planeLine(planePosition, planeNormal,
+    CORRADE_COMPARE((Intersection::planeLine(planePosition, planeNormal,
        Vector3(0.0f, 0.0f, 1.0f), Vector3(0.0f, 0.0f, 2.0f))), -0.5f);

    /* Line lies on the plane */
-    float nan = Intersection::planeLine(planePosition, planeNormal,
-        Vector3(1.0f, 0.5f, 0.5f), Vector3(0.0f, 1.0f, 0.5f));
-    QVERIFY(nan != nan);
+    CORRADE_COMPARE(Intersection::planeLine(planePosition, planeNormal,
+        Vector3(1.0f, 0.5f, 0.5f), Vector3(0.0f, 1.0f, 0.5f)), numeric_limits<float>::quiet_NaN());

    /* Line is parallell to the plane */
-    QCOMPARE((Intersection::planeLine(planePosition, planeNormal,
-        Vector3(1.0f, 0.0f, 1.0f), Vector3(0.0f, 0.0f, 1.0f))), numeric_limits<float>::infinity());
+    CORRADE_COMPARE((Intersection::planeLine(planePosition, planeNormal,
+        Vector3(1.0f, 0.0f, 1.0f), Vector3(0.0f, 0.0f, 1.0f))), -numeric_limits<float>::infinity());
 }

 }}}}
--- a/src/Math/Geometry/Test/IntersectionTest.h
+++ b/src/Math/Geometry/Test/IntersectionTest.h
@ -15,14 +15,14 @@
    GNU Lesser General Public License version 3 for more details.
 */

-#include <QtCore/QObject>
+#include <TestSuite/Tester.h>

 namespace Magnum { namespace Math { namespace Geometry { namespace Test {

-class IntersectionTest: public QObject {
-    Q_OBJECT
+class IntersectionTest: public Corrade::TestSuite::Tester<IntersectionTest> {
+    public:
+        IntersectionTest();

-    private slots:
        void planeLine();
 };

--- a/src/Math/Test/CMakeLists.txt
+++ b/src/Math/Test/CMakeLists.txt
@ -1,18 +1,17 @@
-corrade_add_test(MathMathTypeTraitsTest MathTypeTraitsTest.h MathTypeTraitsTest.cpp)
+corrade_add_test2(MathMathTypeTraitsTest MathTypeTraitsTest.cpp)

-corrade_add_test(MathVectorTest VectorTest.h VectorTest.cpp ${CORRADE_UTILITY_LIBRARY})
-corrade_add_test(MathVector2Test Vector2Test.h Vector2Test.cpp ${CORRADE_UTILITY_LIBRARY})
-corrade_add_test(MathVector3Test Vector3Test.h Vector3Test.cpp ${CORRADE_UTILITY_LIBRARY})
-corrade_add_test(MathVector4Test Vector4Test.h Vector4Test.cpp ${CORRADE_UTILITY_LIBRARY})
+corrade_add_test2(MathVectorTest VectorTest.cpp)
+corrade_add_test2(MathVector2Test Vector2Test.cpp)
+corrade_add_test2(MathVector3Test Vector3Test.cpp)
+corrade_add_test2(MathVector4Test Vector4Test.cpp)

-corrade_add_test(MathMatrixTest MatrixTest.h MatrixTest.cpp ${CORRADE_UTILITY_LIBRARY})
-corrade_add_test(MathMatrix3Test Matrix3Test.h Matrix3Test.cpp ${CORRADE_UTILITY_LIBRARY})
-corrade_add_test(MathMatrix4Test Matrix4Test.h Matrix4Test.cpp ${CORRADE_UTILITY_LIBRARY})
+corrade_add_test2(MathMatrixTest MatrixTest.cpp)
+corrade_add_test2(MathMatrix3Test Matrix3Test.cpp)
+corrade_add_test2(MathMatrix4Test Matrix4Test.cpp)

-set(MathTest_MOC MathTest.h)
 if(NOT CMAKE_NO_OBJECT_TARGET)
    set(MathTest_SRCS MathTest.cpp $<TARGET_OBJECTS:MagnumMathObjects>)
 else()
    set(MathTest_SRCS MathTest.cpp ${MagnumMath_SRCS})
 endif()
-corrade_add_multifile_test(MathTest MathTest_MOC MathTest_SRCS)
+corrade_add_test2(MathTest ${MathTest_SRCS})
--- a/src/Math/Test/MathTest.cpp
+++ b/src/Math/Test/MathTest.cpp
@ -15,29 +15,33 @@

 #include "MathTest.h"

-#include <QtTest/QTest>
-
 #include "Math.h"

-QTEST_APPLESS_MAIN(Magnum::Math::Test::MathTest)
+CORRADE_TEST_MAIN(Magnum::Math::Test::MathTest)

 namespace Magnum { namespace Math { namespace Test {

+MathTest::MathTest() {
+    addTests(&MathTest::degrad,
+             &MathTest::pow,
+             &MathTest::log);
+}
+
 void MathTest::degrad() {
-    QCOMPARE(deg(90.0), Constants<double>::pi()/2);
-    QCOMPARE(deg(90.0f), Constants<float>::pi()/2);
-    QCOMPARE(rad(Constants<double>::pi()/2), Constants<double>::pi()/2);
+    CORRADE_COMPARE(deg(90.0), Constants<double>::pi()/2);
+    CORRADE_COMPARE(deg(90.0f), Constants<float>::pi()/2);
+    CORRADE_COMPARE(rad(Constants<double>::pi()/2), Constants<double>::pi()/2);
 }

 void MathTest::pow() {
-    QCOMPARE(Math::pow<10>(2ul), 1024ul);
-    QCOMPARE(Math::pow<0>(3ul), 1ul);
-    QCOMPARE(Math::pow<2>(2.0f), 4.0f);
+    CORRADE_COMPARE(Math::pow<10>(2ul), 1024ul);
+    CORRADE_COMPARE(Math::pow<0>(3ul), 1ul);
+    CORRADE_COMPARE(Math::pow<2>(2.0f), 4.0f);
 }

 void MathTest::log() {
-    QCOMPARE(Math::log(2, 256), 8ul);
-    QCOMPARE(Math::log(256, 2), 0ul);
+    CORRADE_COMPARE(Math::log(2, 256), 8ul);
+    CORRADE_COMPARE(Math::log(256, 2), 0ul);
 }

 }}}
--- a/src/Math/Test/MathTest.h
+++ b/src/Math/Test/MathTest.h
@ -15,14 +15,14 @@
    GNU Lesser General Public License version 3 for more details.
 */

-#include <QtCore/QObject>
+#include <TestSuite/Tester.h>

 namespace Magnum { namespace Math { namespace Test {

-class MathTest: public QObject {
-    Q_OBJECT
+class MathTest: public Corrade::TestSuite::Tester<MathTest> {
+    public:
+        MathTest();

-    private slots:
        void degrad();
        void pow();
        void log();
--- a/src/Math/Test/MathTypeTraitsTest.cpp
+++ b/src/Math/Test/MathTypeTraitsTest.cpp
@ -16,14 +16,18 @@
 #include "MathTypeTraitsTest.h"

 #include <limits>
-#include <QtTest/QTest>

 #include "MathTypeTraits.h"

-QTEST_APPLESS_MAIN(Magnum::Math::Test::MathTypeTraitsTest)
+CORRADE_TEST_MAIN(Magnum::Math::Test::MathTypeTraitsTest)

 namespace Magnum { namespace Math { namespace Test {

+MathTypeTraitsTest::MathTypeTraitsTest() {
+    addTests(&MathTypeTraitsTest::equalsIntegral,
+             &MathTypeTraitsTest::equalsFloatingPoint);
+}
+
 void MathTypeTraitsTest::equalsIntegral() {
    _equalsIntegral<unsigned char>();
    _equalsIntegral<char>();
@ -43,18 +47,21 @@ void MathTypeTraitsTest::equalsFloatingPoint() {
 }

 template<class T> void MathTypeTraitsTest::_equalsIntegral() {
-    QVERIFY(!MathTypeTraits<T>::equals(1, 1+MathTypeTraits<T>::epsilon()));
+    CORRADE_VERIFY(!MathTypeTraits<T>::equals(1, 1+MathTypeTraits<T>::epsilon()));
 }

 template<class T> void MathTypeTraitsTest::_equalsFloatingPoint() {
-    QVERIFY(MathTypeTraits<T>::equals(T(1)+MathTypeTraits<T>::epsilon()/T(2), T(1)));
-    QVERIFY(!MathTypeTraits<T>::equals(T(1)+MathTypeTraits<T>::epsilon()*T(2), T(1)));
-
-    QEXPECT_FAIL(0, "Comparing to infinity is broken", Continue);
-    QVERIFY(MathTypeTraits<T>::equals(std::numeric_limits<T>::infinity(),
-                                  std::numeric_limits<T>::infinity()));
-    QVERIFY(!MathTypeTraits<T>::equals(std::numeric_limits<T>::quiet_NaN(),
-                                   std::numeric_limits<T>::quiet_NaN()));
+    CORRADE_VERIFY(MathTypeTraits<T>::equals(T(1)+MathTypeTraits<T>::epsilon()/T(2), T(1)));
+    CORRADE_VERIFY(!MathTypeTraits<T>::equals(T(1)+MathTypeTraits<T>::epsilon()*T(2), T(1)));
+
+    {
+        CORRADE_EXPECT_FAIL("Comparing to infinity is broken");
+        CORRADE_VERIFY(MathTypeTraits<T>::equals(std::numeric_limits<T>::infinity(),
+                                                std::numeric_limits<T>::infinity()));
+    }
+
+    CORRADE_VERIFY(!MathTypeTraits<T>::equals(std::numeric_limits<T>::quiet_NaN(),
+                                              std::numeric_limits<T>::quiet_NaN()));
 }

 }}}
--- a/src/Math/Test/MathTypeTraitsTest.h
+++ b/src/Math/Test/MathTypeTraitsTest.h
@ -15,14 +15,14 @@
    GNU Lesser General Public License version 3 for more details.
 */

-#include <QtCore/QObject>
+#include <TestSuite/Tester.h>

 namespace Magnum { namespace Math { namespace Test {

-class MathTypeTraitsTest: public QObject {
-    Q_OBJECT
+class MathTypeTraitsTest: public Corrade::TestSuite::Tester<MathTypeTraitsTest> {
+    public:
+        MathTypeTraitsTest();

-    private slots:
        void equalsFloatingPoint();
        void equalsIntegral();

--- a/src/Math/Test/Matrix3Test.cpp
+++ b/src/Math/Test/Matrix3Test.cpp
@ -16,12 +16,11 @@
 #include "Matrix3Test.h"

 #include <sstream>
-#include <QtTest/QTest>

 #include "Matrix3.h"
 #include "Math.h"

-QTEST_APPLESS_MAIN(Magnum::Math::Test::Matrix3Test)
+CORRADE_TEST_MAIN(Magnum::Math::Test::Matrix3Test)

 using namespace std;
 using namespace Corrade::Utility;
@ -30,6 +29,14 @@ namespace Magnum { namespace Math { namespace Test {

 typedef Math::Matrix3<float> Matrix3;

+Matrix3Test::Matrix3Test() {
+    addTests(&Matrix3Test::constructIdentity,
+             &Matrix3Test::translation,
+             &Matrix3Test::scaling,
+             &Matrix3Test::rotation,
+             &Matrix3Test::debug);
+}
+
 void Matrix3Test::constructIdentity() {
    Matrix3 identity;
    Matrix3 identity2(Matrix3::Identity);
@ -47,9 +54,9 @@ void Matrix3Test::constructIdentity() {
        0.0f, 0.0f, 4.0f
    );

-    QVERIFY(identity == identityExpected);
-    QVERIFY(identity2 == identityExpected);
-    QVERIFY(identity3 == identity3Expected);
+    CORRADE_COMPARE(identity, identityExpected);
+    CORRADE_COMPARE(identity2, identityExpected);
+    CORRADE_COMPARE(identity3, identity3Expected);
 }

 void Matrix3Test::translation() {
@ -59,7 +66,7 @@ void Matrix3Test::translation() {
        3.0f, 1.0f, 1.0f
    );

-    QVERIFY(Matrix3::translation({3.0f, 1.0f}) == matrix);
+    CORRADE_COMPARE(Matrix3::translation({3.0f, 1.0f}), matrix);
 }

 void Matrix3Test::scaling() {
@ -69,7 +76,7 @@ void Matrix3Test::scaling() {
        0.0f, 0.0f, 1.0f
    );

-    QVERIFY(Matrix3::scaling({3.0f, 1.5f}) == matrix);
+    CORRADE_COMPARE(Matrix3::scaling({3.0f, 1.5f}), matrix);
 }

 void Matrix3Test::rotation() {
@ -79,7 +86,7 @@ void Matrix3Test::rotation() {
        0.0f, 0.0f, 1.0f
    );

-    QVERIFY(Matrix3::rotation(deg(15.0f)) == matrix);
+    CORRADE_COMPARE(Matrix3::rotation(deg(15.0f)), matrix);
 }

 void Matrix3Test::debug() {
@ -91,9 +98,9 @@ void Matrix3Test::debug() {

    ostringstream o;
    Debug(&o) << m;
-    QCOMPARE(QString::fromStdString(o.str()), QString("Matrix(3, 4, 7,\n"
-                                                      "       5, 4, -1,\n"
-                                                      "       8, 7, 8)\n"));
+    CORRADE_COMPARE(o.str(), "Matrix(3, 4, 7,\n"
+                             "       5, 4, -1,\n"
+                             "       8, 7, 8)\n");
 }

 }}}
--- a/src/Math/Test/Matrix3Test.h
+++ b/src/Math/Test/Matrix3Test.h
@ -15,14 +15,14 @@
    GNU Lesser General Public License version 3 for more details.
 */

-#include <QtCore/QObject>
+#include <TestSuite/Tester.h>

 namespace Magnum { namespace Math { namespace Test {

-class Matrix3Test: public QObject {
-    Q_OBJECT
+class Matrix3Test: public Corrade::TestSuite::Tester<Matrix3Test> {
+    public:
+        Matrix3Test();

-    private slots:
        void constructIdentity();

        void translation();
--- a/src/Math/Test/Matrix4Test.cpp
+++ b/src/Math/Test/Matrix4Test.cpp
@ -16,12 +16,11 @@
 #include "Matrix4Test.h"

 #include <sstream>
-#include <QtTest/QTest>

 #include "Matrix4.h"
 #include "Math.h"

-QTEST_APPLESS_MAIN(Magnum::Math::Test::Matrix4Test)
+CORRADE_TEST_MAIN(Magnum::Math::Test::Matrix4Test)

 using namespace std;
 using namespace Corrade::Utility;
@ -31,6 +30,16 @@ namespace Magnum { namespace Math { namespace Test {
 typedef Math::Matrix4<float> Matrix4;
 typedef Math::Matrix3<float> Matrix3;

+Matrix4Test::Matrix4Test() {
+    addTests(&Matrix4Test::constructIdentity,
+             &Matrix4Test::translation,
+             &Matrix4Test::scaling,
+             &Matrix4Test::rotation,
+             &Matrix4Test::rotationScalingPart,
+             &Matrix4Test::rotationPart,
+             &Matrix4Test::debug);
+}
+
 void Matrix4Test::constructIdentity() {
    Matrix4 identity;
    Matrix4 identity2(Matrix4::Identity);
@ -50,9 +59,9 @@ void Matrix4Test::constructIdentity() {
        0.0f, 0.0f, 0.0f, 4.0f
    );

-    QVERIFY(identity == identityExpected);
-    QVERIFY(identity2 == identityExpected);
-    QVERIFY(identity3 == identity3Expected);
+    CORRADE_COMPARE(identity, identityExpected);
+    CORRADE_COMPARE(identity2, identityExpected);
+    CORRADE_COMPARE(identity3, identity3Expected);
 }

 void Matrix4Test::translation() {
@ -63,7 +72,7 @@ void Matrix4Test::translation() {
        3.0f, 1.0f, 2.0f, 1.0f
    );

-    QVERIFY(Matrix4::translation({3.0f, 1.0f, 2.0f}) == matrix);
+    CORRADE_COMPARE(Matrix4::translation({3.0f, 1.0f, 2.0f}), matrix);
 }

 void Matrix4Test::scaling() {
@ -74,7 +83,7 @@ void Matrix4Test::scaling() {
        0.0f, 0.0f, 0.0f, 1.0f
    );

-    QVERIFY(Matrix4::scaling({3.0f, 1.5f, 2.0f}) == matrix);
+    CORRADE_COMPARE(Matrix4::scaling({3.0f, 1.5f, 2.0f}), matrix);
 }

 void Matrix4Test::rotation() {
@ -85,7 +94,7 @@ void Matrix4Test::rotation() {
        0.0f,       0.0f,       0.0f,       1.0f
    );

-    QVERIFY(Matrix4::rotation(deg(-74.0f), {-1.0f, 2.0f, 2.0f}) == matrix);
+    CORRADE_COMPARE(Matrix4::rotation(deg(-74.0f), {-1.0f, 2.0f, 2.0f}), matrix);
 }

 void Matrix4Test::rotationScalingPart() {
@ -102,7 +111,7 @@ void Matrix4Test::rotationScalingPart() {
        7.0f, -1.0f, 8.0f
    );

-    QVERIFY(m.rotationScaling() == expected);
+    CORRADE_COMPARE(m.rotationScaling(), expected);
 }

 void Matrix4Test::rotationPart() {
@ -113,10 +122,10 @@ void Matrix4Test::rotationPart() {
    );

    Matrix4 rotation = Matrix4::rotation(deg(-74.0f), {-1.0f, 2.0f, 2.0f});
-    QVERIFY(rotation.rotation() == expectedRotationPart);
+    CORRADE_COMPARE(rotation.rotation(), expectedRotationPart);

    Matrix4 rotationTransformed = Matrix4::translation({2.0f, 5.0f, -3.0f})*rotation*Matrix4::scaling(Vector3<float>(9.0f));
-    QVERIFY(rotationTransformed.rotation() == expectedRotationPart);
+    CORRADE_COMPARE(rotationTransformed.rotation(), expectedRotationPart);
 }

 void Matrix4Test::debug() {
@ -129,10 +138,10 @@ void Matrix4Test::debug() {

    ostringstream o;
    Debug(&o) << m;
-    QCOMPARE(QString::fromStdString(o.str()), QString("Matrix(3, 4, 7, 9,\n"
-                                                      "       5, 4, -1, 4,\n"
-                                                      "       8, 7, 8, 5,\n"
-                                                      "       4, 3, 0, 9)\n"));
+    CORRADE_COMPARE(o.str(), "Matrix(3, 4, 7, 9,\n"
+                             "       5, 4, -1, 4,\n"
+                             "       8, 7, 8, 5,\n"
+                             "       4, 3, 0, 9)\n");
 }

 }}}
--- a/src/Math/Test/Matrix4Test.h
+++ b/src/Math/Test/Matrix4Test.h
@ -15,14 +15,14 @@
    GNU Lesser General Public License version 3 for more details.
 */

-#include <QtCore/QObject>
+#include <TestSuite/Tester.h>

 namespace Magnum { namespace Math { namespace Test {

-class Matrix4Test: public QObject {
-    Q_OBJECT
+class Matrix4Test: public Corrade::TestSuite::Tester<Matrix4Test> {
+    public:
+        Matrix4Test();

-    private slots:
        void constructIdentity();

        void translation();
--- a/src/Math/Test/MatrixTest.cpp
+++ b/src/Math/Test/MatrixTest.cpp
@ -16,11 +16,10 @@
 #include "MatrixTest.h"

 #include <sstream>
-#include <QtTest/QTest>

 #include "Matrix.h"

-QTEST_APPLESS_MAIN(Magnum::Math::Test::MatrixTest)
+CORRADE_TEST_MAIN(Magnum::Math::Test::MatrixTest)

 using namespace std;
 using namespace Corrade::Utility;
@ -31,6 +30,23 @@ typedef Matrix<4, float> Matrix4;
 typedef Matrix<3, float> Matrix3;
 typedef Vector<4, float> Vector4;

+MatrixTest::MatrixTest() {
+    addTests(&MatrixTest::construct,
+             &MatrixTest::constructFromVectors,
+             &MatrixTest::constructIdentity,
+             &MatrixTest::constructZero,
+             &MatrixTest::data,
+             &MatrixTest::copy,
+             &MatrixTest::multiplyIdentity,
+             &MatrixTest::multiply,
+             &MatrixTest::multiplyVector,
+             &MatrixTest::transposed,
+             &MatrixTest::ij,
+             &MatrixTest::determinant,
+             &MatrixTest::inverted,
+             &MatrixTest::debug);
+}
+
 void MatrixTest::construct() {
    float m[] = {
        3.0f, 5.0f, 8.0f, 4.0f,
@ -46,7 +62,7 @@ void MatrixTest::construct() {
        9.0f, 4.0f, 5.0f, 9.0f
    );

-    QVERIFY(Matrix4::from(m) == expected);
+    CORRADE_COMPARE(Matrix4::from(m), expected);
 }

 void MatrixTest::constructFromVectors() {
@ -60,7 +76,7 @@ void MatrixTest::constructFromVectors() {
                     9.0f, 10.0f, 11.0f, 12.0f,
                     13.0f, 14.0f, 15.0f, 16.0f);

-    QVERIFY(actual == expected);
+    CORRADE_COMPARE(actual, expected);
 }

 void MatrixTest::constructIdentity() {
@ -82,9 +98,9 @@ void MatrixTest::constructIdentity() {
        0.0f, 0.0f, 0.0f, 4.0f
    );

-    QVERIFY(identity == identityExpected);
-    QVERIFY(identity2 == identityExpected);
-    QVERIFY(identity3 == identity3Expected);
+    CORRADE_COMPARE(identity, identityExpected);
+    CORRADE_COMPARE(identity2, identityExpected);
+    CORRADE_COMPARE(identity3, identity3Expected);
 }

 void MatrixTest::constructZero() {
@ -97,7 +113,7 @@ void MatrixTest::constructZero() {
        0.0f, 0.0f, 0.0f, 0.0f
    );

-    QVERIFY(zero == zeroExpected);
+    CORRADE_COMPARE(zero, zeroExpected);
 }

 void MatrixTest::data() {
@ -110,8 +126,8 @@ void MatrixTest::data() {

    m[1][2] = 1.5f;

-    QCOMPARE(m[2][1], 1.0f);
-    QVERIFY(m[3] == vector);
+    CORRADE_COMPARE(m[2][1], 1.0f);
+    CORRADE_COMPARE(m[3], vector);

    Matrix4 expected(
        0.0f, 0.0f, 0.0f, 0.0f,
@ -120,7 +136,7 @@ void MatrixTest::data() {
        4.0f, 5.0f, 6.0f, 7.0f
    );

-    QVERIFY(m == expected);
+    CORRADE_COMPARE(m, expected);
 }

 void MatrixTest::copy() {
@ -141,8 +157,8 @@ void MatrixTest::copy() {
    Matrix4 original(Matrix4::Zero);
    original[2][3] = 1.0f;

-    QVERIFY(m2 == original);
-    QVERIFY(m3 == original);
+    CORRADE_COMPARE(m2, original);
+    CORRADE_COMPARE(m3, original);
 }

 void MatrixTest::multiplyIdentity() {
@ -153,8 +169,8 @@ void MatrixTest::multiplyIdentity() {
        12.0f,  13.0f,  14.0f,  15.0f
    );

-    QVERIFY(Matrix4()*values == values);
-    QVERIFY(values*Matrix4() == values);
+    CORRADE_COMPARE(Matrix4()*values, values);
+    CORRADE_COMPARE(values*Matrix4(), values);
 }

 void MatrixTest::multiply() {
@ -182,7 +198,7 @@ void MatrixTest::multiply() {
        -12,   8, -20, -26,  -2
    );

-    QVERIFY((left *= right) == expected);
+    CORRADE_COMPARE((left *= right), expected);
 }

 void MatrixTest::multiplyVector() {
@ -194,9 +210,7 @@ void MatrixTest::multiplyVector() {
          1,   3,  -3,  -4,  -1
    );

-    bool is = (matrix*Vector<5, int>(0, 5, 3, 4, 4) == Vector<5, int>(-24, -35, -32, -25, 1));
-
-    QVERIFY(is);
+    CORRADE_COMPARE((matrix*Vector<5, int>(0, 5, 3, 4, 4)), (Vector<5, int>(-24, -35, -32, -25, 1)));
 }

 void MatrixTest::transposed() {
@ -214,7 +228,7 @@ void MatrixTest::transposed() {
        3.0f,   7.0f,   11.0f,  15.0f
    );

-    QVERIFY(original.transposed() == transposed);
+    CORRADE_COMPARE(original.transposed(), transposed);
 }

 void MatrixTest::ij() {
@ -231,7 +245,7 @@ void MatrixTest::ij() {
        12.0f,  13.0f,  15.0f
    );

-    QVERIFY(original.ij(1, 2) == skipped);
+    CORRADE_COMPARE(original.ij(1, 2), skipped);
 }

 void MatrixTest::determinant() {
@ -243,7 +257,7 @@ void MatrixTest::determinant() {
        3, 1, 0, 1, -2
    );

-    QVERIFY(m.determinant() == -2);
+    CORRADE_COMPARE(m.determinant(), -2);
 }

 void MatrixTest::inverted() {
@ -263,8 +277,8 @@ void MatrixTest::inverted() {

    Matrix4 _inverse = m.inverted();

-    QVERIFY(_inverse == inverse);
-    QVERIFY(_inverse*m == Matrix4());
+    CORRADE_COMPARE(_inverse, inverse);
+    CORRADE_COMPARE(_inverse*m, Matrix4());
 }

 void MatrixTest::debug() {
@ -277,20 +291,20 @@ void MatrixTest::debug() {

    ostringstream o;
    Debug(&o) << m;
-    QCOMPARE(QString::fromStdString(o.str()), QString("Matrix(3, 4, 7, 9,\n"
-                                                      "       5, 4, -1, 4,\n"
-                                                      "       8, 7, 8, 5,\n"
-                                                      "       4, 3, 0, 9)\n"));
+    CORRADE_COMPARE(o.str(), "Matrix(3, 4, 7, 9,\n"
+                             "       5, 4, -1, 4,\n"
+                             "       8, 7, 8, 5,\n"
+                             "       4, 3, 0, 9)\n");

    o.str("");
    Debug(&o) << "a" << Matrix4() << "b" << Matrix4();
-    QCOMPARE(QString::fromStdString(o.str()), QString("a Matrix(1, 0, 0, 0,\n"
-                                                        "       0, 1, 0, 0,\n"
-                                                        "       0, 0, 1, 0,\n"
-                                                        "       0, 0, 0, 1) b Matrix(1, 0, 0, 0,\n"
-                                                        "       0, 1, 0, 0,\n"
-                                                        "       0, 0, 1, 0,\n"
-                                                        "       0, 0, 0, 1)\n"));
+    CORRADE_COMPARE(o.str(), "a Matrix(1, 0, 0, 0,\n"
+                             "       0, 1, 0, 0,\n"
+                             "       0, 0, 1, 0,\n"
+                             "       0, 0, 0, 1) b Matrix(1, 0, 0, 0,\n"
+                             "       0, 1, 0, 0,\n"
+                             "       0, 0, 1, 0,\n"
+                             "       0, 0, 0, 1)\n");
 }

 }}}
--- a/src/Math/Test/MatrixTest.h
+++ b/src/Math/Test/MatrixTest.h
@ -15,14 +15,14 @@
    GNU Lesser General Public License version 3 for more details.
 */

-#include <QtCore/QObject>
+#include <TestSuite/Tester.h>

 namespace Magnum { namespace Math { namespace Test {

-class MatrixTest: public QObject {
-    Q_OBJECT
+class MatrixTest: public Corrade::TestSuite::Tester<MatrixTest> {
+    public:
+        MatrixTest();

-    private slots:
        void construct();
        void constructFromVectors();
        void constructIdentity();
--- a/src/Math/Test/Vector2Test.cpp
+++ b/src/Math/Test/Vector2Test.cpp
@ -16,11 +16,10 @@
 #include "Vector2Test.h"

 #include <sstream>
-#include <QtTest/QTest>

 #include "Vector2.h"

-QTEST_APPLESS_MAIN(Magnum::Math::Test::Vector2Test)
+CORRADE_TEST_MAIN(Magnum::Math::Test::Vector2Test)

 using namespace std;
 using namespace Corrade::Utility;
@ -29,14 +28,19 @@ namespace Magnum { namespace Math { namespace Test {

 typedef Math::Vector2<float> Vector2;

+Vector2Test::Vector2Test() {
+    addTests(&Vector2Test::construct,
+             &Vector2Test::debug);
+}
+
 void Vector2Test::construct() {
-    QVERIFY((Vector2(1, 2) == Vector<2, float>(1.0f, 2.0f)));
+    CORRADE_COMPARE(Vector2(1, 2), (Vector<2, float>(1.0f, 2.0f)));
 }

 void Vector2Test::debug() {
    ostringstream o;
    Debug(&o) << Vector2(0.5f, 15.0f);
-    QCOMPARE(QString::fromStdString(o.str()), QString("Vector(0.5, 15)\n"));
+    CORRADE_COMPARE(o.str(), "Vector(0.5, 15)\n");
 }

 }}}
--- a/src/Math/Test/Vector2Test.h
+++ b/src/Math/Test/Vector2Test.h
@ -15,14 +15,14 @@
    GNU Lesser General Public License version 3 for more details.
 */

-#include <QtCore/QObject>
+#include <TestSuite/Tester.h>

 namespace Magnum { namespace Math { namespace Test {

-class Vector2Test: public QObject {
-    Q_OBJECT
+class Vector2Test: public Corrade::TestSuite::Tester<Vector2Test> {
+    public:
+        Vector2Test();

-    private slots:
        void construct();
        void debug();
 };
--- a/src/Math/Test/Vector3Test.cpp
+++ b/src/Math/Test/Vector3Test.cpp
@ -16,11 +16,10 @@
 #include "Vector3Test.h"

 #include <sstream>
-#include <QtTest/QTest>

 #include "Vector3.h"

-QTEST_APPLESS_MAIN(Magnum::Math::Test::Vector3Test)
+CORRADE_TEST_MAIN(Magnum::Math::Test::Vector3Test)

 using namespace std;
 using namespace Corrade::Utility;
@ -30,32 +29,40 @@ namespace Magnum { namespace Math { namespace Test {
 typedef Math::Vector3<float> Vector3;
 typedef Math::Vector2<float> Vector2;

+Vector3Test::Vector3Test() {
+    addTests(&Vector3Test::construct,
+             &Vector3Test::cross,
+             &Vector3Test::axis,
+             &Vector3Test::twoComponent,
+             &Vector3Test::debug);
+}
+
 void Vector3Test::construct() {
-    QVERIFY((Vector3(1, 2, 3) == Vector<3, float>(1.0f, 2.0f, 3.0f)));
-    QVERIFY((Vector3(Vector<2, float>(1.0f, 2.0f), 3) == Vector<3, float>(1.0f, 2.0f, 3.0f)));
+    CORRADE_COMPARE(Vector3(1, 2, 3), (Vector<3, float>(1.0f, 2.0f, 3.0f)));
+    CORRADE_COMPARE(Vector3(Vector<2, float>(1.0f, 2.0f), 3), (Vector<3, float>(1.0f, 2.0f, 3.0f)));
 }

 void Vector3Test::cross() {
    Vector3 a(1, -1, 1);
    Vector3 b(4, 3, 7);

-    QVERIFY(Vector3::cross(a, b) == Vector3(-10, -3, 7));
+    CORRADE_COMPARE(Vector3::cross(a, b), Vector3(-10, -3, 7));
 }

 void Vector3Test::axis() {
-    QVERIFY(Vector3::xAxis(5.0f) == Vector3(5.0f, 0.0f, 0.0f));
-    QVERIFY(Vector3::yAxis(6.0f) == Vector3(0.0f, 6.0f, 0.0f));
-    QVERIFY(Vector3::zAxis(7.0f) == Vector3(0.0f, 0.0f, 7.0f));
+    CORRADE_COMPARE(Vector3::xAxis(5.0f), Vector3(5.0f, 0.0f, 0.0f));
+    CORRADE_COMPARE(Vector3::yAxis(6.0f), Vector3(0.0f, 6.0f, 0.0f));
+    CORRADE_COMPARE(Vector3::zAxis(7.0f), Vector3(0.0f, 0.0f, 7.0f));
 }

 void Vector3Test::twoComponent() {
-    QVERIFY(Vector3(1.0f, 2.0f, 3.0f).xy() == Vector2(1.0f, 2.0f));
+    CORRADE_COMPARE(Vector3(1.0f, 2.0f, 3.0f).xy(), Vector2(1.0f, 2.0f));
 }

 void Vector3Test::debug() {
    ostringstream o;
    Debug(&o) << Vector3(0.5f, 15.0f, 1.0f);
-    QCOMPARE(QString::fromStdString(o.str()), QString("Vector(0.5, 15, 1)\n"));
+    CORRADE_COMPARE(o.str(), "Vector(0.5, 15, 1)\n");
 }

 }}}
--- a/src/Math/Test/Vector3Test.h
+++ b/src/Math/Test/Vector3Test.h
@ -15,14 +15,14 @@
    GNU Lesser General Public License version 3 for more details.
 */

-#include <QtCore/QObject>
+#include <TestSuite/Tester.h>

 namespace Magnum { namespace Math { namespace Test {

-class Vector3Test: public QObject {
-    Q_OBJECT
+class Vector3Test: public Corrade::TestSuite::Tester<Vector3Test> {
+    public:
+        Vector3Test();

-    private slots:
        void construct();
        void cross();
        void axis();
--- a/src/Math/Test/Vector4Test.cpp
+++ b/src/Math/Test/Vector4Test.cpp
@ -16,11 +16,10 @@
 #include "Vector4Test.h"

 #include <sstream>
-#include <QtTest/QTest>

 #include "Vector4.h"

-QTEST_APPLESS_MAIN(Magnum::Math::Test::Vector4Test)
+CORRADE_TEST_MAIN(Magnum::Math::Test::Vector4Test)

 using namespace std;
 using namespace Corrade::Utility;
@ -31,24 +30,31 @@ typedef Math::Vector4<float> Vector4;
 typedef Math::Vector3<float> Vector3;
 typedef Math::Vector2<float> Vector2;

+Vector4Test::Vector4Test() {
+    addTests(&Vector4Test::construct,
+             &Vector4Test::threeComponent,
+             &Vector4Test::twoComponent,
+             &Vector4Test::debug);
+}
+
 void Vector4Test::construct() {
-    QVERIFY(Vector4() == Vector4(0.0f, 0.0f, 0.0f, 1.0f));
-    QVERIFY((Vector4(1, 2, 3, 4) == Vector<4, float>(1.0f, 2.0f, 3.0f, 4.0f)));
-    QVERIFY((Vector4(Vector<3, float>(1.0f, 2.0f, 3.0f), 4) == Vector<4, float>(1.0f, 2.0f, 3.0f, 4.0f)));
+    CORRADE_COMPARE(Vector4(), Vector4(0.0f, 0.0f, 0.0f, 1.0f));
+    CORRADE_COMPARE(Vector4(1, 2, 3, 4), (Vector<4, float>(1.0f, 2.0f, 3.0f, 4.0f)));
+    CORRADE_COMPARE(Vector4(Vector<3, float>(1.0f, 2.0f, 3.0f), 4), (Vector<4, float>(1.0f, 2.0f, 3.0f, 4.0f)));
 }

 void Vector4Test::threeComponent() {
-    QVERIFY(Vector4(1.0f, 2.0f, 3.0f, 4.0f).xyz() == Vector3(1.0f, 2.0f, 3.0f));
+    CORRADE_COMPARE(Vector4(1.0f, 2.0f, 3.0f, 4.0f).xyz(), Vector3(1.0f, 2.0f, 3.0f));
 }

 void Vector4Test::twoComponent() {
-    QVERIFY(Vector4(1.0f, 2.0f, 3.0f, 4.0f).xy() == Vector2(1.0f, 2.0f));
+    CORRADE_COMPARE(Vector4(1.0f, 2.0f, 3.0f, 4.0f).xy(), Vector2(1.0f, 2.0f));
 }

 void Vector4Test::debug() {
    ostringstream o;
    Debug(&o) << Vector4(0.5f, 15.0f, 1.0f, 1.0f);
-    QCOMPARE(QString::fromStdString(o.str()), QString("Vector(0.5, 15, 1, 1)\n"));
+    CORRADE_COMPARE(o.str(), "Vector(0.5, 15, 1, 1)\n");
 }

 }}}
--- a/src/Math/Test/Vector4Test.h
+++ b/src/Math/Test/Vector4Test.h
@ -15,14 +15,14 @@
    GNU Lesser General Public License version 3 for more details.
 */

-#include <QtCore/QObject>
+#include <TestSuite/Tester.h>

 namespace Magnum { namespace Math { namespace Test {

-class Vector4Test: public QObject {
-    Q_OBJECT
+class Vector4Test: public Corrade::TestSuite::Tester<Vector4Test> {
+    public:
+        Vector4Test();

-    private slots:
        void construct();
        void threeComponent();
        void twoComponent();
--- a/src/Math/Test/VectorTest.cpp
+++ b/src/Math/Test/VectorTest.cpp
@ -16,12 +16,11 @@
 #include "VectorTest.h"

 #include <sstream>
-#include <QtTest/QTest>

 #include "Vector.h"
 #include "Math.h"

-QTEST_APPLESS_MAIN(Magnum::Math::Test::VectorTest)
+CORRADE_TEST_MAIN(Magnum::Math::Test::VectorTest)

 using namespace std;
 using namespace Corrade::Utility;
@ -31,11 +30,27 @@ namespace Magnum { namespace Math { namespace Test {
 typedef Vector<4, float> Vector4;
 typedef Vector<3, float> Vector3;

+VectorTest::VectorTest() {
+    addTests(&VectorTest::construct,
+             &VectorTest::data,
+             &VectorTest::copy,
+             &VectorTest::dot,
+             &VectorTest::multiplyDivide,
+             &VectorTest::addSubstract,
+             &VectorTest::length,
+             &VectorTest::lengthSquared,
+             &VectorTest::normalized,
+             &VectorTest::product,
+             &VectorTest::angle,
+             &VectorTest::negative,
+             &VectorTest::debug);
+}
+
 void VectorTest::construct() {
-    QVERIFY((Vector4() == Vector4(0.0f, 0.0f, 0.0f, 0.0f)));
+    CORRADE_COMPARE(Vector4(), Vector4(0.0f, 0.0f, 0.0f, 0.0f));

    float data[] = { 1.0f, 2.0f, 3.0f, 4.0f };
-    QVERIFY((Vector4::from(data) == Vector4(1.0f, 2.0f, 3.0f, 4.0f)));
+    CORRADE_COMPARE(Vector4::from(data), Vector4(1.0f, 2.0f, 3.0f, 4.0f));
 }

 void VectorTest::data() {
@ -44,7 +59,7 @@ void VectorTest::data() {

    v[0] = 1.0f;

-    QVERIFY(v == Vector4(1.0f, 0.0f, 1.5f, 0.0f));
+    CORRADE_COMPARE(v, Vector4(1.0f, 0.0f, 1.5f, 0.0f));
 }

 void VectorTest::copy() {
@ -64,25 +79,25 @@ void VectorTest::copy() {
    Vector4 original;
    original[3] = 1.0f;

-    QVERIFY(v2 == original);
-    QVERIFY(v3 == original);
+    CORRADE_COMPARE(v2, original);
+    CORRADE_COMPARE(v3, original);
 }

 void VectorTest::dot() {
-    QCOMPARE(Vector4::dot({1.0f, 0.5f, 0.75f, 1.5f}, {2.0f, 4.0f, 1.0f, 7.0f}), 15.25f);
+    CORRADE_COMPARE(Vector4::dot({1.0f, 0.5f, 0.75f, 1.5f}, {2.0f, 4.0f, 1.0f, 7.0f}), 15.25f);
 }

 void VectorTest::multiplyDivide() {
    Vector4 vec(1.0f, 2.0f, 3.0f, 4.0f);
    Vector4 multiplied(-1.5f, -3.0f, -4.5f, -6.0f);

-    QVERIFY(vec*-1.5f == multiplied);
-    QVERIFY(multiplied/-1.5f == vec);
+    CORRADE_COMPARE(vec*-1.5f, multiplied);
+    CORRADE_COMPARE(multiplied/-1.5f, vec);

    Math::Vector<1, char> vecChar(32);
    Math::Vector<1, char> multipliedChar(-48);
-    QVERIFY(vecChar*-1.5f == multipliedChar);
-    QVERIFY(multipliedChar/-1.5f == vecChar);
+    CORRADE_COMPARE(vecChar*-1.5f, multipliedChar);
+    CORRADE_COMPARE(multipliedChar/-1.5f, vecChar);
 }

 void VectorTest::addSubstract() {
@ -90,42 +105,42 @@ void VectorTest::addSubstract() {
    Vector4 b(-0.5, 1.0f, 0.0f, 7.5f);
    Vector4 expected(0.0f, -6.5f, 9.0f, -3.5f);

-    QVERIFY(a + b == expected);
-    QVERIFY(expected - b == a);
+    CORRADE_COMPARE(a + b, expected);
+    CORRADE_COMPARE(expected - b, a);
 }

 void VectorTest::length() {
-    QCOMPARE(Vector4(1.0f, 2.0f, 3.0f, 4.0f).length(), 5.4772256f);
+    CORRADE_COMPARE(Vector4(1.0f, 2.0f, 3.0f, 4.0f).length(), 5.4772256f);
 }

 void VectorTest::lengthSquared() {
-    QCOMPARE(Vector4(1.0f, 2.0f, 3.0f, 4.0f).lengthSquared(), 30.0f);
+    CORRADE_COMPARE(Vector4(1.0f, 2.0f, 3.0f, 4.0f).lengthSquared(), 30.0f);
 }

 void VectorTest::normalized() {
-    QVERIFY(Vector4(1.0f, 1.0f, 1.0f, 1.0f).normalized() == Vector4(0.5f, 0.5f, 0.5f, 0.5f));
+    CORRADE_COMPARE(Vector4(1.0f, 1.0f, 1.0f, 1.0f).normalized(), Vector4(0.5f, 0.5f, 0.5f, 0.5f));
 }

 void VectorTest::product() {
-    QCOMPARE(Vector3(1.0f, 2.0f, 3.0f).product(), 6.0f);
+    CORRADE_COMPARE(Vector3(1.0f, 2.0f, 3.0f).product(), 6.0f);
 }

 void VectorTest::angle() {
-    QCOMPARE(Vector3::angle({2.0f, 3.0f, 4.0f}, {1.0f, -2.0f, 3.0f}), rad(1.16251f));
+    CORRADE_COMPARE(Vector3::angle({2.0f, 3.0f, 4.0f}, {1.0f, -2.0f, 3.0f}), rad(1.162514f));
 }

 void VectorTest::negative() {
-    QVERIFY(-Vector4(1.0f, -3.0f, 5.0f, -10.0f) == Vector4(-1.0f, 3.0f, -5.0f, 10.0f));
+    CORRADE_COMPARE(-Vector4(1.0f, -3.0f, 5.0f, -10.0f), Vector4(-1.0f, 3.0f, -5.0f, 10.0f));
 }

 void VectorTest::debug() {
    ostringstream o;
    Debug(&o) << Vector4(0.5f, 15.0f, 1.0f, 1.0f);
-    QCOMPARE(QString::fromStdString(o.str()), QString("Vector(0.5, 15, 1, 1)\n"));
+    CORRADE_COMPARE(o.str(), "Vector(0.5, 15, 1, 1)\n");

    o.str("");
    Debug(&o) << "a" << Vector4() << "b" << Vector4();
-    QCOMPARE(QString::fromStdString(o.str()), QString("a Vector(0, 0, 0, 0) b Vector(0, 0, 0, 0)\n"));
+    CORRADE_COMPARE(o.str(), "a Vector(0, 0, 0, 0) b Vector(0, 0, 0, 0)\n");
 }

 }}}
--- a/src/Math/Test/VectorTest.h
+++ b/src/Math/Test/VectorTest.h
@ -15,14 +15,14 @@
    GNU Lesser General Public License version 3 for more details.
 */

-#include <QtCore/QObject>
+#include <TestSuite/Tester.h>

 namespace Magnum { namespace Math { namespace Test {

-class VectorTest: public QObject {
-    Q_OBJECT
+class VectorTest: public Corrade::TestSuite::Tester<VectorTest> {
+    public:
+        VectorTest();

-    private slots:
        void construct();
        void data();
        void copy();
--- a/src/Math/Vector.h
+++ b/src/Math/Vector.h
@ -20,8 +20,8 @@
 */

 #include <cmath>
+#include <Utility/Debug.h>

-#include "Utility/Debug.h"
 #include "MathTypeTraits.h"

 namespace Magnum { namespace Math {
--- a/src/MeshTools/Clean.h
+++ b/src/MeshTools/Clean.h
@ -21,8 +21,8 @@

 #include <unordered_map>
 #include <limits>
+#include <Utility/MurmurHash2.h>

-#include "Utility/MurmurHash2.h"
 #include "TypeTraits.h"

 namespace Magnum { namespace MeshTools {
--- a/src/MeshTools/Subdivide.h
+++ b/src/MeshTools/Subdivide.h
@ -20,7 +20,7 @@
 */

 #include <vector>
-#include "Utility/Debug.h"
+#include <Utility/Debug.h>

 namespace Magnum { namespace MeshTools {

--- a/src/MeshTools/Test/CMakeLists.txt
+++ b/src/MeshTools/Test/CMakeLists.txt
@ -1,12 +1,12 @@
-corrade_add_test(MeshToolsCleanTest CleanTest.h CleanTest.cpp ${CORRADE_UTILITY_LIBRARY})
-corrade_add_test(MeshToolsCombineIndexedArraysTest CombineIndexedArraysTest.h CombineIndexedArraysTest.cpp ${CORRADE_UTILITY_LIBRARY})
-corrade_add_test(MeshToolsCompressIndicesTest CompressIndicesTest.h CompressIndicesTest.cpp Magnum)
-corrade_add_test(MeshToolsFlipNormalsTest FlipNormalsTest.h FlipNormalsTest.cpp MagnumMeshToolsTestLib)
-corrade_add_test(MeshToolsGenerateFlatNormalsTest GenerateFlatNormalsTest.h GenerateFlatNormalsTest.cpp MagnumMeshToolsTestLib)
-corrade_add_test(MeshToolsInterleaveTest InterleaveTest.h InterleaveTest.cpp ${CORRADE_UTILITY_LIBRARY})
-corrade_add_test(MeshToolsSubdivideTest SubdivideTest.h SubdivideTest.cpp ${CORRADE_UTILITY_LIBRARY})
-corrade_add_test(MeshToolsSubdivideCleanBenchmark SubdivideCleanBenchmark.h SubdivideCleanBenchmark.cpp MagnumPrimitives)
-corrade_add_test(MeshToolsTipsifyTest TipsifyTest.h TipsifyTest.cpp MagnumMeshTools)
+corrade_add_test2(MeshToolsCleanTest CleanTest.cpp)
+corrade_add_test2(MeshToolsCombineIndexedArraysTest CombineIndexedArraysTest.cpp)
+corrade_add_test2(MeshToolsCompressIndicesTest CompressIndicesTest.cpp LIBRARIES Magnum)
+corrade_add_test2(MeshToolsFlipNormalsTest FlipNormalsTest.cpp LIBRARIES MagnumMeshToolsTestLib)
+corrade_add_test2(MeshToolsGenerateFlatNormalsTest GenerateFlatNormalsTest.cpp LIBRARIES MagnumMeshToolsTestLib)
+corrade_add_test2(MeshToolsInterleaveTest InterleaveTest.cpp)
+corrade_add_test2(MeshToolsSubdivideTest SubdivideTest.cpp)
+# corrade_add_test(MeshToolsSubdivideCleanBenchmark SubdivideCleanBenchmark.h SubdivideCleanBenchmark.cpp MagnumPrimitives)
+corrade_add_test2(MeshToolsTipsifyTest TipsifyTest.cpp LIBRARIES MagnumMeshTools)

 # Graceful assert for testing
 set_target_properties(MeshToolsCombineIndexedArraysTest MeshToolsInterleaveTest MeshToolsSubdivideTest PROPERTIES COMPILE_FLAGS -DCORRADE_GRACEFUL_ASSERT)
--- a/src/MeshTools/Test/CleanTest.cpp
+++ b/src/MeshTools/Test/CleanTest.cpp
@ -15,24 +15,26 @@

 #include "CleanTest.h"

-#include <QtTest/QTest>
-
 #include "MeshTools/Clean.h"

-QTEST_APPLESS_MAIN(Magnum::MeshTools::Test::CleanTest)
+CORRADE_TEST_MAIN(Magnum::MeshTools::Test::CleanTest)

 using namespace std;

 namespace Magnum { namespace MeshTools { namespace Test {

+CleanTest::CleanTest() {
+    addTests(&CleanTest::cleanMesh);
+}
+
 void CleanTest::cleanMesh() {
    vector<Vector1> vertices{1, 2, 1, 4};
    vector<unsigned int> indices{0, 1, 2, 1, 2, 3};
    MeshTools::clean(indices, vertices);

    /* Verify cleanup */
-    QVERIFY((vertices == vector<Vector1>{1, 2, 4}));
-    QVERIFY((indices == vector<unsigned int>{0, 1, 0, 1, 0, 2}));
+    CORRADE_VERIFY(vertices == (vector<Vector1>{1, 2, 4}));
+    CORRADE_COMPARE(indices, (vector<unsigned int>{0, 1, 0, 1, 0, 2}));
 }

 }}}
--- a/src/MeshTools/Test/CleanTest.h
+++ b/src/MeshTools/Test/CleanTest.h
@ -15,14 +15,14 @@
    GNU Lesser General Public License version 3 for more details.
 */

-#include <QtCore/QObject>
+#include <TestSuite/Tester.h>

 namespace Magnum { namespace MeshTools { namespace Test {

-class CleanTest: public QObject {
-    Q_OBJECT
+class CleanTest: public Corrade::TestSuite::Tester<CleanTest> {
+    public:
+        CleanTest();

-    private slots:
        void cleanMesh();

    private:
--- a/src/MeshTools/Test/CombineIndexedArraysTest.cpp
+++ b/src/MeshTools/Test/CombineIndexedArraysTest.cpp
@ -16,16 +16,20 @@
 #include "CombineIndexedArraysTest.h"

 #include <sstream>
-#include <QtTest/QTest>

 #include "MeshTools/CombineIndexedArrays.h"

-QTEST_APPLESS_MAIN(Magnum::MeshTools::Test::CombineIndexedArraysTest)
+CORRADE_TEST_MAIN(Magnum::MeshTools::Test::CombineIndexedArraysTest)

 using namespace std;

 namespace Magnum { namespace MeshTools { namespace Test {

+CombineIndexedArraysTest::CombineIndexedArraysTest() {
+    addTests(&CombineIndexedArraysTest::wrongIndexCount,
+             &CombineIndexedArraysTest::combine);
+}
+
 void CombineIndexedArraysTest::wrongIndexCount() {
    stringstream ss;
    Error::setOutput(&ss);
@ -34,8 +38,8 @@ void CombineIndexedArraysTest::wrongIndexCount() {
        tuple<const vector<unsigned int>&, vector<unsigned int>&>(vector<unsigned int>{0, 1, 0}, array),
        tuple<const vector<unsigned int>&, vector<unsigned int>&>(vector<unsigned int>{3, 4}, array));

-    QVERIFY(result.size() == 0);
-    QVERIFY(ss.str() == "MeshTools::combineIndexedArrays(): index arrays don't have the same length, nothing done.\n");
+    CORRADE_COMPARE(result.size(), 0);
+    CORRADE_COMPARE(ss.str(), "MeshTools::combineIndexedArrays(): index arrays don't have the same length, nothing done.\n");
 }

 void CombineIndexedArraysTest::combine() {
@ -48,11 +52,10 @@ void CombineIndexedArraysTest::combine() {
        tuple<const vector<unsigned int>&, vector<unsigned int>&>(vector<unsigned int>{3, 4, 3}, array2),
        tuple<const vector<unsigned int>&, vector<unsigned int>&>(vector<unsigned int>{6, 7, 6}, array3));

-    QVERIFY((result == vector<unsigned int>{0, 1, 0}));
-    QVERIFY((array1 == vector<unsigned int>{0, 1}));
-    QVERIFY((array2 == vector<unsigned int>{3, 4}));
-    QVERIFY((array3 == vector<unsigned int>{6, 7}));
+    CORRADE_COMPARE(result, (vector<unsigned int>{0, 1, 0}));
+    CORRADE_COMPARE(array1, (vector<unsigned int>{0, 1}));
+    CORRADE_COMPARE(array2, (vector<unsigned int>{3, 4}));
+    CORRADE_COMPARE(array3, (vector<unsigned int>{6, 7}));
 }

-
 }}}
--- a/src/MeshTools/Test/CombineIndexedArraysTest.h
+++ b/src/MeshTools/Test/CombineIndexedArraysTest.h
@ -15,14 +15,14 @@
    GNU Lesser General Public License version 3 for more details.
 */

-#include <QtCore/QObject>
+#include <TestSuite/Tester.h>

 namespace Magnum { namespace MeshTools { namespace Test {

-class CombineIndexedArraysTest: public QObject {
-    Q_OBJECT
+class CombineIndexedArraysTest: public Corrade::TestSuite::Tester<CombineIndexedArraysTest> {
+    public:
+        CombineIndexedArraysTest();

-    private slots:
        void wrongIndexCount();
        void combine();
 };
--- a/src/MeshTools/Test/CompressIndicesTest.cpp
+++ b/src/MeshTools/Test/CompressIndicesTest.cpp
@ -15,18 +15,23 @@

 #include "CompressIndicesTest.h"

-#include <QtTest/QTest>
+#include <Utility/Endianness.h>

-#include "Utility/Endianness.h"
 #include "MeshTools/CompressIndices.h"

-QTEST_APPLESS_MAIN(Magnum::MeshTools::Test::CompressIndicesTest)
+CORRADE_TEST_MAIN(Magnum::MeshTools::Test::CompressIndicesTest)

 using namespace std;
 using Corrade::Utility::Endianness;

 namespace Magnum { namespace MeshTools { namespace Test {

+CompressIndicesTest::CompressIndicesTest() {
+    addTests(&CompressIndicesTest::compressChar,
+             &CompressIndicesTest::compressShort,
+             &CompressIndicesTest::compressInt);
+}
+
 void CompressIndicesTest::compressChar() {
    size_t indexCount;
    Type indexType;
@ -34,10 +39,10 @@ void CompressIndicesTest::compressChar() {
    tie(indexCount, indexType, data) = MeshTools::compressIndices(
        vector<unsigned int>{1, 2, 3, 0, 4});

-    QVERIFY(indexCount == 5);
-    QVERIFY(indexType == Type::UnsignedByte);
-    QVERIFY((vector<char>(data, data+indexCount*TypeInfo::sizeOf(indexType)) ==
-        vector<char>{ 0x01, 0x02, 0x03, 0x00, 0x04 }));
+    CORRADE_COMPARE(indexCount, 5);
+    CORRADE_VERIFY(indexType == Type::UnsignedByte);
+    CORRADE_COMPARE(vector<char>(data, data+indexCount*TypeInfo::sizeOf(indexType)),
+        (vector<char>{ 0x01, 0x02, 0x03, 0x00, 0x04 }));

    delete[] data;
 }
@ -49,20 +54,20 @@ void CompressIndicesTest::compressShort() {
    tie(indexCount, indexType, data) = MeshTools::compressIndices(
        vector<unsigned int>{1, 256, 0, 5});

-    QVERIFY(indexCount == 4);
-    QVERIFY(indexType == Type::UnsignedShort);
+    CORRADE_COMPARE(indexCount, 4);
+    CORRADE_VERIFY(indexType == Type::UnsignedShort);
    if(!Endianness::isBigEndian()) {
-        QVERIFY((vector<char>(data, data+indexCount*TypeInfo::sizeOf(indexType)) ==
-            vector<char>{ 0x01, 0x00,
-                          0x00, 0x01,
-                          0x00, 0x00,
-                          0x05, 0x00 }));
+        CORRADE_COMPARE(vector<char>(data, data+indexCount*TypeInfo::sizeOf(indexType)),
+            (vector<char>{ 0x01, 0x00,
+                           0x00, 0x01,
+                           0x00, 0x00,
+                           0x05, 0x00 }));
    } else {
-        QVERIFY((vector<char>(data, data+indexCount*TypeInfo::sizeOf(indexType)) ==
-            vector<char>{ 0x00, 0x01,
-                          0x01, 0x00,
-                          0x00, 0x00,
-                          0x00, 0x05 }));
+        CORRADE_COMPARE(vector<char>(data, data+indexCount*TypeInfo::sizeOf(indexType)),
+            (vector<char>{ 0x00, 0x01,
+                           0x01, 0x00,
+                           0x00, 0x00,
+                           0x00, 0x05 }));
    }

    delete[] data;
@ -75,21 +80,19 @@ void CompressIndicesTest::compressInt() {
    tie(indexCount, indexType, data) = MeshTools::compressIndices(
        vector<unsigned int>{65536, 3, 2});

-    QVERIFY(indexCount == 3);
-    QVERIFY(indexType == Type::UnsignedInt);
+    CORRADE_COMPARE(indexCount, 3);
+    CORRADE_VERIFY(indexType == Type::UnsignedInt);

    if(!Endianness::isBigEndian()) {
-        QVERIFY((vector<char>(data, data+indexCount*TypeInfo::sizeOf(indexType)) ==
-            vector<char>{ 0x00, 0x00, 0x01, 0x00,
-                          0x03, 0x00, 0x00, 0x00,
-                          0x02, 0x00, 0x00, 0x00
-            }));
+        CORRADE_COMPARE(vector<char>(data, data+indexCount*TypeInfo::sizeOf(indexType)),
+            (vector<char>{ 0x00, 0x00, 0x01, 0x00,
+                           0x03, 0x00, 0x00, 0x00,
+                           0x02, 0x00, 0x00, 0x00 }));
    } else {
-        QVERIFY((vector<char>(data, data+indexCount*TypeInfo::sizeOf(indexType)) ==
-            vector<char>{ 0x00, 0x01, 0x00, 0x00,
-                          0x00, 0x00, 0x00, 0x03,
-                          0x00, 0x00, 0x00, 0x02
-            }));
+        CORRADE_COMPARE(vector<char>(data, data+indexCount*TypeInfo::sizeOf(indexType)),
+            (vector<char>{ 0x00, 0x01, 0x00, 0x00,
+                           0x00, 0x00, 0x00, 0x03,
+                           0x00, 0x00, 0x00, 0x02 }));
    }

    delete[] data;
--- a/src/MeshTools/Test/CompressIndicesTest.h
+++ b/src/MeshTools/Test/CompressIndicesTest.h
@ -15,14 +15,14 @@
    GNU Lesser General Public License version 3 for more details.
 */

-#include <QtCore/QObject>
+#include <TestSuite/Tester.h>

 namespace Magnum { namespace MeshTools { namespace Test {

-class CompressIndicesTest: public QObject {
-    Q_OBJECT
+class CompressIndicesTest: public Corrade::TestSuite::Tester<CompressIndicesTest> {
+    public:
+        CompressIndicesTest();

-    private slots:
        void compressChar();
        void compressShort();
        void compressInt();
--- a/src/MeshTools/Test/FlipNormalsTest.cpp
+++ b/src/MeshTools/Test/FlipNormalsTest.cpp
@ -16,15 +16,21 @@
 #include "FlipNormalsTest.h"

 #include <sstream>
-#include <QtTest/QTest>
+
 #include "MeshTools/FlipNormals.h"

-QTEST_APPLESS_MAIN(Magnum::MeshTools::Test::FlipNormalsTest)
+CORRADE_TEST_MAIN(Magnum::MeshTools::Test::FlipNormalsTest)

 using namespace std;

 namespace Magnum { namespace MeshTools { namespace Test {

+FlipNormalsTest::FlipNormalsTest() {
+    addTests(&FlipNormalsTest::wrongIndexCount,
+             &FlipNormalsTest::flipFaceWinding,
+             &FlipNormalsTest::flipNormals);
+}
+
 void FlipNormalsTest::wrongIndexCount() {
    stringstream ss;
    Error::setOutput(&ss);
@ -32,7 +38,7 @@ void FlipNormalsTest::wrongIndexCount() {
    vector<unsigned int> indices{0, 1};
    MeshTools::flipFaceWinding(indices);

-    QVERIFY(ss.str() == "MeshTools::flipNormals(): index count is not divisible by 3!\n");
+    CORRADE_COMPARE(ss.str(), "MeshTools::flipNormals(): index count is not divisible by 3!\n");
 }

 void FlipNormalsTest::flipFaceWinding() {
@ -40,8 +46,8 @@ void FlipNormalsTest::flipFaceWinding() {
                                 3, 4, 5};
    MeshTools::flipFaceWinding(indices);

-    QVERIFY((indices == vector<unsigned int>{0, 2, 1,
-                                             3, 5, 4}));
+    CORRADE_COMPARE(indices, (vector<unsigned int>{0, 2, 1,
+                                                   3, 5, 4}));
 }

 void FlipNormalsTest::flipNormals() {
@ -50,9 +56,9 @@ void FlipNormalsTest::flipNormals() {
                            Vector3::zAxis()};
    MeshTools::flipNormals(normals);

-    QVERIFY((normals == vector<Vector3>{-Vector3::xAxis(),
-                                        -Vector3::yAxis(),
-                                        -Vector3::zAxis()}));
+    CORRADE_COMPARE(normals, (vector<Vector3>{-Vector3::xAxis(),
+                                              -Vector3::yAxis(),
+                                              -Vector3::zAxis()}));
 }

 }}}
--- a/src/MeshTools/Test/FlipNormalsTest.h
+++ b/src/MeshTools/Test/FlipNormalsTest.h
@ -15,14 +15,14 @@
    GNU Lesser General Public License version 3 for more details.
 */

-#include <QtCore/QObject>
+#include <TestSuite/Tester.h>

 namespace Magnum { namespace MeshTools { namespace Test {

-class FlipNormalsTest: public QObject {
-    Q_OBJECT
+class FlipNormalsTest: public Corrade::TestSuite::Tester<FlipNormalsTest> {
+    public:
+        FlipNormalsTest();

-    private slots:
        void wrongIndexCount();
        void flipFaceWinding();
        void flipNormals();
--- a/src/MeshTools/Test/GenerateFlatNormalsTest.cpp
+++ b/src/MeshTools/Test/GenerateFlatNormalsTest.cpp
@ -16,15 +16,20 @@
 #include "GenerateFlatNormalsTest.h"

 #include <sstream>
-#include <QtTest/QTest>
+
 #include "MeshTools/GenerateFlatNormals.h"

-QTEST_APPLESS_MAIN(Magnum::MeshTools::Test::GenerateFlatNormalsTest)
+CORRADE_TEST_MAIN(Magnum::MeshTools::Test::GenerateFlatNormalsTest)

 using namespace std;

 namespace Magnum { namespace MeshTools { namespace Test {

+GenerateFlatNormalsTest::GenerateFlatNormalsTest() {
+    addTests(&GenerateFlatNormalsTest::wrongIndexCount,
+             &GenerateFlatNormalsTest::generate);
+}
+
 void GenerateFlatNormalsTest::wrongIndexCount() {
    stringstream ss;
    Error::setOutput(&ss);
@ -34,9 +39,9 @@ void GenerateFlatNormalsTest::wrongIndexCount() {
        0, 1
    }, {});

-    QVERIFY(indices.size() == 0);
-    QVERIFY(normals.size() == 0);
-    QVERIFY(ss.str() == "MeshTools::generateFlatNormals(): index count is not divisible by 3!\n");
+    CORRADE_COMPARE(indices.size(), 0);
+    CORRADE_COMPARE(normals.size(), 0);
+    CORRADE_COMPARE(ss.str(), "MeshTools::generateFlatNormals(): index count is not divisible by 3!\n");
 }

 void GenerateFlatNormalsTest::generate() {
@ -55,11 +60,11 @@ void GenerateFlatNormalsTest::generate() {
    }, vertices);


-    QVERIFY((indices == vector<unsigned int>{
+    CORRADE_COMPARE(indices, (vector<unsigned int>{
        0, 0, 0,
        1, 1, 1
    }));
-    QVERIFY((normals == vector<Vector3>{
+    CORRADE_COMPARE(normals, (vector<Vector3>{
        Vector3::zAxis(),
        -Vector3::zAxis()
    }));
--- a/src/MeshTools/Test/GenerateFlatNormalsTest.h
+++ b/src/MeshTools/Test/GenerateFlatNormalsTest.h
@ -15,14 +15,14 @@
    GNU Lesser General Public License version 3 for more details.
 */

-#include <QtCore/QObject>
+#include <TestSuite/Tester.h>

 namespace Magnum { namespace MeshTools { namespace Test {

-class GenerateFlatNormalsTest: public QObject {
-    Q_OBJECT
+class GenerateFlatNormalsTest: public Corrade::TestSuite::Tester<GenerateFlatNormalsTest> {
+    public:
+        GenerateFlatNormalsTest();

-    private slots:
        void wrongIndexCount();
        void generate();
 };
--- a/src/MeshTools/Test/InterleaveTest.cpp
+++ b/src/MeshTools/Test/InterleaveTest.cpp
@ -16,34 +16,39 @@
 #include "InterleaveTest.h"

 #include <sstream>
-#include <QtTest/QTest>

 #include "Utility/Endianness.h"
 #include "Utility/Debug.h"
 #include "MeshTools/Interleave.h"

-QTEST_APPLESS_MAIN(Magnum::MeshTools::Test::InterleaveTest)
+CORRADE_TEST_MAIN(Magnum::MeshTools::Test::InterleaveTest)

 using namespace std;
 using Corrade::Utility::Endianness;

 namespace Magnum { namespace MeshTools { namespace Test {

+InterleaveTest::InterleaveTest() {
+    addTests(&InterleaveTest::attributeCount,
+             &InterleaveTest::stride,
+             &InterleaveTest::write);
+}
+
 void InterleaveTest::attributeCount() {
    stringstream ss;
    Error::setOutput(&ss);
-    QCOMPARE((Implementation::Interleave::attributeCount(vector<char>{0, 1, 2},
+    CORRADE_COMPARE((Implementation::Interleave::attributeCount(vector<char>{0, 1, 2},
        vector<char>{0, 1, 2, 3, 4, 5})), size_t(0));
-    QVERIFY(ss.str() == "MeshTools::interleave(): attribute arrays don't have the same length, nothing done.\n");
+    CORRADE_COMPARE(ss.str(), "MeshTools::interleave(): attribute arrays don't have the same length, nothing done.\n");

-    QCOMPARE((Implementation::Interleave::attributeCount(vector<char>{0, 1, 2},
+    CORRADE_COMPARE((Implementation::Interleave::attributeCount(vector<char>{0, 1, 2},
        vector<char>{3, 4, 5})), size_t(3));
 }

 void InterleaveTest::stride() {
-    QCOMPARE(Implementation::Interleave::stride(vector<char>()), size_t(1));
-    QCOMPARE(Implementation::Interleave::stride(vector<int>()), size_t(4));
-    QCOMPARE((Implementation::Interleave::stride(vector<char>(), vector<int>())), size_t(5));
+    CORRADE_COMPARE(Implementation::Interleave::stride(vector<char>()), size_t(1));
+    CORRADE_COMPARE(Implementation::Interleave::stride(vector<int>()), size_t(4));
+    CORRADE_COMPARE((Implementation::Interleave::stride(vector<char>(), vector<int>())), size_t(5));
 }

 void InterleaveTest::write() {
@ -55,17 +60,17 @@ void InterleaveTest::write() {
        vector<int>{3, 4, 5},
        vector<short>{6, 7, 8});

-    QCOMPARE(attributeCount, size_t(3));
-    QCOMPARE(stride, size_t(7));
+    CORRADE_COMPARE(attributeCount, size_t(3));
+    CORRADE_COMPARE(stride, size_t(7));
    size_t size = attributeCount*stride;
    if(!Endianness::isBigEndian()) {
-        QVERIFY((vector<char>(data, data+size) == vector<char>{
+        CORRADE_COMPARE(vector<char>(data, data+size), (vector<char>{
            0x00, 0x03, 0x00, 0x00, 0x00, 0x06, 0x00,
            0x01, 0x04, 0x00, 0x00, 0x00, 0x07, 0x00,
            0x02, 0x05, 0x00, 0x00, 0x00, 0x08, 0x00
        }));
    } else {
-        QVERIFY((vector<char>(data, data+size) == vector<char>{
+        CORRADE_COMPARE(vector<char>(data, data+size), (vector<char>{
            0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x06,
            0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x07,
            0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x08
--- a/src/MeshTools/Test/InterleaveTest.h
+++ b/src/MeshTools/Test/InterleaveTest.h
@ -15,14 +15,14 @@
    GNU Lesser General Public License version 3 for more details.
 */

-#include <QtCore/QObject>
+#include <TestSuite/Tester.h>

 namespace Magnum { namespace MeshTools { namespace Test {

-class InterleaveTest: public QObject {
-    Q_OBJECT
+class InterleaveTest: public Corrade::TestSuite::Tester<InterleaveTest> {
+    public:
+        InterleaveTest();

-    private slots:
        void attributeCount();
        void stride();
        void write();
--- a/src/MeshTools/Test/SubdivideTest.cpp
+++ b/src/MeshTools/Test/SubdivideTest.cpp
@ -16,17 +16,21 @@
 #include "SubdivideTest.h"

 #include <sstream>
-#include <QtTest/QTest>

 #include "MeshTools/Clean.h"
 #include "MeshTools/Subdivide.h"

-QTEST_APPLESS_MAIN(Magnum::MeshTools::Test::SubdivideTest)
+CORRADE_TEST_MAIN(Magnum::MeshTools::Test::SubdivideTest)

 using namespace std;

 namespace Magnum { namespace MeshTools { namespace Test {

+SubdivideTest::SubdivideTest() {
+    addTests(&SubdivideTest::wrongIndexCount,
+             &SubdivideTest::subdivide);
+}
+
 void SubdivideTest::wrongIndexCount() {
    stringstream ss;
    Error::setOutput(&ss);
@ -34,7 +38,7 @@ void SubdivideTest::wrongIndexCount() {
    vector<Vector1> vertices;
    vector<unsigned int> indices{0, 1};
    MeshTools::subdivide(indices, vertices, interpolator);
-    QVERIFY(ss.str() == "MeshTools::subdivide(): index count is not divisible by 3!\n");
+    CORRADE_COMPARE(ss.str(), "MeshTools::subdivide(): index count is not divisible by 3!\n");
 }

 void SubdivideTest::subdivide() {
@ -42,15 +46,15 @@ void SubdivideTest::subdivide() {
    vector<unsigned int> indices{0, 1, 2, 1, 2, 3};
    MeshTools::subdivide(indices, vertices, interpolator);

-    QVERIFY(indices.size() == 24);
+    CORRADE_COMPARE(indices.size(), 24);

-    QVERIFY((vertices == vector<Vector1>{0, 2, 6, 8, 1, 4, 3, 4, 7, 5}));
-    QVERIFY((indices == vector<unsigned int>{4, 5, 6, 7, 8, 9, 0, 4, 6, 4, 1, 5, 6, 5, 2, 1, 7, 9, 7, 2, 8, 9, 8, 3}));
+    CORRADE_VERIFY(vertices == (vector<Vector1>{0, 2, 6, 8, 1, 4, 3, 4, 7, 5}));
+    CORRADE_COMPARE(indices, (vector<unsigned int>{4, 5, 6, 7, 8, 9, 0, 4, 6, 4, 1, 5, 6, 5, 2, 1, 7, 9, 7, 2, 8, 9, 8, 3}));

    MeshTools::clean(indices, vertices);

    /* Vertices 0, 1, 2, 3, 4, 5, 6, 7, 8 */
-    QVERIFY(vertices.size() == 9);
+    CORRADE_COMPARE(vertices.size(), 9);
 }

 }}}
--- a/src/MeshTools/Test/SubdivideTest.h
+++ b/src/MeshTools/Test/SubdivideTest.h
@ -15,14 +15,14 @@
    GNU Lesser General Public License version 3 for more details.
 */

-#include <QtCore/QObject>
+#include <TestSuite/Tester.h>

 namespace Magnum { namespace MeshTools { namespace Test {

-class SubdivideTest: public QObject {
-    Q_OBJECT
+class SubdivideTest: public Corrade::TestSuite::Tester<SubdivideTest> {
+    public:
+        SubdivideTest();

-    private slots:
        void wrongIndexCount();
        void subdivide();

--- a/src/MeshTools/Test/TipsifyTest.cpp
+++ b/src/MeshTools/Test/TipsifyTest.cpp
@ -19,7 +19,7 @@

 #include "MeshTools/Tipsify.h"

-QTEST_APPLESS_MAIN(Magnum::MeshTools::Test::TipsifyTest)
+CORRADE_TEST_MAIN(Magnum::MeshTools::Test::TipsifyTest)

 using namespace std;

@ -63,13 +63,16 @@ TipsifyTest::TipsifyTest(): indices{
    14, 11, 10,

    16, 17, 18
-}, vertexCount(19) {}
+}, vertexCount(19) {
+    addTests(&TipsifyTest::buildAdjacency,
+             &TipsifyTest::tipsify);
+}

 void TipsifyTest::buildAdjacency() {
    vector<unsigned int> liveTriangleCount, neighborOffset, neighbors;
    Implementation::Tipsify(indices, vertexCount).buildAdjacency(liveTriangleCount, neighborOffset, neighbors);

-    QVERIFY((liveTriangleCount == vector<unsigned int>{
+    CORRADE_COMPARE(liveTriangleCount, (vector<unsigned int>{
        1, 3, 3, 2,
        4, 6, 6, 2,
        2, 6, 6, 4,
@ -77,7 +80,7 @@ void TipsifyTest::buildAdjacency() {
        1, 1, 1
    }));

-    QVERIFY((neighborOffset == vector<unsigned int>{
+    CORRADE_COMPARE(neighborOffset, (vector<unsigned int>{
        0, 1, 4, 7,
        9, 13, 19, 25,
        27, 29, 35, 41,
@ -85,7 +88,7 @@ void TipsifyTest::buildAdjacency() {
        54, 55, 56, 57
    }));

-    QVERIFY((neighbors == vector<unsigned int>{
+    CORRADE_COMPARE(neighbors, (vector<unsigned int>{
        0,
        0, 7, 11,
        2, 7, 13,
@ -113,7 +116,7 @@ void TipsifyTest::buildAdjacency() {
 void TipsifyTest::tipsify() {
    MeshTools::tipsify(indices, vertexCount, 3);

-    QVERIFY((indices == vector<unsigned int>{
+    CORRADE_COMPARE(indices, (vector<unsigned int>{
        4, 1, 0,
        9, 5, 4,
        1, 4, 5,
--- a/src/MeshTools/Test/TipsifyTest.h
+++ b/src/MeshTools/Test/TipsifyTest.h
@ -16,17 +16,14 @@
 */

 #include <vector>
-#include <QtCore/QObject>
+#include <TestSuite/Tester.h>

 namespace Magnum { namespace MeshTools { namespace Test {

-class TipsifyTest: public QObject {
-    Q_OBJECT
-
+class TipsifyTest: public Corrade::TestSuite::Tester<TipsifyTest> {
    public:
        TipsifyTest();

-    private slots:
        void buildAdjacency();
        void tipsify();

--- a/src/Physics/Test/AbstractShapeTest.h
+++ b/src/Physics/Test/AbstractShapeTest.h
@ -15,13 +15,13 @@
    GNU Lesser General Public License version 3 for more details.
 */

-#include <QtTest/QTest>
+#include <TestSuite/Tester.h>

 #include "Magnum.h"

 namespace Magnum { namespace Physics { namespace Test {

-class AbstractShapeTest: public QObject {
+class AbstractShapeTest {
    protected:
        template<class T> void randomTransformation(T& shape) {
            shape.applyTransformation(Matrix4::translation(Vector3(7.0f, 8.0f, -9.0f)));
@ -29,16 +29,16 @@ class AbstractShapeTest: public QObject {
 };

 #define VERIFY_COLLIDES(a, b)                                               \
-    QVERIFY(a % b);                                                         \
-    QVERIFY(b % a);                                                         \
-    QVERIFY(a.collides(&b));                                                \
-    QVERIFY(b.collides(&a));
+    CORRADE_VERIFY(a % b);                                                  \
+    CORRADE_VERIFY(b % a);                                                  \
+    CORRADE_VERIFY(a.collides(&b));                                         \
+    CORRADE_VERIFY(b.collides(&a));

 #define VERIFY_NOT_COLLIDES(a, b)                                           \
-    QVERIFY(!(a % b));                                                      \
-    QVERIFY(!(b % a));                                                      \
-    QVERIFY(!(a.collides(&b)));                                             \
-    QVERIFY(!(b.collides(&a)));
+    CORRADE_VERIFY(!(a % b));                                               \
+    CORRADE_VERIFY(!(b % a));                                               \
+    CORRADE_VERIFY(!(a.collides(&b)));                                      \
+    CORRADE_VERIFY(!(b.collides(&a)));

 }}}

--- a/src/Physics/Test/AxisAlignedBoxTest.cpp
+++ b/src/Physics/Test/AxisAlignedBoxTest.cpp
@ -15,24 +15,26 @@

 #include "AxisAlignedBoxTest.h"

-#include <QtTest/QTest>
-
 #include "Physics/AxisAlignedBox.h"

-QTEST_APPLESS_MAIN(Magnum::Physics::Test::AxisAlignedBoxTest)
+CORRADE_TEST_MAIN(Magnum::Physics::Test::AxisAlignedBoxTest)

 namespace Magnum { namespace Physics { namespace Test {

+AxisAlignedBoxTest::AxisAlignedBoxTest() {
+    addTests(&AxisAlignedBoxTest::applyTransformation);
+}
+
 void AxisAlignedBoxTest::applyTransformation() {
    Physics::AxisAlignedBox box({-1.0f, -2.0f, -3.0f}, {1.0f, 2.0f, 3.0f});

    box.applyTransformation(Matrix4::scaling({2.0f, -1.0f, 1.5f}));
-    QVERIFY((box.transformedPosition() == Vector3(-2.0f, 2.0f, -4.5f)));
-    QVERIFY((box.transformedSize() == Vector3(2.0f, -2.0f, 4.5f)));
+    CORRADE_COMPARE(box.transformedPosition(), Vector3(-2.0f, 2.0f, -4.5f));
+    CORRADE_COMPARE(box.transformedSize(), Vector3(2.0f, -2.0f, 4.5f));

    box.applyTransformation(Matrix4::translation(Vector3(1.0f))*Matrix4::rotation(deg(90.0f), Vector3::xAxis()));
-    QVERIFY((box.transformedPosition() == Vector3(0.0f, 4.0f, -1.0f)));
-    QVERIFY((box.transformedSize() == Vector3(1.0f, -3.0f, 2.0f)));
+    CORRADE_COMPARE(box.transformedPosition(), Vector3(0.0f, 4.0f, -1.0f));
+    CORRADE_COMPARE(box.transformedSize(), Vector3(1.0f, -3.0f, 2.0f));
 }

 }}}
--- a/src/Physics/Test/AxisAlignedBoxTest.h
+++ b/src/Physics/Test/AxisAlignedBoxTest.h
@ -15,14 +15,14 @@
    GNU Lesser General Public License version 3 for more details.
 */

-#include <QtCore/QObject>
+#include <TestSuite/Tester.h>

 namespace Magnum { namespace Physics { namespace Test {

-class AxisAlignedBoxTest: public QObject {
-    Q_OBJECT
+class AxisAlignedBoxTest: public Corrade::TestSuite::Tester<AxisAlignedBoxTest> {
+    public:
+        AxisAlignedBoxTest();

-    private slots:
        void applyTransformation();
 };

--- a/src/Physics/Test/CMakeLists.txt
+++ b/src/Physics/Test/CMakeLists.txt
@ -1,7 +1,7 @@
-corrade_add_test(PhysicsAxisAlignedBoxTest AxisAlignedBoxTest.h AxisAlignedBoxTest.cpp MagnumPhysics)
-corrade_add_test(PhysicsCapsuleTest CapsuleTest.h CapsuleTest.cpp MagnumPhysics)
-corrade_add_test(PhysicsLineTest LineTest.h LineTest.cpp MagnumPhysics)
-corrade_add_test(PhysicsPlaneTest PlaneTest.h PlaneTest.cpp MagnumPhysics)
-corrade_add_test(PhysicsPointTest PointTest.h PointTest.cpp MagnumPhysics)
-corrade_add_test(PhysicsShapeGroupTest ShapeGroupTest.h ShapeGroupTest.cpp MagnumPhysics)
-corrade_add_test(PhysicsSphereTest SphereTest.h SphereTest.cpp MagnumPhysics)
+corrade_add_test2(PhysicsAxisAlignedBoxTest AxisAlignedBoxTest.cpp LIBRARIES MagnumPhysics)
+corrade_add_test2(PhysicsCapsuleTest CapsuleTest.cpp LIBRARIES MagnumPhysics)
+corrade_add_test2(PhysicsLineTest LineTest.cpp LIBRARIES MagnumPhysics)
+corrade_add_test2(PhysicsPlaneTest PlaneTest.cpp LIBRARIES MagnumPhysics)
+corrade_add_test2(PhysicsPointTest PointTest.cpp LIBRARIES MagnumPhysics)
+corrade_add_test2(PhysicsShapeGroupTest ShapeGroupTest.cpp LIBRARIES MagnumPhysics)
+corrade_add_test2(PhysicsSphereTest SphereTest.cpp LIBRARIES MagnumPhysics)
--- a/src/Physics/Test/CapsuleTest.cpp
+++ b/src/Physics/Test/CapsuleTest.cpp
@ -15,25 +15,28 @@

 #include "CapsuleTest.h"

-#include <QtTest/QTest>
-
 #include "Physics/Capsule.h"

-QTEST_APPLESS_MAIN(Magnum::Physics::Test::CapsuleTest)
+CORRADE_TEST_MAIN(Magnum::Physics::Test::CapsuleTest)

 namespace Magnum { namespace Physics { namespace Test {

+CapsuleTest::CapsuleTest() {
+    addTests(&CapsuleTest::applyTransformation,
+             &CapsuleTest::collisionPoint);
+}
+
 void CapsuleTest::applyTransformation() {
    Physics::Capsule capsule({1.0f, 2.0f, 3.0f}, {-1.0f, -2.0f, -3.0f}, 7.0f);

    capsule.applyTransformation(Matrix4::rotation(deg(90.0f), Vector3::zAxis()));
-    QVERIFY((capsule.transformedA() == Vector3(-2.0f, 1.0f, 3.0f)));
-    QVERIFY((capsule.transformedB() == Vector3(2.0f, -1.0f, -3.0f)));
-    QCOMPARE(capsule.radius(), 7.0f);
+    CORRADE_COMPARE(capsule.transformedA(), Vector3(-2.0f, 1.0f, 3.0f));
+    CORRADE_COMPARE(capsule.transformedB(), Vector3(2.0f, -1.0f, -3.0f));
+    CORRADE_COMPARE(capsule.radius(), 7.0f);

    /* Apply average scaling to radius */
    capsule.applyTransformation(Matrix4::scaling({Math::Constants<GLfloat>::sqrt3(), -Math::Constants<GLfloat>::sqrt2(), 2.0f}));
-    QCOMPARE(capsule.transformedRadius(), Math::Constants<GLfloat>::sqrt3()*7.0f);
+    CORRADE_COMPARE(capsule.transformedRadius(), Math::Constants<GLfloat>::sqrt3()*7.0f);
 }

 void CapsuleTest::collisionPoint() {
--- a/src/Physics/Test/CapsuleTest.h
+++ b/src/Physics/Test/CapsuleTest.h
@ -19,10 +19,10 @@

 namespace Magnum { namespace Physics { namespace Test {

-class CapsuleTest: public AbstractShapeTest {
-    Q_OBJECT
+class CapsuleTest: public Corrade::TestSuite::Tester<CapsuleTest>, AbstractShapeTest {
+    public:
+        CapsuleTest();

-    private slots:
        void applyTransformation();
        void collisionPoint();
        void collisionSphere();
--- a/src/Physics/Test/LineTest.cpp
+++ b/src/Physics/Test/LineTest.cpp
@ -15,19 +15,21 @@

 #include "LineTest.h"

-#include <QtTest/QTest>
-
 #include "Physics/Line.h"

-QTEST_APPLESS_MAIN(Magnum::Physics::Test::LineTest)
+CORRADE_TEST_MAIN(Magnum::Physics::Test::LineTest)

 namespace Magnum { namespace Physics { namespace Test {

+LineTest::LineTest() {
+    addTests(&LineTest::applyTransformation);
+}
+
 void LineTest::applyTransformation() {
    Physics::Line line({1.0f, 2.0f, 3.0f}, {-1.0f, -2.0f, -3.0f});
    line.applyTransformation(Matrix4::rotation(deg(90.0f), Vector3::zAxis()));
-    QVERIFY((line.transformedA() == Vector3(-2.0f, 1.0f, 3.0f)));
-    QVERIFY((line.transformedB() == Vector3(2.0f, -1.0f, -3.0f)));
+    CORRADE_COMPARE(line.transformedA(), Vector3(-2.0f, 1.0f, 3.0f));
+    CORRADE_COMPARE(line.transformedB(), Vector3(2.0f, -1.0f, -3.0f));
 }

 }}}
--- a/src/Physics/Test/LineTest.h
+++ b/src/Physics/Test/LineTest.h
@ -15,14 +15,14 @@
    GNU Lesser General Public License version 3 for more details.
 */

-#include <QtCore/QObject>
+#include <TestSuite/Tester.h>

 namespace Magnum { namespace Physics { namespace Test {

-class LineTest: public QObject {
-    Q_OBJECT
+class LineTest: public Corrade::TestSuite::Tester<LineTest> {
+    public:
+        LineTest();

-    private slots:
        void applyTransformation();
 };

--- a/src/Physics/Test/PlaneTest.cpp
+++ b/src/Physics/Test/PlaneTest.cpp
@ -15,25 +15,29 @@

 #include "PlaneTest.h"

-#include <QtTest/QTest>
-
 #include "Physics/Plane.h"

-QTEST_APPLESS_MAIN(Magnum::Physics::Test::PlaneTest)
+CORRADE_TEST_MAIN(Magnum::Physics::Test::PlaneTest)

 namespace Magnum { namespace Physics { namespace Test {

+PlaneTest::PlaneTest() {
+    addTests(&PlaneTest::applyTransformation,
+             &PlaneTest::collisionLine,
+             &PlaneTest::collisionLineSegment);
+}
+
 void PlaneTest::applyTransformation() {
    Physics::Plane plane({1.0f, 2.0f, 3.0f}, {Math::Constants<float>::sqrt2(), -Math::Constants<float>::sqrt2(), 0});

    plane.applyTransformation(Matrix4::rotation(deg(90.0f), Vector3::xAxis()));
-    QVERIFY(plane.transformedPosition() == Vector3(1.0f, -3.0f, 2.0f));
-    QVERIFY(plane.transformedNormal() == Vector3(Math::Constants<float>::sqrt2(), 0, -Math::Constants<float>::sqrt2()));
+    CORRADE_COMPARE(plane.transformedPosition(), Vector3(1.0f, -3.0f, 2.0f));
+    CORRADE_COMPARE(plane.transformedNormal(), Vector3(Math::Constants<float>::sqrt2(), 0, -Math::Constants<float>::sqrt2()));

    /* The normal should stay normalized */
    plane.applyTransformation(Matrix4::scaling({1.5f, 2.0f, 3.0f}));
-    QVERIFY(plane.transformedPosition() == Vector3(1.5f, 4.0f, 9.0f));
-    QVERIFY(plane.transformedNormal() == Vector3(Math::Constants<float>::sqrt2(), -Math::Constants<float>::sqrt2(), 0));
+    CORRADE_COMPARE(plane.transformedPosition(), Vector3(1.5f, 4.0f, 9.0f));
+    CORRADE_COMPARE(plane.transformedNormal(), Vector3(Math::Constants<float>::sqrt2(), -Math::Constants<float>::sqrt2(), 0));
 }

 void PlaneTest::collisionLine() {
--- a/src/Physics/Test/PlaneTest.h
+++ b/src/Physics/Test/PlaneTest.h
@ -19,10 +19,10 @@

 namespace Magnum { namespace Physics { namespace Test {

-class PlaneTest: public AbstractShapeTest {
-    Q_OBJECT
+class PlaneTest: public Corrade::TestSuite::Tester<PlaneTest>, AbstractShapeTest {
+    public:
+        PlaneTest();

-    private slots:
        void applyTransformation();
        void collisionLine();
        void collisionLineSegment();
--- a/src/Physics/Test/PointTest.cpp
+++ b/src/Physics/Test/PointTest.cpp
@ -15,18 +15,20 @@

 #include "PointTest.h"

-#include <QtTest/QTest>
-
 #include "Physics/Point.h"

-QTEST_APPLESS_MAIN(Magnum::Physics::Test::PointTest)
+CORRADE_TEST_MAIN(Magnum::Physics::Test::PointTest)

 namespace Magnum { namespace Physics { namespace Test {

+PointTest::PointTest() {
+    addTests(&PointTest::applyTransformation);
+}
+
 void PointTest::applyTransformation() {
    Physics::Point point({1.0f, 2.0f, 3.0f});
    point.applyTransformation(Matrix4::translation({5.0f, 6.0f, 7.0f}));
-    QVERIFY((point.transformedPosition() == Vector3(6.0f, 8.0f, 10.0f)));
+    CORRADE_COMPARE(point.transformedPosition(), Vector3(6.0f, 8.0f, 10.0f));
 }

 }}}
--- a/src/Physics/Test/PointTest.h
+++ b/src/Physics/Test/PointTest.h
@ -15,14 +15,14 @@
    GNU Lesser General Public License version 3 for more details.
 */

-#include <QtCore/QObject>
+#include <TestSuite/Tester.h>

 namespace Magnum { namespace Physics { namespace Test {

-class PointTest: public QObject {
-    Q_OBJECT
+class PointTest: public Corrade::TestSuite::Tester<PointTest> {
+    public:
+        PointTest();

-    private slots:
        void applyTransformation();
 };

--- a/src/Physics/Test/ShapeGroupTest.cpp
+++ b/src/Physics/Test/ShapeGroupTest.cpp
@ -16,18 +16,22 @@
 #include "ShapeGroupTest.h"

 #include <functional>
-#include <QtTest/QTest>

 #include "Physics/Point.h"
 #include "Physics/Sphere.h"
 #include "Physics/ShapeGroup.h"

-QTEST_APPLESS_MAIN(Magnum::Physics::Test::ShapeGroupTest)
-
 using namespace std;

+CORRADE_TEST_MAIN(Magnum::Physics::Test::ShapeGroupTest)
+
 namespace Magnum { namespace Physics { namespace Test {

+ShapeGroupTest::ShapeGroupTest() {
+    addTests(&ShapeGroupTest::copy,
+             &ShapeGroupTest::reference);
+}
+
 void ShapeGroupTest::copy() {
    ShapeGroup group;
    {
@ -39,6 +43,8 @@ void ShapeGroupTest::copy() {

    /* Just to test that it doesn't crash */
    group.applyTransformation(Matrix4::translation(Vector3::xAxis(1.0f)));
+
+    CORRADE_VERIFY(true);
 }

 void ShapeGroupTest::reference() {
@ -49,8 +55,8 @@ void ShapeGroupTest::reference() {

    group.applyTransformation(Matrix4::translation(Vector3(1.0f)));

-    QVERIFY((point.transformedPosition() == Vector3(2.0f, 3.0f, 4.0f)));
-    QVERIFY((sphere.transformedPosition() == Vector3(3.0f, 2.0f, 31.0f)));
+    CORRADE_VERIFY((point.transformedPosition() == Vector3(2.0f, 3.0f, 4.0f)));
+    CORRADE_VERIFY((sphere.transformedPosition() == Vector3(3.0f, 2.0f, 31.0f)));
 }

 }}}
--- a/src/Physics/Test/ShapeGroupTest.h
+++ b/src/Physics/Test/ShapeGroupTest.h
@ -15,14 +15,14 @@
    GNU Lesser General Public License version 3 for more details.
 */

-#include <QtCore/QObject>
+#include <TestSuite/Tester.h>

 namespace Magnum { namespace Physics { namespace Test {

-class ShapeGroupTest: public QObject {
-    Q_OBJECT
+class ShapeGroupTest: public Corrade::TestSuite::Tester<ShapeGroupTest> {
+    public:
+        ShapeGroupTest();

-    private slots:
        void copy();
        void reference();
 };
--- a/src/Physics/Test/SphereTest.cpp
+++ b/src/Physics/Test/SphereTest.cpp
@ -15,30 +15,35 @@

 #include "SphereTest.h"

-#include <QtTest/QTest>
-#include "Utility/Debug.h"
-
 #include "Physics/Sphere.h"

-QTEST_APPLESS_MAIN(Magnum::Physics::Test::SphereTest)
+CORRADE_TEST_MAIN(Magnum::Physics::Test::SphereTest)

 namespace Magnum { namespace Physics { namespace Test {

+SphereTest::SphereTest() {
+    addTests(&SphereTest::applyTransformation,
+             &SphereTest::collisionPoint,
+             &SphereTest::collisionLine,
+             &SphereTest::collisionLineSegment,
+             &SphereTest::collisionSphere);
+}
+
 void SphereTest::applyTransformation() {
    Physics::Sphere sphere({1.0f, 2.0f, 3.0f}, 7.0f);

    sphere.applyTransformation(Matrix4::rotation(deg(90.0f), Vector3::yAxis()));
-    QVERIFY((sphere.transformedPosition() == Vector3(3.0f, 2.0f, -1.0f)));
-    QCOMPARE(sphere.transformedRadius(), 7.0f);
+    CORRADE_COMPARE(sphere.transformedPosition(), Vector3(3.0f, 2.0f, -1.0f));
+    CORRADE_COMPARE(sphere.transformedRadius(), 7.0f);

    /* Symmetric scaling */
    sphere.applyTransformation(Matrix4::scaling(Vector3(2.0f)));
-    QVERIFY((sphere.transformedPosition() == Vector3(2.0f, 4.0f, 6.0f)));
-    QCOMPARE(sphere.transformedRadius(), 14.0f);
+    CORRADE_COMPARE(sphere.transformedPosition(), Vector3(2.0f, 4.0f, 6.0f));
+    CORRADE_COMPARE(sphere.transformedRadius(), 14.0f);

    /* Apply average scaling to radius */
    sphere.applyTransformation(Matrix4::scaling({Math::Constants<GLfloat>::sqrt3(), -Math::Constants<GLfloat>::sqrt2(), 2.0f}));
-    QCOMPARE(sphere.transformedRadius(), Math::Constants<GLfloat>::sqrt3()*7.0f);
+    CORRADE_COMPARE(sphere.transformedRadius(), Math::Constants<GLfloat>::sqrt3()*7.0f);
 }

 void SphereTest::collisionPoint() {
--- a/src/Physics/Test/SphereTest.h
+++ b/src/Physics/Test/SphereTest.h
@ -19,10 +19,10 @@

 namespace Magnum { namespace Physics { namespace Test {

-class SphereTest: public AbstractShapeTest {
-    Q_OBJECT
+class SphereTest: public Corrade::TestSuite::Tester<SphereTest>, AbstractShapeTest {
+    public:
+        SphereTest();

-    private slots:
        void applyTransformation();
        void collisionPoint();
        void collisionLine();
--- a/src/Primitives/Test/CMakeLists.txt
+++ b/src/Primitives/Test/CMakeLists.txt
@ -1,2 +1,2 @@
-corrade_add_test(PrimitivesCapsuleTest CapsuleTest.h CapsuleTest.cpp MagnumPrimitives)
-corrade_add_test(PrimitivesUVSphereTest UVSphereTest.h UVSphereTest.cpp MagnumPrimitives)
+corrade_add_test2(PrimitivesCapsuleTest CapsuleTest.cpp LIBRARIES MagnumPrimitives)
+corrade_add_test2(PrimitivesUVSphereTest UVSphereTest.cpp LIBRARIES MagnumPrimitives)
--- a/src/Primitives/Test/CapsuleTest.cpp
+++ b/src/Primitives/Test/CapsuleTest.cpp
@ -18,20 +18,23 @@

 #include "CapsuleTest.h"

-#include <QtTest/QTest>
-
-QTEST_APPLESS_MAIN(Magnum::Primitives::Test::CapsuleTest)
-
 #include "Primitives/Capsule.h"

 using namespace std;

+CORRADE_TEST_MAIN(Magnum::Primitives::Test::CapsuleTest)
+
 namespace Magnum { namespace Primitives { namespace Test {

+CapsuleTest::CapsuleTest() {
+    addTests(&CapsuleTest::withoutTextureCoords,
+             &CapsuleTest::withTextureCoords);
+}
+
 void CapsuleTest::withoutTextureCoords() {
    Capsule capsule(2, 3, 1.0f);

-    QVERIFY((*capsule.vertices(0) == vector<Vector4>{
+    CORRADE_COMPARE(*capsule.vertices(0), (vector<Vector4>{
        Vector4(0.0f, -1.5f, 0.0f),

        Vector4(0.0f, -1.20711f, 0.707107f),
@ -53,7 +56,7 @@ void CapsuleTest::withoutTextureCoords() {
        Vector4(0.0f, 1.5f, 0.0f)
    }));

-    QVERIFY((*capsule.normals(0) == vector<Vector3>{
+    CORRADE_COMPARE(*capsule.normals(0), (vector<Vector3>{
        Vector3(0.0f, -1.0f, 0.0f),

        Vector3(0.0f, -0.707107f, 0.707107f),
@ -75,7 +78,7 @@ void CapsuleTest::withoutTextureCoords() {
        Vector3(0.0f, 1.0f, 0.0f)
    }));

-    QVERIFY((*capsule.indices() == vector<unsigned int>{
+    CORRADE_COMPARE(*capsule.indices(), (vector<unsigned int>{
        0, 2, 1, 0, 3, 2, 0, 1, 3,
        1, 2, 5, 1, 5, 4, 2, 3, 6, 2, 6, 5, 3, 1, 4, 3, 4, 6,
        4, 5, 8, 4, 8, 7, 5, 6, 9, 5, 9, 8, 6, 4, 7, 6, 7, 9,
@ -87,7 +90,7 @@ void CapsuleTest::withoutTextureCoords() {
 void CapsuleTest::withTextureCoords() {
    Capsule capsule(2, 3, 1.0f, Capsule::TextureCoords::Generate);

-    QVERIFY((*capsule.vertices(0) == vector<Vector4>{
+    CORRADE_COMPARE(*capsule.vertices(0), (vector<Vector4>{
        Vector4(0.0f, -1.5f, 0.0f),

        Vector4(0.0f, -1.20711f, 0.707107f),
@ -113,7 +116,7 @@ void CapsuleTest::withTextureCoords() {
        Vector4(0.0f, 1.5f, 0.0f)
    }));

-    QVERIFY((*capsule.textureCoords2D(0) == vector<Vector2>{
+    CORRADE_COMPARE(*capsule.textureCoords2D(0), (vector<Vector2>{
        Vector2(0.5f, 0.0f),

        Vector2(0.0f, 0.166667f),
@ -139,7 +142,7 @@ void CapsuleTest::withTextureCoords() {
        Vector2(0.5f, 1.0f)
    }));

-    QVERIFY((*capsule.indices() == vector<unsigned int>{
+    CORRADE_COMPARE(*capsule.indices(), (vector<unsigned int>{
        0, 2, 1, 0, 3, 2, 0, 4, 3,
        1, 2, 6, 1, 6, 5, 2, 3, 7, 2, 7, 6, 3, 4, 8, 3, 8, 7,
        5, 6, 10, 5, 10, 9, 6, 7, 11, 6, 11, 10, 7, 8, 12, 7, 12, 11,
--- a/src/Primitives/Test/CapsuleTest.h
+++ b/src/Primitives/Test/CapsuleTest.h
@ -15,14 +15,14 @@
    GNU Lesser General Public License version 3 for more details.
 */

-#include <QtCore/QObject>
+#include <TestSuite/Tester.h>

 namespace Magnum { namespace Primitives { namespace Test {

-class CapsuleTest: public QObject {
-    Q_OBJECT
+class CapsuleTest: public Corrade::TestSuite::Tester<CapsuleTest> {
+    public:
+        CapsuleTest();

-    private slots:
        void withoutTextureCoords();
        void withTextureCoords();
 };
--- a/src/Primitives/Test/UVSphereTest.cpp
+++ b/src/Primitives/Test/UVSphereTest.cpp
@ -15,20 +15,23 @@

 #include "UVSphereTest.h"

-#include <QtTest/QTest>
-
 #include "Primitives/UVSphere.h"

 using namespace std;

-QTEST_APPLESS_MAIN(Magnum::Primitives::Test::UVSphereTest)
+CORRADE_TEST_MAIN(Magnum::Primitives::Test::UVSphereTest)

 namespace Magnum { namespace Primitives { namespace Test {

+UVSphereTest::UVSphereTest() {
+    addTests(&UVSphereTest::withoutTextureCoords,
+             &UVSphereTest::withTextureCoords);
+}
+
 void UVSphereTest::withoutTextureCoords() {
    UVSphere sphere(3, 3);

-    QVERIFY((*sphere.vertices(0) == vector<Vector4>{
+    CORRADE_COMPARE(*sphere.vertices(0), (vector<Vector4>{
        Vector4(0.0f, -1.0f, 0.0f),

        Vector4(0.0f, -0.5f, 0.866025f),
@ -42,7 +45,7 @@ void UVSphereTest::withoutTextureCoords() {
        Vector4(0.0f, 1.0f, 0.0f)
    }));

-    QVERIFY((*sphere.normals(0) == vector<Vector3>{
+    CORRADE_COMPARE(*sphere.normals(0), (vector<Vector3>{
        Vector3(0.0f, -1.0f, 0.0f),

        Vector3(0.0f, -0.5f, 0.866025f),
@ -56,7 +59,7 @@ void UVSphereTest::withoutTextureCoords() {
        Vector3(0.0f, 1.0f, 0.0f)
    }));

-    QVERIFY((*sphere.indices() == vector<unsigned int>{
+    CORRADE_COMPARE(*sphere.indices(), (vector<unsigned int>{
        0, 2, 1, 0, 3, 2, 0, 1, 3,
        1, 2, 5, 1, 5, 4, 2, 3, 6, 2, 6, 5, 3, 1, 4, 3, 4, 6,
        4, 5, 7, 5, 6, 7, 6, 4, 7
@ -66,7 +69,7 @@ void UVSphereTest::withoutTextureCoords() {
 void UVSphereTest::withTextureCoords() {
    UVSphere sphere(3, 3, UVSphere::TextureCoords::Generate);

-    QVERIFY((*sphere.vertices(0) == vector<Vector4>{
+    CORRADE_COMPARE(*sphere.vertices(0), (vector<Vector4>{
        Vector4(0.0f, -1.0f, 0.0f),

        Vector4(0.0f, -0.5f, 0.866025f),
@ -82,7 +85,7 @@ void UVSphereTest::withTextureCoords() {
        Vector4(0.0f, 1.0f, 0.0f)
    }));

-    QVERIFY((*sphere.textureCoords2D(0) == vector<Vector2>{
+    CORRADE_COMPARE(*sphere.textureCoords2D(0), (vector<Vector2>{
        Vector2(0.5f, 0.0f),

        Vector2(0.0f, 0.333333f),
@ -98,7 +101,7 @@ void UVSphereTest::withTextureCoords() {
        Vector2(0.5f, 1.0f)
    }));

-    QVERIFY((*sphere.indices() == vector<unsigned int>{
+    CORRADE_COMPARE(*sphere.indices(), (vector<unsigned int>{
        0, 2, 1, 0, 3, 2, 0, 4, 3,
        1, 2, 6, 1, 6, 5, 2, 3, 7, 2, 7, 6, 3, 4, 8, 3, 8, 7,
        5, 6, 9, 6, 7, 9, 7, 8, 9
--- a/src/Primitives/Test/UVSphereTest.h
+++ b/src/Primitives/Test/UVSphereTest.h
@ -15,14 +15,14 @@
    GNU Lesser General Public License version 3 for more details.
 */

-#include <QtCore/QObject>
+#include <TestSuite/Tester.h>

 namespace Magnum { namespace Primitives { namespace Test {

-class UVSphereTest: public QObject {
-    Q_OBJECT
+class UVSphereTest: public Corrade::TestSuite::Tester<UVSphereTest> {
+    public:
+        UVSphereTest();

-    private slots:
        void withoutTextureCoords();
        void withTextureCoords();
 };
--- a/src/Shaders/PhongShader.cpp
+++ b/src/Shaders/PhongShader.cpp
@ -15,7 +15,7 @@

 #include "PhongShader.h"

-#include "Utility/Resource.h"
+#include <Utility/Resource.h>

 namespace Magnum { namespace Shaders {

--- a/src/Test/CMakeLists.txt
+++ b/src/Test/CMakeLists.txt
@ -1,3 +1,3 @@
-corrade_add_test(ObjectTest ObjectTest.h ObjectTest.cpp MagnumTestLib)
-corrade_add_test(CameraTest CameraTest.h CameraTest.cpp Magnum)
-corrade_add_test(SceneTest SceneTest.h SceneTest.cpp Magnum)
+corrade_add_test2(ObjectTest ObjectTest.cpp LIBRARIES MagnumTestLib)
+corrade_add_test2(CameraTest CameraTest.cpp LIBRARIES Magnum)
+corrade_add_test2(SceneTest SceneTest.cpp LIBRARIES Magnum)
--- a/src/Test/CameraTest.cpp
+++ b/src/Test/CameraTest.cpp
@ -15,15 +15,18 @@

 #include "CameraTest.h"

-#include <QtTest/QTest>
-
 #include "Camera.h"
 #include "Scene.h"

-QTEST_APPLESS_MAIN(Magnum::Test::CameraTest)
+CORRADE_TEST_MAIN(Magnum::Test::CameraTest)

 namespace Magnum { namespace Test {

+CameraTest::CameraTest() {
+    addTests(&CameraTest::orthographic,
+             &CameraTest::perspective);
+}
+
 void CameraTest::orthographic() {
    Camera camera;
    camera.setOrthographic(5, 1, 9);
@ -33,7 +36,7 @@ void CameraTest::orthographic() {
              0.0f,   0.0f,   -0.25f,     0.0f,
              0.0f,   0.0f,   -1.25f,     1.0f);

-    QVERIFY(camera.projectionMatrix() == a);
+    CORRADE_COMPARE(camera.projectionMatrix(), a);
 }

 void CameraTest::perspective() {
@ -45,7 +48,7 @@ void CameraTest::perspective() {
              0.0f,       0.0f,      -1.9411764f, -1.0f,
              0.0f,       0.0f,      -94.1176452f, 0.0f);

-    QVERIFY(camera.projectionMatrix() == a);
+    CORRADE_COMPARE(camera.projectionMatrix(), a);
 }

 }}
--- a/src/Test/CameraTest.h
+++ b/src/Test/CameraTest.h
@ -15,14 +15,14 @@
    GNU Lesser General Public License version 3 for more details.
 */

-#include <QtCore/QObject>
+#include <TestSuite/Tester.h>

 namespace Magnum { namespace Test {

-class CameraTest: public QObject {
-    Q_OBJECT
+class CameraTest: public Corrade::TestSuite::Tester<CameraTest> {
+    public:
+        CameraTest();

-    private slots:
        void orthographic();
        void perspective();
 };
--- a/src/Test/ObjectTest.cpp
+++ b/src/Test/ObjectTest.cpp
@ -18,39 +18,47 @@
 #include "Camera.h"

 #include <sstream>
-#include <QtTest/QTest>

 using namespace std;

-QTEST_APPLESS_MAIN(Magnum::Test::ObjectTest)
+CORRADE_TEST_MAIN(Magnum::Test::ObjectTest)

 namespace Magnum { namespace Test {

+ObjectTest::ObjectTest() {
+    addTests(&ObjectTest::parenting,
+             &ObjectTest::transformation,
+             &ObjectTest::absoluteTransformationWrongCamera,
+             &ObjectTest::absoluteTransformation,
+             &ObjectTest::scene,
+             &ObjectTest::dirty);
+}
+
 void ObjectTest::parenting() {
    Object root;

    Object* childOne = new Object(&root);
    Object* childTwo = new Object(&root);

-    QVERIFY(childOne->parent() == &root);
-    QVERIFY(root.children().size() == 2);
+    CORRADE_VERIFY(childOne->parent() == &root);
+    CORRADE_COMPARE(root.children().size(), 2);

    /* A object cannot be parent of itself */
    childOne->setParent(childOne);
-    QVERIFY(childOne->parent() == &root);
+    CORRADE_VERIFY(childOne->parent() == &root);

    /* In fact, cyclic dependencies are not allowed at all */
    root.setParent(childTwo);
-    QVERIFY(root.parent() == nullptr);
+    CORRADE_VERIFY(root.parent() == nullptr);

    /* Reparent to another */
    childTwo->setParent(childOne);
-    QVERIFY(root.children().size() == 1 && *root.children().begin() == childOne);
-    QVERIFY(childOne->children().size() == 1 && *childOne->children().begin() == childTwo);
+    CORRADE_VERIFY(root.children().size() == 1 && *root.children().begin() == childOne);
+    CORRADE_VERIFY(childOne->children().size() == 1 && *childOne->children().begin() == childTwo);

    /* Delete child */
    delete childTwo;
-    QVERIFY(childOne->children().size() == 0);
+    CORRADE_VERIFY(childOne->children().empty());
 }

 void ObjectTest::transformation() {
@ -62,16 +70,16 @@ void ObjectTest::transformation() {
    o.multiplyTransformation(Matrix4::rotation(deg(35.0f), Vector3::zAxis()));
    o2.rotate(deg(35.0f), Vector3::zAxis());

-    QVERIFY(o.transformation() == Matrix4::rotation(deg(35.0f), Vector3::zAxis())*
+    CORRADE_COMPARE(o.transformation(), Matrix4::rotation(deg(35.0f), Vector3::zAxis())*
        Matrix4::translation(Vector3::xAxis(1.0f)));
-    QVERIFY(o2.transformation() == o.transformation());
+    CORRADE_COMPARE(o2.transformation(), o.transformation());

    o.multiplyTransformation(Matrix4::scaling(Vector3(2.0f)), Object::Transformation::Local);
    o2.scale(Vector3(2.0f), Object::Transformation::Local);
-    QVERIFY(o.transformation() == Matrix4::rotation(deg(35.0f), Vector3::zAxis())*
+    CORRADE_COMPARE(o.transformation(), Matrix4::rotation(deg(35.0f), Vector3::zAxis())*
        Matrix4::translation(Vector3::xAxis(1.0f))*
        Matrix4::scaling(Vector3(2.0f)));
-    QVERIFY(o2.transformation() == o.transformation());
+    CORRADE_COMPARE(o2.transformation(), o.transformation());
 }

 void ObjectTest::absoluteTransformationWrongCamera() {
@ -82,35 +90,35 @@ void ObjectTest::absoluteTransformationWrongCamera() {
    Object o(&s);
    o.translate(Vector3::yAxis());
    Camera c;
-    QVERIFY(o.absoluteTransformation(&c) == Matrix4::translation(Vector3::yAxis()));
-    QVERIFY(ss.str() == "Object::absoluteTransformation(): the camera is not part of the same scene as object!\n");
+    CORRADE_COMPARE(o.absoluteTransformation(&c), Matrix4::translation(Vector3::yAxis()));
+    CORRADE_COMPARE(ss.str(), "Object::absoluteTransformation(): the camera is not part of the same scene as object!\n");

    ss.str("");
    Object o2;
    o2.translate(Vector3::xAxis());
-    QVERIFY(o2.absoluteTransformation(&c) == Matrix4::translation(Vector3::xAxis()));
-    QVERIFY(ss.str() == "Object::absoluteTransformation(): the object is not part of camera scene!\n");
+    CORRADE_COMPARE(o2.absoluteTransformation(&c), Matrix4::translation(Vector3::xAxis()));
+    CORRADE_COMPARE(ss.str(), "Object::absoluteTransformation(): the object is not part of camera scene!\n");
 }

 void ObjectTest::absoluteTransformation() {
    Scene s;
    Camera c(&s);
    c.translate(Vector3::zAxis(2.0f));
-    QVERIFY(s.absoluteTransformation() == Matrix4());
-    QVERIFY(c.absoluteTransformation(&c) == Matrix4());
+    CORRADE_COMPARE(s.absoluteTransformation(), Matrix4());
+    CORRADE_COMPARE(c.absoluteTransformation(&c), Matrix4());

    Object o(&s);
    o.scale(Vector3(2.0f));
    Object o2(&o);
    o.rotate(deg(90.0f), Vector3::yAxis());
-    QVERIFY((o2.absoluteTransformation() ==
-        Matrix4::scaling(Vector3(2.0f))*Matrix4::rotation(deg(90.0f), Vector3::yAxis())));
-    QVERIFY((o2.absoluteTransformation(&c) ==
-        (Matrix4::translation(Vector3::zAxis(2.0f)).inverted())*Matrix4::scaling(Vector3(2.0f))*Matrix4::rotation(deg(90.0f), Vector3::yAxis())));
+    CORRADE_COMPARE(o2.absoluteTransformation(),
+        Matrix4::scaling(Vector3(2.0f))*Matrix4::rotation(deg(90.0f), Vector3::yAxis()));
+    CORRADE_COMPARE(o2.absoluteTransformation(&c),
+        (Matrix4::translation(Vector3::zAxis(2.0f)).inverted())*Matrix4::scaling(Vector3(2.0f))*Matrix4::rotation(deg(90.0f), Vector3::yAxis()));

    Object o3;
    o3.translate({1.0f, 2.0f, 3.0f});
-    QVERIFY(o3.absoluteTransformation() == Matrix4::translation({1.0f, 2.0f, 3.0f}));
+    CORRADE_COMPARE(o3.absoluteTransformation(), Matrix4::translation({1.0f, 2.0f, 3.0f}));
 }

 void ObjectTest::scene() {
@ -122,8 +130,8 @@ void ObjectTest::scene() {
    Object orphan;
    Object* childOfOrphan = new Object(&orphan);

-    QVERIFY(childTwo->scene() == &scene);
-    QVERIFY(childOfOrphan->scene() == nullptr);
+    CORRADE_VERIFY(childTwo->scene() == &scene);
+    CORRADE_VERIFY(childOfOrphan->scene() == nullptr);
 }

 void ObjectTest::dirty() {
@ -137,54 +145,54 @@ void ObjectTest::dirty() {
    childThree->rotate(deg(90.0f), Vector3::yAxis());

    /* Object is dirty at the beginning */
-    QVERIFY(scene.isDirty());
-    QVERIFY(childOne->isDirty());
+    CORRADE_VERIFY(scene.isDirty());
+    CORRADE_VERIFY(childOne->isDirty());

    /* Clean the object and all its dirty parents (but not children) */
    childOne->setClean();
-    QVERIFY(childOne->cleanedAbsoluteTransformation == childOne->absoluteTransformation());
-    QVERIFY(!scene.isDirty());
-    QVERIFY(!childOne->isDirty());
-    QVERIFY(childTwo->isDirty());
-    QVERIFY(childThree->isDirty());
+    CORRADE_COMPARE(childOne->cleanedAbsoluteTransformation, childOne->absoluteTransformation());
+    CORRADE_VERIFY(!scene.isDirty());
+    CORRADE_VERIFY(!childOne->isDirty());
+    CORRADE_VERIFY(childTwo->isDirty());
+    CORRADE_VERIFY(childThree->isDirty());

    /* If the object itself is already clean, it shouldn't clean it again */
    childOne->cleanedAbsoluteTransformation = Matrix4(Matrix4::Zero);
    childOne->setClean();
-    QVERIFY(childOne->cleanedAbsoluteTransformation == Matrix4(Matrix4::Zero));
+    CORRADE_COMPARE(childOne->cleanedAbsoluteTransformation, Matrix4(Matrix4::Zero));

    /* If any object in the hierarchy is already clean, it shouldn't clean it again */
    childTwo->setClean();
-    QVERIFY(childOne->cleanedAbsoluteTransformation == Matrix4(Matrix4::Zero));
-    QVERIFY(childTwo->cleanedAbsoluteTransformation == childTwo->absoluteTransformation());
-    QVERIFY(!childOne->isDirty());
-    QVERIFY(!childTwo->isDirty());
-    QVERIFY(childThree->isDirty());
+    CORRADE_COMPARE(childOne->cleanedAbsoluteTransformation, Matrix4(Matrix4::Zero));
+    CORRADE_COMPARE(childTwo->cleanedAbsoluteTransformation, childTwo->absoluteTransformation());
+    CORRADE_VERIFY(!childOne->isDirty());
+    CORRADE_VERIFY(!childTwo->isDirty());
+    CORRADE_VERIFY(childThree->isDirty());

    /* Mark object and all its children as dirty (but not parents) */
    childTwo->setDirty();
-    QVERIFY(!scene.isDirty());
-    QVERIFY(!childOne->isDirty());
-    QVERIFY(childTwo->isDirty());
-    QVERIFY(childThree->isDirty());
+    CORRADE_VERIFY(!scene.isDirty());
+    CORRADE_VERIFY(!childOne->isDirty());
+    CORRADE_VERIFY(childTwo->isDirty());
+    CORRADE_VERIFY(childThree->isDirty());

    /* Reparent object => make it and its children dirty (but not parents) */
    childThree->setClean();
-    QVERIFY(childThree->cleanedAbsoluteTransformation == childThree->absoluteTransformation());
+    CORRADE_COMPARE(childThree->cleanedAbsoluteTransformation, childThree->absoluteTransformation());
    childTwo->setParent(nullptr);
-    QVERIFY(childTwo->isDirty());
-    QVERIFY(!childOne->isDirty());
+    CORRADE_VERIFY(childTwo->isDirty());
+    CORRADE_VERIFY(!childOne->isDirty());
    childTwo->setParent(&scene);
-    QVERIFY(!scene.isDirty());
-    QVERIFY(childTwo->isDirty());
-    QVERIFY(childThree->isDirty());
+    CORRADE_VERIFY(!scene.isDirty());
+    CORRADE_VERIFY(childTwo->isDirty());
+    CORRADE_VERIFY(childThree->isDirty());

    /* Set object transformation => make it and its children dirty (but not parents) */
    childThree->setClean();
    childTwo->setTransformation(Matrix4::translation(Vector3::xAxis(1.0f)));
-    QVERIFY(!scene.isDirty());
-    QVERIFY(childTwo->isDirty());
-    QVERIFY(childThree->isDirty());
+    CORRADE_VERIFY(!scene.isDirty());
+    CORRADE_VERIFY(childTwo->isDirty());
+    CORRADE_VERIFY(childThree->isDirty());
 }

 }}
--- a/src/Test/ObjectTest.h
+++ b/src/Test/ObjectTest.h
@ -15,16 +15,16 @@
    GNU Lesser General Public License version 3 for more details.
 */

-#include <QtCore/QObject>
+#include <TestSuite/Tester.h>

 #include "Object.h"

 namespace Magnum { namespace Test {

-class ObjectTest: public QObject {
-    Q_OBJECT
+class ObjectTest: public Corrade::TestSuite::Tester<ObjectTest> {
+    public:
+        ObjectTest();

-    private slots:
        void parenting();
        void transformation();
        void absoluteTransformationWrongCamera();
--- a/src/Test/SceneTest.cpp
+++ b/src/Test/SceneTest.cpp
@ -15,34 +15,37 @@

 #include "SceneTest.h"

-#include <QtTest/QTest>
-
 #include "Scene.h"

-QTEST_APPLESS_MAIN(Magnum::Test::SceneTest)
+CORRADE_TEST_MAIN(Magnum::Test::SceneTest)

 namespace Magnum { namespace Test {

+SceneTest::SceneTest() {
+    addTests(&SceneTest::transformation,
+             &SceneTest::parent);
+}
+
 void SceneTest::transformation() {
    Scene scene;

    Object* scenePointer = &scene;
    scenePointer->setTransformation(Matrix4::translation({1.0f, 1.0f, 1.0f}));
-    QVERIFY(scene.transformation() == Matrix4());
+    CORRADE_COMPARE(scene.transformation(), Matrix4());
 }

 void SceneTest::parent() {
    Scene scene;

-    QVERIFY(scene.parent() == &scene);
+    CORRADE_VERIFY(scene.parent() == &scene);

    /* Scene parent cannot be changed */
    Object* scenePointer = &scene;
    Object object;
    scenePointer->setParent(&object);
-    QVERIFY(scene.parent() == &scene);
-    QVERIFY(scene.children().empty());
-    QVERIFY(object.children().empty());
+    CORRADE_VERIFY(scene.parent() == &scene);
+    CORRADE_VERIFY(scene.children().empty());
+    CORRADE_VERIFY(object.children().empty());
 }

 }}
--- a/src/Test/SceneTest.h
+++ b/src/Test/SceneTest.h
@ -15,16 +15,14 @@
    GNU Lesser General Public License version 3 for more details.
 */

-#include <QtCore/QObject>
-
-#include "Object.h"
+#include <TestSuite/Tester.h>

 namespace Magnum { namespace Test {

-class SceneTest: public QObject {
-    Q_OBJECT
+class SceneTest: public Corrade::TestSuite::Tester<SceneTest> {
+    public:
+        SceneTest();

-    private slots:
        void transformation();
        void parent();
 };
--- a/src/Trade/AbstractImporter.h
+++ b/src/Trade/AbstractImporter.h
@ -19,7 +19,8 @@
 * @brief Class Magnum::Trade::AbstractImporter
 */

-#include "PluginManager/Plugin.h"
+#include <PluginManager/Plugin.h>
+
 #include "ImageData.h"
 #include "Set.h"