Math: rename test cases for consistency with other test files.

src/Magnum/Math/Test/BezierTest.cpp

@@ -77,7 +77,7 @@ struct BezierTest: TestSuite::Tester {
     void constructCopy();
     void convert();
 
-    void data();
+    void access();
 
     void compare();
 
@@ -102,7 +102,7 @@ BezierTest::BezierTest() {
               &BezierTest::constructCopy,
               &BezierTest::convert,
 
-              &BezierTest::data,
+              &BezierTest::access,
 
               &BezierTest::compare,
 
@@ -216,7 +216,7 @@ void BezierTest::convert() {
     CORRADE_VERIFY(!std::is_convertible<QuadraticBezier2D, QBezier2D>::value);
 }
 
-void BezierTest::data() {
+void BezierTest::access() {
     QuadraticBezier2D a{Vector2{0.5f, 1.0f}, Vector2{1.1f, 0.3f}, Vector2{0.1f, 1.2f}};
     a[0] = {};
     a[2] = {0.7f, 20.3f};

src/Magnum/Math/Test/BitVectorTest.cpp

@@ -65,7 +65,7 @@ struct BitVectorTest: TestSuite::Tester {
     void constructCopy();
     void convert();
 
-    void data();
+    void access();
 
     void compare();
     void compareUndefined();
@@ -98,7 +98,7 @@ BitVectorTest::BitVectorTest() {
               &BitVectorTest::constructCopy,
               &BitVectorTest::convert,
 
-              &BitVectorTest::data,
+              &BitVectorTest::access,
 
               &BitVectorTest::compare,
               &BitVectorTest::compareUndefined,
@@ -206,7 +206,7 @@ void BitVectorTest::convert() {
     CORRADE_VERIFY(!std::is_convertible<BitVector<3>, BVec3>::value);
 }
 
-void BitVectorTest::data() {
+void BitVectorTest::access() {
     /* 0b00001000, 0b00000011, 0b100 */
     constexpr BitVector19 ca(0x08, 0x03, 0x04);
 

src/Magnum/Math/Test/ColorTest.cpp

@@ -98,7 +98,7 @@ struct ColorTest: TestSuite::Tester {
     void constructHsvCopy();
     void compareHsv();
 
-    void data();
+    void access();
 
     void colors();
 
@@ -251,7 +251,7 @@ ColorTest::ColorTest() {
               &ColorTest::constructHsvCopy,
               &ColorTest::compareHsv,
 
-              &ColorTest::data,
+              &ColorTest::access,
 
               &ColorTest::colors,
 
@@ -729,7 +729,7 @@ void ColorTest::compareHsv() {
     CORRADE_VERIFY(ColorHsv{135.0_degf, 0.5f, 0.9f} != ColorHsv{135.0_degf, 0.5f, 0.9f + TypeTraits<Float>::epsilon()*2.0f});
 }
 
-void ColorTest::data() {
+void ColorTest::access() {
     Color4 c{1.0f, 2.0f, 3.0f, 4.0f};
     constexpr const Color4 cc{1.0f, 2.0f, 3.0f, 4.0f};
 

src/Magnum/Math/Test/ComplexTest.cpp

@@ -67,7 +67,7 @@ struct ComplexTest: TestSuite::Tester {
     void constructCopy();
     void convert();
 
-    void data();
+    void access();
 
     void compare();
     void isNormalized();
@@ -117,7 +117,7 @@ ComplexTest::ComplexTest() {
               &ComplexTest::constructCopy,
               &ComplexTest::convert,
 
-              &ComplexTest::data,
+              &ComplexTest::access,
 
               &ComplexTest::compare,
               &ComplexTest::isNormalized,
@@ -289,7 +289,7 @@ void ComplexTest::convert() {
     CORRADE_VERIFY(!std::is_convertible<Complex, Cmpl>::value);
 }
 
-void ComplexTest::data() {
+void ComplexTest::access() {
     constexpr Complex ca{1.5f, -3.5f};
     constexpr Float real = ca.real();
     constexpr Float imaginary = ca.imaginary();

src/Magnum/Math/Test/CubicHermiteTest.cpp

@@ -77,10 +77,10 @@ struct CubicHermiteTest: TestSuite::Tester {
     void constructCopyComplex();
     void constructCopyQuaternion();
 
-    void dataScalar();
-    void dataVector();
-    void dataComplex();
-    void dataQuaternion();
+    void accessScalar();
+    void accessVector();
+    void accessComplex();
+    void accessQuaternion();
 
     void compareScalar();
     void compareVector();
@@ -162,10 +162,10 @@ CubicHermiteTest::CubicHermiteTest() {
               &CubicHermiteTest::constructCopyComplex,
               &CubicHermiteTest::constructCopyQuaternion,
 
-              &CubicHermiteTest::dataScalar,
-              &CubicHermiteTest::dataVector,
-              &CubicHermiteTest::dataComplex,
-              &CubicHermiteTest::dataQuaternion,
+              &CubicHermiteTest::accessScalar,
+              &CubicHermiteTest::accessVector,
+              &CubicHermiteTest::accessComplex,
+              &CubicHermiteTest::accessQuaternion,
 
               &CubicHermiteTest::compareScalar,
               &CubicHermiteTest::compareVector,
@@ -658,7 +658,7 @@ void CubicHermiteTest::constructCopyQuaternion() {
     CORRADE_VERIFY(std::is_nothrow_copy_assignable<CubicHermiteQuaternion>::value);
 }
 
-void CubicHermiteTest::dataScalar() {
+void CubicHermiteTest::accessScalar() {
     constexpr CubicHermite1D ca{2.0f, -2.0f, -0.5f};
     constexpr Float inTangent = ca.inTangent();
     constexpr Float point = ca.point();
@@ -683,7 +683,7 @@ void CubicHermiteTest::dataScalar() {
     CORRADE_COMPARE(Containers::arraySize(ca.data()), 3);
 }
 
-void CubicHermiteTest::dataVector() {
+void CubicHermiteTest::accessVector() {
     constexpr CubicHermite2D ca{{1.0f, 2.0f}, {1.5f, -2.0f}, {3.0f, -0.5f}};
     constexpr Vector2 inTangent = ca.inTangent();
     constexpr Vector2 point = ca.point();
@@ -708,7 +708,7 @@ void CubicHermiteTest::dataVector() {
     CORRADE_COMPARE(Containers::arraySize(ca.data()), 3);
 }
 
-void CubicHermiteTest::dataComplex() {
+void CubicHermiteTest::accessComplex() {
     constexpr CubicHermiteComplex ca{{1.0f, 2.0f}, {1.5f, -2.0f}, {3.0f, -0.5f}};
     constexpr Complex inTangent = ca.inTangent();
     constexpr Complex point = ca.point();
@@ -733,7 +733,7 @@ void CubicHermiteTest::dataComplex() {
     CORRADE_COMPARE(Containers::arraySize(ca.data()), 3);
 }
 
-void CubicHermiteTest::dataQuaternion() {
+void CubicHermiteTest::accessQuaternion() {
     constexpr CubicHermiteQuaternion ca{
         {{1.0f, 2.0f, -1.0f}, 3.0f},
         {{1.5f, -2.0f, 0.1f}, 1.1f},

src/Magnum/Math/Test/DualComplexTest.cpp

@@ -68,7 +68,7 @@ struct DualComplexTest: TestSuite::Tester {
     void constructCopy();
     void convert();
 
-    void data();
+    void access();
 
     void isNormalized();
     template<class T> void isNormalizedEpsilonRotation();
@@ -125,7 +125,7 @@ DualComplexTest::DualComplexTest() {
               &DualComplexTest::constructCopy,
               &DualComplexTest::convert,
 
-              &DualComplexTest::data,
+              &DualComplexTest::access,
 
               &DualComplexTest::isNormalized,
               &DualComplexTest::isNormalizedEpsilonRotation<Float>,
@@ -286,7 +286,7 @@ void DualComplexTest::convert() {
     CORRADE_VERIFY(!std::is_convertible<DualComplex, DualCmpl>::value);
 }
 
-void DualComplexTest::data() {
+void DualComplexTest::access() {
     constexpr DualComplex ca{{-1.0f, 2.5f}, {3.0f, -7.5f}};
 
     constexpr Complex b = ca.real();

src/Magnum/Math/Test/DualQuaternionTest.cpp

@@ -71,7 +71,7 @@ struct DualQuaternionTest: TestSuite::Tester {
     void constructCopy();
     void convert();
 
-    void data();
+    void access();
 
     void isNormalized();
     template<class T> void isNormalizedEpsilonRotation();
@@ -135,7 +135,7 @@ DualQuaternionTest::DualQuaternionTest() {
               &DualQuaternionTest::constructCopy,
               &DualQuaternionTest::convert,
 
-              &DualQuaternionTest::data,
+              &DualQuaternionTest::access,
 
               &DualQuaternionTest::isNormalized,
               &DualQuaternionTest::isNormalizedEpsilonRotation<Float>,
@@ -319,7 +319,7 @@ void DualQuaternionTest::convert() {
     CORRADE_VERIFY(!std::is_convertible<DualQuaternion, DualQuat>::value);
 }
 
-void DualQuaternionTest::data() {
+void DualQuaternionTest::access() {
     constexpr DualQuaternion ca{{{1.0f, 2.0f, 3.0f}, -4.0f}, {{0.5f, -3.1f, 3.3f}, 2.0f}};
 
     constexpr Quaternion b = ca.real();

src/Magnum/Math/Test/DualTest.cpp

@@ -46,7 +46,7 @@ struct DualTest: TestSuite::Tester {
     void constructConversion();
     void constructCopy();
 
-    void data();
+    void access();
 
     void compare();
 
@@ -89,7 +89,7 @@ DualTest::DualTest() {
               &DualTest::constructConversion,
               &DualTest::constructCopy,
 
-              &DualTest::data,
+              &DualTest::access,
 
               &DualTest::compare,
 
@@ -199,7 +199,7 @@ void DualTest::constructCopy() {
     CORRADE_VERIFY(std::is_nothrow_copy_assignable<Dual>::value);
 }
 
-void DualTest::data() {
+void DualTest::access() {
     constexpr Dual ca{1.5f, -3.5f};
     constexpr Float real = ca.real();
     constexpr Float dual = ca.dual();

src/Magnum/Math/Test/FrustumTest.cpp

@@ -77,8 +77,8 @@ struct FrustumTest: TestSuite::Tester {
     void constructFromMatrix();
     void convert();
 
-    void data();
-    void dataOutOfRange();
+    void access();
+    void accessOutOfRange();
     void rangeFor();
 
     void compare();
@@ -101,8 +101,8 @@ FrustumTest::FrustumTest() {
               &FrustumTest::constructFromMatrix,
               &FrustumTest::convert,
 
-              &FrustumTest::data,
-              &FrustumTest::dataOutOfRange,
+              &FrustumTest::access,
+              &FrustumTest::accessOutOfRange,
               &FrustumTest::rangeFor,
 
               &FrustumTest::compare,
@@ -312,7 +312,7 @@ void FrustumTest::convert() {
     CORRADE_VERIFY(!std::is_convertible<Frustum, Frstm>::value);
 }
 
-void FrustumTest::data() {
+void FrustumTest::access() {
     /* Using default-constructed to verify that the planes are in correct order */
     constexpr Frustum ca;
 
@@ -352,7 +352,7 @@ void FrustumTest::data() {
     CORRADE_COMPARE(Containers::arraySize(ca.data()), 24);
 }
 
-void FrustumTest::dataOutOfRange() {
+void FrustumTest::accessOutOfRange() {
     CORRADE_SKIP_IF_NO_DEBUG_ASSERT();
 
     Frustum a;

src/Magnum/Math/Test/QuaternionTest.cpp

@@ -69,7 +69,7 @@ struct QuaternionTest: TestSuite::Tester {
     void constructCopy();
     void convert();
 
-    void data();
+    void access();
 
     void compare();
     void isNormalized();
@@ -154,7 +154,7 @@ QuaternionTest::QuaternionTest() {
               &QuaternionTest::constructCopy,
               &QuaternionTest::convert,
 
-              &QuaternionTest::data,
+              &QuaternionTest::access,
 
               &QuaternionTest::compare,
               &QuaternionTest::isNormalized,
@@ -339,7 +339,7 @@ void QuaternionTest::convert() {
     CORRADE_VERIFY(!std::is_convertible<Quaternion, Quat>::value);
 }
 
-void QuaternionTest::data() {
+void QuaternionTest::access() {
     Quaternion a{{1.0f, 2.0f, 3.0f}, -4.0f};
     CORRADE_COMPARE(a.vector(), (Vector3{1.0f, 2.0f, 3.0f}));
     CORRADE_COMPARE(a.scalar(), -4.0f);

src/Magnum/Math/Test/RectangularMatrixTest.cpp

@@ -75,7 +75,7 @@ struct RectangularMatrixTest: TestSuite::Tester {
     void constructCopy();
     void convert();
 
-    void data();
+    void access();
     void row();
 
     void compare();
@@ -144,7 +144,7 @@ RectangularMatrixTest::RectangularMatrixTest() {
               &RectangularMatrixTest::constructCopy,
               &RectangularMatrixTest::convert,
 
-              &RectangularMatrixTest::data,
+              &RectangularMatrixTest::access,
               &RectangularMatrixTest::row,
 
               &RectangularMatrixTest::compare,
@@ -519,7 +519,7 @@ void RectangularMatrixTest::convert() {
     CORRADE_VERIFY(!std::is_convertible<Matrix2x3, Mat2x3>::value);
 }
 
-void RectangularMatrixTest::data() {
+void RectangularMatrixTest::access() {
     Matrix3x4 a;
     Vector4 vector(4.0f, 5.0f, 6.0f, 7.0f);
 

src/Magnum/Math/Test/VectorTest.cpp

@@ -79,7 +79,7 @@ struct VectorTest: TestSuite::Tester {
     void isZeroHalf();
     void isNormalized();
 
-    void data();
+    void access();
 
     void promotedNegated();
     void addSubtract();
@@ -168,7 +168,7 @@ VectorTest::VectorTest() {
               &VectorTest::isZeroHalf,
               &VectorTest::isNormalized,
 
-              &VectorTest::data,
+              &VectorTest::access,
 
               &VectorTest::promotedNegated,
               &VectorTest::addSubtract,
@@ -459,7 +459,7 @@ void VectorTest::isNormalized() {
     CORRADE_VERIFY(Vector3(0.0f, 1.0f, 0.0f).isNormalized());
 }
 
-void VectorTest::data() {
+void VectorTest::access() {
     Vector4 a(4.0f, 5.0f, 6.0f, 7.0f);
     a[2] = 1.0f;
     a[3] = 1.5f;