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

Test: adapt to a less shitty CORRADE_COMPARE().

pull/504/head
Vladimír Vondruš 5 years ago
parent
475b502a1d
commit
ed9deff432
71 changed files with 684 additions and 684 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. 4
      src/Magnum/Animation/Test/TrackViewTest.cpp
  2. 2
      src/Magnum/GL/Test/AbstractShaderProgramTest.cpp
  3. 30
      src/Magnum/GL/Test/AttributeTest.cpp
  4. 2
      src/Magnum/GL/Test/BufferImageTest.cpp
  5. 2
      src/Magnum/GL/Test/BufferTest.cpp
  6. 2
      src/Magnum/GL/Test/BufferTextureTest.cpp
  7. 34
      src/Magnum/GL/Test/ContextTest.cpp
  8. 2
      src/Magnum/GL/Test/CubeMapTextureArrayTest.cpp
  9. 2
      src/Magnum/GL/Test/CubeMapTextureTest.cpp
  10. 2
      src/Magnum/GL/Test/FramebufferTest.cpp
  11. 4
      src/Magnum/GL/Test/MeshTest.cpp
  12. 4
      src/Magnum/GL/Test/MultisampleTextureTest.cpp
  13. 2
      src/Magnum/GL/Test/PipelineStatisticsQueryTest.cpp
  14. 2
      src/Magnum/GL/Test/PrimitiveQueryTest.cpp
  15. 2
      src/Magnum/GL/Test/RectangleTextureTest.cpp
  16. 2
      src/Magnum/GL/Test/RenderbufferTest.cpp
  17. 2
      src/Magnum/GL/Test/SampleQueryTest.cpp
  18. 2
      src/Magnum/GL/Test/ShaderTest.cpp
  19. 4
      src/Magnum/GL/Test/TextureArrayTest.cpp
  20. 6
      src/Magnum/GL/Test/TextureTest.cpp
  21. 2
      src/Magnum/GL/Test/TimeQueryTest.cpp
  22. 2
      src/Magnum/GL/Test/TransformFeedbackTest.cpp
  23. 40
      src/Magnum/Math/Test/AngleTest.cpp
  24. 22
      src/Magnum/Math/Test/BezierTest.cpp
  25. 22
      src/Magnum/Math/Test/BoolVectorTest.cpp
  26. 84
      src/Magnum/Math/Test/ColorTest.cpp
  27. 32
      src/Magnum/Math/Test/ComplexTest.cpp
  28. 100
      src/Magnum/Math/Test/CubicHermiteTest.cpp
  29. 34
      src/Magnum/Math/Test/DualComplexTest.cpp
  30. 40
      src/Magnum/Math/Test/DualQuaternionTest.cpp
  31. 56
      src/Magnum/Math/Test/DualTest.cpp
  32. 16
      src/Magnum/Math/Test/FrustumTest.cpp
  33. 4
      src/Magnum/Math/Test/FunctionsTest.cpp
  34. 22
      src/Magnum/Math/Test/HalfTest.cpp
  35. 26
      src/Magnum/Math/Test/Matrix3Test.cpp
  36. 26
      src/Magnum/Math/Test/Matrix4Test.cpp
  37. 46
      src/Magnum/Math/Test/MatrixTest.cpp
  38. 30
      src/Magnum/Math/Test/QuaternionTest.cpp
  39. 66
      src/Magnum/Math/Test/RangeTest.cpp
  40. 64
      src/Magnum/Math/Test/RectangularMatrixTest.cpp
  41. 28
      src/Magnum/Math/Test/TypeTraitsTest.cpp
  42. 18
      src/Magnum/Math/Test/UnitTest.cpp
  43. 24
      src/Magnum/Math/Test/Vector2Test.cpp
  44. 26
      src/Magnum/Math/Test/Vector3Test.cpp
  45. 26
      src/Magnum/Math/Test/Vector4Test.cpp
  46. 118
      src/Magnum/Math/Test/VectorTest.cpp
  47. 4
      src/Magnum/Test/ArrayTest.cpp
  48. 20
      src/Magnum/Test/ImageViewTest.cpp
  49. 6
      src/Magnum/Test/TagsTest.cpp
  50. 14
      src/Magnum/Vk/Test/BufferTest.cpp
  51. 6
      src/Magnum/Vk/Test/CommandBufferTest.cpp
  52. 6
      src/Magnum/Vk/Test/CommandPoolTest.cpp
  53. 2
      src/Magnum/Vk/Test/DevicePropertiesTest.cpp
  54. 6
      src/Magnum/Vk/Test/DeviceTest.cpp
  55. 4
      src/Magnum/Vk/Test/DeviceVkTest.cpp
  56. 4
      src/Magnum/Vk/Test/ExtensionPropertiesTest.cpp
  57. 44
      src/Magnum/Vk/Test/ExtensionsTest.cpp
  58. 6
      src/Magnum/Vk/Test/FenceTest.cpp
  59. 10
      src/Magnum/Vk/Test/FramebufferTest.cpp
  60. 26
      src/Magnum/Vk/Test/ImageTest.cpp
  61. 6
      src/Magnum/Vk/Test/ImageViewTest.cpp
  62. 8
      src/Magnum/Vk/Test/InstanceTest.cpp
  63. 4
      src/Magnum/Vk/Test/IntegrationTest.cpp
  64. 2
      src/Magnum/Vk/Test/LayerPropertiesTest.cpp
  65. 10
      src/Magnum/Vk/Test/MemoryTest.cpp
  66. 4
      src/Magnum/Vk/Test/MeshLayoutTest.cpp
  67. 6
      src/Magnum/Vk/Test/PipelineLayoutTest.cpp
  68. 22
      src/Magnum/Vk/Test/PipelineTest.cpp
  69. 10
      src/Magnum/Vk/Test/QueueTest.cpp
  70. 42
      src/Magnum/Vk/Test/RenderPassTest.cpp
  71. 10
      src/Magnum/Vk/Test/ShaderTest.cpp

4
src/Magnum/Animation/Test/TrackViewTest.cpp
Unescape View File

@ -607,8 +607,8 @@ void TrackViewTest::convertToConstView() {
CORRADE_COMPARE(ca[1], (std::pair<Float, Vector3>{5.0f, {0.3f, 0.6f, 1.0f}}));
/* Conversion back is not possible */
CORRADE_VERIFY((std::is_convertible<TrackView<Float, Vector3>, TrackView<const Float, const Vector3>>::value));
CORRADE_VERIFY(!(std::is_convertible<TrackView<const Float, const Vector3>, TrackView<Float, Vector3>>::value));
CORRADE_VERIFY(std::is_convertible<TrackView<Float, Vector3>, TrackView<const Float, const Vector3>>::value);
CORRADE_VERIFY(!std::is_convertible<TrackView<const Float, const Vector3>, TrackView<Float, Vector3>>::value);
}
const std::pair<Float, Float> Keyframes[]{

2
src/Magnum/GL/Test/AbstractShaderProgramTest.cpp
Unescape View File

@ -51,7 +51,7 @@ void AbstractShaderProgramTest::constructNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, AbstractShaderProgram>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, AbstractShaderProgram>::value);
}
void AbstractShaderProgramTest::constructCopy() {

30
src/Magnum/GL/Test/AttributeTest.cpp
Unescape View File

@ -178,7 +178,7 @@ AttributeTest::AttributeTest() {
void AttributeTest::attributeScalar() {
typedef Attribute<3, Float> Attribute;
CORRADE_VERIFY((std::is_same<Attribute::ScalarType, Float>{}));
CORRADE_VERIFY(std::is_same<Attribute::ScalarType, Float>{});
CORRADE_COMPARE(Attribute::Location, 3);
CORRADE_COMPARE(Attribute::Vectors, 1);
@ -214,7 +214,7 @@ void AttributeTest::attributeScalar() {
void AttributeTest::attributeScalarInt() {
#ifndef MAGNUM_TARGET_GLES2
typedef Attribute<2, Int> Attribute;
CORRADE_VERIFY((std::is_same<Attribute::ScalarType, Int>{}));
CORRADE_VERIFY(std::is_same<Attribute::ScalarType, Int>{});
CORRADE_COMPARE(Attribute::Vectors, 1);
/* Default constructor */
@ -248,7 +248,7 @@ void AttributeTest::attributeScalarInt() {
void AttributeTest::attributeScalarUnsignedInt() {
#ifndef MAGNUM_TARGET_GLES2
typedef Attribute<3, UnsignedInt> Attribute;
CORRADE_VERIFY((std::is_same<Attribute::ScalarType, UnsignedInt>{}));
CORRADE_VERIFY(std::is_same<Attribute::ScalarType, UnsignedInt>{});
CORRADE_COMPARE(Attribute::Vectors, 1);
/* Default constructor */
@ -282,7 +282,7 @@ void AttributeTest::attributeScalarUnsignedInt() {
void AttributeTest::attributeScalarDouble() {
#ifndef MAGNUM_TARGET_GLES
typedef Attribute<3, Double> Attribute;
CORRADE_VERIFY((std::is_same<Attribute::ScalarType, Double>{}));
CORRADE_VERIFY(std::is_same<Attribute::ScalarType, Double>{});
CORRADE_COMPARE(Attribute::Vectors, 1);
/* Default constructor */
@ -303,7 +303,7 @@ void AttributeTest::attributeScalarDouble() {
void AttributeTest::attributeVector() {
typedef Attribute<3, Vector3> Attribute;
CORRADE_VERIFY((std::is_same<Attribute::ScalarType, Float>{}));
CORRADE_VERIFY(std::is_same<Attribute::ScalarType, Float>{});
CORRADE_COMPARE(Attribute::Vectors, 1);
/* Default constructor */
@ -351,7 +351,7 @@ void AttributeTest::attributeVector() {
void AttributeTest::attributeVectorInt() {
#ifndef MAGNUM_TARGET_GLES2
typedef Attribute<3, Vector2i> Attribute;
CORRADE_VERIFY((std::is_same<Attribute::ScalarType, Int>{}));
CORRADE_VERIFY(std::is_same<Attribute::ScalarType, Int>{});
CORRADE_COMPARE(Attribute::Vectors, 1);
/* Default constructor */
@ -387,7 +387,7 @@ void AttributeTest::attributeVectorInt() {
void AttributeTest::attributeVectorUnsignedInt() {
#ifndef MAGNUM_TARGET_GLES2
typedef Attribute<3, Vector4ui> Attribute;
CORRADE_VERIFY((std::is_same<Attribute::ScalarType, UnsignedInt>{}));
CORRADE_VERIFY(std::is_same<Attribute::ScalarType, UnsignedInt>{});
CORRADE_COMPARE(Attribute::Vectors, 1);
/* Default constructor */
@ -423,7 +423,7 @@ void AttributeTest::attributeVectorUnsignedInt() {
void AttributeTest::attributeVectorDouble() {
#ifndef MAGNUM_TARGET_GLES
typedef Attribute<3, Vector2d> Attribute;
CORRADE_VERIFY((std::is_same<Attribute::ScalarType, Double>{}));
CORRADE_VERIFY(std::is_same<Attribute::ScalarType, Double>{});
CORRADE_COMPARE(Attribute::Vectors, 1);
/* Default constructor */
@ -458,7 +458,7 @@ void AttributeTest::attributeVectorDouble() {
void AttributeTest::attributeVector4() {
typedef Attribute<3, Vector4> Attribute;
CORRADE_VERIFY((std::is_same<Attribute::ScalarType, Float>{}));
CORRADE_VERIFY(std::is_same<Attribute::ScalarType, Float>{});
CORRADE_COMPARE(Attribute::Vectors, 1);
/* Custom type */
@ -501,7 +501,7 @@ void AttributeTest::attributeVector4() {
void AttributeTest::attributeVectorBGRA() {
#ifndef MAGNUM_TARGET_GLES
typedef Attribute<3, Vector4> Attribute;
CORRADE_VERIFY((std::is_same<Attribute::ScalarType, Float>{}));
CORRADE_VERIFY(std::is_same<Attribute::ScalarType, Float>{});
CORRADE_COMPARE(Attribute::Vectors, 1);
/* BGRA */
@ -522,7 +522,7 @@ void AttributeTest::attributeVectorBGRA() {
void AttributeTest::attributeMatrixNxN() {
typedef Attribute<3, Matrix3> Attribute;
CORRADE_VERIFY((std::is_same<Attribute::ScalarType, Float>{}));
CORRADE_VERIFY(std::is_same<Attribute::ScalarType, Float>{});
CORRADE_COMPARE(Attribute::Vectors, 3);
/* Default constructor */
@ -542,7 +542,7 @@ void AttributeTest::attributeMatrixNxN() {
void AttributeTest::attributeMatrixNxNCustomStride() {
typedef Attribute<3, Matrix3> Attribute;
CORRADE_VERIFY((std::is_same<Attribute::ScalarType, Float>{}));
CORRADE_VERIFY(std::is_same<Attribute::ScalarType, Float>{});
CORRADE_COMPARE(Attribute::Vectors, 3);
/* Default stride */
@ -577,7 +577,7 @@ void AttributeTest::attributeMatrixNxNCustomStride() {
#ifndef MAGNUM_TARGET_GLES2
void AttributeTest::attributeMatrixMxN() {
typedef Attribute<3, Matrix3x4> Attribute;
CORRADE_VERIFY((std::is_same<Attribute::ScalarType, Float>{}));
CORRADE_VERIFY(std::is_same<Attribute::ScalarType, Float>{});
CORRADE_COMPARE(Attribute::Vectors, 3);
/* Default constructor */
@ -599,7 +599,7 @@ void AttributeTest::attributeMatrixMxN() {
void AttributeTest::attributeMatrixNxNd() {
#ifndef MAGNUM_TARGET_GLES
typedef Attribute<3, Matrix4d> Attribute;
CORRADE_VERIFY((std::is_same<Attribute::ScalarType, Double>{}));
CORRADE_VERIFY(std::is_same<Attribute::ScalarType, Double>{});
CORRADE_COMPARE(Attribute::Vectors, 4);
/* Default constructor */
@ -623,7 +623,7 @@ void AttributeTest::attributeMatrixNxNd() {
void AttributeTest::attributeMatrixMxNd() {
#ifndef MAGNUM_TARGET_GLES
typedef Attribute<3, Matrix4x2d> Attribute;
CORRADE_VERIFY((std::is_same<Attribute::ScalarType, Double>{}));
CORRADE_VERIFY(std::is_same<Attribute::ScalarType, Double>{});
CORRADE_COMPARE(Attribute::Vectors, 4);
/* Default constructor */

2
src/Magnum/GL/Test/BufferImageTest.cpp
Unescape View File

@ -54,7 +54,7 @@ void BufferImageTest::constructNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, BufferImage2D>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, BufferImage2D>::value);
}
void BufferImageTest::constructNoCreateCompressed() {

2
src/Magnum/GL/Test/BufferTest.cpp
Unescape View File

@ -62,7 +62,7 @@ void BufferTest::constructNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, Buffer>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, Buffer>::value);
}
void BufferTest::constructCopy() {

2
src/Magnum/GL/Test/BufferTextureTest.cpp
Unescape View File

@ -48,7 +48,7 @@ void BufferTextureTest::constructNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, BufferTexture>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, BufferTexture>::value);
}
void BufferTextureTest::constructCopy() {

34
src/Magnum/GL/Test/ContextTest.cpp
Unescape View File

@ -103,39 +103,39 @@ void ContextTest::isExtension() {
/* Variadic check (used in variadic Configuration::addDisabledExtensions()),
check that it properly fails for each occurence of a non-extension */
#ifndef MAGNUM_TARGET_WEBGL
CORRADE_VERIFY((Implementation::IsExtension<
CORRADE_VERIFY(Implementation::IsExtension<
Extensions::KHR::debug,
Extensions::EXT::texture_filter_anisotropic,
Extensions::KHR::texture_compression_astc_hdr>::value));
CORRADE_VERIFY(!(Implementation::IsExtension<
Extensions::KHR::texture_compression_astc_hdr>::value);
CORRADE_VERIFY(!Implementation::IsExtension<
Extension,
Extensions::KHR::debug,
Extensions::EXT::texture_filter_anisotropic>::value));
CORRADE_VERIFY(!(Implementation::IsExtension<
Extensions::EXT::texture_filter_anisotropic>::value);
CORRADE_VERIFY(!Implementation::IsExtension<
Extensions::KHR::debug,
Extension,
Extensions::EXT::texture_filter_anisotropic>::value));
CORRADE_VERIFY(!(Implementation::IsExtension<
Extensions::EXT::texture_filter_anisotropic>::value);
CORRADE_VERIFY(!Implementation::IsExtension<
Extensions::KHR::debug,
Extensions::EXT::texture_filter_anisotropic,
Extension>::value));
Extension>::value);
#else
CORRADE_VERIFY((Implementation::IsExtension<
CORRADE_VERIFY(Implementation::IsExtension<
Extensions::OES::texture_float_linear,
Extensions::EXT::texture_filter_anisotropic,
Extensions::WEBGL::compressed_texture_s3tc>::value));
CORRADE_VERIFY(!(Implementation::IsExtension<
Extensions::WEBGL::compressed_texture_s3tc>::value);
CORRADE_VERIFY(!Implementation::IsExtension<
Extension,
Extensions::OES::texture_float_linear,
Extensions::EXT::texture_filter_anisotropic>::value));
CORRADE_VERIFY(!(Implementation::IsExtension<
Extensions::EXT::texture_filter_anisotropic>::value);
CORRADE_VERIFY(!Implementation::IsExtension<
Extensions::OES::texture_float_linear,
Extension,
Extensions::EXT::texture_filter_anisotropic>::value));
CORRADE_VERIFY(!(Implementation::IsExtension<
Extensions::EXT::texture_filter_anisotropic>::value);
CORRADE_VERIFY(!Implementation::IsExtension<
Extensions::OES::texture_float_linear,
Extensions::EXT::texture_filter_anisotropic,
Extension>::value));
Extension>::value);
#endif
/* Empty variadic list should return true */
@ -350,7 +350,7 @@ void ContextTest::constructNoCreate() {
CORRADE_VERIFY(!Context::hasCurrent());
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, Context>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, Context>::value);
}
void ContextTest::constructCopy() {

2
src/Magnum/GL/Test/CubeMapTextureArrayTest.cpp
Unescape View File

@ -48,7 +48,7 @@ void CubeMapTextureArrayTest::constructNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, CubeMapTextureArray>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, CubeMapTextureArray>::value);
}
void CubeMapTextureArrayTest::constructCopy() {

2
src/Magnum/GL/Test/CubeMapTextureTest.cpp
Unescape View File

@ -48,7 +48,7 @@ void CubeMapTextureTest::constructNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, CubeMapTexture>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, CubeMapTexture>::value);
}
void CubeMapTextureTest::constructCopy() {

2
src/Magnum/GL/Test/FramebufferTest.cpp
Unescape View File

@ -54,7 +54,7 @@ void FramebufferTest::constructNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, Framebuffer>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, Framebuffer>::value);
}
void FramebufferTest::constructCopy() {

4
src/Magnum/GL/Test/MeshTest.cpp
Unescape View File

@ -90,7 +90,7 @@ void MeshTest::constructNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, Mesh>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, Mesh>::value);
}
void MeshTest::constructViewNoCreate() {
@ -101,7 +101,7 @@ void MeshTest::constructViewNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, MeshView>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, MeshView>::value);
}
void MeshTest::constructCopy() {

4
src/Magnum/GL/Test/MultisampleTextureTest.cpp
Unescape View File

@ -54,7 +54,7 @@ void MultisampleTextureTest::construct2DNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, MultisampleTexture2D>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, MultisampleTexture2D>::value);
}
void MultisampleTextureTest::construct2DArrayNoCreate() {
@ -64,7 +64,7 @@ void MultisampleTextureTest::construct2DArrayNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, MultisampleTexture2DArray>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, MultisampleTexture2DArray>::value);
}
void MultisampleTextureTest::constructCopy2D() {

2
src/Magnum/GL/Test/PipelineStatisticsQueryTest.cpp
Unescape View File

@ -48,7 +48,7 @@ void PipelineStatisticsQueryTest::constructNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, PipelineStatisticsQuery>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, PipelineStatisticsQuery>::value);
}
void PipelineStatisticsQueryTest::constructCopy() {

2
src/Magnum/GL/Test/PrimitiveQueryTest.cpp
Unescape View File

@ -48,7 +48,7 @@ void PrimitiveQueryTest::constructNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, PrimitiveQuery>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, PrimitiveQuery>::value);
}
void PrimitiveQueryTest::constructCopy() {

2
src/Magnum/GL/Test/RectangleTextureTest.cpp
Unescape View File

@ -48,7 +48,7 @@ void RectangleTextureTest::constructNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, RectangleTexture>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, RectangleTexture>::value);
}
void RectangleTextureTest::constructCopy() {

2
src/Magnum/GL/Test/RenderbufferTest.cpp
Unescape View File

@ -48,7 +48,7 @@ void RenderbufferTest::constructNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, Renderbuffer>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, Renderbuffer>::value);
}
void RenderbufferTest::constructCopy() {

2
src/Magnum/GL/Test/SampleQueryTest.cpp
Unescape View File

@ -48,7 +48,7 @@ void SampleQueryTest::constructNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, SampleQuery>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, SampleQuery>::value);
}
void SampleQueryTest::constructCopy() {

2
src/Magnum/GL/Test/ShaderTest.cpp
Unescape View File

@ -52,7 +52,7 @@ void ShaderTest::constructNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, Shader>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, Shader>::value);
}
void ShaderTest::constructCopy() {

4
src/Magnum/GL/Test/TextureArrayTest.cpp
Unescape View File

@ -64,7 +64,7 @@ void TextureArrayTest::construct1DNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, Texture1DArray>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, Texture1DArray>::value);
}
#endif
@ -75,7 +75,7 @@ void TextureArrayTest::construct2DNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, Texture2DArray>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, Texture2DArray>::value);
}
#ifndef MAGNUM_TARGET_GLES

6
src/Magnum/GL/Test/TextureTest.cpp
Unescape View File

@ -77,7 +77,7 @@ void TextureTest::construct1DNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, Texture1D>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, Texture1D>::value);
}
#endif
@ -88,7 +88,7 @@ void TextureTest::construct2DNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, Texture2D>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, Texture2D>::value);
}
#if !(defined(MAGNUM_TARGET_WEBGL) && defined(MAGNUM_TARGET_GLES2))
@ -99,7 +99,7 @@ void TextureTest::construct3DNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, Texture3D>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, Texture3D>::value);
}
#endif

2
src/Magnum/GL/Test/TimeQueryTest.cpp
Unescape View File

@ -48,7 +48,7 @@ void TimeQueryTest::constructNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, TimeQuery>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, TimeQuery>::value);
}
void TimeQueryTest::constructCopy() {

2
src/Magnum/GL/Test/TransformFeedbackTest.cpp
Unescape View File

@ -48,7 +48,7 @@ void TransformFeedbackTest::constructNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, TransformFeedback>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, TransformFeedback>::value);
}
void TransformFeedbackTest::constructCopy() {

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

@ -150,11 +150,11 @@ void AngleTest::construct() {
CORRADE_COMPARE(Double(n), 3.14);
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Float, Rad>::value));
CORRADE_VERIFY(!(std::is_convertible<Double, Degd>::value));
CORRADE_VERIFY(!std::is_convertible<Float, Rad>::value);
CORRADE_VERIFY(!std::is_convertible<Double, Degd>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Deg, Float>::value));
CORRADE_VERIFY((std::is_nothrow_constructible<Rad, Float>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Deg, Float>::value);
CORRADE_VERIFY(std::is_nothrow_constructible<Rad, Float>::value);
}
void AngleTest::constructDefault() {
@ -169,12 +169,12 @@ void AngleTest::constructDefault() {
CORRADE_VERIFY(std::is_nothrow_default_constructible<Deg>::value);
CORRADE_VERIFY(std::is_nothrow_default_constructible<Rad>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Deg, ZeroInitT>::value));
CORRADE_VERIFY((std::is_nothrow_constructible<Rad, ZeroInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Deg, ZeroInitT>::value);
CORRADE_VERIFY(std::is_nothrow_constructible<Rad, ZeroInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<ZeroInitT, Deg>::value));
CORRADE_VERIFY(!(std::is_convertible<ZeroInitT, Rad>::value));
CORRADE_VERIFY(!std::is_convertible<ZeroInitT, Deg>::value);
CORRADE_VERIFY(!std::is_convertible<ZeroInitT, Rad>::value);
}
void AngleTest::constructNoInit() {
@ -198,12 +198,12 @@ void AngleTest::constructNoInit() {
#endif
}
CORRADE_VERIFY((std::is_nothrow_constructible<Deg, Magnum::NoInitT>::value));
CORRADE_VERIFY((std::is_nothrow_constructible<Rad, Magnum::NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Deg, Magnum::NoInitT>::value);
CORRADE_VERIFY(std::is_nothrow_constructible<Rad, Magnum::NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Deg>::value));
CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Rad>::value));
CORRADE_VERIFY(!std::is_convertible<Magnum::NoInitT, Deg>::value);
CORRADE_VERIFY(!std::is_convertible<Magnum::NoInitT, Rad>::value);
}
void AngleTest::constructConversion() {
@ -216,11 +216,11 @@ void AngleTest::constructConversion() {
CORRADE_COMPARE(Double(d), 25.0);
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Degd, Deg>::value));
CORRADE_VERIFY(!(std::is_convertible<Rad, Radd>::value));
CORRADE_VERIFY(!std::is_convertible<Degd, Deg>::value);
CORRADE_VERIFY(!std::is_convertible<Rad, Radd>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Deg, Degd>::value));
CORRADE_VERIFY((std::is_nothrow_constructible<Radd, Rad>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Deg, Degd>::value);
CORRADE_VERIFY(std::is_nothrow_constructible<Radd, Rad>::value);
}
void AngleTest::constructCopy() {
@ -240,17 +240,17 @@ void AngleTest::constructCopy() {
void AngleTest::literals() {
constexpr auto a = 25.0_deg;
CORRADE_VERIFY((std::is_same<decltype(a), const Degd>::value));
CORRADE_VERIFY(std::is_same<decltype(a), const Degd>::value);
CORRADE_COMPARE(Double(a), 25.0);
constexpr auto b = 25.0_degf;
CORRADE_VERIFY((std::is_same<decltype(b), const Deg>::value));
CORRADE_VERIFY(std::is_same<decltype(b), const Deg>::value);
CORRADE_COMPARE(Float(b), 25.0f);
constexpr auto m = 3.14_rad;
CORRADE_VERIFY((std::is_same<decltype(m), const Radd>::value));
CORRADE_VERIFY(std::is_same<decltype(m), const Radd>::value);
CORRADE_COMPARE(Double(m), 3.14);
constexpr auto n = 3.14_radf;
CORRADE_VERIFY((std::is_same<decltype(n), const Rad>::value));
CORRADE_VERIFY(std::is_same<decltype(n), const Rad>::value);
CORRADE_COMPARE(Float(n), 3.14f);
}

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

@ -121,7 +121,7 @@ void BezierTest::construct() {
constexpr QuadraticBezier2D a = {Vector2{0.5f, 1.0f}, Vector2{1.1f, 0.3f}, Vector2{0.1f, 1.2f}};
CORRADE_COMPARE(a, (QuadraticBezier2D{Vector2{0.5f, 1.0f}, Vector2{1.1f, 0.3f}, Vector2{0.1f, 1.2f}}));
CORRADE_VERIFY((std::is_nothrow_constructible<QuadraticBezier2D, Vector2, Vector2, Vector2>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<QuadraticBezier2D, Vector2, Vector2, Vector2>::value);
}
void BezierTest::constructDefault() {
@ -131,10 +131,10 @@ void BezierTest::constructDefault() {
CORRADE_COMPARE(b, (QuadraticBezier2D{Vector2{}, Vector2{}, Vector2{}}));
CORRADE_VERIFY(std::is_nothrow_default_constructible<QuadraticBezier2D>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<QuadraticBezier2D, ZeroInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<QuadraticBezier2D, ZeroInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<ZeroInitT, QuadraticBezier2D>::value));
CORRADE_VERIFY(!std::is_convertible<ZeroInitT, QuadraticBezier2D>::value);
}
void BezierTest::constructNoInit() {
@ -147,10 +147,10 @@ void BezierTest::constructNoInit() {
CORRADE_COMPARE(a, (QuadraticBezier2D{Vector2{0.5f, 1.0f}, Vector2{1.1f, 0.3f}, Vector2{0.1f, 1.2f}}));
}
CORRADE_VERIFY((std::is_nothrow_constructible<QuadraticBezier2D, Magnum::NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<QuadraticBezier2D, Magnum::NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, QuadraticBezier2D>::value));
CORRADE_VERIFY(!std::is_convertible<Magnum::NoInitT, QuadraticBezier2D>::value);
}
void BezierTest::constructConversion() {
@ -165,9 +165,9 @@ void BezierTest::constructConversion() {
CORRADE_COMPARE(b, (QuadraticBezier2D{Vector2{0.5f, 1.0f}, Vector2{1.1f, 0.3f}, Vector2{0.1f, 1.2f}}));
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<QuadraticBezier2Dd, QuadraticBezier2D>::value));
CORRADE_VERIFY(!std::is_convertible<QuadraticBezier2Dd, QuadraticBezier2D>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<QuadraticBezier2D, QuadraticBezier2Dd>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<QuadraticBezier2D, QuadraticBezier2Dd>::value);
}
void BezierTest::constructFromCubicHermite() {
@ -208,8 +208,8 @@ void BezierTest::convert() {
CORRADE_COMPARE(d.y1, a.y1);
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<QBezier2D, QuadraticBezier2D>::value));
CORRADE_VERIFY(!(std::is_convertible<QuadraticBezier2D, QBezier2D>::value));
CORRADE_VERIFY(!std::is_convertible<QBezier2D, QuadraticBezier2D>::value);
CORRADE_VERIFY(!std::is_convertible<QuadraticBezier2D, QBezier2D>::value);
}
void BezierTest::data() {
@ -238,8 +238,8 @@ void BezierTest::data() {
}
void BezierTest::compare() {
CORRADE_VERIFY((QuadraticBezier2D{Vector2{0.5f, 1.0f + TypeTraits<Float>::epsilon()/2}, Vector2{1.1f, 0.3f}, Vector2{0.1f, 1.2f}} == QuadraticBezier2D{Vector2{0.5f, 1.0f}, Vector2{1.1f, 0.3f}, Vector2{0.1f, 1.2f}}));
CORRADE_VERIFY((QuadraticBezier2D{Vector2{0.5f, 1.1f}, Vector2{1.1f, 0.3f}, Vector2{0.1f, 1.0f + TypeTraits<Float>::epsilon()*2}} != QuadraticBezier2D{Vector2{0.5f, 1.1f}, Vector2{1.1f, 0.3f}, Vector2{0.1f, 1.0f}}));
CORRADE_VERIFY(QuadraticBezier2D{Vector2{0.5f, 1.0f + TypeTraits<Float>::epsilon()/2}, Vector2{1.1f, 0.3f}, Vector2{0.1f, 1.2f}} == QuadraticBezier2D{Vector2{0.5f, 1.0f}, Vector2{1.1f, 0.3f}, Vector2{0.1f, 1.2f}});
CORRADE_VERIFY(QuadraticBezier2D{Vector2{0.5f, 1.1f}, Vector2{1.1f, 0.3f}, Vector2{0.1f, 1.0f + TypeTraits<Float>::epsilon()*2}} != QuadraticBezier2D{Vector2{0.5f, 1.1f}, Vector2{1.1f, 0.3f}, Vector2{0.1f, 1.0f}});
}
void BezierTest::valueLinear() {

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

@ -118,7 +118,7 @@ void BoolVectorTest::construct() {
constexpr BoolVector19 a = {0xa5, 0x5f, 0x07};
CORRADE_COMPARE(a, BoolVector19(0xa5, 0x5f, 0x07));
CORRADE_VERIFY((std::is_nothrow_constructible<BoolVector19, UnsignedByte, UnsignedByte, UnsignedByte>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<BoolVector19, UnsignedByte, UnsignedByte, UnsignedByte>::value);
}
void BoolVectorTest::constructDefault() {
@ -128,10 +128,10 @@ void BoolVectorTest::constructDefault() {
CORRADE_COMPARE(b, BoolVector19(0x00, 0x00, 0x00));
CORRADE_VERIFY(std::is_nothrow_default_constructible<BoolVector19>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<BoolVector19, ZeroInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<BoolVector19, ZeroInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<ZeroInitT, BoolVector19>::value));
CORRADE_VERIFY(!std::is_convertible<ZeroInitT, BoolVector19>::value);
}
void BoolVectorTest::constructNoInit() {
@ -144,10 +144,10 @@ void BoolVectorTest::constructNoInit() {
CORRADE_COMPARE(a, BoolVector19(0xa5, 0x5f, 0x07));
}
CORRADE_VERIFY((std::is_nothrow_constructible<BoolVector19, Magnum::NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<BoolVector19, Magnum::NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, BoolVector19>::value));
CORRADE_VERIFY(!std::is_convertible<Magnum::NoInitT, BoolVector19>::value);
}
void BoolVectorTest::constructOneValue() {
@ -157,9 +157,9 @@ void BoolVectorTest::constructOneValue() {
constexpr BoolVector19 b(true);
CORRADE_COMPARE(b, BoolVector19(0xff, 0xff, 0x07));
CORRADE_VERIFY(!(std::is_convertible<bool, BoolVector19>::value));
CORRADE_VERIFY(!std::is_convertible<bool, BoolVector19>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<BoolVector19, bool>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<BoolVector19, bool>::value);
}
void BoolVectorTest::constructOneElement() {
@ -168,7 +168,7 @@ void BoolVectorTest::constructOneElement() {
constexpr BoolVector1 a = 0x01;
CORRADE_COMPARE(a, BoolVector1(0x01));
CORRADE_VERIFY((std::is_nothrow_constructible<BoolVector1, UnsignedByte>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<BoolVector1, UnsignedByte>::value);
}
void BoolVectorTest::constructCopy() {
@ -193,8 +193,8 @@ void BoolVectorTest::convert() {
CORRADE_COMPARE(d.z, a.z);
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<BVec3, BoolVector<3>>::value));
CORRADE_VERIFY(!(std::is_convertible<BoolVector<3>, BVec3>::value));
CORRADE_VERIFY(!std::is_convertible<BVec3, BoolVector<3>>::value);
CORRADE_VERIFY(!std::is_convertible<BoolVector<3>, BVec3>::value);
}
void BoolVectorTest::data() {
@ -266,7 +266,7 @@ void BoolVectorTest::convertBool() {
CORRADE_COMPARE(bool(!BoolVector19(0xff, 0xff, 0x04)), false);
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<BoolVector19, bool>::value));
CORRADE_VERIFY(!std::is_convertible<BoolVector19, bool>::value);
}
void BoolVectorTest::all() {

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

@ -295,8 +295,8 @@ void ColorTest::construct() {
CORRADE_COMPARE(c, Vector4(1.0f, 0.5f, 0.75f, 1.0f));
CORRADE_COMPARE(d, Math::Vector4<UnsignedByte>(10, 25, 176, 255));
CORRADE_VERIFY((std::is_nothrow_constructible<Color3, Float, Float, Float>::value));
CORRADE_VERIFY((std::is_nothrow_constructible<Color4, Float, Float, Float, Float>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Color3, Float, Float, Float>::value);
CORRADE_VERIFY(std::is_nothrow_constructible<Color4, Float, Float, Float, Float>::value);
}
void ColorTest::constructDefaultAlphaHalf() {
@ -321,12 +321,12 @@ void ColorTest::constructDefault() {
CORRADE_VERIFY(std::is_nothrow_default_constructible<Color3>::value);
CORRADE_VERIFY(std::is_nothrow_default_constructible<Color4>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Color3, ZeroInitT>::value));
CORRADE_VERIFY((std::is_nothrow_constructible<Color4, ZeroInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Color3, ZeroInitT>::value);
CORRADE_VERIFY(std::is_nothrow_constructible<Color4, ZeroInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<ZeroInitT, Color3>::value));
CORRADE_VERIFY(!(std::is_convertible<ZeroInitT, Color4>::value));
CORRADE_VERIFY(!std::is_convertible<ZeroInitT, Color3>::value);
CORRADE_VERIFY(!std::is_convertible<ZeroInitT, Color4>::value);
}
void ColorTest::constructNoInit() {
@ -342,12 +342,12 @@ void ColorTest::constructNoInit() {
CORRADE_COMPARE(b, (Color4{1.0f, 0.5f, 0.75f, 0.5f}));
}
CORRADE_VERIFY((std::is_nothrow_constructible<Color3, Magnum::NoInitT>::value));
CORRADE_VERIFY((std::is_nothrow_constructible<Color4, Magnum::NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Color3, Magnum::NoInitT>::value);
CORRADE_VERIFY(std::is_nothrow_constructible<Color4, Magnum::NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Color3>::value));
CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Color4>::value));
CORRADE_VERIFY(!std::is_convertible<Magnum::NoInitT, Color3>::value);
CORRADE_VERIFY(!std::is_convertible<Magnum::NoInitT, Color4>::value);
}
void ColorTest::constructOneValue() {
@ -364,11 +364,11 @@ void ColorTest::constructOneValue() {
CORRADE_COMPARE(d, Color4ub(67, 67, 67, 255));
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Float, Color3>::value));
CORRADE_VERIFY(!(std::is_convertible<Float, Color4>::value));
CORRADE_VERIFY(!std::is_convertible<Float, Color3>::value);
CORRADE_VERIFY(!std::is_convertible<Float, Color4>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Color3, Float>::value));
CORRADE_VERIFY((std::is_nothrow_constructible<Color4, Float, Float>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Color3, Float>::value);
CORRADE_VERIFY(std::is_nothrow_constructible<Color4, Float, Float>::value);
}
void ColorTest::constructParts() {
@ -384,7 +384,7 @@ void ColorTest::constructParts() {
CORRADE_COMPARE(d, Color4(1.0f, 0.5f, 0.75f, 1.0f));
CORRADE_COMPARE(e, Color4ub(10, 25, 176, 255));
CORRADE_VERIFY((std::is_nothrow_constructible<Color4, Color3, Float>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Color4, Color3, Float>::value);
}
void ColorTest::constructConversion() {
@ -397,11 +397,11 @@ void ColorTest::constructConversion() {
CORRADE_COMPARE(d, Color4ub(10, 12, 0, 5));
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Color3, Color3ub>::value));
CORRADE_VERIFY(!(std::is_convertible<Color4, Color4ub>::value));
CORRADE_VERIFY(!std::is_convertible<Color3, Color3ub>::value);
CORRADE_VERIFY(!std::is_convertible<Color4, Color4ub>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Color3ub, Color3>::value));
CORRADE_VERIFY((std::is_nothrow_constructible<Color4, Color4ub>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Color3ub, Color3>::value);
CORRADE_VERIFY(std::is_nothrow_constructible<Color4, Color4ub>::value);
}
void ColorTest::constructPacking() {
@ -466,10 +466,10 @@ void ColorTest::convert() {
CORRADE_COMPARE(d4.w, a4.w);
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Vec3, Color3>::value));
CORRADE_VERIFY(!(std::is_convertible<Vec4, Color4>::value));
CORRADE_VERIFY(!(std::is_convertible<Color3, Vec3>::value));
CORRADE_VERIFY(!(std::is_convertible<Color4, Vec4>::value));
CORRADE_VERIFY(!std::is_convertible<Vec3, Color3>::value);
CORRADE_VERIFY(!std::is_convertible<Vec4, Color4>::value);
CORRADE_VERIFY(!std::is_convertible<Color3, Vec3>::value);
CORRADE_VERIFY(!std::is_convertible<Color4, Vec4>::value);
}
void ColorTest::constructHsv() {
@ -486,7 +486,7 @@ void ColorTest::constructHsv() {
CORRADE_COMPARE(saturation, 0.5f);
CORRADE_COMPARE(value, 0.9f);
CORRADE_VERIFY((std::is_nothrow_constructible<ColorHsv, Deg, Float, Float>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<ColorHsv, Deg, Float, Float>::value);
}
void ColorTest::constructHsvDefault() {
@ -501,10 +501,10 @@ void ColorTest::constructHsvDefault() {
CORRADE_COMPARE(ca2, (ColorHsv{0.0_degf, 0.0f, 0.0f}));
CORRADE_VERIFY(std::is_nothrow_default_constructible<ColorHsv>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<ColorHsv, ZeroInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<ColorHsv, ZeroInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<ZeroInitT, ColorHsv>::value));
CORRADE_VERIFY(!std::is_convertible<ZeroInitT, ColorHsv>::value);
}
void ColorTest::constructHsvNoInit() {
@ -517,10 +517,10 @@ void ColorTest::constructHsvNoInit() {
CORRADE_COMPARE(a, (ColorHsv{135.0_degf, 0.5f, 0.9f}));
}
CORRADE_VERIFY((std::is_nothrow_constructible<ColorHsv, Magnum::NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<ColorHsv, Magnum::NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, ColorHsv>::value));
CORRADE_VERIFY(!std::is_convertible<Magnum::NoInitT, ColorHsv>::value);
}
void ColorTest::constructHsvConversion() {
@ -537,9 +537,9 @@ void ColorTest::constructHsvConversion() {
CORRADE_COMPARE(cb, (ColorHsv(135.0_degf, 0.5f, 0.9f)));
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<ColorHsvd, ColorHsv>::value));
CORRADE_VERIFY(!std::is_convertible<ColorHsvd, ColorHsv>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<ColorHsv, ColorHsvd>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<ColorHsv, ColorHsvd>::value);
}
void ColorTest::constructHsvCopy() {
@ -556,11 +556,11 @@ void ColorTest::constructHsvCopy() {
}
void ColorTest::compareHsv() {
CORRADE_VERIFY((ColorHsv{135.0_degf, 0.5f, 0.9f} == ColorHsv{135.0_degf + TypeTraits<Float>::epsilon()*100.0_degf, 0.5f, 0.9f}));
CORRADE_VERIFY((ColorHsv{135.0_degf, 0.5f, 0.9f} != ColorHsv{135.0_degf + TypeTraits<Float>::epsilon()*400.0_degf, 0.5f, 0.9f}));
CORRADE_VERIFY(ColorHsv{135.0_degf, 0.5f, 0.9f} == ColorHsv{135.0_degf + TypeTraits<Float>::epsilon()*100.0_degf, 0.5f, 0.9f});
CORRADE_VERIFY(ColorHsv{135.0_degf, 0.5f, 0.9f} != ColorHsv{135.0_degf + TypeTraits<Float>::epsilon()*400.0_degf, 0.5f, 0.9f});
CORRADE_VERIFY((ColorHsv{135.0_degf, 0.5f, 0.9f} == ColorHsv{135.0_degf, 0.5f, 0.9f + TypeTraits<Float>::epsilon()*0.5f}));
CORRADE_VERIFY((ColorHsv{135.0_degf, 0.5f, 0.9f} != ColorHsv{135.0_degf, 0.5f, 0.9f + TypeTraits<Float>::epsilon()*2.0f}));
CORRADE_VERIFY(ColorHsv{135.0_degf, 0.5f, 0.9f} == ColorHsv{135.0_degf, 0.5f, 0.9f + TypeTraits<Float>::epsilon()*0.5f});
CORRADE_VERIFY(ColorHsv{135.0_degf, 0.5f, 0.9f} != ColorHsv{135.0_degf, 0.5f, 0.9f + TypeTraits<Float>::epsilon()*2.0f});
}
void ColorTest::data() {
@ -582,10 +582,10 @@ void ColorTest::data() {
CORRADE_COMPARE(cc3a, (Color3{1.0f, 2.0f, 3.0f}));
CORRADE_COMPARE(cc3b, (Color3{1.0f, 2.0f, 3.0f}));
CORRADE_VERIFY((std::is_same<decltype(c.xyz()), Color3&>::value));
CORRADE_VERIFY((std::is_same<decltype(cc.xyz()), const Color3>::value));
CORRADE_VERIFY((std::is_same<decltype(c.rgb()), Color3&>::value));
CORRADE_VERIFY((std::is_same<decltype(cc.rgb()), const Color3>::value));
CORRADE_VERIFY(std::is_same<decltype(c.xyz()), Color3&>::value);
CORRADE_VERIFY(std::is_same<decltype(cc.xyz()), const Color3>::value);
CORRADE_VERIFY(std::is_same<decltype(c.rgb()), Color3&>::value);
CORRADE_VERIFY(std::is_same<decltype(cc.rgb()), const Color3>::value);
}
void ColorTest::literals() {
@ -1009,16 +1009,16 @@ void ColorTest::swizzleType() {
constexpr Color4ub origColor4;
constexpr auto a = Math::gather<'y', 'z', 'r'>(origColor3);
CORRADE_VERIFY((std::is_same<decltype(a), const Color3>::value));
CORRADE_VERIFY(std::is_same<decltype(a), const Color3>::value);
constexpr auto b = Math::gather<'y', 'z', 'a'>(origColor4);
CORRADE_VERIFY((std::is_same<decltype(b), const Color3ub>::value));
CORRADE_VERIFY(std::is_same<decltype(b), const Color3ub>::value);
constexpr auto c = Math::gather<'y', 'z', 'y', 'x'>(origColor3);
CORRADE_VERIFY((std::is_same<decltype(c), const Color4>::value));
CORRADE_VERIFY(std::is_same<decltype(c), const Color4>::value);
constexpr auto d = Math::gather<'y', 'a', 'y', 'x'>(origColor4);
CORRADE_VERIFY((std::is_same<decltype(d), const Color4ub>::value));
CORRADE_VERIFY(std::is_same<decltype(d), const Color4ub>::value);
}
void ColorTest::debug() {

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

@ -174,7 +174,7 @@ void ComplexTest::construct() {
CORRADE_COMPARE(a.real(), 0.5f);
CORRADE_COMPARE(a.imaginary(), -3.7f);
CORRADE_VERIFY((std::is_nothrow_constructible<Complex, Float, Float>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Complex, Float, Float>::value);
}
void ComplexTest::constructIdentity() {
@ -186,20 +186,20 @@ void ComplexTest::constructIdentity() {
CORRADE_COMPARE(b.length(), 1.0f);
CORRADE_VERIFY(std::is_nothrow_default_constructible<Complex>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Complex, IdentityInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Complex, IdentityInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<IdentityInitT, Complex>::value));
CORRADE_VERIFY(!std::is_convertible<IdentityInitT, Complex>::value);
}
void ComplexTest::constructZero() {
constexpr Complex a{ZeroInit};
CORRADE_COMPARE(a, Complex(0.0f, 0.0f));
CORRADE_VERIFY((std::is_nothrow_constructible<Complex, ZeroInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Complex, ZeroInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<ZeroInitT, Complex>::value));
CORRADE_VERIFY(!std::is_convertible<ZeroInitT, Complex>::value);
}
void ComplexTest::constructNoInit() {
@ -212,10 +212,10 @@ void ComplexTest::constructNoInit() {
CORRADE_COMPARE(a, Complex(0.5f, -3.7f));
}
CORRADE_VERIFY((std::is_nothrow_constructible<Complex, Magnum::NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Complex, Magnum::NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Complex>::value));
CORRADE_VERIFY(!std::is_convertible<Magnum::NoInitT, Complex>::value);
}
void ComplexTest::constructFromVector() {
@ -228,10 +228,10 @@ void ComplexTest::constructFromVector() {
CORRADE_COMPARE(b, vec);
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Vector2, Complex>::value));
CORRADE_VERIFY(!(std::is_convertible<Complex, Vector2>::value));
CORRADE_VERIFY(!std::is_convertible<Vector2, Complex>::value);
CORRADE_VERIFY(!std::is_convertible<Complex, Vector2>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Complex, Vector2>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Complex, Vector2>::value);
}
void ComplexTest::constructConversion() {
@ -243,9 +243,9 @@ void ComplexTest::constructConversion() {
CORRADE_COMPARE(b, (Complexi{1, 2}));
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Complex, Complexi>::value));
CORRADE_VERIFY(!std::is_convertible<Complex, Complexi>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Complex, Complexi>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Complex, Complexi>::value);
}
void ComplexTest::constructCopy() {
@ -271,8 +271,8 @@ void ComplexTest::convert() {
CORRADE_COMPARE(d.im, a.im);
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Cmpl, Complex>::value));
CORRADE_VERIFY(!(std::is_convertible<Complex, Cmpl>::value));
CORRADE_VERIFY(!std::is_convertible<Cmpl, Complex>::value);
CORRADE_VERIFY(!std::is_convertible<Complex, Cmpl>::value);
}
void ComplexTest::data() {
@ -308,8 +308,8 @@ void ComplexTest::isNormalized() {
template<class T> void ComplexTest::isNormalizedEpsilon() {
setTestCaseTemplateName(TypeTraits<T>::name());
CORRADE_VERIFY((Math::Complex<T>{T(0.801775644243754) + TypeTraits<T>::epsilon()/T(2.0), T(0.597625146975521)}.isNormalized()));
CORRADE_VERIFY(!(Math::Complex<T>{T(0.801775644243754) + TypeTraits<T>::epsilon()*T(2.0), T(0.597625146975521)}.isNormalized()));
CORRADE_VERIFY(Math::Complex<T>{T(0.801775644243754) + TypeTraits<T>::epsilon()/T(2.0), T(0.597625146975521)}.isNormalized());
CORRADE_VERIFY(!Math::Complex<T>{T(0.801775644243754) + TypeTraits<T>::epsilon()*T(2.0), T(0.597625146975521)}.isNormalized());
}
void ComplexTest::addSubtract() {

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

@ -230,7 +230,7 @@ void CubicHermiteTest::constructScalar() {
CORRADE_COMPARE(a.outTangent(), -0.5f);
CORRADE_COMPARE(b.outTangent(), -0.5f);
CORRADE_VERIFY((std::is_nothrow_constructible<CubicHermite1D, Float, Float, Float>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<CubicHermite1D, Float, Float, Float>::value);
}
void CubicHermiteTest::constructVector() {
@ -244,7 +244,7 @@ void CubicHermiteTest::constructVector() {
CORRADE_COMPARE(a.outTangent(), (Vector2{3.0f, -0.5f}));
CORRADE_COMPARE(b.outTangent(), (Vector2{3.0f, -0.5f}));
CORRADE_VERIFY((std::is_nothrow_constructible<CubicHermite2D, Vector2, Vector2, Vector2>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<CubicHermite2D, Vector2, Vector2, Vector2>::value);
}
void CubicHermiteTest::constructComplex() {
@ -258,7 +258,7 @@ void CubicHermiteTest::constructComplex() {
CORRADE_COMPARE(a.outTangent(), (Complex{3.0f, -0.5f}));
CORRADE_COMPARE(b.outTangent(), (Complex{3.0f, -0.5f}));
CORRADE_VERIFY((std::is_nothrow_constructible<CubicHermiteComplex, Complex, Complex, Complex>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<CubicHermiteComplex, Complex, Complex, Complex>::value);
}
void CubicHermiteTest::constructQuaternion() {
@ -278,7 +278,7 @@ void CubicHermiteTest::constructQuaternion() {
CORRADE_COMPARE(a.outTangent(), (Quaternion{{3.0f, -0.5f, 1.2f}, 0.3f}));
CORRADE_COMPARE(b.outTangent(), (Quaternion{{3.0f, -0.5f, 1.2f}, 0.3f}));
CORRADE_VERIFY((std::is_nothrow_constructible<CubicHermiteQuaternion, Quaternion, Quaternion, Quaternion>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<CubicHermiteQuaternion, Quaternion, Quaternion, Quaternion>::value);
}
void CubicHermiteTest::constructDefaultScalar() {
@ -289,7 +289,7 @@ void CubicHermiteTest::constructDefaultScalar() {
CORRADE_COMPARE(a, (CubicHermite1D{0.0f, 0.0f, 0.0f}));
CORRADE_COMPARE(b, (CubicHermite1D{0.0f, 0.0f, 0.0f}));
CORRADE_VERIFY((std::is_nothrow_default_constructible<CubicHermite1D>::value));
CORRADE_VERIFY(std::is_nothrow_default_constructible<CubicHermite1D>::value);
}
void CubicHermiteTest::constructDefaultVector() {
@ -300,7 +300,7 @@ void CubicHermiteTest::constructDefaultVector() {
CORRADE_COMPARE(a, (CubicHermite2D{{0.0f, 0.0f}, {0.0f, 0.0f}, {0.0f, 0.0f}}));
CORRADE_COMPARE(b, (CubicHermite2D{{0.0f, 0.0f}, {0.0f, 0.0f}, {0.0f, 0.0f}}));
CORRADE_VERIFY((std::is_nothrow_default_constructible<CubicHermite2D>::value));
CORRADE_VERIFY(std::is_nothrow_default_constructible<CubicHermite2D>::value);
}
void CubicHermiteTest::constructDefaultComplex() {
@ -311,7 +311,7 @@ void CubicHermiteTest::constructDefaultComplex() {
CORRADE_COMPARE(a, (CubicHermiteComplex{{0.0f, 0.0f}, {1.0f, 0.0f}, {0.0f, 0.0f}}));
CORRADE_COMPARE(b, (CubicHermiteComplex{{0.0f, 0.0f}, {1.0f, 0.0f}, {0.0f, 0.0f}}));
CORRADE_VERIFY((std::is_nothrow_default_constructible<CubicHermiteComplex>::value));
CORRADE_VERIFY(std::is_nothrow_default_constructible<CubicHermiteComplex>::value);
}
void CubicHermiteTest::constructDefaultQuaternion() {
@ -328,7 +328,7 @@ void CubicHermiteTest::constructDefaultQuaternion() {
{{0.0f, 0.0f, 0.0f}, 1.0f},
{{0.0f, 0.0f, 0.0f}, 0.0f}}));
CORRADE_VERIFY((std::is_nothrow_default_constructible<CubicHermiteQuaternion>::value));
CORRADE_VERIFY(std::is_nothrow_default_constructible<CubicHermiteQuaternion>::value);
}
void CubicHermiteTest::constructZeroScalar() {
@ -338,10 +338,10 @@ void CubicHermiteTest::constructZeroScalar() {
CORRADE_COMPARE(a, (CubicHermite1D{0.0f, 0.0f, 0.0f}));
CORRADE_COMPARE(b, (CubicHermite1D{0.0f, 0.0f, 0.0f}));
CORRADE_VERIFY((std::is_nothrow_constructible<CubicHermite1D, ZeroInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<CubicHermite1D, ZeroInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<ZeroInitT, CubicHermite1D>::value));
CORRADE_VERIFY(!std::is_convertible<ZeroInitT, CubicHermite1D>::value);
}
void CubicHermiteTest::constructZeroVector() {
@ -351,10 +351,10 @@ void CubicHermiteTest::constructZeroVector() {
CORRADE_COMPARE(a, (CubicHermite2D{{0.0f, 0.0f}, {0.0f, 0.0f}, {0.0f, 0.0f}}));
CORRADE_COMPARE(b, (CubicHermite2D{{0.0f, 0.0f}, {0.0f, 0.0f}, {0.0f, 0.0f}}));
CORRADE_VERIFY((std::is_nothrow_constructible<CubicHermite2D, ZeroInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<CubicHermite2D, ZeroInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<ZeroInitT, CubicHermite2D>::value));
CORRADE_VERIFY(!std::is_convertible<ZeroInitT, CubicHermite2D>::value);
}
void CubicHermiteTest::constructZeroComplex() {
@ -364,10 +364,10 @@ void CubicHermiteTest::constructZeroComplex() {
CORRADE_COMPARE(a, (CubicHermiteComplex{{0.0f, 0.0f}, {0.0f, 0.0f}, {0.0f, 0.0f}}));
CORRADE_COMPARE(b, (CubicHermiteComplex{{0.0f, 0.0f}, {0.0f, 0.0f}, {0.0f, 0.0f}}));
CORRADE_VERIFY((std::is_nothrow_constructible<CubicHermiteComplex, ZeroInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<CubicHermiteComplex, ZeroInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<ZeroInitT, CubicHermiteComplex>::value));
CORRADE_VERIFY(!std::is_convertible<ZeroInitT, CubicHermiteComplex>::value);
}
void CubicHermiteTest::constructZeroQuaternion() {
@ -383,18 +383,18 @@ void CubicHermiteTest::constructZeroQuaternion() {
{{0.0f, 0.0f, 0.0f}, 0.0f},
{{0.0f, 0.0f, 0.0f}, 0.0f}}));
CORRADE_VERIFY((std::is_nothrow_constructible<CubicHermiteQuaternion, ZeroInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<CubicHermiteQuaternion, ZeroInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<ZeroInitT, CubicHermiteQuaternion>::value));
CORRADE_VERIFY(!std::is_convertible<ZeroInitT, CubicHermiteQuaternion>::value);
}
void CubicHermiteTest::constructIdentityScalar() {
CORRADE_VERIFY(!(std::is_constructible<CubicHermite1D, IdentityInitT>::value));
CORRADE_VERIFY(!std::is_constructible<CubicHermite1D, IdentityInitT>::value);
}
void CubicHermiteTest::constructIdentityVector() {
CORRADE_VERIFY(!(std::is_constructible<CubicHermite2D, IdentityInitT>::value));
CORRADE_VERIFY(!std::is_constructible<CubicHermite2D, IdentityInitT>::value);
}
void CubicHermiteTest::constructIdentityComplex() {
@ -404,10 +404,10 @@ void CubicHermiteTest::constructIdentityComplex() {
CORRADE_COMPARE(a, (CubicHermiteComplex{{0.0f, 0.0f}, {1.0f, 0.0f}, {0.0f, 0.0f}}));
CORRADE_COMPARE(b, (CubicHermiteComplex{{0.0f, 0.0f}, {1.0f, 0.0f}, {0.0f, 0.0f}}));
CORRADE_VERIFY((std::is_nothrow_constructible<CubicHermiteComplex, IdentityInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<CubicHermiteComplex, IdentityInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<IdentityInitT, CubicHermiteComplex>::value));
CORRADE_VERIFY(!std::is_convertible<IdentityInitT, CubicHermiteComplex>::value);
}
void CubicHermiteTest::constructIdentityQuaternion() {
@ -423,10 +423,10 @@ void CubicHermiteTest::constructIdentityQuaternion() {
{{0.0f, 0.0f, 0.0f}, 1.0f},
{{0.0f, 0.0f, 0.0f}, 0.0f}}));
CORRADE_VERIFY((std::is_nothrow_constructible<CubicHermiteComplex, IdentityInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<CubicHermiteComplex, IdentityInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<IdentityInitT, CubicHermiteQuaternion>::value));
CORRADE_VERIFY(!std::is_convertible<IdentityInitT, CubicHermiteQuaternion>::value);
}
void CubicHermiteTest::constructNoInitScalar() {
@ -439,10 +439,10 @@ void CubicHermiteTest::constructNoInitScalar() {
CORRADE_COMPARE(spline, (CubicHermite1D{2.0f, -2.0f, -0.5f}));
}
CORRADE_VERIFY((std::is_nothrow_constructible<CubicHermite1D, Magnum::NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<CubicHermite1D, Magnum::NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, CubicHermite1D>::value));
CORRADE_VERIFY(!std::is_convertible<Magnum::NoInitT, CubicHermite1D>::value);
}
void CubicHermiteTest::constructNoInitVector() {
@ -455,10 +455,10 @@ void CubicHermiteTest::constructNoInitVector() {
CORRADE_COMPARE(spline, (CubicHermite2D{{1.0f, 2.0f}, {1.5f, -2.0f}, {3.0f, -0.5f}}));
}
CORRADE_VERIFY((std::is_nothrow_constructible<CubicHermite2D, Magnum::NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<CubicHermite2D, Magnum::NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, CubicHermite2D>::value));
CORRADE_VERIFY(!std::is_convertible<Magnum::NoInitT, CubicHermite2D>::value);
}
void CubicHermiteTest::constructNoInitComplex() {
@ -471,10 +471,10 @@ void CubicHermiteTest::constructNoInitComplex() {
CORRADE_COMPARE(spline, (CubicHermiteComplex{{1.0f, 2.0f}, {1.5f, -2.0f}, {3.0f, -0.5f}}));
}
CORRADE_VERIFY((std::is_nothrow_constructible<CubicHermiteComplex, Magnum::NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<CubicHermiteComplex, Magnum::NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, CubicHermiteComplex>::value));
CORRADE_VERIFY(!std::is_convertible<Magnum::NoInitT, CubicHermiteComplex>::value);
}
void CubicHermiteTest::constructNoInitQuaternion() {
@ -493,10 +493,10 @@ void CubicHermiteTest::constructNoInitQuaternion() {
{{3.0f, -0.5f, 1.2f}, 0.3f}}));
}
CORRADE_VERIFY((std::is_nothrow_constructible<CubicHermiteQuaternion, Magnum::NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<CubicHermiteQuaternion, Magnum::NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, CubicHermiteQuaternion>::value));
CORRADE_VERIFY(!std::is_convertible<Magnum::NoInitT, CubicHermiteQuaternion>::value);
}
void CubicHermiteTest::constructConversionScalar() {
@ -509,9 +509,9 @@ void CubicHermiteTest::constructConversionScalar() {
CORRADE_COMPARE(c, (CubicHermite1Di{2, -2, 0}));
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<CubicHermite1D, CubicHermite1Di>::value));
CORRADE_VERIFY(!std::is_convertible<CubicHermite1D, CubicHermite1Di>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<CubicHermite1D, CubicHermite1Di>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<CubicHermite1D, CubicHermite1Di>::value);
}
void CubicHermiteTest::constructConversionVector() {
@ -524,9 +524,9 @@ void CubicHermiteTest::constructConversionVector() {
CORRADE_COMPARE(c, (CubicHermite2Di{{1, 2}, {1, -2}, {3, 0}}));
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<CubicHermite2D, CubicHermite2Di>::value));
CORRADE_VERIFY(!std::is_convertible<CubicHermite2D, CubicHermite2Di>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<CubicHermite2D, CubicHermite2Di>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<CubicHermite2D, CubicHermite2Di>::value);
}
void CubicHermiteTest::constructConversionComplex() {
@ -539,9 +539,9 @@ void CubicHermiteTest::constructConversionComplex() {
CORRADE_COMPARE(c, (CubicHermiteComplexi{{1, 2}, {1, -2}, {3, 0}}));
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<CubicHermiteComplex, CubicHermiteComplexi>::value));
CORRADE_VERIFY(!std::is_convertible<CubicHermiteComplex, CubicHermiteComplexi>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<CubicHermiteComplex, CubicHermiteComplexi>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<CubicHermiteComplex, CubicHermiteComplexi>::value);
}
void CubicHermiteTest::constructConversionQuaternion() {
@ -563,9 +563,9 @@ void CubicHermiteTest::constructConversionQuaternion() {
{{3, 0, 1}, 0}}));
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<CubicHermiteQuaternion, CubicHermiteQuaternioni>::value));
CORRADE_VERIFY(!std::is_convertible<CubicHermiteQuaternion, CubicHermiteQuaternioni>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<CubicHermiteQuaternion, CubicHermiteQuaternioni>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<CubicHermiteQuaternion, CubicHermiteQuaternioni>::value);
}
void CubicHermiteTest::constructFromBezier() {
@ -723,35 +723,35 @@ void CubicHermiteTest::dataQuaternion() {
}
void CubicHermiteTest::compareScalar() {
CORRADE_VERIFY((CubicHermite1D{3.0f, 1.0f, 2.0f} == CubicHermite1D{3.0f, 1.0f + TypeTraits<Float>::epsilon()/2, 2.0f}));
CORRADE_VERIFY((CubicHermite1D{3.0f, 1.0f, 2.0f} != CubicHermite1D{3.0f + TypeTraits<Float>::epsilon()*6, 1.0f, 2.0f}));
CORRADE_VERIFY(CubicHermite1D{3.0f, 1.0f, 2.0f} == CubicHermite1D{3.0f, 1.0f + TypeTraits<Float>::epsilon()/2, 2.0f});
CORRADE_VERIFY(CubicHermite1D{3.0f, 1.0f, 2.0f} != CubicHermite1D{3.0f + TypeTraits<Float>::epsilon()*6, 1.0f, 2.0f});
}
void CubicHermiteTest::compareVector() {
CORRADE_VERIFY((CubicHermite2D{{1.0f, 3.0f}, {1.0f, -2.0f}, {3.0f, 2.0f}}) == (CubicHermite2D{{1.0f, 3.0f}, {1.0f, -2.0f}, {3.0f, 2.0f + TypeTraits<Float>::epsilon()/2}}));
CORRADE_VERIFY((CubicHermite2D{{1.0f, 3.0f}, {1.0f, -2.0f}, {3.0f, 2.0f}}) != (CubicHermite2D{{1.0f + TypeTraits<Float>::epsilon()*2, 3.0f}, {1.0f, -2.0f}, {3.0f, 2.0f}}));
CORRADE_VERIFY(CubicHermite2D{{1.0f, 3.0f}, {1.0f, -2.0f}, {3.0f, 2.0f}} == CubicHermite2D{{1.0f, 3.0f}, {1.0f, -2.0f}, {3.0f, 2.0f + TypeTraits<Float>::epsilon()/2}});
CORRADE_VERIFY(CubicHermite2D{{1.0f, 3.0f}, {1.0f, -2.0f}, {3.0f, 2.0f}} != CubicHermite2D{{1.0f + TypeTraits<Float>::epsilon()*2, 3.0f}, {1.0f, -2.0f}, {3.0f, 2.0f}});
}
void CubicHermiteTest::compareComplex() {
CORRADE_VERIFY((CubicHermiteComplex{{1.0f, 3.0f}, {1.0f, -2.0f}, {3.0f, 2.0f}}) == (CubicHermiteComplex{{1.0f, 3.0f}, {1.0f, -2.0f}, {3.0f, 2.0f + TypeTraits<Float>::epsilon()/2}}));
CORRADE_VERIFY((CubicHermiteComplex{{1.0f, 3.0f}, {1.0f, -2.0f}, {3.0f, 2.0f}}) != (CubicHermiteComplex{{1.0f + TypeTraits<Float>::epsilon()*2, 3.0f}, {1.0f, -2.0f}, {3.0f, 2.0f}}));
CORRADE_VERIFY(CubicHermiteComplex{{1.0f, 3.0f}, {1.0f, -2.0f}, {3.0f, 2.0f}} == CubicHermiteComplex{{1.0f, 3.0f}, {1.0f, -2.0f}, {3.0f, 2.0f + TypeTraits<Float>::epsilon()/2}});
CORRADE_VERIFY(CubicHermiteComplex{{1.0f, 3.0f}, {1.0f, -2.0f}, {3.0f, 2.0f}} != CubicHermiteComplex{{1.0f + TypeTraits<Float>::epsilon()*2, 3.0f}, {1.0f, -2.0f}, {3.0f, 2.0f}});
}
void CubicHermiteTest::compareQuaternion() {
CORRADE_VERIFY((CubicHermiteQuaternion{
CORRADE_VERIFY(CubicHermiteQuaternion{
{{1.0f, 3.0f, -1.0f}, 3.0f},
{{1.5f, -2.0f, 0.1f}, 1.0f},
{{3.0f, -0.5f, 2.0f}, 0.3f}}) == (CubicHermiteQuaternion{
{{3.0f, -0.5f, 2.0f}, 0.3f}} == CubicHermiteQuaternion{
{{1.0f, 3.0f, -1.0f}, 3.0f},
{{1.5f, -2.0f, 0.1f}, 1.0f + TypeTraits<Float>::epsilon()/2},
{{3.0f, -0.5f, 2.0f}, 0.3f}}));
CORRADE_VERIFY((CubicHermiteQuaternion{
{{3.0f, -0.5f, 2.0f}, 0.3f}});
CORRADE_VERIFY(CubicHermiteQuaternion{
{{1.0f, 3.0f, -1.0f}, 3.0f},
{{1.5f, -2.0f, 0.1f}, 1.0f},
{{3.0f, -0.5f, 2.0f}, 0.3f}}) != (CubicHermiteQuaternion{
{{3.0f, -0.5f, 2.0f}, 0.3f}} != CubicHermiteQuaternion{
{{1.0f + TypeTraits<Float>::epsilon()*2, 3.0f, -1.0f}, 3.0f},
{{1.5f, -2.0f, 0.1f}, 1.0f},
{{3.0f, -0.5f, 2.0f}, 0.3f}}));
{{3.0f, -0.5f, 2.0f}, 0.3f}});
}
void CubicHermiteTest::selectScalar() {

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

@ -170,7 +170,7 @@ void DualComplexTest::construct() {
constexpr DualComplex b(Complex(-1.0f, 2.5f));
CORRADE_COMPARE(b, DualComplex({-1.0f, 2.5f}, {0.0f, 0.0f}));
CORRADE_VERIFY((std::is_nothrow_constructible<DualComplex, Complex, Complex>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<DualComplex, Complex, Complex>::value);
}
void DualComplexTest::constructIdentity() {
@ -182,20 +182,20 @@ void DualComplexTest::constructIdentity() {
CORRADE_COMPARE(b.length(), 1.0f);
CORRADE_VERIFY(std::is_nothrow_default_constructible<DualComplex>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<DualComplex, IdentityInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<DualComplex, IdentityInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<IdentityInitT, DualComplex>::value));
CORRADE_VERIFY(!std::is_convertible<IdentityInitT, DualComplex>::value);
}
void DualComplexTest::constructZero() {
constexpr DualComplex a{ZeroInit};
CORRADE_COMPARE(a, DualComplex({0.0f, 0.0f}, {0.0f, 0.0f}));
CORRADE_VERIFY((std::is_nothrow_constructible<DualComplex, ZeroInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<DualComplex, ZeroInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<ZeroInitT, DualComplex>::value));
CORRADE_VERIFY(!std::is_convertible<ZeroInitT, DualComplex>::value);
}
void DualComplexTest::constructNoInit() {
@ -208,10 +208,10 @@ void DualComplexTest::constructNoInit() {
CORRADE_COMPARE(a, DualComplex({-1.0f, 2.5f}, {3.0f, -7.5f}));
}
CORRADE_VERIFY((std::is_nothrow_constructible<DualComplex, Magnum::NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<DualComplex, Magnum::NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, DualComplex>::value));
CORRADE_VERIFY(!std::is_convertible<Magnum::NoInitT, DualComplex>::value);
}
void DualComplexTest::constructFromVector() {
@ -219,9 +219,9 @@ void DualComplexTest::constructFromVector() {
CORRADE_COMPARE(a, DualComplex({1.0f, 0.0f}, {1.5f, -3.0f}));
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Vector2, DualComplex>::value));
CORRADE_VERIFY(!std::is_convertible<Vector2, DualComplex>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<DualComplex, Vector2>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<DualComplex, Vector2>::value);
}
void DualComplexTest::constructConversion() {
@ -233,9 +233,9 @@ void DualComplexTest::constructConversion() {
CORRADE_COMPARE(b, (DualComplexi{{1, 2}, {-15, 7}}));
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<DualComplex, DualComplexi>::value));
CORRADE_VERIFY(!std::is_convertible<DualComplex, DualComplexi>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<DualComplex, DualComplexi>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<DualComplex, DualComplexi>::value);
}
void DualComplexTest::constructCopy() {
@ -266,8 +266,8 @@ void DualComplexTest::convert() {
CORRADE_COMPARE(d.y, a.y);
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<DualCmpl, DualComplex>::value));
CORRADE_VERIFY(!(std::is_convertible<DualComplex, DualCmpl>::value));
CORRADE_VERIFY(!std::is_convertible<DualCmpl, DualComplex>::value);
CORRADE_VERIFY(!std::is_convertible<DualComplex, DualCmpl>::value);
}
void DualComplexTest::data() {
@ -294,16 +294,16 @@ void DualComplexTest::isNormalized() {
template<class T> void DualComplexTest::isNormalizedEpsilonRotation() {
setTestCaseTemplateName(TypeTraits<T>::name());
CORRADE_VERIFY((Math::DualComplex<T>{{T(0.801775644243754) + TypeTraits<T>::epsilon()/T(2.0), T(0.597625146975521)}, {T(8018055.25501103), T(5975850.58193309)}}.isNormalized()));
CORRADE_VERIFY(!(Math::DualComplex<T>{{T(0.801775644243754) + TypeTraits<T>::epsilon()*T(2.0), T(0.597625146975521)}, {T(8018055.25501103), T(5975850.58193309)}}.isNormalized()));
CORRADE_VERIFY(Math::DualComplex<T>{{T(0.801775644243754) + TypeTraits<T>::epsilon()/T(2.0), T(0.597625146975521)}, {T(8018055.25501103), T(5975850.58193309)}}.isNormalized());
CORRADE_VERIFY(!Math::DualComplex<T>{{T(0.801775644243754) + TypeTraits<T>::epsilon()*T(2.0), T(0.597625146975521)}, {T(8018055.25501103), T(5975850.58193309)}}.isNormalized());
}
template<class T> void DualComplexTest::isNormalizedEpsilonTranslation() {
setTestCaseTemplateName(TypeTraits<T>::name());
/* Translation does not affect normalization */
CORRADE_VERIFY((Math::DualComplex<T>{{T(0.801775644243754), T(0.597625146975521)}, {T(8018055.25501103), T(20.5)}}.isNormalized()));
CORRADE_VERIFY((Math::DualComplex<T>{{T(0.801775644243754), T(0.597625146975521)}, {T(8018055.25501103), T(-200000000.0)}}.isNormalized()));
CORRADE_VERIFY(Math::DualComplex<T>{{T(0.801775644243754), T(0.597625146975521)}, {T(8018055.25501103), T(20.5)}}.isNormalized());
CORRADE_VERIFY(Math::DualComplex<T>{{T(0.801775644243754), T(0.597625146975521)}, {T(8018055.25501103), T(-200000000.0)}}.isNormalized());
}
void DualComplexTest::multiply() {

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

@ -186,7 +186,7 @@ void DualQuaternionTest::construct() {
constexpr DualQuaternion b({{1.0f, 2.0f, 3.0f}, -4.0f});
CORRADE_COMPARE(b, DualQuaternion({{1.0f, 2.0f, 3.0f}, -4.0f}, {{0.0f, 0.0f, 0.0f}, 0.0f}));
CORRADE_VERIFY((std::is_nothrow_constructible<DualQuaternion, Quaternion, Quaternion>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<DualQuaternion, Quaternion, Quaternion>::value);
}
void DualQuaternionTest::constructVectorScalar() {
@ -199,7 +199,7 @@ void DualQuaternionTest::constructVectorScalar() {
constexpr Quaternion c = a.dual();
CORRADE_COMPARE(c, Quaternion({0.5f, -3.1f, 3.3f}, 2.0f));
CORRADE_VERIFY((std::is_nothrow_constructible<DualQuaternion, Math::Dual<Vector3>, Math::Dual<Float>>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<DualQuaternion, Math::Dual<Vector3>, Math::Dual<Float>>::value);
}
void DualQuaternionTest::constructIdentity() {
@ -211,20 +211,20 @@ void DualQuaternionTest::constructIdentity() {
CORRADE_COMPARE(b.length(), 1.0f);
CORRADE_VERIFY(std::is_nothrow_default_constructible<DualQuaternion>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<DualQuaternion, IdentityInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<DualQuaternion, IdentityInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<IdentityInitT, DualQuaternion>::value));
CORRADE_VERIFY(!std::is_convertible<IdentityInitT, DualQuaternion>::value);
}
void DualQuaternionTest::constructZero() {
constexpr DualQuaternion a{ZeroInit};
CORRADE_COMPARE(a, DualQuaternion({{0.0f, 0.0f, 0.0f}, 0.0f}, {{0.0f, 0.0f, 0.0f}, 0.0f}));
CORRADE_VERIFY((std::is_nothrow_constructible<DualQuaternion, ZeroInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<DualQuaternion, ZeroInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<ZeroInitT, DualQuaternion>::value));
CORRADE_VERIFY(!std::is_convertible<ZeroInitT, DualQuaternion>::value);
}
void DualQuaternionTest::constructNoInit() {
@ -237,10 +237,10 @@ void DualQuaternionTest::constructNoInit() {
CORRADE_COMPARE(a, DualQuaternion({{1.0f, 2.0f, 3.0f}, -4.0f}, {{0.5f, -3.1f, 3.3f}, 2.0f}));
}
CORRADE_VERIFY((std::is_nothrow_constructible<DualQuaternion, Magnum::NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<DualQuaternion, Magnum::NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, DualQuaternion>::value));
CORRADE_VERIFY(!std::is_convertible<Magnum::NoInitT, DualQuaternion>::value);
}
void DualQuaternionTest::constructFromVector() {
@ -248,9 +248,9 @@ void DualQuaternionTest::constructFromVector() {
CORRADE_COMPARE(a, DualQuaternion({{0.0f, 0.0f, 0.0f}, 1.0f}, {{1.0f, 2.0f, 3.0f}, 0.0f}));
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Vector3, DualQuaternion>::value));
CORRADE_VERIFY(!std::is_convertible<Vector3, DualQuaternion>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<DualQuaternion, Vector3>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<DualQuaternion, Vector3>::value);
}
void DualQuaternionTest::constructConversion() {
@ -262,9 +262,9 @@ void DualQuaternionTest::constructConversion() {
CORRADE_COMPARE(b, (DualQuaternioni{{{1, 2, -15}, 7}, {{1, -2, 3}, 0}}));
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<DualQuaternion, DualQuaternioni>::value));
CORRADE_VERIFY(!std::is_convertible<DualQuaternion, DualQuaternioni>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<DualQuaternion, DualQuaternioni>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<DualQuaternion, DualQuaternioni>::value);
}
void DualQuaternionTest::constructCopy() {
@ -299,8 +299,8 @@ void DualQuaternionTest::convert() {
CORRADE_COMPARE(d.du.w, a.du.w);
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<DualQuat, DualQuaternion>::value));
CORRADE_VERIFY(!(std::is_convertible<DualQuaternion, DualQuat>::value));
CORRADE_VERIFY(!std::is_convertible<DualQuat, DualQuaternion>::value);
CORRADE_VERIFY(!std::is_convertible<DualQuaternion, DualQuat>::value);
}
void DualQuaternionTest::data() {
@ -331,19 +331,19 @@ void DualQuaternionTest::isNormalized() {
template<class T> void DualQuaternionTest::isNormalizedEpsilonRotation() {
setTestCaseTemplateName(TypeTraits<T>::name());
CORRADE_VERIFY((Math::DualQuaternion<T>{{{T(0.199367934417197) + TypeTraits<T>::epsilon()/T(2.0), T(0.0), T(0.0)}, T(0.97992470462083)}, {{T(0.440966117079373), T(-0.440120368706115), T(-0.344665143363806)}, T(-0.0897155704877387)}}.isNormalized()));
CORRADE_VERIFY(!(Math::DualQuaternion<T>{{{T(0.199367934417197), T(0.0), T(0.0)}, T(0.97992470462083) + TypeTraits<T>::epsilon()*T(2.0)}, {{T(0.440966117079373), T(-0.440120368706115), T(-0.344665143363806)}, T(-0.0897155704877387)}}.isNormalized()));
CORRADE_VERIFY(Math::DualQuaternion<T>{{{T(0.199367934417197) + TypeTraits<T>::epsilon()/T(2.0), T(0.0), T(0.0)}, T(0.97992470462083)}, {{T(0.440966117079373), T(-0.440120368706115), T(-0.344665143363806)}, T(-0.0897155704877387)}}.isNormalized());
CORRADE_VERIFY(!Math::DualQuaternion<T>{{{T(0.199367934417197), T(0.0), T(0.0)}, T(0.97992470462083) + TypeTraits<T>::epsilon()*T(2.0)}, {{T(0.440966117079373), T(-0.440120368706115), T(-0.344665143363806)}, T(-0.0897155704877387)}}.isNormalized());
}
template<class T> void DualQuaternionTest::isNormalizedEpsilonTranslation() {
setTestCaseTemplateName(TypeTraits<T>::name());
CORRADE_VERIFY((Math::DualQuaternion<T>{{{T(0.199367934417197), T(0.0), T(0.0)}, T(0.97992470462083)}, {{T(0.440966117079373), T(-0.440120368706115) + TypeTraits<T>::epsilon()*T(2.0), T(-0.344665143363806)}, T(-0.0897155704877387)}}.isNormalized()));
CORRADE_VERIFY(!(Math::DualQuaternion<T>{{{T(0.199367934417197), T(0.0), T(0.0)}, T(0.97992470462083)}, {{T(0.440966117079373) + TypeTraits<T>::epsilon()*T(4.0), T(-0.440120368706115), T(-0.344665143363806)}, T(-0.0897155704877387)}}.isNormalized()));
CORRADE_VERIFY(Math::DualQuaternion<T>{{{T(0.199367934417197), T(0.0), T(0.0)}, T(0.97992470462083)}, {{T(0.440966117079373), T(-0.440120368706115) + TypeTraits<T>::epsilon()*T(2.0), T(-0.344665143363806)}, T(-0.0897155704877387)}}.isNormalized());
CORRADE_VERIFY(!Math::DualQuaternion<T>{{{T(0.199367934417197), T(0.0), T(0.0)}, T(0.97992470462083)}, {{T(0.440966117079373) + TypeTraits<T>::epsilon()*T(4.0), T(-0.440120368706115), T(-0.344665143363806)}, T(-0.0897155704877387)}}.isNormalized());
/* Large translation -- large epsilon */
CORRADE_VERIFY((Math::DualQuaternion<T>{{{T(0.0106550719778129), T(0.311128101752138), T(-0.0468823167023769)}, T(0.949151106053128)}, {{T(5056871.9114386), T(-245303.943266211) + TypeTraits<T>::epsilon()*T(10000000.0), T(-606492.066475555)}, T(-6315.26116124973)}}.isNormalized()));
CORRADE_VERIFY(!(Math::DualQuaternion<T>{{{T(0.0106550719778129), T(0.311128101752138), T(-0.0468823167023769)}, T(0.949151106053128)}, {{T(5056871.9114386), T(-245303.943266211) + TypeTraits<T>::epsilon()*T(20000000.0), T(-606492.066475555)}, T(-6315.26116124973)}}.isNormalized()));
CORRADE_VERIFY(Math::DualQuaternion<T>{{{T(0.0106550719778129), T(0.311128101752138), T(-0.0468823167023769)}, T(0.949151106053128)}, {{T(5056871.9114386), T(-245303.943266211) + TypeTraits<T>::epsilon()*T(10000000.0), T(-606492.066475555)}, T(-6315.26116124973)}}.isNormalized());
CORRADE_VERIFY(!Math::DualQuaternion<T>{{{T(0.0106550719778129), T(0.311128101752138), T(-0.0468823167023769)}, T(0.949151106053128)}, {{T(5056871.9114386), T(-245303.943266211) + TypeTraits<T>::epsilon()*T(20000000.0), T(-606492.066475555)}, T(-6315.26116124973)}}.isNormalized());
}
void DualQuaternionTest::lengthSquared() {

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

@ -118,7 +118,7 @@ void DualTest::construct() {
CORRADE_COMPARE(d.real(), 3.0f);
CORRADE_COMPARE(d.dual(), 0.0f);
CORRADE_VERIFY((std::is_nothrow_constructible<Dual, Float, Float>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Dual, Float, Float>::value);
}
void DualTest::constructDefault() {
@ -136,12 +136,12 @@ void DualTest::constructZero() {
CORRADE_COMPARE(a, Dual(0.0f, 0.0f));
CORRADE_COMPARE(b, Math::Dual<Math::Quaternion<Float>>({{0.0f, 0.0f, 0.0f}, 0.0f}, {{0.0f, 0.0f, 0.0f}, 0.0f}));
CORRADE_VERIFY((std::is_nothrow_constructible<Dual, ZeroInitT>::value));
CORRADE_VERIFY((std::is_nothrow_constructible<Math::Dual<Math::Quaternion<Float>>, ZeroInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Dual, ZeroInitT>::value);
CORRADE_VERIFY(std::is_nothrow_constructible<Math::Dual<Math::Quaternion<Float>>, ZeroInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<ZeroInitT, Dual>::value));
CORRADE_VERIFY(!(std::is_convertible<ZeroInitT, Math::Dual<Math::Quaternion<Float>>>::value));
CORRADE_VERIFY(!std::is_convertible<ZeroInitT, Dual>::value);
CORRADE_VERIFY(!std::is_convertible<ZeroInitT, Math::Dual<Math::Quaternion<Float>>>::value);
}
void DualTest::constructNoInit() {
@ -157,12 +157,12 @@ void DualTest::constructNoInit() {
CORRADE_COMPARE(b, (Math::Dual<Math::Quaternion<Float>>{{{3.0f, 0.1f, 1.0f}, 1.0f}, {{0.1f, 0.0f, 1.0f}, 0.3f}}));
}
CORRADE_VERIFY((std::is_nothrow_constructible<Dual, Magnum::NoInitT>::value));
CORRADE_VERIFY((std::is_nothrow_constructible<Math::Dual<Math::Quaternion<Float>>, Magnum::NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Dual, Magnum::NoInitT>::value);
CORRADE_VERIFY(std::is_nothrow_constructible<Math::Dual<Math::Quaternion<Float>>, Magnum::NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Dual>::value));
CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Math::Dual<Math::Quaternion<Float>>>::value));
CORRADE_VERIFY(!std::is_convertible<Magnum::NoInitT, Dual>::value);
CORRADE_VERIFY(!std::is_convertible<Magnum::NoInitT, Math::Dual<Math::Quaternion<Float>>>::value);
}
void DualTest::constructConversion() {
@ -174,9 +174,9 @@ void DualTest::constructConversion() {
CORRADE_COMPARE(b, (Duali{1, 2}));
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Dual, Duali>::value));
CORRADE_VERIFY(!std::is_convertible<Dual, Duali>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Dual, Duali>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Dual, Duali>::value);
}
void DualTest::constructCopy() {
@ -278,8 +278,8 @@ void DualTest::sincos() {
void DualTest::sincosWithBase() {
/* Verify that the functions can be called with Dual<Unit<Deg, T>> and Dual<Unit<Rad, T>> */
CORRADE_VERIFY((std::is_same<decltype(2*Math::Dual<Deg>{15.0_degf}), Math::Dual<Unit<Math::Deg, Float>>>::value));
CORRADE_VERIFY((std::is_same<decltype(2*Math::Dual<Rad>{Rad{Constants::pi()/12}}), Math::Dual<Unit<Math::Rad, Float>>>::value));
CORRADE_VERIFY(std::is_same<decltype(2*Math::Dual<Deg>{15.0_degf}), Math::Dual<Unit<Math::Deg, Float>>>::value);
CORRADE_VERIFY(std::is_same<decltype(2*Math::Dual<Rad>{Rad{Constants::pi()/12}}), Math::Dual<Unit<Math::Rad, Float>>>::value);
const auto result = std::make_pair(
Dual(0.5f, 0.8660254037844386f*Constants::pi()/2),
@ -317,25 +317,25 @@ typedef BasicDualVec2<Float> DualVec2;
void DualTest::subclassTypes() {
const DualVec2 a;
CORRADE_VERIFY((std::is_same<decltype(-a), DualVec2>::value));
CORRADE_VERIFY((std::is_same<decltype(a + a), DualVec2>::value));
CORRADE_VERIFY((std::is_same<decltype(a - a), DualVec2>::value));
CORRADE_VERIFY((std::is_same<decltype(a*a), DualVec2>::value));
CORRADE_VERIFY((std::is_same<decltype(a/a), DualVec2>::value));
CORRADE_VERIFY(std::is_same<decltype(-a), DualVec2>::value);
CORRADE_VERIFY(std::is_same<decltype(a + a), DualVec2>::value);
CORRADE_VERIFY(std::is_same<decltype(a - a), DualVec2>::value);
CORRADE_VERIFY(std::is_same<decltype(a*a), DualVec2>::value);
CORRADE_VERIFY(std::is_same<decltype(a/a), DualVec2>::value);
DualVec2 b;
CORRADE_VERIFY((std::is_same<decltype(b += a), DualVec2&>::value));
CORRADE_VERIFY((std::is_same<decltype(b -= a), DualVec2&>::value));
CORRADE_VERIFY(std::is_same<decltype(b += a), DualVec2&>::value);
CORRADE_VERIFY(std::is_same<decltype(b -= a), DualVec2&>::value);
const Dual c;
CORRADE_VERIFY((std::is_same<decltype(a*c), DualVec2>::value));
CORRADE_VERIFY((std::is_same<decltype(c*a), DualVec2>::value));
CORRADE_VERIFY((std::is_same<decltype(a/c), DualVec2>::value));
CORRADE_VERIFY((std::is_same<decltype(c/a), DualVec2>::value));
CORRADE_VERIFY((std::is_same<decltype(a*5.0f), DualVec2>::value));
CORRADE_VERIFY((std::is_same<decltype(5.0f*a), DualVec2>::value));
CORRADE_VERIFY((std::is_same<decltype(a/5.0f), DualVec2>::value));
CORRADE_VERIFY(std::is_same<decltype(a*c), DualVec2>::value);
CORRADE_VERIFY(std::is_same<decltype(c*a), DualVec2>::value);
CORRADE_VERIFY(std::is_same<decltype(a/c), DualVec2>::value);
CORRADE_VERIFY(std::is_same<decltype(c/a), DualVec2>::value);
CORRADE_VERIFY(std::is_same<decltype(a*5.0f), DualVec2>::value);
CORRADE_VERIFY(std::is_same<decltype(5.0f*a), DualVec2>::value);
CORRADE_VERIFY(std::is_same<decltype(a/5.0f), DualVec2>::value);
}
void DualTest::subclass() {

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

@ -156,7 +156,7 @@ void FrustumTest::construct() {
CORRADE_COMPARE(cfar, planes[5]);
CORRADE_COMPARE(a.far(), planes[5]);
CORRADE_VERIFY((std::is_nothrow_constructible<Frustum, Vector4, Vector4, Vector4, Vector4, Vector4, Vector4>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Frustum, Vector4, Vector4, Vector4, Vector4, Vector4, Vector4>::value);
}
void FrustumTest::constructIdentity() {
@ -174,10 +174,10 @@ void FrustumTest::constructIdentity() {
CORRADE_COMPARE(b, expected);
CORRADE_VERIFY(std::is_nothrow_default_constructible<Frustum>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Frustum, IdentityInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Frustum, IdentityInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<IdentityInitT, Frustum>::value));
CORRADE_VERIFY(!std::is_convertible<IdentityInitT, Frustum>::value);
}
void FrustumTest::constructNoInit() {
@ -205,7 +205,7 @@ void FrustumTest::constructNoInit() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY((std::is_nothrow_constructible<Frustum, Magnum::NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Frustum, Magnum::NoInitT>::value);
}
void FrustumTest::constructConversion() {
@ -228,9 +228,9 @@ void FrustumTest::constructConversion() {
CORRADE_COMPARE(b, expected);
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Frustum, Frustumd>::value));
CORRADE_VERIFY(!std::is_convertible<Frustum, Frustumd>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Frustum, Frustumd>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Frustum, Frustumd>::value);
}
void FrustumTest::constructCopy() {
@ -294,8 +294,8 @@ void FrustumTest::convert() {
Corrade::TestSuite::Compare::Container);
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Frstm, Frustum>::value));
CORRADE_VERIFY(!(std::is_convertible<Frustum, Frstm>::value));
CORRADE_VERIFY(!std::is_convertible<Frstm, Frustum>::value);
CORRADE_VERIFY(!std::is_convertible<Frustum, Frstm>::value);
}
void FrustumTest::data() {

4
src/Magnum/Math/Test/FunctionsTest.cpp
Unescape View File

@ -588,8 +588,8 @@ void FunctionsTest::trigonometric() {
void FunctionsTest::trigonometricWithBase() {
/* Verify that the functions can be called with Unit<Deg, T> and Unit<Rad, T> */
CORRADE_VERIFY((std::is_same<decltype(2*15.0_degf), Unit<Math::Deg, Float>>::value));
CORRADE_VERIFY((std::is_same<decltype(2*Rad(Constants::pi()/12)), Unit<Math::Rad, Float>>::value));
CORRADE_VERIFY(std::is_same<decltype(2*15.0_degf), Unit<Math::Deg, Float>>::value);
CORRADE_VERIFY(std::is_same<decltype(2*Rad(Constants::pi()/12)), Unit<Math::Rad, Float>>::value);
CORRADE_COMPARE(Math::sin(2*15.0_degf), 0.5f);
CORRADE_COMPARE(Math::sin(2*Rad(Constants::pi()/12)), 0.5f);

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

@ -504,11 +504,11 @@ void HalfTest::constructDefault() {
CORRADE_COMPARE(UnsignedShort(b), 0);
CORRADE_COMPARE(b.data(), 0);
CORRADE_VERIFY((std::is_nothrow_default_constructible<Half>::value));
CORRADE_VERIFY((std::is_nothrow_constructible<Half, ZeroInitT>::value));
CORRADE_VERIFY(std::is_nothrow_default_constructible<Half>::value);
CORRADE_VERIFY(std::is_nothrow_constructible<Half, ZeroInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<ZeroInitT, Half>::value));
CORRADE_VERIFY(!std::is_convertible<ZeroInitT, Half>::value);
}
void HalfTest::constructValue() {
@ -521,12 +521,12 @@ void HalfTest::constructValue() {
CORRADE_COMPARE(a.data(), 0x4300);
CORRADE_COMPARE(b.data(), 0x4300);
CORRADE_VERIFY((std::is_nothrow_constructible<Half, Float>::value));
CORRADE_VERIFY((std::is_nothrow_constructible<Half, Double>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Half, Float>::value);
CORRADE_VERIFY(std::is_nothrow_constructible<Half, Double>::value);
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Float, Half>::value));
CORRADE_VERIFY(!(std::is_convertible<Double, Half>::value));
CORRADE_VERIFY(!std::is_convertible<Float, Half>::value);
CORRADE_VERIFY(!std::is_convertible<Double, Half>::value);
}
void HalfTest::constructData() {
@ -534,10 +534,10 @@ void HalfTest::constructData() {
CORRADE_COMPARE(Float(a), 3.5f);
CORRADE_COMPARE(UnsignedShort(a), 0x4300);
CORRADE_VERIFY((std::is_nothrow_constructible<Half, UnsignedShort>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Half, UnsignedShort>::value);
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<UnsignedShort, Half>::value));
CORRADE_VERIFY(!std::is_convertible<UnsignedShort, Half>::value);
}
void HalfTest::constructNoInit() {
@ -550,10 +550,10 @@ void HalfTest::constructNoInit() {
CORRADE_COMPARE(a, Half{3.5f});
}
CORRADE_VERIFY((std::is_nothrow_constructible<Half, Magnum::NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Half, Magnum::NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Half>::value));
CORRADE_VERIFY(!std::is_convertible<Magnum::NoInitT, Half>::value);
}
void HalfTest::constructCopy() {

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

@ -164,7 +164,7 @@ void Matrix3Test::construct() {
{4.5f, 4.0f, 7.0f},
{7.9f, -1.0f, 8.0f}));
CORRADE_VERIFY((std::is_nothrow_constructible<Matrix3, Vector3, Vector3, Vector3>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Matrix3, Vector3, Vector3, Vector3>::value);
}
void Matrix3Test::constructIdentity() {
@ -185,10 +185,10 @@ void Matrix3Test::constructIdentity() {
CORRADE_COMPARE(identity3, identity3Expected);
CORRADE_VERIFY(std::is_nothrow_default_constructible<Matrix3>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Matrix3, IdentityInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Matrix3, IdentityInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<IdentityInitT, Matrix3>::value));
CORRADE_VERIFY(!std::is_convertible<IdentityInitT, Matrix3>::value);
}
void Matrix3Test::constructZero() {
@ -197,10 +197,10 @@ void Matrix3Test::constructZero() {
{0.0f, 0.0f, 0.0f},
{0.0f, 0.0f, 0.0f}));
CORRADE_VERIFY((std::is_nothrow_constructible<Matrix3, ZeroInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Matrix3, ZeroInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<ZeroInitT, Matrix3>::value));
CORRADE_VERIFY(!std::is_convertible<ZeroInitT, Matrix3>::value);
}
void Matrix3Test::constructNoInit() {
@ -217,10 +217,10 @@ void Matrix3Test::constructNoInit() {
{7.9f, -1.0f, 8.0f}));
}
CORRADE_VERIFY((std::is_nothrow_constructible<Matrix3, Magnum::NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Matrix3, Magnum::NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Matrix3>::value));
CORRADE_VERIFY(!std::is_convertible<Magnum::NoInitT, Matrix3>::value);
}
void Matrix3Test::constructOneValue() {
@ -230,9 +230,9 @@ void Matrix3Test::constructOneValue() {
Vector3{1.5f, 1.5f, 1.5f}}));
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Float, Matrix3>::value));
CORRADE_VERIFY(!std::is_convertible<Float, Matrix3>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Matrix3, Float>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Matrix3, Float>::value);
}
void Matrix3Test::constructConversion() {
@ -245,9 +245,9 @@ void Matrix3Test::constructConversion() {
{7, -1, 8}));
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Matrix3, Matrix3i>::value));
CORRADE_VERIFY(!std::is_convertible<Matrix3, Matrix3i>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Matrix3, Matrix3i>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Matrix3, Matrix3i>::value);
}
void Matrix3Test::constructFromDifferentSize() {
@ -304,8 +304,8 @@ void Matrix3Test::convert() {
CORRADE_COMPARE(d.a[0], a.a[0]);
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Mat3, Matrix3>::value));
CORRADE_VERIFY(!(std::is_convertible<Matrix3, Mat3>::value));
CORRADE_VERIFY(!std::is_convertible<Mat3, Matrix3>::value);
CORRADE_VERIFY(!std::is_convertible<Matrix3, Mat3>::value);
}
void Matrix3Test::isRigidTransformation() {

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

@ -201,7 +201,7 @@ void Matrix4Test::construct() {
{1.0f, 2.0f, 3.0f, -1.0f},
{7.9f, -1.0f, 8.0f, -1.5f}));
CORRADE_VERIFY((std::is_nothrow_constructible<Matrix4, Vector4, Vector4, Vector4, Vector4>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Matrix4, Vector4, Vector4, Vector4, Vector4>::value);
}
void Matrix4Test::constructIdentity() {
@ -224,10 +224,10 @@ void Matrix4Test::constructIdentity() {
CORRADE_COMPARE(identity3, identity3Expected);
CORRADE_VERIFY(std::is_nothrow_default_constructible<Matrix4>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Matrix4, IdentityInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Matrix4, IdentityInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<IdentityInitT, Matrix4>::value));
CORRADE_VERIFY(!std::is_convertible<IdentityInitT, Matrix4>::value);
}
void Matrix4Test::constructZero() {
@ -237,10 +237,10 @@ void Matrix4Test::constructZero() {
{0.0f, 0.0f, 0.0f, 0.0f},
{0.0f, 0.0f, 0.0f, 0.0f}));
CORRADE_VERIFY((std::is_nothrow_constructible<Matrix4, ZeroInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Matrix4, ZeroInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<ZeroInitT, Matrix4>::value));
CORRADE_VERIFY(!std::is_convertible<ZeroInitT, Matrix4>::value);
}
void Matrix4Test::constructNoInit() {
@ -259,10 +259,10 @@ void Matrix4Test::constructNoInit() {
{7.9f, -1.0f, 8.0f, -1.5f}));
}
CORRADE_VERIFY((std::is_nothrow_constructible<Matrix4, Magnum::NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Matrix4, Magnum::NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Matrix4>::value));
CORRADE_VERIFY(!std::is_convertible<Magnum::NoInitT, Matrix4>::value);
}
void Matrix4Test::constructOneValue() {
@ -273,9 +273,9 @@ void Matrix4Test::constructOneValue() {
{1.5f, 1.5f, 1.5f, 1.5f}}));
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Float, Matrix4>::value));
CORRADE_VERIFY(!std::is_convertible<Float, Matrix4>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Matrix4, Float>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Matrix4, Float>::value);
}
void Matrix4Test::constructConversion() {
@ -290,9 +290,9 @@ void Matrix4Test::constructConversion() {
{7, -1, 8, -1}));
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Matrix4, Matrix4i>::value));
CORRADE_VERIFY(!std::is_convertible<Matrix4, Matrix4i>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Matrix4, Matrix4i>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Matrix4, Matrix4i>::value);
}
void Matrix4Test::constructFromDifferentSize() {
@ -355,8 +355,8 @@ void Matrix4Test::convert() {
CORRADE_COMPARE(d.a[i], a.a[i]);
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Mat4, Matrix4>::value));
CORRADE_VERIFY(!(std::is_convertible<Matrix4, Mat4>::value));
CORRADE_VERIFY(!std::is_convertible<Mat4, Matrix4>::value);
CORRADE_VERIFY(!std::is_convertible<Matrix4, Mat4>::value);
}
void Matrix4Test::isRigidTransformation() {

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

@ -139,7 +139,7 @@ void MatrixTest::construct() {
Vector4(1.0f, 2.0f, 3.0f, -1.0f),
Vector4(7.9f, -1.0f, 8.0f, -1.5f)));
CORRADE_VERIFY((std::is_nothrow_constructible<Matrix4x4, Vector4, Vector4, Vector4, Vector4>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Matrix4x4, Vector4, Vector4, Vector4, Vector4>::value);
}
void MatrixTest::constructIdentity() {
@ -162,10 +162,10 @@ void MatrixTest::constructIdentity() {
CORRADE_COMPARE(identity3, identity3Expected);
CORRADE_VERIFY(std::is_nothrow_default_constructible<Matrix4x4>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Matrix4x4, IdentityInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Matrix4x4, IdentityInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<IdentityInitT, Matrix4x4>::value));
CORRADE_VERIFY(!std::is_convertible<IdentityInitT, Matrix4x4>::value);
}
void MatrixTest::constructZero() {
@ -175,10 +175,10 @@ void MatrixTest::constructZero() {
Vector4(0.0f, 0.0f, 0.0f, 0.0f),
Vector4(0.0f, 0.0f, 0.0f, 0.0f)));
CORRADE_VERIFY((std::is_nothrow_constructible<Matrix4x4, ZeroInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Matrix4x4, ZeroInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<ZeroInitT, Matrix4x4>::value));
CORRADE_VERIFY(!std::is_convertible<ZeroInitT, Matrix4x4>::value);
}
void MatrixTest::constructNoInit() {
@ -197,10 +197,10 @@ void MatrixTest::constructNoInit() {
Vector4(7.9f, -1.0f, 8.0f, -1.5f)));
}
CORRADE_VERIFY((std::is_nothrow_constructible<Matrix4x4, Magnum::NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Matrix4x4, Magnum::NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Matrix4x4>::value));
CORRADE_VERIFY(!std::is_convertible<Magnum::NoInitT, Matrix4x4>::value);
}
void MatrixTest::constructOneValue() {
@ -210,9 +210,9 @@ void MatrixTest::constructOneValue() {
Vector3{1.5f, 1.5f, 1.5f}}));
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Float, Matrix3x3>::value));
CORRADE_VERIFY(!std::is_convertible<Float, Matrix3x3>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Matrix3x3, Float>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Matrix3x3, Float>::value);
}
void MatrixTest::constructOneComponent() {
@ -227,7 +227,7 @@ void MatrixTest::constructOneComponent() {
constexpr Matrix1x1 c = Vector1{1.5f};
CORRADE_COMPARE(c, Matrix1x1{Vector1{1.5f}});
CORRADE_VERIFY((std::is_nothrow_constructible<Matrix1x1, Vector1>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Matrix1x1, Vector1>::value);
}
void MatrixTest::constructConversion() {
@ -242,9 +242,9 @@ void MatrixTest::constructConversion() {
Vector4i(7, -1, 8, -1)));
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Matrix4x4, Matrix4x4i>::value));
CORRADE_VERIFY(!std::is_convertible<Matrix4x4, Matrix4x4i>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Matrix4x4, Matrix4x4i>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Matrix4x4, Matrix4x4i>::value);
}
void MatrixTest::constructFromDifferentSize() {
@ -302,8 +302,8 @@ void MatrixTest::convert() {
CORRADE_COMPARE(d.a[i], a.a[i]);
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Mat3, Matrix3x3>::value));
CORRADE_VERIFY(!(std::is_convertible<Matrix3x3, Mat3>::value));
CORRADE_VERIFY(!std::is_convertible<Mat3, Matrix3x3>::value);
CORRADE_VERIFY(!std::is_convertible<Matrix3x3, Mat3>::value);
}
void MatrixTest::isOrthogonal() {
@ -445,19 +445,19 @@ typedef BasicMat2<Float> Mat2;
void MatrixTest::subclassTypes() {
const Mat2 c;
Mat2 a;
CORRADE_VERIFY((std::is_same<decltype(c[1]), const Vec2>::value));
CORRADE_VERIFY((std::is_same<decltype(a[1]), Vec2&>::value));
CORRADE_VERIFY((std::is_same<decltype(c.row(1)), Vec2>::value));
CORRADE_VERIFY(std::is_same<decltype(c[1]), const Vec2>::value);
CORRADE_VERIFY(std::is_same<decltype(a[1]), Vec2&>::value);
CORRADE_VERIFY(std::is_same<decltype(c.row(1)), Vec2>::value);
const Mat2 c2;
const Vec2 cv;
CORRADE_VERIFY((std::is_same<decltype(c*c2), Mat2>::value));
CORRADE_VERIFY((std::is_same<decltype(c*cv), Vec2>::value));
CORRADE_VERIFY(std::is_same<decltype(c*c2), Mat2>::value);
CORRADE_VERIFY(std::is_same<decltype(c*cv), Vec2>::value);
CORRADE_VERIFY((std::is_same<decltype(c.transposed()), Mat2>::value));
CORRADE_VERIFY((std::is_same<decltype(c.diagonal()), Vec2>::value));
CORRADE_VERIFY((std::is_same<decltype(c.inverted()), Mat2>::value));
CORRADE_VERIFY((std::is_same<decltype(c.invertedOrthogonal()), Mat2>::value));
CORRADE_VERIFY(std::is_same<decltype(c.transposed()), Mat2>::value);
CORRADE_VERIFY(std::is_same<decltype(c.diagonal()), Vec2>::value);
CORRADE_VERIFY(std::is_same<decltype(c.inverted()), Mat2>::value);
CORRADE_VERIFY(std::is_same<decltype(c.invertedOrthogonal()), Mat2>::value);
}
void MatrixTest::subclass() {

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

@ -217,7 +217,7 @@ void QuaternionTest::construct() {
CORRADE_COMPARE(a.vector(), Vector3(1.0f, 2.0f, 3.0f));
CORRADE_COMPARE(a.scalar(), -4.0f);
CORRADE_VERIFY((std::is_nothrow_constructible<Quaternion, Vector3, Float>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Quaternion, Vector3, Float>::value);
}
void QuaternionTest::constructIdentity() {
@ -229,20 +229,20 @@ void QuaternionTest::constructIdentity() {
CORRADE_COMPARE(b.length(), 1.0f);
CORRADE_VERIFY(std::is_nothrow_default_constructible<Quaternion>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Quaternion, IdentityInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Quaternion, IdentityInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<IdentityInitT, Quaternion>::value));
CORRADE_VERIFY(!std::is_convertible<IdentityInitT, Quaternion>::value);
}
void QuaternionTest::constructZero() {
constexpr Quaternion a{ZeroInit};
CORRADE_COMPARE(a, Quaternion({0.0f, 0.0f, 0.0f}, 0.0f));
CORRADE_VERIFY((std::is_nothrow_constructible<Quaternion, ZeroInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Quaternion, ZeroInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<ZeroInitT, Quaternion>::value));
CORRADE_VERIFY(!std::is_convertible<ZeroInitT, Quaternion>::value);
}
void QuaternionTest::constructNoInit() {
@ -255,10 +255,10 @@ void QuaternionTest::constructNoInit() {
CORRADE_COMPARE(a, Quaternion({1.0f, 2.0f, 3.0f}, -4.0f));
}
CORRADE_VERIFY((std::is_nothrow_constructible<Quaternion, Magnum::NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Quaternion, Magnum::NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Quaternion>::value));
CORRADE_VERIFY(!std::is_convertible<Magnum::NoInitT, Quaternion>::value);
}
void QuaternionTest::constructFromVector() {
@ -266,9 +266,9 @@ void QuaternionTest::constructFromVector() {
CORRADE_COMPARE(a, Quaternion({1.0f, 2.0f, 3.0f}, 0.0f));
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Vector3, Quaternion>::value));
CORRADE_VERIFY(!std::is_convertible<Vector3, Quaternion>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Quaternion, Vector3>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Quaternion, Vector3>::value);
}
void QuaternionTest::constructConversion() {
@ -280,9 +280,9 @@ void QuaternionTest::constructConversion() {
CORRADE_COMPARE(b, (Quaternioni{{1, 2, -15}, 7}));
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Quaternion, Quaternioni>::value));
CORRADE_VERIFY(!std::is_convertible<Quaternion, Quaternioni>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Quaternion, Quaternioni>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Quaternion, Quaternioni>::value);
}
void QuaternionTest::constructCopy() {
@ -310,8 +310,8 @@ void QuaternionTest::convert() {
CORRADE_COMPARE(d.w, a.w);
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Quat, Quaternion>::value));
CORRADE_VERIFY(!(std::is_convertible<Quaternion, Quat>::value));
CORRADE_VERIFY(!std::is_convertible<Quat, Quaternion>::value);
CORRADE_VERIFY(!std::is_convertible<Quaternion, Quat>::value);
}
void QuaternionTest::data() {
@ -350,8 +350,8 @@ void QuaternionTest::isNormalized() {
template<class T> void QuaternionTest::isNormalizedEpsilon() {
setTestCaseTemplateName(TypeTraits<T>::name());
CORRADE_VERIFY((Math::Quaternion<T>{{T(0.0106550719778129), T(0.311128101752138), T(-0.0468823167023769)}, T(0.949151106053128) + TypeTraits<T>::epsilon()/T(2.0)}.isNormalized()));
CORRADE_VERIFY(!(Math::Quaternion<T>{{T(0.0106550719778129), T(0.311128101752138), T(-0.0468823167023769)}, T(0.949151106053128) + TypeTraits<T>::epsilon()*T(2.0)}.isNormalized()));
CORRADE_VERIFY(Math::Quaternion<T>{{T(0.0106550719778129), T(0.311128101752138), T(-0.0468823167023769)}, T(0.949151106053128) + TypeTraits<T>::epsilon()/T(2.0)}.isNormalized());
CORRADE_VERIFY(!Math::Quaternion<T>{{T(0.0106550719778129), T(0.311128101752138), T(-0.0468823167023769)}, T(0.949151106053128) + TypeTraits<T>::epsilon()*T(2.0)}.isNormalized());
}
void QuaternionTest::axisAngle() {

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

@ -205,9 +205,9 @@ void RangeTest::construct() {
CORRADE_COMPARE(b, (Range<2, Int>({3, 5}, {23, 78})));
CORRADE_COMPARE(c, (Range<3, Int>({3, 5, -7}, {23, 78, 2})));
CORRADE_VERIFY((std::is_nothrow_constructible<Range1Di, Int, Int>::value));
CORRADE_VERIFY((std::is_nothrow_constructible<Range2Di, Vector2i, Vector2i>::value));
CORRADE_VERIFY((std::is_nothrow_constructible<Range3Di, Vector3i, Vector3i>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Range1Di, Int, Int>::value);
CORRADE_VERIFY(std::is_nothrow_constructible<Range2Di, Vector2i, Vector2i>::value);
CORRADE_VERIFY(std::is_nothrow_constructible<Range3Di, Vector3i, Vector3i>::value);
}
void RangeTest::constructDefault() {
@ -228,14 +228,14 @@ void RangeTest::constructDefault() {
CORRADE_VERIFY(std::is_nothrow_default_constructible<Range1Di>::value);
CORRADE_VERIFY(std::is_nothrow_default_constructible<Range2Di>::value);
CORRADE_VERIFY(std::is_nothrow_default_constructible<Range3Di>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Range1Di, ZeroInitT>::value));
CORRADE_VERIFY((std::is_nothrow_constructible<Range2Di, ZeroInitT>::value));
CORRADE_VERIFY((std::is_nothrow_constructible<Range3Di, ZeroInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Range1Di, ZeroInitT>::value);
CORRADE_VERIFY(std::is_nothrow_constructible<Range2Di, ZeroInitT>::value);
CORRADE_VERIFY(std::is_nothrow_constructible<Range3Di, ZeroInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<ZeroInitT, Range1Di>::value));
CORRADE_VERIFY(!(std::is_convertible<ZeroInitT, Range2Di>::value));
CORRADE_VERIFY(!(std::is_convertible<ZeroInitT, Range3Di>::value));
CORRADE_VERIFY(!std::is_convertible<ZeroInitT, Range1Di>::value);
CORRADE_VERIFY(!std::is_convertible<ZeroInitT, Range2Di>::value);
CORRADE_VERIFY(!std::is_convertible<ZeroInitT, Range3Di>::value);
}
void RangeTest::constructNoInit() {
@ -256,14 +256,14 @@ void RangeTest::constructNoInit() {
CORRADE_COMPARE(c, (Range3Di{{3, 5, -7}, {23, 78, 2}}));
}
CORRADE_VERIFY((std::is_nothrow_constructible<Range1Di, Magnum::NoInitT>::value));
CORRADE_VERIFY((std::is_nothrow_constructible<Range2Di, Magnum::NoInitT>::value));
CORRADE_VERIFY((std::is_nothrow_constructible<Range3Di, Magnum::NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Range1Di, Magnum::NoInitT>::value);
CORRADE_VERIFY(std::is_nothrow_constructible<Range2Di, Magnum::NoInitT>::value);
CORRADE_VERIFY(std::is_nothrow_constructible<Range3Di, Magnum::NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Range1Di>::value));
CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Range2Di>::value));
CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Range3Di>::value));
CORRADE_VERIFY(!std::is_convertible<Magnum::NoInitT, Range1Di>::value);
CORRADE_VERIFY(!std::is_convertible<Magnum::NoInitT, Range2Di>::value);
CORRADE_VERIFY(!std::is_convertible<Magnum::NoInitT, Range3Di>::value);
}
void RangeTest::constructFromSize() {
@ -320,14 +320,14 @@ void RangeTest::constructConversion() {
CORRADE_COMPARE(f, Range3Di({1, 2, -1}, {-15, 7, 0}));
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Range<2, Float>, Range<2, Int>>::value));
CORRADE_VERIFY(!(std::is_convertible<Range1D, Range1Di>::value));
CORRADE_VERIFY(!(std::is_convertible<Range2D, Range2Di>::value));
CORRADE_VERIFY(!(std::is_convertible<Range3D, Range3Di>::value));
CORRADE_VERIFY(!std::is_convertible<Range<2, Float>, Range<2, Int>>::value);
CORRADE_VERIFY(!std::is_convertible<Range1D, Range1Di>::value);
CORRADE_VERIFY(!std::is_convertible<Range2D, Range2Di>::value);
CORRADE_VERIFY(!std::is_convertible<Range3D, Range3Di>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Range1D, Range1Di>::value));
CORRADE_VERIFY((std::is_nothrow_constructible<Range2D, Range2Di>::value));
CORRADE_VERIFY((std::is_nothrow_constructible<Range3D, Range3Di>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Range1D, Range1Di>::value);
CORRADE_VERIFY(std::is_nothrow_constructible<Range2D, Range2Di>::value);
CORRADE_VERIFY(std::is_nothrow_constructible<Range3D, Range3Di>::value);
}
void RangeTest::constructCopy() {
@ -390,14 +390,14 @@ void RangeTest::convert() {
CORRADE_COMPARE(m.d, c.d);
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Rect, Range<2, Float>>::value));
CORRADE_VERIFY(!(std::is_convertible<Dim, Range1D>::value));
CORRADE_VERIFY(!(std::is_convertible<Rect, Range2D>::value));
CORRADE_VERIFY(!(std::is_convertible<Box, Range3D>::value));
CORRADE_VERIFY(!std::is_convertible<Rect, Range<2, Float>>::value);
CORRADE_VERIFY(!std::is_convertible<Dim, Range1D>::value);
CORRADE_VERIFY(!std::is_convertible<Rect, Range2D>::value);
CORRADE_VERIFY(!std::is_convertible<Box, Range3D>::value);
CORRADE_VERIFY(!(std::is_convertible<Range1D, Dim>::value));
CORRADE_VERIFY(!(std::is_convertible<Range2D, Rect>::value));
CORRADE_VERIFY(!(std::is_convertible<Range3D, Box>::value));
CORRADE_VERIFY(!std::is_convertible<Range1D, Dim>::value);
CORRADE_VERIFY(!std::is_convertible<Range2D, Rect>::value);
CORRADE_VERIFY(!std::is_convertible<Range3D, Box>::value);
}
void RangeTest::access() {
@ -871,12 +871,12 @@ typedef BasicRect<Int> Recti;
void RangeTest::subclassTypes() {
const Vector2i a;
CORRADE_VERIFY((std::is_same<decltype(Recti::fromSize(a, a)), Recti>::value));
CORRADE_VERIFY(std::is_same<decltype(Recti::fromSize(a, a)), Recti>::value);
const Recti r;
CORRADE_VERIFY((std::is_same<decltype(r.translated(a)), Recti>::value));
CORRADE_VERIFY((std::is_same<decltype(r.padded(a)), Recti>::value));
CORRADE_VERIFY((std::is_same<decltype(r.scaled(a)), Recti>::value));
CORRADE_VERIFY(std::is_same<decltype(r.translated(a)), Recti>::value);
CORRADE_VERIFY(std::is_same<decltype(r.padded(a)), Recti>::value);
CORRADE_VERIFY(std::is_same<decltype(r.scaled(a)), Recti>::value);
}
void RangeTest::subclass() {

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

@ -157,7 +157,7 @@ void RectangularMatrixTest::construct() {
Vector4(5.0f, 6.0f, 7.0f, 8.0f),
Vector4(9.0f, 10.0f, 11.0f, 12.0f)));
CORRADE_VERIFY((std::is_nothrow_constructible<Matrix3x4, Vector4, Vector4, Vector4>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Matrix3x4, Vector4, Vector4, Vector4>::value);
}
void RectangularMatrixTest::constructDefault() {
@ -173,10 +173,10 @@ void RectangularMatrixTest::constructDefault() {
Vector3(0.0f, 0.0f, 0.0f)));
CORRADE_VERIFY(std::is_nothrow_default_constructible<Matrix4x3>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Matrix4x3, ZeroInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Matrix4x3, ZeroInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<ZeroInitT, Matrix4x3>::value));
CORRADE_VERIFY(!std::is_convertible<ZeroInitT, Matrix4x3>::value);
}
void RectangularMatrixTest::constructNoInit() {
@ -193,10 +193,10 @@ void RectangularMatrixTest::constructNoInit() {
Vector4(9.0f, 10.0f, 11.0f, 12.0f)));
}
CORRADE_VERIFY((std::is_nothrow_constructible<Matrix3x4, Magnum::NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Matrix3x4, Magnum::NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Matrix3x4>::value));
CORRADE_VERIFY(!std::is_convertible<Magnum::NoInitT, Matrix3x4>::value);
}
void RectangularMatrixTest::constructOneValue() {
@ -206,9 +206,9 @@ void RectangularMatrixTest::constructOneValue() {
Vector4{1.5f, 1.5f, 1.5f, 1.5f}}));
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Float, Matrix3x4>::value));
CORRADE_VERIFY(!std::is_convertible<Float, Matrix3x4>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Matrix3x4, Float>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Matrix3x4, Float>::value);
}
void RectangularMatrixTest::constructOneComponent() {
@ -223,7 +223,7 @@ void RectangularMatrixTest::constructOneComponent() {
constexpr Matrix1x1 c = Vector1{1.5f};
CORRADE_COMPARE(c, Matrix1x1{Vector1{1.5f}});
CORRADE_VERIFY((std::is_nothrow_constructible<Matrix1x1, Vector1>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Matrix1x1, Vector1>::value);
}
void RectangularMatrixTest::constructConversion() {
@ -235,9 +235,9 @@ void RectangularMatrixTest::constructConversion() {
Vector2i(-15, 7)));
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Matrix2x2, Matrix2x2i>::value));
CORRADE_VERIFY(!std::is_convertible<Matrix2x2, Matrix2x2i>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Matrix2x2, Matrix2x2i>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Matrix2x2, Matrix2x2i>::value);
}
void RectangularMatrixTest::constructFromData() {
@ -301,8 +301,8 @@ void RectangularMatrixTest::convert() {
CORRADE_COMPARE(d.a[i], a.a[i]);
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Mat2x3, Matrix2x3>::value));
CORRADE_VERIFY(!(std::is_convertible<Matrix2x3, Mat2x3>::value));
CORRADE_VERIFY(!std::is_convertible<Mat2x3, Matrix2x3>::value);
CORRADE_VERIFY(!std::is_convertible<Matrix2x3, Mat2x3>::value);
}
void RectangularMatrixTest::data() {
@ -571,37 +571,37 @@ typedef BasicMat2x2<Float> Mat2x2;
void RectangularMatrixTest::subclassTypes() {
Float* const data = nullptr;
const Float* const cdata = nullptr;
CORRADE_VERIFY((std::is_same<decltype(Mat2x2::from(data)), Mat2x2&>::value));
CORRADE_VERIFY((std::is_same<decltype(Mat2x2::from(cdata)), const Mat2x2&>::value));
CORRADE_VERIFY((std::is_same<decltype(Mat2x2::fromDiagonal({})), Mat2x2>::value));
CORRADE_VERIFY(std::is_same<decltype(Mat2x2::from(data)), Mat2x2&>::value);
CORRADE_VERIFY(std::is_same<decltype(Mat2x2::from(cdata)), const Mat2x2&>::value);
CORRADE_VERIFY(std::is_same<decltype(Mat2x2::fromDiagonal({})), Mat2x2>::value);
/* Const operators */
const Mat2x2 c;
CORRADE_VERIFY((std::is_same<decltype(-c), Mat2x2>::value));
CORRADE_VERIFY((std::is_same<decltype(c + c), Mat2x2>::value));
CORRADE_VERIFY((std::is_same<decltype(c*1.0f), Mat2x2>::value));
CORRADE_VERIFY((std::is_same<decltype(1.0f*c), Mat2x2>::value));
CORRADE_VERIFY((std::is_same<decltype(c/1.0f), Mat2x2>::value));
CORRADE_VERIFY((std::is_same<decltype(1.0f/c), Mat2x2>::value));
CORRADE_VERIFY((std::is_same<decltype(Vector2()*Math::RectangularMatrix<2, 1, Float>()), Mat2x2>::value));
CORRADE_VERIFY(std::is_same<decltype(-c), Mat2x2>::value);
CORRADE_VERIFY(std::is_same<decltype(c + c), Mat2x2>::value);
CORRADE_VERIFY(std::is_same<decltype(c*1.0f), Mat2x2>::value);
CORRADE_VERIFY(std::is_same<decltype(1.0f*c), Mat2x2>::value);
CORRADE_VERIFY(std::is_same<decltype(c/1.0f), Mat2x2>::value);
CORRADE_VERIFY(std::is_same<decltype(1.0f/c), Mat2x2>::value);
CORRADE_VERIFY(std::is_same<decltype(Vector2()*Math::RectangularMatrix<2, 1, Float>()), Mat2x2>::value);
/* Assignment operators */
Mat2x2 a;
CORRADE_VERIFY((std::is_same<decltype(a = c), Mat2x2&>::value));
CORRADE_VERIFY((std::is_same<decltype(a += c), Mat2x2&>::value));
CORRADE_VERIFY((std::is_same<decltype(a -= c), Mat2x2&>::value));
CORRADE_VERIFY((std::is_same<decltype(a *= 1.0f), Mat2x2&>::value));
CORRADE_VERIFY((std::is_same<decltype(a /= 1.0f), Mat2x2&>::value));
CORRADE_VERIFY(std::is_same<decltype(a = c), Mat2x2&>::value);
CORRADE_VERIFY(std::is_same<decltype(a += c), Mat2x2&>::value);
CORRADE_VERIFY(std::is_same<decltype(a -= c), Mat2x2&>::value);
CORRADE_VERIFY(std::is_same<decltype(a *= 1.0f), Mat2x2&>::value);
CORRADE_VERIFY(std::is_same<decltype(a /= 1.0f), Mat2x2&>::value);
/* Operators on variable-sized matrix */
const BasicMat<3, Float> c2;
CORRADE_VERIFY((std::is_same<decltype(1.0f*c2), BasicMat<3, Float>>::value));
CORRADE_VERIFY((std::is_same<decltype(1.0f/c2), BasicMat<3, Float>>::value));
CORRADE_VERIFY((std::is_same<decltype(Vector3()*Math::RectangularMatrix<3, 1, Float>()), BasicMat<3, Float>>::value));
CORRADE_VERIFY(std::is_same<decltype(1.0f*c2), BasicMat<3, Float>>::value);
CORRADE_VERIFY(std::is_same<decltype(1.0f/c2), BasicMat<3, Float>>::value);
CORRADE_VERIFY(std::is_same<decltype(Vector3()*Math::RectangularMatrix<3, 1, Float>()), BasicMat<3, Float>>::value);
/* Functions */
CORRADE_VERIFY((std::is_same<decltype(a.flippedCols()), Mat2x2>::value));
CORRADE_VERIFY((std::is_same<decltype(a.flippedRows()), Mat2x2>::value));
CORRADE_VERIFY(std::is_same<decltype(a.flippedCols()), Mat2x2>::value);
CORRADE_VERIFY(std::is_same<decltype(a.flippedRows()), Mat2x2>::value);
}
void RectangularMatrixTest::subclass() {

28
src/Magnum/Math/Test/TypeTraitsTest.cpp
Unescape View File

@ -170,7 +170,7 @@ void TypeTraitsTest::isScalar() {
CORRADE_VERIFY(IsScalar<UnsignedShort>::value);
CORRADE_VERIFY(IsScalar<Deg<Float>>::value);
CORRADE_VERIFY(IsScalar<Half>::value);
CORRADE_VERIFY((IsScalar<Unit<Rad, Double>>::value));
CORRADE_VERIFY(IsScalar<Unit<Rad, Double>>::value);
CORRADE_VERIFY(!IsScalar<Vector2<Float>>::value);
CORRADE_VERIFY(!IsVector<Matrix2x3<Float>>::value);
CORRADE_VERIFY(!IsScalar<Color3<Half>>::value);
@ -181,7 +181,7 @@ void TypeTraitsTest::isScalar() {
void TypeTraitsTest::isVector() {
CORRADE_VERIFY(!IsVector<UnsignedByte>::value);
CORRADE_VERIFY(!IsVector<Deg<UnsignedByte>>::value);
CORRADE_VERIFY((IsVector<Vector<2, Deg<Float>>>::value));
CORRADE_VERIFY(IsVector<Vector<2, Deg<Float>>>::value);
CORRADE_VERIFY(IsVector<Color3<UnsignedByte>>::value);
CORRADE_VERIFY(IsVector<Color3<Half>>::value);
CORRADE_VERIFY(!IsVector<Matrix2x3<Float>>::value);
@ -195,7 +195,7 @@ void TypeTraitsTest::isIntegral() {
CORRADE_VERIFY(IsIntegral<UnsignedByte>::value);
CORRADE_VERIFY(IsIntegral<Int>::value);
CORRADE_VERIFY((IsIntegral<Vector<7, UnsignedInt>>::value));
CORRADE_VERIFY(IsIntegral<Vector<7, UnsignedInt>>::value);
CORRADE_VERIFY(IsIntegral<Vector2<Long>>::value);
CORRADE_VERIFY(!IsIntegral<Half>::value);
CORRADE_VERIFY(!IsIntegral<Deg<Float>>::value);
@ -205,13 +205,13 @@ void TypeTraitsTest::isIntegral() {
void TypeTraitsTest::isFloatingPoint() {
CORRADE_VERIFY(!IsFloatingPoint<Int>::value);
CORRADE_VERIFY(!(IsFloatingPoint<Vector<7, UnsignedInt>>::value));
CORRADE_VERIFY(!IsFloatingPoint<Vector<7, UnsignedInt>>::value);
CORRADE_VERIFY(IsFloatingPoint<Double>::value);
CORRADE_VERIFY((IsFloatingPoint<Vector<2, Float>>::value));
CORRADE_VERIFY(IsFloatingPoint<Vector<2, Float>>::value);
CORRADE_VERIFY(IsFloatingPoint<Vector2<long double>>::value);
CORRADE_VERIFY(IsFloatingPoint<Deg<Float>>::value);
CORRADE_VERIFY(IsFloatingPoint<Color4<Half>>::value);
CORRADE_VERIFY((IsFloatingPoint<Unit<Rad, Float>>::value));
CORRADE_VERIFY(IsFloatingPoint<Unit<Rad, Float>>::value);
CORRADE_VERIFY(IsFloatingPoint<Deg<Half>>::value);
CORRADE_VERIFY(!IsFloatingPoint<char*>::value);
}
@ -221,21 +221,21 @@ void TypeTraitsTest::isUnitless() {
CORRADE_VERIFY(IsUnitless<Half>::value);
CORRADE_VERIFY(IsUnitless<Color4<Float>>::value);
CORRADE_VERIFY(!IsUnitless<Deg<Float>>::value);
CORRADE_VERIFY(!(IsUnitless<Unit<Rad, Double>>::value));
CORRADE_VERIFY(!IsUnitless<Unit<Rad, Double>>::value);
CORRADE_VERIFY(!IsUnitless<char*>::value);
}
void TypeTraitsTest::underlyingTypeOf() {
CORRADE_VERIFY((std::is_same<UnderlyingTypeOf<Int>, Int>::value));
CORRADE_VERIFY(std::is_same<UnderlyingTypeOf<Int>, Int>::value);
CORRADE_VERIFY((std::is_same<UnderlyingTypeOf<Deg<Float>>, Float>::value));
CORRADE_VERIFY((std::is_same<UnderlyingTypeOf<Unit<Rad, Double>>, Double>::value));
CORRADE_VERIFY(std::is_same<UnderlyingTypeOf<Deg<Float>>, Float>::value);
CORRADE_VERIFY(std::is_same<UnderlyingTypeOf<Unit<Rad, Double>>, Double>::value);
CORRADE_VERIFY((std::is_same<UnderlyingTypeOf<Vector2<UnsignedByte>>, UnsignedByte>::value));
CORRADE_VERIFY((std::is_same<UnderlyingTypeOf<Color3<Float>>, Float>::value));
CORRADE_VERIFY(std::is_same<UnderlyingTypeOf<Vector2<UnsignedByte>>, UnsignedByte>::value);
CORRADE_VERIFY(std::is_same<UnderlyingTypeOf<Color3<Float>>, Float>::value);
CORRADE_VERIFY((std::is_same<UnderlyingTypeOf<Matrix2x3<Double>>, Double>::value));
CORRADE_VERIFY((std::is_same<UnderlyingTypeOf<Matrix4<Float>>, Float>::value));
CORRADE_VERIFY(std::is_same<UnderlyingTypeOf<Matrix2x3<Double>>, Double>::value);
CORRADE_VERIFY(std::is_same<UnderlyingTypeOf<Matrix4<Float>>, Float>::value);
}
template<class T> void TypeTraitsTest::epsilonConsistentWithCorrade() {

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

@ -73,10 +73,10 @@ void UnitTest::construct() {
CORRADE_COMPARE(Float(a), 25.0f);
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Float, Sec>::value));
CORRADE_VERIFY(!(std::is_convertible<Sec, Float>::value));
CORRADE_VERIFY(!std::is_convertible<Float, Sec>::value);
CORRADE_VERIFY(!std::is_convertible<Sec, Float>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Sec, Float>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Sec, Float>::value);
}
void UnitTest::constructDefault() {
@ -86,10 +86,10 @@ void UnitTest::constructDefault() {
CORRADE_COMPARE(b, Sec(0.0f));
CORRADE_VERIFY(std::is_nothrow_default_constructible<Sec>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Sec, ZeroInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Sec, ZeroInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<ZeroInitT, Sec>::value));
CORRADE_VERIFY(!std::is_convertible<ZeroInitT, Sec>::value);
}
void UnitTest::constructNoInit() {
@ -102,10 +102,10 @@ void UnitTest::constructNoInit() {
CORRADE_COMPARE(a, Sec{25.0f});
}
CORRADE_VERIFY((std::is_nothrow_constructible<Sec, Magnum::NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Sec, Magnum::NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Sec>::value));
CORRADE_VERIFY(!std::is_convertible<Magnum::NoInitT, Sec>::value);
}
void UnitTest::constructConversion() {
@ -114,9 +114,9 @@ void UnitTest::constructConversion() {
CORRADE_COMPARE(b, Sec(25.0f));
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Sec, Seci>::value));
CORRADE_VERIFY(!std::is_convertible<Sec, Seci>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Sec, Seci>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Sec, Seci>::value);
}
void UnitTest::compare() {

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

@ -107,7 +107,7 @@ void Vector2Test::construct() {
constexpr Vector2 a = {1.5f, 2.5f};
CORRADE_COMPARE(a, (Vector<2, Float>(1.5f, 2.5f)));
CORRADE_VERIFY((std::is_nothrow_constructible<Vector2, Float, Float>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Vector2, Float, Float>::value);
}
void Vector2Test::constructDefault() {
@ -117,10 +117,10 @@ void Vector2Test::constructDefault() {
CORRADE_COMPARE(b, Vector2(0.0f, 0.0f));
CORRADE_VERIFY(std::is_nothrow_default_constructible<Vector2>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Vector2, ZeroInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Vector2, ZeroInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<ZeroInitT, Vector2>::value));
CORRADE_VERIFY(!std::is_convertible<ZeroInitT, Vector2>::value);
}
void Vector2Test::constructNoInit() {
@ -133,10 +133,10 @@ void Vector2Test::constructNoInit() {
CORRADE_COMPARE(a, (Vector2{1.5f, 2.5f}));
}
CORRADE_VERIFY((std::is_nothrow_constructible<Vector2, Magnum::NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Vector2, Magnum::NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Vector2>::value));
CORRADE_VERIFY(!std::is_convertible<Magnum::NoInitT, Vector2>::value);
}
void Vector2Test::constructOneValue() {
@ -144,9 +144,9 @@ void Vector2Test::constructOneValue() {
CORRADE_COMPARE(a, Vector2(3.0f, 3.0f));
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Float, Vector2>::value));
CORRADE_VERIFY(!std::is_convertible<Float, Vector2>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Vector2, Float>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Vector2, Float>::value);
}
void Vector2Test::constructConversion() {
@ -155,9 +155,9 @@ void Vector2Test::constructConversion() {
CORRADE_COMPARE(b, Vector2i(1, 2));
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Vector2, Vector2i>::value));
CORRADE_VERIFY(!std::is_convertible<Vector2, Vector2i>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Vector2, Vector2i>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Vector2, Vector2i>::value);
}
void Vector2Test::constructCopy() {
@ -184,8 +184,8 @@ void Vector2Test::convert() {
CORRADE_COMPARE(d.y, a.y);
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Vec2, Vector2>::value));
CORRADE_VERIFY(!(std::is_convertible<Vector2, Vec2>::value));
CORRADE_VERIFY(!std::is_convertible<Vec2, Vector2>::value);
CORRADE_VERIFY(!std::is_convertible<Vector2, Vec2>::value);
}
void Vector2Test::access() {
@ -252,7 +252,7 @@ void Vector2Test::strictWeakOrdering() {
void Vector2Test::swizzleType() {
constexpr Vector<4, Int> orig;
constexpr auto a = gather<'y', 'a'>(orig);
CORRADE_VERIFY((std::is_same<decltype(a), const Vector2i>::value));
CORRADE_VERIFY(std::is_same<decltype(a), const Vector2i>::value);
}
void Vector2Test::debug() {

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

@ -107,7 +107,7 @@ void Vector3Test::construct() {
constexpr Vector3 a = {1.0f, 2.5f, -3.0f};
CORRADE_COMPARE(a, (Vector<3, Float>(1.0f, 2.5f, -3.0f)));
CORRADE_VERIFY((std::is_nothrow_constructible<Vector3, Float, Float, Float>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Vector3, Float, Float, Float>::value);
}
void Vector3Test::constructDefault() {
@ -117,10 +117,10 @@ void Vector3Test::constructDefault() {
CORRADE_COMPARE(b, Vector3(0.0f, 0.0f, 0.0f));
CORRADE_VERIFY(std::is_nothrow_default_constructible<Vector3>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Vector3, ZeroInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Vector3, ZeroInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<ZeroInitT, Vector3>::value));
CORRADE_VERIFY(!std::is_convertible<ZeroInitT, Vector3>::value);
}
void Vector3Test::constructNoInit() {
@ -133,10 +133,10 @@ void Vector3Test::constructNoInit() {
CORRADE_COMPARE(a, (Vector3{1.0f, 2.5f, -3.0f}));
}
CORRADE_VERIFY((std::is_nothrow_constructible<Vector3, Magnum::NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Vector3, Magnum::NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Vector3>::value));
CORRADE_VERIFY(!std::is_convertible<Magnum::NoInitT, Vector3>::value);
}
void Vector3Test::constructOneValue() {
@ -144,9 +144,9 @@ void Vector3Test::constructOneValue() {
CORRADE_COMPARE(a, Vector3(-3.0f, -3.0f, -3.0f));
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Float, Vector3>::value));
CORRADE_VERIFY(!std::is_convertible<Float, Vector3>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Vector3, Float>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Vector3, Float>::value);
}
void Vector3Test::constructParts() {
@ -154,7 +154,7 @@ void Vector3Test::constructParts() {
constexpr Vector3 b = {a, 3.0f};
CORRADE_COMPARE(b, Vector3(1.0f, 2.0f, 3.0f));
CORRADE_VERIFY((std::is_nothrow_constructible<Vector3, Vector2, Float>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Vector3, Vector2, Float>::value);
}
void Vector3Test::constructConversion() {
@ -163,9 +163,9 @@ void Vector3Test::constructConversion() {
CORRADE_COMPARE(b, Vector3i(1, 2, -3));
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Vector3, Vector3i>::value));
CORRADE_VERIFY(!std::is_convertible<Vector3, Vector3i>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Vector3, Vector3i>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Vector3, Vector3i>::value);
}
void Vector3Test::constructCopy() {
@ -193,8 +193,8 @@ void Vector3Test::convert() {
CORRADE_COMPARE(d.z, a.z);
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Vec3, Vector3>::value));
CORRADE_VERIFY(!(std::is_convertible<Vector3, Vec3>::value));
CORRADE_VERIFY(!std::is_convertible<Vec3, Vector3>::value);
CORRADE_VERIFY(!std::is_convertible<Vector3, Vec3>::value);
}
void Vector3Test::access() {
@ -276,7 +276,7 @@ void Vector3Test::strictWeakOrdering() {
void Vector3Test::swizzleType() {
constexpr Vector<4, Int> orig;
constexpr auto b = gather<'y', 'z', 'a'>(orig);
CORRADE_VERIFY((std::is_same<decltype(b), const Vector3i>::value));
CORRADE_VERIFY(std::is_same<decltype(b), const Vector3i>::value);
}
void Vector3Test::debug() {

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

@ -112,7 +112,7 @@ void Vector4Test::construct() {
constexpr Vector4 a = {1.0f, -2.5f, 3.0f, 4.1f};
CORRADE_COMPARE(a, (Vector<4, Float>(1.0f, -2.5f, 3.0f, 4.1f)));
CORRADE_VERIFY((std::is_nothrow_constructible<Vector4, Float, Float, Float, Float>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Vector4, Float, Float, Float, Float>::value);
}
void Vector4Test::constructPad() {
@ -138,10 +138,10 @@ void Vector4Test::constructDefault() {
CORRADE_COMPARE(b, Vector4(0.0f, 0.0f, 0.0f, 0.0f));
CORRADE_VERIFY(std::is_nothrow_default_constructible<Vector4>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Vector4, ZeroInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Vector4, ZeroInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<ZeroInitT, Vector4>::value));
CORRADE_VERIFY(!std::is_convertible<ZeroInitT, Vector4>::value);
}
void Vector4Test::constructNoInit() {
@ -154,10 +154,10 @@ void Vector4Test::constructNoInit() {
CORRADE_COMPARE(a, (Vector4{1.0f, -2.5f, 3.0f, 4.1f}));
}
CORRADE_VERIFY((std::is_nothrow_constructible<Vector4, Magnum::NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Vector4, Magnum::NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Vector4>::value));
CORRADE_VERIFY(!std::is_convertible<Magnum::NoInitT, Vector4>::value);
}
void Vector4Test::constructOneValue() {
@ -165,9 +165,9 @@ void Vector4Test::constructOneValue() {
CORRADE_COMPARE(a, Vector4(4.3f, 4.3f, 4.3f, 4.3f));
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Float, Vector4>::value));
CORRADE_VERIFY(!std::is_convertible<Float, Vector4>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Vector4, Float>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Vector4, Float>::value);
}
void Vector4Test::constructParts() {
@ -175,7 +175,7 @@ void Vector4Test::constructParts() {
constexpr Vector4 b = {a, 4.0f};
CORRADE_COMPARE(b, Vector4(1.0f, 2.0f, 3.0f, 4.0f));
CORRADE_VERIFY((std::is_nothrow_constructible<Vector4, Vector3, Float>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Vector4, Vector3, Float>::value);
}
void Vector4Test::constructConversion() {
@ -184,9 +184,9 @@ void Vector4Test::constructConversion() {
CORRADE_COMPARE(b, Vector4i(1, -2, 3, 4));
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Vector4, Vector4i>::value));
CORRADE_VERIFY(!std::is_convertible<Vector4, Vector4i>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Vector4, Vector4i>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Vector4, Vector4i>::value);
}
void Vector4Test::constructCopy() {
@ -215,8 +215,8 @@ void Vector4Test::convert() {
CORRADE_COMPARE(d.w, a.w);
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Vec4, Vector4>::value));
CORRADE_VERIFY(!(std::is_convertible<Vector4, Vec4>::value));
CORRADE_VERIFY(!std::is_convertible<Vec4, Vector4>::value);
CORRADE_VERIFY(!std::is_convertible<Vector4, Vec4>::value);
}
void Vector4Test::access() {
@ -319,7 +319,7 @@ void Vector4Test::strictWeakOrdering() {
void Vector4Test::swizzleType() {
constexpr Vector4i orig;
constexpr auto c = gather<'y', 'a', 'y', 'x'>(orig);
CORRADE_VERIFY((std::is_same<decltype(c), const Vector4i>::value));
CORRADE_VERIFY(std::is_same<decltype(c), const Vector4i>::value);
}
void Vector4Test::debug() {

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

@ -197,7 +197,7 @@ void VectorTest::construct() {
constexpr Vector4 a = {1.0f, 2.0f, -3.0f, 4.5f};
CORRADE_COMPARE(a, Vector4(1.0f, 2.0f, -3.0f, 4.5f));
CORRADE_VERIFY((std::is_nothrow_constructible<Vector4, Float, Float, Float, Float>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Vector4, Float, Float, Float, Float>::value);
}
void VectorTest::constructFromData() {
@ -231,10 +231,10 @@ void VectorTest::constructDefault() {
CORRADE_COMPARE(b, Vector4(0.0f, 0.0f, 0.0f, 0.0f));
CORRADE_VERIFY(std::is_nothrow_default_constructible<Vector4>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Vector4, ZeroInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Vector4, ZeroInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<ZeroInitT, Vector4>::value));
CORRADE_VERIFY(!std::is_convertible<ZeroInitT, Vector4>::value);
}
void VectorTest::constructNoInit() {
@ -247,10 +247,10 @@ void VectorTest::constructNoInit() {
CORRADE_COMPARE(a, (Vector4{1.0f, 2.0f, -3.0f, 4.5f}));
}
CORRADE_VERIFY((std::is_nothrow_constructible<Vector4, Magnum::NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Vector4, Magnum::NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Vector4>::value));
CORRADE_VERIFY(!std::is_convertible<Magnum::NoInitT, Vector4>::value);
}
void VectorTest::constructOneValue() {
@ -259,9 +259,9 @@ void VectorTest::constructOneValue() {
CORRADE_COMPARE(a, Vector4(7.25f, 7.25f, 7.25f, 7.25f));
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Float, Vector4>::value));
CORRADE_VERIFY(!std::is_convertible<Float, Vector4>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Vector4, Float>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Vector4, Float>::value);
}
void VectorTest::constructOneComponent() {
@ -271,7 +271,7 @@ void VectorTest::constructOneComponent() {
constexpr Vector1 vec = 1.0f;
CORRADE_COMPARE(vec, Vector1(1));
CORRADE_VERIFY((std::is_nothrow_constructible<Vector1, Float>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Vector1, Float>::value);
}
void VectorTest::constructConversion() {
@ -281,9 +281,9 @@ void VectorTest::constructConversion() {
CORRADE_COMPARE(b, Vector4i(1, 2, -15, 7));
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Vector4, Vector4i>::value));
CORRADE_VERIFY(!std::is_convertible<Vector4, Vector4i>::value);
CORRADE_VERIFY((std::is_nothrow_constructible<Vector4, Vector4i>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<Vector4, Vector4i>::value);
}
void VectorTest::constructCopy() {
@ -310,8 +310,8 @@ void VectorTest::convert() {
CORRADE_COMPARE(d.z, a.z);
/* Implicit conversion is not allowed */
CORRADE_VERIFY(!(std::is_convertible<Vec3, Vector3>::value));
CORRADE_VERIFY(!(std::is_convertible<Vector3, Vec3>::value));
CORRADE_VERIFY(!std::is_convertible<Vec3, Vector3>::value);
CORRADE_VERIFY(!std::is_convertible<Vector3, Vec3>::value);
}
void VectorTest::isZeroFloat() {
@ -321,8 +321,8 @@ void VectorTest::isZeroFloat() {
}
void VectorTest::isZeroInteger() {
CORRADE_VERIFY(!(Math::Vector<3, Int>{0, 1, 0}.isZero()));
CORRADE_VERIFY((Math::Vector<3, Int>{0, 0, 0}.isZero()));
CORRADE_VERIFY(!Math::Vector<3, Int>{0, 1, 0}.isZero());
CORRADE_VERIFY(Math::Vector<3, Int>{0, 0, 0}.isZero());
}
void VectorTest::isNormalized() {
@ -630,71 +630,71 @@ typedef BasicVec2<Int> Vec2i;
void VectorTest::subclassTypes() {
Float* const data = nullptr;
const Float* const cdata = nullptr;
CORRADE_VERIFY((std::is_same<decltype(Vec2::from(data)), Vec2&>::value));
CORRADE_VERIFY((std::is_same<decltype(Vec2::from(cdata)), const Vec2&>::value));
CORRADE_VERIFY(std::is_same<decltype(Vec2::from(data)), Vec2&>::value);
CORRADE_VERIFY(std::is_same<decltype(Vec2::from(cdata)), const Vec2&>::value);
Vector<1, Float> one;
CORRADE_VERIFY((std::is_same<decltype(Vec2::pad(one)), Vec2>::value));
CORRADE_VERIFY(std::is_same<decltype(Vec2::pad(one)), Vec2>::value);
/* Const operators */
const Vec2 c;
const Vec2 c2;
CORRADE_VERIFY((std::is_same<decltype(-c), Vec2>::value));
CORRADE_VERIFY((std::is_same<decltype(c + c), Vec2>::value));
CORRADE_VERIFY((std::is_same<decltype(c*1.0f), Vec2>::value));
CORRADE_VERIFY((std::is_same<decltype(1.0f*c), Vec2>::value));
CORRADE_VERIFY((std::is_same<decltype(c/1.0f), Vec2>::value));
CORRADE_VERIFY((std::is_same<decltype(1.0f/c), Vec2>::value));
CORRADE_VERIFY((std::is_same<decltype(c*c2), Vec2>::value));
CORRADE_VERIFY((std::is_same<decltype(c/c2), Vec2>::value));
CORRADE_VERIFY(std::is_same<decltype(-c), Vec2>::value);
CORRADE_VERIFY(std::is_same<decltype(c + c), Vec2>::value);
CORRADE_VERIFY(std::is_same<decltype(c*1.0f), Vec2>::value);
CORRADE_VERIFY(std::is_same<decltype(1.0f*c), Vec2>::value);
CORRADE_VERIFY(std::is_same<decltype(c/1.0f), Vec2>::value);
CORRADE_VERIFY(std::is_same<decltype(1.0f/c), Vec2>::value);
CORRADE_VERIFY(std::is_same<decltype(c*c2), Vec2>::value);
CORRADE_VERIFY(std::is_same<decltype(c/c2), Vec2>::value);
/* Assignment operators */
Vec2 a;
CORRADE_VERIFY((std::is_same<decltype(a = c), Vec2&>::value));
CORRADE_VERIFY((std::is_same<decltype(a += c), Vec2&>::value));
CORRADE_VERIFY((std::is_same<decltype(a -= c), Vec2&>::value));
CORRADE_VERIFY((std::is_same<decltype(a *= 1.0f), Vec2&>::value));
CORRADE_VERIFY((std::is_same<decltype(a /= 1.0f), Vec2&>::value));
CORRADE_VERIFY((std::is_same<decltype(a *= c), Vec2&>::value));
CORRADE_VERIFY((std::is_same<decltype(a /= c), Vec2&>::value));
CORRADE_VERIFY(std::is_same<decltype(a = c), Vec2&>::value);
CORRADE_VERIFY(std::is_same<decltype(a += c), Vec2&>::value);
CORRADE_VERIFY(std::is_same<decltype(a -= c), Vec2&>::value);
CORRADE_VERIFY(std::is_same<decltype(a *= 1.0f), Vec2&>::value);
CORRADE_VERIFY(std::is_same<decltype(a /= 1.0f), Vec2&>::value);
CORRADE_VERIFY(std::is_same<decltype(a *= c), Vec2&>::value);
CORRADE_VERIFY(std::is_same<decltype(a /= c), Vec2&>::value);
/* Modulo operations */
const Vec2i ci;
Vec2i i;
const Int j = {};
CORRADE_VERIFY((std::is_same<decltype(ci % j), Vec2i>::value));
CORRADE_VERIFY((std::is_same<decltype(i %= j), Vec2i&>::value));
CORRADE_VERIFY((std::is_same<decltype(ci % ci), Vec2i>::value));
CORRADE_VERIFY((std::is_same<decltype(i %= ci), Vec2i&>::value));
CORRADE_VERIFY(std::is_same<decltype(ci % j), Vec2i>::value);
CORRADE_VERIFY(std::is_same<decltype(i %= j), Vec2i&>::value);
CORRADE_VERIFY(std::is_same<decltype(ci % ci), Vec2i>::value);
CORRADE_VERIFY(std::is_same<decltype(i %= ci), Vec2i&>::value);
/* Bitwise operations */
CORRADE_VERIFY((std::is_same<decltype(~ci), Vec2i>::value));
CORRADE_VERIFY((std::is_same<decltype(ci & ci), Vec2i>::value));
CORRADE_VERIFY((std::is_same<decltype(ci | ci), Vec2i>::value));
CORRADE_VERIFY((std::is_same<decltype(ci ^ ci), Vec2i>::value));
CORRADE_VERIFY((std::is_same<decltype(ci << 1), Vec2i>::value));
CORRADE_VERIFY((std::is_same<decltype(ci >> 1), Vec2i>::value));
CORRADE_VERIFY((std::is_same<decltype(i &= ci), Vec2i&>::value));
CORRADE_VERIFY((std::is_same<decltype(i |= ci), Vec2i&>::value));
CORRADE_VERIFY((std::is_same<decltype(i ^= ci), Vec2i&>::value));
CORRADE_VERIFY((std::is_same<decltype(i <<= 1), Vec2i&>::value));
CORRADE_VERIFY((std::is_same<decltype(i >>= 1), Vec2i&>::value));
CORRADE_VERIFY(std::is_same<decltype(~ci), Vec2i>::value);
CORRADE_VERIFY(std::is_same<decltype(ci & ci), Vec2i>::value);
CORRADE_VERIFY(std::is_same<decltype(ci | ci), Vec2i>::value);
CORRADE_VERIFY(std::is_same<decltype(ci ^ ci), Vec2i>::value);
CORRADE_VERIFY(std::is_same<decltype(ci << 1), Vec2i>::value);
CORRADE_VERIFY(std::is_same<decltype(ci >> 1), Vec2i>::value);
CORRADE_VERIFY(std::is_same<decltype(i &= ci), Vec2i&>::value);
CORRADE_VERIFY(std::is_same<decltype(i |= ci), Vec2i&>::value);
CORRADE_VERIFY(std::is_same<decltype(i ^= ci), Vec2i&>::value);
CORRADE_VERIFY(std::is_same<decltype(i <<= 1), Vec2i&>::value);
CORRADE_VERIFY(std::is_same<decltype(i >>= 1), Vec2i&>::value);
/* Integer multiplication/division */
CORRADE_VERIFY((std::is_same<decltype(ci*1.0f), Vec2i>::value));
CORRADE_VERIFY((std::is_same<decltype(1.0f*ci), Vec2i>::value));
CORRADE_VERIFY((std::is_same<decltype(c*ci), Vec2i>::value));
CORRADE_VERIFY((std::is_same<decltype(ci*c), Vec2i>::value));
CORRADE_VERIFY((std::is_same<decltype(ci/c), Vec2i>::value));
CORRADE_VERIFY((std::is_same<decltype(i *= c), Vec2i&>::value));
CORRADE_VERIFY((std::is_same<decltype(i /= c), Vec2i&>::value));
CORRADE_VERIFY(std::is_same<decltype(ci*1.0f), Vec2i>::value);
CORRADE_VERIFY(std::is_same<decltype(1.0f*ci), Vec2i>::value);
CORRADE_VERIFY(std::is_same<decltype(c*ci), Vec2i>::value);
CORRADE_VERIFY(std::is_same<decltype(ci*c), Vec2i>::value);
CORRADE_VERIFY(std::is_same<decltype(ci/c), Vec2i>::value);
CORRADE_VERIFY(std::is_same<decltype(i *= c), Vec2i&>::value);
CORRADE_VERIFY(std::is_same<decltype(i /= c), Vec2i&>::value);
/* Functions */
CORRADE_VERIFY((std::is_same<decltype(c.normalized()), Vec2>::value));
CORRADE_VERIFY((std::is_same<decltype(c.resized(1.0f)), Vec2>::value));
CORRADE_VERIFY((std::is_same<decltype(c.projected(c2)), Vec2>::value));
CORRADE_VERIFY((std::is_same<decltype(c.projectedOntoNormalized(c2)), Vec2>::value));
CORRADE_VERIFY((std::is_same<decltype(c.flipped()), Vec2>::value));
CORRADE_VERIFY(std::is_same<decltype(c.normalized()), Vec2>::value);
CORRADE_VERIFY(std::is_same<decltype(c.resized(1.0f)), Vec2>::value);
CORRADE_VERIFY(std::is_same<decltype(c.projected(c2)), Vec2>::value);
CORRADE_VERIFY(std::is_same<decltype(c.projectedOntoNormalized(c2)), Vec2>::value);
CORRADE_VERIFY(std::is_same<decltype(c.flipped()), Vec2>::value);
}
void VectorTest::subclass() {

4
src/Magnum/Test/ArrayTest.cpp
Unescape View File

@ -78,8 +78,8 @@ void ArrayTest::construct() {
}
void ArrayTest::equality() {
CORRADE_VERIFY((Array<3, Int>(5, 6, 7) == Array<3, Int>(5, 6, 7)));
CORRADE_VERIFY((Array<3, Int>(5, 6, 7) != Array<3, Int>(5, 6, 8)));
CORRADE_VERIFY(Array<3, Int>(5, 6, 7) == Array<3, Int>(5, 6, 7));
CORRADE_VERIFY(Array<3, Int>(5, 6, 7) != Array<3, Int>(5, 6, 8));
}
void ArrayTest::access() {

20
src/Magnum/Test/ImageViewTest.cpp
Unescape View File

@ -477,9 +477,9 @@ void ImageViewTest::construct3DFrom1D() {
/* Conversion the other way is not allowed (will be later, but explicitly
via a slice<1>() like with StridedArrayView); conversion from const to
mutable is not possible either */
CORRADE_VERIFY((std::is_convertible<ImageView1D, ImageView3D>::value));
CORRADE_VERIFY(!(std::is_convertible<ImageView3D, ImageView1D>::value));
CORRADE_VERIFY(!(std::is_convertible<ImageView1D, MutableImageView3D>::value));
CORRADE_VERIFY(std::is_convertible<ImageView1D, ImageView3D>::value);
CORRADE_VERIFY(!std::is_convertible<ImageView3D, ImageView1D>::value);
CORRADE_VERIFY(!std::is_convertible<ImageView1D, MutableImageView3D>::value);
}
void ImageViewTest::construct3DFrom2D() {
@ -506,8 +506,8 @@ void ImageViewTest::construct3DFrom2D() {
/* Conversion the other way is not allowed (will be later, but explicitly
via a slice<1>() like with StridedArrayView) */
CORRADE_VERIFY((std::is_convertible<MutableImageView1D, MutableImageView3D>::value));
CORRADE_VERIFY(!(std::is_convertible<MutableImageView3D, MutableImageView1D>::value));
CORRADE_VERIFY(std::is_convertible<MutableImageView1D, MutableImageView3D>::value);
CORRADE_VERIFY(!std::is_convertible<MutableImageView3D, MutableImageView1D>::value);
}
void ImageViewTest::constructCompressed3DFrom1D() {
@ -534,9 +534,9 @@ void ImageViewTest::constructCompressed3DFrom1D() {
/* Conversion the other way is not allowed (will be later, but explicitly
via a slice<1>() like with StridedArrayView); conversion from const to
mutable is not possible either */
CORRADE_VERIFY((std::is_convertible<CompressedImageView1D, CompressedImageView3D>::value));
CORRADE_VERIFY(!(std::is_convertible<CompressedImageView3D, CompressedImageView1D>::value));
CORRADE_VERIFY(!(std::is_convertible<CompressedImageView1D, MutableCompressedImageView3D>::value));
CORRADE_VERIFY(std::is_convertible<CompressedImageView1D, CompressedImageView3D>::value);
CORRADE_VERIFY(!std::is_convertible<CompressedImageView3D, CompressedImageView1D>::value);
CORRADE_VERIFY(!std::is_convertible<CompressedImageView1D, MutableCompressedImageView3D>::value);
}
void ImageViewTest::constructCompressed3DFrom2D() {
@ -560,8 +560,8 @@ void ImageViewTest::constructCompressed3DFrom2D() {
/* Conversion the other way is not allowed (will be later, but explicitly
via a slice<1>() like with StridedArrayView) */
CORRADE_VERIFY((std::is_convertible<MutableCompressedImageView1D, MutableCompressedImageView3D>::value));
CORRADE_VERIFY(!(std::is_convertible<MutableCompressedImageView3D, MutableCompressedImageView1D>::value));
CORRADE_VERIFY(std::is_convertible<MutableCompressedImageView1D, MutableCompressedImageView3D>::value);
CORRADE_VERIFY(!std::is_convertible<MutableCompressedImageView3D, MutableCompressedImageView1D>::value);
}
void ImageViewTest::constructFromMutable() {

6
src/Magnum/Test/TagsTest.cpp
Unescape View File

@ -49,9 +49,9 @@ void TagsTest::noDefaultConstructor() {
}
void TagsTest::inlineDefinition() {
CORRADE_VERIFY((std::is_same<decltype(NoInit), const NoInitT>::value));
CORRADE_VERIFY((std::is_same<decltype(NoCreate), const NoCreateT>::value));
CORRADE_VERIFY((std::is_same<decltype(NoAllocate), const NoAllocateT>::value));
CORRADE_VERIFY(std::is_same<decltype(NoInit), const NoInitT>::value);
CORRADE_VERIFY(std::is_same<decltype(NoCreate), const NoCreateT>::value);
CORRADE_VERIFY(std::is_same<decltype(NoAllocate), const NoAllocateT>::value);
}
}}}

14
src/Magnum/Vk/Test/BufferTest.cpp
Unescape View File

@ -120,10 +120,10 @@ void BufferTest::createInfoConstructNoInit() {
new(&info) BufferCreateInfo{NoInit};
CORRADE_COMPARE(info->sType, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
CORRADE_VERIFY((std::is_nothrow_constructible<BufferCreateInfo, NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<BufferCreateInfo, NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoInitT, BufferCreateInfo>::value));
CORRADE_VERIFY(!std::is_convertible<NoInitT, BufferCreateInfo>::value);
}
void BufferTest::createInfoConstructFromVk() {
@ -141,7 +141,7 @@ void BufferTest::constructNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, Buffer>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, Buffer>::value);
}
void BufferTest::constructCopy() {
@ -176,10 +176,10 @@ void BufferTest::bufferCopyConstructNoInit() {
new(&copy) BufferCopy{NoInit};
CORRADE_COMPARE(copy->sType, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
CORRADE_VERIFY((std::is_nothrow_constructible<BufferCopy, NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<BufferCopy, NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoInitT, BufferCopy>::value));
CORRADE_VERIFY(!std::is_convertible<NoInitT, BufferCopy>::value);
}
template<class From, class To> void BufferTest::bufferCopyConstructFromVk() {
@ -242,10 +242,10 @@ void BufferTest::copyBufferInfoConstructNoInit() {
new(&info) CopyBufferInfo{NoInit};
CORRADE_COMPARE(info->sType, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
CORRADE_VERIFY((std::is_nothrow_constructible<CopyBufferInfo, NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<CopyBufferInfo, NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoInitT, CopyBufferInfo>::value));
CORRADE_VERIFY(!std::is_convertible<NoInitT, CopyBufferInfo>::value);
}
void BufferTest::copyBufferInfoConstructFromVk() {

6
src/Magnum/Vk/Test/CommandBufferTest.cpp
Unescape View File

@ -61,10 +61,10 @@ void CommandBufferTest::beginInfoConstructNoInit() {
new(&info) CommandBufferBeginInfo{NoInit};
CORRADE_COMPARE(info->sType, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
CORRADE_VERIFY((std::is_nothrow_constructible<CommandBufferBeginInfo, NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<CommandBufferBeginInfo, NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoInitT, CommandBufferBeginInfo>::value));
CORRADE_VERIFY(!std::is_convertible<NoInitT, CommandBufferBeginInfo>::value);
}
void CommandBufferTest::beginInfoConstructFromVk() {
@ -82,7 +82,7 @@ void CommandBufferTest::constructNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, CommandBuffer>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, CommandBuffer>::value);
}
void CommandBufferTest::constructCopy() {

6
src/Magnum/Vk/Test/CommandPoolTest.cpp
Unescape View File

@ -62,10 +62,10 @@ void CommandPoolTest::createInfoConstructNoInit() {
new(&info) CommandPoolCreateInfo{NoInit};
CORRADE_COMPARE(info->sType, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
CORRADE_VERIFY((std::is_nothrow_constructible<CommandPoolCreateInfo, NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<CommandPoolCreateInfo, NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoInitT, CommandPoolCreateInfo>::value));
CORRADE_VERIFY(!std::is_convertible<NoInitT, CommandPoolCreateInfo>::value);
}
void CommandPoolTest::createInfoConstructFromVk() {
@ -83,7 +83,7 @@ void CommandPoolTest::constructNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, CommandPool>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, CommandPool>::value);
}
void CommandPoolTest::constructCopy() {

2
src/Magnum/Vk/Test/DevicePropertiesTest.cpp
Unescape View File

@ -64,7 +64,7 @@ void DevicePropertiesTest::constructNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, DeviceProperties>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, DeviceProperties>::value);
}
void DevicePropertiesTest::constructCopy() {

6
src/Magnum/Vk/Test/DeviceTest.cpp
Unescape View File

@ -56,10 +56,10 @@ void DeviceTest::createInfoConstructNoInit() {
new(&info) DeviceCreateInfo{NoInit};
CORRADE_COMPARE(info->sType, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
CORRADE_VERIFY((std::is_nothrow_constructible<DeviceCreateInfo, NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<DeviceCreateInfo, NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoInitT, DeviceCreateInfo>::value));
CORRADE_VERIFY(!std::is_convertible<NoInitT, DeviceCreateInfo>::value);
}
void DeviceTest::createInfoConstructFromVk() {
@ -79,7 +79,7 @@ void DeviceTest::constructNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, Device>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, Device>::value);
}
void DeviceTest::constructCopy() {

4
src/Magnum/Vk/Test/DeviceVkTest.cpp
Unescape View File

@ -498,8 +498,8 @@ void DeviceVkTest::createInfoWrongQueueOutputCount() {
}
void DeviceVkTest::createInfoConstructCopy() {
CORRADE_VERIFY(!(std::is_copy_constructible<DeviceCreateInfo>{}));
CORRADE_VERIFY(!(std::is_copy_assignable<DeviceCreateInfo>{}));
CORRADE_VERIFY(!std::is_copy_constructible<DeviceCreateInfo>{});
CORRADE_VERIFY(!std::is_copy_assignable<DeviceCreateInfo>{});
}
void DeviceVkTest::createInfoConstructMove() {

4
src/Magnum/Vk/Test/ExtensionPropertiesTest.cpp
Unescape View File

@ -54,7 +54,7 @@ void ExtensionPropertiesTest::constructNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, ExtensionProperties>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, ExtensionProperties>::value);
}
void ExtensionPropertiesTest::constructInstanceNoCreate() {
@ -64,7 +64,7 @@ void ExtensionPropertiesTest::constructInstanceNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, InstanceExtensionProperties>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, InstanceExtensionProperties>::value);
}
void ExtensionPropertiesTest::constructCopy() {

44
src/Magnum/Vk/Test/ExtensionsTest.cpp
Unescape View File

@ -65,22 +65,22 @@ void ExtensionsTest::isInstanceExtension() {
/* Variadic check (used in variadic addEnabledExtensions()), check that it
properly fails for each occurence of a device extension */
CORRADE_VERIFY((Implementation::IsInstanceExtension<
CORRADE_VERIFY(Implementation::IsInstanceExtension<
Extensions::KHR::get_physical_device_properties2,
Extensions::KHR::external_memory_capabilities,
Extensions::KHR::external_fence_capabilities>::value));
CORRADE_VERIFY(!(Implementation::IsInstanceExtension<
Extensions::KHR::external_fence_capabilities>::value);
CORRADE_VERIFY(!Implementation::IsInstanceExtension<
Extensions::KHR::draw_indirect_count, /* not */
Extensions::KHR::external_memory_capabilities,
Extensions::KHR::external_fence_capabilities>::value));
CORRADE_VERIFY(!(Implementation::IsInstanceExtension<
Extensions::KHR::external_fence_capabilities>::value);
CORRADE_VERIFY(!Implementation::IsInstanceExtension<
Extensions::KHR::get_physical_device_properties2,
Extensions::KHR::external_memory, /* not */
Extensions::KHR::external_fence_capabilities>::value));
CORRADE_VERIFY(!(Implementation::IsInstanceExtension<
Extensions::KHR::external_fence_capabilities>::value);
CORRADE_VERIFY(!Implementation::IsInstanceExtension<
Extensions::KHR::get_physical_device_properties2,
Extensions::KHR::external_memory_capabilities,
Extensions::KHR::external_fence>::value)); /* not */
Extensions::KHR::external_fence>::value); /* not */
/* Empty variadic list should return true */
CORRADE_VERIFY(Implementation::IsInstanceExtension<>::value);
@ -104,22 +104,22 @@ void ExtensionsTest::isExtension() {
/* Variadic check (used in variadic addEnabledExtensions()), check that it
properly fails for each occurence of a device extension */
CORRADE_VERIFY((Implementation::IsExtension<
CORRADE_VERIFY(Implementation::IsExtension<
Extensions::KHR::external_memory,
Extensions::KHR::depth_stencil_resolve,
Extensions::KHR::external_fence>::value));
CORRADE_VERIFY(!(Implementation::IsExtension<
Extensions::KHR::external_fence>::value);
CORRADE_VERIFY(!Implementation::IsExtension<
Extensions::KHR::external_memory_capabilities, /* not */
Extensions::KHR::depth_stencil_resolve,
Extensions::KHR::external_fence>::value));
CORRADE_VERIFY(!(Implementation::IsExtension<
Extensions::KHR::external_fence>::value);
CORRADE_VERIFY(!Implementation::IsExtension<
Extensions::KHR::external_memory,
Extensions::EXT::debug_report, /* not */
Extensions::KHR::external_fence>::value));
CORRADE_VERIFY(!(Implementation::IsExtension<
Extensions::KHR::external_fence>::value);
CORRADE_VERIFY(!Implementation::IsExtension<
Extensions::KHR::external_memory,
Extensions::KHR::depth_stencil_resolve,
Extensions::KHR::external_fence_capabilities>::value)); /* not */
Extensions::KHR::external_fence_capabilities>::value); /* not */
/* Empty variadic list should return true */
CORRADE_VERIFY(Implementation::IsExtension<>::value);
@ -133,12 +133,12 @@ void ExtensionsTest::constructInstanceExtensionFromCompileTimeExtension() {
CORRADE_COMPARE(a.string(), Extensions::KHR::get_physical_device_properties2::string());
/* Should be convertible from device extensions, but not instance exts */
CORRADE_VERIFY((std::is_convertible<Extensions::KHR::get_physical_device_properties2, InstanceExtension>::value));
CORRADE_VERIFY(!(std::is_convertible<Extensions::KHR::external_memory, InstanceExtension>::value));
CORRADE_VERIFY(std::is_convertible<Extensions::KHR::get_physical_device_properties2, InstanceExtension>::value);
CORRADE_VERIFY(!std::is_convertible<Extensions::KHR::external_memory, InstanceExtension>::value);
/* Shouldn't be convertible from strings to avoid ambiguity in APIs that
have string/extension overloads */
CORRADE_VERIFY(!(std::is_convertible<Containers::StringView, InstanceExtension>::value));
CORRADE_VERIFY(!std::is_convertible<Containers::StringView, InstanceExtension>::value);
}
void ExtensionsTest::constructExtensionFromCompileTimeExtension() {
@ -149,12 +149,12 @@ void ExtensionsTest::constructExtensionFromCompileTimeExtension() {
CORRADE_COMPARE(a.string(), Extensions::KHR::external_memory::string());
/* Should be convertible from device extensions, but not instance exts */
CORRADE_VERIFY((std::is_convertible<Extensions::KHR::external_memory, Extension>::value));
CORRADE_VERIFY(!(std::is_convertible<Extensions::KHR::get_physical_device_properties2, Extension>::value));
CORRADE_VERIFY(std::is_convertible<Extensions::KHR::external_memory, Extension>::value);
CORRADE_VERIFY(!std::is_convertible<Extensions::KHR::get_physical_device_properties2, Extension>::value);
/* Shouldn't be convertible from strings to avoid ambiguity in APIs that
have string/extension overloads */
CORRADE_VERIFY(!(std::is_convertible<Containers::StringView, Extension>::value));
CORRADE_VERIFY(!std::is_convertible<Containers::StringView, Extension>::value);
}
void ExtensionsTest::instanceExtensions() {

6
src/Magnum/Vk/Test/FenceTest.cpp
Unescape View File

@ -61,10 +61,10 @@ void FenceTest::createInfoConstructNoInit() {
new(&info) FenceCreateInfo{NoInit};
CORRADE_COMPARE(info->sType, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
CORRADE_VERIFY((std::is_nothrow_constructible<FenceCreateInfo, NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<FenceCreateInfo, NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoInitT, FenceCreateInfo>::value));
CORRADE_VERIFY(!std::is_convertible<NoInitT, FenceCreateInfo>::value);
}
void FenceTest::createInfoConstructFromVk() {
@ -82,7 +82,7 @@ void FenceTest::constructNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, Fence>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, Fence>::value);
}
void FenceTest::constructCopy() {

10
src/Magnum/Vk/Test/FramebufferTest.cpp
Unescape View File

@ -108,10 +108,10 @@ void FramebufferTest::createInfoConstructNoInit() {
new(&info) FramebufferCreateInfo{NoInit};
CORRADE_COMPARE(info->sType, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
CORRADE_VERIFY((std::is_nothrow_constructible<FramebufferCreateInfo, NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<FramebufferCreateInfo, NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoInitT, FramebufferCreateInfo>::value));
CORRADE_VERIFY(!std::is_convertible<NoInitT, FramebufferCreateInfo>::value);
}
void FramebufferTest::createInfoConstructFromVk() {
@ -123,8 +123,8 @@ void FramebufferTest::createInfoConstructFromVk() {
}
void FramebufferTest::createInfoConstructCopy() {
CORRADE_VERIFY(!(std::is_copy_constructible<FramebufferCreateInfo>{}));
CORRADE_VERIFY(!(std::is_copy_assignable<FramebufferCreateInfo>{}));
CORRADE_VERIFY(!std::is_copy_constructible<FramebufferCreateInfo>{});
CORRADE_VERIFY(!std::is_copy_assignable<FramebufferCreateInfo>{});
}
void FramebufferTest::createInfoConstructMove() {
@ -162,7 +162,7 @@ void FramebufferTest::constructNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, Framebuffer>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, Framebuffer>::value);
}
void FramebufferTest::constructCopy() {

26
src/Magnum/Vk/Test/ImageTest.cpp
Unescape View File

@ -327,10 +327,10 @@ void ImageTest::createInfoConstructNoInit() {
new(&info) ImageCreateInfo{NoInit};
CORRADE_COMPARE(info->sType, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
CORRADE_VERIFY((std::is_nothrow_constructible<ImageCreateInfo, NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<ImageCreateInfo, NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoInitT, ImageCreateInfo>::value));
CORRADE_VERIFY(!std::is_convertible<NoInitT, ImageCreateInfo>::value);
}
void ImageTest::createInfoConstructFromVk() {
@ -371,7 +371,7 @@ void ImageTest::constructNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, Image>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, Image>::value);
}
void ImageTest::constructCopy() {
@ -414,10 +414,10 @@ void ImageTest::imageCopyConstructNoInit() {
new(&copy) ImageCopy{NoInit};
CORRADE_COMPARE(copy->sType, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
CORRADE_VERIFY((std::is_nothrow_constructible<ImageCopy, NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<ImageCopy, NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoInitT, ImageCopy>::value));
CORRADE_VERIFY(!std::is_convertible<NoInitT, ImageCopy>::value);
}
template<class From, class To> void ImageTest::imageCopyConstructFromVk() {
@ -510,10 +510,10 @@ void ImageTest::copyImageInfoConstructNoInit() {
new(&info) CopyImageInfo{NoInit};
CORRADE_COMPARE(info->sType, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
CORRADE_VERIFY((std::is_nothrow_constructible<CopyImageInfo, NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<CopyImageInfo, NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoInitT, CopyImageInfo>::value));
CORRADE_VERIFY(!std::is_convertible<NoInitT, CopyImageInfo>::value);
}
void ImageTest::copyImageInfoConstructFromVk() {
@ -656,10 +656,10 @@ void ImageTest::bufferImageCopyConstructNoInit() {
new(&copy) BufferImageCopy{NoInit};
CORRADE_COMPARE(copy->sType, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
CORRADE_VERIFY((std::is_nothrow_constructible<BufferImageCopy, NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<BufferImageCopy, NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoInitT, BufferImageCopy>::value));
CORRADE_VERIFY(!std::is_convertible<NoInitT, BufferImageCopy>::value);
}
template<class From, class To> void ImageTest::bufferImageCopyConstructFromVk() {
@ -744,10 +744,10 @@ void ImageTest::copyBufferToImageInfoConstructNoInit() {
new(&info) CopyBufferToImageInfo{NoInit};
CORRADE_COMPARE(info->sType, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
CORRADE_VERIFY((std::is_nothrow_constructible<CopyBufferToImageInfo, NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<CopyBufferToImageInfo, NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoInitT, CopyBufferToImageInfo>::value));
CORRADE_VERIFY(!std::is_convertible<NoInitT, CopyBufferToImageInfo>::value);
}
void ImageTest::copyBufferToImageInfoConstructFromVk() {
@ -797,10 +797,10 @@ void ImageTest::copyImageToBufferInfoConstructNoInit() {
new(&info) CopyImageToBufferInfo{NoInit};
CORRADE_COMPARE(info->sType, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
CORRADE_VERIFY((std::is_nothrow_constructible<CopyImageToBufferInfo, NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<CopyImageToBufferInfo, NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoInitT, CopyImageToBufferInfo>::value));
CORRADE_VERIFY(!std::is_convertible<NoInitT, CopyImageToBufferInfo>::value);
}
void ImageTest::copyImageToBufferInfoConstructFromVk() {

6
src/Magnum/Vk/Test/ImageViewTest.cpp
Unescape View File

@ -405,10 +405,10 @@ void ImageViewTest::createInfoConstructNoInit() {
new(&info) ImageViewCreateInfo{NoInit};
CORRADE_COMPARE(info->sType, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
CORRADE_VERIFY((std::is_nothrow_constructible<ImageViewCreateInfo, NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<ImageViewCreateInfo, NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoInitT, ImageViewCreateInfo>::value));
CORRADE_VERIFY(!std::is_convertible<NoInitT, ImageViewCreateInfo>::value);
}
void ImageViewTest::createInfoConstructFromVk() {
@ -426,7 +426,7 @@ void ImageViewTest::constructNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, ImageView>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, ImageView>::value);
}
void ImageViewTest::constructCopy() {

8
src/Magnum/Vk/Test/InstanceTest.cpp
Unescape View File

@ -57,10 +57,10 @@ void InstanceTest::createInfoConstructNoInit() {
new(&info) InstanceCreateInfo{NoInit};
CORRADE_COMPARE(info->sType, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
CORRADE_VERIFY((std::is_nothrow_constructible<InstanceCreateInfo, NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<InstanceCreateInfo, NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoInitT, InstanceCreateInfo>::value));
CORRADE_VERIFY(!std::is_convertible<NoInitT, InstanceCreateInfo>::value);
}
void InstanceTest::createInfoConstructFromVk() {
@ -71,7 +71,7 @@ void InstanceTest::createInfoConstructFromVk() {
CORRADE_COMPARE(info->sType, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<VkInstanceCreateInfo, InstanceCreateInfo>::value));
CORRADE_VERIFY(!std::is_convertible<VkInstanceCreateInfo, InstanceCreateInfo>::value);
}
void InstanceTest::constructNoCreate() {
@ -83,7 +83,7 @@ void InstanceTest::constructNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, Instance>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, Instance>::value);
}
void InstanceTest::constructCopy() {

4
src/Magnum/Vk/Test/IntegrationTest.cpp
Unescape View File

@ -217,8 +217,8 @@ void IntegrationTest::vkClearColorValue3() {
/** @todo test constexpr once/if possible */
/* Conversion the ohter way not allowed */
CORRADE_VERIFY((std::is_constructible<Color4, VkClearColorValue>::value));
CORRADE_VERIFY(!(std::is_constructible<Color3, VkClearColorValue>::value));
CORRADE_VERIFY(std::is_constructible<Color4, VkClearColorValue>::value);
CORRADE_VERIFY(!std::is_constructible<Color3, VkClearColorValue>::value);
}
void IntegrationTest::vkViewport() {

2
src/Magnum/Vk/Test/LayerPropertiesTest.cpp
Unescape View File

@ -48,7 +48,7 @@ void LayerPropertiesTest::constructNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, LayerProperties>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, LayerProperties>::value);
}
void LayerPropertiesTest::constructCopy() {

10
src/Magnum/Vk/Test/MemoryTest.cpp
Unescape View File

@ -81,10 +81,10 @@ void MemoryTest::requirementsConstructNoInit() {
new(&requirements) MemoryRequirements{NoInit};
CORRADE_COMPARE(requirements->sType, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
CORRADE_VERIFY((std::is_nothrow_constructible<MemoryRequirements, NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<MemoryRequirements, NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoInitT, MemoryRequirements>::value));
CORRADE_VERIFY(!std::is_convertible<NoInitT, MemoryRequirements>::value);
}
void MemoryTest::requirementsConstructFromVk() {
@ -137,10 +137,10 @@ void MemoryTest::allocateInfoConstructNoInit() {
new(&info) MemoryAllocateInfo{NoInit};
CORRADE_COMPARE(info->sType, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
CORRADE_VERIFY((std::is_nothrow_constructible<MemoryAllocateInfo, NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<MemoryAllocateInfo, NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoInitT, MemoryAllocateInfo>::value));
CORRADE_VERIFY(!std::is_convertible<NoInitT, MemoryAllocateInfo>::value);
}
void MemoryTest::allocateInfoConstructFromVk() {
@ -158,7 +158,7 @@ void MemoryTest::constructNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, Memory>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, Memory>::value);
}
void MemoryTest::constructCopy() {

4
src/Magnum/Vk/Test/MeshLayoutTest.cpp
Unescape View File

@ -205,10 +205,10 @@ void MeshLayoutTest::constructNoInit() {
CORRADE_COMPARE(layout.vkPipelineVertexInputStateCreateInfo().sType, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
CORRADE_COMPARE(layout.vkPipelineInputAssemblyStateCreateInfo().sType, VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES);
CORRADE_VERIFY((std::is_nothrow_constructible<MeshLayout, NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<MeshLayout, NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoInitT, MeshLayout>::value));
CORRADE_VERIFY(!std::is_convertible<NoInitT, MeshLayout>::value);
}
void MeshLayoutTest::constructFromVk() {

6
src/Magnum/Vk/Test/PipelineLayoutTest.cpp
Unescape View File

@ -62,10 +62,10 @@ void PipelineLayoutTest::createInfoConstructNoInit() {
new(&info) PipelineLayoutCreateInfo{NoInit};
CORRADE_COMPARE(info->sType, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
CORRADE_VERIFY((std::is_nothrow_constructible<PipelineLayoutCreateInfo, NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<PipelineLayoutCreateInfo, NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoInitT, PipelineLayoutCreateInfo>::value));
CORRADE_VERIFY(!std::is_convertible<NoInitT, PipelineLayoutCreateInfo>::value);
}
void PipelineLayoutTest::createInfoConstructFromVk() {
@ -83,7 +83,7 @@ void PipelineLayoutTest::constructNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, PipelineLayout>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, PipelineLayout>::value);
}
void PipelineLayoutTest::constructCopy() {

22
src/Magnum/Vk/Test/PipelineTest.cpp
Unescape View File

@ -224,10 +224,10 @@ void PipelineTest::rasterizationCreateInfoConstructNoInit() {
new(&info) RasterizationPipelineCreateInfo{NoInit};
CORRADE_COMPARE(info->sType, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
CORRADE_VERIFY((std::is_nothrow_constructible<RasterizationPipelineCreateInfo, NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<RasterizationPipelineCreateInfo, NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoInitT, RasterizationPipelineCreateInfo>::value));
CORRADE_VERIFY(!std::is_convertible<NoInitT, RasterizationPipelineCreateInfo>::value);
}
void PipelineTest::rasterizationCreateInfoConstructFromVk() {
@ -581,10 +581,10 @@ void PipelineTest::computeCreateInfoConstructNoInit() {
new(&info) ComputePipelineCreateInfo{NoInit};
CORRADE_COMPARE(info->sType, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
CORRADE_VERIFY((std::is_nothrow_constructible<ComputePipelineCreateInfo, NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<ComputePipelineCreateInfo, NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoInitT, ComputePipelineCreateInfo>::value));
CORRADE_VERIFY(!std::is_convertible<NoInitT, ComputePipelineCreateInfo>::value);
}
void PipelineTest::computeCreateInfoConstructFromVk() {
@ -602,7 +602,7 @@ void PipelineTest::constructNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, Pipeline>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, Pipeline>::value);
}
void PipelineTest::constructCopy() {
@ -622,10 +622,10 @@ void PipelineTest::memoryBarrierConstructNoInit() {
new(&barrier) MemoryBarrier{NoInit};
CORRADE_COMPARE(barrier->sType, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
CORRADE_VERIFY((std::is_nothrow_constructible<MemoryBarrier, NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<MemoryBarrier, NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoInitT, MemoryBarrier>::value));
CORRADE_VERIFY(!std::is_convertible<NoInitT, MemoryBarrier>::value);
}
void PipelineTest::memoryBarrierConstructFromVk() {
@ -651,10 +651,10 @@ void PipelineTest::bufferMemoryBarrierConstructNoInit() {
new(&barrier) BufferMemoryBarrier{NoInit};
CORRADE_COMPARE(barrier->sType, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
CORRADE_VERIFY((std::is_nothrow_constructible<BufferMemoryBarrier, NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<BufferMemoryBarrier, NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoInitT, BufferMemoryBarrier>::value));
CORRADE_VERIFY(!std::is_convertible<NoInitT, BufferMemoryBarrier>::value);
}
void PipelineTest::bufferMemoryBarrierConstructFromVk() {
@ -705,10 +705,10 @@ void PipelineTest::imageMemoryBarrierConstructNoInit() {
new(&barrier) ImageMemoryBarrier{NoInit};
CORRADE_COMPARE(barrier->sType, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
CORRADE_VERIFY((std::is_nothrow_constructible<ImageMemoryBarrier, NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<ImageMemoryBarrier, NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoInitT, ImageMemoryBarrier>::value));
CORRADE_VERIFY(!std::is_convertible<NoInitT, ImageMemoryBarrier>::value);
}
void PipelineTest::imageMemoryBarrierConstructFromVk() {

10
src/Magnum/Vk/Test/QueueTest.cpp
Unescape View File

@ -70,7 +70,7 @@ void QueueTest::constructNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, Queue>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, Queue>::value);
}
void QueueTest::constructCopy() {
@ -120,10 +120,10 @@ void QueueTest::submitInfoConstructNoInit() {
new(&info) SubmitInfo{NoInit};
CORRADE_COMPARE(info->sType, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
CORRADE_VERIFY((std::is_nothrow_constructible<SubmitInfo, NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<SubmitInfo, NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoInitT, SubmitInfo>::value));
CORRADE_VERIFY(!std::is_convertible<NoInitT, SubmitInfo>::value);
}
void QueueTest::submitInfoConstructCommandBuffers() {
@ -148,8 +148,8 @@ void QueueTest::submitInfoConstructFromVk() {
}
void QueueTest::submitInfoConstructCopy() {
CORRADE_VERIFY(!(std::is_copy_constructible<SubmitInfo>{}));
CORRADE_VERIFY(!(std::is_copy_assignable<SubmitInfo>{}));
CORRADE_VERIFY(!std::is_copy_constructible<SubmitInfo>{});
CORRADE_VERIFY(!std::is_copy_assignable<SubmitInfo>{});
}
void QueueTest::submitInfoConstructMove() {

42
src/Magnum/Vk/Test/RenderPassTest.cpp
Unescape View File

@ -296,10 +296,10 @@ void RenderPassTest::attachmentDescriptionConstructNoInit() {
new(&description) AttachmentDescription{NoInit};
CORRADE_COMPARE(description->sType, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
CORRADE_VERIFY((std::is_nothrow_constructible<AttachmentDescription, NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<AttachmentDescription, NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoInitT, AttachmentDescription>::value));
CORRADE_VERIFY(!std::is_convertible<NoInitT, AttachmentDescription>::value);
}
template<class From, class To> void RenderPassTest::attachmentDescriptionConstructFromVk() {
@ -381,10 +381,10 @@ void RenderPassTest::attachmentReferenceConstructNoInit() {
new(&reference) AttachmentReference{NoInit};
CORRADE_COMPARE(reference->sType, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
CORRADE_VERIFY((std::is_nothrow_constructible<AttachmentReference, NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<AttachmentReference, NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoInitT, AttachmentReference>::value));
CORRADE_VERIFY(!std::is_convertible<NoInitT, AttachmentReference>::value);
}
template<class From, class To> void RenderPassTest::attachmentReferenceConstructFromVk() {
@ -443,10 +443,10 @@ void RenderPassTest::subpassDescriptionConstructNoInit() {
new(&description) SubpassDescription{NoInit};
CORRADE_COMPARE(description->sType, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
CORRADE_VERIFY((std::is_nothrow_constructible<SubpassDescription, NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<SubpassDescription, NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoInitT, SubpassDescription>::value));
CORRADE_VERIFY(!std::is_convertible<NoInitT, SubpassDescription>::value);
}
void RenderPassTest::subpassDescriptionConstructInputAttachments() {
@ -619,8 +619,8 @@ template<class From, class To> void RenderPassTest::subpassDescriptionConstructF
}
void RenderPassTest::subpassDescriptionConstructCopy() {
CORRADE_VERIFY(!(std::is_copy_constructible<SubpassDescription>{}));
CORRADE_VERIFY(!(std::is_copy_assignable<SubpassDescription>{}));
CORRADE_VERIFY(!std::is_copy_constructible<SubpassDescription>{});
CORRADE_VERIFY(!std::is_copy_assignable<SubpassDescription>{});
}
void RenderPassTest::subpassDescriptionConstructMove() {
@ -795,10 +795,10 @@ void RenderPassTest::subpassDependencyConstructNoInit() {
new(&dependency) SubpassDependency{NoInit};
CORRADE_COMPARE(dependency->sType, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
CORRADE_VERIFY((std::is_nothrow_constructible<SubpassDependency, NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<SubpassDependency, NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoInitT, SubpassDependency>::value));
CORRADE_VERIFY(!std::is_convertible<NoInitT, SubpassDependency>::value);
}
template<class From, class To> void RenderPassTest::subpassDependencyConstructFromVk() {
@ -876,10 +876,10 @@ void RenderPassTest::createInfoConstructNoInit() {
new(&info) RenderPassCreateInfo{NoInit};
CORRADE_COMPARE(info->sType, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
CORRADE_VERIFY((std::is_nothrow_constructible<RenderPassCreateInfo, NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<RenderPassCreateInfo, NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoInitT, RenderPassCreateInfo>::value));
CORRADE_VERIFY(!std::is_convertible<NoInitT, RenderPassCreateInfo>::value);
}
void RenderPassTest::createInfoConstructAttachments() {
@ -1121,7 +1121,7 @@ void RenderPassTest::constructNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, RenderPass>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, RenderPass>::value);
}
void RenderPassTest::constructCopy() {
@ -1174,10 +1174,10 @@ void RenderPassTest::beginInfoConstructNoInit() {
new(&info) RenderPassBeginInfo{NoInit};
CORRADE_COMPARE(info->sType, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
CORRADE_VERIFY((std::is_nothrow_constructible<RenderPassBeginInfo, NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<RenderPassBeginInfo, NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoInitT, RenderPassBeginInfo>::value));
CORRADE_VERIFY(!std::is_convertible<NoInitT, RenderPassBeginInfo>::value);
}
void RenderPassTest::beginInfoConstructClears() {
@ -1206,8 +1206,8 @@ void RenderPassTest::beginInfoConstructFromVk() {
}
void RenderPassTest::beginInfoConstructCopy() {
CORRADE_VERIFY(!(std::is_copy_constructible<RenderPassBeginInfo>{}));
CORRADE_VERIFY(!(std::is_copy_assignable<RenderPassBeginInfo>{}));
CORRADE_VERIFY(!std::is_copy_constructible<RenderPassBeginInfo>{});
CORRADE_VERIFY(!std::is_copy_assignable<RenderPassBeginInfo>{});
}
void RenderPassTest::beginInfoConstructMove() {
@ -1244,10 +1244,10 @@ void RenderPassTest::subpassBeginInfoConstructNoInit() {
new(&info) SubpassBeginInfo{NoInit};
CORRADE_COMPARE(info->sType, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
CORRADE_VERIFY((std::is_nothrow_constructible<SubpassBeginInfo, NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<SubpassBeginInfo, NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoInitT, SubpassBeginInfo>::value));
CORRADE_VERIFY(!std::is_convertible<NoInitT, SubpassBeginInfo>::value);
}
void RenderPassTest::subpassBeginInfoConstructFromVk() {
@ -1269,10 +1269,10 @@ void RenderPassTest::subpassEndInfoConstructNoInit() {
new(&info) SubpassEndInfo{NoInit};
CORRADE_COMPARE(info->sType, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
CORRADE_VERIFY((std::is_nothrow_constructible<SubpassEndInfo, NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<SubpassEndInfo, NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoInitT, SubpassEndInfo>::value));
CORRADE_VERIFY(!std::is_convertible<NoInitT, SubpassEndInfo>::value);
}
void RenderPassTest::subpassEndInfoConstructFromVk() {

10
src/Magnum/Vk/Test/ShaderTest.cpp
Unescape View File

@ -218,10 +218,10 @@ void ShaderTest::createInfoConstructNoInit() {
/* The deleter should be zero-init'd and thus no function called on
destruction */
CORRADE_VERIFY((std::is_nothrow_constructible<ShaderCreateInfo, NoInitT>::value));
CORRADE_VERIFY(std::is_nothrow_constructible<ShaderCreateInfo, NoInitT>::value);
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoInitT, ShaderCreateInfo>::value));
CORRADE_VERIFY(!std::is_convertible<NoInitT, ShaderCreateInfo>::value);
}
void ShaderTest::createInfoConstructFromVk() {
@ -287,12 +287,12 @@ void ShaderTest::constructNoCreate() {
}
/* Implicit construction is not allowed */
CORRADE_VERIFY(!(std::is_convertible<NoCreateT, Shader>::value));
CORRADE_VERIFY(!std::is_convertible<NoCreateT, Shader>::value);
}
void ShaderTest::constructCopy() {
CORRADE_VERIFY(!(std::is_constructible<Shader, const Shader&>{}));
CORRADE_VERIFY(!(std::is_assignable<Shader, const Shader&>{}));
CORRADE_VERIFY(!std::is_constructible<Shader, const Shader&>{});
CORRADE_VERIFY(!std::is_assignable<Shader, const Shader&>{});
}
}}}}

Write Preview
Loading…
Cancel
Save