Adapted to Corrade changes.

Allowing to instantiate Trade::AbstractImporter subclasses directly
without plugin manager.

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,
+    addTests({&GaussJordanTest::singular,
-             &GaussJordanTest::invert);
+              &GaussJordanTest::invert});
 }
 
 void GaussJordanTest::singular() {

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,
+    addTests({&GramSchmidtTest::orthogonalize,
-             &GramSchmidtTest::orthonormalize);
+              &GramSchmidtTest::orthonormalize});
 }
 
 void GramSchmidtTest::orthogonalize() {

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,
+    addTests({&SvdTest::testDouble,
-             &SvdTest::testFloat);
+              &SvdTest::testFloat});
 }
 
 void SvdTest::testDouble() {

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,
+    addTests({&DistanceTest::linePoint2D,
               &DistanceTest::linePoint3D,
               &DistanceTest::lineSegmentPoint2D,
-             &DistanceTest::lineSegmentPoint3D);
+              &DistanceTest::lineSegmentPoint3D});
 }
 
 void DistanceTest::linePoint2D() {

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() {

src/Math/Geometry/Test/RectangleTest.cpp

@@ -37,11 +37,12 @@ typedef Geometry::Rectangle<Int> Rectanglei;
 typedef Vector2<Int> Vector2i;
 
 RectangleTest::RectangleTest() {
-    addTests(&RectangleTest::access,
+    addTests({&RectangleTest::access,
               &RectangleTest::compare,
               &RectangleTest::construct,
               &RectangleTest::size,
-             &RectangleTest::debug);
+
+              &RectangleTest::debug});
 }
 
 void RectangleTest::access() {

src/Math/Test/AngleTest.cpp

@@ -38,12 +38,12 @@ typedef Math::Deg<Double> Degd;
 typedef Math::Rad<Double> Radd;
 
 AngleTest::AngleTest() {
-    addTests(&AngleTest::construct,
+    addTests({&AngleTest::construct,
               &AngleTest::literals,
               &AngleTest::conversion,
 
               &AngleTest::debugDeg,
-             &AngleTest::debugRad);
+              &AngleTest::debugRad});
 }
 
 void AngleTest::construct() {

src/Math/Test/BoolVectorTest.cpp

@@ -50,7 +50,7 @@ static_assert(BoolVector<17>::DataSize == 3, "Improper DataSize");
 typedef Math::BoolVector<19> BoolVector19;
 
 BoolVectorTest::BoolVectorTest() {
-    addTests(&BoolVectorTest::constructDefault,
+    addTests({&BoolVectorTest::constructDefault,
               &BoolVectorTest::constructOneValue,
               &BoolVectorTest::constructOneElement,
               &BoolVectorTest::data,
@@ -66,7 +66,7 @@ BoolVectorTest::BoolVectorTest() {
               &BoolVectorTest::bitInverse,
               &BoolVectorTest::bitAndOrXor,
 
-             &BoolVectorTest::debug);
+              &BoolVectorTest::debug});
 }
 
 void BoolVectorTest::constructDefault() {

src/Math/Test/ComplexTest.cpp

@@ -55,7 +55,7 @@ class ComplexTest: public Corrade::TestSuite::Tester {
 };
 
 ComplexTest::ComplexTest() {
-    addTests(&ComplexTest::construct,
+    addTests({&ComplexTest::construct,
               &ComplexTest::constructDefault,
               &ComplexTest::constructFromVector,
               &ComplexTest::compare,
@@ -81,7 +81,7 @@ ComplexTest::ComplexTest() {
               &ComplexTest::matrix,
               &ComplexTest::transformVector,
 
-             &ComplexTest::debug);
+              &ComplexTest::debug});
 }
 
 typedef Math::Deg<Float> Deg;

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() {

src/Math/Test/DualComplexTest.cpp

@@ -61,7 +61,7 @@ typedef Math::Matrix3<Float> Matrix3;
 typedef Math::Vector2<Float> Vector2;
 
 DualComplexTest::DualComplexTest() {
-    addTests(&DualComplexTest::construct,
+    addTests({&DualComplexTest::construct,
               &DualComplexTest::constructDefault,
               &DualComplexTest::constructFromVector,
 
@@ -85,7 +85,7 @@ DualComplexTest::DualComplexTest() {
               &DualComplexTest::matrix,
               &DualComplexTest::transformPoint,
 
-             &DualComplexTest::debug);
+              &DualComplexTest::debug});
 }
 
 void DualComplexTest::construct() {

src/Math/Test/DualQuaternionTest.cpp

@@ -59,7 +59,7 @@ typedef Math::Quaternion<Float> Quaternion;
 typedef Math::Vector3<Float> Vector3;
 
 DualQuaternionTest::DualQuaternionTest() {
-    addTests(&DualQuaternionTest::construct,
+    addTests({&DualQuaternionTest::construct,
               &DualQuaternionTest::constructDefault,
               &DualQuaternionTest::constructFromVector,
 
@@ -82,7 +82,7 @@ DualQuaternionTest::DualQuaternionTest() {
               &DualQuaternionTest::transformPoint,
               &DualQuaternionTest::transformPointNormalized,
 
-             &DualQuaternionTest::debug);
+              &DualQuaternionTest::debug});
 }
 
 void DualQuaternionTest::construct() {

src/Math/Test/DualTest.cpp

@@ -43,7 +43,7 @@ class DualTest: public Corrade::TestSuite::Tester {
 typedef Math::Dual<Float> Dual;
 
 DualTest::DualTest() {
-    addTests(&DualTest::construct,
+    addTests({&DualTest::construct,
               &DualTest::constructDefault,
               &DualTest::compare,
 
@@ -56,7 +56,7 @@ DualTest::DualTest() {
               &DualTest::conjugated,
               &DualTest::sqrt,
 
-             &DualTest::debug);
+              &DualTest::debug});
 }
 
 void DualTest::construct() {

src/Math/Test/FunctionsTest.cpp

@@ -54,7 +54,7 @@ typedef Math::Vector3<Byte> Vector3b;
 typedef Math::Vector3<Int> Vector3i;
 
 FunctionsTest::FunctionsTest() {
-    addTests(&FunctionsTest::min,
+    addTests({&FunctionsTest::min,
               &FunctionsTest::max,
               &FunctionsTest::abs,
               &FunctionsTest::sqrt,
@@ -72,7 +72,7 @@ FunctionsTest::FunctionsTest() {
               &FunctionsTest::pow,
               &FunctionsTest::log,
               &FunctionsTest::log2,
-             &FunctionsTest::trigonometric);
+              &FunctionsTest::trigonometric});
 }
 
 void FunctionsTest::min() {

src/Math/Test/MathTypeTraitsTest.cpp

@@ -33,8 +33,8 @@ class MathTypeTraitsTest: public Corrade::TestSuite::Tester {
 };
 
 MathTypeTraitsTest::MathTypeTraitsTest() {
-    addTests(&MathTypeTraitsTest::equalsIntegral,
+    addTests({&MathTypeTraitsTest::equalsIntegral,
-             &MathTypeTraitsTest::equalsFloatingPoint);
+              &MathTypeTraitsTest::equalsFloatingPoint});
 }
 
 void MathTypeTraitsTest::equalsIntegral() {

src/Math/Test/Matrix3Test.cpp

@@ -54,7 +54,7 @@ typedef Math::Matrix<2, Float> Matrix2;
 typedef Math::Vector2<Float> Vector2;
 
 Matrix3Test::Matrix3Test() {
-    addTests(&Matrix3Test::construct,
+    addTests({&Matrix3Test::construct,
               &Matrix3Test::constructIdentity,
               &Matrix3Test::constructZero,
               &Matrix3Test::constructConversion,
@@ -73,7 +73,7 @@ Matrix3Test::Matrix3Test() {
               &Matrix3Test::transform,
 
               &Matrix3Test::debug,
-             &Matrix3Test::configuration);
+              &Matrix3Test::configuration});
 }
 
 void Matrix3Test::construct() {

src/Math/Test/Matrix4Test.cpp

@@ -60,7 +60,7 @@ typedef Math::Matrix<3, Float> Matrix3;
 typedef Math::Vector3<Float> Vector3;
 
 Matrix4Test::Matrix4Test() {
-    addTests(&Matrix4Test::construct,
+    addTests({&Matrix4Test::construct,
               &Matrix4Test::constructIdentity,
               &Matrix4Test::constructZero,
               &Matrix4Test::constructConversion,
@@ -84,7 +84,7 @@ Matrix4Test::Matrix4Test() {
               &Matrix4Test::transform,
 
               &Matrix4Test::debug,
-             &Matrix4Test::configuration);
+              &Matrix4Test::configuration});
 }
 
 void Matrix4Test::construct() {

src/Math/Test/MatrixTest.cpp

@@ -48,7 +48,7 @@ typedef Vector<4, Int> Vector4i;
 typedef Vector<3, Float> Vector3;
 
 MatrixTest::MatrixTest() {
-    addTests(&MatrixTest::construct,
+    addTests({&MatrixTest::construct,
               &MatrixTest::constructIdentity,
               &MatrixTest::constructZero,
               &MatrixTest::constructConversion,
@@ -59,7 +59,7 @@ MatrixTest::MatrixTest() {
               &MatrixTest::determinant,
               &MatrixTest::inverted,
               &MatrixTest::debug,
-             &MatrixTest::configuration);
+              &MatrixTest::configuration});
 }
 
 void MatrixTest::construct() {

src/Math/Test/QuaternionTest.cpp

@@ -66,7 +66,7 @@ typedef Math::Vector3<Float> Vector3;
 typedef Math::Vector4<Float> Vector4;
 
 QuaternionTest::QuaternionTest() {
-    addTests(&QuaternionTest::construct,
+    addTests({&QuaternionTest::construct,
               &QuaternionTest::constructDefault,
               &QuaternionTest::constructFromVector,
               &QuaternionTest::compare,
@@ -95,7 +95,7 @@ QuaternionTest::QuaternionTest() {
               &QuaternionTest::transformVector,
               &QuaternionTest::transformVectorNormalized,
 
-             &QuaternionTest::debug);
+              &QuaternionTest::debug});
 }
 
 void QuaternionTest::construct() {

src/Math/Test/RectangularMatrixTest.cpp

@@ -64,7 +64,7 @@ typedef Vector<2, Float> Vector2;
 typedef Vector<2, Int> Vector2i;
 
 RectangularMatrixTest::RectangularMatrixTest() {
-    addTests(&RectangularMatrixTest::construct,
+    addTests({&RectangularMatrixTest::construct,
               &RectangularMatrixTest::constructDefault,
               &RectangularMatrixTest::constructConversion,
               &RectangularMatrixTest::constructFromData,
@@ -90,7 +90,7 @@ RectangularMatrixTest::RectangularMatrixTest() {
               &RectangularMatrixTest::maxAbs,
 
               &RectangularMatrixTest::debug,
-             &RectangularMatrixTest::configuration);
+              &RectangularMatrixTest::configuration});
 }
 
 void RectangularMatrixTest::construct() {

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,
+    addTests({&SwizzleTest::components,
               &SwizzleTest::constants,
               &SwizzleTest::sizes,
-             &SwizzleTest::constExpressions);
+              &SwizzleTest::constExpressions});
 }
 
 void SwizzleTest::components() {

src/Math/Test/UnitTest.cpp

@@ -34,14 +34,14 @@ class UnitTest: public Corrade::TestSuite::Tester {
 };
 
 UnitTest::UnitTest() {
-    addTests(&UnitTest::construct,
+    addTests({&UnitTest::construct,
               &UnitTest::constructDefault,
               &UnitTest::constructConversion,
               &UnitTest::compare,
 
               &UnitTest::negated,
               &UnitTest::addSubtract,
-             &UnitTest::multiplyDivide);
+              &UnitTest::multiplyDivide});
 }
 
 template<class> struct Sec_;

src/Math/Test/Vector2Test.cpp

@@ -43,7 +43,7 @@ typedef Math::Vector2<Float> Vector2;
 typedef Math::Vector2<Int> Vector2i;
 
 Vector2Test::Vector2Test() {
-    addTests(&Vector2Test::construct,
+    addTests({&Vector2Test::construct,
               &Vector2Test::constructDefault,
               &Vector2Test::constructOneValue,
               &Vector2Test::constructConversion,
@@ -52,8 +52,9 @@ Vector2Test::Vector2Test() {
               &Vector2Test::access,
               &Vector2Test::axes,
               &Vector2Test::scales,
+
               &Vector2Test::debug,
-             &Vector2Test::configuration);
+              &Vector2Test::configuration});
 }
 
 void Vector2Test::construct() {

src/Math/Test/Vector3Test.cpp

@@ -47,7 +47,7 @@ typedef Math::Vector3<Int> Vector3i;
 typedef Math::Vector2<Float> Vector2;
 
 Vector3Test::Vector3Test() {
-    addTests(&Vector3Test::construct,
+    addTests({&Vector3Test::construct,
               &Vector3Test::constructDefault,
               &Vector3Test::constructOneValue,
               &Vector3Test::constructParts,
@@ -61,7 +61,7 @@ Vector3Test::Vector3Test() {
               &Vector3Test::twoComponent,
 
               &Vector3Test::debug,
-             &Vector3Test::configuration);
+              &Vector3Test::configuration});
 }
 
 void Vector3Test::construct() {

src/Math/Test/Vector4Test.cpp

@@ -46,7 +46,7 @@ typedef Math::Vector3<Float> Vector3;
 typedef Math::Vector2<Float> Vector2;
 
 Vector4Test::Vector4Test() {
-    addTests(&Vector4Test::construct,
+    addTests({&Vector4Test::construct,
               &Vector4Test::constructDefault,
               &Vector4Test::constructOneValue,
               &Vector4Test::constructParts,
@@ -58,7 +58,7 @@ Vector4Test::Vector4Test() {
               &Vector4Test::twoComponent,
 
               &Vector4Test::debug,
-             &Vector4Test::configuration);
+              &Vector4Test::configuration});
 }
 
 void Vector4Test::construct() {

src/Math/Test/VectorTest.cpp

@@ -68,7 +68,7 @@ typedef Vector<4, Float> Vector4;
 typedef Vector<4, Int> Vector4i;
 
 VectorTest::VectorTest() {
-    addTests(&VectorTest::construct,
+    addTests({&VectorTest::construct,
               &VectorTest::constructFromData,
               &VectorTest::constructDefault,
               &VectorTest::constructOneValue,
@@ -102,7 +102,7 @@ VectorTest::VectorTest() {
               &VectorTest::angle,
 
               &VectorTest::debug,
-             &VectorTest::configuration);
+              &VectorTest::configuration});
 }
 
 void VectorTest::construct() {

src/MeshTools/Test/CleanTest.cpp

@@ -24,9 +24,9 @@ class CleanTest: public Corrade::TestSuite::Tester {
         CleanTest();
 
         void cleanMesh();
+};
 
-    private:
+class Vector1 {
-        class Vector1 {
     public:
         static const std::size_t Size = 1;
         typedef Int Type;
@@ -40,11 +40,10 @@ class CleanTest: public Corrade::TestSuite::Tester {
 
     private:
         Type data;
-        };
 };
 
 CleanTest::CleanTest() {
-    addTests(&CleanTest::cleanMesh);
+    addTests({&CleanTest::cleanMesh});
 }
 
 void CleanTest::cleanMesh() {

src/MeshTools/Test/CombineIndexedArraysTest.cpp

@@ -30,8 +30,8 @@ class CombineIndexedArraysTest: public Corrade::TestSuite::Tester {
 };
 
 CombineIndexedArraysTest::CombineIndexedArraysTest() {
-    addTests(&CombineIndexedArraysTest::wrongIndexCount,
+    addTests({&CombineIndexedArraysTest::wrongIndexCount,
-             &CombineIndexedArraysTest::combine);
+              &CombineIndexedArraysTest::combine});
 }
 
 void CombineIndexedArraysTest::wrongIndexCount() {

src/MeshTools/Test/CompressIndicesTest.cpp

@@ -32,9 +32,9 @@ class CompressIndicesTest: public Corrade::TestSuite::Tester {
 };
 
 CompressIndicesTest::CompressIndicesTest() {
-    addTests(&CompressIndicesTest::compressChar,
+    addTests({&CompressIndicesTest::compressChar,
               &CompressIndicesTest::compressShort,
-             &CompressIndicesTest::compressInt);
+              &CompressIndicesTest::compressInt});
 }
 
 void CompressIndicesTest::compressChar() {

src/MeshTools/Test/FlipNormalsTest.cpp

@@ -31,9 +31,9 @@ class FlipNormalsTest: public Corrade::TestSuite::Tester {
 };
 
 FlipNormalsTest::FlipNormalsTest() {
-    addTests(&FlipNormalsTest::wrongIndexCount,
+    addTests({&FlipNormalsTest::wrongIndexCount,
               &FlipNormalsTest::flipFaceWinding,
-             &FlipNormalsTest::flipNormals);
+              &FlipNormalsTest::flipNormals});
 }
 
 void FlipNormalsTest::wrongIndexCount() {

src/MeshTools/Test/GenerateFlatNormalsTest.cpp

@@ -30,8 +30,8 @@ class GenerateFlatNormalsTest: public Corrade::TestSuite::Tester {
 };
 
 GenerateFlatNormalsTest::GenerateFlatNormalsTest() {
-    addTests(&GenerateFlatNormalsTest::wrongIndexCount,
+    addTests({&GenerateFlatNormalsTest::wrongIndexCount,
-             &GenerateFlatNormalsTest::generate);
+              &GenerateFlatNormalsTest::generate});
 }
 
 void GenerateFlatNormalsTest::wrongIndexCount() {

src/MeshTools/Test/InterleaveTest.cpp

@@ -37,12 +37,12 @@ class InterleaveTest: public Corrade::TestSuite::Tester {
 };
 
 InterleaveTest::InterleaveTest() {
-    addTests(&InterleaveTest::attributeCount,
+    addTests({&InterleaveTest::attributeCount,
               &InterleaveTest::attributeCountGaps,
               &InterleaveTest::stride,
               &InterleaveTest::strideGaps,
               &InterleaveTest::write,
-             &InterleaveTest::writeGaps);
+              &InterleaveTest::writeGaps});
 }
 
 void InterleaveTest::attributeCount() {

src/MeshTools/Test/SubdivideTest.cpp

@@ -49,8 +49,8 @@ class SubdivideTest: public Corrade::TestSuite::Tester {
 };
 
 SubdivideTest::SubdivideTest() {
-    addTests(&SubdivideTest::wrongIndexCount,
+    addTests({&SubdivideTest::wrongIndexCount,
-             &SubdivideTest::subdivide);
+              &SubdivideTest::subdivide});
 }
 
 void SubdivideTest::wrongIndexCount() {

src/MeshTools/Test/TipsifyTest.cpp

@@ -70,8 +70,8 @@ TipsifyTest::TipsifyTest(): indices{
 
     16, 17, 18
 }, vertexCount(19) {
-    addTests(&TipsifyTest::buildAdjacency,
+    addTests({&TipsifyTest::buildAdjacency,
-             &TipsifyTest::tipsify);
+              &TipsifyTest::tipsify});
 }
 
 void TipsifyTest::buildAdjacency() {

src/MeshTools/Test/TransformTest.cpp

@@ -34,11 +34,11 @@ class TransformTest: public Corrade::TestSuite::Tester {
 };
 
 TransformTest::TransformTest() {
-    addTests(&TransformTest::transformVectors2D,
+    addTests({&TransformTest::transformVectors2D,
               &TransformTest::transformVectors3D,
 
               &TransformTest::transformPoints2D,
-             &TransformTest::transformPoints3D);
+              &TransformTest::transformPoints3D});
 }
 
 /* GCC < 4.7 doesn't like constexpr here, don't know why */

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() {

src/Physics/Test/AxisAlignedBoxTest.cpp

@@ -32,8 +32,8 @@ class AxisAlignedBoxTest: public Corrade::TestSuite::Tester, ShapeTestBase {
 };
 
 AxisAlignedBoxTest::AxisAlignedBoxTest() {
-    addTests(&AxisAlignedBoxTest::applyTransformation,
+    addTests({&AxisAlignedBoxTest::applyTransformation,
-             &AxisAlignedBoxTest::collisionPoint);
+              &AxisAlignedBoxTest::collisionPoint});
 }
 
 void AxisAlignedBoxTest::applyTransformation() {

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() {

src/Physics/Test/CapsuleTest.cpp

@@ -31,8 +31,8 @@ class CapsuleTest: public Corrade::TestSuite::Tester, ShapeTestBase {
 };
 
 CapsuleTest::CapsuleTest() {
-    addTests(&CapsuleTest::applyTransformation,
+    addTests({&CapsuleTest::applyTransformation,
-             &CapsuleTest::collisionPoint);
+              &CapsuleTest::collisionPoint});
 }
 
 void CapsuleTest::applyTransformation() {

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() {

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,
+    addTests({&ObjectShapeTest::clean,
-             &ObjectShapeTest::firstCollision);
+              &ObjectShapeTest::firstCollision});
 }
 
 void ObjectShapeTest::clean() {

src/Physics/Test/PlaneTest.cpp

@@ -31,9 +31,9 @@ class PlaneTest: public Corrade::TestSuite::Tester, ShapeTestBase {
 };
 
 PlaneTest::PlaneTest() {
-    addTests(&PlaneTest::applyTransformation,
+    addTests({&PlaneTest::applyTransformation,
               &PlaneTest::collisionLine,
-             &PlaneTest::collisionLineSegment);
+              &PlaneTest::collisionLineSegment});
 }
 
 void PlaneTest::applyTransformation() {

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() {

src/Physics/Test/ShapeGroupTest.cpp

@@ -31,8 +31,8 @@ class ShapeGroupTest: public Corrade::TestSuite::Tester {
 };
 
 ShapeGroupTest::ShapeGroupTest() {
-    addTests(&ShapeGroupTest::copy,
+    addTests({&ShapeGroupTest::copy,
-             &ShapeGroupTest::reference);
+              &ShapeGroupTest::reference});
 }
 
 void ShapeGroupTest::copy() {

src/Physics/Test/SphereTest.cpp

@@ -33,11 +33,11 @@ class SphereTest: public Corrade::TestSuite::Tester, ShapeTestBase {
 };
 
 SphereTest::SphereTest() {
-    addTests(&SphereTest::applyTransformation,
+    addTests({&SphereTest::applyTransformation,
               &SphereTest::collisionPoint,
               &SphereTest::collisionLine,
               &SphereTest::collisionLineSegment,
-             &SphereTest::collisionSphere);
+              &SphereTest::collisionSphere});
 }
 
 void SphereTest::applyTransformation() {

src/Primitives/Test/CapsuleTest.cpp

@@ -35,8 +35,8 @@ class CapsuleTest: public Corrade::TestSuite::Tester {
 };
 
 CapsuleTest::CapsuleTest() {
-    addTests(&CapsuleTest::withoutTextureCoords,
+    addTests({&CapsuleTest::withoutTextureCoords,
-             &CapsuleTest::withTextureCoords);
+              &CapsuleTest::withTextureCoords});
 }
 
 void CapsuleTest::withoutTextureCoords() {

src/Primitives/Test/CylinderTest.cpp

@@ -32,8 +32,8 @@ class CylinderTest: public Corrade::TestSuite::Tester {
 };
 
 CylinderTest::CylinderTest() {
-    addTests(&CylinderTest::withoutAnything,
+    addTests({&CylinderTest::withoutAnything,
-             &CylinderTest::withTextureCoordsAndCaps);
+              &CylinderTest::withTextureCoordsAndCaps});
 }
 
 void CylinderTest::withoutAnything() {

src/Primitives/Test/UVSphereTest.cpp

@@ -32,8 +32,8 @@ class UVSphereTest: public Corrade::TestSuite::Tester {
 };
 
 UVSphereTest::UVSphereTest() {
-    addTests(&UVSphereTest::withoutTextureCoords,
+    addTests({&UVSphereTest::withoutTextureCoords,
-             &UVSphereTest::withTextureCoords);
+              &UVSphereTest::withTextureCoords});
 }
 
 void UVSphereTest::withoutTextureCoords() {

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,
+    addTests({&AnimableTest::state,
               &AnimableTest::step,
               &AnimableTest::duration,
               &AnimableTest::repeat,
               &AnimableTest::stop,
               &AnimableTest::pause,
-             &AnimableTest::debug);
+
+              &AnimableTest::debug});
 }
 
 void AnimableTest::state() {

src/SceneGraph/Test/CameraTest.cpp

@@ -46,14 +46,14 @@ typedef SceneGraph::Camera2D<> Camera2D;
 typedef SceneGraph::Camera3D<> Camera3D;
 
 CameraTest::CameraTest() {
-    addTests(&CameraTest::fixAspectRatio,
+    addTests({&CameraTest::fixAspectRatio,
               &CameraTest::defaultProjection2D,
               &CameraTest::defaultProjection3D,
               &CameraTest::projectionSize2D,
               &CameraTest::projectionSizeOrthographic,
               &CameraTest::projectionSizePerspective,
               &CameraTest::projectionSizeViewport,
-             &CameraTest::draw);
+              &CameraTest::draw});
 }
 
 void CameraTest::fixAspectRatio() {

src/SceneGraph/Test/EuclideanMatrixTransformation2DTest.cpp

@@ -40,7 +40,7 @@ class EuclideanMatrixTransformation2DTest: public Corrade::TestSuite::Tester {
 };
 
 EuclideanMatrixTransformation2DTest::EuclideanMatrixTransformation2DTest() {
-    addTests(&EuclideanMatrixTransformation2DTest::fromMatrix,
+    addTests({&EuclideanMatrixTransformation2DTest::fromMatrix,
               &EuclideanMatrixTransformation2DTest::toMatrix,
               &EuclideanMatrixTransformation2DTest::compose,
               &EuclideanMatrixTransformation2DTest::inverted,
@@ -49,7 +49,7 @@ EuclideanMatrixTransformation2DTest::EuclideanMatrixTransformation2DTest() {
               &EuclideanMatrixTransformation2DTest::translate,
               &EuclideanMatrixTransformation2DTest::rotate,
               &EuclideanMatrixTransformation2DTest::reflect,
-             &EuclideanMatrixTransformation2DTest::normalizeRotation);
+              &EuclideanMatrixTransformation2DTest::normalizeRotation});
 }
 
 void EuclideanMatrixTransformation2DTest::fromMatrix() {

src/SceneGraph/Test/EuclideanMatrixTransformation3DTest.cpp

@@ -40,7 +40,7 @@ class EuclideanMatrixTransformation3DTest: public Corrade::TestSuite::Tester {
 };
 
 EuclideanMatrixTransformation3DTest::EuclideanMatrixTransformation3DTest() {
-    addTests(&EuclideanMatrixTransformation3DTest::fromMatrix,
+    addTests({&EuclideanMatrixTransformation3DTest::fromMatrix,
               &EuclideanMatrixTransformation3DTest::toMatrix,
               &EuclideanMatrixTransformation3DTest::compose,
               &EuclideanMatrixTransformation3DTest::inverted,
@@ -49,7 +49,7 @@ EuclideanMatrixTransformation3DTest::EuclideanMatrixTransformation3DTest() {
               &EuclideanMatrixTransformation3DTest::translate,
               &EuclideanMatrixTransformation3DTest::rotate,
               &EuclideanMatrixTransformation3DTest::reflect,
-             &EuclideanMatrixTransformation3DTest::normalizeRotation);
+              &EuclideanMatrixTransformation3DTest::normalizeRotation});
 }
 
 void EuclideanMatrixTransformation3DTest::fromMatrix() {

src/SceneGraph/Test/MatrixTransformation2DTest.cpp

@@ -41,7 +41,7 @@ class MatrixTransformation2DTest: public Corrade::TestSuite::Tester {
 };
 
 MatrixTransformation2DTest::MatrixTransformation2DTest() {
-    addTests(&MatrixTransformation2DTest::fromMatrix,
+    addTests({&MatrixTransformation2DTest::fromMatrix,
               &MatrixTransformation2DTest::toMatrix,
               &MatrixTransformation2DTest::compose,
               &MatrixTransformation2DTest::inverted,
@@ -51,7 +51,7 @@ MatrixTransformation2DTest::MatrixTransformation2DTest() {
               &MatrixTransformation2DTest::translate,
               &MatrixTransformation2DTest::rotate,
               &MatrixTransformation2DTest::scale,
-             &MatrixTransformation2DTest::reflect);
+              &MatrixTransformation2DTest::reflect});
 }
 
 void MatrixTransformation2DTest::fromMatrix() {

src/SceneGraph/Test/MatrixTransformation3DTest.cpp

@@ -41,7 +41,7 @@ class MatrixTransformation3DTest: public Corrade::TestSuite::Tester {
 };
 
 MatrixTransformation3DTest::MatrixTransformation3DTest() {
-    addTests(&MatrixTransformation3DTest::fromMatrix,
+    addTests({&MatrixTransformation3DTest::fromMatrix,
               &MatrixTransformation3DTest::toMatrix,
               &MatrixTransformation3DTest::compose,
               &MatrixTransformation3DTest::inverted,
@@ -51,7 +51,7 @@ MatrixTransformation3DTest::MatrixTransformation3DTest() {
               &MatrixTransformation3DTest::translate,
               &MatrixTransformation3DTest::rotate,
               &MatrixTransformation3DTest::scale,
-             &MatrixTransformation3DTest::reflect);
+              &MatrixTransformation3DTest::reflect});
 }
 
 void MatrixTransformation3DTest::fromMatrix() {

src/SceneGraph/Test/ObjectTest.cpp

@@ -54,7 +54,7 @@ class CachingObject: public Object3D, AbstractFeature<3> {
 };
 
 ObjectTest::ObjectTest() {
-    addTests(&ObjectTest::parenting,
+    addTests({&ObjectTest::parenting,
               &ObjectTest::scene,
               &ObjectTest::absoluteTransformation,
               &ObjectTest::transformations,
@@ -62,7 +62,7 @@ ObjectTest::ObjectTest() {
               &ObjectTest::transformationsOrphan,
               &ObjectTest::transformationsDuplicate,
               &ObjectTest::setClean,
-             &ObjectTest::bulkSetClean);
+              &ObjectTest::bulkSetClean});
 }
 
 void ObjectTest::parenting() {

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,
+    addTests({&SceneTest::transformation,
-             &SceneTest::parent);
+              &SceneTest::parent});
 }
 
 void SceneTest::transformation() {

src/Test/AbstractImageTest.cpp

@@ -29,8 +29,8 @@ class AbstractImageTest: public Corrade::TestSuite::Tester {
 };
 
 AbstractImageTest::AbstractImageTest() {
-    addTests(&AbstractImageTest::debugFormat,
+    addTests({&AbstractImageTest::debugFormat,
-             &AbstractImageTest::debugType);
+              &AbstractImageTest::debugType});
 }
 
 void AbstractImageTest::debugFormat() {

src/Test/AbstractShaderProgramTest.cpp

@@ -40,7 +40,7 @@ class AbstractShaderProgramTest: public Corrade::TestSuite::Tester {
 };
 
 AbstractShaderProgramTest::AbstractShaderProgramTest() {
-    addTests(&AbstractShaderProgramTest::attributeScalar,
+    addTests({&AbstractShaderProgramTest::attributeScalar,
               &AbstractShaderProgramTest::attributeScalarInt,
               &AbstractShaderProgramTest::attributeScalarUnsignedInt,
               &AbstractShaderProgramTest::attributeScalarDouble,
@@ -53,7 +53,7 @@ AbstractShaderProgramTest::AbstractShaderProgramTest() {
               &AbstractShaderProgramTest::attributeVectorBGRA,
 
               &AbstractShaderProgramTest::attributeMatrix,
-             &AbstractShaderProgramTest::attributeMatrixDouble);
+              &AbstractShaderProgramTest::attributeMatrixDouble});
 }
 
 void AbstractShaderProgramTest::attributeScalar() {

src/Test/ArrayTest.cpp

@@ -34,10 +34,10 @@ typedef Magnum::Array2D<int> Array2D;
 typedef Magnum::Array3D<int> Array3D;
 
 ArrayTest::ArrayTest() {
-    addTests(&ArrayTest::construct,
+    addTests({&ArrayTest::construct,
               &ArrayTest::constexprConstruct,
               &ArrayTest::equality,
-             &ArrayTest::access);
+              &ArrayTest::access});
 }
 
 void ArrayTest::construct() {

src/Test/ColorTest.cpp

@@ -49,7 +49,7 @@ typedef Magnum::Color3<Float> Color3f;
 typedef Magnum::Color4<Float> Color4f;
 
 ColorTest::ColorTest() {
-    addTests(&ColorTest::access,
+    addTests({&ColorTest::access,
 
               &ColorTest::fromHue,
               &ColorTest::fromSaturation,
@@ -64,7 +64,7 @@ ColorTest::ColorTest() {
               &ColorTest::hsvAlpha,
 
               &ColorTest::debug,
-             &ColorTest::configuration);
+              &ColorTest::configuration});
 }
 
 void ColorTest::access() {

src/Test/MeshTest.cpp

@@ -32,10 +32,10 @@ class MeshTest: public Corrade::TestSuite::Tester {
 };
 
 MeshTest::MeshTest() {
-    addTests(&MeshTest::debugPrimitive,
+    addTests({&MeshTest::debugPrimitive,
               &MeshTest::debugIndexType,
               &MeshTest::configurationPrimitive,
-             &MeshTest::configurationIndexType);
+              &MeshTest::configurationIndexType});
 }
 
 void MeshTest::debugPrimitive() {

src/Test/ResourceManagerTest.cpp

@@ -62,14 +62,14 @@ class IntResourceLoader: public AbstractResourceLoader<Int> {
 size_t Data::count = 0;
 
 ResourceManagerTest::ResourceManagerTest() {
-    addTests(&ResourceManagerTest::state,
+    addTests({&ResourceManagerTest::state,
               &ResourceManagerTest::stateFallback,
               &ResourceManagerTest::stateDisallowed,
               &ResourceManagerTest::basic,
               &ResourceManagerTest::residentPolicy,
               &ResourceManagerTest::referenceCountedPolicy,
               &ResourceManagerTest::manualPolicy,
-             &ResourceManagerTest::loader);
+              &ResourceManagerTest::loader});
 }
 
 void ResourceManagerTest::state() {

src/Test/SwizzleTest.cpp

@@ -29,9 +29,9 @@ class SwizzleTest: public Corrade::TestSuite::Tester {
 };
 
 SwizzleTest::SwizzleTest() {
-    addTests(&SwizzleTest::rgba,
+    addTests({&SwizzleTest::rgba,
               &SwizzleTest::type,
-             &SwizzleTest::defaultType);
+              &SwizzleTest::defaultType});
 }
 
 void SwizzleTest::rgba() {

src/TextureTools/Test/AtlasTest.cpp

@@ -32,10 +32,10 @@ class AtlasTest: public Corrade::TestSuite::Tester {
 };
 
 AtlasTest::AtlasTest() {
-    addTests(&AtlasTest::create,
+    addTests({&AtlasTest::create,
               &AtlasTest::createPadding,
               &AtlasTest::createEmpty,
-             &AtlasTest::createTooSmall);
+              &AtlasTest::createTooSmall});
 }
 
 void AtlasTest::create() {

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 */
+        /** @brief Default constructor */
-        /* GCC 4.6 can't handle {} as default parameter */
+        inline explicit AbstractImporter() = default;
-        inline explicit AbstractImporter(Corrade::PluginManager::AbstractPluginManager* manager = nullptr, const std::string& plugin = std::string()): Plugin(manager, plugin) {}
+
+        /** @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;

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() {

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() {