Adapted to Corrade changes.

Allowing to instantiate Trade::AbstractImporter subclasses directly without plugin manager.
13 years ago · 231f3277ab
67 changed files with 526 additions and 522 deletions
--- a/src/Math/Algorithms/Test/GaussJordanTest.cpp
+++ b/src/Math/Algorithms/Test/GaussJordanTest.cpp
@ -31,8 +31,8 @@ typedef RectangularMatrix<4, 4, Float> Matrix4;
 typedef Vector<4, Float> Vector4;

 GaussJordanTest::GaussJordanTest() {
-    addTests(&GaussJordanTest::singular,
-             &GaussJordanTest::invert);
+    addTests({&GaussJordanTest::singular,
+              &GaussJordanTest::invert});
 }

 void GaussJordanTest::singular() {
--- a/src/Math/Algorithms/Test/GramSchmidtTest.cpp
+++ b/src/Math/Algorithms/Test/GramSchmidtTest.cpp
@ -31,8 +31,8 @@ typedef RectangularMatrix<3, 3, Float> Matrix3;
 typedef Vector<3, Float> Vector3;

 GramSchmidtTest::GramSchmidtTest() {
-    addTests(&GramSchmidtTest::orthogonalize,
-             &GramSchmidtTest::orthonormalize);
+    addTests({&GramSchmidtTest::orthogonalize,
+              &GramSchmidtTest::orthonormalize});
 }

 void GramSchmidtTest::orthogonalize() {
--- a/src/Math/Algorithms/Test/SvdTest.cpp
+++ b/src/Math/Algorithms/Test/SvdTest.cpp
@ -50,8 +50,8 @@ constexpr static Matrix5x8d a(
 static const Vector5d expected(std::sqrt(1248.0), 0.0, 20.0, std::sqrt(384.0), 0.0);

 SvdTest::SvdTest() {
-    addTests(&SvdTest::testDouble,
-             &SvdTest::testFloat);
+    addTests({&SvdTest::testDouble,
+              &SvdTest::testFloat});
 }

 void SvdTest::testDouble() {
--- a/src/Math/Geometry/Test/DistanceTest.cpp
+++ b/src/Math/Geometry/Test/DistanceTest.cpp
@ -36,10 +36,10 @@ typedef Math::Vector3<Float> Vector3;
 typedef Math::Constants<Float> Constants;

 DistanceTest::DistanceTest() {
-    addTests(&DistanceTest::linePoint2D,
-             &DistanceTest::linePoint3D,
-             &DistanceTest::lineSegmentPoint2D,
-             &DistanceTest::lineSegmentPoint3D);
+    addTests({&DistanceTest::linePoint2D,
+              &DistanceTest::linePoint3D,
+              &DistanceTest::lineSegmentPoint2D,
+              &DistanceTest::lineSegmentPoint3D});
 }

 void DistanceTest::linePoint2D() {
--- a/src/Math/Geometry/Test/IntersectionTest.cpp
+++ b/src/Math/Geometry/Test/IntersectionTest.cpp
@ -30,7 +30,7 @@ class IntersectionTest: public Corrade::TestSuite::Tester {
 typedef Math::Vector3<Float> Vector3;

 IntersectionTest::IntersectionTest() {
-    addTests(&IntersectionTest::planeLine);
+    addTests({&IntersectionTest::planeLine});
 }

 void IntersectionTest::planeLine() {
--- a/src/Math/Geometry/Test/RectangleTest.cpp
+++ b/src/Math/Geometry/Test/RectangleTest.cpp
@ -37,11 +37,12 @@ typedef Geometry::Rectangle<Int> Rectanglei;
 typedef Vector2<Int> Vector2i;

 RectangleTest::RectangleTest() {
-    addTests(&RectangleTest::access,
-             &RectangleTest::compare,
-             &RectangleTest::construct,
-             &RectangleTest::size,
-             &RectangleTest::debug);
+    addTests({&RectangleTest::access,
+              &RectangleTest::compare,
+              &RectangleTest::construct,
+              &RectangleTest::size,
+
+              &RectangleTest::debug});
 }

 void RectangleTest::access() {
--- a/src/Math/Test/AngleTest.cpp
+++ b/src/Math/Test/AngleTest.cpp
@ -38,12 +38,12 @@ typedef Math::Deg<Double> Degd;
 typedef Math::Rad<Double> Radd;

 AngleTest::AngleTest() {
-    addTests(&AngleTest::construct,
-             &AngleTest::literals,
-             &AngleTest::conversion,
+    addTests({&AngleTest::construct,
+              &AngleTest::literals,
+              &AngleTest::conversion,

-             &AngleTest::debugDeg,
-             &AngleTest::debugRad);
+              &AngleTest::debugDeg,
+              &AngleTest::debugRad});
 }

 void AngleTest::construct() {
--- a/src/Math/Test/BoolVectorTest.cpp
+++ b/src/Math/Test/BoolVectorTest.cpp
@ -50,23 +50,23 @@ static_assert(BoolVector<17>::DataSize == 3, "Improper DataSize");
 typedef Math::BoolVector<19> BoolVector19;

 BoolVectorTest::BoolVectorTest() {
-    addTests(&BoolVectorTest::constructDefault,
-             &BoolVectorTest::constructOneValue,
-             &BoolVectorTest::constructOneElement,
-             &BoolVectorTest::data,
+    addTests({&BoolVectorTest::constructDefault,
+              &BoolVectorTest::constructOneValue,
+              &BoolVectorTest::constructOneElement,
+              &BoolVectorTest::data,

-             &BoolVectorTest::constExpressions,
+              &BoolVectorTest::constExpressions,

-             &BoolVectorTest::compare,
-             &BoolVectorTest::compareUndefined,
-             &BoolVectorTest::all,
-             &BoolVectorTest::none,
-             &BoolVectorTest::any,
+              &BoolVectorTest::compare,
+              &BoolVectorTest::compareUndefined,
+              &BoolVectorTest::all,
+              &BoolVectorTest::none,
+              &BoolVectorTest::any,

-             &BoolVectorTest::bitInverse,
-             &BoolVectorTest::bitAndOrXor,
+              &BoolVectorTest::bitInverse,
+              &BoolVectorTest::bitAndOrXor,

-             &BoolVectorTest::debug);
+              &BoolVectorTest::debug});
 }

 void BoolVectorTest::constructDefault() {
--- a/src/Math/Test/ComplexTest.cpp
+++ b/src/Math/Test/ComplexTest.cpp
@ -55,33 +55,33 @@ class ComplexTest: public Corrade::TestSuite::Tester {
 };

 ComplexTest::ComplexTest() {
-    addTests(&ComplexTest::construct,
-             &ComplexTest::constructDefault,
-             &ComplexTest::constructFromVector,
-             &ComplexTest::compare,
+    addTests({&ComplexTest::construct,
+              &ComplexTest::constructDefault,
+              &ComplexTest::constructFromVector,
+              &ComplexTest::compare,

-             &ComplexTest::constExpressions,
+              &ComplexTest::constExpressions,

-             &ComplexTest::addSubtract,
-             &ComplexTest::negated,
-             &ComplexTest::multiplyDivideScalar,
-             &ComplexTest::multiply,
+              &ComplexTest::addSubtract,
+              &ComplexTest::negated,
+              &ComplexTest::multiplyDivideScalar,
+              &ComplexTest::multiply,

-             &ComplexTest::dot,
-             &ComplexTest::dotSelf,
-             &ComplexTest::length,
-             &ComplexTest::normalized,
+              &ComplexTest::dot,
+              &ComplexTest::dotSelf,
+              &ComplexTest::length,
+              &ComplexTest::normalized,

-             &ComplexTest::conjugated,
-             &ComplexTest::inverted,
-             &ComplexTest::invertedNormalized,
+              &ComplexTest::conjugated,
+              &ComplexTest::inverted,
+              &ComplexTest::invertedNormalized,

-             &ComplexTest::angle,
-             &ComplexTest::rotation,
-             &ComplexTest::matrix,
-             &ComplexTest::transformVector,
+              &ComplexTest::angle,
+              &ComplexTest::rotation,
+              &ComplexTest::matrix,
+              &ComplexTest::transformVector,

-             &ComplexTest::debug);
+              &ComplexTest::debug});
 }

 typedef Math::Deg<Float> Deg;
--- a/src/Math/Test/ConstantsTest.cpp
+++ b/src/Math/Test/ConstantsTest.cpp
@ -28,7 +28,7 @@ class ConstantsTest: public Corrade::TestSuite::Tester {
 };

 ConstantsTest::ConstantsTest() {
-    addTests(&ConstantsTest::constants);
+    addTests({&ConstantsTest::constants});
 }

 void ConstantsTest::constants() {
--- a/src/Math/Test/DualComplexTest.cpp
+++ b/src/Math/Test/DualComplexTest.cpp
@ -61,31 +61,31 @@ typedef Math::Matrix3<Float> Matrix3;
 typedef Math::Vector2<Float> Vector2;

 DualComplexTest::DualComplexTest() {
-    addTests(&DualComplexTest::construct,
-             &DualComplexTest::constructDefault,
-             &DualComplexTest::constructFromVector,
+    addTests({&DualComplexTest::construct,
+              &DualComplexTest::constructDefault,
+              &DualComplexTest::constructFromVector,

-             &DualComplexTest::constExpressions,
+              &DualComplexTest::constExpressions,

-             &DualComplexTest::multiply,
+              &DualComplexTest::multiply,

-             &DualComplexTest::lengthSquared,
-             &DualComplexTest::length,
-             &DualComplexTest::normalized,
+              &DualComplexTest::lengthSquared,
+              &DualComplexTest::length,
+              &DualComplexTest::normalized,

-             &DualComplexTest::complexConjugated,
-             &DualComplexTest::dualConjugated,
-             &DualComplexTest::conjugated,
-             &DualComplexTest::inverted,
-             &DualComplexTest::invertedNormalized,
+              &DualComplexTest::complexConjugated,
+              &DualComplexTest::dualConjugated,
+              &DualComplexTest::conjugated,
+              &DualComplexTest::inverted,
+              &DualComplexTest::invertedNormalized,

-             &DualComplexTest::rotation,
-             &DualComplexTest::translation,
-             &DualComplexTest::combinedTransformParts,
-             &DualComplexTest::matrix,
-             &DualComplexTest::transformPoint,
+              &DualComplexTest::rotation,
+              &DualComplexTest::translation,
+              &DualComplexTest::combinedTransformParts,
+              &DualComplexTest::matrix,
+              &DualComplexTest::transformPoint,

-             &DualComplexTest::debug);
+              &DualComplexTest::debug});
 }

 void DualComplexTest::construct() {
--- a/src/Math/Test/DualQuaternionTest.cpp
+++ b/src/Math/Test/DualQuaternionTest.cpp
@ -59,30 +59,30 @@ typedef Math::Quaternion<Float> Quaternion;
 typedef Math::Vector3<Float> Vector3;

 DualQuaternionTest::DualQuaternionTest() {
-    addTests(&DualQuaternionTest::construct,
-             &DualQuaternionTest::constructDefault,
-             &DualQuaternionTest::constructFromVector,
-
-             &DualQuaternionTest::constExpressions,
-
-             &DualQuaternionTest::lengthSquared,
-             &DualQuaternionTest::length,
-             &DualQuaternionTest::normalized,
-
-             &DualQuaternionTest::quaternionConjugated,
-             &DualQuaternionTest::dualConjugated,
-             &DualQuaternionTest::conjugated,
-             &DualQuaternionTest::inverted,
-             &DualQuaternionTest::invertedNormalized,
-
-             &DualQuaternionTest::rotation,
-             &DualQuaternionTest::translation,
-             &DualQuaternionTest::combinedTransformParts,
-             &DualQuaternionTest::matrix,
-             &DualQuaternionTest::transformPoint,
-             &DualQuaternionTest::transformPointNormalized,
-
-             &DualQuaternionTest::debug);
+    addTests({&DualQuaternionTest::construct,
+              &DualQuaternionTest::constructDefault,
+              &DualQuaternionTest::constructFromVector,
+
+              &DualQuaternionTest::constExpressions,
+
+              &DualQuaternionTest::lengthSquared,
+              &DualQuaternionTest::length,
+              &DualQuaternionTest::normalized,
+
+              &DualQuaternionTest::quaternionConjugated,
+              &DualQuaternionTest::dualConjugated,
+              &DualQuaternionTest::conjugated,
+              &DualQuaternionTest::inverted,
+              &DualQuaternionTest::invertedNormalized,
+
+              &DualQuaternionTest::rotation,
+              &DualQuaternionTest::translation,
+              &DualQuaternionTest::combinedTransformParts,
+              &DualQuaternionTest::matrix,
+              &DualQuaternionTest::transformPoint,
+              &DualQuaternionTest::transformPointNormalized,
+
+              &DualQuaternionTest::debug});
 }

 void DualQuaternionTest::construct() {
--- a/src/Math/Test/DualTest.cpp
+++ b/src/Math/Test/DualTest.cpp
@ -43,20 +43,20 @@ class DualTest: public Corrade::TestSuite::Tester {
 typedef Math::Dual<Float> Dual;

 DualTest::DualTest() {
-    addTests(&DualTest::construct,
-             &DualTest::constructDefault,
-             &DualTest::compare,
+    addTests({&DualTest::construct,
+              &DualTest::constructDefault,
+              &DualTest::compare,

-             &DualTest::constExpressions,
+              &DualTest::constExpressions,

-             &DualTest::addSubtract,
-             &DualTest::negated,
-             &DualTest::multiplyDivide,
+              &DualTest::addSubtract,
+              &DualTest::negated,
+              &DualTest::multiplyDivide,

-             &DualTest::conjugated,
-             &DualTest::sqrt,
+              &DualTest::conjugated,
+              &DualTest::sqrt,

-             &DualTest::debug);
+              &DualTest::debug});
 }

 void DualTest::construct() {
--- a/src/Math/Test/FunctionsTest.cpp
+++ b/src/Math/Test/FunctionsTest.cpp
@ -54,25 +54,25 @@ typedef Math::Vector3<Byte> Vector3b;
 typedef Math::Vector3<Int> Vector3i;

 FunctionsTest::FunctionsTest() {
-    addTests(&FunctionsTest::min,
-             &FunctionsTest::max,
-             &FunctionsTest::abs,
-             &FunctionsTest::sqrt,
-             &FunctionsTest::clamp,
-             &FunctionsTest::lerp,
-             &FunctionsTest::normalizeUnsigned,
-             &FunctionsTest::normalizeSigned,
-             &FunctionsTest::denormalizeUnsigned,
-             &FunctionsTest::denormalizeSigned,
-             &FunctionsTest::renormalizeUnsinged,
-             &FunctionsTest::renormalizeSinged,
-
-             &FunctionsTest::normalizeTypeDeduction,
-
-             &FunctionsTest::pow,
-             &FunctionsTest::log,
-             &FunctionsTest::log2,
-             &FunctionsTest::trigonometric);
+    addTests({&FunctionsTest::min,
+              &FunctionsTest::max,
+              &FunctionsTest::abs,
+              &FunctionsTest::sqrt,
+              &FunctionsTest::clamp,
+              &FunctionsTest::lerp,
+              &FunctionsTest::normalizeUnsigned,
+              &FunctionsTest::normalizeSigned,
+              &FunctionsTest::denormalizeUnsigned,
+              &FunctionsTest::denormalizeSigned,
+              &FunctionsTest::renormalizeUnsinged,
+              &FunctionsTest::renormalizeSinged,
+
+              &FunctionsTest::normalizeTypeDeduction,
+
+              &FunctionsTest::pow,
+              &FunctionsTest::log,
+              &FunctionsTest::log2,
+              &FunctionsTest::trigonometric});
 }

 void FunctionsTest::min() {
--- a/src/Math/Test/MathTypeTraitsTest.cpp
+++ b/src/Math/Test/MathTypeTraitsTest.cpp
@ -33,8 +33,8 @@ class MathTypeTraitsTest: public Corrade::TestSuite::Tester {
 };

 MathTypeTraitsTest::MathTypeTraitsTest() {
-    addTests(&MathTypeTraitsTest::equalsIntegral,
-             &MathTypeTraitsTest::equalsFloatingPoint);
+    addTests({&MathTypeTraitsTest::equalsIntegral,
+              &MathTypeTraitsTest::equalsFloatingPoint});
 }

 void MathTypeTraitsTest::equalsIntegral() {
--- a/src/Math/Test/Matrix3Test.cpp
+++ b/src/Math/Test/Matrix3Test.cpp
@ -54,26 +54,26 @@ typedef Math::Matrix<2, Float> Matrix2;
 typedef Math::Vector2<Float> Vector2;

 Matrix3Test::Matrix3Test() {
-    addTests(&Matrix3Test::construct,
-             &Matrix3Test::constructIdentity,
-             &Matrix3Test::constructZero,
-             &Matrix3Test::constructConversion,
-             &Matrix3Test::constructCopy,
-
-             &Matrix3Test::translation,
-             &Matrix3Test::scaling,
-             &Matrix3Test::rotation,
-             &Matrix3Test::reflection,
-             &Matrix3Test::projection,
-             &Matrix3Test::fromParts,
-             &Matrix3Test::rotationScalingPart,
-             &Matrix3Test::rotationPart,
-             &Matrix3Test::vectorParts,
-             &Matrix3Test::invertedEuclidean,
-             &Matrix3Test::transform,
-
-             &Matrix3Test::debug,
-             &Matrix3Test::configuration);
+    addTests({&Matrix3Test::construct,
+              &Matrix3Test::constructIdentity,
+              &Matrix3Test::constructZero,
+              &Matrix3Test::constructConversion,
+              &Matrix3Test::constructCopy,
+
+              &Matrix3Test::translation,
+              &Matrix3Test::scaling,
+              &Matrix3Test::rotation,
+              &Matrix3Test::reflection,
+              &Matrix3Test::projection,
+              &Matrix3Test::fromParts,
+              &Matrix3Test::rotationScalingPart,
+              &Matrix3Test::rotationPart,
+              &Matrix3Test::vectorParts,
+              &Matrix3Test::invertedEuclidean,
+              &Matrix3Test::transform,
+
+              &Matrix3Test::debug,
+              &Matrix3Test::configuration});
 }

 void Matrix3Test::construct() {
--- a/src/Math/Test/Matrix4Test.cpp
+++ b/src/Math/Test/Matrix4Test.cpp
@ -60,31 +60,31 @@ typedef Math::Matrix<3, Float> Matrix3;
 typedef Math::Vector3<Float> Vector3;

 Matrix4Test::Matrix4Test() {
-    addTests(&Matrix4Test::construct,
-             &Matrix4Test::constructIdentity,
-             &Matrix4Test::constructZero,
-             &Matrix4Test::constructConversion,
-             &Matrix4Test::constructCopy,
-
-             &Matrix4Test::translation,
-             &Matrix4Test::scaling,
-             &Matrix4Test::rotation,
-             &Matrix4Test::rotationX,
-             &Matrix4Test::rotationY,
-             &Matrix4Test::rotationZ,
-             &Matrix4Test::reflection,
-             &Matrix4Test::orthographicProjection,
-             &Matrix4Test::perspectiveProjection,
-             &Matrix4Test::perspectiveProjectionFov,
-             &Matrix4Test::fromParts,
-             &Matrix4Test::rotationScalingPart,
-             &Matrix4Test::rotationPart,
-             &Matrix4Test::vectorParts,
-             &Matrix4Test::invertedEuclidean,
-             &Matrix4Test::transform,
-
-             &Matrix4Test::debug,
-             &Matrix4Test::configuration);
+    addTests({&Matrix4Test::construct,
+              &Matrix4Test::constructIdentity,
+              &Matrix4Test::constructZero,
+              &Matrix4Test::constructConversion,
+              &Matrix4Test::constructCopy,
+
+              &Matrix4Test::translation,
+              &Matrix4Test::scaling,
+              &Matrix4Test::rotation,
+              &Matrix4Test::rotationX,
+              &Matrix4Test::rotationY,
+              &Matrix4Test::rotationZ,
+              &Matrix4Test::reflection,
+              &Matrix4Test::orthographicProjection,
+              &Matrix4Test::perspectiveProjection,
+              &Matrix4Test::perspectiveProjectionFov,
+              &Matrix4Test::fromParts,
+              &Matrix4Test::rotationScalingPart,
+              &Matrix4Test::rotationPart,
+              &Matrix4Test::vectorParts,
+              &Matrix4Test::invertedEuclidean,
+              &Matrix4Test::transform,
+
+              &Matrix4Test::debug,
+              &Matrix4Test::configuration});
 }

 void Matrix4Test::construct() {
--- a/src/Math/Test/MatrixTest.cpp
+++ b/src/Math/Test/MatrixTest.cpp
@ -48,18 +48,18 @@ typedef Vector<4, Int> Vector4i;
 typedef Vector<3, Float> Vector3;

 MatrixTest::MatrixTest() {
-    addTests(&MatrixTest::construct,
-             &MatrixTest::constructIdentity,
-             &MatrixTest::constructZero,
-             &MatrixTest::constructConversion,
-             &MatrixTest::constructCopy,
-
-             &MatrixTest::trace,
-             &MatrixTest::ij,
-             &MatrixTest::determinant,
-             &MatrixTest::inverted,
-             &MatrixTest::debug,
-             &MatrixTest::configuration);
+    addTests({&MatrixTest::construct,
+              &MatrixTest::constructIdentity,
+              &MatrixTest::constructZero,
+              &MatrixTest::constructConversion,
+              &MatrixTest::constructCopy,
+
+              &MatrixTest::trace,
+              &MatrixTest::ij,
+              &MatrixTest::determinant,
+              &MatrixTest::inverted,
+              &MatrixTest::debug,
+              &MatrixTest::configuration});
 }

 void MatrixTest::construct() {
--- a/src/Math/Test/QuaternionTest.cpp
+++ b/src/Math/Test/QuaternionTest.cpp
@ -66,36 +66,36 @@ typedef Math::Vector3<Float> Vector3;
 typedef Math::Vector4<Float> Vector4;

 QuaternionTest::QuaternionTest() {
-    addTests(&QuaternionTest::construct,
-             &QuaternionTest::constructDefault,
-             &QuaternionTest::constructFromVector,
-             &QuaternionTest::compare,
-
-             &QuaternionTest::constExpressions,
-
-             &QuaternionTest::addSubtract,
-             &QuaternionTest::negated,
-             &QuaternionTest::multiplyDivideScalar,
-             &QuaternionTest::multiply,
-
-             &QuaternionTest::dot,
-             &QuaternionTest::dotSelf,
-             &QuaternionTest::length,
-             &QuaternionTest::normalized,
-
-             &QuaternionTest::conjugated,
-             &QuaternionTest::inverted,
-             &QuaternionTest::invertedNormalized,
-
-             &QuaternionTest::rotation,
-             &QuaternionTest::angle,
-             &QuaternionTest::matrix,
-             &QuaternionTest::lerp,
-             &QuaternionTest::slerp,
-             &QuaternionTest::transformVector,
-             &QuaternionTest::transformVectorNormalized,
-
-             &QuaternionTest::debug);
+    addTests({&QuaternionTest::construct,
+              &QuaternionTest::constructDefault,
+              &QuaternionTest::constructFromVector,
+              &QuaternionTest::compare,
+
+              &QuaternionTest::constExpressions,
+
+              &QuaternionTest::addSubtract,
+              &QuaternionTest::negated,
+              &QuaternionTest::multiplyDivideScalar,
+              &QuaternionTest::multiply,
+
+              &QuaternionTest::dot,
+              &QuaternionTest::dotSelf,
+              &QuaternionTest::length,
+              &QuaternionTest::normalized,
+
+              &QuaternionTest::conjugated,
+              &QuaternionTest::inverted,
+              &QuaternionTest::invertedNormalized,
+
+              &QuaternionTest::rotation,
+              &QuaternionTest::angle,
+              &QuaternionTest::matrix,
+              &QuaternionTest::lerp,
+              &QuaternionTest::slerp,
+              &QuaternionTest::transformVector,
+              &QuaternionTest::transformVectorNormalized,
+
+              &QuaternionTest::debug});
 }

 void QuaternionTest::construct() {
--- a/src/Math/Test/RectangularMatrixTest.cpp
+++ b/src/Math/Test/RectangularMatrixTest.cpp
@ -64,33 +64,33 @@ typedef Vector<2, Float> Vector2;
 typedef Vector<2, Int> Vector2i;

 RectangularMatrixTest::RectangularMatrixTest() {
-    addTests(&RectangularMatrixTest::construct,
-             &RectangularMatrixTest::constructDefault,
-             &RectangularMatrixTest::constructConversion,
-             &RectangularMatrixTest::constructFromData,
-             &RectangularMatrixTest::constructFromDiagonal,
-             &RectangularMatrixTest::constructCopy,
-             &RectangularMatrixTest::data,
-
-             &RectangularMatrixTest::compare,
-
-             &RectangularMatrixTest::negative,
-             &RectangularMatrixTest::addSubtract,
-             &RectangularMatrixTest::multiplyDivide,
-             &RectangularMatrixTest::multiply,
-
-             &RectangularMatrixTest::transposed,
-             &RectangularMatrixTest::diagonal,
-
-             &RectangularMatrixTest::sum,
-             &RectangularMatrixTest::product,
-             &RectangularMatrixTest::min,
-             &RectangularMatrixTest::minAbs,
-             &RectangularMatrixTest::max,
-             &RectangularMatrixTest::maxAbs,
-
-             &RectangularMatrixTest::debug,
-             &RectangularMatrixTest::configuration);
+    addTests({&RectangularMatrixTest::construct,
+              &RectangularMatrixTest::constructDefault,
+              &RectangularMatrixTest::constructConversion,
+              &RectangularMatrixTest::constructFromData,
+              &RectangularMatrixTest::constructFromDiagonal,
+              &RectangularMatrixTest::constructCopy,
+              &RectangularMatrixTest::data,
+
+              &RectangularMatrixTest::compare,
+
+              &RectangularMatrixTest::negative,
+              &RectangularMatrixTest::addSubtract,
+              &RectangularMatrixTest::multiplyDivide,
+              &RectangularMatrixTest::multiply,
+
+              &RectangularMatrixTest::transposed,
+              &RectangularMatrixTest::diagonal,
+
+              &RectangularMatrixTest::sum,
+              &RectangularMatrixTest::product,
+              &RectangularMatrixTest::min,
+              &RectangularMatrixTest::minAbs,
+              &RectangularMatrixTest::max,
+              &RectangularMatrixTest::maxAbs,
+
+              &RectangularMatrixTest::debug,
+              &RectangularMatrixTest::configuration});
 }

 void RectangularMatrixTest::construct() {
--- a/src/Math/Test/SwizzleTest.cpp
+++ b/src/Math/Test/SwizzleTest.cpp
@ -32,10 +32,10 @@ class SwizzleTest: public Corrade::TestSuite::Tester {
 typedef Vector<4, Int> Vector4i;

 SwizzleTest::SwizzleTest() {
-    addTests(&SwizzleTest::components,
-             &SwizzleTest::constants,
-             &SwizzleTest::sizes,
-             &SwizzleTest::constExpressions);
+    addTests({&SwizzleTest::components,
+              &SwizzleTest::constants,
+              &SwizzleTest::sizes,
+              &SwizzleTest::constExpressions});
 }

 void SwizzleTest::components() {
--- a/src/Math/Test/UnitTest.cpp
+++ b/src/Math/Test/UnitTest.cpp
@ -34,14 +34,14 @@ class UnitTest: public Corrade::TestSuite::Tester {
 };

 UnitTest::UnitTest() {
-    addTests(&UnitTest::construct,
-             &UnitTest::constructDefault,
-             &UnitTest::constructConversion,
-             &UnitTest::compare,
-
-             &UnitTest::negated,
-             &UnitTest::addSubtract,
-             &UnitTest::multiplyDivide);
+    addTests({&UnitTest::construct,
+              &UnitTest::constructDefault,
+              &UnitTest::constructConversion,
+              &UnitTest::compare,
+
+              &UnitTest::negated,
+              &UnitTest::addSubtract,
+              &UnitTest::multiplyDivide});
 }

 template<class> struct Sec_;
--- a/src/Math/Test/Vector2Test.cpp
+++ b/src/Math/Test/Vector2Test.cpp
@ -43,17 +43,18 @@ typedef Math::Vector2<Float> Vector2;
 typedef Math::Vector2<Int> Vector2i;

 Vector2Test::Vector2Test() {
-    addTests(&Vector2Test::construct,
-             &Vector2Test::constructDefault,
-             &Vector2Test::constructOneValue,
-             &Vector2Test::constructConversion,
-             &Vector2Test::constructCopy,
-
-             &Vector2Test::access,
-             &Vector2Test::axes,
-             &Vector2Test::scales,
-             &Vector2Test::debug,
-             &Vector2Test::configuration);
+    addTests({&Vector2Test::construct,
+              &Vector2Test::constructDefault,
+              &Vector2Test::constructOneValue,
+              &Vector2Test::constructConversion,
+              &Vector2Test::constructCopy,
+
+              &Vector2Test::access,
+              &Vector2Test::axes,
+              &Vector2Test::scales,
+
+              &Vector2Test::debug,
+              &Vector2Test::configuration});
 }

 void Vector2Test::construct() {
--- a/src/Math/Test/Vector3Test.cpp
+++ b/src/Math/Test/Vector3Test.cpp
@ -47,21 +47,21 @@ typedef Math::Vector3<Int> Vector3i;
 typedef Math::Vector2<Float> Vector2;

 Vector3Test::Vector3Test() {
-    addTests(&Vector3Test::construct,
-             &Vector3Test::constructDefault,
-             &Vector3Test::constructOneValue,
-             &Vector3Test::constructParts,
-             &Vector3Test::constructConversion,
-             &Vector3Test::constructCopy,
-
-             &Vector3Test::access,
-             &Vector3Test::cross,
-             &Vector3Test::axes,
-             &Vector3Test::scales,
-             &Vector3Test::twoComponent,
-
-             &Vector3Test::debug,
-             &Vector3Test::configuration);
+    addTests({&Vector3Test::construct,
+              &Vector3Test::constructDefault,
+              &Vector3Test::constructOneValue,
+              &Vector3Test::constructParts,
+              &Vector3Test::constructConversion,
+              &Vector3Test::constructCopy,
+
+              &Vector3Test::access,
+              &Vector3Test::cross,
+              &Vector3Test::axes,
+              &Vector3Test::scales,
+              &Vector3Test::twoComponent,
+
+              &Vector3Test::debug,
+              &Vector3Test::configuration});
 }

 void Vector3Test::construct() {
--- a/src/Math/Test/Vector4Test.cpp
+++ b/src/Math/Test/Vector4Test.cpp
@ -46,19 +46,19 @@ typedef Math::Vector3<Float> Vector3;
 typedef Math::Vector2<Float> Vector2;

 Vector4Test::Vector4Test() {
-    addTests(&Vector4Test::construct,
-             &Vector4Test::constructDefault,
-             &Vector4Test::constructOneValue,
-             &Vector4Test::constructParts,
-             &Vector4Test::constructConversion,
-             &Vector4Test::constructCopy,
-
-             &Vector4Test::access,
-             &Vector4Test::threeComponent,
-             &Vector4Test::twoComponent,
-
-             &Vector4Test::debug,
-             &Vector4Test::configuration);
+    addTests({&Vector4Test::construct,
+              &Vector4Test::constructDefault,
+              &Vector4Test::constructOneValue,
+              &Vector4Test::constructParts,
+              &Vector4Test::constructConversion,
+              &Vector4Test::constructCopy,
+
+              &Vector4Test::access,
+              &Vector4Test::threeComponent,
+              &Vector4Test::twoComponent,
+
+              &Vector4Test::debug,
+              &Vector4Test::configuration});
 }

 void Vector4Test::construct() {
--- a/src/Math/Test/VectorTest.cpp
+++ b/src/Math/Test/VectorTest.cpp
@ -68,41 +68,41 @@ typedef Vector<4, Float> Vector4;
 typedef Vector<4, Int> Vector4i;

 VectorTest::VectorTest() {
-    addTests(&VectorTest::construct,
-             &VectorTest::constructFromData,
-             &VectorTest::constructDefault,
-             &VectorTest::constructOneValue,
-             &VectorTest::constructOneComponent,
-             &VectorTest::constructConversion,
-             &VectorTest::constructCopy,
-             &VectorTest::data,
-
-             &VectorTest::negative,
-             &VectorTest::addSubtract,
-             &VectorTest::multiplyDivide,
-             &VectorTest::multiplyDivideComponentWise,
-
-             &VectorTest::compare,
-             &VectorTest::compareComponentWise,
-
-             &VectorTest::dot,
-             &VectorTest::dotSelf,
-             &VectorTest::length,
-             &VectorTest::normalized,
-
-             &VectorTest::sum,
-             &VectorTest::product,
-             &VectorTest::min,
-             &VectorTest::minAbs,
-             &VectorTest::max,
-             &VectorTest::maxAbs,
-
-             &VectorTest::projected,
-             &VectorTest::projectedOntoNormalized,
-             &VectorTest::angle,
-
-             &VectorTest::debug,
-             &VectorTest::configuration);
+    addTests({&VectorTest::construct,
+              &VectorTest::constructFromData,
+              &VectorTest::constructDefault,
+              &VectorTest::constructOneValue,
+              &VectorTest::constructOneComponent,
+              &VectorTest::constructConversion,
+              &VectorTest::constructCopy,
+              &VectorTest::data,
+
+              &VectorTest::negative,
+              &VectorTest::addSubtract,
+              &VectorTest::multiplyDivide,
+              &VectorTest::multiplyDivideComponentWise,
+
+              &VectorTest::compare,
+              &VectorTest::compareComponentWise,
+
+              &VectorTest::dot,
+              &VectorTest::dotSelf,
+              &VectorTest::length,
+              &VectorTest::normalized,
+
+              &VectorTest::sum,
+              &VectorTest::product,
+              &VectorTest::min,
+              &VectorTest::minAbs,
+              &VectorTest::max,
+              &VectorTest::maxAbs,
+
+              &VectorTest::projected,
+              &VectorTest::projectedOntoNormalized,
+              &VectorTest::angle,
+
+              &VectorTest::debug,
+              &VectorTest::configuration});
 }

 void VectorTest::construct() {
--- a/src/MeshTools/Test/CleanTest.cpp
+++ b/src/MeshTools/Test/CleanTest.cpp
@ -24,27 +24,26 @@ class CleanTest: public Corrade::TestSuite::Tester {
        CleanTest();

        void cleanMesh();
+};
+
+class Vector1 {
+    public:
+        static const std::size_t Size = 1;
+        typedef Int Type;
+
+        Vector1(): data(0) {}
+        Vector1(Type i): data(i) {}
+        Type operator[](std::size_t) const { return data; }
+        Type& operator[](std::size_t) { return data; }
+        bool operator==(Vector1 i) const { return i.data == data; }
+        Vector1 operator-(Vector1 i) const { return data-i.data; }

    private:
-        class Vector1 {
-            public:
-                static const std::size_t Size = 1;
-                typedef Int Type;
-
-                Vector1(): data(0) {}
-                Vector1(Type i): data(i) {}
-                Type operator[](std::size_t) const { return data; }
-                Type& operator[](std::size_t) { return data; }
-                bool operator==(Vector1 i) const { return i.data == data; }
-                Vector1 operator-(Vector1 i) const { return data-i.data; }
-
-            private:
-                Type data;
-        };
+        Type data;
 };

 CleanTest::CleanTest() {
-    addTests(&CleanTest::cleanMesh);
+    addTests({&CleanTest::cleanMesh});
 }

 void CleanTest::cleanMesh() {
--- a/src/MeshTools/Test/CombineIndexedArraysTest.cpp
+++ b/src/MeshTools/Test/CombineIndexedArraysTest.cpp
@ -30,8 +30,8 @@ class CombineIndexedArraysTest: public Corrade::TestSuite::Tester {
 };

 CombineIndexedArraysTest::CombineIndexedArraysTest() {
-    addTests(&CombineIndexedArraysTest::wrongIndexCount,
-             &CombineIndexedArraysTest::combine);
+    addTests({&CombineIndexedArraysTest::wrongIndexCount,
+              &CombineIndexedArraysTest::combine});
 }

 void CombineIndexedArraysTest::wrongIndexCount() {
--- a/src/MeshTools/Test/CompressIndicesTest.cpp
+++ b/src/MeshTools/Test/CompressIndicesTest.cpp
@ -32,9 +32,9 @@ class CompressIndicesTest: public Corrade::TestSuite::Tester {
 };

 CompressIndicesTest::CompressIndicesTest() {
-    addTests(&CompressIndicesTest::compressChar,
-             &CompressIndicesTest::compressShort,
-             &CompressIndicesTest::compressInt);
+    addTests({&CompressIndicesTest::compressChar,
+              &CompressIndicesTest::compressShort,
+              &CompressIndicesTest::compressInt});
 }

 void CompressIndicesTest::compressChar() {
--- a/src/MeshTools/Test/FlipNormalsTest.cpp
+++ b/src/MeshTools/Test/FlipNormalsTest.cpp
@ -31,9 +31,9 @@ class FlipNormalsTest: public Corrade::TestSuite::Tester {
 };

 FlipNormalsTest::FlipNormalsTest() {
-    addTests(&FlipNormalsTest::wrongIndexCount,
-             &FlipNormalsTest::flipFaceWinding,
-             &FlipNormalsTest::flipNormals);
+    addTests({&FlipNormalsTest::wrongIndexCount,
+              &FlipNormalsTest::flipFaceWinding,
+              &FlipNormalsTest::flipNormals});
 }

 void FlipNormalsTest::wrongIndexCount() {
--- a/src/MeshTools/Test/GenerateFlatNormalsTest.cpp
+++ b/src/MeshTools/Test/GenerateFlatNormalsTest.cpp
@ -30,8 +30,8 @@ class GenerateFlatNormalsTest: public Corrade::TestSuite::Tester {
 };

 GenerateFlatNormalsTest::GenerateFlatNormalsTest() {
-    addTests(&GenerateFlatNormalsTest::wrongIndexCount,
-             &GenerateFlatNormalsTest::generate);
+    addTests({&GenerateFlatNormalsTest::wrongIndexCount,
+              &GenerateFlatNormalsTest::generate});
 }

 void GenerateFlatNormalsTest::wrongIndexCount() {
--- a/src/MeshTools/Test/InterleaveTest.cpp
+++ b/src/MeshTools/Test/InterleaveTest.cpp
@ -37,12 +37,12 @@ class InterleaveTest: public Corrade::TestSuite::Tester {
 };

 InterleaveTest::InterleaveTest() {
-    addTests(&InterleaveTest::attributeCount,
-             &InterleaveTest::attributeCountGaps,
-             &InterleaveTest::stride,
-             &InterleaveTest::strideGaps,
-             &InterleaveTest::write,
-             &InterleaveTest::writeGaps);
+    addTests({&InterleaveTest::attributeCount,
+              &InterleaveTest::attributeCountGaps,
+              &InterleaveTest::stride,
+              &InterleaveTest::strideGaps,
+              &InterleaveTest::write,
+              &InterleaveTest::writeGaps});
 }

 void InterleaveTest::attributeCount() {
--- a/src/MeshTools/Test/SubdivideTest.cpp
+++ b/src/MeshTools/Test/SubdivideTest.cpp
@ -49,8 +49,8 @@ class SubdivideTest: public Corrade::TestSuite::Tester {
 };

 SubdivideTest::SubdivideTest() {
-    addTests(&SubdivideTest::wrongIndexCount,
-             &SubdivideTest::subdivide);
+    addTests({&SubdivideTest::wrongIndexCount,
+              &SubdivideTest::subdivide});
 }

 void SubdivideTest::wrongIndexCount() {
--- a/src/MeshTools/Test/TipsifyTest.cpp
+++ b/src/MeshTools/Test/TipsifyTest.cpp
@ -70,8 +70,8 @@ TipsifyTest::TipsifyTest(): indices{

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

 void TipsifyTest::buildAdjacency() {
--- a/src/MeshTools/Test/TransformTest.cpp
+++ b/src/MeshTools/Test/TransformTest.cpp
@ -34,11 +34,11 @@ class TransformTest: public Corrade::TestSuite::Tester {
 };

 TransformTest::TransformTest() {
-    addTests(&TransformTest::transformVectors2D,
-             &TransformTest::transformVectors3D,
+    addTests({&TransformTest::transformVectors2D,
+              &TransformTest::transformVectors3D,

-             &TransformTest::transformPoints2D,
-             &TransformTest::transformPoints3D);
+              &TransformTest::transformPoints2D,
+              &TransformTest::transformPoints3D});
 }

 /* GCC < 4.7 doesn't like constexpr here, don't know why */
--- a/src/Physics/Test/AbstractShapeTest.cpp
+++ b/src/Physics/Test/AbstractShapeTest.cpp
@ -28,7 +28,7 @@ class AbstractShapeTest: public Corrade::TestSuite::Tester {
 };

 AbstractShapeTest::AbstractShapeTest() {
-    addTests(&AbstractShapeTest::debug);
+    addTests({&AbstractShapeTest::debug});
 }

 void AbstractShapeTest::debug() {
--- a/src/Physics/Test/AxisAlignedBoxTest.cpp
+++ b/src/Physics/Test/AxisAlignedBoxTest.cpp
@ -32,8 +32,8 @@ class AxisAlignedBoxTest: public Corrade::TestSuite::Tester, ShapeTestBase {
 };

 AxisAlignedBoxTest::AxisAlignedBoxTest() {
-    addTests(&AxisAlignedBoxTest::applyTransformation,
-             &AxisAlignedBoxTest::collisionPoint);
+    addTests({&AxisAlignedBoxTest::applyTransformation,
+              &AxisAlignedBoxTest::collisionPoint});
 }

 void AxisAlignedBoxTest::applyTransformation() {
--- a/src/Physics/Test/BoxTest.cpp
+++ b/src/Physics/Test/BoxTest.cpp
@ -28,7 +28,7 @@ class BoxTest: public Corrade::TestSuite::Tester {
 };

 BoxTest::BoxTest() {
-    addTests(&BoxTest::applyTransformation);
+    addTests({&BoxTest::applyTransformation});
 }

 void BoxTest::applyTransformation() {
--- a/src/Physics/Test/CapsuleTest.cpp
+++ b/src/Physics/Test/CapsuleTest.cpp
@ -31,8 +31,8 @@ class CapsuleTest: public Corrade::TestSuite::Tester, ShapeTestBase {
 };

 CapsuleTest::CapsuleTest() {
-    addTests(&CapsuleTest::applyTransformation,
-             &CapsuleTest::collisionPoint);
+    addTests({&CapsuleTest::applyTransformation,
+              &CapsuleTest::collisionPoint});
 }

 void CapsuleTest::applyTransformation() {
--- a/src/Physics/Test/LineTest.cpp
+++ b/src/Physics/Test/LineTest.cpp
@ -28,7 +28,7 @@ class LineTest: public Corrade::TestSuite::Tester {
 };

 LineTest::LineTest() {
-    addTests(&LineTest::applyTransformation);
+    addTests({&LineTest::applyTransformation});
 }

 void LineTest::applyTransformation() {
--- a/src/Physics/Test/ObjectShapeTest.cpp
+++ b/src/Physics/Test/ObjectShapeTest.cpp
@ -36,8 +36,8 @@ typedef SceneGraph::Scene<SceneGraph::MatrixTransformation3D<>> Scene3D;
 typedef SceneGraph::Object<SceneGraph::MatrixTransformation3D<>> Object3D;

 ObjectShapeTest::ObjectShapeTest() {
-    addTests(&ObjectShapeTest::clean,
-             &ObjectShapeTest::firstCollision);
+    addTests({&ObjectShapeTest::clean,
+              &ObjectShapeTest::firstCollision});
 }

 void ObjectShapeTest::clean() {
--- a/src/Physics/Test/PlaneTest.cpp
+++ b/src/Physics/Test/PlaneTest.cpp
@ -31,9 +31,9 @@ class PlaneTest: public Corrade::TestSuite::Tester, ShapeTestBase {
 };

 PlaneTest::PlaneTest() {
-    addTests(&PlaneTest::applyTransformation,
-             &PlaneTest::collisionLine,
-             &PlaneTest::collisionLineSegment);
+    addTests({&PlaneTest::applyTransformation,
+              &PlaneTest::collisionLine,
+              &PlaneTest::collisionLineSegment});
 }

 void PlaneTest::applyTransformation() {
--- a/src/Physics/Test/PointTest.cpp
+++ b/src/Physics/Test/PointTest.cpp
@ -28,7 +28,7 @@ class PointTest: public Corrade::TestSuite::Tester {
 };

 PointTest::PointTest() {
-    addTests(&PointTest::applyTransformation);
+    addTests({&PointTest::applyTransformation});
 }

 void PointTest::applyTransformation() {
--- a/src/Physics/Test/ShapeGroupTest.cpp
+++ b/src/Physics/Test/ShapeGroupTest.cpp
@ -31,8 +31,8 @@ class ShapeGroupTest: public Corrade::TestSuite::Tester {
 };

 ShapeGroupTest::ShapeGroupTest() {
-    addTests(&ShapeGroupTest::copy,
-             &ShapeGroupTest::reference);
+    addTests({&ShapeGroupTest::copy,
+              &ShapeGroupTest::reference});
 }

 void ShapeGroupTest::copy() {
--- a/src/Physics/Test/SphereTest.cpp
+++ b/src/Physics/Test/SphereTest.cpp
@ -33,11 +33,11 @@ class SphereTest: public Corrade::TestSuite::Tester, ShapeTestBase {
 };

 SphereTest::SphereTest() {
-    addTests(&SphereTest::applyTransformation,
-             &SphereTest::collisionPoint,
-             &SphereTest::collisionLine,
-             &SphereTest::collisionLineSegment,
-             &SphereTest::collisionSphere);
+    addTests({&SphereTest::applyTransformation,
+              &SphereTest::collisionPoint,
+              &SphereTest::collisionLine,
+              &SphereTest::collisionLineSegment,
+              &SphereTest::collisionSphere});
 }

 void SphereTest::applyTransformation() {
--- a/src/Primitives/Test/CapsuleTest.cpp
+++ b/src/Primitives/Test/CapsuleTest.cpp
@ -35,8 +35,8 @@ class CapsuleTest: public Corrade::TestSuite::Tester {
 };

 CapsuleTest::CapsuleTest() {
-    addTests(&CapsuleTest::withoutTextureCoords,
-             &CapsuleTest::withTextureCoords);
+    addTests({&CapsuleTest::withoutTextureCoords,
+              &CapsuleTest::withTextureCoords});
 }

 void CapsuleTest::withoutTextureCoords() {
--- a/src/Primitives/Test/CylinderTest.cpp
+++ b/src/Primitives/Test/CylinderTest.cpp
@ -32,8 +32,8 @@ class CylinderTest: public Corrade::TestSuite::Tester {
 };

 CylinderTest::CylinderTest() {
-    addTests(&CylinderTest::withoutAnything,
-             &CylinderTest::withTextureCoordsAndCaps);
+    addTests({&CylinderTest::withoutAnything,
+              &CylinderTest::withTextureCoordsAndCaps});
 }

 void CylinderTest::withoutAnything() {
--- a/src/Primitives/Test/UVSphereTest.cpp
+++ b/src/Primitives/Test/UVSphereTest.cpp
@ -32,8 +32,8 @@ class UVSphereTest: public Corrade::TestSuite::Tester {
 };

 UVSphereTest::UVSphereTest() {
-    addTests(&UVSphereTest::withoutTextureCoords,
-             &UVSphereTest::withTextureCoords);
+    addTests({&UVSphereTest::withoutTextureCoords,
+              &UVSphereTest::withTextureCoords});
 }

 void UVSphereTest::withoutTextureCoords() {
--- a/src/SceneGraph/Test/AnimableTest.cpp
+++ b/src/SceneGraph/Test/AnimableTest.cpp
@ -39,13 +39,14 @@ class AnimableTest: public Corrade::TestSuite::Tester {
 typedef SceneGraph::Object<SceneGraph::MatrixTransformation3D<>> Object3D;

 AnimableTest::AnimableTest() {
-    addTests(&AnimableTest::state,
-             &AnimableTest::step,
-             &AnimableTest::duration,
-             &AnimableTest::repeat,
-             &AnimableTest::stop,
-             &AnimableTest::pause,
-             &AnimableTest::debug);
+    addTests({&AnimableTest::state,
+              &AnimableTest::step,
+              &AnimableTest::duration,
+              &AnimableTest::repeat,
+              &AnimableTest::stop,
+              &AnimableTest::pause,
+
+              &AnimableTest::debug});
 }

 void AnimableTest::state() {
--- a/src/SceneGraph/Test/CameraTest.cpp
+++ b/src/SceneGraph/Test/CameraTest.cpp
@ -46,14 +46,14 @@ typedef SceneGraph::Camera2D<> Camera2D;
 typedef SceneGraph::Camera3D<> Camera3D;

 CameraTest::CameraTest() {
-    addTests(&CameraTest::fixAspectRatio,
-             &CameraTest::defaultProjection2D,
-             &CameraTest::defaultProjection3D,
-             &CameraTest::projectionSize2D,
-             &CameraTest::projectionSizeOrthographic,
-             &CameraTest::projectionSizePerspective,
-             &CameraTest::projectionSizeViewport,
-             &CameraTest::draw);
+    addTests({&CameraTest::fixAspectRatio,
+              &CameraTest::defaultProjection2D,
+              &CameraTest::defaultProjection3D,
+              &CameraTest::projectionSize2D,
+              &CameraTest::projectionSizeOrthographic,
+              &CameraTest::projectionSizePerspective,
+              &CameraTest::projectionSizeViewport,
+              &CameraTest::draw});
 }

 void CameraTest::fixAspectRatio() {
--- a/src/SceneGraph/Test/EuclideanMatrixTransformation2DTest.cpp
+++ b/src/SceneGraph/Test/EuclideanMatrixTransformation2DTest.cpp
@ -40,16 +40,16 @@ class EuclideanMatrixTransformation2DTest: public Corrade::TestSuite::Tester {
 };

 EuclideanMatrixTransformation2DTest::EuclideanMatrixTransformation2DTest() {
-    addTests(&EuclideanMatrixTransformation2DTest::fromMatrix,
-             &EuclideanMatrixTransformation2DTest::toMatrix,
-             &EuclideanMatrixTransformation2DTest::compose,
-             &EuclideanMatrixTransformation2DTest::inverted,
-
-             &EuclideanMatrixTransformation2DTest::setTransformation,
-             &EuclideanMatrixTransformation2DTest::translate,
-             &EuclideanMatrixTransformation2DTest::rotate,
-             &EuclideanMatrixTransformation2DTest::reflect,
-             &EuclideanMatrixTransformation2DTest::normalizeRotation);
+    addTests({&EuclideanMatrixTransformation2DTest::fromMatrix,
+              &EuclideanMatrixTransformation2DTest::toMatrix,
+              &EuclideanMatrixTransformation2DTest::compose,
+              &EuclideanMatrixTransformation2DTest::inverted,
+
+              &EuclideanMatrixTransformation2DTest::setTransformation,
+              &EuclideanMatrixTransformation2DTest::translate,
+              &EuclideanMatrixTransformation2DTest::rotate,
+              &EuclideanMatrixTransformation2DTest::reflect,
+              &EuclideanMatrixTransformation2DTest::normalizeRotation});
 }

 void EuclideanMatrixTransformation2DTest::fromMatrix() {
--- a/src/SceneGraph/Test/EuclideanMatrixTransformation3DTest.cpp
+++ b/src/SceneGraph/Test/EuclideanMatrixTransformation3DTest.cpp
@ -40,16 +40,16 @@ class EuclideanMatrixTransformation3DTest: public Corrade::TestSuite::Tester {
 };

 EuclideanMatrixTransformation3DTest::EuclideanMatrixTransformation3DTest() {
-    addTests(&EuclideanMatrixTransformation3DTest::fromMatrix,
-             &EuclideanMatrixTransformation3DTest::toMatrix,
-             &EuclideanMatrixTransformation3DTest::compose,
-             &EuclideanMatrixTransformation3DTest::inverted,
-
-             &EuclideanMatrixTransformation3DTest::setTransformation,
-             &EuclideanMatrixTransformation3DTest::translate,
-             &EuclideanMatrixTransformation3DTest::rotate,
-             &EuclideanMatrixTransformation3DTest::reflect,
-             &EuclideanMatrixTransformation3DTest::normalizeRotation);
+    addTests({&EuclideanMatrixTransformation3DTest::fromMatrix,
+              &EuclideanMatrixTransformation3DTest::toMatrix,
+              &EuclideanMatrixTransformation3DTest::compose,
+              &EuclideanMatrixTransformation3DTest::inverted,
+
+              &EuclideanMatrixTransformation3DTest::setTransformation,
+              &EuclideanMatrixTransformation3DTest::translate,
+              &EuclideanMatrixTransformation3DTest::rotate,
+              &EuclideanMatrixTransformation3DTest::reflect,
+              &EuclideanMatrixTransformation3DTest::normalizeRotation});
 }

 void EuclideanMatrixTransformation3DTest::fromMatrix() {
--- a/src/SceneGraph/Test/MatrixTransformation2DTest.cpp
+++ b/src/SceneGraph/Test/MatrixTransformation2DTest.cpp
@ -41,17 +41,17 @@ class MatrixTransformation2DTest: public Corrade::TestSuite::Tester {
 };

 MatrixTransformation2DTest::MatrixTransformation2DTest() {
-    addTests(&MatrixTransformation2DTest::fromMatrix,
-             &MatrixTransformation2DTest::toMatrix,
-             &MatrixTransformation2DTest::compose,
-             &MatrixTransformation2DTest::inverted,
-
-             &MatrixTransformation2DTest::setTransformation,
-             &MatrixTransformation2DTest::transform,
-             &MatrixTransformation2DTest::translate,
-             &MatrixTransformation2DTest::rotate,
-             &MatrixTransformation2DTest::scale,
-             &MatrixTransformation2DTest::reflect);
+    addTests({&MatrixTransformation2DTest::fromMatrix,
+              &MatrixTransformation2DTest::toMatrix,
+              &MatrixTransformation2DTest::compose,
+              &MatrixTransformation2DTest::inverted,
+
+              &MatrixTransformation2DTest::setTransformation,
+              &MatrixTransformation2DTest::transform,
+              &MatrixTransformation2DTest::translate,
+              &MatrixTransformation2DTest::rotate,
+              &MatrixTransformation2DTest::scale,
+              &MatrixTransformation2DTest::reflect});
 }

 void MatrixTransformation2DTest::fromMatrix() {
--- a/src/SceneGraph/Test/MatrixTransformation3DTest.cpp
+++ b/src/SceneGraph/Test/MatrixTransformation3DTest.cpp
@ -41,17 +41,17 @@ class MatrixTransformation3DTest: public Corrade::TestSuite::Tester {
 };

 MatrixTransformation3DTest::MatrixTransformation3DTest() {
-    addTests(&MatrixTransformation3DTest::fromMatrix,
-             &MatrixTransformation3DTest::toMatrix,
-             &MatrixTransformation3DTest::compose,
-             &MatrixTransformation3DTest::inverted,
-
-             &MatrixTransformation3DTest::setTransformation,
-             &MatrixTransformation3DTest::transform,
-             &MatrixTransformation3DTest::translate,
-             &MatrixTransformation3DTest::rotate,
-             &MatrixTransformation3DTest::scale,
-             &MatrixTransformation3DTest::reflect);
+    addTests({&MatrixTransformation3DTest::fromMatrix,
+              &MatrixTransformation3DTest::toMatrix,
+              &MatrixTransformation3DTest::compose,
+              &MatrixTransformation3DTest::inverted,
+
+              &MatrixTransformation3DTest::setTransformation,
+              &MatrixTransformation3DTest::transform,
+              &MatrixTransformation3DTest::translate,
+              &MatrixTransformation3DTest::rotate,
+              &MatrixTransformation3DTest::scale,
+              &MatrixTransformation3DTest::reflect});
 }

 void MatrixTransformation3DTest::fromMatrix() {
--- a/src/SceneGraph/Test/ObjectTest.cpp
+++ b/src/SceneGraph/Test/ObjectTest.cpp
@ -54,15 +54,15 @@ class CachingObject: public Object3D, AbstractFeature<3> {
 };

 ObjectTest::ObjectTest() {
-    addTests(&ObjectTest::parenting,
-             &ObjectTest::scene,
-             &ObjectTest::absoluteTransformation,
-             &ObjectTest::transformations,
-             &ObjectTest::transformationsRelative,
-             &ObjectTest::transformationsOrphan,
-             &ObjectTest::transformationsDuplicate,
-             &ObjectTest::setClean,
-             &ObjectTest::bulkSetClean);
+    addTests({&ObjectTest::parenting,
+              &ObjectTest::scene,
+              &ObjectTest::absoluteTransformation,
+              &ObjectTest::transformations,
+              &ObjectTest::transformationsRelative,
+              &ObjectTest::transformationsOrphan,
+              &ObjectTest::transformationsDuplicate,
+              &ObjectTest::setClean,
+              &ObjectTest::bulkSetClean});
 }

 void ObjectTest::parenting() {
--- a/src/SceneGraph/Test/SceneTest.cpp
+++ b/src/SceneGraph/Test/SceneTest.cpp
@ -32,8 +32,8 @@ typedef SceneGraph::Scene<SceneGraph::MatrixTransformation3D<Float>> Scene3D;
 typedef SceneGraph::Object<SceneGraph::MatrixTransformation3D<Float>> Object3D;

 SceneTest::SceneTest() {
-    addTests(&SceneTest::transformation,
-             &SceneTest::parent);
+    addTests({&SceneTest::transformation,
+              &SceneTest::parent});
 }

 void SceneTest::transformation() {
--- a/src/Test/AbstractImageTest.cpp
+++ b/src/Test/AbstractImageTest.cpp
@ -29,8 +29,8 @@ class AbstractImageTest: public Corrade::TestSuite::Tester {
 };

 AbstractImageTest::AbstractImageTest() {
-    addTests(&AbstractImageTest::debugFormat,
-             &AbstractImageTest::debugType);
+    addTests({&AbstractImageTest::debugFormat,
+              &AbstractImageTest::debugType});
 }

 void AbstractImageTest::debugFormat() {
--- a/src/Test/AbstractShaderProgramTest.cpp
+++ b/src/Test/AbstractShaderProgramTest.cpp
@ -40,20 +40,20 @@ class AbstractShaderProgramTest: public Corrade::TestSuite::Tester {
 };

 AbstractShaderProgramTest::AbstractShaderProgramTest() {
-    addTests(&AbstractShaderProgramTest::attributeScalar,
-             &AbstractShaderProgramTest::attributeScalarInt,
-             &AbstractShaderProgramTest::attributeScalarUnsignedInt,
-             &AbstractShaderProgramTest::attributeScalarDouble,
-
-             &AbstractShaderProgramTest::attributeVector,
-             &AbstractShaderProgramTest::attributeVectorInt,
-             &AbstractShaderProgramTest::attributeVectorUnsignedInt,
-             &AbstractShaderProgramTest::attributeVectorDouble,
-             &AbstractShaderProgramTest::attributeVector4,
-             &AbstractShaderProgramTest::attributeVectorBGRA,
-
-             &AbstractShaderProgramTest::attributeMatrix,
-             &AbstractShaderProgramTest::attributeMatrixDouble);
+    addTests({&AbstractShaderProgramTest::attributeScalar,
+              &AbstractShaderProgramTest::attributeScalarInt,
+              &AbstractShaderProgramTest::attributeScalarUnsignedInt,
+              &AbstractShaderProgramTest::attributeScalarDouble,
+
+              &AbstractShaderProgramTest::attributeVector,
+              &AbstractShaderProgramTest::attributeVectorInt,
+              &AbstractShaderProgramTest::attributeVectorUnsignedInt,
+              &AbstractShaderProgramTest::attributeVectorDouble,
+              &AbstractShaderProgramTest::attributeVector4,
+              &AbstractShaderProgramTest::attributeVectorBGRA,
+
+              &AbstractShaderProgramTest::attributeMatrix,
+              &AbstractShaderProgramTest::attributeMatrixDouble});
 }

 void AbstractShaderProgramTest::attributeScalar() {
--- a/src/Test/ArrayTest.cpp
+++ b/src/Test/ArrayTest.cpp
@ -34,10 +34,10 @@ typedef Magnum::Array2D<int> Array2D;
 typedef Magnum::Array3D<int> Array3D;

 ArrayTest::ArrayTest() {
-    addTests(&ArrayTest::construct,
-             &ArrayTest::constexprConstruct,
-             &ArrayTest::equality,
-             &ArrayTest::access);
+    addTests({&ArrayTest::construct,
+              &ArrayTest::constexprConstruct,
+              &ArrayTest::equality,
+              &ArrayTest::access});
 }

 void ArrayTest::construct() {
--- a/src/Test/ColorTest.cpp
+++ b/src/Test/ColorTest.cpp
@ -49,22 +49,22 @@ typedef Magnum::Color3<Float> Color3f;
 typedef Magnum::Color4<Float> Color4f;

 ColorTest::ColorTest() {
-    addTests(&ColorTest::access,
+    addTests({&ColorTest::access,

-             &ColorTest::fromHue,
-             &ColorTest::fromSaturation,
-             &ColorTest::fromValue,
+              &ColorTest::fromHue,
+              &ColorTest::fromSaturation,
+              &ColorTest::fromValue,

-             &ColorTest::hue,
-             &ColorTest::saturation,
-             &ColorTest::value,
+              &ColorTest::hue,
+              &ColorTest::saturation,
+              &ColorTest::value,

-             &ColorTest::hsv,
-             &ColorTest::hsvOverflow,
-             &ColorTest::hsvAlpha,
+              &ColorTest::hsv,
+              &ColorTest::hsvOverflow,
+              &ColorTest::hsvAlpha,

-             &ColorTest::debug,
-             &ColorTest::configuration);
+              &ColorTest::debug,
+              &ColorTest::configuration});
 }

 void ColorTest::access() {
--- a/src/Test/MeshTest.cpp
+++ b/src/Test/MeshTest.cpp
@ -32,10 +32,10 @@ class MeshTest: public Corrade::TestSuite::Tester {
 };

 MeshTest::MeshTest() {
-    addTests(&MeshTest::debugPrimitive,
-             &MeshTest::debugIndexType,
-             &MeshTest::configurationPrimitive,
-             &MeshTest::configurationIndexType);
+    addTests({&MeshTest::debugPrimitive,
+              &MeshTest::debugIndexType,
+              &MeshTest::configurationPrimitive,
+              &MeshTest::configurationIndexType});
 }

 void MeshTest::debugPrimitive() {
--- a/src/Test/ResourceManagerTest.cpp
+++ b/src/Test/ResourceManagerTest.cpp
@ -62,14 +62,14 @@ class IntResourceLoader: public AbstractResourceLoader<Int> {
 size_t Data::count = 0;

 ResourceManagerTest::ResourceManagerTest() {
-    addTests(&ResourceManagerTest::state,
-             &ResourceManagerTest::stateFallback,
-             &ResourceManagerTest::stateDisallowed,
-             &ResourceManagerTest::basic,
-             &ResourceManagerTest::residentPolicy,
-             &ResourceManagerTest::referenceCountedPolicy,
-             &ResourceManagerTest::manualPolicy,
-             &ResourceManagerTest::loader);
+    addTests({&ResourceManagerTest::state,
+              &ResourceManagerTest::stateFallback,
+              &ResourceManagerTest::stateDisallowed,
+              &ResourceManagerTest::basic,
+              &ResourceManagerTest::residentPolicy,
+              &ResourceManagerTest::referenceCountedPolicy,
+              &ResourceManagerTest::manualPolicy,
+              &ResourceManagerTest::loader});
 }

 void ResourceManagerTest::state() {
--- a/src/Test/SwizzleTest.cpp
+++ b/src/Test/SwizzleTest.cpp
@ -29,9 +29,9 @@ class SwizzleTest: public Corrade::TestSuite::Tester {
 };

 SwizzleTest::SwizzleTest() {
-    addTests(&SwizzleTest::rgba,
-             &SwizzleTest::type,
-             &SwizzleTest::defaultType);
+    addTests({&SwizzleTest::rgba,
+              &SwizzleTest::type,
+              &SwizzleTest::defaultType});
 }

 void SwizzleTest::rgba() {
--- a/src/TextureTools/Test/AtlasTest.cpp
+++ b/src/TextureTools/Test/AtlasTest.cpp
@ -32,10 +32,10 @@ class AtlasTest: public Corrade::TestSuite::Tester {
 };

 AtlasTest::AtlasTest() {
-    addTests(&AtlasTest::create,
-             &AtlasTest::createPadding,
-             &AtlasTest::createEmpty,
-             &AtlasTest::createTooSmall);
+    addTests({&AtlasTest::create,
+              &AtlasTest::createPadding,
+              &AtlasTest::createEmpty,
+              &AtlasTest::createTooSmall});
 }

 void AtlasTest::create() {
--- a/src/Trade/AbstractImporter.h
+++ b/src/Trade/AbstractImporter.h
@ -20,7 +20,7 @@
 */

 #include <Containers/EnumSet.h>
-#include <PluginManager/Plugin.h>
+#include <PluginManager/AbstractPlugin.h>

 #include "Trade/Trade.h"

@ -44,7 +44,7 @@ be done in data parsing functions, because the user might want to import only
 some data. This is obviously not the case for single-data formats like images,
 as the file contains all data user wants to import.
 */
-class MAGNUM_EXPORT AbstractImporter: public Corrade::PluginManager::Plugin {
+class MAGNUM_EXPORT AbstractImporter: public Corrade::PluginManager::AbstractPlugin {
    PLUGIN_INTERFACE("cz.mosra.magnum.Trade.AbstractImporter/0.2")

    public:
@ -61,9 +61,11 @@ class MAGNUM_EXPORT AbstractImporter: public Corrade::PluginManager::Plugin {
        /** @brief Set of features supported by this importer */
        typedef Corrade::Containers::EnumSet<Feature, int> Features;

-        /** @brief Constructor */
-        /* GCC 4.6 can't handle {} as default parameter */
-        inline explicit AbstractImporter(Corrade::PluginManager::AbstractPluginManager* manager = nullptr, const std::string& plugin = std::string()): Plugin(manager, plugin) {}
+        /** @brief Default constructor */
+        inline explicit AbstractImporter() = default;
+
+        /** @brief Plugin manager constructor */
+        inline explicit AbstractImporter(Corrade::PluginManager::AbstractPluginManager* manager, std::string plugin): AbstractPlugin(manager, std::move(plugin)) {}

        /** @brief Features supported by this importer */
        virtual Features features() const = 0;
--- a/src/Trade/Test/ObjectData2DTest.cpp
+++ b/src/Trade/Test/ObjectData2DTest.cpp
@ -28,7 +28,7 @@ class ObjectData2DTest: public Corrade::TestSuite::Tester {
 };

 ObjectData2DTest::ObjectData2DTest() {
-    addTests(&ObjectData2DTest::debug);
+    addTests({&ObjectData2DTest::debug});
 }

 void ObjectData2DTest::debug() {
--- a/src/Trade/Test/ObjectData3DTest.cpp
+++ b/src/Trade/Test/ObjectData3DTest.cpp
@ -28,7 +28,7 @@ class ObjectData3DTest: public Corrade::TestSuite::Tester {
 };

 ObjectData3DTest::ObjectData3DTest() {
-    addTests(&ObjectData3DTest::debug);
+    addTests({&ObjectData3DTest::debug});
 }

 void ObjectData3DTest::debug() {