309 lines
11 KiB
C++
309 lines
11 KiB
C++
#include <QtTest>
|
|
|
|
#include <array>
|
|
|
|
#include "fixedsizematrix.h"
|
|
|
|
class QFixedSizeMatrixTest : public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
public:
|
|
enum class TestEnum { ONE, TWO, THREE, FOUR };
|
|
Q_ENUM(TestEnum)
|
|
|
|
private Q_SLOTS:
|
|
void constructorTest();
|
|
void copyConstructorTest();
|
|
void assignmentOperatorTest();
|
|
void equalsOperatorTest();
|
|
void notEqualsOperatorTest();
|
|
void rotateLeftTest();
|
|
void rotateRightTest();
|
|
void rotate180Test();
|
|
void mirrorHorizontallyTest();
|
|
void mirrorVerticallyTest();
|
|
void asRotatedLeftTest();
|
|
void asRotatedRightTest();
|
|
void asRotated180Test();
|
|
void asMirroredHorizontally();
|
|
void asMirroredVertically();
|
|
|
|
private:
|
|
static const std::array<std::array<TestEnum, 2>, 4> demoData2x4;
|
|
static const std::array<std::array<TestEnum, 4>, 2> demoData2x4RotatedLeft;
|
|
static const std::array<std::array<TestEnum, 4>, 2> demoData2x4RotatedRight;
|
|
static const std::array<std::array<TestEnum, 2>, 4> demoData2x4Rotated180;
|
|
|
|
static const std::array<std::array<TestEnum, 4>, 4> demoData4x4;
|
|
static const std::array<std::array<TestEnum, 4>, 4> demoData4x4RotatedLeft;
|
|
static const std::array<std::array<TestEnum, 4>, 4> demoData4x4RotatedRight;
|
|
static const std::array<std::array<TestEnum, 4>, 4> demoData4x4Rotated180;
|
|
static const std::array<std::array<TestEnum, 4>, 4> demoData4x4HorizontallyMirrored;
|
|
static const std::array<std::array<TestEnum, 4>, 4> demoData4x4VerticallyMirrored;
|
|
|
|
template<unsigned int width, unsigned int height>
|
|
void verifyData(const FixedSizeMatrix<TestEnum, width, height>& matrix,
|
|
const std::array<std::array<QFixedSizeMatrixTest::TestEnum, width>, height> &data);
|
|
};
|
|
|
|
const std::array<std::array<QFixedSizeMatrixTest::TestEnum, 2>, 4> QFixedSizeMatrixTest::demoData2x4 {
|
|
std::array<TestEnum, 2> { TestEnum::ONE, TestEnum::ONE },
|
|
std::array<TestEnum, 2> { TestEnum::TWO, TestEnum::TWO },
|
|
std::array<TestEnum, 2> { TestEnum::THREE, TestEnum::THREE },
|
|
std::array<TestEnum, 2> { TestEnum::FOUR, TestEnum::FOUR }
|
|
};
|
|
|
|
const std::array<std::array<QFixedSizeMatrixTest::TestEnum, 4>, 2> QFixedSizeMatrixTest::demoData2x4RotatedLeft {
|
|
std::array<TestEnum, 4> { TestEnum::ONE, TestEnum::TWO, TestEnum::THREE, TestEnum::FOUR },
|
|
std::array<TestEnum, 4> { TestEnum::ONE, TestEnum::TWO, TestEnum::THREE, TestEnum::FOUR }
|
|
};
|
|
|
|
const std::array<std::array<QFixedSizeMatrixTest::TestEnum, 4>, 2> QFixedSizeMatrixTest::demoData2x4RotatedRight {
|
|
std::array<TestEnum, 4> { TestEnum::FOUR, TestEnum::THREE, TestEnum::TWO, TestEnum::ONE },
|
|
std::array<TestEnum, 4> { TestEnum::FOUR, TestEnum::THREE, TestEnum::TWO, TestEnum::ONE }
|
|
};
|
|
|
|
const std::array<std::array<QFixedSizeMatrixTest::TestEnum, 2>, 4> QFixedSizeMatrixTest::demoData2x4Rotated180 {
|
|
std::array<TestEnum, 2> { TestEnum::FOUR, TestEnum::FOUR },
|
|
std::array<TestEnum, 2> { TestEnum::THREE, TestEnum::THREE },
|
|
std::array<TestEnum, 2> { TestEnum::TWO, TestEnum::TWO },
|
|
std::array<TestEnum, 2> { TestEnum::ONE, TestEnum::ONE }
|
|
};
|
|
|
|
const std::array<std::array<QFixedSizeMatrixTest::TestEnum, 4>, 4> QFixedSizeMatrixTest::demoData4x4 {
|
|
std::array<TestEnum, 4> { TestEnum::ONE, TestEnum::ONE, TestEnum::TWO, TestEnum::TWO },
|
|
std::array<TestEnum, 4> { TestEnum::TWO, TestEnum::TWO, TestEnum::ONE, TestEnum::ONE },
|
|
std::array<TestEnum, 4> { TestEnum::THREE, TestEnum::THREE, TestEnum::FOUR, TestEnum::FOUR },
|
|
std::array<TestEnum, 4> { TestEnum::FOUR, TestEnum::FOUR, TestEnum::THREE, TestEnum::THREE }
|
|
};
|
|
|
|
const std::array<std::array<QFixedSizeMatrixTest::TestEnum, 4>, 4> QFixedSizeMatrixTest::demoData4x4RotatedLeft {
|
|
std::array<TestEnum, 4> { TestEnum::ONE, TestEnum::TWO, TestEnum::THREE, TestEnum::FOUR },
|
|
std::array<TestEnum, 4> { TestEnum::ONE, TestEnum::TWO, TestEnum::THREE, TestEnum::FOUR },
|
|
std::array<TestEnum, 4> { TestEnum::TWO, TestEnum::ONE, TestEnum::FOUR, TestEnum::THREE },
|
|
std::array<TestEnum, 4> { TestEnum::TWO, TestEnum::ONE, TestEnum::FOUR, TestEnum::THREE }
|
|
};
|
|
|
|
const std::array<std::array<QFixedSizeMatrixTest::TestEnum, 4>, 4> QFixedSizeMatrixTest::demoData4x4RotatedRight {
|
|
std::array<TestEnum, 4> { TestEnum::FOUR, TestEnum::FOUR, TestEnum::TWO, TestEnum::TWO },
|
|
std::array<TestEnum, 4> { TestEnum::FOUR, TestEnum::FOUR, TestEnum::TWO, TestEnum::TWO },
|
|
std::array<TestEnum, 4> { TestEnum::THREE, TestEnum::THREE, TestEnum::ONE, TestEnum::ONE },
|
|
std::array<TestEnum, 4> { TestEnum::THREE, TestEnum::THREE, TestEnum::ONE, TestEnum::ONE }
|
|
};
|
|
|
|
const std::array<std::array<QFixedSizeMatrixTest::TestEnum, 4>, 4> QFixedSizeMatrixTest::demoData4x4Rotated180 {
|
|
std::array<TestEnum, 4> { TestEnum::FOUR, TestEnum::FOUR, TestEnum::THREE, TestEnum::THREE },
|
|
std::array<TestEnum, 4> { TestEnum::FOUR, TestEnum::FOUR, TestEnum::THREE, TestEnum::THREE },
|
|
std::array<TestEnum, 4> { TestEnum::TWO, TestEnum::TWO, TestEnum::ONE, TestEnum::ONE },
|
|
std::array<TestEnum, 4> { TestEnum::TWO, TestEnum::TWO, TestEnum::ONE, TestEnum::ONE }
|
|
};
|
|
|
|
const std::array<std::array<QFixedSizeMatrixTest::TestEnum, 4>, 4> QFixedSizeMatrixTest::demoData4x4HorizontallyMirrored {
|
|
std::array<TestEnum, 4> { TestEnum::FOUR, TestEnum::FOUR, TestEnum::THREE, TestEnum::THREE },
|
|
std::array<TestEnum, 4> { TestEnum::THREE, TestEnum::THREE, TestEnum::FOUR, TestEnum::FOUR },
|
|
std::array<TestEnum, 4> { TestEnum::TWO, TestEnum::TWO, TestEnum::ONE, TestEnum::ONE },
|
|
std::array<TestEnum, 4> { TestEnum::ONE, TestEnum::ONE, TestEnum::TWO, TestEnum::TWO }
|
|
};
|
|
|
|
const std::array<std::array<QFixedSizeMatrixTest::TestEnum, 4>, 4> QFixedSizeMatrixTest::demoData4x4VerticallyMirrored {
|
|
std::array<TestEnum, 4> { TestEnum::TWO, TestEnum::TWO, TestEnum::ONE, TestEnum::ONE },
|
|
std::array<TestEnum, 4> { TestEnum::ONE, TestEnum::ONE, TestEnum::TWO, TestEnum::TWO },
|
|
std::array<TestEnum, 4> { TestEnum::FOUR, TestEnum::FOUR, TestEnum::THREE, TestEnum::THREE },
|
|
std::array<TestEnum, 4> { TestEnum::THREE, TestEnum::THREE, TestEnum::FOUR, TestEnum::FOUR }
|
|
};
|
|
|
|
template<unsigned int width, unsigned int height>
|
|
void QFixedSizeMatrixTest::verifyData(const FixedSizeMatrix<QFixedSizeMatrixTest::TestEnum, width, height> &matrix,
|
|
const std::array<std::array<QFixedSizeMatrixTest::TestEnum, width>, height> &data)
|
|
{
|
|
for(unsigned int y = 0; y < height; y++)
|
|
for(unsigned int x = 0; x < width; x++)
|
|
QCOMPARE(matrix(x, y), data[y][x]);
|
|
}
|
|
|
|
void QFixedSizeMatrixTest::constructorTest()
|
|
{
|
|
FixedSizeMatrix<TestEnum, 2, 4> matrix { demoData2x4 };
|
|
verifyData(matrix, demoData2x4);
|
|
}
|
|
|
|
void QFixedSizeMatrixTest::copyConstructorTest()
|
|
{
|
|
FixedSizeMatrix<TestEnum, 2, 4> matrix { demoData2x4 };
|
|
FixedSizeMatrix<TestEnum, 2, 4> otherMatrix { matrix };
|
|
verifyData(otherMatrix, demoData2x4);
|
|
}
|
|
|
|
void QFixedSizeMatrixTest::assignmentOperatorTest()
|
|
{
|
|
FixedSizeMatrix<TestEnum, 2, 4> matrix { demoData2x4 };
|
|
FixedSizeMatrix<TestEnum, 2, 4> other;
|
|
other = matrix;
|
|
verifyData(other, demoData2x4);
|
|
}
|
|
|
|
void QFixedSizeMatrixTest::equalsOperatorTest()
|
|
{
|
|
FixedSizeMatrix<TestEnum, 2, 4> matrix0 { demoData2x4 };
|
|
FixedSizeMatrix<TestEnum, 2, 4> matrix1;
|
|
|
|
QVERIFY2(!(matrix0 == matrix1), "");
|
|
|
|
matrix1 = FixedSizeMatrix<TestEnum, 2, 4> { demoData2x4 };
|
|
|
|
QVERIFY2(matrix0 == matrix1, "");
|
|
}
|
|
|
|
void QFixedSizeMatrixTest::notEqualsOperatorTest()
|
|
{
|
|
FixedSizeMatrix<TestEnum, 2, 4> matrix0 { demoData2x4 };
|
|
FixedSizeMatrix<TestEnum, 2, 4> matrix1;
|
|
|
|
QVERIFY2(matrix0 != matrix1, "");
|
|
|
|
matrix1 = FixedSizeMatrix<TestEnum, 2, 4> { demoData2x4 };
|
|
|
|
QVERIFY2(matrix0 == matrix1, "");
|
|
}
|
|
|
|
void QFixedSizeMatrixTest::rotateLeftTest()
|
|
{
|
|
FixedSizeMatrix<TestEnum, 4, 4> matrix { demoData4x4 };
|
|
|
|
matrix.rotateLeft();
|
|
verifyData(matrix, demoData4x4RotatedLeft);
|
|
|
|
matrix.rotateLeft();
|
|
verifyData(matrix, demoData4x4Rotated180);
|
|
|
|
matrix.rotateLeft();
|
|
verifyData(matrix, demoData4x4RotatedRight);
|
|
|
|
matrix.rotateLeft();
|
|
verifyData(matrix, demoData4x4);
|
|
}
|
|
|
|
void QFixedSizeMatrixTest::rotateRightTest()
|
|
{
|
|
FixedSizeMatrix<TestEnum, 4, 4> matrix { demoData4x4 };
|
|
|
|
matrix.rotateRight();
|
|
verifyData(matrix, demoData4x4RotatedRight);
|
|
|
|
matrix.rotateRight();
|
|
verifyData(matrix, demoData4x4Rotated180);
|
|
|
|
matrix.rotateRight();
|
|
verifyData(matrix, demoData4x4RotatedLeft);
|
|
|
|
matrix.rotateRight();
|
|
verifyData(matrix, demoData4x4);
|
|
}
|
|
|
|
void QFixedSizeMatrixTest::rotate180Test()
|
|
{
|
|
FixedSizeMatrix<TestEnum, 2, 4> matrix { demoData2x4 };
|
|
|
|
matrix.rotate180();
|
|
verifyData(matrix, demoData2x4Rotated180);
|
|
|
|
matrix.rotate180();
|
|
verifyData(matrix, demoData2x4);
|
|
}
|
|
|
|
void QFixedSizeMatrixTest::mirrorHorizontallyTest()
|
|
{
|
|
FixedSizeMatrix<TestEnum, 4, 4> matrix { demoData4x4 };
|
|
|
|
matrix.mirrorHorizontally();
|
|
verifyData(matrix, demoData4x4HorizontallyMirrored);
|
|
|
|
matrix.mirrorHorizontally();
|
|
verifyData(matrix, demoData4x4);
|
|
}
|
|
|
|
void QFixedSizeMatrixTest::mirrorVerticallyTest()
|
|
{
|
|
FixedSizeMatrix<TestEnum, 4, 4> matrix { demoData4x4 };
|
|
|
|
matrix.mirrorVertically();
|
|
verifyData(matrix, demoData4x4VerticallyMirrored);
|
|
|
|
matrix.mirrorVertically();
|
|
verifyData(matrix, demoData4x4);
|
|
}
|
|
|
|
void QFixedSizeMatrixTest::asRotatedLeftTest()
|
|
{
|
|
FixedSizeMatrix<TestEnum, 2, 4> matrix { demoData2x4 };
|
|
FixedSizeMatrix<TestEnum, 4, 2> rotatedContainer;
|
|
|
|
rotatedContainer = matrix.asRotatedLeft();
|
|
verifyData(rotatedContainer, demoData2x4RotatedLeft);
|
|
|
|
matrix = rotatedContainer.asRotatedLeft();
|
|
verifyData(matrix, demoData2x4Rotated180);
|
|
|
|
rotatedContainer = matrix.asRotatedLeft();
|
|
verifyData(rotatedContainer, demoData2x4RotatedRight);
|
|
|
|
matrix = rotatedContainer.asRotatedLeft();
|
|
verifyData(matrix, demoData2x4);
|
|
}
|
|
|
|
void QFixedSizeMatrixTest::asRotatedRightTest()
|
|
{
|
|
FixedSizeMatrix<TestEnum, 2, 4> matrix { demoData2x4 };
|
|
FixedSizeMatrix<TestEnum, 4, 2> rotatedContainer;
|
|
|
|
rotatedContainer = matrix.asRotatedRight();
|
|
verifyData(rotatedContainer, demoData2x4RotatedRight);
|
|
|
|
matrix = rotatedContainer.asRotatedRight();
|
|
verifyData(matrix, demoData2x4Rotated180);
|
|
|
|
rotatedContainer = matrix.asRotatedRight();
|
|
verifyData(rotatedContainer, demoData2x4RotatedLeft);
|
|
|
|
matrix = rotatedContainer.asRotatedRight();
|
|
verifyData(matrix, demoData2x4);
|
|
}
|
|
|
|
void QFixedSizeMatrixTest::asRotated180Test()
|
|
{
|
|
FixedSizeMatrix<TestEnum, 2, 4> matrix { demoData2x4 };
|
|
|
|
matrix = matrix.asRotated180();
|
|
verifyData(matrix, demoData2x4Rotated180);
|
|
|
|
matrix = matrix.asRotated180();
|
|
verifyData(matrix, demoData2x4);
|
|
}
|
|
|
|
void QFixedSizeMatrixTest::asMirroredHorizontally()
|
|
{
|
|
FixedSizeMatrix<TestEnum, 4, 4> matrix { demoData4x4 };
|
|
|
|
matrix = matrix.asMirroredHorizontally();
|
|
verifyData(matrix, demoData4x4HorizontallyMirrored);
|
|
|
|
matrix = matrix.asMirroredHorizontally();
|
|
verifyData(matrix, demoData4x4);
|
|
}
|
|
|
|
void QFixedSizeMatrixTest::asMirroredVertically()
|
|
{
|
|
FixedSizeMatrix<TestEnum, 4, 4> matrix { demoData4x4 };
|
|
|
|
matrix = matrix.asMirroredVertically();
|
|
verifyData(matrix, demoData4x4VerticallyMirrored);
|
|
|
|
matrix = matrix.asMirroredVertically();
|
|
verifyData(matrix, demoData4x4);
|
|
}
|
|
|
|
QTEST_APPLESS_MAIN(QFixedSizeMatrixTest)
|
|
|
|
#include "tst_qfixedsizematrixtest.moc"
|