Test: use shorter std::is_copy_{constructible,assignable} everywhere.

I wonder why I didn't do this from the beginning, back in 2010 or so.

src/Magnum/Animation/Test/PlayerTest.cpp

@@ -255,8 +255,8 @@ void PlayerTest::constructChrono() {
 }
 
 void PlayerTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<Player<Float>, const Player<Float>&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<Player<Float>, const Player<Float>&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<Player<Float>>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<Player<Float>&>{});
 }
 
 void PlayerTest::constructMove() {

src/Magnum/Audio/Test/ContextTest.cpp

@@ -62,10 +62,10 @@ void ContextTest::constructNoCreate() {
 
 void ContextTest::constructCopyMove() {
     /* Only move-construction allowed */
-    CORRADE_VERIFY(!(std::is_constructible<Context, const Context&>{}));
-    CORRADE_VERIFY((std::is_constructible<Context, Context&&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<Context, const Context&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<Context, Context&&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<Context>{});
+    CORRADE_VERIFY(std::is_move_constructible<Context>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<Context>{});
+    CORRADE_VERIFY(!std::is_move_assignable<Context>{});
 }
 
 void ContextTest::extensions() {

src/Magnum/DebugTools/Test/FrameProfilerTest.cpp

@@ -671,8 +671,8 @@ void FrameProfilerTest::reSetup() {
 }
 
 void FrameProfilerTest::copy() {
-    CORRADE_VERIFY(!(std::is_constructible<FrameProfiler, const FrameProfiler&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<FrameProfiler, const FrameProfiler&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<FrameProfiler>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<FrameProfiler>{});
 }
 
 void FrameProfilerTest::move() {

src/Magnum/GL/Test/AbstractShaderProgramTest.cpp

@@ -57,8 +57,8 @@ void AbstractShaderProgramTest::constructNoCreate() {
 void AbstractShaderProgramTest::constructCopy() {
     class DummyShader: public AbstractShaderProgram {};
 
-    CORRADE_VERIFY(!(std::is_constructible<DummyShader, const DummyShader&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<DummyShader, const DummyShader&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<DummyShader>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<DummyShader>{});
 }
 
 }}}}

src/Magnum/GL/Test/BufferImageTest.cpp

@@ -67,13 +67,13 @@ void BufferImageTest::constructNoCreateCompressed() {
 }
 
 void BufferImageTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<BufferImage2D, const BufferImage2D&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<BufferImage2D, const BufferImage2D&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<BufferImage2D>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<BufferImage2D>{});
 }
 
 void BufferImageTest::constructCopyCompressed() {
-    CORRADE_VERIFY(!(std::is_constructible<CompressedBufferImage2D, const CompressedBufferImage2D&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<CompressedBufferImage2D, const CompressedBufferImage2D&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<CompressedBufferImage2D>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<CompressedBufferImage2D>{});
 }
 
 }}}}

src/Magnum/GL/Test/BufferTest.cpp

@@ -66,8 +66,8 @@ void BufferTest::constructNoCreate() {
 }
 
 void BufferTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<Buffer, const Buffer&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<Buffer, const Buffer&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<Buffer>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<Buffer>{});
 }
 
 void BufferTest::debugTargetHint() {

src/Magnum/GL/Test/BufferTextureTest.cpp

@@ -52,8 +52,8 @@ void BufferTextureTest::constructNoCreate() {
 }
 
 void BufferTextureTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<BufferTexture, const BufferTexture&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<BufferTexture, const BufferTexture&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<BufferTexture>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<BufferTexture>{});
 }
 
 }}}}

src/Magnum/GL/Test/ContextTest.cpp

@@ -85,10 +85,10 @@ void ContextTest::constructNoCreate() {
 
 void ContextTest::constructCopyMove() {
     /* Only move-construction allowed */
-    CORRADE_VERIFY(!(std::is_constructible<Context, const Context&>{}));
-    CORRADE_VERIFY((std::is_constructible<Context, Context&&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<Context, const Context&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<Context, Context&&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<Context>{});
+    CORRADE_VERIFY(std::is_move_constructible<Context>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<Context>{});
+    CORRADE_VERIFY(!std::is_move_assignable<Context>{});
 
     CORRADE_VERIFY(std::is_nothrow_move_constructible<Context>::value);
     /* No move assignment */

src/Magnum/GL/Test/CubeMapTextureArrayTest.cpp

@@ -52,8 +52,8 @@ void CubeMapTextureArrayTest::constructNoCreate() {
 }
 
 void CubeMapTextureArrayTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<CubeMapTextureArray, const CubeMapTextureArray&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<CubeMapTextureArray, const CubeMapTextureArray&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<CubeMapTextureArray>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<CubeMapTextureArray>{});
 }
 
 }}}}

src/Magnum/GL/Test/CubeMapTextureTest.cpp

@@ -52,8 +52,8 @@ void CubeMapTextureTest::constructNoCreate() {
 }
 
 void CubeMapTextureTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<CubeMapTexture, const CubeMapTexture&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<CubeMapTexture, const CubeMapTexture&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<CubeMapTexture>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<CubeMapTexture>{});
 }
 
 }}}}

src/Magnum/GL/Test/FramebufferTest.cpp

@@ -58,8 +58,8 @@ void FramebufferTest::constructNoCreate() {
 }
 
 void FramebufferTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<Framebuffer, const Framebuffer&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<Framebuffer, const Framebuffer&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<Framebuffer>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<Framebuffer>{});
 }
 
 void FramebufferTest::debugStatus() {

src/Magnum/GL/Test/MeshTest.cpp

@@ -105,8 +105,8 @@ void MeshTest::constructViewNoCreate() {
 }
 
 void MeshTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<Mesh, const Mesh&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<Mesh, const Mesh&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<Mesh>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<Mesh>{});
 }
 
 void MeshTest::constructMoveNoCreate() {

src/Magnum/GL/Test/MultisampleTextureTest.cpp

@@ -68,13 +68,13 @@ void MultisampleTextureTest::construct2DArrayNoCreate() {
 }
 
 void MultisampleTextureTest::constructCopy2D() {
-    CORRADE_VERIFY(!(std::is_constructible<MultisampleTexture2D, const MultisampleTexture2D&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<MultisampleTexture2D, const MultisampleTexture2D&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<MultisampleTexture2D>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<MultisampleTexture2D>{});
 }
 
 void MultisampleTextureTest::constructCopy2DArray() {
-    CORRADE_VERIFY(!(std::is_constructible<MultisampleTexture2DArray, const MultisampleTexture2DArray&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<MultisampleTexture2DArray, const MultisampleTexture2DArray&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<MultisampleTexture2DArray>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<MultisampleTexture2DArray>{});
 }
 
 }}}}

src/Magnum/GL/Test/PipelineStatisticsQueryTest.cpp

@@ -52,8 +52,8 @@ void PipelineStatisticsQueryTest::constructNoCreate() {
 }
 
 void PipelineStatisticsQueryTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<PipelineStatisticsQuery, const PipelineStatisticsQuery&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<PipelineStatisticsQuery, const PipelineStatisticsQuery&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<PipelineStatisticsQuery>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<PipelineStatisticsQuery>{});
 }
 
 }}}}

src/Magnum/GL/Test/PrimitiveQueryTest.cpp

@@ -52,8 +52,8 @@ void PrimitiveQueryTest::constructNoCreate() {
 }
 
 void PrimitiveQueryTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<PrimitiveQuery, const PrimitiveQuery&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<PrimitiveQuery, const PrimitiveQuery&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<PrimitiveQuery>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<PrimitiveQuery>{});
 }
 
 }}}}

src/Magnum/GL/Test/RectangleTextureTest.cpp

@@ -52,8 +52,8 @@ void RectangleTextureTest::constructNoCreate() {
 }
 
 void RectangleTextureTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<RectangleTexture, const RectangleTexture&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<RectangleTexture, const RectangleTexture&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<RectangleTexture>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<RectangleTexture>{});
 }
 
 }}}}

src/Magnum/GL/Test/RenderbufferTest.cpp

@@ -52,8 +52,8 @@ void RenderbufferTest::constructNoCreate() {
 }
 
 void RenderbufferTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<Renderbuffer, const Renderbuffer&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<Renderbuffer, const Renderbuffer&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<Renderbuffer>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<Renderbuffer>{});
 }
 
 }}}}

src/Magnum/GL/Test/SampleQueryTest.cpp

@@ -52,8 +52,8 @@ void SampleQueryTest::constructNoCreate() {
 }
 
 void SampleQueryTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<SampleQuery, const SampleQuery&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<SampleQuery, const SampleQuery&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<SampleQuery>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<SampleQuery>{});
 }
 
 }}}}

src/Magnum/GL/Test/ShaderTest.cpp

@@ -56,8 +56,8 @@ void ShaderTest::constructNoCreate() {
 }
 
 void ShaderTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<Shader, const Shader&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<Shader, const Shader&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<Shader>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<Shader>{});
 }
 
 void ShaderTest::debugType() {

src/Magnum/GL/Test/TextureArrayTest.cpp

@@ -80,14 +80,14 @@ void TextureArrayTest::construct2DNoCreate() {
 
 #ifndef MAGNUM_TARGET_GLES
 void TextureArrayTest::constructCopy1D() {
-    CORRADE_VERIFY(!(std::is_constructible<Texture1DArray, const Texture1DArray&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<Texture1DArray, const Texture1DArray&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<Texture1DArray>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<Texture1DArray>{});
 }
 #endif
 
 void TextureArrayTest::constructCopy2D() {
-    CORRADE_VERIFY(!(std::is_constructible<Texture2DArray, const Texture2DArray&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<Texture2DArray, const Texture2DArray&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<Texture2DArray>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<Texture2DArray>{});
 }
 
 }}}}

src/Magnum/GL/Test/TextureTest.cpp

@@ -105,20 +105,20 @@ void TextureTest::construct3DNoCreate() {
 
 #ifndef MAGNUM_TARGET_GLES
 void TextureTest::constructCopy1D() {
-    CORRADE_VERIFY(!(std::is_constructible<Texture1D, const Texture1D&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<Texture1D, const Texture1D&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<Texture1D>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<Texture1D>{});
 }
 #endif
 
 void TextureTest::constructCopy2D() {
-    CORRADE_VERIFY(!(std::is_constructible<Texture2D, const Texture2D&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<Texture2D, const Texture2D&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<Texture2D>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<Texture2D>{});
 }
 
 #if !(defined(MAGNUM_TARGET_WEBGL) && defined(MAGNUM_TARGET_GLES2))
 void TextureTest::constructCopy3D() {
-    CORRADE_VERIFY(!(std::is_constructible<Texture3D, const Texture3D&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<Texture3D, const Texture3D&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<Texture3D>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<Texture3D>{});
 }
 #endif
 

src/Magnum/GL/Test/TimeQueryTest.cpp

@@ -52,8 +52,8 @@ void TimeQueryTest::constructNoCreate() {
 }
 
 void TimeQueryTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<TimeQuery, const TimeQuery&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<TimeQuery, const TimeQuery&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<TimeQuery>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<TimeQuery>{});
 }
 
 }}}}

src/Magnum/GL/Test/TransformFeedbackTest.cpp

@@ -52,8 +52,8 @@ void TransformFeedbackTest::constructNoCreate() {
 }
 
 void TransformFeedbackTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<TransformFeedback, const TransformFeedback&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<TransformFeedback, const TransformFeedback&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<TransformFeedback>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<TransformFeedback>{});
 }
 
 }}}}

src/Magnum/Shaders/Test/DistanceFieldVectorTest.cpp

@@ -66,11 +66,8 @@ template<UnsignedInt dimensions> void DistanceFieldVectorTest::constructNoCreate
 template<UnsignedInt dimensions> void DistanceFieldVectorTest::constructCopy() {
     setTestCaseTemplateName(std::to_string(dimensions));
 
-    CORRADE_VERIFY((std::is_constructible<DistanceFieldVector<dimensions>, DistanceFieldVector<dimensions>&&>{}));
-    CORRADE_VERIFY(!(std::is_constructible<DistanceFieldVector<dimensions>, const DistanceFieldVector<dimensions>&>{}));
-
-    CORRADE_VERIFY((std::is_assignable<DistanceFieldVector<dimensions>, DistanceFieldVector<dimensions>&&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<DistanceFieldVector<dimensions>, const DistanceFieldVector<dimensions>&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<DistanceFieldVector<dimensions>>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<DistanceFieldVector<dimensions>>{});
 }
 
 void DistanceFieldVectorTest::debugFlag() {

src/Magnum/Shaders/Test/FlatTest.cpp

@@ -68,11 +68,8 @@ template<UnsignedInt dimensions> void FlatTest::constructNoCreate() {
 template<UnsignedInt dimensions> void FlatTest::constructCopy() {
     setTestCaseTemplateName(std::to_string(dimensions));
 
-    CORRADE_VERIFY((std::is_constructible<Flat<dimensions>, Flat<dimensions>&&>{}));
-    CORRADE_VERIFY(!(std::is_constructible<Flat<dimensions>, const Flat<dimensions>&>{}));
-
-    CORRADE_VERIFY((std::is_assignable<Flat<dimensions>, Flat<dimensions>&&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<Flat<dimensions>, const Flat<dimensions>&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<Flat<dimensions>>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<Flat<dimensions>>{});
 }
 
 void FlatTest::debugFlag() {

src/Magnum/Shaders/Test/MeshVisualizerTest.cpp

@@ -82,19 +82,13 @@ void MeshVisualizerTest::constructNoCreate3D() {
 }
 
 void MeshVisualizerTest::constructCopy2D() {
-    CORRADE_VERIFY((std::is_constructible<MeshVisualizer2D, MeshVisualizer2D&&>{}));
-    CORRADE_VERIFY(!(std::is_constructible<MeshVisualizer2D, const MeshVisualizer2D&>{}));
-
-    CORRADE_VERIFY((std::is_assignable<MeshVisualizer2D, MeshVisualizer2D&&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<MeshVisualizer2D, const MeshVisualizer2D&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<MeshVisualizer2D>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<MeshVisualizer2D>{});
 }
 
 void MeshVisualizerTest::constructCopy3D() {
-    CORRADE_VERIFY((std::is_constructible<MeshVisualizer3D, MeshVisualizer3D&&>{}));
-    CORRADE_VERIFY(!(std::is_constructible<MeshVisualizer3D, const MeshVisualizer3D&>{}));
-
-    CORRADE_VERIFY((std::is_assignable<MeshVisualizer3D, MeshVisualizer3D&&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<MeshVisualizer3D, const MeshVisualizer3D&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<MeshVisualizer3D>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<MeshVisualizer3D>{});
 }
 
 void MeshVisualizerTest::vertexIndexSameAsObjectId() {

src/Magnum/Shaders/Test/PhongTest.cpp

@@ -61,8 +61,8 @@ void PhongTest::constructNoCreate() {
 }
 
 void PhongTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<Phong, const Phong&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<Phong, const Phong&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<Phong>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<Phong>{});
 }
 
 void PhongTest::debugFlag() {

src/Magnum/Shaders/Test/VectorTest.cpp

@@ -66,11 +66,8 @@ template<UnsignedInt dimensions> void VectorTest::constructNoCreate() {
 template<UnsignedInt dimensions> void VectorTest::constructCopy() {
     setTestCaseTemplateName(std::to_string(dimensions));
 
-    CORRADE_VERIFY((std::is_constructible<Vector<dimensions>, Vector<dimensions>&&>{}));
-    CORRADE_VERIFY(!(std::is_constructible<Vector<dimensions>, const Vector<dimensions>&>{}));
-
-    CORRADE_VERIFY((std::is_assignable<Vector<dimensions>, Vector<dimensions>&&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<Vector<dimensions>, const Vector<dimensions>&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<Vector<dimensions>>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<Vector<dimensions>>{});
 }
 
 void VectorTest::debugFlag() {

src/Magnum/Shaders/Test/VertexColorTest.cpp

@@ -59,11 +59,8 @@ template<UnsignedInt dimensions> void VertexColorTest::constructNoCreate() {
 template<UnsignedInt dimensions> void VertexColorTest::constructCopy() {
     setTestCaseTemplateName(std::to_string(dimensions));
 
-    CORRADE_VERIFY((std::is_constructible<VertexColor<dimensions>, VertexColor<dimensions>&&>{}));
-    CORRADE_VERIFY(!(std::is_constructible<VertexColor<dimensions>, const VertexColor<dimensions>&>{}));
-
-    CORRADE_VERIFY((std::is_assignable<VertexColor<dimensions>, VertexColor<dimensions>&&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<VertexColor<dimensions>, const VertexColor<dimensions>&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<VertexColor<dimensions>>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<VertexColor<dimensions>>{});
 }
 
 }}}}

src/Magnum/Test/ImageTest.cpp

@@ -454,13 +454,13 @@ void ImageTest::constructCompressedInvalidSize() {
 }
 
 void ImageTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<Image2D, const Image2D&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<Image2D, const Image2D&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<Image2D>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<Image2D>{});
 }
 
 void ImageTest::constructCopyCompressed() {
-    CORRADE_VERIFY(!(std::is_constructible<CompressedImage2D, const CompressedImage2D&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<CompressedImage2D, const CompressedImage2D&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<CompressedImage2D>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<CompressedImage2D>{});
 }
 
 void ImageTest::constructMoveGeneric() {

src/Magnum/Trade/Test/AnimationDataTest.cpp

@@ -422,8 +422,8 @@ void AnimationDataTest::constructImplicitDurationNotOwnedFlagOwned() {
 }
 
 void AnimationDataTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<AnimationData, const AnimationData&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<AnimationData, const AnimationData&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<AnimationData>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<AnimationData>{});
 }
 
 void AnimationDataTest::constructMove() {

src/Magnum/Trade/Test/CameraDataTest.cpp

@@ -131,8 +131,8 @@ void CameraDataTest::construct2DNearFar() {
 }
 
 void CameraDataTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<CameraData, const CameraData&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<CameraData, const CameraData&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<CameraData>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<CameraData>{});
 }
 
 void CameraDataTest::constructMove() {

src/Magnum/Trade/Test/ImageDataTest.cpp

@@ -669,8 +669,8 @@ void ImageDataTest::constructCompressedInvalidSize() {
 }
 
 void ImageDataTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<ImageData2D, const ImageData2D&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<ImageData2D, const ImageData2D&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<ImageData2D>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<ImageData2D>{});
 }
 
 void ImageDataTest::constructMoveGeneric() {

src/Magnum/Trade/Test/LightDataTest.cpp

@@ -397,8 +397,8 @@ void LightDataTest::constructInvalid() {
 }
 
 void LightDataTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<LightData, const LightData&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<LightData, const LightData&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<LightData>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<LightData>{});
 }
 
 void LightDataTest::constructMove() {

src/Magnum/Trade/Test/MaterialDataTest.cpp

@@ -1582,8 +1582,8 @@ void MaterialDataTest::constructNonOwnedLayersOffsetOutOfBounds() {
 }
 
 void MaterialDataTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<MaterialData, const MaterialData&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<MaterialData, const MaterialData&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<MaterialData>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<MaterialData>{});
 }
 
 void MaterialDataTest::constructMove() {

src/Magnum/Trade/Test/MeshData2DTest.cpp

@@ -183,8 +183,8 @@ void MeshData2DTest::constructNoColors() {
 }
 
 void MeshData2DTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<MeshData2D, const MeshData2D&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<MeshData2D, const MeshData2D&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<MeshData2D>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<MeshData2D>{});
 }
 
 void MeshData2DTest::constructMove() {

src/Magnum/Trade/Test/MeshData3DTest.cpp

@@ -211,8 +211,8 @@ void MeshData3DTest::constructNoColors() {
 }
 
 void MeshData3DTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<MeshData3D, const MeshData3D&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<MeshData3D, const MeshData3D&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<MeshData3D>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<MeshData3D>{});
 }
 
 void MeshData3DTest::constructMove() {

src/Magnum/Trade/Test/MeshDataTest.cpp

@@ -1808,8 +1808,8 @@ void MeshDataTest::constructInvalidAttributeData() {
 }
 
 void MeshDataTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<MeshData, const MeshData&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<MeshData, const MeshData&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<MeshData>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<MeshData>{});
 }
 
 void MeshDataTest::constructMove() {

src/Magnum/Trade/Test/ObjectData2DTest.cpp

@@ -147,10 +147,10 @@ void ObjectData2DTest::constructCamera() {
 }
 
 void ObjectData2DTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<ObjectData2D, const ObjectData2D&>{}));
-    CORRADE_VERIFY(!(std::is_constructible<MeshObjectData2D, const MeshObjectData2D&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<ObjectData2D, const ObjectData2D&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<MeshObjectData2D, const MeshObjectData2D&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<ObjectData2D>{});
+    CORRADE_VERIFY(!std::is_copy_constructible<MeshObjectData2D>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<ObjectData2D>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<MeshObjectData2D>{});
 }
 
 void ObjectData2DTest::constructMoveTransformations() {

src/Magnum/Trade/Test/ObjectData3DTest.cpp

@@ -161,10 +161,10 @@ void ObjectData3DTest::constructLight() {
 }
 
 void ObjectData3DTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<ObjectData3D, const ObjectData3D&>{}));
-    CORRADE_VERIFY(!(std::is_constructible<MeshObjectData3D, const MeshObjectData3D&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<ObjectData3D, const ObjectData3D&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<MeshObjectData3D, const MeshObjectData3D&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<ObjectData3D>{});
+    CORRADE_VERIFY(!std::is_copy_constructible<MeshObjectData3D>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<ObjectData3D>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<MeshObjectData3D>{});
 }
 
 void ObjectData3DTest::constructMoveTransformations() {

src/Magnum/Trade/Test/SceneDataTest.cpp

@@ -54,8 +54,8 @@ void SceneDataTest::construct() {
 }
 
 void SceneDataTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<SceneData, const SceneData&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<SceneData, const SceneData&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<SceneData>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<SceneData>{});
 }
 
 void SceneDataTest::constructMove() {

src/Magnum/Trade/Test/SkinDataTest.cpp

@@ -97,8 +97,8 @@ void SkinDataTest::constructDifferentSize() {
 }
 
 void SkinDataTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<SkinData3D, const SkinData3D&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<SkinData3D, const SkinData3D&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<SkinData3D>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<SkinData3D>{});
 }
 
 void SkinDataTest::constructMove() {

src/Magnum/Trade/Test/TextureDataTest.cpp

@@ -70,8 +70,8 @@ void TextureDataTest::construct() {
 }
 
 void TextureDataTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<TextureData, const TextureData&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<TextureData, const TextureData&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<TextureData>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<TextureData>{});
 }
 
 void TextureDataTest::constructMove() {

src/Magnum/Vk/Test/BufferTest.cpp

@@ -95,8 +95,8 @@ void BufferTest::constructNoCreate() {
 }
 
 void BufferTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<Buffer, const Buffer&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<Buffer, const Buffer&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<Buffer>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<Buffer>{});
 }
 
 void BufferTest::dedicatedMemoryNotDedicated() {

src/Magnum/Vk/Test/CommandBufferTest.cpp

@@ -53,8 +53,8 @@ void CommandBufferTest::constructNoCreate() {
 }
 
 void CommandBufferTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<CommandBuffer, const CommandBuffer&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<CommandBuffer, const CommandBuffer&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<CommandBuffer>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<CommandBuffer>{});
 }
 
 }}}}

src/Magnum/Vk/Test/CommandPoolTest.cpp

@@ -87,8 +87,8 @@ void CommandPoolTest::constructNoCreate() {
 }
 
 void CommandPoolTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<CommandPool, const CommandPool&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<CommandPool, const CommandPool&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<CommandPool>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<CommandPool>{});
 }
 
 }}}}

src/Magnum/Vk/Test/DevicePropertiesTest.cpp

@@ -68,8 +68,8 @@ void DevicePropertiesTest::constructNoCreate() {
 }
 
 void DevicePropertiesTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<DeviceProperties, const DeviceProperties&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<DeviceProperties, const DeviceProperties&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<DeviceProperties>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<DeviceProperties>{});
 }
 
 void DevicePropertiesTest::debugDeviceType() {

src/Magnum/Vk/Test/DeviceTest.cpp

@@ -81,8 +81,8 @@ void DeviceTest::constructNoCreate() {
 }
 
 void DeviceTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<Device, const Device&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<Device, const Device&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<Device>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<Device>{});
 }
 
 }}}}

src/Magnum/Vk/Test/ExtensionPropertiesTest.cpp

@@ -68,13 +68,13 @@ void ExtensionPropertiesTest::constructInstanceNoCreate() {
 }
 
 void ExtensionPropertiesTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<ExtensionProperties, const ExtensionProperties&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<ExtensionProperties, const ExtensionProperties&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<ExtensionProperties>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<ExtensionProperties>{});
 }
 
 void ExtensionPropertiesTest::constructInstanceCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<InstanceExtensionProperties, const InstanceExtensionProperties&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<InstanceExtensionProperties, const InstanceExtensionProperties&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<InstanceExtensionProperties>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<InstanceExtensionProperties>{});
 }
 
 }}}}

src/Magnum/Vk/Test/ImageTest.cpp

@@ -201,8 +201,8 @@ void ImageTest::constructNoCreate() {
 }
 
 void ImageTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<Image, const Image&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<Image, const Image&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<Image>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<Image>{});
 }
 
 void ImageTest::dedicatedMemoryNotDedicated() {

src/Magnum/Vk/Test/InstanceTest.cpp

@@ -85,8 +85,8 @@ void InstanceTest::constructNoCreate() {
 }
 
 void InstanceTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<Instance, const Instance&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<Instance, const Instance&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<Instance>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<Instance>{});
 }
 
 }}}}

src/Magnum/Vk/Test/LayerPropertiesTest.cpp

@@ -52,8 +52,8 @@ void LayerPropertiesTest::constructNoCreate() {
 }
 
 void LayerPropertiesTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<LayerProperties, const LayerProperties&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<LayerProperties, const LayerProperties&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<LayerProperties>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<LayerProperties>{});
 }
 
 }}}}

src/Magnum/Vk/Test/MemoryTest.cpp

@@ -156,8 +156,8 @@ void MemoryTest::constructNoCreate() {
 }
 
 void MemoryTest::constructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<Memory, const Memory&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<Memory, const Memory&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<Memory>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<Memory>{});
 }
 
 void MemoryTest::debugMemoryFlag() {

src/Magnum/Vk/Test/ShaderTest.cpp

@@ -120,8 +120,8 @@ void ShaderTest::createInfoConstructFromVk() {
 }
 
 void ShaderTest::createInfoConstructCopy() {
-    CORRADE_VERIFY(!(std::is_constructible<ShaderCreateInfo, const ShaderCreateInfo&>{}));
-    CORRADE_VERIFY(!(std::is_assignable<ShaderCreateInfo, const ShaderCreateInfo&>{}));
+    CORRADE_VERIFY(!std::is_copy_constructible<ShaderCreateInfo>{});
+    CORRADE_VERIFY(!std::is_copy_assignable<ShaderCreateInfo>{});
 }
 
 void ShaderTest::createInfoConstructMove() {