1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the test suite of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include <QtTest/QtTest>

    43 #include <QtCore/qmath.h>

    44 #include <QtGui/qmatrix4x4.h>

    45 

    46 class tst_QMatrixNxN : public QObject

    47 {

    48     Q_OBJECT

    49 public:

    50     tst_QMatrixNxN() {}

    51     ~tst_QMatrixNxN() {}

    52 

    53 private slots:

    54     void create2x2();

    55     void create3x3();

    56     void create4x4();

    57     void create4x3();

    58 

    59     void isIdentity2x2();

    60     void isIdentity3x3();

    61     void isIdentity4x4();

    62     void isIdentity4x3();

    63 

    64     void compare2x2();

    65     void compare3x3();

    66     void compare4x4();

    67     void compare4x3();

    68 

    69     void transposed2x2();

    70     void transposed3x3();

    71     void transposed4x4();

    72     void transposed4x3();

    73 

    74     void add2x2_data();

    75     void add2x2();

    76     void add3x3_data();

    77     void add3x3();

    78     void add4x4_data();

    79     void add4x4();

    80     void add4x3_data();

    81     void add4x3();

    82 

    83     void subtract2x2_data();

    84     void subtract2x2();

    85     void subtract3x3_data();

    86     void subtract3x3();

    87     void subtract4x4_data();

    88     void subtract4x4();

    89     void subtract4x3_data();

    90     void subtract4x3();

    91 

    92     void multiply2x2_data();

    93     void multiply2x2();

    94     void multiply3x3_data();

    95     void multiply3x3();

    96     void multiply4x4_data();

    97     void multiply4x4();

    98     void multiply4x3_data();

    99     void multiply4x3();

   100 

   101     void multiplyFactor2x2_data();

   102     void multiplyFactor2x2();

   103     void multiplyFactor3x3_data();

   104     void multiplyFactor3x3();

   105     void multiplyFactor4x4_data();

   106     void multiplyFactor4x4();

   107     void multiplyFactor4x3_data();

   108     void multiplyFactor4x3();

   109 

   110     void divideFactor2x2_data();

   111     void divideFactor2x2();

   112     void divideFactor3x3_data();

   113     void divideFactor3x3();

   114     void divideFactor4x4_data();

   115     void divideFactor4x4();

   116     void divideFactor4x3_data();

   117     void divideFactor4x3();

   118 

   119     void negate2x2_data();

   120     void negate2x2();

   121     void negate3x3_data();

   122     void negate3x3();

   123     void negate4x4_data();

   124     void negate4x4();

   125     void negate4x3_data();

   126     void negate4x3();

   127 

   128     void inverted4x4_data();

   129     void inverted4x4();

   130 

   131     void orthonormalInverse4x4();

   132 

   133     void scale4x4_data();

   134     void scale4x4();

   135 

   136     void translate4x4_data();

   137     void translate4x4();

   138 

   139     void rotate4x4_data();

   140     void rotate4x4();

   141 

   142     void normalMatrix_data();

   143     void normalMatrix();

   144 

   145     void optimizedTransforms();

   146 

   147     void ortho();

   148     void frustum();

   149     void perspective();

   150     void flipCoordinates();

   151 

   152     void convertGeneric();

   153 

   154     void extractAxisRotation_data();

   155     void extractAxisRotation();

   156 

   157     void extractTranslation_data();

   158     void extractTranslation();

   159 

   160     void inferSpecialType_data();

   161     void inferSpecialType();

   162 

   163     void columnsAndRows();

   164 

   165     void convertQMatrix();

   166     void convertQTransform();

   167 

   168     void fill();

   169 

   170     void mapRect_data();

   171     void mapRect();

   172 

   173     void mapVector_data();

   174     void mapVector();

   175 

   176     void properties();

   177     void metaTypes();

   178 

   179 private:

   180     static void setMatrix(QMatrix2x2& m, const qreal *values);

   181     static void setMatrixDirect(QMatrix2x2& m, const qreal *values);

   182     static bool isSame(const QMatrix2x2& m, const qreal *values);

   183     static bool isIdentity(const QMatrix2x2& m);

   184 

   185     static void setMatrix(QMatrix3x3& m, const qreal *values);

   186     static void setMatrixDirect(QMatrix3x3& m, const qreal *values);

   187     static bool isSame(const QMatrix3x3& m, const qreal *values);

   188     static bool isIdentity(const QMatrix3x3& m);

   189 

   190     static void setMatrix(QMatrix4x4& m, const qreal *values);

   191     static void setMatrixDirect(QMatrix4x4& m, const qreal *values);

   192     static bool isSame(const QMatrix4x4& m, const qreal *values);

   193     static bool isIdentity(const QMatrix4x4& m);

   194 

   195     static void setMatrix(QMatrix4x3& m, const qreal *values);

   196     static void setMatrixDirect(QMatrix4x3& m, const qreal *values);

   197     static bool isSame(const QMatrix4x3& m, const qreal *values);

   198     static bool isIdentity(const QMatrix4x3& m);

   199 };

   200 

   201 static const qreal nullValues2[] =

   202     {0.0f, 0.0f,

   203      0.0f, 0.0f};

   204 

   205 static qreal const identityValues2[16] =

   206     {1.0f, 0.0f,

   207      0.0f, 1.0f};

   208 

   209 static const qreal doubleIdentity2[] =

   210     {2.0f, 0.0f,

   211      0.0f, 2.0f};

   212 

   213 static qreal const uniqueValues2[16] =

   214     {1.0f, 2.0f,

   215      5.0f, 6.0f};

   216 

   217 static qreal const transposedValues2[16] =

   218     {1.0f, 5.0f,

   219      2.0f, 6.0f};

   220 

   221 static const qreal nullValues3[] =

   222     {0.0f, 0.0f, 0.0f,

   223      0.0f, 0.0f, 0.0f,

   224      0.0f, 0.0f, 0.0f};

   225 

   226 static qreal const identityValues3[16] =

   227     {1.0f, 0.0f, 0.0f,

   228      0.0f, 1.0f, 0.0f,

   229      0.0f, 0.0f, 1.0f};

   230 

   231 static const qreal doubleIdentity3[] =

   232     {2.0f, 0.0f, 0.0f,

   233      0.0f, 2.0f, 0.0f,

   234      0.0f, 0.0f, 2.0f};

   235 

   236 static qreal const uniqueValues3[16] =

   237     {1.0f, 2.0f, 3.0f,

   238      5.0f, 6.0f, 7.0f,

   239      9.0f, 10.0f, 11.0f};

   240 

   241 static qreal const transposedValues3[16] =

   242     {1.0f, 5.0f, 9.0f,

   243      2.0f, 6.0f, 10.0f,

   244      3.0f, 7.0f, 11.0f};

   245 

   246 static const qreal nullValues4[] =

   247     {0.0f, 0.0f, 0.0f, 0.0f,

   248      0.0f, 0.0f, 0.0f, 0.0f,

   249      0.0f, 0.0f, 0.0f, 0.0f,

   250      0.0f, 0.0f, 0.0f, 0.0f};

   251 

   252 static qreal const identityValues4[16] =

   253     {1.0f, 0.0f, 0.0f, 0.0f,

   254      0.0f, 1.0f, 0.0f, 0.0f,

   255      0.0f, 0.0f, 1.0f, 0.0f,

   256      0.0f, 0.0f, 0.0f, 1.0f};

   257 

   258 static const qreal doubleIdentity4[] =

   259     {2.0f, 0.0f, 0.0f, 0.0f,

   260      0.0f, 2.0f, 0.0f, 0.0f,

   261      0.0f, 0.0f, 2.0f, 0.0f,

   262      0.0f, 0.0f, 0.0f, 2.0f};

   263 

   264 static qreal const uniqueValues4[16] =

   265     {1.0f, 2.0f, 3.0f, 4.0f,

   266      5.0f, 6.0f, 7.0f, 8.0f,

   267      9.0f, 10.0f, 11.0f, 12.0f,

   268      13.0f, 14.0f, 15.0f, 16.0f};

   269 

   270 static qreal const transposedValues4[16] =

   271     {1.0f, 5.0f, 9.0f, 13.0f,

   272      2.0f, 6.0f, 10.0f, 14.0f,

   273      3.0f, 7.0f, 11.0f, 15.0f,

   274      4.0f, 8.0f, 12.0f, 16.0f};

   275 

   276 static const qreal nullValues4x3[] =

   277     {0.0f, 0.0f, 0.0f, 0.0f,

   278      0.0f, 0.0f, 0.0f, 0.0f,

   279      0.0f, 0.0f, 0.0f, 0.0f};

   280 

   281 static qreal const identityValues4x3[12] =

   282     {1.0f, 0.0f, 0.0f, 0.0f,

   283      0.0f, 1.0f, 0.0f, 0.0f,

   284      0.0f, 0.0f, 1.0f, 0.0f};

   285 

   286 static qreal const doubleIdentity4x3[12] =

   287     {2.0f, 0.0f, 0.0f, 0.0f,

   288      0.0f, 2.0f, 0.0f, 0.0f,

   289      0.0f, 0.0f, 2.0f, 0.0f};

   290 

   291 static qreal const uniqueValues4x3[12] =

   292     {1.0f, 2.0f, 3.0f, 4.0f,

   293      5.0f, 6.0f, 7.0f, 8.0f,

   294      9.0f, 10.0f, 11.0f, 12.0f};

   295 

   296 static qreal const transposedValues3x4[12] =

   297     {1.0f, 5.0f, 9.0f,

   298      2.0f, 6.0f, 10.0f,

   299      3.0f, 7.0f, 11.0f,

   300      4.0f, 8.0f, 12.0f};

   301 

   302 // Set a matrix to a specified array of values, which are assumed

   303 // to be in row-major order.  This sets the values using floating-point.

   304 void tst_QMatrixNxN::setMatrix(QMatrix2x2& m, const qreal *values)

   305 {

   306     for (int row = 0; row < 2; ++row)

   307         for (int col = 0; col < 2; ++col)

   308             m(row, col) = values[row * 2 + col];

   309 }

   310 void tst_QMatrixNxN::setMatrix(QMatrix3x3& m, const qreal *values)

   311 {

   312     for (int row = 0; row < 3; ++row)

   313         for (int col = 0; col < 3; ++col)

   314             m(row, col) = values[row * 3 + col];

   315 }

   316 void tst_QMatrixNxN::setMatrix(QMatrix4x4& m, const qreal *values)

   317 {

   318     for (int row = 0; row < 4; ++row)

   319         for (int col = 0; col < 4; ++col)

   320             m(row, col) = values[row * 4 + col];

   321 }

   322 void tst_QMatrixNxN::setMatrix(QMatrix4x3& m, const qreal *values)

   323 {

   324     for (int row = 0; row < 3; ++row)

   325         for (int col = 0; col < 4; ++col)

   326             m(row, col) = values[row * 4 + col];

   327 }

   328 

   329 // Set a matrix to a specified array of values, which are assumed

   330 // to be in row-major order.  This sets the values directly into

   331 // the internal data() array.

   332 void tst_QMatrixNxN::setMatrixDirect(QMatrix2x2& m, const qreal *values)

   333 {

   334     qreal *data = m.data();

   335     for (int row = 0; row < 2; ++row) {

   336         for (int col = 0; col < 2; ++col) {

   337             data[row + col * 2] = values[row * 2 + col];

   338         }

   339     }

   340 }

   341 void tst_QMatrixNxN::setMatrixDirect(QMatrix3x3& m, const qreal *values)

   342 {

   343     qreal *data = m.data();

   344     for (int row = 0; row < 3; ++row) {

   345         for (int col = 0; col < 3; ++col) {

   346             data[row + col * 3] = values[row * 3 + col];

   347         }

   348     }

   349 }

   350 void tst_QMatrixNxN::setMatrixDirect(QMatrix4x4& m, const qreal *values)

   351 {

   352     qreal *data = m.data();

   353     for (int row = 0; row < 4; ++row) {

   354         for (int col = 0; col < 4; ++col) {

   355             data[row + col * 4] = values[row * 4 + col];

   356         }

   357     }

   358 }

   359 void tst_QMatrixNxN::setMatrixDirect(QMatrix4x3& m, const qreal *values)

   360 {

   361     qreal *data = m.data();

   362     for (int row = 0; row < 3; ++row) {

   363         for (int col = 0; col < 4; ++col) {

   364             data[row + col * 3] = values[row * 4 + col];

   365         }

   366     }

   367 }

   368 

   369 // QVector2/3/4D use float internally, which can sometimes lead

   370 // to precision issues when converting to and from qreal during

   371 // operations involving QMatrix4x4.  This fuzzy compare is slightly

   372 // "fuzzier" than the default qFuzzyCompare for qreal to compensate.

   373 static bool fuzzyCompare(qreal x, qreal y)

   374 {

   375     return qFuzzyIsNull((float)(x - y));

   376 }

   377 

   378 static bool fuzzyCompare(const QVector3D &v1, const QVector3D &v2)

   379 {

   380     if (!fuzzyCompare(v1.x(), v2.x()))

   381         return false;

   382     if (!fuzzyCompare(v1.y(), v2.y()))

   383         return false;

   384     if (!fuzzyCompare(v1.z(), v2.z()))

   385         return false;

   386     return true;

   387 }

   388 

   389 // Determine if a matrix is the same as a specified array of values.

   390 // The values are assumed to be specified in row-major order.

   391 bool tst_QMatrixNxN::isSame(const QMatrix2x2& m, const qreal *values)

   392 {

   393     const qreal *mv = m.constData();

   394     for (int row = 0; row < 2; ++row) {

   395         for (int col = 0; col < 2; ++col) {

   396             // Check the values using the operator() function.

   397             if (!fuzzyCompare(m(row, col), values[row * 2 + col])) {

   398                 qDebug() << "floating-point failure at" << row << col << "actual =" << m(row, col) << "expected =" << values[row * 2 + col];

   399                 return false;

   400             }

   401 

   402             // Check the values using direct access, which verifies that the values

   403             // are stored internally in column-major order.

   404             if (!fuzzyCompare(mv[col * 2 + row], values[row * 2 + col])) {

   405                 qDebug() << "column floating-point failure at" << row << col << "actual =" << mv[col * 2 + row] << "expected =" << values[row * 2 + col];

   406                 return false;

   407             }

   408         }

   409     }

   410     return true;

   411 }

   412 bool tst_QMatrixNxN::isSame(const QMatrix3x3& m, const qreal *values)

   413 {

   414     const qreal *mv = m.constData();

   415     for (int row = 0; row < 3; ++row) {

   416         for (int col = 0; col < 3; ++col) {

   417             // Check the values using the operator() access function.

   418             if (!fuzzyCompare(m(row, col), values[row * 3 + col])) {

   419                 qDebug() << "floating-point failure at" << row << col << "actual =" << m(row, col) << "expected =" << values[row * 3 + col];

   420                 return false;

   421             }

   422 

   423             // Check the values using direct access, which verifies that the values

   424             // are stored internally in column-major order.

   425             if (!fuzzyCompare(mv[col * 3 + row], values[row * 3 + col])) {

   426                 qDebug() << "column floating-point failure at" << row << col << "actual =" << mv[col * 3 + row] << "expected =" << values[row * 3 + col];

   427                 return false;

   428             }

   429         }

   430     }

   431     return true;

   432 }

   433 bool tst_QMatrixNxN::isSame(const QMatrix4x4& m, const qreal *values)

   434 {

   435     const qreal *mv = m.constData();

   436     for (int row = 0; row < 4; ++row) {

   437         for (int col = 0; col < 4; ++col) {

   438             // Check the values using the operator() access function.

   439             if (!fuzzyCompare(m(row, col), values[row * 4 + col])) {

   440                 qDebug() << "floating-point failure at" << row << col << "actual =" << m(row, col) << "expected =" << values[row * 4 + col];

   441                 return false;

   442             }

   443 

   444             // Check the values using direct access, which verifies that the values

   445             // are stored internally in column-major order.

   446             if (!fuzzyCompare(mv[col * 4 + row], values[row * 4 + col])) {

   447                 qDebug() << "column floating-point failure at" << row << col << "actual =" << mv[col * 4 + row] << "expected =" << values[row * 4 + col];

   448                 return false;

   449             }

   450         }

   451     }

   452     return true;

   453 }

   454 bool tst_QMatrixNxN::isSame(const QMatrix4x3& m, const qreal *values)

   455 {

   456     const qreal *mv = m.constData();

   457     for (int row = 0; row < 3; ++row) {

   458         for (int col = 0; col < 4; ++col) {

   459             // Check the values using the operator() access function.

   460             if (!fuzzyCompare(m(row, col), values[row * 4 + col])) {

   461                 qDebug() << "floating-point failure at" << row << col << "actual =" << m(row, col) << "expected =" << values[row * 4 + col];

   462                 return false;

   463             }

   464 

   465             // Check the values using direct access, which verifies that the values

   466             // are stored internally in column-major order.

   467             if (!fuzzyCompare(mv[col * 3 + row], values[row * 4 + col])) {

   468                 qDebug() << "column floating-point failure at" << row << col << "actual =" << mv[col * 3 + row] << "expected =" << values[row * 4 + col];

   469                 return false;

   470             }

   471         }

   472     }

   473     return true;

   474 }

   475 

   476 // Determine if a matrix is the identity.

   477 bool tst_QMatrixNxN::isIdentity(const QMatrix2x2& m)

   478 {

   479     return isSame(m, identityValues2);

   480 }

   481 bool tst_QMatrixNxN::isIdentity(const QMatrix3x3& m)

   482 {

   483     return isSame(m, identityValues3);

   484 }

   485 bool tst_QMatrixNxN::isIdentity(const QMatrix4x4& m)

   486 {

   487     return isSame(m, identityValues4);

   488 }

   489 bool tst_QMatrixNxN::isIdentity(const QMatrix4x3& m)

   490 {

   491     return isSame(m, identityValues4x3);

   492 }

   493 

   494 // Test the creation of QMatrix2x2 objects in various ways:

   495 // construct, copy, and modify.

   496 void tst_QMatrixNxN::create2x2()

   497 {

   498     QMatrix2x2 m1;

   499     QVERIFY(isIdentity(m1));

   500     QVERIFY(m1.isIdentity());

   501 

   502     QMatrix2x2 m2;

   503     setMatrix(m2, uniqueValues2);

   504     QVERIFY(isSame(m2, uniqueValues2));

   505     QVERIFY(!m2.isIdentity());

   506 

   507     QMatrix2x2 m3;

   508     setMatrixDirect(m3, uniqueValues2);

   509     QVERIFY(isSame(m3, uniqueValues2));

   510 

   511     QMatrix2x2 m4(m3);

   512     QVERIFY(isSame(m4, uniqueValues2));

   513 

   514     QMatrix2x2 m5;

   515     m5 = m3;

   516     QVERIFY(isSame(m5, uniqueValues2));

   517 

   518     m5.setIdentity();

   519     QVERIFY(isIdentity(m5));

   520 

   521     QMatrix2x2 m6(uniqueValues2);

   522     QVERIFY(isSame(m6, uniqueValues2));

   523     qreal vals[4];

   524     m6.toValueArray(vals);

   525     for (int index = 0; index < 4; ++index)

   526         QCOMPARE(vals[index], uniqueValues2[index]);

   527 }

   528 

   529 // Test the creation of QMatrix3x3 objects in various ways:

   530 // construct, copy, and modify.

   531 void tst_QMatrixNxN::create3x3()

   532 {

   533     QMatrix3x3 m1;

   534     QVERIFY(isIdentity(m1));

   535     QVERIFY(m1.isIdentity());

   536 

   537     QMatrix3x3 m2;

   538     setMatrix(m2, uniqueValues3);

   539     QVERIFY(isSame(m2, uniqueValues3));

   540     QVERIFY(!m2.isIdentity());

   541 

   542     QMatrix3x3 m3;

   543     setMatrixDirect(m3, uniqueValues3);

   544     QVERIFY(isSame(m3, uniqueValues3));

   545 

   546     QMatrix3x3 m4(m3);

   547     QVERIFY(isSame(m4, uniqueValues3));

   548 

   549     QMatrix3x3 m5;

   550     m5 = m3;

   551     QVERIFY(isSame(m5, uniqueValues3));

   552 

   553     m5.setIdentity();

   554     QVERIFY(isIdentity(m5));

   555 

   556     QMatrix3x3 m6(uniqueValues3);

   557     QVERIFY(isSame(m6, uniqueValues3));

   558     qreal vals[9];

   559     m6.toValueArray(vals);

   560     for (int index = 0; index < 9; ++index)

   561         QCOMPARE(vals[index], uniqueValues3[index]);

   562 }

   563 

   564 // Test the creation of QMatrix4x4 objects in various ways:

   565 // construct, copy, and modify.

   566 void tst_QMatrixNxN::create4x4()

   567 {

   568     QMatrix4x4 m1;

   569     QVERIFY(isIdentity(m1));

   570     QVERIFY(m1.isIdentity());

   571 

   572     QMatrix4x4 m2;

   573     setMatrix(m2, uniqueValues4);

   574     QVERIFY(isSame(m2, uniqueValues4));

   575     QVERIFY(!m2.isIdentity());

   576 

   577     QMatrix4x4 m3;

   578     setMatrixDirect(m3, uniqueValues4);

   579     QVERIFY(isSame(m3, uniqueValues4));

   580 

   581     QMatrix4x4 m4(m3);

   582     QVERIFY(isSame(m4, uniqueValues4));

   583 

   584     QMatrix4x4 m5;

   585     m5 = m3;

   586     QVERIFY(isSame(m5, uniqueValues4));

   587 

   588     m5.setIdentity();

   589     QVERIFY(isIdentity(m5));

   590 

   591     QMatrix4x4 m6(uniqueValues4);

   592     QVERIFY(isSame(m6, uniqueValues4));

   593     qreal vals[16];

   594     m6.toValueArray(vals);

   595     for (int index = 0; index < 16; ++index)

   596         QCOMPARE(vals[index], uniqueValues4[index]);

   597 

   598     QMatrix4x4 m8

   599         (uniqueValues4[0], uniqueValues4[1], uniqueValues4[2], uniqueValues4[3],

   600          uniqueValues4[4], uniqueValues4[5], uniqueValues4[6], uniqueValues4[7],

   601          uniqueValues4[8], uniqueValues4[9], uniqueValues4[10], uniqueValues4[11],

   602          uniqueValues4[12], uniqueValues4[13], uniqueValues4[14], uniqueValues4[15]);

   603     QVERIFY(isSame(m8, uniqueValues4));

   604 }

   605 

   606 // Test the creation of QMatrix4x3 objects in various ways:

   607 // construct, copy, and modify.

   608 void tst_QMatrixNxN::create4x3()

   609 {

   610     QMatrix4x3 m1;

   611     QVERIFY(isIdentity(m1));

   612     QVERIFY(m1.isIdentity());

   613 

   614     QMatrix4x3 m2;

   615     setMatrix(m2, uniqueValues4x3);

   616     QVERIFY(isSame(m2, uniqueValues4x3));

   617     QVERIFY(!m2.isIdentity());

   618 

   619     QMatrix4x3 m3;

   620     setMatrixDirect(m3, uniqueValues4x3);

   621     QVERIFY(isSame(m3, uniqueValues4x3));

   622 

   623     QMatrix4x3 m4(m3);

   624     QVERIFY(isSame(m4, uniqueValues4x3));

   625 

   626     QMatrix4x3 m5;

   627     m5 = m3;

   628     QVERIFY(isSame(m5, uniqueValues4x3));

   629 

   630     m5.setIdentity();

   631     QVERIFY(isIdentity(m5));

   632 

   633     QMatrix4x3 m6(uniqueValues4x3);

   634     QVERIFY(isSame(m6, uniqueValues4x3));

   635     qreal vals[12];

   636     m6.toValueArray(vals);

   637     for (int index = 0; index < 12; ++index)

   638         QCOMPARE(vals[index], uniqueValues4x3[index]);

   639 }

   640 

   641 // Test isIdentity() for 2x2 matrices.

   642 void tst_QMatrixNxN::isIdentity2x2()

   643 {

   644     for (int i = 0; i < 2 * 2; ++i) {

   645         QMatrix2x2 m;

   646         QVERIFY(m.isIdentity());

   647         m.data()[i] = 42.0f;

   648         QVERIFY(!m.isIdentity());

   649     }

   650 }

   651 

   652 // Test isIdentity() for 3x3 matrices.

   653 void tst_QMatrixNxN::isIdentity3x3()

   654 {

   655     for (int i = 0; i < 3 * 3; ++i) {

   656         QMatrix3x3 m;

   657         QVERIFY(m.isIdentity());

   658         m.data()[i] = 42.0f;

   659         QVERIFY(!m.isIdentity());

   660     }

   661 }

   662 

   663 // Test isIdentity() for 4x4 matrices.

   664 void tst_QMatrixNxN::isIdentity4x4()

   665 {

   666     for (int i = 0; i < 4 * 4; ++i) {

   667         QMatrix4x4 m;

   668         QVERIFY(m.isIdentity());

   669         m.data()[i] = 42.0f;

   670         QVERIFY(!m.isIdentity());

   671     }

   672 

   673     // Force the "Identity" flag bit to be lost and check again.

   674     QMatrix4x4 m2;

   675     m2.data()[0] = 1.0f;

   676     QVERIFY(m2.isIdentity());

   677 }

   678 

   679 // Test isIdentity() for 4x3 matrices.

   680 void tst_QMatrixNxN::isIdentity4x3()

   681 {

   682     for (int i = 0; i < 4 * 3; ++i) {

   683         QMatrix4x3 m;

   684         QVERIFY(m.isIdentity());

   685         m.data()[i] = 42.0f;

   686         QVERIFY(!m.isIdentity());

   687     }

   688 }

   689 

   690 // Test 2x2 matrix comparisons.

   691 void tst_QMatrixNxN::compare2x2()

   692 {

   693     QMatrix2x2 m1(uniqueValues2);

   694     QMatrix2x2 m2(uniqueValues2);

   695     QMatrix2x2 m3(transposedValues2);

   696 

   697     QVERIFY(m1 == m2);

   698     QVERIFY(!(m1 != m2));

   699     QVERIFY(m1 != m3);

   700     QVERIFY(!(m1 == m3));

   701 }

   702 

   703 // Test 3x3 matrix comparisons.

   704 void tst_QMatrixNxN::compare3x3()

   705 {

   706     QMatrix3x3 m1(uniqueValues3);

   707     QMatrix3x3 m2(uniqueValues3);

   708     QMatrix3x3 m3(transposedValues3);

   709 

   710     QVERIFY(m1 == m2);

   711     QVERIFY(!(m1 != m2));

   712     QVERIFY(m1 != m3);

   713     QVERIFY(!(m1 == m3));

   714 }

   715 

   716 // Test 4x4 matrix comparisons.

   717 void tst_QMatrixNxN::compare4x4()

   718 {

   719     QMatrix4x4 m1(uniqueValues4);

   720     QMatrix4x4 m2(uniqueValues4);

   721     QMatrix4x4 m3(transposedValues4);

   722 

   723     QVERIFY(m1 == m2);

   724     QVERIFY(!(m1 != m2));

   725     QVERIFY(m1 != m3);

   726     QVERIFY(!(m1 == m3));

   727 }

   728 

   729 // Test 4x3 matrix comparisons.

   730 void tst_QMatrixNxN::compare4x3()

   731 {

   732     QMatrix4x3 m1(uniqueValues4x3);

   733     QMatrix4x3 m2(uniqueValues4x3);

   734     QMatrix4x3 m3(transposedValues3x4);

   735 

   736     QVERIFY(m1 == m2);

   737     QVERIFY(!(m1 != m2));

   738     QVERIFY(m1 != m3);

   739     QVERIFY(!(m1 == m3));

   740 }

   741 

   742 // Test matrix 2x2 transpose operations.

   743 void tst_QMatrixNxN::transposed2x2()

   744 {

   745     // Transposing the identity should result in the identity.

   746     QMatrix2x2 m1;

   747     QMatrix2x2 m2 = m1.transposed();

   748     QVERIFY(isIdentity(m2));

   749 

   750     // Transpose a more interesting matrix that allows us to track

   751     // exactly where each source element ends up.

   752     QMatrix2x2 m3(uniqueValues2);

   753     QMatrix2x2 m4 = m3.transposed();

   754     QVERIFY(isSame(m4, transposedValues2));

   755 

   756     // Transpose in-place, just to check that the compiler is sane.

   757     m3 = m3.transposed();

   758     QVERIFY(isSame(m3, transposedValues2));

   759 }

   760 

   761 // Test matrix 3x3 transpose operations.

   762 void tst_QMatrixNxN::transposed3x3()

   763 {

   764     // Transposing the identity should result in the identity.

   765     QMatrix3x3 m1;

   766     QMatrix3x3 m2 = m1.transposed();

   767     QVERIFY(isIdentity(m2));

   768 

   769     // Transpose a more interesting matrix that allows us to track

   770     // exactly where each source element ends up.

   771     QMatrix3x3 m3(uniqueValues3);

   772     QMatrix3x3 m4 = m3.transposed();

   773     QVERIFY(isSame(m4, transposedValues3));

   774 

   775     // Transpose in-place, just to check that the compiler is sane.

   776     m3 = m3.transposed();

   777     QVERIFY(isSame(m3, transposedValues3));

   778 }

   779 

   780 // Test matrix 4x4 transpose operations.

   781 void tst_QMatrixNxN::transposed4x4()

   782 {

   783     // Transposing the identity should result in the identity.

   784     QMatrix4x4 m1;

   785     QMatrix4x4 m2 = m1.transposed();

   786     QVERIFY(isIdentity(m2));

   787 

   788     // Transpose a more interesting matrix that allows us to track

   789     // exactly where each source element ends up.

   790     QMatrix4x4 m3(uniqueValues4);

   791     QMatrix4x4 m4 = m3.transposed();

   792     QVERIFY(isSame(m4, transposedValues4));

   793 

   794     // Transpose in-place, just to check that the compiler is sane.

   795     m3 = m3.transposed();

   796     QVERIFY(isSame(m3, transposedValues4));

   797 }

   798 

   799 // Test matrix 4x3 transpose operations.

   800 void tst_QMatrixNxN::transposed4x3()

   801 {

   802     QMatrix4x3 m3(uniqueValues4x3);

   803     QMatrix3x4 m4 = m3.transposed();

   804     qreal values[12];

   805     m4.toValueArray(values);

   806     for (int index = 0; index < 12; ++index)

   807         QCOMPARE(values[index], transposedValues3x4[index]);

   808 }

   809 

   810 // Test matrix addition for 2x2 matrices.

   811 void tst_QMatrixNxN::add2x2_data()

   812 {

   813     QTest::addColumn<void *>("m1Values");

   814     QTest::addColumn<void *>("m2Values");

   815     QTest::addColumn<void *>("m3Values");

   816 

   817     QTest::newRow("null")

   818         << (void *)nullValues2 << (void *)nullValues2 << (void *)nullValues2;

   819 

   820     QTest::newRow("identity/null")

   821         << (void *)identityValues2 << (void *)nullValues2 << (void *)identityValues2;

   822 

   823     QTest::newRow("identity/identity")

   824         << (void *)identityValues2 << (void *)identityValues2 << (void *)doubleIdentity2;

   825 

   826     static qreal const sumValues[16] =

   827         {2.0f, 7.0f,

   828          7.0f, 12.0f};

   829     QTest::newRow("unique")

   830         << (void *)uniqueValues2 << (void *)transposedValues2 << (void *)sumValues;

   831 }

   832 void tst_QMatrixNxN::add2x2()

   833 {

   834     QFETCH(void *, m1Values);

   835     QFETCH(void *, m2Values);

   836     QFETCH(void *, m3Values);

   837 

   838     QMatrix2x2 m1((const qreal *)m1Values);

   839     QMatrix2x2 m2((const qreal *)m2Values);

   840 

   841     QMatrix2x2 m4(m1);

   842     m4 += m2;

   843     QVERIFY(isSame(m4, (const qreal *)m3Values));

   844 

   845     QMatrix2x2 m5;

   846     m5 = m1 + m2;

   847     QVERIFY(isSame(m5, (const qreal *)m3Values));

   848 }

   849 

   850 // Test matrix addition for 3x3 matrices.

   851 void tst_QMatrixNxN::add3x3_data()

   852 {

   853     QTest::addColumn<void *>("m1Values");

   854     QTest::addColumn<void *>("m2Values");

   855     QTest::addColumn<void *>("m3Values");

   856 

   857     QTest::newRow("null")

   858         << (void *)nullValues3 << (void *)nullValues3 << (void *)nullValues3;

   859 

   860     QTest::newRow("identity/null")

   861         << (void *)identityValues3 << (void *)nullValues3 << (void *)identityValues3;

   862 

   863     QTest::newRow("identity/identity")

   864         << (void *)identityValues3 << (void *)identityValues3 << (void *)doubleIdentity3;

   865 

   866     static qreal const sumValues[16] =

   867         {2.0f, 7.0f, 12.0f,

   868          7.0f, 12.0f, 17.0f,

   869          12.0f, 17.0f, 22.0f};

   870     QTest::newRow("unique")

   871         << (void *)uniqueValues3 << (void *)transposedValues3 << (void *)sumValues;

   872 }

   873 void tst_QMatrixNxN::add3x3()

   874 {

   875     QFETCH(void *, m1Values);

   876     QFETCH(void *, m2Values);

   877     QFETCH(void *, m3Values);

   878 

   879     QMatrix3x3 m1((const qreal *)m1Values);

   880     QMatrix3x3 m2((const qreal *)m2Values);

   881 

   882     QMatrix3x3 m4(m1);

   883     m4 += m2;

   884     QVERIFY(isSame(m4, (const qreal *)m3Values));

   885 

   886     QMatrix3x3 m5;

   887     m5 = m1 + m2;

   888     QVERIFY(isSame(m5, (const qreal *)m3Values));

   889 }

   890 

   891 // Test matrix addition for 4x4 matrices.

   892 void tst_QMatrixNxN::add4x4_data()

   893 {

   894     QTest::addColumn<void *>("m1Values");

   895     QTest::addColumn<void *>("m2Values");

   896     QTest::addColumn<void *>("m3Values");

   897 

   898     QTest::newRow("null")

   899         << (void *)nullValues4 << (void *)nullValues4 << (void *)nullValues4;

   900 

   901     QTest::newRow("identity/null")

   902         << (void *)identityValues4 << (void *)nullValues4 << (void *)identityValues4;

   903 

   904     QTest::newRow("identity/identity")

   905         << (void *)identityValues4 << (void *)identityValues4 << (void *)doubleIdentity4;

   906 

   907     static qreal const sumValues[16] =

   908         {2.0f, 7.0f, 12.0f, 17.0f,

   909          7.0f, 12.0f, 17.0f, 22.0f,

   910          12.0f, 17.0f, 22.0f, 27.0f,

   911          17.0f, 22.0f, 27.0f, 32.0f};

   912     QTest::newRow("unique")

   913         << (void *)uniqueValues4 << (void *)transposedValues4 << (void *)sumValues;

   914 }

   915 void tst_QMatrixNxN::add4x4()

   916 {

   917     QFETCH(void *, m1Values);

   918     QFETCH(void *, m2Values);

   919     QFETCH(void *, m3Values);

   920 

   921     QMatrix4x4 m1((const qreal *)m1Values);

   922     QMatrix4x4 m2((const qreal *)m2Values);

   923 

   924     QMatrix4x4 m4(m1);

   925     m4 += m2;

   926     QVERIFY(isSame(m4, (const qreal *)m3Values));

   927 

   928     QMatrix4x4 m5;

   929     m5 = m1 + m2;

   930     QVERIFY(isSame(m5, (const qreal *)m3Values));

   931 }

   932 

   933 // Test matrix addition for 4x3 matrices.

   934 void tst_QMatrixNxN::add4x3_data()

   935 {

   936     QTest::addColumn<void *>("m1Values");

   937     QTest::addColumn<void *>("m2Values");

   938     QTest::addColumn<void *>("m3Values");

   939 

   940     QTest::newRow("null")

   941         << (void *)nullValues4x3 << (void *)nullValues4x3 << (void *)nullValues4x3;

   942 

   943     QTest::newRow("identity/null")

   944         << (void *)identityValues4x3 << (void *)nullValues4x3 << (void *)identityValues4x3;

   945 

   946     QTest::newRow("identity/identity")

   947         << (void *)identityValues4x3 << (void *)identityValues4x3 << (void *)doubleIdentity4x3;

   948 

   949     static qreal const sumValues[16] =

   950         {2.0f, 7.0f, 12.0f, 6.0f,

   951          11.0f, 16.0f, 10.0f, 15.0f,

   952          20.0f, 14.0f, 19.0f, 24.0f};

   953     QTest::newRow("unique")

   954         << (void *)uniqueValues4x3 << (void *)transposedValues3x4 << (void *)sumValues;

   955 }

   956 void tst_QMatrixNxN::add4x3()

   957 {

   958     QFETCH(void *, m1Values);

   959     QFETCH(void *, m2Values);

   960     QFETCH(void *, m3Values);

   961 

   962     QMatrix4x3 m1((const qreal *)m1Values);

   963     QMatrix4x3 m2((const qreal *)m2Values);

   964 

   965     QMatrix4x3 m4(m1);

   966     m4 += m2;

   967     QVERIFY(isSame(m4, (const qreal *)m3Values));

   968 

   969     QMatrix4x3 m5;

   970     m5 = m1 + m2;

   971     QVERIFY(isSame(m5, (const qreal *)m3Values));

   972 }

   973 

   974 // Test matrix subtraction for 2x2 matrices.

   975 void tst_QMatrixNxN::subtract2x2_data()

   976 {

   977     // Use the same test cases as the add test.

   978     add2x2_data();

   979 }

   980 void tst_QMatrixNxN::subtract2x2()

   981 {

   982     QFETCH(void *, m1Values);

   983     QFETCH(void *, m2Values);

   984     QFETCH(void *, m3Values);

   985 

   986     QMatrix2x2 m1((const qreal *)m1Values);

   987     QMatrix2x2 m2((const qreal *)m2Values);

   988     QMatrix2x2 m3((const qreal *)m3Values);

   989 

   990     QMatrix2x2 m4(m3);

   991     m4 -= m1;

   992     QVERIFY(isSame(m4, (const qreal *)m2Values));

   993 

   994     QMatrix2x2 m5;

   995     m5 = m3 - m1;

   996     QVERIFY(isSame(m5, (const qreal *)m2Values));

   997 

   998     QMatrix2x2 m6(m3);

   999     m6 -= m2;

  1000     QVERIFY(isSame(m6, (const qreal *)m1Values));

  1001 

  1002     QMatrix2x2 m7;

  1003     m7 = m3 - m2;

  1004     QVERIFY(isSame(m7, (const qreal *)m1Values));

  1005 }

  1006 

  1007 // Test matrix subtraction for 3x3 matrices.

  1008 void tst_QMatrixNxN::subtract3x3_data()

  1009 {

  1010     // Use the same test cases as the add test.

  1011     add3x3_data();

  1012 }

  1013 void tst_QMatrixNxN::subtract3x3()

  1014 {

  1015     QFETCH(void *, m1Values);

  1016     QFETCH(void *, m2Values);

  1017     QFETCH(void *, m3Values);

  1018 

  1019     QMatrix3x3 m1((const qreal *)m1Values);

  1020     QMatrix3x3 m2((const qreal *)m2Values);

  1021     QMatrix3x3 m3((const qreal *)m3Values);

  1022 

  1023     QMatrix3x3 m4(m3);

  1024     m4 -= m1;

  1025     QVERIFY(isSame(m4, (const qreal *)m2Values));

  1026 

  1027     QMatrix3x3 m5;

  1028     m5 = m3 - m1;

  1029     QVERIFY(isSame(m5, (const qreal *)m2Values));

  1030 

  1031     QMatrix3x3 m6(m3);

  1032     m6 -= m2;

  1033     QVERIFY(isSame(m6, (const qreal *)m1Values));

  1034 

  1035     QMatrix3x3 m7;

  1036     m7 = m3 - m2;

  1037     QVERIFY(isSame(m7, (const qreal *)m1Values));

  1038 }

  1039 

  1040 // Test matrix subtraction for 4x4 matrices.

  1041 void tst_QMatrixNxN::subtract4x4_data()

  1042 {

  1043     // Use the same test cases as the add test.

  1044     add4x4_data();

  1045 }

  1046 void tst_QMatrixNxN::subtract4x4()

  1047 {

  1048     QFETCH(void *, m1Values);

  1049     QFETCH(void *, m2Values);

  1050     QFETCH(void *, m3Values);

  1051 

  1052     QMatrix4x4 m1((const qreal *)m1Values);

  1053     QMatrix4x4 m2((const qreal *)m2Values);

  1054     QMatrix4x4 m3((const qreal *)m3Values);

  1055 

  1056     QMatrix4x4 m4(m3);

  1057     m4 -= m1;

  1058     QVERIFY(isSame(m4, (const qreal *)m2Values));

  1059 

  1060     QMatrix4x4 m5;

  1061     m5 = m3 - m1;

  1062     QVERIFY(isSame(m5, (const qreal *)m2Values));

  1063 

  1064     QMatrix4x4 m6(m3);

  1065     m6 -= m2;

  1066     QVERIFY(isSame(m6, (const qreal *)m1Values));

  1067 

  1068     QMatrix4x4 m7;

  1069     m7 = m3 - m2;

  1070     QVERIFY(isSame(m7, (const qreal *)m1Values));

  1071 }

  1072 

  1073 // Test matrix subtraction for 4x3 matrices.

  1074 void tst_QMatrixNxN::subtract4x3_data()

  1075 {

  1076     // Use the same test cases as the add test.

  1077     add4x3_data();

  1078 }

  1079 void tst_QMatrixNxN::subtract4x3()

  1080 {

  1081     QFETCH(void *, m1Values);

  1082     QFETCH(void *, m2Values);

  1083     QFETCH(void *, m3Values);

  1084 

  1085     QMatrix4x3 m1((const qreal *)m1Values);

  1086     QMatrix4x3 m2((const qreal *)m2Values);

  1087     QMatrix4x3 m3((const qreal *)m3Values);

  1088 

  1089     QMatrix4x3 m4(m3);

  1090     m4 -= m1;

  1091     QVERIFY(isSame(m4, (const qreal *)m2Values));

  1092 

  1093     QMatrix4x3 m5;

  1094     m5 = m3 - m1;

  1095     QVERIFY(isSame(m5, (const qreal *)m2Values));

  1096 

  1097     QMatrix4x3 m6(m3);

  1098     m6 -= m2;

  1099     QVERIFY(isSame(m6, (const qreal *)m1Values));

  1100 

  1101     QMatrix4x3 m7;

  1102     m7 = m3 - m2;

  1103     QVERIFY(isSame(m7, (const qreal *)m1Values));

  1104 }

  1105 

  1106 // Test matrix multiplication for 2x2 matrices.

  1107 void tst_QMatrixNxN::multiply2x2_data()

  1108 {

  1109     QTest::addColumn<void *>("m1Values");

  1110     QTest::addColumn<void *>("m2Values");

  1111     QTest::addColumn<void *>("m3Values");

  1112 

  1113     QTest::newRow("null")

  1114         << (void *)nullValues2 << (void *)nullValues2 << (void *)nullValues2;

  1115 

  1116     QTest::newRow("null/unique")

  1117         << (void *)nullValues2 << (void *)uniqueValues2 << (void *)nullValues2;

  1118 

  1119     QTest::newRow("unique/null")

  1120         << (void *)uniqueValues2 << (void *)nullValues2 << (void *)nullValues2;

  1121 

  1122     QTest::newRow("unique/identity")

  1123         << (void *)uniqueValues2 << (void *)identityValues2 << (void *)uniqueValues2;

  1124 

  1125     QTest::newRow("identity/unique")

  1126         << (void *)identityValues2 << (void *)uniqueValues2 << (void *)uniqueValues2;

  1127 

  1128     static qreal uniqueResult[4];

  1129     for (int row = 0; row < 2; ++row) {

  1130         for (int col = 0; col < 2; ++col) {

  1131             qreal sum = 0.0f;

  1132             for (int j = 0; j < 2; ++j)

  1133                 sum += uniqueValues2[row * 2 + j] * transposedValues2[j * 2 + col];

  1134             uniqueResult[row * 2 + col] = sum;