From b28b90a9df32f67ec573c9397567f9d2e0e8c480 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vladim=C3=ADr=20Vondru=C5=A1?= Date: Sat, 16 Mar 2013 21:12:51 +0100 Subject: [PATCH] Math: merged constExpressions() test cases into other test cases. Simplifies the code and reduces duplicates. --- src/Math/Test/ComplexTest.cpp | 61 +++++++++++----------------- src/Math/Test/DualComplexTest.cpp | 48 +++++++++------------- src/Math/Test/DualQuaternionTest.cpp | 49 ++++++++++------------ src/Math/Test/DualTest.cpp | 53 ++++++++++-------------- src/Math/Test/QuaternionTest.cpp | 54 +++++++++--------------- 5 files changed, 105 insertions(+), 160 deletions(-) diff --git a/src/Math/Test/ComplexTest.cpp b/src/Math/Test/ComplexTest.cpp index ae5b2a6e4..ecf939ada 100644 --- a/src/Math/Test/ComplexTest.cpp +++ b/src/Math/Test/ComplexTest.cpp @@ -37,12 +37,11 @@ class ComplexTest: public Corrade::TestSuite::Tester { void construct(); void constructDefault(); void constructFromVector(); + void constructCopy(); void compare(); void isNormalized(); - void constExpressions(); - void addSubtract(); void negated(); void multiplyDivideScalar(); @@ -69,12 +68,11 @@ ComplexTest::ComplexTest() { addTests({&ComplexTest::construct, &ComplexTest::constructDefault, &ComplexTest::constructFromVector, + &ComplexTest::constructCopy, &ComplexTest::compare, &ComplexTest::isNormalized, - &ComplexTest::constExpressions, - &ComplexTest::addSubtract, &ComplexTest::negated, &ComplexTest::multiplyDivideScalar, @@ -105,22 +103,35 @@ typedef Math::Matrix3 Matrix3; typedef Math::Matrix<2, Float> Matrix2; void ComplexTest::construct() { - Complex c(0.5f, -3.7f); - CORRADE_COMPARE(c.real(), 0.5f); - CORRADE_COMPARE(c.imaginary(), -3.7f); + constexpr Complex a(0.5f, -3.7f); + CORRADE_COMPARE(a, Complex(0.5f, -3.7f)); + + constexpr Float b = a.real(); + constexpr Float c = a.imaginary(); + CORRADE_COMPARE(b, 0.5f); + CORRADE_COMPARE(c, -3.7f); } void ComplexTest::constructDefault() { - CORRADE_COMPARE(Complex(), Complex(1.0f, 0.0f)); - CORRADE_COMPARE(Complex().length(), 1.0f); + constexpr Complex a; + CORRADE_COMPARE(a, Complex(1.0f, 0.0f)); + CORRADE_COMPARE(a.length(), 1.0f); } void ComplexTest::constructFromVector() { - Vector2 vec(1.5f, -3.0f); + constexpr Vector2 vec(1.5f, -3.0f); - Complex a(vec); + constexpr Complex a(vec); CORRADE_COMPARE(a, Complex(1.5f, -3.0f)); - CORRADE_COMPARE(Vector2(a), vec); + + constexpr Vector2 b(a); + CORRADE_COMPARE(b, vec); +} + +void ComplexTest::constructCopy() { + constexpr Complex a(2.5f, -5.0f); + constexpr Complex b(a); + CORRADE_COMPARE(b, Complex(2.5f, -5.0f)); } void ComplexTest::compare() { @@ -135,32 +146,6 @@ void ComplexTest::isNormalized() { CORRADE_VERIFY(Complex::rotation(Deg(23.0f)).isNormalized()); } -void ComplexTest::constExpressions() { - /* Default constructor */ - constexpr Complex a; - CORRADE_COMPARE(a, Complex(1.0f, 0.0f)); - - /* Value constructor */ - constexpr Complex b(2.5f, -5.0f); - CORRADE_COMPARE(b, Complex(2.5f, -5.0f)); - - /* Vector constructor */ - constexpr Complex c(Vector2(-1.0f, 2.2f)); - CORRADE_COMPARE(c, Complex(-1.0f, 2.2f)); - - /* Copy constructor */ - constexpr Complex d(b); - CORRADE_COMPARE(d, Complex(2.5f, -5.0f)); - - /* Data access */ - constexpr Float e = b.real(); - constexpr Float f = b.imaginary(); - constexpr Vector2 g(b); - CORRADE_COMPARE(e, 2.5f); - CORRADE_COMPARE(f, -5.0f); - CORRADE_COMPARE(g, Vector2(2.5f, -5.0f)); -} - void ComplexTest::addSubtract() { Complex a( 1.7f, -3.7f); Complex b(-3.6f, 0.2f); diff --git a/src/Math/Test/DualComplexTest.cpp b/src/Math/Test/DualComplexTest.cpp index 6ea187159..9e8f0ca20 100644 --- a/src/Math/Test/DualComplexTest.cpp +++ b/src/Math/Test/DualComplexTest.cpp @@ -37,11 +37,10 @@ class DualComplexTest: public Corrade::TestSuite::Tester { void construct(); void constructDefault(); void constructFromVector(); + void constructCopy(); void isNormalized(); - void constExpressions(); - void multiply(); void lengthSquared(); @@ -75,11 +74,10 @@ DualComplexTest::DualComplexTest() { addTests({&DualComplexTest::construct, &DualComplexTest::constructDefault, &DualComplexTest::constructFromVector, + &DualComplexTest::constructCopy, &DualComplexTest::isNormalized, - &DualComplexTest::constExpressions, - &DualComplexTest::multiply, &DualComplexTest::lengthSquared, @@ -102,18 +100,30 @@ DualComplexTest::DualComplexTest() { } void DualComplexTest::construct() { - DualComplex a({-1.0f, 2.5f}, {3.0f, -7.5f}); - CORRADE_COMPARE(a.real(), Complex(-1.0f, 2.5f)); - CORRADE_COMPARE(a.dual(), Complex(3.0f, -7.5f)); + constexpr DualComplex a({-1.0f, 2.5f}, {3.0f, -7.5f}); + CORRADE_COMPARE(a, DualComplex({-1.0f, 2.5f}, {3.0f, -7.5f})); + + constexpr Complex b = a.real(); + constexpr Complex c = a.dual(); + CORRADE_COMPARE(b, Complex(-1.0f, 2.5f)); + CORRADE_COMPARE(c, Complex(3.0f, -7.5f)); } void DualComplexTest::constructDefault() { - CORRADE_COMPARE(DualComplex(), DualComplex({1.0f, 0.0f}, {0.0f, 0.0f})); - CORRADE_COMPARE(DualComplex().length(), 1.0f); + constexpr DualComplex a; + CORRADE_COMPARE(a, DualComplex({1.0f, 0.0f}, {0.0f, 0.0f})); + CORRADE_COMPARE(a.length(), 1.0f); } void DualComplexTest::constructFromVector() { - CORRADE_COMPARE(DualComplex(Vector2(1.5f, -3.0f)), DualComplex({1.0f, 0.0f}, {1.5f, -3.0f})); + constexpr DualComplex a(Vector2(1.5f, -3.0f)); + CORRADE_COMPARE(a, DualComplex({1.0f, 0.0f}, {1.5f, -3.0f})); +} + +void DualComplexTest::constructCopy() { + constexpr DualComplex a({-1.0f, 2.5f}, {3.0f, -7.5f}); + constexpr DualComplex b(a); + CORRADE_COMPARE(a, DualComplex({-1.0f, 2.5f}, {3.0f, -7.5f})); } void DualComplexTest::isNormalized() { @@ -121,24 +131,6 @@ void DualComplexTest::isNormalized() { CORRADE_VERIFY((DualComplex::rotation(Deg(23.0f))*DualComplex::translation({6.0f, 3.0f})).isNormalized()); } -void DualComplexTest::constExpressions() { - /* Default constructor */ - constexpr DualComplex a; - CORRADE_COMPARE(a, DualComplex({1.0f, 0.0f}, {0.0f, 0.0f})); - - /* Value constructor */ - constexpr DualComplex b({-1.0f, 2.5f}, {3.0f, -7.5f}); - CORRADE_COMPARE(b, DualComplex({-1.0f, 2.5f}, {3.0f, -7.5f})); - - /* Vector constructor */ - constexpr DualComplex c(Vector2(-3.0f, 7.5f)); - CORRADE_COMPARE(c, DualComplex({}, {-3.0f, 7.5f})); - - /* Copy constructor */ - constexpr DualComplex d(b); - CORRADE_COMPARE(d, DualComplex({-1.0f, 2.5f}, {3.0f, -7.5f})); -} - void DualComplexTest::multiply() { DualComplex a({-1.5f, 2.0f}, { 3.0f, -6.5f}); DualComplex b({ 2.0f, -7.5f}, {-0.5f, 1.0f});; diff --git a/src/Math/Test/DualQuaternionTest.cpp b/src/Math/Test/DualQuaternionTest.cpp index db6809b26..f25594961 100644 --- a/src/Math/Test/DualQuaternionTest.cpp +++ b/src/Math/Test/DualQuaternionTest.cpp @@ -36,11 +36,10 @@ class DualQuaternionTest: public Corrade::TestSuite::Tester { void construct(); void constructDefault(); void constructFromVector(); + void constructCopy(); void isNormalized(); - void constExpressions(); - void lengthSquared(); void length(); void normalized(); @@ -73,11 +72,10 @@ DualQuaternionTest::DualQuaternionTest() { addTests({&DualQuaternionTest::construct, &DualQuaternionTest::constructDefault, &DualQuaternionTest::constructFromVector, + &DualQuaternionTest::constructCopy, &DualQuaternionTest::isNormalized, - &DualQuaternionTest::constExpressions, - &DualQuaternionTest::lengthSquared, &DualQuaternionTest::length, &DualQuaternionTest::normalized, @@ -99,18 +97,31 @@ DualQuaternionTest::DualQuaternionTest() { } void DualQuaternionTest::construct() { - DualQuaternion q({{1.0f, 2.0f, 3.0f}, -4.0f}, {{0.5f, -3.1f, 3.3f}, 2.0f}); - CORRADE_COMPARE(q.real(), Quaternion({1.0f, 2.0f, 3.0f}, -4.0f)); - CORRADE_COMPARE(q.dual(), Quaternion({0.5f, -3.1f, 3.3f}, 2.0f)); + constexpr DualQuaternion a({{1.0f, 2.0f, 3.0f}, -4.0f}, {{0.5f, -3.1f, 3.3f}, 2.0f}); + CORRADE_COMPARE(a, DualQuaternion({{1.0f, 2.0f, 3.0f}, -4.0f}, {{0.5f, -3.1f, 3.3f}, 2.0f})); + + constexpr Quaternion b = a.real(); + CORRADE_COMPARE(b, Quaternion({1.0f, 2.0f, 3.0f}, -4.0f)); + + constexpr Quaternion c = a.dual(); + CORRADE_COMPARE(c, Quaternion({0.5f, -3.1f, 3.3f}, 2.0f)); } void DualQuaternionTest::constructDefault() { - CORRADE_COMPARE(DualQuaternion(), DualQuaternion({{0.0f, 0.0f, 0.0f}, 1.0f}, {{0.0f, 0.0f, 0.0f}, 0.0f})); - CORRADE_COMPARE(DualQuaternion().length(), 1.0f); + constexpr DualQuaternion a; + CORRADE_COMPARE(a, DualQuaternion({{0.0f, 0.0f, 0.0f}, 1.0f}, {{0.0f, 0.0f, 0.0f}, 0.0f})); + CORRADE_COMPARE(a.length(), 1.0f); } void DualQuaternionTest::constructFromVector() { - CORRADE_COMPARE(DualQuaternion(Vector3(1.0f, 2.0f, 3.0f)), DualQuaternion({{0.0f, 0.0f, 0.0f}, 1.0f}, {{1.0f, 2.0f, 3.0f}, 0.0f})); + constexpr DualQuaternion a(Vector3(1.0f, 2.0f, 3.0f)); + CORRADE_COMPARE(a, DualQuaternion({{0.0f, 0.0f, 0.0f}, 1.0f}, {{1.0f, 2.0f, 3.0f}, 0.0f})); +} + +void DualQuaternionTest::constructCopy() { + constexpr DualQuaternion a({{1.0f, 2.0f, -3.0f}, -3.5f}, {{4.5f, -7.0f, 2.0f}, 1.0f}); + constexpr DualQuaternion b(a); + CORRADE_COMPARE(a, DualQuaternion({{1.0f, 2.0f, -3.0f}, -3.5f}, {{4.5f, -7.0f, 2.0f}, 1.0f})); } void DualQuaternionTest::isNormalized() { @@ -118,24 +129,6 @@ void DualQuaternionTest::isNormalized() { CORRADE_VERIFY((DualQuaternion::rotation(Deg(23.0f), Vector3::xAxis())*DualQuaternion::translation({3.0f, 1.0f, -0.5f})).isNormalized()); } -void DualQuaternionTest::constExpressions() { - /* Default constructor */ - constexpr DualQuaternion a; - CORRADE_COMPARE(a, DualQuaternion({{0.0f, 0.0f, 0.0f}, 1.0f}, {{0.0f, 0.0f, 0.0f}, 0.0f})); - - /* Value constructor */ - constexpr DualQuaternion b({{1.0f, 2.0f, -3.0f}, -3.5f}, {{4.5f, -7.0f, 2.0f}, 1.0f}); - CORRADE_COMPARE(b, DualQuaternion({{1.0f, 2.0f, -3.0f}, -3.5f}, {{4.5f, -7.0f, 2.0f}, 1.0f})); - - /* Vector constructor */ - constexpr DualQuaternion c(Vector3(1.5f, -5.0f, 3.0f)); - CORRADE_COMPARE(c, DualQuaternion({{0.0f, 0.0f, 0.0f}, 1.0f}, {{1.5f, -5.0f, 3.0f}, 0.0f})); - - /* Copy constructor */ - constexpr DualQuaternion d(b); - CORRADE_COMPARE(d, DualQuaternion({{1.0f, 2.0f, -3.0f}, -3.5f}, {{4.5f, -7.0f, 2.0f}, 1.0f})); -} - void DualQuaternionTest::lengthSquared() { DualQuaternion a({{1.0f, 2.0f, 3.0f}, -4.0f}, {{0.5f, -3.0f, 3.0f}, 2.0f}); CORRADE_COMPARE(a.lengthSquared(), Dual(30.0f, -9.0f)); diff --git a/src/Math/Test/DualTest.cpp b/src/Math/Test/DualTest.cpp index dd6338f0c..1bf0c2da7 100644 --- a/src/Math/Test/DualTest.cpp +++ b/src/Math/Test/DualTest.cpp @@ -35,9 +35,9 @@ class DualTest: public Corrade::TestSuite::Tester { void construct(); void constructDefault(); - void compare(); + void constructCopy(); - void constExpressions(); + void compare(); void addSubtract(); void negated(); @@ -54,9 +54,9 @@ typedef Math::Dual Dual; DualTest::DualTest() { addTests({&DualTest::construct, &DualTest::constructDefault, - &DualTest::compare, + &DualTest::constructCopy, - &DualTest::constExpressions, + &DualTest::compare, &DualTest::addSubtract, &DualTest::negated, @@ -69,17 +69,26 @@ DualTest::DualTest() { } void DualTest::construct() { - Dual a(2.0f, -7.5f); - CORRADE_COMPARE(a.real(), 2.0f); - CORRADE_COMPARE(a.dual(), -7.5f); - - Dual b(3.0f); - CORRADE_COMPARE(b.real(), 3.0f); - CORRADE_COMPARE(b.dual(), 0.0f); + constexpr Dual a(2.0f, -7.5f); + constexpr Float b = a.real(); + constexpr Float c = a.dual(); + CORRADE_COMPARE(b, 2.0f); + CORRADE_COMPARE(c, -7.5f); + + constexpr Dual d(3.0f); + CORRADE_COMPARE(d.real(), 3.0f); + CORRADE_COMPARE(d.dual(), 0.0f); } void DualTest::constructDefault() { - CORRADE_COMPARE(Dual(), Dual(0.0f, 0.0f)); + constexpr Dual a; + CORRADE_COMPARE(a, Dual(0.0f, 0.0f)); +} + +void DualTest::constructCopy() { + constexpr Dual a(2.0f, 3.0f); + constexpr Dual b(a); + CORRADE_COMPARE(b, Dual(2.0f, 3.0f)); } void DualTest::compare() { @@ -93,26 +102,6 @@ void DualTest::compare() { CORRADE_VERIFY(Dual(1.0f, 3.0f) != 1.0f); } -void DualTest::constExpressions() { - /* Default constructor */ - constexpr Dual a; - CORRADE_COMPARE(a, Dual(0.0f, 0.0f)); - - /* Value constructor */ - constexpr Dual b(2.0f, 3.0f); - CORRADE_COMPARE(b, Dual(2.0f, 3.0f)); - - /* Copy constructor */ - constexpr Dual c(b); - CORRADE_COMPARE(c, Dual(2.0f, 3.0f)); - - /* Data access */ - constexpr Float e = b.real(); - constexpr Float f = b.dual(); - CORRADE_COMPARE(e, 2.0f); - CORRADE_COMPARE(f, 3.0f); -} - void DualTest::addSubtract() { Dual a(2.0f, -7.5f); Dual b(-3.3f, 0.2f); diff --git a/src/Math/Test/QuaternionTest.cpp b/src/Math/Test/QuaternionTest.cpp index 4ffefcdd2..7cd6fc1d1 100644 --- a/src/Math/Test/QuaternionTest.cpp +++ b/src/Math/Test/QuaternionTest.cpp @@ -37,12 +37,11 @@ class QuaternionTest: public Corrade::TestSuite::Tester { void construct(); void constructDefault(); void constructFromVector(); + void constructCopy(); void compare(); void isNormalized(); - void constExpressions(); - void addSubtract(); void negated(); void multiplyDivideScalar(); @@ -80,12 +79,11 @@ QuaternionTest::QuaternionTest() { addTests({&QuaternionTest::construct, &QuaternionTest::constructDefault, &QuaternionTest::constructFromVector, + &QuaternionTest::constructCopy, &QuaternionTest::compare, &QuaternionTest::isNormalized, - &QuaternionTest::constExpressions, - &QuaternionTest::addSubtract, &QuaternionTest::negated, &QuaternionTest::multiplyDivideScalar, @@ -112,18 +110,30 @@ QuaternionTest::QuaternionTest() { } void QuaternionTest::construct() { - Quaternion q({1.0f, 2.0f, 3.0f}, -4.0f); - CORRADE_COMPARE(q.vector(), Vector3(1.0f, 2.0f, 3.0f)); - CORRADE_COMPARE(q.scalar(), -4.0f); + constexpr Quaternion a({1.0f, 2.0f, 3.0f}, -4.0f); + CORRADE_COMPARE(a, Quaternion({1.0f, 2.0f, 3.0f}, -4.0f)); + + constexpr Vector3 b = a.vector(); + constexpr Float c = a.scalar(); + CORRADE_COMPARE(b, Vector3(1.0f, 2.0f, 3.0f)); + CORRADE_COMPARE(c, -4.0f); } void QuaternionTest::constructDefault() { - CORRADE_COMPARE(Quaternion(), Quaternion({0.0f, 0.0f, 0.0f}, 1.0f)); - CORRADE_COMPARE(Quaternion().length(), 1.0f); + constexpr Quaternion a; + CORRADE_COMPARE(a, Quaternion({0.0f, 0.0f, 0.0f}, 1.0f)); + CORRADE_COMPARE(a.length(), 1.0f); } void QuaternionTest::constructFromVector() { - CORRADE_COMPARE(Quaternion(Vector3(1.0f, 2.0f, 3.0f)), Quaternion({1.0f, 2.0f, 3.0f}, 0.0f)); + constexpr Quaternion a(Vector3(1.0f, 2.0f, 3.0f)); + CORRADE_COMPARE(a, Quaternion({1.0f, 2.0f, 3.0f}, 0.0f)); +} + +void QuaternionTest::constructCopy() { + constexpr Quaternion a({1.0f, -3.0f, 7.0f}, 2.5f); + constexpr Quaternion b(a); + CORRADE_COMPARE(b, Quaternion({1.0f, -3.0f, 7.0f}, 2.5f)); } void QuaternionTest::compare() { @@ -138,30 +148,6 @@ void QuaternionTest::isNormalized() { CORRADE_VERIFY(Quaternion::rotation(Deg(23.0f), Vector3::xAxis()).isNormalized()); } -void QuaternionTest::constExpressions() { - /* Default constructor */ - constexpr Quaternion a; - CORRADE_COMPARE(a, Quaternion({0.0f, 0.0f, 0.0f}, 1.0f)); - - /* Value constructor */ - constexpr Quaternion b({1.0f, -3.0f, 7.0f}, 2.5f); - CORRADE_COMPARE(b, Quaternion({1.0f, -3.0f, 7.0f}, 2.5f)); - - /* Construct from vector */ - constexpr Quaternion c(Vector3(2.0f, -3.0f, 1.5f)); - CORRADE_COMPARE(c, Quaternion({2.0f, -3.0f, 1.5f}, 0.0f)); - - /* Copy constructor */ - constexpr Quaternion d(b); - CORRADE_COMPARE(d, Quaternion({1.0f, -3.0f, 7.0f}, 2.5f)); - - /* Data access */ - constexpr Vector3 e = b.vector(); - constexpr Float f = b.scalar(); - CORRADE_COMPARE(e, Vector3(1.0f, -3.0f, 7.0f)); - CORRADE_COMPARE(f, 2.5f); -} - void QuaternionTest::addSubtract() { Quaternion a({ 1.0f, 3.0f, -2.0f}, -4.0f); Quaternion b({-0.5f, 1.4f, 3.0f}, 12.0f);