Making test declarations more compact.

Yet again I experienced how insanely large this thing got over the
years.

src/Magnum/Audio/Test/AbstractImporterTest.cpp

@@ -33,11 +33,10 @@
 
 namespace Magnum { namespace Audio { namespace Test {
 
-class AbstractImporterTest: public TestSuite::Tester {
+struct AbstractImporterTest: TestSuite::Tester {
-    public:
+    explicit AbstractImporterTest();
-        explicit AbstractImporterTest();
 
-        void openFile();
+    void openFile();
 };
 
 AbstractImporterTest::AbstractImporterTest() {

src/Magnum/Audio/Test/BufferTest.cpp

@@ -30,11 +30,10 @@
 
 namespace Magnum { namespace Audio { namespace Test {
 
-class BufferTest: public TestSuite::Tester {
+struct BufferTest: TestSuite::Tester {
-    public:
+    explicit BufferTest();
-        explicit BufferTest();
 
-        void debugFormat();
+    void debugFormat();
 };
 
 BufferTest::BufferTest() {

src/Magnum/Audio/Test/RendererTest.cpp

@@ -30,11 +30,10 @@
 
 namespace Magnum { namespace Audio { namespace Test {
 
-class RendererTest: public TestSuite::Tester {
+struct RendererTest: TestSuite::Tester {
-    public:
+    explicit RendererTest();
-        explicit RendererTest();
 
-        void debugError();
+    void debugError();
 };
 
 RendererTest::RendererTest() {

src/Magnum/Audio/Test/SourceTest.cpp

@@ -30,11 +30,10 @@
 
 namespace Magnum { namespace Audio { namespace Test {
 
-class SourceTest: public TestSuite::Tester {
+struct SourceTest: TestSuite::Tester {
-    public:
+    explicit SourceTest();
-        explicit SourceTest();
 
-        void debugState();
+    void debugState();
 };
 
 SourceTest::SourceTest() {

src/Magnum/DebugTools/Test/CapsuleRendererTest.cpp

@@ -29,17 +29,16 @@
 
 namespace Magnum { namespace DebugTools { namespace Test {
 
-class CapsuleRendererTest: public TestSuite::Tester {
+struct CapsuleRendererTest: TestSuite::Tester {
-    public:
+    explicit CapsuleRendererTest();
-        explicit CapsuleRendererTest();
 
-        void zeroLength2D();
+    void zeroLength2D();
-        void common2D();
+    void common2D();
 
-        void zeroLength3D();
+    void zeroLength3D();
-        void parallel3D();
+    void parallel3D();
-        void antiParallel3D();
+    void antiParallel3D();
-        void common3D();
+    void common3D();
 };
 
 CapsuleRendererTest::CapsuleRendererTest() {

src/Magnum/DebugTools/Test/CylinderRendererTest.cpp

@@ -29,17 +29,16 @@
 
 namespace Magnum { namespace DebugTools { namespace Test {
 
-class CylinderRendererTest: public TestSuite::Tester {
+struct CylinderRendererTest: TestSuite::Tester {
-    public:
+    explicit CylinderRendererTest();
-        explicit CylinderRendererTest();
 
-        void zeroLength2D();
+    void zeroLength2D();
-        void common2D();
+    void common2D();
 
-        void zeroLength3D();
+    void zeroLength3D();
-        void parallel3D();
+    void parallel3D();
-        void antiParallel3D();
+    void antiParallel3D();
-        void common3D();
+    void common3D();
 };
 
 CylinderRendererTest::CylinderRendererTest() {

src/Magnum/DebugTools/Test/ForceRendererTest.cpp

@@ -29,17 +29,16 @@
 
 namespace Magnum { namespace DebugTools { namespace Implementation { namespace Test {
 
-class ForceRendererTest: public TestSuite::Tester {
+struct ForceRendererTest: TestSuite::Tester {
-    public:
+    explicit ForceRendererTest();
-        explicit ForceRendererTest();
 
-        void zero2D();
+    void zero2D();
-        void common2D();
+    void common2D();
 
-        void zero3D();
+    void zero3D();
-        void parallel3D();
+    void parallel3D();
-        void antiParallel3D();
+    void antiParallel3D();
-        void arbitrary3D();
+    void arbitrary3D();
 };
 
 ForceRendererTest::ForceRendererTest() {

src/Magnum/DebugTools/Test/LineSegmentRendererTest.cpp

@@ -33,12 +33,11 @@
 
 namespace Magnum { namespace DebugTools { namespace Test {
 
-class LineSegmentRendererTest: public TestSuite::Tester {
+struct LineSegmentRendererTest: TestSuite::Tester {
-    public:
+    explicit LineSegmentRendererTest();
-        explicit LineSegmentRendererTest();
 
-        void line2D();
+    void line2D();
-        void line3D();
+    void line3D();
 };
 
 LineSegmentRendererTest::LineSegmentRendererTest() {

src/Magnum/Math/Algorithms/Test/GaussJordanTest.cpp

@@ -29,12 +29,11 @@
 
 namespace Magnum { namespace Math { namespace Algorithms { namespace Test {
 
-class GaussJordanTest: public Corrade::TestSuite::Tester {
+struct GaussJordanTest: Corrade::TestSuite::Tester {
-    public:
+    explicit GaussJordanTest();
-        explicit GaussJordanTest();
 
-        void singular();
+    void singular();
-        void invert();
+    void invert();
 };
 
 typedef RectangularMatrix<4, 4, Float> Matrix4x4;

src/Magnum/Math/Algorithms/Test/GramSchmidtTest.cpp

@@ -29,12 +29,11 @@
 
 namespace Magnum { namespace Math { namespace Algorithms { namespace Test {
 
-class GramSchmidtTest: public Corrade::TestSuite::Tester {
+struct GramSchmidtTest: Corrade::TestSuite::Tester {
-    public:
+    explicit GramSchmidtTest();
-        GramSchmidtTest();
 
-        void orthogonalize();
+    void orthogonalize();
-        void orthonormalize();
+    void orthonormalize();
 };
 
 typedef RectangularMatrix<3, 3, Float> Matrix3x3;

src/Magnum/Math/Algorithms/Test/SvdTest.cpp

@@ -29,12 +29,11 @@
 
 namespace Magnum { namespace Math { namespace Algorithms { namespace Test {
 
-class SvdTest: public Corrade::TestSuite::Tester {
+struct SvdTest: Corrade::TestSuite::Tester {
-    public:
+    explicit SvdTest();
-        explicit SvdTest();
 
-        void testDouble();
+    void testDouble();
-        void testFloat();
+    void testFloat();
 };
 
 #ifndef MAGNUM_TARGET_GLES

src/Magnum/Math/Geometry/Test/DistanceTest.cpp

@@ -30,14 +30,13 @@
 
 namespace Magnum { namespace Math { namespace Geometry { namespace Test {
 
-class DistanceTest: public Corrade::TestSuite::Tester {
+struct DistanceTest: Corrade::TestSuite::Tester {
-    public:
+    explicit DistanceTest();
-        DistanceTest();
+
-
+    void linePoint2D();
-        void linePoint2D();
+    void linePoint3D();
-        void linePoint3D();
+    void lineSegmentPoint2D();
-        void lineSegmentPoint2D();
+    void lineSegmentPoint3D();
-        void lineSegmentPoint3D();
 };
 
 typedef Math::Vector2<Float> Vector2;

src/Magnum/Math/Geometry/Test/IntersectionTest.cpp

@@ -29,12 +29,11 @@
 
 namespace Magnum { namespace Math { namespace Geometry { namespace Test {
 
-class IntersectionTest: public Corrade::TestSuite::Tester {
+struct IntersectionTest: Corrade::TestSuite::Tester {
-    public:
+    explicit IntersectionTest();
-        IntersectionTest();
 
-        void planeLine();
+    void planeLine();
-        void lineLine();
+    void lineLine();
 };
 
 typedef Math::Vector2<Float> Vector2;

src/Magnum/Math/Test/AngleTest.cpp

@@ -30,16 +30,15 @@
 
 namespace Magnum { namespace Math { namespace Test {
 
-class AngleTest: public Corrade::TestSuite::Tester {
+struct AngleTest: Corrade::TestSuite::Tester {
-    public:
+    explicit AngleTest();
-        explicit AngleTest();
 
-        void construct();
+    void construct();
-        void literals();
+    void literals();
-        void conversion();
+    void conversion();
 
-        void debugDeg();
+    void debugDeg();
-        void debugRad();
+    void debugRad();
 };
 
 typedef Math::Deg<Float> Deg;

src/Magnum/Math/Test/BoolVectorTest.cpp

@@ -30,27 +30,26 @@
 
 namespace Magnum { namespace Math { namespace Test {
 
-class BoolVectorTest: public Corrade::TestSuite::Tester {
+struct BoolVectorTest: Corrade::TestSuite::Tester {
-    public:
+    explicit BoolVectorTest();
-        explicit BoolVectorTest();
+
-
+    void construct();
-        void construct();
+    void constructDefault();
-        void constructDefault();
+    void constructOneValue();
-        void constructOneValue();
+    void constructOneElement();
-        void constructOneElement();
+    void constructCopy();
-        void constructCopy();
+    void data();
-        void data();
+
-
+    void compare();
-        void compare();
+    void compareUndefined();
-        void compareUndefined();
+    void all();
-        void all();
+    void none();
-        void none();
+    void any();
-        void any();
+
-
+    void bitInverse();
-        void bitInverse();
+    void bitAndOrXor();
-        void bitAndOrXor();
+
-
+    void debug();
-        void debug();
 };
 
 static_assert(BoolVector<15>::DataSize == 2, "Improper DataSize");

src/Magnum/Math/Test/ComplexTest.cpp

@@ -31,38 +31,37 @@
 
 namespace Magnum { namespace Math { namespace Test {
 
-class ComplexTest: public Corrade::TestSuite::Tester {
+struct ComplexTest: Corrade::TestSuite::Tester {
-    public:
+    explicit ComplexTest();
-        explicit ComplexTest();
+
-
+    void construct();
-        void construct();
+    void constructDefault();
-        void constructDefault();
+    void constructFromVector();
-        void constructFromVector();
+    void constructCopy();
-        void constructCopy();
+
-
+    void compare();
-        void compare();
+    void isNormalized();
-        void isNormalized();
+
-
+    void addSubtract();
-        void addSubtract();
+    void negated();
-        void negated();
+    void multiplyDivideScalar();
-        void multiplyDivideScalar();
+    void multiply();
-        void multiply();
+
-
+    void dot();
-        void dot();
+    void dotSelf();
-        void dotSelf();
+    void length();
-        void length();
+    void normalized();
-        void normalized();
+
-
+    void conjugated();
-        void conjugated();
+    void inverted();
-        void inverted();
+    void invertedNormalized();
-        void invertedNormalized();
+
-
+    void angle();
-        void angle();
+    void rotation();
-        void rotation();
+    void matrix();
-        void matrix();
+    void transformVector();
-        void transformVector();
+
-
+    void debug();
-        void debug();
 };
 
 ComplexTest::ComplexTest() {

src/Magnum/Math/Test/ConstantsTest.cpp

@@ -30,12 +30,11 @@
 
 namespace Magnum { namespace Math { namespace Test {
 
-class ConstantsTest: public Corrade::TestSuite::Tester {
+struct ConstantsTest: Corrade::TestSuite::Tester {
-    public:
+    explicit ConstantsTest();
-        ConstantsTest();
 
-        void constants();
+    void constants();
-        void specials();
+    void specials();
 
     private:
         template<class> void _constants();

src/Magnum/Math/Test/DualComplexTest.cpp

@@ -31,36 +31,35 @@
 
 namespace Magnum { namespace Math { namespace Test {
 
-class DualComplexTest: public Corrade::TestSuite::Tester {
+struct DualComplexTest: Corrade::TestSuite::Tester {
-    public:
+    explicit DualComplexTest();
-        explicit DualComplexTest();
 
-        void construct();
+    void construct();
-        void constructDefault();
+    void constructDefault();
-        void constructFromVector();
+    void constructFromVector();
-        void constructCopy();
+    void constructCopy();
 
-        void isNormalized();
+    void isNormalized();
 
-        void multiply();
+    void multiply();
 
-        void lengthSquared();
+    void lengthSquared();
-        void length();
+    void length();
-        void normalized();
+    void normalized();
 
-        void complexConjugated();
+    void complexConjugated();
-        void dualConjugated();
+    void dualConjugated();
-        void conjugated();
+    void conjugated();
-        void inverted();
+    void inverted();
-        void invertedNormalized();
+    void invertedNormalized();
 
-        void rotation();
+    void rotation();
-        void translation();
+    void translation();
-        void combinedTransformParts();
+    void combinedTransformParts();
-        void matrix();
+    void matrix();
-        void transformPoint();
+    void transformPoint();
 
-        void debug();
+    void debug();
 };
 
 typedef Math::Deg<Float> Deg;

src/Magnum/Math/Test/DualQuaternionTest.cpp

@@ -30,35 +30,34 @@
 
 namespace Magnum { namespace Math { namespace Test {
 
-class DualQuaternionTest: public Corrade::TestSuite::Tester {
+struct DualQuaternionTest: Corrade::TestSuite::Tester {
-    public:
+    explicit DualQuaternionTest();
-        explicit DualQuaternionTest();
+
-
+    void construct();
-        void construct();
+    void constructDefault();
-        void constructDefault();
+    void constructFromVector();
-        void constructFromVector();
+    void constructCopy();
-        void constructCopy();
+
-
+    void isNormalized();
-        void isNormalized();
+
-
+    void lengthSquared();
-        void lengthSquared();
+    void length();
-        void length();
+    void normalized();
-        void normalized();
+
-
+    void quaternionConjugated();
-        void quaternionConjugated();
+    void dualConjugated();
-        void dualConjugated();
+    void conjugated();
-        void conjugated();
+    void inverted();
-        void inverted();
+    void invertedNormalized();
-        void invertedNormalized();
+
-
+    void rotation();
-        void rotation();
+    void translation();
-        void translation();
+    void combinedTransformParts();
-        void combinedTransformParts();
+    void matrix();
-        void matrix();
+    void transformPoint();
-        void transformPoint();
+    void transformPointNormalized();
-        void transformPointNormalized();
+
-
+    void debug();
-        void debug();
 };
 
 typedef Math::Deg<Float> Deg;

src/Magnum/Math/Test/DualTest.cpp

@@ -30,24 +30,23 @@
 
 namespace Magnum { namespace Math { namespace Test {
 
-class DualTest: public Corrade::TestSuite::Tester {
+struct DualTest: Corrade::TestSuite::Tester {
-    public:
+    explicit DualTest();
-        explicit DualTest();
 
-        void construct();
+    void construct();
-        void constructDefault();
+    void constructDefault();
-        void constructCopy();
+    void constructCopy();
 
-        void compare();
+    void compare();
 
-        void addSubtract();
+    void addSubtract();
-        void negated();
+    void negated();
-        void multiplyDivide();
+    void multiplyDivide();
 
-        void conjugated();
+    void conjugated();
-        void sqrt();
+    void sqrt();
 
-        void debug();
+    void debug();
 };
 
 typedef Math::Dual<Float> Dual;

src/Magnum/Math/Test/FunctionsTest.cpp

@@ -30,44 +30,43 @@
 
 namespace Magnum { namespace Math { namespace Test {
 
-class FunctionsTest: public Corrade::TestSuite::Tester {
+struct FunctionsTest: Corrade::TestSuite::Tester {
-    public:
+    explicit FunctionsTest();
-        FunctionsTest();
+
-
+    void min();
-        void min();
+    void minList();
-        void minList();
+    void max();
-        void max();
+    void maxList();
-        void maxList();
+    void minmax();
-        void minmax();
+    void clamp();
-        void clamp();
+    void nanPropagation();
-        void nanPropagation();
+
-
+    void sign();
-        void sign();
+    void abs();
-        void abs();
+
-
+    void floor();
-        void floor();
+    void round();
-        void round();
+    void ceil();
-        void ceil();
+
-
+    void sqrt();
-        void sqrt();
+    void sqrtInverted();
-        void sqrtInverted();
+    void lerp();
-        void lerp();
+    void lerpInverted();
-        void lerpInverted();
+    void fma();
-        void fma();
+    void normalizeUnsigned();
-        void normalizeUnsigned();
+    void normalizeSigned();
-        void normalizeSigned();
+    void denormalizeUnsigned();
-        void denormalizeUnsigned();
+    void denormalizeSigned();
-        void denormalizeSigned();
+    void renormalizeUnsinged();
-        void renormalizeUnsinged();
+    void renormalizeSinged();
-        void renormalizeSinged();
+
-
+    void normalizeTypeDeduction();
-        void normalizeTypeDeduction();
+
-
+    void pow();
-        void pow();
+    void log();
-        void log();
+    void log2();
-        void log2();
+    void trigonometric();
-        void trigonometric();
+    void trigonometricWithBase();
-        void trigonometricWithBase();
 };
 
 typedef Math::Constants<Float> Constants;

src/Magnum/Math/Test/Matrix3Test.cpp

@@ -56,37 +56,36 @@ template<> struct RectangularMatrixConverter<3, 3, float, Mat3> {
 
 namespace Test {
 
-class Matrix3Test: public Corrade::TestSuite::Tester {
+struct Matrix3Test: Corrade::TestSuite::Tester {
-    public:
+    explicit Matrix3Test();
-        Matrix3Test();
+
-
+    void construct();
-        void construct();
+    void constructIdentity();
-        void constructIdentity();
+    void constructZero();
-        void constructZero();
+    void constructConversion();
-        void constructConversion();
+    void constructCopy();
-        void constructCopy();
+
-
+    void convert();
-        void convert();
+
-
+    void isRigidTransformation();
-        void isRigidTransformation();
+
-
+    void translation();
-        void translation();
+    void scaling();
-        void scaling();
+    void rotation();
-        void rotation();
+    void reflection();
-        void reflection();
+    void reflectionIsScaling();
-        void reflectionIsScaling();
+    void projection();
-        void projection();
+    void fromParts();
-        void fromParts();
+    void rotationScalingPart();
-        void rotationScalingPart();
+    void rotationNormalizedPart();
-        void rotationNormalizedPart();
+    void rotationPart();
-        void rotationPart();
+    void uniformScalingPart();
-        void uniformScalingPart();
+    void vectorParts();
-        void vectorParts();
+    void invertedRigid();
-        void invertedRigid();
+    void transform();
-        void transform();
+
-
+    void debug();
-        void debug();
+    void configuration();
-        void configuration();
 };
 
 typedef Math::Deg<Float> Deg;

src/Magnum/Math/Test/Matrix4Test.cpp

@@ -58,42 +58,41 @@ template<> struct RectangularMatrixConverter<4, 4, float, Mat4> {
 
 namespace Test {
 
-class Matrix4Test: public Corrade::TestSuite::Tester {
+struct Matrix4Test: Corrade::TestSuite::Tester {
-    public:
+    explicit Matrix4Test();
-        Matrix4Test();
+
-
+    void construct();
-        void construct();
+    void constructIdentity();
-        void constructIdentity();
+    void constructZero();
-        void constructZero();
+    void constructConversion();
-        void constructConversion();
+    void constructCopy();
-        void constructCopy();
+
-
+    void convert();
-        void convert();
+
-
+    void isRigidTransformation();
-        void isRigidTransformation();
+
-
+    void translation();
-        void translation();
+    void scaling();
-        void scaling();
+    void rotation();
-        void rotation();
+    void rotationX();
-        void rotationX();
+    void rotationY();
-        void rotationY();
+    void rotationZ();
-        void rotationZ();
+    void reflection();
-        void reflection();
+    void reflectionIsScaling();
-        void reflectionIsScaling();
+    void orthographicProjection();
-        void orthographicProjection();
+    void perspectiveProjection();
-        void perspectiveProjection();
+    void perspectiveProjectionFov();
-        void perspectiveProjectionFov();
+    void fromParts();
-        void fromParts();
+    void rotationScalingPart();
-        void rotationScalingPart();
+    void rotationNormalizedPart();
-        void rotationNormalizedPart();
+    void rotationPart();
-        void rotationPart();
+    void uniformScalingPart();
-        void uniformScalingPart();
+    void vectorParts();
-        void vectorParts();
+    void invertedRigid();
-        void invertedRigid();
+    void transform();
-        void transform();
+
-
+    void debug();
-        void debug();
+    void configuration();
-        void configuration();
 };
 
 typedef Math::Deg<Float> Deg;

src/Magnum/Math/Test/MatrixTest.cpp

@@ -56,31 +56,30 @@ template<> struct RectangularMatrixConverter<3, 3, float, Mat3> {
 
 namespace Test {
 
-class MatrixTest: public Corrade::TestSuite::Tester {
+struct MatrixTest: Corrade::TestSuite::Tester {
-    public:
+    explicit MatrixTest();
-        MatrixTest();
 
-        void construct();
+    void construct();
-        void constructIdentity();
+    void constructIdentity();
-        void constructZero();
+    void constructZero();
-        void constructConversion();
+    void constructConversion();
-        void constructCopy();
+    void constructCopy();
 
-        void convert();
+    void convert();
 
-        void isOrthogonal();
+    void isOrthogonal();
 
-        void trace();
+    void trace();
-        void ij();
+    void ij();
-        void determinant();
+    void determinant();
-        void inverted();
+    void inverted();
-        void invertedOrthogonal();
+    void invertedOrthogonal();
 
-        void subclassTypes();
+    void subclassTypes();
-        void subclass();
+    void subclass();
 
-        void debug();
+    void debug();
-        void configuration();
+    void configuration();
 };
 
 typedef Matrix<4, Float> Matrix4x4;

src/Magnum/Math/Test/QuaternionTest.cpp

@@ -31,41 +31,40 @@
 
 namespace Magnum { namespace Math { namespace Test {
 
-class QuaternionTest: public Corrade::TestSuite::Tester {
+struct QuaternionTest: Corrade::TestSuite::Tester {
-    public:
+    explicit QuaternionTest();
-        explicit QuaternionTest();
+
-
+    void construct();
-        void construct();
+    void constructDefault();
-        void constructDefault();
+    void constructFromVector();
-        void constructFromVector();
+    void constructCopy();
-        void constructCopy();
+
-
+    void compare();
-        void compare();
+    void isNormalized();
-        void isNormalized();
+
-
+    void addSubtract();
-        void addSubtract();
+    void negated();
-        void negated();
+    void multiplyDivideScalar();
-        void multiplyDivideScalar();
+    void multiply();
-        void multiply();
+
-
+    void dot();
-        void dot();
+    void dotSelf();
-        void dotSelf();
+    void length();
-        void length();
+    void normalized();
-        void normalized();
+
-
+    void conjugated();
-        void conjugated();
+    void inverted();
-        void inverted();
+    void invertedNormalized();
-        void invertedNormalized();
+
-
+    void rotation();
-        void rotation();
+    void angle();
-        void angle();
+    void matrix();
-        void matrix();
+    void lerp();
-        void lerp();
+    void slerp();
-        void slerp();
+    void transformVector();
-        void transformVector();
+    void transformVectorNormalized();
-        void transformVectorNormalized();
+
-
+    void debug();
-        void debug();
 };
 
 typedef Math::Deg<Float> Deg;

src/Magnum/Math/Test/RangeTest.cpp

@@ -35,34 +35,33 @@
 
 namespace Magnum { namespace Math { namespace Test {
 
-class RangeTest: public Corrade::TestSuite::Tester {
+struct RangeTest: Corrade::TestSuite::Tester {
-    public:
+    explicit RangeTest();
-        RangeTest();
 
-        void construct();
+    void construct();
-        void constructDefault();
+    void constructDefault();
-        void constructFromSize();
+    void constructFromSize();
-        void constructConversion();
+    void constructConversion();
-        void constructCopy();
+    void constructCopy();
 
-        void access();
+    void access();
-        void compare();
+    void compare();
-        void size();
+    void size();
-        void center();
+    void center();
 
-        void translated();
+    void translated();
-        void padded();
+    void padded();
-        void scaled();
+    void scaled();
 
-        void subclassTypes();
+    void subclassTypes();
-        void subclass();
+    void subclass();
 
-        #ifdef MAGNUM_BUILD_DEPRECATED
+    #ifdef MAGNUM_BUILD_DEPRECATED
-        void deprecated();
+    void deprecated();
-        #endif
+    #endif
 
-        void debug();
+    void debug();
-        void configuration();
+    void configuration();
 };
 
 typedef Math::Range1D<Float> Range1D;

src/Magnum/Math/Test/RectangularMatrixTest.cpp

@@ -54,39 +54,38 @@ template<> struct RectangularMatrixConverter<2, 3, float, Mat2x3> {
 
 namespace Test {
 
-class RectangularMatrixTest: public Corrade::TestSuite::Tester {
+struct RectangularMatrixTest: Corrade::TestSuite::Tester {
-    public:
+    explicit RectangularMatrixTest();
-        RectangularMatrixTest();
 
-        void construct();
+    void construct();
-        void constructDefault();
+    void constructDefault();
-        void constructConversion();
+    void constructConversion();
-        void constructFromData();
+    void constructFromData();
-        void constructFromDiagonal();
+    void constructFromDiagonal();
-        void constructCopy();
+    void constructCopy();
 
-        void convert();
+    void convert();
-        void data();
+    void data();
-        void row();
+    void row();
 
-        void compare();
+    void compare();
 
-        void negative();
+    void negative();
-        void addSubtract();
+    void addSubtract();
-        void multiplyDivide();
+    void multiplyDivide();
-        void multiply();
+    void multiply();
-        void multiplyVector();
+    void multiplyVector();
 
-        void transposed();
+    void transposed();
-        void diagonal();
+    void diagonal();
 
-        void vector();
+    void vector();
 
-        void subclassTypes();
+    void subclassTypes();
-        void subclass();
+    void subclass();
 
-        void debug();
+    void debug();
-        void configuration();
+    void configuration();
 };
 
 typedef RectangularMatrix<4, 3, Float> Matrix4x3;

src/Magnum/Math/Test/SwizzleTest.cpp

@@ -29,14 +29,13 @@
 
 namespace Magnum { namespace Math { namespace Test {
 
-class SwizzleTest: public Corrade::TestSuite::Tester {
+struct SwizzleTest: Corrade::TestSuite::Tester {
-    public:
+    explicit SwizzleTest();
-        SwizzleTest();
+
-
+    void components();
-        void components();
+    void constants();
-        void constants();
+    void rgba();
-        void rgba();
+    void sizes();
-        void sizes();
 };
 
 typedef Vector<4, Int> Vector4i;

src/Magnum/Math/Test/TypeTraitsTest.cpp

@@ -30,16 +30,15 @@
 
 namespace Magnum { namespace Math { namespace Test {
 
-class TypeTraitsTest: public Corrade::TestSuite::Tester {
+struct TypeTraitsTest: Corrade::TestSuite::Tester {
-    public:
+    explicit TypeTraitsTest();
-        TypeTraitsTest();
+
-
+    void equalsIntegral();
-        void equalsIntegral();
+    void equalsFloatingPoint0();
-        void equalsFloatingPoint0();
+    void equalsFloatingPoint1();
-        void equalsFloatingPoint1();
+    void equalsFloatingPointLarge();
-        void equalsFloatingPointLarge();
+    void equalsFloatingPointInfinity();
-        void equalsFloatingPointInfinity();
+    void equalsFloatingPointNaN();
-        void equalsFloatingPointNaN();
 
     private:
         template<class> void _equalsIntegral();

src/Magnum/Math/Test/UnitTest.cpp

@@ -29,18 +29,17 @@
 
 namespace Magnum { namespace Math { namespace Test {
 
-class UnitTest: public Corrade::TestSuite::Tester {
+struct UnitTest: Corrade::TestSuite::Tester {
-    public:
+    explicit UnitTest();
-        explicit UnitTest();
+
-
+    void construct();
-        void construct();
+    void constructDefault();
-        void constructDefault();
+    void constructConversion();
-        void constructConversion();
+    void compare();
-        void compare();
+
-
+    void negated();
-        void negated();
+    void addSubtract();
-        void addSubtract();
+    void multiplyDivide();
-        void multiplyDivide();
 };
 
 UnitTest::UnitTest() {

src/Magnum/Math/Test/Vector2Test.cpp

@@ -51,29 +51,28 @@ template<> struct VectorConverter<2, float, Vec2> {
 
 namespace Test {
 
-class Vector2Test: public Corrade::TestSuite::Tester {
+struct Vector2Test: Corrade::TestSuite::Tester {
-    public:
+    explicit Vector2Test();
-        Vector2Test();
+
-
+    void construct();
-        void construct();
+    void constructDefault();
-        void constructDefault();
+    void constructOneValue();
-        void constructOneValue();
+    void constructConversion();
-        void constructConversion();
+    void constructCopy();
-        void constructCopy();
+
-
+    void convert();
-        void convert();
+
-
+    void access();
-        void access();
+    void cross();
-        void cross();
+    void axes();
-        void axes();
+    void scales();
-        void scales();
+    void perpendicular();
-        void perpendicular();
+    void aspectRatio();
-        void aspectRatio();
+    void minmax();
-        void minmax();
+
-
+    void swizzleType();
-        void swizzleType();
+    void debug();
-        void debug();
+    void configuration();
-        void configuration();
 };
 
 typedef Math::Vector3<Int> Vector3i;

src/Magnum/Math/Test/Vector3Test.cpp

@@ -51,28 +51,27 @@ template<> struct VectorConverter<3, float, Vec3> {
 
 namespace Test {
 
-class Vector3Test: public Corrade::TestSuite::Tester {
+struct Vector3Test: Corrade::TestSuite::Tester {
-    public:
+    explicit Vector3Test();
-        Vector3Test();
+
-
+    void construct();
-        void construct();
+    void constructDefault();
-        void constructDefault();
+    void constructOneValue();
-        void constructOneValue();
+    void constructParts();
-        void constructParts();
+    void constructConversion();
-        void constructConversion();
+    void constructCopy();
-        void constructCopy();
+
-
+    void convert();
-        void convert();
+
-
+    void access();
-        void access();
+    void cross();
-        void cross();
+    void axes();
-        void axes();
+    void scales();
-        void scales();
+    void twoComponent();
-        void twoComponent();
+
-
+    void swizzleType();
-        void swizzleType();
+    void debug();
-        void debug();
+    void configuration();
-        void configuration();
 };
 
 typedef Math::Vector3<Float> Vector3;

src/Magnum/Math/Test/Vector4Test.cpp

@@ -51,26 +51,25 @@ template<> struct VectorConverter<4, float, Vec4> {
 
 namespace Test {
 
-class Vector4Test: public Corrade::TestSuite::Tester {
+struct Vector4Test: Corrade::TestSuite::Tester {
-    public:
+    explicit Vector4Test();
-        Vector4Test();
+
-
+    void construct();
-        void construct();
+    void constructDefault();
-        void constructDefault();
+    void constructOneValue();
-        void constructOneValue();
+    void constructParts();
-        void constructParts();
+    void constructConversion();
-        void constructConversion();
+    void constructCopy();
-        void constructCopy();
+
-
+    void convert();
-        void convert();
+
-
+    void access();
-        void access();
+    void threeComponent();
-        void threeComponent();
+    void twoComponent();
-        void twoComponent();
+
-
+    void swizzleType();
-        void swizzleType();
+    void debug();
-        void debug();
+    void configuration();
-        void configuration();
 };
 
 typedef Math::Vector4<Float> Vector4;

src/Magnum/Math/Test/VectorTest.cpp

@@ -51,57 +51,56 @@ template<> struct VectorConverter<3, float, Vec3> {
 
 namespace Test {
 
-class VectorTest: public Corrade::TestSuite::Tester {
+struct VectorTest: Corrade::TestSuite::Tester {
-    public:
+    explicit VectorTest();
-        VectorTest();
+
-
+    void construct();
-        void construct();
+    void constructFromData();
-        void constructFromData();
+    void constructDefault();
-        void constructDefault();
+    void constructOneValue();
-        void constructOneValue();
+    void constructOneComponent();
-        void constructOneComponent();
+    void constructConversion();
-        void constructConversion();
+    void constructCopy();
-        void constructCopy();
+
-
+    void isZero();
-        void isZero();
+    void isNormalized();
-        void isNormalized();
+
-
+    void convert();
-        void convert();
+    void data();
-        void data();
+
-
+    void negative();
-        void negative();
+    void addSubtract();
-        void addSubtract();
+    void multiplyDivide();
-        void multiplyDivide();
+    void multiplyDivideIntegral();
-        void multiplyDivideIntegral();
+    void multiplyDivideComponentWise();
-        void multiplyDivideComponentWise();
+    void multiplyDivideComponentWiseIntegral();
-        void multiplyDivideComponentWiseIntegral();
+    void modulo();
-        void modulo();
+    void bitwise();
-        void bitwise();
+
-
+    void compare();
-        void compare();
+    void compareComponentWise();
-        void compareComponentWise();
+
-
+    void dot();
-        void dot();
+    void dotSelf();
-        void dotSelf();
+    void length();
-        void length();
+    void lengthInverted();
-        void lengthInverted();
+    void normalized();
-        void normalized();
+    void resized();
-        void resized();
+
-
+    void sum();
-        void sum();
+    void product();
-        void product();
+    void min();
-        void min();
+    void max();
-        void max();
+
-
+    void projected();
-        void projected();
+    void projectedOntoNormalized();
-        void projectedOntoNormalized();
+    void angle();
-        void angle();
+
-
+    void subclassTypes();
-        void subclassTypes();
+    void subclass();
-        void subclass();
+
-
+    void debug();
-        void debug();
+    void configuration();
-        void configuration();
 };
 
 typedef Math::Rad<Float> Rad;

src/Magnum/MeshTools/Test/CombineIndexedArraysTest.cpp

@@ -32,13 +32,12 @@
 
 namespace Magnum { namespace MeshTools { namespace Test {
 
-class CombineIndexedArraysTest: public TestSuite::Tester {
+struct CombineIndexedArraysTest: TestSuite::Tester {
-    public:
+    explicit CombineIndexedArraysTest();
-        CombineIndexedArraysTest();
 
-        void wrongIndexCount();
+    void wrongIndexCount();
-        void indexArrays();
+    void indexArrays();
-        void indexedArrays();
+    void indexedArrays();
 };
 
 CombineIndexedArraysTest::CombineIndexedArraysTest() {

src/Magnum/MeshTools/Test/CompressIndicesTest.cpp

@@ -31,13 +31,12 @@
 
 namespace Magnum { namespace MeshTools { namespace Test {
 
-class CompressIndicesTest: public TestSuite::Tester {
+struct CompressIndicesTest: TestSuite::Tester {
-    public:
+    explicit CompressIndicesTest();
-        CompressIndicesTest();
 
-        void compressChar();
+    void compressChar();
-        void compressShort();
+    void compressShort();
-        void compressInt();
+    void compressInt();
 };
 
 CompressIndicesTest::CompressIndicesTest() {

src/Magnum/MeshTools/Test/DuplicateTest.cpp

@@ -30,11 +30,10 @@
 
 namespace Magnum { namespace MeshTools { namespace Test {
 
-class DuplicateTest: public TestSuite::Tester {
+struct DuplicateTest: TestSuite::Tester {
-    public:
+    explicit DuplicateTest();
-        explicit DuplicateTest();
 
-        void duplicate();
+    void duplicate();
 };
 
 DuplicateTest::DuplicateTest() {

src/Magnum/MeshTools/Test/FlipNormalsTest.cpp

@@ -31,13 +31,12 @@
 
 namespace Magnum { namespace MeshTools { namespace Test {
 
-class FlipNormalsTest: public TestSuite::Tester {
+struct FlipNormalsTest: TestSuite::Tester {
-    public:
+    explicit FlipNormalsTest();
-        FlipNormalsTest();
 
-        void wrongIndexCount();
+    void wrongIndexCount();
-        void flipFaceWinding();
+    void flipFaceWinding();
-        void flipNormals();
+    void flipNormals();
 };
 
 FlipNormalsTest::FlipNormalsTest() {

src/Magnum/MeshTools/Test/GenerateFlatNormalsTest.cpp

@@ -31,12 +31,11 @@
 
 namespace Magnum { namespace MeshTools { namespace Test {
 
-class GenerateFlatNormalsTest: public TestSuite::Tester {
+struct GenerateFlatNormalsTest: TestSuite::Tester {
-    public:
+    explicit GenerateFlatNormalsTest();
-        GenerateFlatNormalsTest();
 
-        void wrongIndexCount();
+    void wrongIndexCount();
-        void generate();
+    void generate();
 };
 
 GenerateFlatNormalsTest::GenerateFlatNormalsTest() {

src/Magnum/MeshTools/Test/InterleaveTest.cpp

@@ -32,18 +32,17 @@
 
 namespace Magnum { namespace MeshTools { namespace Test {
 
-class InterleaveTest: public Corrade::TestSuite::Tester {
+struct InterleaveTest: Corrade::TestSuite::Tester {
-    public:
+    explicit InterleaveTest();
-        InterleaveTest();
+
-
+    void attributeCount();
-        void attributeCount();
+    void attributeCountGaps();
-        void attributeCountGaps();
+    void stride();
-        void stride();
+    void strideGaps();
-        void strideGaps();
+    void write();
-        void write();
+    void writeGaps();
-        void writeGaps();
+
-
+    void interleaveInto();
-        void interleaveInto();
 };
 
 InterleaveTest::InterleaveTest() {

src/Magnum/MeshTools/Test/RemoveDuplicatesTest.cpp

@@ -30,11 +30,10 @@
 
 namespace Magnum { namespace MeshTools { namespace Test {
 
-class RemoveDuplicatesTest: public TestSuite::Tester {
+struct RemoveDuplicatesTest: TestSuite::Tester {
-    public:
+    explicit RemoveDuplicatesTest();
-        RemoveDuplicatesTest();
 
-        void removeDuplicates();
+    void removeDuplicates();
 };
 
 RemoveDuplicatesTest::RemoveDuplicatesTest() {

src/Magnum/MeshTools/Test/SubdivideTest.cpp

@@ -31,12 +31,11 @@
 
 namespace Magnum { namespace MeshTools { namespace Test {
 
-class SubdivideTest: public TestSuite::Tester {
+struct SubdivideTest: TestSuite::Tester {
-    public:
+    explicit SubdivideTest();
-        SubdivideTest();
 
-        void wrongIndexCount();
+    void wrongIndexCount();
-        void subdivide();
+    void subdivide();
 };
 
 namespace {

src/Magnum/MeshTools/Test/TransformTest.cpp

@@ -32,15 +32,14 @@
 
 namespace Magnum { namespace MeshTools { namespace Test {
 
-class TransformTest: public TestSuite::Tester {
+struct TransformTest: TestSuite::Tester {
-    public:
+    explicit TransformTest();
-        explicit TransformTest();
 
-        void transformVectors2D();
+    void transformVectors2D();
-        void transformVectors3D();
+    void transformVectors3D();
 
-        void transformPoints2D();
+    void transformPoints2D();
-        void transformPoints3D();
+    void transformPoints3D();
 };
 
 TransformTest::TransformTest() {

src/Magnum/Primitives/Test/CapsuleTest.cpp

@@ -33,15 +33,14 @@
 
 namespace Magnum { namespace Primitives { namespace Test {
 
-class CapsuleTest: public TestSuite::Tester {
+struct CapsuleTest: TestSuite::Tester {
-    public:
+    explicit CapsuleTest();
-        CapsuleTest();
 
-        void wireframe2D();
+    void wireframe2D();
 
-        void solid3DWithoutTextureCoords();
+    void solid3DWithoutTextureCoords();
-        void solid3DWithTextureCoords();
+    void solid3DWithTextureCoords();
-        void wireframe3D();
+    void wireframe3D();
 };
 
 CapsuleTest::CapsuleTest() {

src/Magnum/Primitives/Test/CircleTest.cpp

@@ -31,12 +31,11 @@
 
 namespace Magnum { namespace Primitives { namespace Test {
 
-class CircleTest: public TestSuite::Tester {
+struct CircleTest: TestSuite::Tester {
-    public:
+    explicit CircleTest();
-        explicit CircleTest();
 
-        void solid();
+    void solid();
-        void wireframe();
+    void wireframe();
 };
 
 CircleTest::CircleTest() {

src/Magnum/Primitives/Test/CylinderTest.cpp

@@ -32,13 +32,12 @@
 
 namespace Magnum { namespace Primitives { namespace Test {
 
-class CylinderTest: public TestSuite::Tester {
+struct CylinderTest: TestSuite::Tester {
-    public:
+    explicit CylinderTest();
-        CylinderTest();
 
-        void solidWithoutAnything();
+    void solidWithoutAnything();
-        void solidWithTextureCoordsAndCaps();
+    void solidWithTextureCoordsAndCaps();
-        void wireframe();
+    void wireframe();
 };
 
 CylinderTest::CylinderTest() {

src/Magnum/Primitives/Test/IcosphereTest.cpp

@@ -31,11 +31,10 @@
 
 namespace Magnum { namespace Primitives { namespace Test {
 
-class IcosphereTest: public TestSuite::Tester {
+struct IcosphereTest: TestSuite::Tester {
-    public:
+    explicit IcosphereTest();
-        explicit IcosphereTest();
 
-        void count();
+    void count();
 };
 
 IcosphereTest::IcosphereTest() {

src/Magnum/Primitives/Test/UVSphereTest.cpp

@@ -32,13 +32,12 @@
 
 namespace Magnum { namespace Primitives { namespace Test {
 
-class UVSphereTest: public TestSuite::Tester {
+struct UVSphereTest: TestSuite::Tester {
-    public:
+    explicit UVSphereTest();
-        UVSphereTest();
 
-        void solidWithoutTextureCoords();
+    void solidWithoutTextureCoords();
-        void solidWithTextureCoords();
+    void solidWithTextureCoords();
-        void wireframe();
+    void wireframe();
 };
 
 UVSphereTest::UVSphereTest() {

src/Magnum/SceneGraph/Test/AnimableTest.cpp

@@ -32,18 +32,17 @@
 
 namespace Magnum { namespace SceneGraph { namespace Test {
 
-class AnimableTest: public TestSuite::Tester {
+struct AnimableTest: TestSuite::Tester {
-    public:
+    explicit AnimableTest();
-        AnimableTest();
 
-        void state();
+    void state();
-        void step();
+    void step();
-        void duration();
+    void duration();
-        void repeat();
+    void repeat();
-        void stop();
+    void stop();
-        void pause();
+    void pause();
 
-        void debug();
+    void debug();
 };
 
 typedef SceneGraph::Object<SceneGraph::MatrixTransformation3D> Object3D;

src/Magnum/SceneGraph/Test/CameraTest.cpp

@@ -35,18 +35,17 @@
 
 namespace Magnum { namespace SceneGraph { namespace Test {
 
-class CameraTest: public TestSuite::Tester {
+struct CameraTest: TestSuite::Tester {
-    public:
+    explicit CameraTest();
-        CameraTest();
+
-
+    void fixAspectRatio();
-        void fixAspectRatio();
+    void defaultProjection2D();
-        void defaultProjection2D();
+    void defaultProjection3D();
-        void defaultProjection3D();
+    void projectionSize2D();
-        void projectionSize2D();
+    void projectionSizeOrthographic();
-        void projectionSizeOrthographic();
+    void projectionSizePerspective();
-        void projectionSizePerspective();
+    void projectionSizeViewport();
-        void projectionSizeViewport();
+    void draw();
-        void draw();
 };
 
 typedef SceneGraph::Object<SceneGraph::MatrixTransformation2D> Object2D;

src/Magnum/SceneGraph/Test/DualComplexTransformationTest.cpp

@@ -34,21 +34,20 @@ namespace Magnum { namespace SceneGraph { namespace Test {
 typedef Object<DualComplexTransformation> Object2D;
 typedef Scene<DualComplexTransformation> Scene2D;
 
-class DualComplexTransformationTest: public TestSuite::Tester {
+struct DualComplexTransformationTest: TestSuite::Tester {
-    public:
+    explicit DualComplexTransformationTest();
-        explicit DualComplexTransformationTest();
+
-
+    void fromMatrix();
-        void fromMatrix();
+    void toMatrix();
-        void toMatrix();
+    void compose();
-        void compose();
+    void inverted();
-        void inverted();
+
-
+    void setTransformation();
-        void setTransformation();
+    void resetTransformation();
-        void resetTransformation();
+    void transform();
-        void transform();
+    void translate();
-        void translate();
+    void rotate();
-        void rotate();
+    void normalizeRotation();
-        void normalizeRotation();
 };
 
 DualComplexTransformationTest::DualComplexTransformationTest() {

src/Magnum/SceneGraph/Test/DualQuaternionTransformationTest.cpp

@@ -34,21 +34,20 @@ namespace Magnum { namespace SceneGraph { namespace Test {
 typedef Object<DualQuaternionTransformation> Object3D;
 typedef Scene<DualQuaternionTransformation> Scene3D;
 
-class DualQuaternionTransformationTest: public TestSuite::Tester {
+struct DualQuaternionTransformationTest: TestSuite::Tester {
-    public:
+    explicit DualQuaternionTransformationTest();
-        explicit DualQuaternionTransformationTest();
+
-
+    void fromMatrix();
-        void fromMatrix();
+    void toMatrix();
-        void toMatrix();
+    void compose();
-        void compose();
+    void inverted();
-        void inverted();
+
-
+    void setTransformation();
-        void setTransformation();
+    void resetTransformation();
-        void resetTransformation();
+    void transform();
-        void transform();
+    void translate();
-        void translate();
+    void rotate();
-        void rotate();
+    void normalizeRotation();
-        void normalizeRotation();
 };
 
 DualQuaternionTransformationTest::DualQuaternionTransformationTest() {

src/Magnum/SceneGraph/Test/MatrixTransformation2DTest.cpp

@@ -33,22 +33,21 @@ namespace Magnum { namespace SceneGraph { namespace Test {
 typedef Object<MatrixTransformation2D> Object2D;
 typedef Scene<MatrixTransformation2D> Scene2D;
 
-class MatrixTransformation2DTest: public TestSuite::Tester {
+struct MatrixTransformation2DTest: TestSuite::Tester {
-    public:
+    explicit MatrixTransformation2DTest();
-        explicit MatrixTransformation2DTest();
+
-
+    void fromMatrix();
-        void fromMatrix();
+    void toMatrix();
-        void toMatrix();
+    void compose();
-        void compose();
+    void inverted();
-        void inverted();
+
-
+    void setTransformation();
-        void setTransformation();
+    void resetTransformation();
-        void resetTransformation();
+    void transform();
-        void transform();
+    void translate();
-        void translate();
+    void rotate();
-        void rotate();
+    void scale();
-        void scale();
+    void reflect();
-        void reflect();
 };
 
 MatrixTransformation2DTest::MatrixTransformation2DTest() {

src/Magnum/SceneGraph/Test/MatrixTransformation3DTest.cpp

@@ -33,22 +33,21 @@ namespace Magnum { namespace SceneGraph { namespace Test {
 typedef Object<MatrixTransformation3D> Object3D;
 typedef Scene<MatrixTransformation3D> Scene3D;
 
-class MatrixTransformation3DTest: public TestSuite::Tester {
+struct MatrixTransformation3DTest: TestSuite::Tester {
-    public:
+    explicit MatrixTransformation3DTest();
-        explicit MatrixTransformation3DTest();
+
-
+    void fromMatrix();
-        void fromMatrix();
+    void toMatrix();
-        void toMatrix();
+    void compose();
-        void compose();
+    void inverted();
-        void inverted();
+
-
+    void setTransformation();
-        void setTransformation();
+    void resetTransformation();
-        void resetTransformation();
+    void transform();
-        void transform();
+    void translate();
-        void translate();
+    void rotate();
-        void rotate();
+    void scale();
-        void scale();
+    void reflect();
-        void reflect();
 };
 
 MatrixTransformation3DTest::MatrixTransformation3DTest() {

src/Magnum/SceneGraph/Test/ObjectTest.cpp

@@ -31,24 +31,23 @@
 
 namespace Magnum { namespace SceneGraph { namespace Test {
 
-class ObjectTest: public TestSuite::Tester {
+struct ObjectTest: TestSuite::Tester {
-    public:
+    explicit ObjectTest();
-        ObjectTest();
+
-
+    void parenting();
-        void parenting();
+    void scene();
-        void scene();
+    void setParentKeepTransformation();
-        void setParentKeepTransformation();
+    void absoluteTransformation();
-        void absoluteTransformation();
+    void transformations();
-        void transformations();
+    void transformationsRelative();
-        void transformationsRelative();
+    void transformationsOrphan();
-        void transformationsOrphan();
+    void transformationsDuplicate();
-        void transformationsDuplicate();
+    void setClean();
-        void setClean();
+    void setCleanListHierarchy();
-        void setCleanListHierarchy();
+    void setCleanListBulk();
-        void setCleanListBulk();
+
-
+    void rangeBasedForChildren();
-        void rangeBasedForChildren();
+    void rangeBasedForFeatures();
-        void rangeBasedForFeatures();
 };
 
 typedef SceneGraph::Object<SceneGraph::MatrixTransformation3D> Object3D;

src/Magnum/SceneGraph/Test/RigidMatrixTransformation2DTest.cpp

@@ -34,22 +34,21 @@ namespace Magnum { namespace SceneGraph { namespace Test {
 typedef Object<RigidMatrixTransformation2D> Object2D;
 typedef Scene<RigidMatrixTransformation2D> Scene2D;
 
-class RigidMatrixTransformation2DTest: public TestSuite::Tester {
+struct RigidMatrixTransformation2DTest: TestSuite::Tester {
-    public:
+    explicit RigidMatrixTransformation2DTest();
-        explicit RigidMatrixTransformation2DTest();
+
-
+    void fromMatrix();
-        void fromMatrix();
+    void toMatrix();
-        void toMatrix();
+    void compose();
-        void compose();
+    void inverted();
-        void inverted();
+
-
+    void setTransformation();
-        void setTransformation();
+    void resetTransformation();
-        void resetTransformation();
+    void transform();
-        void transform();
+    void translate();
-        void translate();
+    void rotate();
-        void rotate();
+    void reflect();
-        void reflect();
+    void normalizeRotation();
-        void normalizeRotation();
 };
 
 RigidMatrixTransformation2DTest::RigidMatrixTransformation2DTest() {

src/Magnum/SceneGraph/Test/RigidMatrixTransformation3DTest.cpp

@@ -34,22 +34,21 @@ namespace Magnum { namespace SceneGraph { namespace Test {
 typedef Object<RigidMatrixTransformation3D> Object3D;
 typedef Scene<RigidMatrixTransformation3D> Scene3D;
 
-class RigidMatrixTransformation3DTest: public TestSuite::Tester {
+struct RigidMatrixTransformation3DTest: TestSuite::Tester {
-    public:
+    explicit RigidMatrixTransformation3DTest();
-        explicit RigidMatrixTransformation3DTest();
+
-
+    void fromMatrix();
-        void fromMatrix();
+    void toMatrix();
-        void toMatrix();
+    void compose();
-        void compose();
+    void inverted();
-        void inverted();
+
-
+    void setTransformation();
-        void setTransformation();
+    void resetTransformation();
-        void resetTransformation();
+    void transform();
-        void transform();
+    void translate();
-        void translate();
+    void rotate();
-        void rotate();
+    void reflect();
-        void reflect();
+    void normalizeRotation();
-        void normalizeRotation();
 };
 
 RigidMatrixTransformation3DTest::RigidMatrixTransformation3DTest() {

src/Magnum/SceneGraph/Test/SceneTest.cpp

@@ -30,12 +30,11 @@
 
 namespace Magnum { namespace SceneGraph { namespace Test {
 
-class SceneTest: public TestSuite::Tester {
+struct SceneTest: TestSuite::Tester {
-    public:
+    explicit SceneTest();
-        SceneTest();
 
-        void transformation();
+    void transformation();
-        void parent();
+    void parent();
 };
 
 typedef SceneGraph::Scene<SceneGraph::MatrixTransformation3D> Scene3D;

src/Magnum/SceneGraph/Test/TranslationTransformationTest.cpp

@@ -35,21 +35,20 @@ namespace Magnum { namespace SceneGraph { namespace Test {
 typedef Object<TranslationTransformation2D> Object2D;
 typedef Scene<TranslationTransformation2D> Scene2D;
 
-class TranslationTransformationTest: public TestSuite::Tester {
+struct TranslationTransformationTest: TestSuite::Tester {
-    public:
+    explicit TranslationTransformationTest();
-        explicit TranslationTransformationTest();
 
-        void fromMatrix();
+    void fromMatrix();
-        void toMatrix();
+    void toMatrix();
-        void compose();
+    void compose();
-        void inverted();
+    void inverted();
 
-        void setTransformation();
+    void setTransformation();
-        void resetTransformation();
+    void resetTransformation();
-        void transform();
+    void transform();
-        void translate();
+    void translate();
 
-        void integral();
+    void integral();
 };
 
 TranslationTransformationTest::TranslationTransformationTest() {

src/Magnum/Shaders/Test/DistanceFieldVectorGLTest.cpp

@@ -32,12 +32,11 @@
 
 namespace Magnum { namespace Shaders { namespace Test {
 
-class DistanceFieldVectorGLTest: public Magnum::Test::AbstractOpenGLTester {
+struct DistanceFieldVectorGLTest: Magnum::Test::AbstractOpenGLTester {
-    public:
+    explicit DistanceFieldVectorGLTest();
-        explicit DistanceFieldVectorGLTest();
 
-        void compile2D();
+    void compile2D();
-        void compile3D();
+    void compile3D();
 };
 
 DistanceFieldVectorGLTest::DistanceFieldVectorGLTest() {

src/Magnum/Shaders/Test/FlatGLTest.cpp

@@ -32,14 +32,13 @@
 
 namespace Magnum { namespace Shaders { namespace Test {
 
-class FlatGLTest: public Magnum::Test::AbstractOpenGLTester {
+struct FlatGLTest: Magnum::Test::AbstractOpenGLTester {
-    public:
+    explicit FlatGLTest();
-        explicit FlatGLTest();
+
-
+    void compile2D();
-        void compile2D();
+    void compile3D();
-        void compile3D();
+    void compile2DTextured();
-        void compile2DTextured();
+    void compile3DTextured();
-        void compile3DTextured();
 };
 
 FlatGLTest::FlatGLTest() {

src/Magnum/Shaders/Test/MeshVisualizerGLTest.cpp

@@ -34,13 +34,12 @@
 
 namespace Magnum { namespace Shaders { namespace Test {
 
-class MeshVisualizerGLTest: public Magnum::Test::AbstractOpenGLTester {
+struct MeshVisualizerGLTest: Magnum::Test::AbstractOpenGLTester {
-    public:
+    explicit MeshVisualizerGLTest();
-        explicit MeshVisualizerGLTest();
 
-        void compile();
+    void compile();
-        void compileWireframeGeometryShader();
+    void compileWireframeGeometryShader();
-        void compileWireframeNoGeometryShader();
+    void compileWireframeNoGeometryShader();
 };
 
 MeshVisualizerGLTest::MeshVisualizerGLTest() {

src/Magnum/Shaders/Test/PhongGLTest.cpp

@@ -32,18 +32,17 @@
 
 namespace Magnum { namespace Shaders { namespace Test {
 
-class PhongGLTest: public Magnum::Test::AbstractOpenGLTester {
+struct PhongGLTest: Magnum::Test::AbstractOpenGLTester {
-    public:
+    explicit PhongGLTest();
-        explicit PhongGLTest();
+
-
+    void compile();
-        void compile();
+    void compileAmbientTexture();
-        void compileAmbientTexture();
+    void compileDiffuseTexture();
-        void compileDiffuseTexture();
+    void compileSpecularTexture();
-        void compileSpecularTexture();
+    void compileAmbientDiffuseTexture();
-        void compileAmbientDiffuseTexture();
+    void compileAmbientSpecularTexture();
-        void compileAmbientSpecularTexture();
+    void compileDiffuseSpecularTexture();
-        void compileDiffuseSpecularTexture();
+    void compileAmbientDiffuseSpecularTexture();
-        void compileAmbientDiffuseSpecularTexture();
 };
 
 PhongGLTest::PhongGLTest() {

src/Magnum/Shaders/Test/VectorGLTest.cpp

@@ -32,12 +32,11 @@
 
 namespace Magnum { namespace Shaders { namespace Test {
 
-class VectorGLTest: public Magnum::Test::AbstractOpenGLTester {
+struct VectorGLTest: Magnum::Test::AbstractOpenGLTester {
-    public:
+    explicit VectorGLTest();
-        explicit VectorGLTest();
 
-        void compile2D();
+    void compile2D();
-        void compile3D();
+    void compile3D();
 };
 
 VectorGLTest::VectorGLTest() {

src/Magnum/Shaders/Test/VertexColorGLTest.cpp

@@ -32,12 +32,11 @@
 
 namespace Magnum { namespace Shaders { namespace Test {
 
-class VertexColorGLTest: public Magnum::Test::AbstractOpenGLTester {
+struct VertexColorGLTest: Magnum::Test::AbstractOpenGLTester {
-    public:
+    explicit VertexColorGLTest();
-        explicit VertexColorGLTest();
 
-        void compile2D();
+    void compile2D();
-        void compile3D();
+    void compile3D();
 };
 
 VertexColorGLTest::VertexColorGLTest() {

src/Magnum/Shapes/Test/AxisAlignedBoxTest.cpp

@@ -32,12 +32,11 @@
 
 namespace Magnum { namespace Shapes { namespace Test {
 
-class AxisAlignedBoxTest: public TestSuite::Tester {
+struct AxisAlignedBoxTest: TestSuite::Tester {
-    public:
+    explicit AxisAlignedBoxTest();
-        AxisAlignedBoxTest();
 
-        void transformed();
+    void transformed();
-        void collisionPoint();
+    void collisionPoint();
 };
 
 AxisAlignedBoxTest::AxisAlignedBoxTest() {

src/Magnum/Shapes/Test/BoxTest.cpp

@@ -31,11 +31,10 @@
 
 namespace Magnum { namespace Shapes { namespace Test {
 
-class BoxTest: public TestSuite::Tester {
+struct BoxTest: TestSuite::Tester {
-    public:
+    explicit BoxTest();
-        BoxTest();
 
-        void transformed();
+    void transformed();
 };
 
 BoxTest::BoxTest() {

src/Magnum/Shapes/Test/CapsuleTest.cpp

@@ -34,14 +34,13 @@
 
 namespace Magnum { namespace Shapes { namespace Test {
 
-class CapsuleTest: public TestSuite::Tester {
+struct CapsuleTest: TestSuite::Tester {
-    public:
+    explicit CapsuleTest();
-        CapsuleTest();
+
-
+    void transformed();
-        void transformed();
+    void transformedAverageScaling();
-        void transformedAverageScaling();
+    void collisionPoint();
-        void collisionPoint();
+    void collisionSphere();
-        void collisionSphere();
 };
 
 CapsuleTest::CapsuleTest() {

src/Magnum/Shapes/Test/CollisionTest.cpp

@@ -30,12 +30,11 @@
 
 namespace Magnum { namespace Shapes { namespace Test {
 
-class CollisionTest: public TestSuite::Tester {
+struct CollisionTest: TestSuite::Tester {
-    public:
+    explicit CollisionTest();
-        explicit CollisionTest();
 
-        void boolConversion();
+    void boolConversion();
-        void flipped();
+    void flipped();
 };
 
 CollisionTest::CollisionTest() {

src/Magnum/Shapes/Test/CompositionTest.cpp

@@ -34,20 +34,19 @@
 
 namespace Magnum { namespace Shapes { namespace Test {
 
-class CompositionTest: public TestSuite::Tester {
+struct CompositionTest: TestSuite::Tester {
-    public:
+    explicit CompositionTest();
-        CompositionTest();
+
-
+    void negated();
-        void negated();
+    void anded();
-        void anded();
+    void ored();
-        void ored();
+    void multipleUnary();
-        void multipleUnary();
+    void hierarchy();
-        void hierarchy();
+    void empty();
-        void empty();
+
-
+    void copy();
-        void copy();
+    void move();
-        void move();
+    void transformed();
-        void transformed();
 };
 
 CompositionTest::CompositionTest() {

src/Magnum/Shapes/Test/CylinderTest.cpp

@@ -34,14 +34,13 @@
 
 namespace Magnum { namespace Shapes { namespace Test {
 
-class CylinderTest: public TestSuite::Tester {
+struct CylinderTest: TestSuite::Tester {
-    public:
+    explicit CylinderTest();
-        CylinderTest();
+
-
+    void transformed();
-        void transformed();
+    void transformedAverageScaling();
-        void transformedAverageScaling();
+    void collisionPoint();
-        void collisionPoint();
+    void collisionSphere();
-        void collisionSphere();
 };
 
 CylinderTest::CylinderTest() {

src/Magnum/Shapes/Test/LineTest.cpp

@@ -31,11 +31,10 @@
 
 namespace Magnum { namespace Shapes { namespace Test {
 
-class LineTest: public TestSuite::Tester {
+struct LineTest: TestSuite::Tester {
-    public:
+    explicit LineTest();
-        LineTest();
 
-        void transformed();
+    void transformed();
 };
 
 LineTest::LineTest() {

src/Magnum/Shapes/Test/PlaneTest.cpp

@@ -32,13 +32,12 @@
 
 namespace Magnum { namespace Shapes { namespace Test {
 
-class PlaneTest: public TestSuite::Tester {
+struct PlaneTest: TestSuite::Tester {
-    public:
+    explicit PlaneTest();
-        PlaneTest();
 
-        void transformed();
+    void transformed();
-        void collisionLine();
+    void collisionLine();
-        void collisionLineSegment();
+    void collisionLineSegment();
 };
 
 PlaneTest::PlaneTest() {

src/Magnum/Shapes/Test/PointTest.cpp

@@ -31,11 +31,10 @@
 
 namespace Magnum { namespace Shapes { namespace Test {
 
-class PointTest: public TestSuite::Tester {
+struct PointTest: TestSuite::Tester {
-    public:
+    explicit PointTest();
-        PointTest();
 
-        void transformed();
+    void transformed();
 };
 
 PointTest::PointTest() {

src/Magnum/Shapes/Test/ShapeImplementationTest.cpp

@@ -30,11 +30,10 @@
 
 namespace Magnum { namespace Shapes { namespace Test {
 
-class ShapeImplementationTest: public TestSuite::Tester {
+struct ShapeImplementationTest: TestSuite::Tester {
-    public:
+    explicit ShapeImplementationTest();
-        ShapeImplementationTest();
 
-        void debug();
+    void debug();
 };
 
 ShapeImplementationTest::ShapeImplementationTest() {

src/Magnum/Shapes/Test/ShapeTest.cpp

@@ -36,15 +36,14 @@
 
 namespace Magnum { namespace Shapes { namespace Test {
 
-class ShapeTest: public TestSuite::Tester {
+struct ShapeTest: TestSuite::Tester {
-    public:
+    explicit ShapeTest();
-        ShapeTest();
+
-
+    void clean();
-        void clean();
+    void collides();
-        void collides();
+    void collision();
-        void collision();
+    void firstCollision();
-        void firstCollision();
+    void shapeGroup();
-        void shapeGroup();
 };
 
 typedef SceneGraph::Scene<SceneGraph::MatrixTransformation2D> Scene2D;

src/Magnum/Shapes/Test/SphereTest.cpp

@@ -34,17 +34,16 @@
 
 namespace Magnum { namespace Shapes { namespace Test {
 
-class SphereTest: public TestSuite::Tester {
+struct SphereTest: TestSuite::Tester {
-    public:
+    explicit SphereTest();
-        SphereTest();
+
-
+    void transformed();
-        void transformed();
+    void collisionPoint();
-        void collisionPoint();
+    void collisionPointInverted();
-        void collisionPointInverted();
+    void collisionLine();
-        void collisionLine();
+    void collisionLineSegment();
-        void collisionLineSegment();
+    void collisionSphere();
-        void collisionSphere();
+    void collisionSphereInverted();
-        void collisionSphereInverted();
 };
 
 SphereTest::SphereTest() {

src/Magnum/Test/AbstractImageTest.cpp

@@ -32,15 +32,14 @@
 
 namespace Magnum { namespace Test {
 
-class AbstractImageTest: public TestSuite::Tester {
+struct AbstractImageTest: TestSuite::Tester {
-    public:
+    explicit AbstractImageTest();
-        explicit AbstractImageTest();
 
-        void pixelSize();
+    void pixelSize();
-        void dataSize();
+    void dataSize();
 
-        void debugFormat();
+    void debugFormat();
-        void debugType();
+    void debugType();
 };
 
 AbstractImageTest::AbstractImageTest() {

src/Magnum/Test/AbstractObjectGLTest.cpp

@@ -30,11 +30,10 @@
 
 namespace Magnum { namespace Test {
 
-class AbstractObjectGLTest: public AbstractOpenGLTester {
+struct AbstractObjectGLTest: AbstractOpenGLTester {
-    public:
+    explicit AbstractObjectGLTest();
-        explicit AbstractObjectGLTest();
 
-        void labelNoOp();
+    void labelNoOp();
 };
 
 AbstractObjectGLTest::AbstractObjectGLTest() {

src/Magnum/Test/AbstractQueryGLTest.cpp

@@ -28,15 +28,14 @@
 
 namespace Magnum { namespace Test {
 
-class AbstractQueryGLTest: public AbstractOpenGLTester {
+struct AbstractQueryGLTest: AbstractOpenGLTester {
-    public:
+    explicit AbstractQueryGLTest();
-        explicit AbstractQueryGLTest();
 
-        void construct();
+    void construct();
-        void constructCopy();
+    void constructCopy();
-        void constructMove();
+    void constructMove();
 
-        void label();
+    void label();
 };
 
 AbstractQueryGLTest::AbstractQueryGLTest() {

src/Magnum/Test/AbstractShaderProgramGLTest.cpp

@@ -35,26 +35,25 @@
 
 namespace Magnum { namespace Test {
 
-class AbstractShaderProgramGLTest: public AbstractOpenGLTester {
+struct AbstractShaderProgramGLTest: AbstractOpenGLTester {
-    public:
+    explicit AbstractShaderProgramGLTest();
-        explicit AbstractShaderProgramGLTest();
 
-        void construct();
+    void construct();
-        void constructCopy();
+    void constructCopy();
-        void constructMove();
+    void constructMove();
 
-        void label();
+    void label();
 
-        void create();
+    void create();
-        void createMultipleOutputs();
+    void createMultipleOutputs();
-        #ifndef MAGNUM_TARGET_GLES
+    #ifndef MAGNUM_TARGET_GLES
-        void createMultipleOutputsIndexed();
+    void createMultipleOutputsIndexed();
-        #endif
+    #endif
 
-        void uniform();
+    void uniform();
-        void uniformVector();
+    void uniformVector();
-        void uniformMatrix();
+    void uniformMatrix();
-        void uniformArray();
+    void uniformArray();
 };
 
 AbstractShaderProgramGLTest::AbstractShaderProgramGLTest() {

src/Magnum/Test/AbstractShaderProgramTest.cpp

@@ -29,28 +29,27 @@
 
 namespace Magnum { namespace Test {
 
-class AbstractShaderProgramTest: public TestSuite::Tester {
+struct AbstractShaderProgramTest: TestSuite::Tester {
-    public:
+    explicit AbstractShaderProgramTest();
-        explicit AbstractShaderProgramTest();
+
-
+    void attributeScalar();
-        void attributeScalar();
+    void attributeScalarInt();
-        void attributeScalarInt();
+    void attributeScalarUnsignedInt();
-        void attributeScalarUnsignedInt();
+    void attributeScalarDouble();
-        void attributeScalarDouble();
+
-
+    void attributeVector();
-        void attributeVector();
+    void attributeVectorInt();
-        void attributeVectorInt();
+    void attributeVectorUnsignedInt();
-        void attributeVectorUnsignedInt();
+    void attributeVectorDouble();
-        void attributeVectorDouble();
+    void attributeVector4();
-        void attributeVector4();
+    void attributeVectorBGRA();
-        void attributeVectorBGRA();
+
-
+    void attributeMatrixNxN();
-        void attributeMatrixNxN();
+    #ifndef MAGNUM_TARGET_GLES2
-        #ifndef MAGNUM_TARGET_GLES2
+    void attributeMatrixMxN();
-        void attributeMatrixMxN();
+    #endif
-        #endif
+    void attributeMatrixNxNd();
-        void attributeMatrixNxNd();
+    void attributeMatrixMxNd();
-        void attributeMatrixMxNd();
 };
 
 AbstractShaderProgramTest::AbstractShaderProgramTest() {

src/Magnum/Test/AbstractTextureGLTest.cpp

@@ -30,15 +30,14 @@
 
 namespace Magnum { namespace Test {
 
-class AbstractTextureGLTest: public AbstractOpenGLTester {
+struct AbstractTextureGLTest: AbstractOpenGLTester {
-    public:
+    explicit AbstractTextureGLTest();
-        explicit AbstractTextureGLTest();
 
-        void construct();
+    void construct();
-        void constructCopy();
+    void constructCopy();
-        void constructMove();
+    void constructMove();
 
-        void label();
+    void label();
 };
 
 AbstractTextureGLTest::AbstractTextureGLTest() {

src/Magnum/Test/ArrayTest.cpp

@@ -29,13 +29,12 @@
 
 namespace Magnum { namespace Test {
 
-class ArrayTest: public TestSuite::Tester {
+struct ArrayTest: TestSuite::Tester {
-    public:
+    explicit ArrayTest();
-        ArrayTest();
 
-        void construct();
+    void construct();
-        void equality();
+    void equality();
-        void access();
+    void access();
 };
 
 typedef Magnum::Array1D<Int> Array1D;

src/Magnum/Test/BufferGLTest.cpp

@@ -34,32 +34,31 @@
 
 namespace Magnum { namespace Test {
 
-class BufferGLTest: public AbstractOpenGLTester {
+struct BufferGLTest: AbstractOpenGLTester {
-    public:
+    explicit BufferGLTest();
-        explicit BufferGLTest();
+
-
+    void construct();
-        void construct();
+    void constructCopy();
-        void constructCopy();
+    void constructMove();
-        void constructMove();
+
-
+    void label();
-        void label();
+
-
+    #ifndef MAGNUM_TARGET_GLES2
-        #ifndef MAGNUM_TARGET_GLES2
+    void bindBase();
-        void bindBase();
+    void bindRange();
-        void bindRange();
+    #endif
-        #endif
+
-
+    void data();
-        void data();
+    void map();
-        void map();
+    #ifdef MAGNUM_TARGET_GLES2
-        #ifdef MAGNUM_TARGET_GLES2
+    void mapSub();
-        void mapSub();
+    #endif
-        #endif
+    void mapRange();
-        void mapRange();
+    void mapRangeExplicitFlush();
-        void mapRangeExplicitFlush();
+    #ifndef MAGNUM_TARGET_GLES2
-        #ifndef MAGNUM_TARGET_GLES2
+    void copy();
-        void copy();
+    #endif
-        #endif
+    void invalidate();
-        void invalidate();
 };
 
 BufferGLTest::BufferGLTest() {

src/Magnum/Test/BufferImageGLTest.cpp

@@ -31,15 +31,14 @@
 
 namespace Magnum { namespace Test {
 
-class BufferImageTest: public AbstractOpenGLTester {
+struct BufferImageTest: AbstractOpenGLTester {
-    public:
+    explicit BufferImageTest();
-        explicit BufferImageTest();
 
-        void construct();
+    void construct();
-        void constructCopy();
+    void constructCopy();
-        void constructMove();
+    void constructMove();
 
-        void setData();
+    void setData();
 };
 
 BufferImageTest::BufferImageTest() {

src/Magnum/Test/BufferTextureGLTest.cpp

@@ -31,14 +31,13 @@
 
 namespace Magnum { namespace Test {
 
-class BufferTextureGLTest: public AbstractOpenGLTester {
+struct BufferTextureGLTest: AbstractOpenGLTester {
-    public:
+    explicit BufferTextureGLTest();
-        explicit BufferTextureGLTest();
+
-
+    void construct();
-        void construct();
+    void bind();
-        void bind();
+    void setBuffer();
-        void setBuffer();
+    void setBufferOffset();
-        void setBufferOffset();
 };
 
 BufferTextureGLTest::BufferTextureGLTest() {

src/Magnum/Test/ColorTest.cpp

@@ -31,35 +31,34 @@
 
 namespace Magnum { namespace Test {
 
-class ColorTest: public TestSuite::Tester {
+struct ColorTest: TestSuite::Tester {
-    public:
+    explicit ColorTest();
-        ColorTest();
+
-
+    void construct();
-        void construct();
+    void constructDefault();
-        void constructDefault();
+    void constructOneValue();
-        void constructOneValue();
+    void constructParts();
-        void constructParts();
+    void constructConversion();
-        void constructConversion();
+    void constructNormalization();
-        void constructNormalization();
+    void constructCopy();
-        void constructCopy();
+
-
+    void colors();
-        void colors();
+
-
+    void fromHue();
-        void fromHue();
+    void fromSaturation();
-        void fromSaturation();
+    void fromValue();
-        void fromValue();
+
-
+    void hue();
-        void hue();
+    void saturation();
-        void saturation();
+    void value();
-        void value();
+
-
+    void hsv();
-        void hsv();
+    void hsvOverflow();
-        void hsvOverflow();
+    void hsvAlpha();
-        void hsvAlpha();
+
-
+    void swizzleType();
-        void swizzleType();
+    void debug();
-        void debug();
+    void configuration();
-        void configuration();
 };
 
 ColorTest::ColorTest() {

src/Magnum/Test/ContextGLTest.cpp

@@ -29,14 +29,13 @@
 
 namespace Magnum { namespace Test {
 
-class ContextGLTest: public AbstractOpenGLTester {
+struct ContextGLTest: AbstractOpenGLTester {
-    public:
+    explicit ContextGLTest();
-        explicit ContextGLTest();
+
-
+    void isVersionSupported();
-        void isVersionSupported();
+    void supportedVersion();
-        void supportedVersion();
+    void isExtensionSupported();
-        void isExtensionSupported();
+    void isExtensionDisabled();
-        void isExtensionDisabled();
 };
 
 ContextGLTest::ContextGLTest() {

src/Magnum/Test/ContextTest.cpp

@@ -30,11 +30,10 @@
 
 namespace Magnum { namespace Test {
 
-class ContextTest: public TestSuite::Tester {
+struct ContextTest: TestSuite::Tester {
-    public:
+    explicit ContextTest();
-        explicit ContextTest();
 
-        void debugFlag();
+    void debugFlag();
 };
 
 ContextTest::ContextTest() {

src/Magnum/Test/CubeMapTextureArrayGLTest.cpp

@@ -35,30 +35,29 @@
 
 namespace Magnum { namespace Test {
 
-class CubeMapTextureArrayGLTest: public AbstractOpenGLTester {
+struct CubeMapTextureArrayGLTest: AbstractOpenGLTester {
-    public:
+    explicit CubeMapTextureArrayGLTest();
-        explicit CubeMapTextureArrayGLTest();
 
-        void construct();
+    void construct();
-        void bind();
+    void bind();
 
-        void sampling();
+    void sampling();
-        void samplingSRGBDecode();
+    void samplingSRGBDecode();
-        void samplingBorderInteger();
+    void samplingBorderInteger();
-        void samplingSwizzle();
+    void samplingSwizzle();
-        void samplingDepthStencilMode();
+    void samplingDepthStencilMode();
 
-        void storage();
+    void storage();
 
-        void image();
+    void image();
-        void imageBuffer();
+    void imageBuffer();
-        void subImage();
+    void subImage();
-        void subImageBuffer();
+    void subImageBuffer();
 
-        void generateMipmap();
+    void generateMipmap();
 
-        void invalidateImage();
+    void invalidateImage();
-        void invalidateSubImage();
+    void invalidateSubImage();
 };
 
 CubeMapTextureArrayGLTest::CubeMapTextureArrayGLTest() {

src/Magnum/Test/CubeMapTextureGLTest.cpp

@@ -38,44 +38,43 @@
 
 namespace Magnum { namespace Test {
 
-class CubeMapTextureGLTest: public AbstractOpenGLTester {
+struct CubeMapTextureGLTest: AbstractOpenGLTester {
-    public:
+    explicit CubeMapTextureGLTest();
-        explicit CubeMapTextureGLTest();
+
-
+    void construct();
-        void construct();
+    void bind();
-        void bind();
+
-
+    void sampling();
-        void sampling();
+    void samplingSRGBDecode();
-        void samplingSRGBDecode();
+    #ifndef MAGNUM_TARGET_GLES2
-        #ifndef MAGNUM_TARGET_GLES2
+    void samplingSwizzle();
-        void samplingSwizzle();
+    #else
-        #else
+    void samplingMaxLevel();
-        void samplingMaxLevel();
+    void samplingCompare();
-        void samplingCompare();
+    #endif
-        #endif
+    #ifndef MAGNUM_TARGET_GLES
-        #ifndef MAGNUM_TARGET_GLES
+    void samplingBorderInteger();
-        void samplingBorderInteger();
+    #endif
-        #endif
+    #ifndef MAGNUM_TARGET_GLES2
-        #ifndef MAGNUM_TARGET_GLES2
+    void samplingDepthStencilMode();
-        void samplingDepthStencilMode();
+    #endif
-        #endif
+
-
+    void storage();
-        void storage();
+
-
+    void image();
-        void image();
+    #ifndef MAGNUM_TARGET_GLES2
-        #ifndef MAGNUM_TARGET_GLES2
+    void imageBuffer();
-        void imageBuffer();
+    #endif
-        #endif
+
-
+    void subImage();
-        void subImage();
+    #ifndef MAGNUM_TARGET_GLES2
-        #ifndef MAGNUM_TARGET_GLES2
+    void subImageBuffer();
-        void subImageBuffer();
+    #endif
-        #endif
+
-
+    void generateMipmap();
-        void generateMipmap();
+
-
+    void invalidateImage();
-        void invalidateImage();
+    void invalidateSubImage();
-        void invalidateSubImage();
 };
 
 CubeMapTextureGLTest::CubeMapTextureGLTest() {

src/Magnum/Test/DebugGLTest.cpp

@@ -36,17 +36,16 @@
 
 namespace Magnum { namespace Test {
 
-class DebugGLTest: public AbstractOpenGLTester {
+struct DebugGLTest: AbstractOpenGLTester {
-    public:
+    explicit DebugGLTest();
-        explicit DebugGLTest();
 
-        void insertMessageNoOp();
+    void insertMessageNoOp();
-        void insertMessage();
+    void insertMessage();
-        void insertMessageFallback();
+    void insertMessageFallback();
 
-        void setMessageEnabled();
+    void setMessageEnabled();
 
-        void deprecated();
+    void deprecated();
 };
 
 DebugGLTest::DebugGLTest() {

src/Magnum/Test/DebugMessageTest.cpp

@@ -30,13 +30,12 @@
 
 namespace Magnum { namespace Test {
 
-class DebugMessageTest: public TestSuite::Tester {
+struct DebugMessageTest: TestSuite::Tester {
-    public:
+    explicit DebugMessageTest();
-        explicit DebugMessageTest();
 
-        void debugSource();
+    void debugSource();
-        void debugType();
+    void debugType();
-        void debugSeverity();
+    void debugSeverity();
 };
 
 DebugMessageTest::DebugMessageTest() {

src/Magnum/Test/DefaultFramebufferTest.cpp

@@ -30,11 +30,10 @@
 
 namespace Magnum { namespace Test {
 
-class DefaultFramebufferTest: public TestSuite::Tester {
+struct DefaultFramebufferTest: TestSuite::Tester {
-    public:
+    explicit DefaultFramebufferTest();
-        explicit DefaultFramebufferTest();
 
-        void debugStatus();
+    void debugStatus();
 };
 
 DefaultFramebufferTest::DefaultFramebufferTest() {

src/Magnum/Test/FramebufferGLTest.cpp

@@ -49,52 +49,51 @@
 
 namespace Magnum { namespace Test {
 
-class FramebufferGLTest: public AbstractOpenGLTester {
+struct FramebufferGLTest: AbstractOpenGLTester {
-    public:
+    explicit FramebufferGLTest();
-        explicit FramebufferGLTest();
 
-        void construct();
+    void construct();
-        void constructCopy();
+    void constructCopy();
-        void constructMove();
+    void constructMove();
 
-        void label();
+    void label();
 
-        void attachRenderbuffer();
+    void attachRenderbuffer();
-        void attachRenderbufferMultisample();
+    void attachRenderbufferMultisample();
 
-        #ifndef MAGNUM_TARGET_GLES
+    #ifndef MAGNUM_TARGET_GLES
-        void attachTexture1D();
+    void attachTexture1D();
-        #endif
+    #endif
-        void attachTexture2D();
+    void attachTexture2D();
-        void attachTexture3D();
+    void attachTexture3D();
-        #ifndef MAGNUM_TARGET_GLES
+    #ifndef MAGNUM_TARGET_GLES
-        void attachTexture1DArray();
+    void attachTexture1DArray();
-        #endif
+    #endif
-        #ifndef MAGNUM_TARGET_GLES2
+    #ifndef MAGNUM_TARGET_GLES2
-        void attachTexture2DArray();
+    void attachTexture2DArray();
-        void attachTexture2DMultisample();
+    void attachTexture2DMultisample();
-        #endif
+    #endif
-        #ifndef MAGNUM_TARGET_GLES
+    #ifndef MAGNUM_TARGET_GLES
-        void attachTexture2DMultisampleArray();
+    void attachTexture2DMultisampleArray();
-        void attachRectangleTexture();
+    void attachRectangleTexture();
-        #endif
+    #endif
-        void attachCubeMapTexture();
+    void attachCubeMapTexture();
-        #ifndef MAGNUM_TARGET_GLES
+    #ifndef MAGNUM_TARGET_GLES
-        void attachCubeMapTextureArray();
+    void attachCubeMapTextureArray();
-        #endif
+    #endif
 
-        void multipleColorOutputs();
+    void multipleColorOutputs();
 
-        void clear();
+    void clear();
-        void invalidate();
+    void invalidate();
-        #ifndef MAGNUM_TARGET_GLES2
+    #ifndef MAGNUM_TARGET_GLES2
-        void invalidateSub();
+    void invalidateSub();
-        #endif
+    #endif
-        void read();
+    void read();
-        #ifndef MAGNUM_TARGET_GLES2
+    #ifndef MAGNUM_TARGET_GLES2
-        void readBuffer();
+    void readBuffer();
-        #endif
+    #endif
-        void blit();
+    void blit();
 
     #ifdef MAGNUM_TARGET_GLES2
     private:

src/Magnum/Test/FramebufferTest.cpp

@@ -30,11 +30,10 @@
 
 namespace Magnum { namespace Test {
 
-class FramebufferTest: public TestSuite::Tester {
+struct FramebufferTest: TestSuite::Tester {
-    public:
+    explicit FramebufferTest();
-        explicit FramebufferTest();
 
-        void debugStatus();
+    void debugStatus();
 };
 
 FramebufferTest::FramebufferTest() {

src/Magnum/Test/ImageReferenceTest.cpp

@@ -30,12 +30,11 @@
 
 namespace Magnum { namespace Test {
 
-class ImageReferenceTest: public TestSuite::Tester {
+struct ImageReferenceTest: TestSuite::Tester {
-    public:
+    explicit ImageReferenceTest();
-        explicit ImageReferenceTest();
 
-        void construct();
+    void construct();
-        void setData();
+    void setData();
 };
 
 ImageReferenceTest::ImageReferenceTest() {

src/Magnum/Test/ImageTest.cpp

@@ -30,17 +30,16 @@
 
 namespace Magnum { namespace Test {
 
-class ImageTest: public TestSuite::Tester {
+struct ImageTest: TestSuite::Tester {
-    public:
+    explicit ImageTest();
-        explicit ImageTest();
 
-        void construct();
+    void construct();
-        void constructCopy();
+    void constructCopy();
-        void constructMove();
+    void constructMove();
 
-        void setData();
+    void setData();
-        void toReference();
+    void toReference();
-        void release();
+    void release();
 };
 
 ImageTest::ImageTest() {

src/Magnum/Test/MeshGLTest.cpp

@@ -42,98 +42,97 @@ namespace Magnum { namespace Test {
 
 /* Tests also MeshView class. */
 
-class MeshGLTest: public AbstractOpenGLTester {
+struct MeshGLTest: AbstractOpenGLTester {
-    public:
+    explicit MeshGLTest();
-        explicit MeshGLTest();
 
-        void construct();
+    void construct();
-        void constructCopy();
+    void constructCopy();
-        void constructMove();
+    void constructMove();
 
-        void label();
+    void label();
 
-        #ifndef MAGNUM_TARGET_GLES2
+    #ifndef MAGNUM_TARGET_GLES2
-        void addVertexBufferUnsignedInt();
+    void addVertexBufferUnsignedInt();
-        void addVertexBufferInt();
+    void addVertexBufferInt();
-        #endif
+    #endif
-        void addVertexBufferFloat();
+    void addVertexBufferFloat();
-        #ifndef MAGNUM_TARGET_GLES
+    #ifndef MAGNUM_TARGET_GLES
-        void addVertexBufferDouble();
+    void addVertexBufferDouble();
-        #endif
+    #endif
-        #ifndef MAGNUM_TARGET_GLES2
+    #ifndef MAGNUM_TARGET_GLES2
-        void addVertexBufferVectorNui();
+    void addVertexBufferVectorNui();
-        void addVertexBufferVectorNi();
+    void addVertexBufferVectorNi();
-        #endif
+    #endif
-        void addVertexBufferVectorN();
+    void addVertexBufferVectorN();
-        #ifndef MAGNUM_TARGET_GLES
+    #ifndef MAGNUM_TARGET_GLES
-        void addVertexBufferVectorNd();
+    void addVertexBufferVectorNd();
-        #endif
+    #endif
-        void addVertexBufferMatrixNxN();
+    void addVertexBufferMatrixNxN();
-        #ifndef MAGNUM_TARGET_GLES
+    #ifndef MAGNUM_TARGET_GLES
-        void addVertexBufferMatrixNxNd();
+    void addVertexBufferMatrixNxNd();
-        #endif
+    #endif
-        #ifndef MAGNUM_TARGET_GLES2
+    #ifndef MAGNUM_TARGET_GLES2
-        void addVertexBufferMatrixMxN();
+    void addVertexBufferMatrixMxN();
-        #endif
+    #endif
-        #ifndef MAGNUM_TARGET_GLES
+    #ifndef MAGNUM_TARGET_GLES
-        void addVertexBufferMatrixMxNd();
+    void addVertexBufferMatrixMxNd();
-        #endif
+    #endif
 
-        #ifndef MAGNUM_TARGET_GLES2
+    #ifndef MAGNUM_TARGET_GLES2
-        void addVertexBufferUnsignedIntWithUnsignedShort();
+    void addVertexBufferUnsignedIntWithUnsignedShort();
-        void addVertexBufferUnsignedIntWithShort();
+    void addVertexBufferUnsignedIntWithShort();
-        void addVertexBufferIntWithUnsignedShort();
+    void addVertexBufferIntWithUnsignedShort();
-        void addVertexBufferIntWithShort();
+    void addVertexBufferIntWithShort();
-        #endif
+    #endif
-        /* Other Float types omitted (covered by addVertexBufferNormalized()) */
+    /* Other Float types omitted (covered by addVertexBufferNormalized()) */
-        void addVertexBufferFloatWithHalfFloat();
+    void addVertexBufferFloatWithHalfFloat();
-        #ifndef MAGNUM_TARGET_GLES
+    #ifndef MAGNUM_TARGET_GLES
-        void addVertexBufferFloatWithDouble();
+    void addVertexBufferFloatWithDouble();
-        void addVertexBufferVector3WithUnsignedInt10f11f11fRev();
+    void addVertexBufferVector3WithUnsignedInt10f11f11fRev();
-        #endif
+    #endif
-        #ifndef MAGNUM_TARGET_GLES2
+    #ifndef MAGNUM_TARGET_GLES2
-        void addVertexBufferVector4WithUnsignedInt2101010Rev();
+    void addVertexBufferVector4WithUnsignedInt2101010Rev();
-        void addVertexBufferVector4WithInt2101010Rev();
+    void addVertexBufferVector4WithInt2101010Rev();
-        #endif
+    #endif
 
-        void addVertexBufferLessVectorComponents();
+    void addVertexBufferLessVectorComponents();
-        void addVertexBufferNormalized();
+    void addVertexBufferNormalized();
-        #ifndef MAGNUM_TARGET_GLES
+    #ifndef MAGNUM_TARGET_GLES
-        void addVertexBufferBGRA();
+    void addVertexBufferBGRA();
-        #endif
+    #endif
 
-        void addVertexBufferMultiple();
+    void addVertexBufferMultiple();
-        void addVertexBufferMultipleGaps();
+    void addVertexBufferMultipleGaps();
 
-        void setIndexBuffer();
+    void setIndexBuffer();
-        void setIndexBufferRange();
+    void setIndexBufferRange();
-        void setIndexBufferUnsignedInt();
+    void setIndexBufferUnsignedInt();
 
-        #ifndef MAGNUM_TARGET_GLES
+    #ifndef MAGNUM_TARGET_GLES
-        void setBaseVertex();
+    void setBaseVertex();
-        #endif
+    #endif
-        void setInstanceCount();
+    void setInstanceCount();
-        void setInstanceCountIndexed();
+    void setInstanceCountIndexed();
-        #ifndef MAGNUM_TARGET_GLES
+    #ifndef MAGNUM_TARGET_GLES
-        void setInstanceCountBaseInstance();
+    void setInstanceCountBaseInstance();
-        void setInstanceCountBaseInstanceIndexed();
+    void setInstanceCountBaseInstanceIndexed();
-        void setInstanceCountBaseVertex();
+    void setInstanceCountBaseVertex();
-        void setInstanceCountBaseVertexBaseInstance();
+    void setInstanceCountBaseVertexBaseInstance();
-        #endif
+    #endif
 
-        void addVertexBufferInstancedFloat();
+    void addVertexBufferInstancedFloat();
-        #ifndef MAGNUM_TARGET_GLES2
+    #ifndef MAGNUM_TARGET_GLES2
-        void addVertexBufferInstancedInteger();
+    void addVertexBufferInstancedInteger();
-        #endif
+    #endif
-        #ifndef MAGNUM_TARGET_GLES
+    #ifndef MAGNUM_TARGET_GLES
-        void addVertexBufferInstancedDouble();
+    void addVertexBufferInstancedDouble();
-        #endif
+    #endif
 
-        void multiDraw();
+    void multiDraw();
-        void multiDrawIndexed();
+    void multiDrawIndexed();
-        #ifndef MAGNUM_TARGET_GLES
+    #ifndef MAGNUM_TARGET_GLES
-        void multiDrawBaseVertex();
+    void multiDrawBaseVertex();
-        #endif
+    #endif
 };
 
 MeshGLTest::MeshGLTest() {