Math: use Math typedefs from Magnum.h where possible in tests.

Instead of defining the same types and vaguely risking little
differences. Typedefs that don't exist in Magnum.h (such as integer
quaternions) and typedefs that differ from Magnum.h (such as
using Vector<4, T> instead of Vector4<T>) stay as typedefs, to make it
clear what *deliberately* differs and what not.

Typedefs that didn't conflict with the template types in Math (such as
Vector3us) are removed entirely, as the typedef from Magnum.h can be
used directly in that case, without any `using`.

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

@@ -41,9 +41,9 @@ struct QrTest: TestSuite::Tester {
 
 using namespace Math::Literals;
 
-typedef Matrix3x3<Float> Matrix3x3;
+using Magnum::Matrix3x3;
-typedef Vector3<Float> Vector3;
+using Magnum::Vector3;
-typedef Matrix4<Float> Matrix4;
+using Magnum::Matrix4;
 
 QrTest::QrTest() {
     addTests({&QrTest::test,

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

@@ -97,9 +97,9 @@ template<class T> void SvdTest::test() {
 }
 
 void SvdTest::decomposeRotationScaling() {
-    typedef Math::Matrix4<Float> Matrix4;
+    using Magnum::Matrix4;
-    typedef Math::Matrix3x3<Float> Matrix3x3;
+    using Magnum::Matrix3x3;
-    typedef Math::Vector3<Float> Vector3;
+    using Magnum::Vector3;
 
     using namespace Math::Literals;
 
@@ -119,9 +119,9 @@ void SvdTest::decomposeRotationScaling() {
 }
 
 void SvdTest::decomposeRotationShear() {
-    typedef Math::Matrix4<Float> Matrix4;
+    using Magnum::Matrix4;
-    typedef Math::Matrix3x3<Float> Matrix3x3;
+    using Magnum::Matrix3x3;
-    typedef Math::Vector3<Float> Vector3;
+    using Magnum::Vector3;
 
     using namespace Math::Literals;
 

src/Magnum/Math/Test/AngleTest.cpp

@@ -61,10 +61,10 @@ struct AngleTest: TestSuite::Tester {
     #endif
 };
 
-typedef Math::Deg<Float> Deg;
+using Magnum::Deg;
-typedef Math::Rad<Float> Rad;
+using Magnum::Rad;
-typedef Math::Deg<Double> Degd;
+using Magnum::Degd;
-typedef Math::Rad<Double> Radd;
+using Magnum::Radd;
 
 using namespace Literals;
 

src/Magnum/Math/Test/BezierTest.cpp

@@ -56,13 +56,11 @@ template<> struct BezierConverter<2, 2, Float, QBezier2D> {
 
 namespace Test { namespace {
 
-typedef Math::Vector2<Float> Vector2;
+using Magnum::Vector2;
-typedef Math::Vector2<Double> Vector2d;
 typedef Math::Bezier<1, 2, Float> LinearBezier2D;
-typedef Math::QuadraticBezier2D<Float> QuadraticBezier2D;
+using Magnum::QuadraticBezier2D;
-typedef Math::QuadraticBezier2D<Double> QuadraticBezier2Dd;
+using Magnum::CubicBezier2D;
-typedef Math::CubicBezier2D<Float> CubicBezier2D;
+using Magnum::CubicHermite2D;
-typedef Math::CubicHermite2D<Float> CubicHermite2D;
 
 struct BezierTest: TestSuite::Tester {
     explicit BezierTest();

src/Magnum/Math/Test/ColorTest.cpp

@@ -155,25 +155,16 @@ struct ColorTest: TestSuite::Tester {
     #endif
 };
 
-typedef Math::Vector2<Float> Vector2;
+using Magnum::Vector2;
-typedef Math::Vector3<Float> Vector3;
+using Magnum::Vector3;
-typedef Math::Vector3<UnsignedByte> Vector3ub;
+using Magnum::Color3;
-typedef Math::Vector3<UnsignedShort> Vector3us;
+
-typedef Math::Color3<Float> Color3;
+using Magnum::Vector4;
-typedef Math::Color3<UnsignedByte> Color3ub;
+using Magnum::Color4;
-typedef Math::Color3<UnsignedShort> Color3us;
+
-
+using Magnum::ColorHsv;
-typedef Math::Vector4<Float> Vector4;
+
-typedef Math::Vector4<UnsignedByte> Vector4ub;
+using Magnum::Deg;
-typedef Math::Vector4<Half> Vector4h;
-typedef Math::Color4<Float> Color4;
-typedef Math::Color4<Half> Color4h;
-typedef Math::Color4<UnsignedByte> Color4ub;
-typedef Math::Color4<UnsignedShort> Color4us;
-
-typedef Math::ColorHsv<Float> ColorHsv;
-
-typedef Math::Deg<Float> Deg;
 
 using namespace Literals;
 

src/Magnum/Math/Test/ComplexTest.cpp

@@ -159,12 +159,12 @@ ComplexTest::ComplexTest() {
               &ComplexTest::debug});
 }
 
-typedef Math::Deg<Float> Deg;
+using Magnum::Deg;
-typedef Math::Rad<Float> Rad;
+using Magnum::Rad;
-typedef Math::Complex<Float> Complex;
+using Magnum::Complex;
-typedef Math::Vector2<Float> Vector2;
+using Magnum::Vector2;
-typedef Math::Matrix3<Float> Matrix3;
+using Magnum::Matrix3;
-typedef Math::Matrix2x2<Float> Matrix2x2;
+using Magnum::Matrix2x2;
 
 using namespace Math::Literals;
 

src/Magnum/Math/Test/ConfigurationValueTest.cpp

@@ -84,7 +84,7 @@ ConfigurationValueTest::ConfigurationValueTest() {
 }
 
 void ConfigurationValueTest::deg() {
-    typedef Math::Deg<Float> Deg;
+    using Magnum::Deg;
 
     Utility::Configuration c;
 
@@ -97,7 +97,7 @@ void ConfigurationValueTest::deg() {
 }
 
 void ConfigurationValueTest::rad() {
-    typedef Math::Rad<Float> Rad;
+    using Magnum::Rad;
 
     Utility::Configuration c;
 
@@ -131,7 +131,7 @@ void ConfigurationValueTest::vector() {
 }
 
 void ConfigurationValueTest::vector2() {
-    typedef Math::Vector2<Float> Vector2;
+    using Magnum::Vector2;
 
     Utility::Configuration c;
 
@@ -144,7 +144,7 @@ void ConfigurationValueTest::vector2() {
 }
 
 void ConfigurationValueTest::vector3() {
-    typedef Math::Vector3<Float> Vector3;
+    using Magnum::Vector3;
 
     Utility::Configuration c;
 
@@ -157,7 +157,7 @@ void ConfigurationValueTest::vector3() {
 }
 
 void ConfigurationValueTest::vector4() {
-    typedef Math::Vector4<Float> Vector4;
+    using Magnum::Vector4;
 
     Utility::Configuration c;
 
@@ -170,8 +170,8 @@ void ConfigurationValueTest::vector4() {
 }
 
 void ConfigurationValueTest::color() {
-    typedef Math::Color3<Float> Color3;
+    using Magnum::Color3;
-    typedef Math::Color4<Float> Color4;
+    using Magnum::Color4;
 
     Utility::Configuration c;
 
@@ -191,8 +191,8 @@ void ConfigurationValueTest::color() {
 }
 
 void ConfigurationValueTest::rectangularMatrix() {
-    typedef Math::Vector4<Float> Vector4;
+    using Magnum::Vector4;
-    typedef Math::Matrix3x4<Float> Matrix3x4;
+    using Magnum::Matrix3x4;
 
     Matrix3x4 m(Vector4(3.0f,  5.0f, 8.0f,   4.0f),
                 Vector4(4.0f,  4.0f, 7.0f, 3.125f),
@@ -221,8 +221,8 @@ void ConfigurationValueTest::rectangularMatrix() {
 }
 
 void ConfigurationValueTest::matrix() {
-    typedef Math::Vector4<Float> Vector4;
+    using Magnum::Vector4;
-    typedef Math::Matrix4x4<Float> Matrix4x4;
+    using Magnum::Matrix4x4;
 
     Utility::Configuration c;
 
@@ -238,7 +238,7 @@ void ConfigurationValueTest::matrix() {
 }
 
 void ConfigurationValueTest::matrix3() {
-    typedef Math::Matrix3<Float> Matrix3;
+    using Magnum::Matrix3;
 
     Utility::Configuration c;
 
@@ -253,7 +253,7 @@ void ConfigurationValueTest::matrix3() {
 }
 
 void ConfigurationValueTest::matrix4() {
-    typedef Math::Matrix4<Float> Matrix4;
+    using Magnum::Matrix4;
 
     Utility::Configuration c;
 
@@ -269,7 +269,7 @@ void ConfigurationValueTest::matrix4() {
 }
 
 void ConfigurationValueTest::complex() {
-    typedef Math::Complex<Float> Complex;
+    using Magnum::Complex;
 
     Utility::Configuration c;
 
@@ -290,7 +290,7 @@ void ConfigurationValueTest::complex() {
 }
 
 void ConfigurationValueTest::dualComplex() {
-    typedef Math::DualComplex<Float> DualComplex;
+    using Magnum::DualComplex;
 
     Utility::Configuration c;
 
@@ -311,7 +311,7 @@ void ConfigurationValueTest::dualComplex() {
 }
 
 void ConfigurationValueTest::quaternion() {
-    typedef Math::Quaternion<Float> Quaternion;
+    using Magnum::Quaternion;
 
     Utility::Configuration c;
 
@@ -332,7 +332,7 @@ void ConfigurationValueTest::quaternion() {
 }
 
 void ConfigurationValueTest::dualQuaternion() {
-    typedef Math::DualQuaternion<Float> DualQuaternion;
+    using Magnum::DualQuaternion;
 
     Utility::Configuration c;
 
@@ -353,7 +353,7 @@ void ConfigurationValueTest::dualQuaternion() {
 }
 
 void ConfigurationValueTest::range() {
-    typedef Math::Range2D<Float> Range2D;
+    using Magnum::Range2D;
 
     Utility::Configuration c;
 
@@ -366,8 +366,8 @@ void ConfigurationValueTest::range() {
 }
 
 void ConfigurationValueTest::bezier() {
-    typedef Math::Vector2<Float> Vector2;
+    using Magnum::Vector2;
-    typedef Math::CubicBezier2D<Float> CubicBezier2D;
+    using Magnum::CubicBezier2D;
 
     Utility::Configuration c;
 

src/Magnum/Math/Test/CubicHermiteTest.cpp

@@ -209,15 +209,15 @@ CubicHermiteTest::CubicHermiteTest() {
 
 using namespace Math::Literals;
 
-typedef Math::Vector2<Float> Vector2;
+using Magnum::Vector2;
-typedef Math::Vector3<Float> Vector3;
+using Magnum::Vector3;
-typedef Math::Complex<Float> Complex;
+using Magnum::Complex;
-typedef Math::Quaternion<Float> Quaternion;
+using Magnum::Quaternion;
-typedef Math::CubicBezier2D<Float> CubicBezier2D;
+using Magnum::CubicBezier2D;
-typedef Math::CubicHermite1D<Float> CubicHermite1D;
+using Magnum::CubicHermite1D;
-typedef Math::CubicHermite2D<Float> CubicHermite2D;
+using Magnum::CubicHermite2D;
-typedef Math::CubicHermiteComplex<Float> CubicHermiteComplex;
+using Magnum::CubicHermiteComplex;
-typedef Math::CubicHermiteQuaternion<Float> CubicHermiteQuaternion;
+using Magnum::CubicHermiteQuaternion;
 
 void CubicHermiteTest::constructScalar() {
     constexpr CubicHermite1D a{2.0f, -2.0f, -0.5f};

src/Magnum/Math/Test/DistanceTest.cpp

@@ -50,10 +50,10 @@ struct DistanceTest: TestSuite::Tester {
     void pointPlaneNormalizedNotNormalized();
 };
 
-typedef Math::Vector2<Float> Vector2;
+using Magnum::Vector2;
-typedef Math::Vector3<Float> Vector3;
+using Magnum::Vector3;
-typedef Math::Vector4<Float> Vector4;
+using Magnum::Vector4;
-typedef Math::Constants<Float> Constants;
+using Magnum::Constants;
 
 DistanceTest::DistanceTest() {
     addTests({&DistanceTest::pointPoint2D,

src/Magnum/Math/Test/DualComplexTest.cpp

@@ -103,13 +103,13 @@ struct DualComplexTest: TestSuite::Tester {
 
 using namespace Math::Literals;
 
-typedef Math::Deg<Float> Deg;
+using Magnum::Deg;
-typedef Math::Rad<Float> Rad;
+using Magnum::Rad;
-typedef Math::Complex<Float> Complex;
+using Magnum::Complex;
 typedef Math::Dual<Float> Dual;
-typedef Math::DualComplex<Float> DualComplex;
+using Magnum::DualComplex;
-typedef Math::Matrix3<Float> Matrix3;
+using Magnum::Matrix3;
-typedef Math::Vector2<Float> Vector2;
+using Magnum::Vector2;
 
 DualComplexTest::DualComplexTest() {
     addTests({&DualComplexTest::construct,

src/Magnum/Math/Test/DualQuaternionTest.cpp

@@ -110,13 +110,13 @@ struct DualQuaternionTest: TestSuite::Tester {
     void debug();
 };
 
-typedef Math::Deg<Float> Deg;
+using Magnum::Deg;
-typedef Math::Rad<Float> Rad;
+using Magnum::Rad;
 typedef Math::Dual<Float> Dual;
-typedef Math::Matrix4<Float> Matrix4;
+using Magnum::Matrix4;
-typedef Math::DualQuaternion<Float> DualQuaternion;
+using Magnum::DualQuaternion;
-typedef Math::Quaternion<Float> Quaternion;
+using Magnum::Quaternion;
-typedef Math::Vector3<Float> Vector3;
+using Magnum::Vector3;
 
 using namespace Literals;
 

src/Magnum/Math/Test/DualTest.cpp

@@ -69,11 +69,11 @@ struct DualTest: TestSuite::Tester {
 };
 
 typedef Math::Dual<Float> Dual;
-typedef Math::Vector2<Float> Vector2;
+using Magnum::Vector2;
 typedef Math::Dual<Vector2> DualVector2;
-typedef Math::Deg<Float> Deg;
+using Magnum::Deg;
-typedef Math::Rad<Float> Rad;
+using Magnum::Rad;
-typedef Math::Constants<Float> Constants;
+using Magnum::Constants;
 
 using namespace Literals;
 

src/Magnum/Math/Test/FrustumTest.cpp

@@ -87,10 +87,9 @@ struct FrustumTest: TestSuite::Tester {
     void debug();
 };
 
-typedef Math::Vector4<Float> Vector4;
+using Magnum::Vector4;
-typedef Math::Matrix4<Float> Matrix4;
+using Magnum::Matrix4;
-typedef Math::Frustum<Float> Frustum;
+using Magnum::Frustum;
-typedef Math::Frustum<Double> Frustumd;
 
 FrustumTest::FrustumTest() {
     addTests({&FrustumTest::construct,

src/Magnum/Math/Test/FunctionsBatchTest.cpp

@@ -51,10 +51,9 @@ struct FunctionsBatchTest: TestSuite::Tester {
 
 using namespace Literals;
 
-typedef Math::Constants<Float> Constants;
+using Magnum::Constants;
-typedef Math::Vector2<Float> Vector2;
+using Magnum::Vector2;
-typedef Math::Vector3<Int> Vector3i;
+using Magnum::Vector3;
-typedef Math::Vector3<Float> Vector3;
 
 FunctionsBatchTest::FunctionsBatchTest() {
     addTests({&FunctionsBatchTest::isInf,

src/Magnum/Math/Test/FunctionsTest.cpp

@@ -90,15 +90,12 @@ struct FunctionsTest: TestSuite::Tester {
 
 using namespace Literals;
 
-typedef Math::Constants<Float> Constants;
+using Magnum::Constants;
-typedef Math::Deg<Float> Deg;
+using Magnum::Deg;
-typedef Math::Rad<Float> Rad;
+using Magnum::Rad;
-typedef Math::Vector2<Float> Vector2;
+using Magnum::Vector2;
-typedef Math::Vector3<Float> Vector3;
+using Magnum::Vector3;
-typedef Math::Vector4<Float> Vector4;
+using Magnum::Vector4;
-typedef Math::Vector3<UnsignedByte> Vector3ub;
-typedef Math::Vector3<Byte> Vector3b;
-typedef Math::Vector3<Int> Vector3i;
 
 FunctionsTest::FunctionsTest() {
     addRepeatedTests<FunctionsTest>({

src/Magnum/Math/Test/HalfTest.cpp

@@ -76,7 +76,7 @@ struct HalfTest: TestSuite::Tester {
     #endif
 };
 
-typedef Math::Constants<Float> Constants;
+using Magnum::Constants;
 
 using namespace Literals;
 

src/Magnum/Math/Test/IntersectionTest.cpp

@@ -59,17 +59,14 @@ struct IntersectionTest: TestSuite::Tester {
     void aabbCone();
 };
 
-typedef Math::Vector2<Float> Vector2;
+using Magnum::Vector2;
-typedef Math::Vector3<Float> Vector3;
+using Magnum::Vector3;
-typedef Math::Vector3<Double> Vector3d;
+using Magnum::Vector4;
-typedef Math::Vector4<Float> Vector4;
+using Magnum::Matrix4;
-typedef Math::Matrix4<Float> Matrix4;
+using Magnum::Frustum;
-typedef Math::Matrix4<Double> Matrix4d;
+using Magnum::Constants;
-typedef Math::Frustum<Float> Frustum;
+using Magnum::Range3D;
-typedef Math::Constants<Float> Constants;
+using Magnum::Rad;
-typedef Math::Range3D<Float> Range3D;
-typedef Math::Rad<Float> Rad;
-typedef Math::Rad<Double> Radd;
 
 IntersectionTest::IntersectionTest() {
     addTests({&IntersectionTest::pointCircle,

src/Magnum/Math/Test/Matrix3Test.cpp

@@ -104,13 +104,13 @@ struct Matrix3Test: TestSuite::Tester {
     void debug();
 };
 
-typedef Math::Deg<Float> Deg;
+using Magnum::Deg;
-typedef Math::Matrix2x2<Float> Matrix2x2;
+using Magnum::Matrix2x2;
-typedef Math::Matrix2x4<Float> Matrix2x4;
+using Magnum::Matrix2x4;
-typedef Math::Matrix3<Float> Matrix3;
+using Magnum::Matrix3;
 typedef Math::Matrix3<Int> Matrix3i;
-typedef Math::Vector2<Float> Vector2;
+using Magnum::Vector2;
-typedef Math::Vector3<Float> Vector3;
+using Magnum::Vector3;
 typedef Math::Vector<4, Float> Vector4; /* to avoid having to include Vector4 */
 
 Matrix3Test::Matrix3Test() {

src/Magnum/Math/Test/Matrix4Test.cpp

@@ -124,17 +124,17 @@ struct Matrix4Test: TestSuite::Tester {
     void debug();
 };
 
-typedef Math::Deg<Float> Deg;
+using Magnum::Deg;
-typedef Math::Rad<Float> Rad;
+using Magnum::Rad;
-typedef Math::Matrix2x2<Float> Matrix2x2;
+using Magnum::Matrix2x2;
-typedef Math::Matrix2x3<Float> Matrix2x3;
+using Magnum::Matrix2x3;
-typedef Math::Matrix3x3<Float> Matrix3x3;
+using Magnum::Matrix3x3;
-typedef Math::Matrix4<Float> Matrix4;
+using Magnum::Matrix4;
 typedef Math::Matrix4<Int> Matrix4i;
-typedef Math::Vector2<Float> Vector2;
+using Magnum::Vector2;
-typedef Math::Vector3<Float> Vector3;
+using Magnum::Vector3;
-typedef Math::Vector4<Float> Vector4;
+using Magnum::Vector4;
-typedef Math::Constants<Float> Constants;
+using Magnum::Constants;
 
 Matrix4Test::Matrix4Test() {
     addTests({&Matrix4Test::construct,

src/Magnum/Math/Test/MatrixTest.cpp

@@ -89,16 +89,16 @@ struct MatrixTest: TestSuite::Tester {
     void debug();
 };
 
-typedef Math::Matrix2x2<Float> Matrix2x2;
+using Magnum::Matrix2x2;
-typedef Math::Matrix2x3<Float> Matrix2x3;
+using Magnum::Matrix2x3;
-typedef Math::Matrix3x3<Float> Matrix3x3;
+using Magnum::Matrix3x3;
-typedef Math::Matrix4x4<Float> Matrix4x4;
+using Magnum::Matrix4x4;
 typedef Math::Matrix4x4<Int> Matrix4x4i;
 typedef Math::Vector<2, Float> Vector2;
 typedef Math::Vector<3, Float> Vector3;
 typedef Math::Vector<4, Float> Vector4;
 typedef Math::Vector<4, Int> Vector4i;
-typedef Math::Constants<Float> Constants;
+using Magnum::Constants;
 
 MatrixTest::MatrixTest() {
     addTests({&MatrixTest::construct,

src/Magnum/Math/Test/PackingBatchTest.cpp

@@ -155,17 +155,10 @@ PackingBatchTest::PackingBatchTest() {
               &PackingBatchTest::assertionsCast<Double, Double>});
 }
 
-typedef Math::Constants<Float> Constants;
+using Magnum::Constants;
-typedef Math::Vector2<UnsignedByte> Vector2ub;
+using Magnum::Vector2;
-typedef Math::Vector2<UnsignedShort> Vector2us;
+using Magnum::Vector3;
-typedef Math::Vector2<Byte> Vector2b;
+using Magnum::Vector4;
-typedef Math::Vector2<Short> Vector2s;
-typedef Math::Vector2<Float> Vector2;
-typedef Math::Vector2<UnsignedInt> Vector2ui;
-typedef Math::Vector2<Int> Vector2i;
-typedef Math::Vector3<Float> Vector3;
-typedef Math::Vector4<UnsignedShort> Vector4us;
-typedef Math::Vector4<Float> Vector4;
 
 void PackingBatchTest::unpackUnsignedByte() {
     /* Test data adapted from PackingTest */

src/Magnum/Math/Test/PackingTest.cpp

@@ -53,10 +53,8 @@ struct PackingTest: TestSuite::Tester {
 
 using namespace Literals;
 
-typedef Math::Rad<Float> Rad;
+using Magnum::Rad;
-typedef Math::Vector3<Float> Vector3;
+using Magnum::Vector3;
-typedef Math::Vector3<UnsignedByte> Vector3ub;
-typedef Math::Vector3<Byte> Vector3b;
 
 PackingTest::PackingTest() {
     addTests({&PackingTest::bitMax,

src/Magnum/Math/Test/QuaternionTest.cpp

@@ -129,13 +129,13 @@ struct QuaternionTest: TestSuite::Tester {
     void debug();
 };
 
-typedef Math::Deg<Float> Deg;
+using Magnum::Deg;
-typedef Math::Rad<Float> Rad;
+using Magnum::Rad;
-typedef Math::Matrix<3, Float> Matrix3x3;
+using Magnum::Matrix3x3;
-typedef Math::Matrix4<Float> Matrix4;
+using Magnum::Matrix4;
-typedef Math::Quaternion<Float> Quaternion;
+using Magnum::Quaternion;
-typedef Math::Vector3<Float> Vector3;
+using Magnum::Vector3;
-typedef Math::Vector4<Float> Vector4;
+using Magnum::Vector4;
 
 using namespace Math::Literals;
 

src/Magnum/Math/Test/RangeTest.cpp

@@ -146,14 +146,9 @@ struct RangeTest: TestSuite::Tester {
     void debug();
 };
 
-typedef Math::Range1D<Float> Range1D;
+using Magnum::Range1D;
-typedef Math::Range2D<Float> Range2D;
+using Magnum::Range2D;
-typedef Math::Range3D<Float> Range3D;
+using Magnum::Range3D;
-typedef Math::Range1D<Int> Range1Di;
-typedef Math::Range2D<Int> Range2Di;
-typedef Math::Range3D<Int> Range3Di;
-typedef Vector2<Int> Vector2i;
-typedef Vector3<Int> Vector3i;
 
 RangeTest::RangeTest() {
     addTests({&RangeTest::construct,

src/Magnum/Math/Test/UnitTest.cpp

@@ -67,7 +67,7 @@ UnitTest::UnitTest() {
 template<class> struct Sec_;
 typedef Unit<Sec_, Float> Sec;
 typedef Unit<Sec_, Int> Seci;
-typedef Constants<Float> Constants;
+using Magnum::Constants;
 
 inline Debug& operator<<(Debug& debug, Sec value) {
     return debug << Float(value);

src/Magnum/Math/Test/Vector2Test.cpp

@@ -77,9 +77,7 @@ struct Vector2Test: TestSuite::Tester {
     void debug();
 };
 
-typedef Math::Vector3<Int> Vector3i;
+using Magnum::Vector2;
-typedef Math::Vector2<Float> Vector2;
-typedef Math::Vector2<Int> Vector2i;
 
 Vector2Test::Vector2Test() {
     addTests({&Vector2Test::construct,

src/Magnum/Math/Test/Vector3Test.cpp

@@ -77,9 +77,8 @@ struct Vector3Test: TestSuite::Tester {
     void debug();
 };
 
-typedef Math::Vector3<Float> Vector3;
+using Magnum::Vector3;
-typedef Math::Vector3<Int> Vector3i;
+using Magnum::Vector2;
-typedef Math::Vector2<Float> Vector2;
 
 Vector3Test::Vector3Test() {
     addTests({&Vector3Test::construct,

src/Magnum/Math/Test/Vector4Test.cpp

@@ -79,10 +79,9 @@ struct Vector4Test: TestSuite::Tester {
     void debug();
 };
 
-typedef Math::Vector4<Float> Vector4;
+using Magnum::Vector4;
-typedef Math::Vector4<Int> Vector4i;
+using Magnum::Vector3;
-typedef Math::Vector3<Float> Vector3;
+using Magnum::Vector2;
-typedef Math::Vector2<Float> Vector2;
 
 Vector4Test::Vector4Test() {
     addTests({&Vector4Test::construct,

src/Magnum/Math/Test/VectorTest.cpp

@@ -120,8 +120,8 @@ struct VectorTest: TestSuite::Tester {
     void debugPacked();
 };
 
-typedef Math::Constants<Float> Constants;
+using Magnum::Constants;
-typedef Math::Rad<Float> Rad;
+using Magnum::Rad;
 typedef Vector<2, Float> Vector2;
 typedef Vector<2, Half> Vector2h;
 typedef Vector<3, Float> Vector3;