FCL/sf/mw/qt: comparison tests/auto/qvectornd/tst

equal deleted inserted replaced

-:41300fa6a67c
+:f7bc934e204c
 /****************************************************************************
 **
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the test suite of the Qt Toolkit.
 **
 #include <QtCore/qmath.h>
 #include <QtGui/qvector2d.h>
 #include <QtGui/qvector3d.h>
 #include <QtGui/qvector4d.h>
-class tst_QVector : public QObject
+class tst_QVectorND : public QObject
 {
 Q_OBJECT
 public:
-tst_QVector() {}
+tst_QVectorND() {}
-~tst_QVector() {}
+~tst_QVectorND() {}
 private slots:
 void create2();
 void create3();
 void create4();
 return qFuzzyIsNull((float)(x - y));
 }
 // Test the creation of QVector2D objects in various ways:
 // construct, copy, and modify.
-void tst_QVector::create2()
+void tst_QVectorND::create2()
 {
 QVector2D null;
 QCOMPARE(null.x(), (qreal)0.0f);
 QCOMPARE(null.y(), (qreal)0.0f);
 QVERIFY(null.isNull());
 QCOMPARE(v10.w(), (qreal)0.0f);
 }
 // Test the creation of QVector3D objects in various ways:
 // construct, copy, and modify.
-void tst_QVector::create3()
+void tst_QVectorND::create3()
 {
 QVector3D null;
 QCOMPARE(null.x(), (qreal)0.0f);
 QCOMPARE(null.y(), (qreal)0.0f);
 QCOMPARE(null.z(), (qreal)0.0f);
 QCOMPARE(v11.w(), (qreal)0.0f);
 }
 // Test the creation of QVector4D objects in various ways:
 // construct, copy, and modify.
-void tst_QVector::create4()
+void tst_QVectorND::create4()
 {
 QVector4D null;
 QCOMPARE(null.x(), (qreal)0.0f);
 QCOMPARE(null.y(), (qreal)0.0f);
 QCOMPARE(null.z(), (qreal)0.0f);
 v14 = zerow.toVector3DAffine();
 QVERIFY(v14.isNull());
 }
 // Test vector length computation for 2D vectors.
-void tst_QVector::length2_data()
+void tst_QVectorND::length2_data()
 {
 QTest::addColumn<qreal>("x");
 QTest::addColumn<qreal>("y");
 QTest::addColumn<qreal>("len");
 QTest::newRow("1y") << (qreal)0.0f << (qreal)1.0f << (qreal)1.0f;
 QTest::newRow("-1x") << (qreal)-1.0f << (qreal)0.0f << (qreal)1.0f;
 QTest::newRow("-1y") << (qreal)0.0f << (qreal)-1.0f << (qreal)1.0f;
 QTest::newRow("two") << (qreal)2.0f << (qreal)-2.0f << (qreal)qSqrt(8.0f);
 }
-void tst_QVector::length2()
+void tst_QVectorND::length2()
 {
 QFETCH(qreal, x);
 QFETCH(qreal, y);
 QFETCH(qreal, len);
 QCOMPARE(v.length(), len);
 QCOMPARE(v.lengthSquared(), x * x + y * y);
 }
 // Test vector length computation for 3D vectors.
-void tst_QVector::length3_data()
+void tst_QVectorND::length3_data()
 {
 QTest::addColumn<qreal>("x");
 QTest::addColumn<qreal>("y");
 QTest::addColumn<qreal>("z");
 QTest::addColumn<qreal>("len");
 QTest::newRow("-1x") << (qreal)-1.0f << (qreal)0.0f << (qreal)0.0f << (qreal)1.0f;
 QTest::newRow("-1y") << (qreal)0.0f << (qreal)-1.0f << (qreal)0.0f << (qreal)1.0f;
 QTest::newRow("-1z") << (qreal)0.0f << (qreal)0.0f << (qreal)-1.0f << (qreal)1.0f;
 QTest::newRow("two") << (qreal)2.0f << (qreal)-2.0f << (qreal)2.0f << (qreal)qSqrt(12.0f);
 }
-void tst_QVector::length3()
+void tst_QVectorND::length3()
 {
 QFETCH(qreal, x);
 QFETCH(qreal, y);
 QFETCH(qreal, z);
 QFETCH(qreal, len);
 QCOMPARE(v.length(), len);
 QCOMPARE(v.lengthSquared(), x * x + y * y + z * z);
 }
 // Test vector length computation for 4D vectors.
-void tst_QVector::length4_data()
+void tst_QVectorND::length4_data()
 {
 QTest::addColumn<qreal>("x");
 QTest::addColumn<qreal>("y");
 QTest::addColumn<qreal>("z");
 QTest::addColumn<qreal>("w");
 QTest::newRow("-1y") << (qreal)0.0f << (qreal)-1.0f << (qreal)0.0f << (qreal)0.0f << (qreal)1.0f;
 QTest::newRow("-1z") << (qreal)0.0f << (qreal)0.0f << (qreal)-1.0f << (qreal)0.0f << (qreal)1.0f;
 QTest::newRow("-1w") << (qreal)0.0f << (qreal)0.0f << (qreal)0.0f << (qreal)-1.0f << (qreal)1.0f;
 QTest::newRow("two") << (qreal)2.0f << (qreal)-2.0f << (qreal)2.0f << (qreal)2.0f << (qreal)qSqrt(16.0f);
 }
-void tst_QVector::length4()
+void tst_QVectorND::length4()
 {
 QFETCH(qreal, x);
 QFETCH(qreal, y);
 QFETCH(qreal, z);
 QFETCH(qreal, w);
 QCOMPARE(v.length(), len);
 QCOMPARE(v.lengthSquared(), x * x + y * y + z * z + w * w);
 }
 // Test the unit vector conversion for 2D vectors.
-void tst_QVector::normalized2_data()
+void tst_QVectorND::normalized2_data()
 {
 // Use the same test data as the length test.
 length2_data();
 }
-void tst_QVector::normalized2()
+void tst_QVectorND::normalized2()
 {
 QFETCH(qreal, x);
 QFETCH(qreal, y);
 QFETCH(qreal, len);
 QVERIFY(fuzzyCompare(u.x() * len, v.x()));
 QVERIFY(fuzzyCompare(u.y() * len, v.y()));
 }
 // Test the unit vector conversion for 3D vectors.
-void tst_QVector::normalized3_data()
+void tst_QVectorND::normalized3_data()
 {
 // Use the same test data as the length test.
 length3_data();
 }
-void tst_QVector::normalized3()
+void tst_QVectorND::normalized3()
 {
 QFETCH(qreal, x);
 QFETCH(qreal, y);
 QFETCH(qreal, z);
 QFETCH(qreal, len);
 QVERIFY(fuzzyCompare(u.y() * len, v.y()));
 QVERIFY(fuzzyCompare(u.z() * len, v.z()));
 }
 // Test the unit vector conversion for 4D vectors.
-void tst_QVector::normalized4_data()
+void tst_QVectorND::normalized4_data()
 {
 // Use the same test data as the length test.
 length4_data();
 }
-void tst_QVector::normalized4()
+void tst_QVectorND::normalized4()
 {
 QFETCH(qreal, x);
 QFETCH(qreal, y);
 QFETCH(qreal, z);
 QFETCH(qreal, w);
 QVERIFY(fuzzyCompare(u.z() * len, v.z()));
 QVERIFY(fuzzyCompare(u.w() * len, v.w()));
 }
 // Test the unit vector conversion for 2D vectors.
-void tst_QVector::normalize2_data()
+void tst_QVectorND::normalize2_data()
 {
 // Use the same test data as the length test.
 length2_data();
 }
-void tst_QVector::normalize2()
+void tst_QVectorND::normalize2()
 {
 QFETCH(qreal, x);
 QFETCH(qreal, y);
 QVector2D v(x, y);
 else
 QVERIFY(fuzzyCompare(v.length(), qreal(1.0f)));
 }
 // Test the unit vector conversion for 3D vectors.
-void tst_QVector::normalize3_data()
+void tst_QVectorND::normalize3_data()
 {
 // Use the same test data as the length test.
 length3_data();
 }
-void tst_QVector::normalize3()
+void tst_QVectorND::normalize3()
 {
 QFETCH(qreal, x);
 QFETCH(qreal, y);
 QFETCH(qreal, z);
 else
 QVERIFY(fuzzyCompare(v.length(), qreal(1.0f)));
 }
 // Test the unit vector conversion for 4D vectors.
-void tst_QVector::normalize4_data()
+void tst_QVectorND::normalize4_data()
 {
 // Use the same test data as the length test.
 length4_data();
 }
-void tst_QVector::normalize4()
+void tst_QVectorND::normalize4()
 {
 QFETCH(qreal, x);
 QFETCH(qreal, y);
 QFETCH(qreal, z);
 QFETCH(qreal, w);
 else
 QVERIFY(fuzzyCompare(v.length(), qreal(1.0f)));
 }
 // Test the comparison operators for 2D vectors.
-void tst_QVector::compare2()
+void tst_QVectorND::compare2()
 {
 QVector2D v1(1, 2);
 QVector2D v2(1, 2);
 QVector2D v3(3, 2);
 QVector2D v4(1, 3);
 QVERIFY(v1 != v3);
 QVERIFY(v1 != v4);
 }
 // Test the comparison operators for 3D vectors.
-void tst_QVector::compare3()
+void tst_QVectorND::compare3()
 {
 QVector3D v1(1, 2, 4);
 QVector3D v2(1, 2, 4);
 QVector3D v3(3, 2, 4);
 QVector3D v4(1, 3, 4);
 QVERIFY(v1 != v4);
 QVERIFY(v1 != v5);
 }
 // Test the comparison operators for 4D vectors.
-void tst_QVector::compare4()
+void tst_QVectorND::compare4()
 {
 QVector4D v1(1, 2, 4, 8);
 QVector4D v2(1, 2, 4, 8);
 QVector4D v3(3, 2, 4, 8);
 QVector4D v4(1, 3, 4, 8);
 QVERIFY(v1 != v5);
 QVERIFY(v1 != v6);
 }
 // Test vector addition for 2D vectors.
-void tst_QVector::add2_data()
+void tst_QVectorND::add2_data()
 {
 QTest::addColumn<qreal>("x1");
 QTest::addColumn<qreal>("y1");
 QTest::addColumn<qreal>("x2");
 QTest::addColumn<qreal>("y2");
 QTest::newRow("all")
 << (qreal)1.0f << (qreal)2.0f
 << (qreal)4.0f << (qreal)5.0f
 << (qreal)5.0f << (qreal)7.0f;
 }
-void tst_QVector::add2()
+void tst_QVectorND::add2()
 {
 QFETCH(qreal, x1);
 QFETCH(qreal, y1);
 QFETCH(qreal, x2);
 QFETCH(qreal, y2);
 QCOMPARE(v4.x(), v1.x() + v2.x());
 QCOMPARE(v4.y(), v1.y() + v2.y());
 }
 // Test vector addition for 3D vectors.
-void tst_QVector::add3_data()
+void tst_QVectorND::add3_data()
 {
 QTest::addColumn<qreal>("x1");
 QTest::addColumn<qreal>("y1");
 QTest::addColumn<qreal>("z1");
 QTest::addColumn<qreal>("x2");
 QTest::newRow("all")
 << (qreal)1.0f << (qreal)2.0f << (qreal)3.0f
 << (qreal)4.0f << (qreal)5.0f << (qreal)-6.0f
 << (qreal)5.0f << (qreal)7.0f << (qreal)-3.0f;
 }
-void tst_QVector::add3()
+void tst_QVectorND::add3()
 {
 QFETCH(qreal, x1);
 QFETCH(qreal, y1);
 QFETCH(qreal, z1);
 QFETCH(qreal, x2);
 QCOMPARE(v4.y(), v1.y() + v2.y());
 QCOMPARE(v4.z(), v1.z() + v2.z());
 }
 // Test vector addition for 4D vectors.
-void tst_QVector::add4_data()
+void tst_QVectorND::add4_data()
 {
 QTest::addColumn<qreal>("x1");
 QTest::addColumn<qreal>("y1");
 QTest::addColumn<qreal>("z1");
 QTest::addColumn<qreal>("w1");
 QTest::newRow("all")
 << (qreal)1.0f << (qreal)2.0f << (qreal)3.0f << (qreal)8.0f
 << (qreal)4.0f << (qreal)5.0f << (qreal)-6.0f << (qreal)9.0f
 << (qreal)5.0f << (qreal)7.0f << (qreal)-3.0f << (qreal)17.0f;
 }
-void tst_QVector::add4()
+void tst_QVectorND::add4()
 {
 QFETCH(qreal, x1);
 QFETCH(qreal, y1);
 QFETCH(qreal, z1);
 QFETCH(qreal, w1);
 QCOMPARE(v4.z(), v1.z() + v2.z());
 QCOMPARE(v4.w(), v1.w() + v2.w());
 }
 // Test vector subtraction for 2D vectors.
-void tst_QVector::subtract2_data()
+void tst_QVectorND::subtract2_data()
 {
 // Use the same test data as the add test.
 add2_data();
 }
-void tst_QVector::subtract2()
+void tst_QVectorND::subtract2()
 {
 QFETCH(qreal, x1);
 QFETCH(qreal, y1);
 QFETCH(qreal, x2);
 QFETCH(qreal, y2);
 QCOMPARE(v5.x(), v3.x() - v2.x());
 QCOMPARE(v5.y(), v3.y() - v2.y());
 }
 // Test vector subtraction for 3D vectors.
-void tst_QVector::subtract3_data()
+void tst_QVectorND::subtract3_data()
 {
 // Use the same test data as the add test.
 add3_data();
 }
-void tst_QVector::subtract3()
+void tst_QVectorND::subtract3()
 {
 QFETCH(qreal, x1);
 QFETCH(qreal, y1);
 QFETCH(qreal, z1);
 QFETCH(qreal, x2);
 QCOMPARE(v5.y(), v3.y() - v2.y());
 QCOMPARE(v5.z(), v3.z() - v2.z());
 }
 // Test vector subtraction for 4D vectors.
-void tst_QVector::subtract4_data()
+void tst_QVectorND::subtract4_data()
 {
 // Use the same test data as the add test.
 add4_data();
 }
-void tst_QVector::subtract4()
+void tst_QVectorND::subtract4()
 {
 QFETCH(qreal, x1);
 QFETCH(qreal, y1);
 QFETCH(qreal, z1);
 QFETCH(qreal, w1);
 QCOMPARE(v5.z(), v3.z() - v2.z());
 QCOMPARE(v5.w(), v3.w() - v2.w());
 }
 // Test component-wise vector multiplication for 2D vectors.
-void tst_QVector::multiply2_data()
+void tst_QVectorND::multiply2_data()
 {
 QTest::addColumn<qreal>("x1");
 QTest::addColumn<qreal>("y1");
 QTest::addColumn<qreal>("x2");
 QTest::addColumn<qreal>("y2");
 QTest::newRow("all")
 << (qreal)1.0f << (qreal)2.0f
 << (qreal)4.0f << (qreal)5.0f
 << (qreal)4.0f << (qreal)10.0f;
 }
-void tst_QVector::multiply2()
+void tst_QVectorND::multiply2()
 {
 QFETCH(qreal, x1);
 QFETCH(qreal, y1);
 QFETCH(qreal, x2);
 QFETCH(qreal, y2);
 QCOMPARE(v4.x(), v1.x() * v2.x());
 QCOMPARE(v4.y(), v1.y() * v2.y());
 }
 // Test component-wise vector multiplication for 3D vectors.
-void tst_QVector::multiply3_data()
+void tst_QVectorND::multiply3_data()
 {
 QTest::addColumn<qreal>("x1");
 QTest::addColumn<qreal>("y1");
 QTest::addColumn<qreal>("z1");
 QTest::addColumn<qreal>("x2");
 QTest::newRow("all")
 << (qreal)1.0f << (qreal)2.0f << (qreal)3.0f
 << (qreal)4.0f << (qreal)5.0f << (qreal)-6.0f
 << (qreal)4.0f << (qreal)10.0f << (qreal)-18.0f;
 }
-void tst_QVector::multiply3()
+void tst_QVectorND::multiply3()
 {
 QFETCH(qreal, x1);
 QFETCH(qreal, y1);
 QFETCH(qreal, z1);
 QFETCH(qreal, x2);
 QCOMPARE(v4.y(), v1.y() * v2.y());
 QCOMPARE(v4.z(), v1.z() * v2.z());
 }
 // Test component-wise vector multiplication for 4D vectors.
-void tst_QVector::multiply4_data()
+void tst_QVectorND::multiply4_data()
 {
 QTest::addColumn<qreal>("x1");
 QTest::addColumn<qreal>("y1");
 QTest::addColumn<qreal>("z1");
 QTest::addColumn<qreal>("w1");
 QTest::newRow("all")
 << (qreal)1.0f << (qreal)2.0f << (qreal)3.0f << (qreal)8.0f
 << (qreal)4.0f << (qreal)5.0f << (qreal)-6.0f << (qreal)9.0f
 << (qreal)4.0f << (qreal)10.0f << (qreal)-18.0f << (qreal)72.0f;
 }
-void tst_QVector::multiply4()
+void tst_QVectorND::multiply4()
 {
 QFETCH(qreal, x1);
 QFETCH(qreal, y1);
 QFETCH(qreal, z1);
 QFETCH(qreal, w1);
 QCOMPARE(v4.z(), v1.z() * v2.z());
 QCOMPARE(v4.w(), v1.w() * v2.w());
 }
 // Test vector multiplication by a factor for 2D vectors.
-void tst_QVector::multiplyFactor2_data()
+void tst_QVectorND::multiplyFactor2_data()
 {
 QTest::addColumn<qreal>("x1");
 QTest::addColumn<qreal>("y1");
 QTest::addColumn<qreal>("factor");
 QTest::addColumn<qreal>("x2");
 QTest::newRow("allzero")
 << (qreal)1.0f << (qreal)2.0f
 << (qreal)0.0f
 << (qreal)0.0f << (qreal)0.0f;
 }
-void tst_QVector::multiplyFactor2()
+void tst_QVectorND::multiplyFactor2()
 {
 QFETCH(qreal, x1);
 QFETCH(qreal, y1);
 QFETCH(qreal, factor);
 QFETCH(qreal, x2);
 QCOMPARE(v3.x(), v1.x() * factor);
 QCOMPARE(v3.y(), v1.y() * factor);
 }
 // Test vector multiplication by a factor for 3D vectors.
-void tst_QVector::multiplyFactor3_data()
+void tst_QVectorND::multiplyFactor3_data()
 {
 QTest::addColumn<qreal>("x1");
 QTest::addColumn<qreal>("y1");
 QTest::addColumn<qreal>("z1");
 QTest::addColumn<qreal>("factor");
 QTest::newRow("allzero")
 << (qreal)1.0f << (qreal)2.0f << (qreal)-3.0f
 << (qreal)0.0f
 << (qreal)0.0f << (qreal)0.0f << (qreal)0.0f;
 }
-void tst_QVector::multiplyFactor3()
+void tst_QVectorND::multiplyFactor3()
 {
 QFETCH(qreal, x1);
 QFETCH(qreal, y1);
 QFETCH(qreal, z1);
 QFETCH(qreal, factor);
 QCOMPARE(v3.y(), v1.y() * factor);
 QCOMPARE(v3.z(), v1.z() * factor);
 }
 // Test vector multiplication by a factor for 4D vectors.
-void tst_QVector::multiplyFactor4_data()
+void tst_QVectorND::multiplyFactor4_data()
 {
 QTest::addColumn<qreal>("x1");
 QTest::addColumn<qreal>("y1");
 QTest::addColumn<qreal>("z1");
 QTest::addColumn<qreal>("w1");
 QTest::newRow("allzero")
 << (qreal)1.0f << (qreal)2.0f << (qreal)-3.0f << (qreal)4.0f
 << (qreal)0.0f
 << (qreal)0.0f << (qreal)0.0f << (qreal)0.0f << (qreal)0.0f;
 }
-void tst_QVector::multiplyFactor4()
+void tst_QVectorND::multiplyFactor4()
 {
 QFETCH(qreal, x1);
 QFETCH(qreal, y1);
 QFETCH(qreal, z1);
 QFETCH(qreal, w1);
 QCOMPARE(v3.z(), v1.z() * factor);
 QCOMPARE(v3.w(), v1.w() * factor);
 }
 // Test vector division by a factor for 2D vectors.
-void tst_QVector::divide2_data()
+void tst_QVectorND::divide2_data()
 {
 // Use the same test data as the multiply test.
 multiplyFactor2_data();
 }
-void tst_QVector::divide2()
+void tst_QVectorND::divide2()
 {
 QFETCH(qreal, x1);
 QFETCH(qreal, y1);
 QFETCH(qreal, factor);
 QFETCH(qreal, x2);
 QCOMPARE(v3.x(), v2.x() / factor);
 QCOMPARE(v3.y(), v2.y() / factor);
 }
 // Test vector division by a factor for 3D vectors.
-void tst_QVector::divide3_data()
+void tst_QVectorND::divide3_data()
 {
 // Use the same test data as the multiply test.
 multiplyFactor3_data();
 }
-void tst_QVector::divide3()
+void tst_QVectorND::divide3()
 {
 QFETCH(qreal, x1);
 QFETCH(qreal, y1);
 QFETCH(qreal, z1);
 QFETCH(qreal, factor);
 QCOMPARE(v3.y(), v2.y() / factor);
 QCOMPARE(v3.z(), v2.z() / factor);
 }
 // Test vector division by a factor for 4D vectors.
-void tst_QVector::divide4_data()
+void tst_QVectorND::divide4_data()
 {
 // Use the same test data as the multiply test.
 multiplyFactor4_data();
 }
-void tst_QVector::divide4()
+void tst_QVectorND::divide4()
 {
 QFETCH(qreal, x1);
 QFETCH(qreal, y1);
 QFETCH(qreal, z1);
 QFETCH(qreal, w1);
 QCOMPARE(v3.z(), v2.z() / factor);
 QCOMPARE(v3.w(), v2.w() / factor);
 }
 // Test vector negation for 2D vectors.
-void tst_QVector::negate2_data()
+void tst_QVectorND::negate2_data()
 {
 // Use the same test data as the add test.
 add2_data();
 }
-void tst_QVector::negate2()
+void tst_QVectorND::negate2()
 {
 QFETCH(qreal, x1);
 QFETCH(qreal, y1);
 QVector2D v1(x1, y1);
 QVERIFY(-v1 == v2);
 }
 // Test vector negation for 3D vectors.
-void tst_QVector::negate3_data()
+void tst_QVectorND::negate3_data()
 {
 // Use the same test data as the add test.
 add3_data();
 }
-void tst_QVector::negate3()
+void tst_QVectorND::negate3()
 {
 QFETCH(qreal, x1);
 QFETCH(qreal, y1);
 QFETCH(qreal, z1);
 QVERIFY(-v1 == v2);
 }
 // Test vector negation for 4D vectors.
-void tst_QVector::negate4_data()
+void tst_QVectorND::negate4_data()
 {
 // Use the same test data as the add test.
 add4_data();
 }
-void tst_QVector::negate4()
+void tst_QVectorND::negate4()
 {
 QFETCH(qreal, x1);
 QFETCH(qreal, y1);
 QFETCH(qreal, z1);
 QFETCH(qreal, w1);
 QVERIFY(-v1 == v2);
 }
 // Test the computation of vector cross-products.
-void tst_QVector::crossProduct_data()
+void tst_QVectorND::crossProduct_data()
 {
 QTest::addColumn<qreal>("x1");
 QTest::addColumn<qreal>("y1");
 QTest::addColumn<qreal>("z1");
 QTest::addColumn<qreal>("x2");
 << (qreal)1.0f << (qreal)2.0f << (qreal)3.0f
 << (qreal)4.0f << (qreal)5.0f << (qreal)6.0f
 << (qreal)-3.0f << (qreal)6.0f << (qreal)-3.0f
 << (qreal)32.0f;
 }
-void tst_QVector::crossProduct()
+void tst_QVectorND::crossProduct()
 {
 QFETCH(qreal, x1);
 QFETCH(qreal, y1);
 QFETCH(qreal, z1);
 QFETCH(qreal, x2);
 QCOMPARE(v4.y(), yres);
 QCOMPARE(v4.z(), zres);
 }
 // Test the computation of normals.
-void tst_QVector::normal_data()
+void tst_QVectorND::normal_data()
 {
 // Use the same test data as the crossProduct test.
 crossProduct_data();
 }
-void tst_QVector::normal()
+void tst_QVectorND::normal()
 {
 QFETCH(qreal, x1);
 QFETCH(qreal, y1);
 QFETCH(qreal, z1);
 QFETCH(qreal, x2);
 QVector3D point(1.0f, 2.0f, 3.0f);
 QVERIFY(QVector3D::normal(point, v1 + point, v2 + point) == v3.normalized());
 }
 // Test distance to plane calculations.
-void tst_QVector::distanceToPlane_data()
+void tst_QVectorND::distanceToPlane_data()
 {
 QTest::addColumn<qreal>("x1");  // Point on plane
 QTest::addColumn<qreal>("y1");
 QTest::addColumn<qreal>("z1");
 QTest::addColumn<qreal>("x2");  // Normal to plane
 << (qreal)-1.0f << (qreal)1.0f << (qreal)-2.0f
 << (qreal)1.0f << (qreal)0.0f << (qreal)0.0f
 << (qreal)0.0f << (qreal)2.0f << (qreal)0.0f
 << (qreal)-2.0f;
 }
-void tst_QVector::distanceToPlane()
+void tst_QVectorND::distanceToPlane()
 {
 QFETCH(qreal, x1);
 QFETCH(qreal, y1);
 QFETCH(qreal, z1);
 QFETCH(qreal, x2);
 QCOMPARE(v3.distanceToPlane(v1, v2), distance);
 QCOMPARE(v3.distanceToPlane(v1, v4, v5), distance);
 }
 // Test distance to line calculations.
-void tst_QVector::distanceToLine_data()
+void tst_QVectorND::distanceToLine_data()
 {
 QTest::addColumn<qreal>("x1");  // Point on line
 QTest::addColumn<qreal>("y1");
 QTest::addColumn<qreal>("z1");
 QTest::addColumn<qreal>("x2");  // Direction of the line
 << (qreal)0.0f << (qreal)0.0f << (qreal)0.0f
 << (qreal)0.0f << (qreal)0.0f << (qreal)0.0f
 << (qreal)0.0f << (qreal)5.0f << (qreal)0.0f
 << (qreal)5.0f;
 }
-void tst_QVector::distanceToLine()
+void tst_QVectorND::distanceToLine()
 {
 QFETCH(qreal, x1);
 QFETCH(qreal, y1);
 QFETCH(qreal, z1);
 QFETCH(qreal, x2);
 QCOMPARE(v3.distanceToLine(v1, v2), distance);
 }
 // Test the computation of dot products for 2D vectors.
-void tst_QVector::dotProduct2_data()
+void tst_QVectorND::dotProduct2_data()
 {
 QTest::addColumn<qreal>("x1");
 QTest::addColumn<qreal>("y1");
 QTest::addColumn<qreal>("x2");
 QTest::addColumn<qreal>("y2");
 QTest::newRow("complex")
 << (qreal)1.0f << (qreal)2.0f
 << (qreal)4.0f << (qreal)5.0f
 << (qreal)14.0f;
 }
-void tst_QVector::dotProduct2()
+void tst_QVectorND::dotProduct2()
 {
 QFETCH(qreal, x1);
 QFETCH(qreal, y1);
 QFETCH(qreal, x2);
 QFETCH(qreal, y2);
 QCOMPARE(QVector2D::dotProduct(v1, v2), d);
 }
 // Test the computation of dot products for 3D vectors.
-void tst_QVector::dotProduct3_data()
+void tst_QVectorND::dotProduct3_data()
 {
 // Use the same test data as the crossProduct test.
 crossProduct_data();
 }
-void tst_QVector::dotProduct3()
+void tst_QVectorND::dotProduct3()
 {
 QFETCH(qreal, x1);
 QFETCH(qreal, y1);
 QFETCH(qreal, z1);
 QFETCH(qreal, x2);
 QCOMPARE(QVector3D::dotProduct(v1, v2), d);
 }
 // Test the computation of dot products for 4D vectors.
-void tst_QVector::dotProduct4_data()
+void tst_QVectorND::dotProduct4_data()
 {
 QTest::addColumn<qreal>("x1");
 QTest::addColumn<qreal>("y1");
 QTest::addColumn<qreal>("z1");
 QTest::addColumn<qreal>("w1");
 QTest::newRow("complex")
 << (qreal)1.0f << (qreal)2.0f << (qreal)3.0f << (qreal)4.0f
 << (qreal)4.0f << (qreal)5.0f << (qreal)6.0f << (qreal)7.0f
 << (qreal)60.0f;
 }
-void tst_QVector::dotProduct4()
+void tst_QVectorND::dotProduct4()
 {
 QFETCH(qreal, x1);
 QFETCH(qreal, y1);
 QFETCH(qreal, z1);
 QFETCH(qreal, w1);
 qreal d = x1 * x2 + y1 * y2 + z1 * z2 + w1 * w2;
 QCOMPARE(QVector4D::dotProduct(v1, v2), d);
 }
-class tst_QVectorProperties : public QObject
+class tst_QVectorNDProperties : public QObject
 {
 Q_OBJECT
 Q_PROPERTY(QVector2D vector2D READ vector2D WRITE setVector2D)
 Q_PROPERTY(QVector3D vector3D READ vector3D WRITE setVector3D)
 Q_PROPERTY(QVector4D vector4D READ vector4D WRITE setVector4D)
 public:
-tst_QVectorProperties(QObject *parent = 0) : QObject(parent) {}
+tst_QVectorNDProperties(QObject *parent = 0) : QObject(parent) {}
 QVector2D vector2D() const { return v2; }
 void setVector2D(const QVector2D& value) { v2 = value; }
 QVector3D vector3D() const { return v3; }
 QVector3D v3;
 QVector4D v4;
 };
 // Test getting and setting vector properties via the metaobject system.
-void tst_QVector::properties()
+void tst_QVectorND::properties()
 {
-tst_QVectorProperties obj;
+tst_QVectorNDProperties obj;
 obj.setVector2D(QVector2D(1.0f, 2.0f));
 obj.setVector3D(QVector3D(3.0f, 4.0f, 5.0f));
 obj.setVector4D(QVector4D(6.0f, 7.0f, 8.0f, 9.0f));
 QCOMPARE(v4.y(), (qreal)-7.0f);
 QCOMPARE(v4.z(), (qreal)-8.0f);
 QCOMPARE(v4.w(), (qreal)-9.0f);
 }
-void tst_QVector::metaTypes()
+void tst_QVectorND::metaTypes()
 {
 QVERIFY(QMetaType::type("QVector2D") == QMetaType::QVector2D);
 QVERIFY(QMetaType::type("QVector3D") == QMetaType::QVector3D);
 QVERIFY(QMetaType::type("QVector4D") == QMetaType::QVector4D);
 QVERIFY(qMetaTypeId<QVector2D>() == QMetaType::QVector2D);
 QVERIFY(qMetaTypeId<QVector3D>() == QMetaType::QVector3D);
 QVERIFY(qMetaTypeId<QVector4D>() == QMetaType::QVector4D);
 }
-QTEST_APPLESS_MAIN(tst_QVector)
+QTEST_APPLESS_MAIN(tst_QVectorND)
 #include "tst_qvectornd.moc"

changeset 7	f7bc934e204c
parent 0	1918ee327afb