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;
-typedef Vector3<Float> Vector3;
-typedef Matrix4<Float> Matrix4;
+using Magnum::Matrix3x3;
+using Magnum::Vector3;
+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;
-    typedef Math::Matrix3x3<Float> Matrix3x3;
-    typedef Math::Vector3<Float> Vector3;
+    using Magnum::Matrix4;
+    using Magnum::Matrix3x3;
+    using Magnum::Vector3;
 
     using namespace Math::Literals;
 
@@ -119,9 +119,9 @@ void SvdTest::decomposeRotationScaling() {
 }
 
 void SvdTest::decomposeRotationShear() {
-    typedef Math::Matrix4<Float> Matrix4;
-    typedef Math::Matrix3x3<Float> Matrix3x3;
-    typedef Math::Vector3<Float> Vector3;
+    using Magnum::Matrix4;
+    using Magnum::Matrix3x3;
+    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;
-typedef Math::Rad<Float> Rad;
-typedef Math::Deg<Double> Degd;
-typedef Math::Rad<Double> Radd;
+using Magnum::Deg;
+using Magnum::Rad;
+using Magnum::Degd;
+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;
-typedef Math::Vector2<Double> Vector2d;
+using Magnum::Vector2;
 typedef Math::Bezier<1, 2, Float> LinearBezier2D;
-typedef Math::QuadraticBezier2D<Float> QuadraticBezier2D;
-typedef Math::QuadraticBezier2D<Double> QuadraticBezier2Dd;
-typedef Math::CubicBezier2D<Float> CubicBezier2D;
-typedef Math::CubicHermite2D<Float> CubicHermite2D;
+using Magnum::QuadraticBezier2D;
+using Magnum::CubicBezier2D;
+using Magnum::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;
-typedef Math::Vector3<Float> Vector3;
-typedef Math::Vector3<UnsignedByte> Vector3ub;
-typedef Math::Vector3<UnsignedShort> Vector3us;
-typedef Math::Color3<Float> Color3;
-typedef Math::Color3<UnsignedByte> Color3ub;
-typedef Math::Color3<UnsignedShort> Color3us;
-
-typedef Math::Vector4<Float> Vector4;
-typedef Math::Vector4<UnsignedByte> Vector4ub;
-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 Magnum::Vector2;
+using Magnum::Vector3;
+using Magnum::Color3;
+
+using Magnum::Vector4;
+using Magnum::Color4;
+
+using Magnum::ColorHsv;
+
+using Magnum::Deg;
 
 using namespace Literals;
 

src/Magnum/Math/Test/ComplexTest.cpp

@@ -159,12 +159,12 @@ ComplexTest::ComplexTest() {
               &ComplexTest::debug});
 }
 
-typedef Math::Deg<Float> Deg;
-typedef Math::Rad<Float> Rad;
-typedef Math::Complex<Float> Complex;
-typedef Math::Vector2<Float> Vector2;
-typedef Math::Matrix3<Float> Matrix3;
-typedef Math::Matrix2x2<Float> Matrix2x2;
+using Magnum::Deg;
+using Magnum::Rad;
+using Magnum::Complex;
+using Magnum::Vector2;
+using Magnum::Matrix3;
+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;
-    typedef Math::Color4<Float> Color4;
+    using Magnum::Color3;
+    using Magnum::Color4;
 
     Utility::Configuration c;
 
@@ -191,8 +191,8 @@ void ConfigurationValueTest::color() {
 }
 
 void ConfigurationValueTest::rectangularMatrix() {
-    typedef Math::Vector4<Float> Vector4;
-    typedef Math::Matrix3x4<Float> Matrix3x4;
+    using Magnum::Vector4;
+    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;
-    typedef Math::Matrix4x4<Float> Matrix4x4;
+    using Magnum::Vector4;
+    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;
-    typedef Math::CubicBezier2D<Float> CubicBezier2D;
+    using Magnum::Vector2;
+    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;
-typedef Math::Vector3<Float> Vector3;
-typedef Math::Complex<Float> Complex;
-typedef Math::Quaternion<Float> Quaternion;
-typedef Math::CubicBezier2D<Float> CubicBezier2D;
-typedef Math::CubicHermite1D<Float> CubicHermite1D;
-typedef Math::CubicHermite2D<Float> CubicHermite2D;
-typedef Math::CubicHermiteComplex<Float> CubicHermiteComplex;
-typedef Math::CubicHermiteQuaternion<Float> CubicHermiteQuaternion;
+using Magnum::Vector2;
+using Magnum::Vector3;
+using Magnum::Complex;
+using Magnum::Quaternion;
+using Magnum::CubicBezier2D;
+using Magnum::CubicHermite1D;
+using Magnum::CubicHermite2D;
+using Magnum::CubicHermiteComplex;
+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;
-typedef Math::Vector3<Float> Vector3;
-typedef Math::Vector4<Float> Vector4;
-typedef Math::Constants<Float> Constants;
+using Magnum::Vector2;
+using Magnum::Vector3;
+using Magnum::Vector4;
+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;
-typedef Math::Rad<Float> Rad;
-typedef Math::Complex<Float> Complex;
+using Magnum::Deg;
+using Magnum::Rad;
+using Magnum::Complex;
 typedef Math::Dual<Float> Dual;
-typedef Math::DualComplex<Float> DualComplex;
-typedef Math::Matrix3<Float> Matrix3;
-typedef Math::Vector2<Float> Vector2;
+using Magnum::DualComplex;
+using Magnum::Matrix3;
+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;
-typedef Math::Rad<Float> Rad;
+using Magnum::Deg;
+using Magnum::Rad;
 typedef Math::Dual<Float> Dual;
-typedef Math::Matrix4<Float> Matrix4;
-typedef Math::DualQuaternion<Float> DualQuaternion;
-typedef Math::Quaternion<Float> Quaternion;
-typedef Math::Vector3<Float> Vector3;
+using Magnum::Matrix4;
+using Magnum::DualQuaternion;
+using Magnum::Quaternion;
+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;
-typedef Math::Rad<Float> Rad;
-typedef Math::Constants<Float> Constants;
+using Magnum::Deg;
+using Magnum::Rad;
+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;
-typedef Math::Matrix4<Float> Matrix4;
-typedef Math::Frustum<Float> Frustum;
-typedef Math::Frustum<Double> Frustumd;
+using Magnum::Vector4;
+using Magnum::Matrix4;
+using Magnum::Frustum;
 
 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;
-typedef Math::Vector2<Float> Vector2;
-typedef Math::Vector3<Int> Vector3i;
-typedef Math::Vector3<Float> Vector3;
+using Magnum::Constants;
+using Magnum::Vector2;
+using Magnum::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;
-typedef Math::Deg<Float> Deg;
-typedef Math::Rad<Float> Rad;
-typedef Math::Vector2<Float> Vector2;
-typedef Math::Vector3<Float> Vector3;
-typedef Math::Vector4<Float> Vector4;
-typedef Math::Vector3<UnsignedByte> Vector3ub;
-typedef Math::Vector3<Byte> Vector3b;
-typedef Math::Vector3<Int> Vector3i;
+using Magnum::Constants;
+using Magnum::Deg;
+using Magnum::Rad;
+using Magnum::Vector2;
+using Magnum::Vector3;
+using Magnum::Vector4;
 
 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;
-typedef Math::Vector3<Float> Vector3;
-typedef Math::Vector3<Double> Vector3d;
-typedef Math::Vector4<Float> Vector4;
-typedef Math::Matrix4<Float> Matrix4;
-typedef Math::Matrix4<Double> Matrix4d;
-typedef Math::Frustum<Float> Frustum;
-typedef Math::Constants<Float> Constants;
-typedef Math::Range3D<Float> Range3D;
-typedef Math::Rad<Float> Rad;
-typedef Math::Rad<Double> Radd;
+using Magnum::Vector2;
+using Magnum::Vector3;
+using Magnum::Vector4;
+using Magnum::Matrix4;
+using Magnum::Frustum;
+using Magnum::Constants;
+using Magnum::Range3D;
+using Magnum::Rad;
 
 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;
-typedef Math::Matrix2x2<Float> Matrix2x2;
-typedef Math::Matrix2x4<Float> Matrix2x4;
-typedef Math::Matrix3<Float> Matrix3;
+using Magnum::Deg;
+using Magnum::Matrix2x2;
+using Magnum::Matrix2x4;
+using Magnum::Matrix3;
 typedef Math::Matrix3<Int> Matrix3i;
-typedef Math::Vector2<Float> Vector2;
-typedef Math::Vector3<Float> Vector3;
+using Magnum::Vector2;
+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;
-typedef Math::Rad<Float> Rad;
-typedef Math::Matrix2x2<Float> Matrix2x2;
-typedef Math::Matrix2x3<Float> Matrix2x3;
-typedef Math::Matrix3x3<Float> Matrix3x3;
-typedef Math::Matrix4<Float> Matrix4;
+using Magnum::Deg;
+using Magnum::Rad;
+using Magnum::Matrix2x2;
+using Magnum::Matrix2x3;
+using Magnum::Matrix3x3;
+using Magnum::Matrix4;
 typedef Math::Matrix4<Int> Matrix4i;
-typedef Math::Vector2<Float> Vector2;
-typedef Math::Vector3<Float> Vector3;
-typedef Math::Vector4<Float> Vector4;
-typedef Math::Constants<Float> Constants;
+using Magnum::Vector2;
+using Magnum::Vector3;
+using Magnum::Vector4;
+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;
-typedef Math::Matrix2x3<Float> Matrix2x3;
-typedef Math::Matrix3x3<Float> Matrix3x3;
-typedef Math::Matrix4x4<Float> Matrix4x4;
+using Magnum::Matrix2x2;
+using Magnum::Matrix2x3;
+using Magnum::Matrix3x3;
+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;
-typedef Math::Vector2<UnsignedByte> Vector2ub;
-typedef Math::Vector2<UnsignedShort> Vector2us;
-typedef Math::Vector2<Byte> Vector2b;
-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;
+using Magnum::Constants;
+using Magnum::Vector2;
+using Magnum::Vector3;
+using Magnum::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;
-typedef Math::Vector3<Float> Vector3;
-typedef Math::Vector3<UnsignedByte> Vector3ub;
-typedef Math::Vector3<Byte> Vector3b;
+using Magnum::Rad;
+using Magnum::Vector3;
 
 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;
-typedef Math::Rad<Float> Rad;
-typedef Math::Matrix<3, Float> Matrix3x3;
-typedef Math::Matrix4<Float> Matrix4;
-typedef Math::Quaternion<Float> Quaternion;
-typedef Math::Vector3<Float> Vector3;
-typedef Math::Vector4<Float> Vector4;
+using Magnum::Deg;
+using Magnum::Rad;
+using Magnum::Matrix3x3;
+using Magnum::Matrix4;
+using Magnum::Quaternion;
+using Magnum::Vector3;
+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;
-typedef Math::Range2D<Float> Range2D;
-typedef Math::Range3D<Float> Range3D;
-typedef Math::Range1D<Int> Range1Di;
-typedef Math::Range2D<Int> Range2Di;
-typedef Math::Range3D<Int> Range3Di;
-typedef Vector2<Int> Vector2i;
-typedef Vector3<Int> Vector3i;
+using Magnum::Range1D;
+using Magnum::Range2D;
+using Magnum::Range3D;
 
 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;
-typedef Math::Vector2<Float> Vector2;
-typedef Math::Vector2<Int> Vector2i;
+using Magnum::Vector2;
 
 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;
-typedef Math::Vector3<Int> Vector3i;
-typedef Math::Vector2<Float> Vector2;
+using Magnum::Vector3;
+using Magnum::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;
-typedef Math::Vector4<Int> Vector4i;
-typedef Math::Vector3<Float> Vector3;
-typedef Math::Vector2<Float> Vector2;
+using Magnum::Vector4;
+using Magnum::Vector3;
+using Magnum::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;
-typedef Math::Rad<Float> Rad;
+using Magnum::Constants;
+using Magnum::Rad;
 typedef Vector<2, Float> Vector2;
 typedef Vector<2, Half> Vector2h;
 typedef Vector<3, Float> Vector3;