ic
/
magnum
mirror of https://github.com/mosra/magnum.git
6
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Math: explicit test that all types are trivially copyable. 

I saw some copy constructors here and there and wasn't sure.
pull/518/head
Vladimír Vondruš 5 years ago
parent
7072befbdb
commit
08a6e7d957
22 changed files with 146 additions and 2 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 7
      src/Magnum/Math/Test/AngleTest.cpp
  2. 5
      src/Magnum/Math/Test/BezierTest.cpp
  3. 5
      src/Magnum/Math/Test/BoolVectorTest.cpp
  4. 7
      src/Magnum/Math/Test/ColorTest.cpp
  5. 5
      src/Magnum/Math/Test/ComplexTest.cpp
  6. 21
      src/Magnum/Math/Test/CubicHermiteTest.cpp
  7. 5
      src/Magnum/Math/Test/DualComplexTest.cpp
  8. 5
      src/Magnum/Math/Test/DualQuaternionTest.cpp
  9. 5
      src/Magnum/Math/Test/DualTest.cpp
  10. 5
      src/Magnum/Math/Test/FrustumTest.cpp
  11. 5
      src/Magnum/Math/Test/HalfTest.cpp
  12. 5
      src/Magnum/Math/Test/Matrix3Test.cpp
  13. 5
      src/Magnum/Math/Test/Matrix4Test.cpp
  14. 5
      src/Magnum/Math/Test/MatrixTest.cpp
  15. 5
      src/Magnum/Math/Test/QuaternionTest.cpp
  16. 9
      src/Magnum/Math/Test/RangeTest.cpp
  17. 5
      src/Magnum/Math/Test/RectangularMatrixTest.cpp
  18. 19
      src/Magnum/Math/Test/UnitTest.cpp
  19. 5
      src/Magnum/Math/Test/Vector2Test.cpp
  20. 5
      src/Magnum/Math/Test/Vector3Test.cpp
  21. 5
      src/Magnum/Math/Test/Vector4Test.cpp
  22. 5
      src/Magnum/Math/Test/VectorTest.cpp

7
src/Magnum/Math/Test/AngleTest.cpp
Unescape View File

@ -33,6 +33,7 @@
#include <Corrade/Utility/FormatStl.h>
#include <Corrade/Utility/TweakableParser.h>
#endif
#include <Corrade/Utility/TypeTraits.h> /* CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED */
#include "Magnum/Math/Angle.h"
@ -232,6 +233,12 @@ void AngleTest::constructCopy() {
constexpr Radd d(b);
CORRADE_COMPARE(d, b);
#ifdef CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED
CORRADE_VERIFY(std::is_trivially_copy_constructible<Deg>::value);
CORRADE_VERIFY(std::is_trivially_copy_constructible<Rad>::value);
CORRADE_VERIFY(std::is_trivially_copy_assignable<Deg>::value);
CORRADE_VERIFY(std::is_trivially_copy_assignable<Rad>::value);
#endif
CORRADE_VERIFY(std::is_nothrow_copy_constructible<Deg>::value);
CORRADE_VERIFY(std::is_nothrow_copy_constructible<Rad>::value);
CORRADE_VERIFY(std::is_nothrow_copy_assignable<Deg>::value);

5
src/Magnum/Math/Test/BezierTest.cpp
Unescape View File

@ -27,6 +27,7 @@
#include <sstream>
#include <Corrade/TestSuite/Tester.h>
#include <Corrade/Utility/DebugStl.h>
#include <Corrade/Utility/TypeTraits.h> /* CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED */
#include "Magnum/Math/Bezier.h"
#include "Magnum/Math/CubicHermite.h"
@ -185,6 +186,10 @@ void BezierTest::constructCopy() {
constexpr QuadraticBezier2D b{a};
CORRADE_COMPARE(b, (QuadraticBezier2D{Vector2{0.5f, 1.0f}, Vector2{1.1f, 0.3f}, Vector2{0.1f, 1.2f}}));
#ifdef CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED
CORRADE_VERIFY(std::is_trivially_copy_constructible<QuadraticBezier2D>::value);
CORRADE_VERIFY(std::is_trivially_copy_assignable<QuadraticBezier2D>::value);
#endif
CORRADE_VERIFY(std::is_nothrow_copy_constructible<QuadraticBezier2D>::value);
CORRADE_VERIFY(std::is_nothrow_copy_assignable<QuadraticBezier2D>::value);
}

5
src/Magnum/Math/Test/BoolVectorTest.cpp
Unescape View File

@ -26,6 +26,7 @@
#include <sstream>
#include <Corrade/TestSuite/Tester.h>
#include <Corrade/Utility/DebugStl.h>
#include <Corrade/Utility/TypeTraits.h> /* CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED */
#include "Magnum/Math/BoolVector.h"
#include "Magnum/Math/StrictWeakOrdering.h"
@ -176,6 +177,10 @@ void BoolVectorTest::constructCopy() {
constexpr BoolVector19 b(a);
CORRADE_COMPARE(b, BoolVector19(0xa5, 0x5f, 0x07));
#ifdef CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED
CORRADE_VERIFY(std::is_trivially_copy_constructible<BoolVector19>::value);
CORRADE_VERIFY(std::is_trivially_copy_assignable<BoolVector19>::value);
#endif
CORRADE_VERIFY(std::is_nothrow_copy_constructible<BoolVector19>::value);
CORRADE_VERIFY(std::is_nothrow_copy_assignable<BoolVector19>::value);
}

7
src/Magnum/Math/Test/ColorTest.cpp
Unescape View File

@ -32,6 +32,7 @@
#include <Corrade/Utility/FormatStl.h>
#include <Corrade/Utility/Tweakable.h>
#endif
#include <Corrade/Utility/TypeTraits.h> /* CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED */
#include "Magnum/Math/Color.h"
#include "Magnum/Math/Half.h"
@ -429,6 +430,12 @@ void ColorTest::constructCopy() {
Color4 d(c);
CORRADE_COMPARE(d, Color4(1.0f, 0.5f, 0.75f, 0.25f));
#ifdef CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED
CORRADE_VERIFY(std::is_trivially_copy_constructible<Color3>::value);
CORRADE_VERIFY(std::is_trivially_copy_constructible<Color4>::value);
CORRADE_VERIFY(std::is_trivially_copy_assignable<Color3>::value);
CORRADE_VERIFY(std::is_trivially_copy_assignable<Color4>::value);
#endif
CORRADE_VERIFY(std::is_nothrow_copy_constructible<Color3>::value);
CORRADE_VERIFY(std::is_nothrow_copy_constructible<Color4>::value);
CORRADE_VERIFY(std::is_nothrow_copy_assignable<Color3>::value);

5
src/Magnum/Math/Test/ComplexTest.cpp
Unescape View File

@ -26,6 +26,7 @@
#include <sstream>
#include <Corrade/TestSuite/Tester.h>
#include <Corrade/Utility/DebugStl.h>
#include <Corrade/Utility/TypeTraits.h> /* CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED */
#include "Magnum/Math/Complex.h"
#include "Magnum/Math/Matrix3.h"
@ -253,6 +254,10 @@ void ComplexTest::constructCopy() {
constexpr Complex b(a);
CORRADE_COMPARE(b, Complex(2.5f, -5.0f));
#ifdef CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED
CORRADE_VERIFY(std::is_trivially_copy_constructible<Complex>::value);
CORRADE_VERIFY(std::is_trivially_copy_assignable<Complex>::value);
#endif
CORRADE_VERIFY(std::is_nothrow_copy_constructible<Complex>::value);
CORRADE_VERIFY(std::is_nothrow_copy_assignable<Complex>::value);
}

21
src/Magnum/Math/Test/CubicHermiteTest.cpp
Unescape View File

@ -26,6 +26,7 @@
#include <sstream>
#include <Corrade/TestSuite/Tester.h>
#include <Corrade/Utility/DebugStl.h>
#include <Corrade/Utility/TypeTraits.h> /* CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED */
#include "Magnum/Math/Bezier.h"
#include "Magnum/Math/CubicHermite.h"
@ -588,6 +589,10 @@ void CubicHermiteTest::constructCopyScalar() {
CORRADE_COMPARE(b, (CubicHermite1D{2.0f, -2.0f, -0.5f}));
#ifdef CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED
CORRADE_VERIFY(std::is_trivially_copy_constructible<CubicHermite1D>::value);
CORRADE_VERIFY(std::is_trivially_copy_assignable<CubicHermite1D>::value);
#endif
CORRADE_VERIFY(std::is_nothrow_copy_constructible<CubicHermite1D>::value);
CORRADE_VERIFY(std::is_nothrow_copy_assignable<CubicHermite1D>::value);
}
@ -598,6 +603,10 @@ void CubicHermiteTest::constructCopyVector() {
CORRADE_COMPARE(b, (CubicHermite2D{{1.0f, 2.0f}, {1.5f, -2.0f}, {3.0f, -0.5f}}));
#ifdef CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED
CORRADE_VERIFY(std::is_trivially_copy_constructible<CubicHermite2D>::value);
CORRADE_VERIFY(std::is_trivially_copy_assignable<CubicHermite2D>::value);
#endif
CORRADE_VERIFY(std::is_nothrow_copy_constructible<CubicHermite2D>::value);
CORRADE_VERIFY(std::is_nothrow_copy_assignable<CubicHermite2D>::value);
}
@ -608,6 +617,10 @@ void CubicHermiteTest::constructCopyComplex() {
CORRADE_COMPARE(b, (CubicHermiteComplex{{1.0f, 2.0f}, {1.5f, -2.0f}, {3.0f, -0.5f}}));
#ifdef CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED
CORRADE_VERIFY(std::is_trivially_copy_constructible<CubicHermiteComplex>::value);
CORRADE_VERIFY(std::is_trivially_copy_assignable<CubicHermiteComplex>::value);
#endif
CORRADE_VERIFY(std::is_nothrow_copy_constructible<CubicHermiteComplex>::value);
CORRADE_VERIFY(std::is_nothrow_copy_assignable<CubicHermiteComplex>::value);
}
@ -624,8 +637,12 @@ void CubicHermiteTest::constructCopyQuaternion() {
{{1.5f, -2.0f, 0.1f}, 1.1f},
{{3.0f, -0.5f, 1.2f}, 0.3f}}));
CORRADE_VERIFY(std::is_nothrow_copy_constructible<CubicHermiteComplex>::value);
CORRADE_VERIFY(std::is_nothrow_copy_assignable<CubicHermiteComplex>::value);
#ifdef CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED
CORRADE_VERIFY(std::is_trivially_copy_constructible<CubicHermiteQuaternion>::value);
CORRADE_VERIFY(std::is_trivially_copy_assignable<CubicHermiteQuaternion>::value);
#endif
CORRADE_VERIFY(std::is_nothrow_copy_constructible<CubicHermiteQuaternion>::value);
CORRADE_VERIFY(std::is_nothrow_copy_assignable<CubicHermiteQuaternion>::value);
}
void CubicHermiteTest::dataScalar() {

5
src/Magnum/Math/Test/DualComplexTest.cpp
Unescape View File

@ -27,6 +27,7 @@
#include <sstream>
#include <Corrade/TestSuite/Tester.h>
#include <Corrade/Utility/DebugStl.h>
#include <Corrade/Utility/TypeTraits.h> /* CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED */
#include "Magnum/Math/DualComplex.h"
#include "Magnum/Math/DualQuaternion.h"
@ -246,6 +247,10 @@ void DualComplexTest::constructCopy() {
DualComplex b(a);
CORRADE_COMPARE(b, DualComplex({-1.0f, 2.5f}, {3.0f, -7.5f}));
#ifdef CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED
CORRADE_VERIFY(std::is_trivially_copy_constructible<DualComplex>::value);
CORRADE_VERIFY(std::is_trivially_copy_assignable<DualComplex>::value);
#endif
CORRADE_VERIFY(std::is_nothrow_copy_constructible<DualComplex>::value);
CORRADE_VERIFY(std::is_nothrow_copy_assignable<DualComplex>::value);
}

5
src/Magnum/Math/Test/DualQuaternionTest.cpp
Unescape View File

@ -27,6 +27,7 @@
#include <sstream>
#include <Corrade/TestSuite/Tester.h>
#include <Corrade/Utility/DebugStl.h>
#include <Corrade/Utility/TypeTraits.h> /* CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED */
#include "Magnum/Math/DualQuaternion.h"
#include "Magnum/Math/StrictWeakOrdering.h"
@ -275,6 +276,10 @@ void DualQuaternionTest::constructCopy() {
DualQuaternion b(a);
CORRADE_COMPARE(b, DualQuaternion({{1.0f, 2.0f, -3.0f}, -3.5f}, {{4.5f, -7.0f, 2.0f}, 1.0f}));
#ifdef CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED
CORRADE_VERIFY(std::is_trivially_copy_constructible<DualQuaternion>::value);
CORRADE_VERIFY(std::is_trivially_copy_assignable<DualQuaternion>::value);
#endif
CORRADE_VERIFY(std::is_nothrow_copy_constructible<DualQuaternion>::value);
CORRADE_VERIFY(std::is_nothrow_copy_assignable<DualQuaternion>::value);
}

5
src/Magnum/Math/Test/DualTest.cpp
Unescape View File

@ -26,6 +26,7 @@
#include <sstream>
#include <Corrade/TestSuite/Tester.h>
#include <Corrade/Utility/DebugStl.h>
#include <Corrade/Utility/TypeTraits.h> /* CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED */
#include "Magnum/Math/Dual.h"
#include "Magnum/Math/Quaternion.h"
@ -184,6 +185,10 @@ void DualTest::constructCopy() {
constexpr Dual b(a);
CORRADE_COMPARE(b, Dual(2.0f, 3.0f));
#ifdef CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED
CORRADE_VERIFY(std::is_trivially_copy_constructible<Dual>::value);
CORRADE_VERIFY(std::is_trivially_copy_assignable<Dual>::value);
#endif
CORRADE_VERIFY(std::is_nothrow_copy_constructible<Dual>::value);
CORRADE_VERIFY(std::is_nothrow_copy_assignable<Dual>::value);
}

5
src/Magnum/Math/Test/FrustumTest.cpp
Unescape View File

@ -29,6 +29,7 @@
#include <Corrade/TestSuite/Tester.h>
#include <Corrade/TestSuite/Compare/Container.h>
#include <Corrade/Utility/DebugStl.h>
#include <Corrade/Utility/TypeTraits.h> /* CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED */
#include "Magnum/Math/Frustum.h"
#include "Magnum/Math/StrictWeakOrdering.h"
@ -244,6 +245,10 @@ void FrustumTest::constructCopy() {
constexpr Frustum b{a};
CORRADE_COMPARE(b, a);
#ifdef CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED
CORRADE_VERIFY(std::is_trivially_copy_constructible<Frustum>::value);
CORRADE_VERIFY(std::is_trivially_copy_assignable<Frustum>::value);
#endif
CORRADE_VERIFY(std::is_nothrow_copy_constructible<Frustum>::value);
CORRADE_VERIFY(std::is_nothrow_copy_assignable<Frustum>::value);
}

5
src/Magnum/Math/Test/HalfTest.cpp
Unescape View File

@ -32,6 +32,7 @@
#if defined(DOXYGEN_GENERATING_OUTPUT) || defined(CORRADE_TARGET_UNIX) || (defined(CORRADE_TARGET_WINDOWS) && !defined(CORRADE_TARGET_WINDOWS_RT)) || defined(CORRADE_TARGET_EMSCRIPTEN)
#include <Corrade/Utility/Tweakable.h>
#endif
#include <Corrade/Utility/TypeTraits.h> /* CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED */
#include "Magnum/Math/Half.h"
#include "Magnum/Math/Packing.h"
@ -562,6 +563,10 @@ void HalfTest::constructCopy() {
CORRADE_COMPARE(b, Half{3.5f});
#ifdef CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED
CORRADE_VERIFY(std::is_trivially_copy_constructible<Half>::value);
CORRADE_VERIFY(std::is_trivially_copy_assignable<Half>::value);
#endif
CORRADE_VERIFY(std::is_nothrow_copy_constructible<Half>::value);
CORRADE_VERIFY(std::is_nothrow_copy_assignable<Half>::value);
}

5
src/Magnum/Math/Test/Matrix3Test.cpp
Unescape View File

@ -26,6 +26,7 @@
#include <sstream>
#include <Corrade/TestSuite/Tester.h>
#include <Corrade/Utility/DebugStl.h>
#include <Corrade/Utility/TypeTraits.h> /* CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED */
#include "Magnum/Math/Matrix3.h"
#include "Magnum/Math/StrictWeakOrdering.h"
@ -288,6 +289,10 @@ void Matrix3Test::constructCopy() {
{4.5f, 4.0f, 7.0f},
{7.9f, -1.0f, 8.0f}));
#ifdef CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED
CORRADE_VERIFY(std::is_trivially_copy_constructible<Matrix3>::value);
CORRADE_VERIFY(std::is_trivially_copy_assignable<Matrix3>::value);
#endif
CORRADE_VERIFY(std::is_nothrow_copy_constructible<Matrix3>::value);
CORRADE_VERIFY(std::is_nothrow_copy_assignable<Matrix3>::value);
}

5
src/Magnum/Math/Test/Matrix4Test.cpp
Unescape View File

@ -27,6 +27,7 @@
#include <Corrade/TestSuite/Tester.h>
#include <Corrade/TestSuite/Compare/Numeric.h>
#include <Corrade/Utility/DebugStl.h>
#include <Corrade/Utility/TypeTraits.h> /* CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED */
#include "Magnum/Math/Matrix4.h"
#include "Magnum/Math/StrictWeakOrdering.h"
@ -336,6 +337,10 @@ void Matrix4Test::constructCopy() {
{1.0f, 2.0f, 3.0f, -1.0f},
{7.9f, -1.0f, 8.0f, -1.5f}));
#ifdef CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED
CORRADE_VERIFY(std::is_trivially_copy_constructible<Matrix4>::value);
CORRADE_VERIFY(std::is_trivially_copy_assignable<Matrix4>::value);
#endif
CORRADE_VERIFY(std::is_nothrow_copy_constructible<Matrix4>::value);
CORRADE_VERIFY(std::is_nothrow_copy_assignable<Matrix4>::value);
}

5
src/Magnum/Math/Test/MatrixTest.cpp
Unescape View File

@ -26,6 +26,7 @@
#include <sstream>
#include <Corrade/TestSuite/Tester.h>
#include <Corrade/Utility/DebugStl.h>
#include <Corrade/Utility/TypeTraits.h> /* CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED */
#include "Magnum/Math/Matrix.h"
#include "Magnum/Math/StrictWeakOrdering.h"
@ -290,6 +291,10 @@ void MatrixTest::constructCopy() {
CORRADE_VERIFY(std::is_nothrow_copy_constructible<Matrix4x4>::value);
CORRADE_VERIFY(std::is_nothrow_copy_assignable<Matrix4x4>::value);
#ifdef CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED
CORRADE_VERIFY(std::is_trivially_copy_constructible<Matrix4x4>::value);
CORRADE_VERIFY(std::is_trivially_copy_assignable<Matrix4x4>::value);
#endif
}
void MatrixTest::convert() {

5
src/Magnum/Math/Test/QuaternionTest.cpp
Unescape View File

@ -27,6 +27,7 @@
#include <Corrade/TestSuite/Tester.h>
#include <Corrade/TestSuite/Compare/Numeric.h>
#include <Corrade/Utility/DebugStl.h>
#include <Corrade/Utility/TypeTraits.h> /* CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED */
#include "Magnum/Math/Functions.h"
#include "Magnum/Math/Matrix4.h"
@ -290,6 +291,10 @@ void QuaternionTest::constructCopy() {
constexpr Quaternion b(a);
CORRADE_COMPARE(b, Quaternion({1.0f, -3.0f, 7.0f}, 2.5f));
#ifdef CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED
CORRADE_VERIFY(std::is_trivially_copy_constructible<Quaternion>::value);
CORRADE_VERIFY(std::is_trivially_copy_assignable<Quaternion>::value);
#endif
CORRADE_VERIFY(std::is_nothrow_copy_constructible<Quaternion>::value);
CORRADE_VERIFY(std::is_nothrow_copy_assignable<Quaternion>::value);
}

9
src/Magnum/Math/Test/RangeTest.cpp
Unescape View File

@ -26,6 +26,7 @@
#include <sstream>
#include <Corrade/TestSuite/Tester.h>
#include <Corrade/Utility/DebugStl.h>
#include <Corrade/Utility/TypeTraits.h> /* CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED */
#include "Magnum/Math/FunctionsBatch.h"
#include "Magnum/Math/Range.h"
@ -343,6 +344,14 @@ void RangeTest::constructCopy() {
CORRADE_COMPARE(e, Range2Di({3, 5}, {23, 78}));
CORRADE_COMPARE(f, Range3Di({3, 5, -7}, {23, 78, 2}));
#ifdef CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED
CORRADE_VERIFY(std::is_trivially_copy_constructible<Range1Di>::value);
CORRADE_VERIFY(std::is_trivially_copy_constructible<Range2Di>::value);
CORRADE_VERIFY(std::is_trivially_copy_constructible<Range3Di>::value);
CORRADE_VERIFY(std::is_trivially_copy_assignable<Range1Di>::value);
CORRADE_VERIFY(std::is_trivially_copy_assignable<Range2Di>::value);
CORRADE_VERIFY(std::is_trivially_copy_assignable<Range3Di>::value);
#endif
CORRADE_VERIFY(std::is_nothrow_copy_constructible<Range1Di>::value);
CORRADE_VERIFY(std::is_nothrow_copy_constructible<Range2Di>::value);
CORRADE_VERIFY(std::is_nothrow_copy_constructible<Range3Di>::value);

5
src/Magnum/Math/Test/RectangularMatrixTest.cpp
Unescape View File

@ -26,6 +26,7 @@
#include <sstream>
#include <Corrade/TestSuite/Tester.h>
#include <Corrade/Utility/DebugStl.h>
#include <Corrade/Utility/TypeTraits.h> /* CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED */
#include "Magnum/Math/RectangularMatrix.h"
#include "Magnum/Math/StrictWeakOrdering.h"
@ -366,6 +367,10 @@ void RectangularMatrixTest::constructCopy() {
Vector4(5.0f, 6.0f, 7.0f, 8.0f),
Vector4(9.0f, 10.0f, 11.0f, 12.0f)));
#ifdef CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED
CORRADE_VERIFY(std::is_trivially_copy_constructible<Matrix3x4>::value);
CORRADE_VERIFY(std::is_trivially_copy_assignable<Matrix3x4>::value);
#endif
CORRADE_VERIFY(std::is_nothrow_copy_constructible<Matrix3x4>::value);
CORRADE_VERIFY(std::is_nothrow_copy_assignable<Matrix3x4>::value);
}

19
src/Magnum/Math/Test/UnitTest.cpp
Unescape View File

@ -25,6 +25,7 @@
#include <new>
#include <Corrade/TestSuite/Tester.h>
#include <Corrade/Utility/TypeTraits.h> /* CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED */
#include "Magnum/Math/Constants.h"
#include "Magnum/Math/Unit.h"
@ -38,6 +39,8 @@ struct UnitTest: Corrade::TestSuite::Tester {
void constructDefault();
void constructNoInit();
void constructConversion();
void constructCopy();
void compare();
void compareNaN();
@ -51,6 +54,8 @@ UnitTest::UnitTest() {
&UnitTest::constructDefault,
&UnitTest::constructNoInit,
&UnitTest::constructConversion,
&UnitTest::constructCopy,
&UnitTest::compare,
&UnitTest::compareNaN,
@ -119,6 +124,20 @@ void UnitTest::constructConversion() {
CORRADE_VERIFY(std::is_nothrow_constructible<Sec, Seci>::value);
}
void UnitTest::constructCopy() {
constexpr Sec a{25.0f};
constexpr Sec b{a};
CORRADE_COMPARE(b, a);
#ifdef CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED
CORRADE_VERIFY(std::is_trivially_copy_constructible<Sec>::value);
CORRADE_VERIFY(std::is_trivially_copy_assignable<Sec>::value);
#endif
CORRADE_VERIFY(std::is_nothrow_copy_constructible<Sec>::value);
CORRADE_VERIFY(std::is_nothrow_copy_assignable<Sec>::value);
}
void UnitTest::compare() {
CORRADE_VERIFY(Sec(25.0f + TypeTraits<Float>::epsilon()/2.0f) == Sec(25.0f));
CORRADE_VERIFY(Sec(25.0f + TypeTraits<Float>::epsilon()*75.0f) != Sec(25.0f));

5
src/Magnum/Math/Test/Vector2Test.cpp
Unescape View File

@ -26,6 +26,7 @@
#include <sstream>
#include <Corrade/TestSuite/Tester.h>
#include <Corrade/Utility/DebugStl.h>
#include <Corrade/Utility/TypeTraits.h> /* CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED */
#include "Magnum/Math/Vector3.h" /* Vector3 used in Vector2Test::cross() */
#include "Magnum/Math/StrictWeakOrdering.h"
@ -168,6 +169,10 @@ void Vector2Test::constructCopy() {
Vector2 b(a);
CORRADE_COMPARE(b, Vector2(1.5f, 2.5f));
#ifdef CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED
CORRADE_VERIFY(std::is_trivially_copy_constructible<Vector2>::value);
CORRADE_VERIFY(std::is_trivially_copy_assignable<Vector2>::value);
#endif
CORRADE_VERIFY(std::is_nothrow_copy_constructible<Vector2>::value);
CORRADE_VERIFY(std::is_nothrow_copy_assignable<Vector2>::value);
}

5
src/Magnum/Math/Test/Vector3Test.cpp
Unescape View File

@ -26,6 +26,7 @@
#include <sstream>
#include <Corrade/TestSuite/Tester.h>
#include <Corrade/Utility/DebugStl.h>
#include <Corrade/Utility/TypeTraits.h> /* CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED */
#include "Magnum/Math/Vector3.h"
#include "Magnum/Math/StrictWeakOrdering.h"
@ -176,6 +177,10 @@ void Vector3Test::constructCopy() {
Vector3 b(a);
CORRADE_COMPARE(b, Vector3(1.0f, 2.5f, -3.0f));
#ifdef CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED
CORRADE_VERIFY(std::is_trivially_copy_constructible<Vector3>::value);
CORRADE_VERIFY(std::is_trivially_copy_assignable<Vector3>::value);
#endif
CORRADE_VERIFY(std::is_nothrow_copy_constructible<Vector3>::value);
CORRADE_VERIFY(std::is_nothrow_copy_assignable<Vector3>::value);
}

5
src/Magnum/Math/Test/Vector4Test.cpp
Unescape View File

@ -26,6 +26,7 @@
#include <sstream>
#include <Corrade/TestSuite/Tester.h>
#include <Corrade/Utility/DebugStl.h>
#include <Corrade/Utility/TypeTraits.h> /* CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED */
#include "Magnum/Math/Vector4.h"
#include "Magnum/Math/StrictWeakOrdering.h"
@ -197,6 +198,10 @@ void Vector4Test::constructCopy() {
Vector4 b(a);
CORRADE_COMPARE(b, Vector4(1.0f, -2.5f, 3.0f, 4.1f));
#ifdef CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED
CORRADE_VERIFY(std::is_trivially_copy_constructible<Vector4>::value);
CORRADE_VERIFY(std::is_trivially_copy_assignable<Vector4>::value);
#endif
CORRADE_VERIFY(std::is_nothrow_copy_constructible<Vector4>::value);
CORRADE_VERIFY(std::is_nothrow_copy_assignable<Vector4>::value);
}

5
src/Magnum/Math/Test/VectorTest.cpp
Unescape View File

@ -27,6 +27,7 @@
#include <Corrade/TestSuite/Tester.h>
#include <Corrade/TestSuite/Compare/Numeric.h>
#include <Corrade/Utility/DebugStl.h>
#include <Corrade/Utility/TypeTraits.h> /* CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED */
#include "Magnum/Math/Half.h"
#include "Magnum/Math/Vector.h"
@ -291,6 +292,10 @@ void VectorTest::constructCopy() {
constexpr Vector4 b(a);
CORRADE_COMPARE(b, Vector4(1.0f, 3.5f, 4.0f, -2.7f));
#ifdef CORRADE_STD_IS_TRIVIALLY_TRAITS_SUPPORTED
CORRADE_VERIFY(std::is_trivially_copy_constructible<Vector4>::value);
CORRADE_VERIFY(std::is_trivially_copy_assignable<Vector4>::value);
#endif
CORRADE_VERIFY(std::is_nothrow_copy_constructible<Vector4>::value);
CORRADE_VERIFY(std::is_nothrow_copy_assignable<Vector4>::value);
}

Write Preview
Loading…
Cancel
Save