diff --git a/src/Magnum/Animation/Test/TrackViewTest.cpp b/src/Magnum/Animation/Test/TrackViewTest.cpp
index b1277d754..30b98632c 100644
--- a/src/Magnum/Animation/Test/TrackViewTest.cpp
+++ b/src/Magnum/Animation/Test/TrackViewTest.cpp
@@ -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[]{
diff --git a/src/Magnum/GL/Test/AbstractShaderProgramTest.cpp b/src/Magnum/GL/Test/AbstractShaderProgramTest.cpp
index db179e611..76a7e0f50 100644
--- a/src/Magnum/GL/Test/AbstractShaderProgramTest.cpp
+++ b/src/Magnum/GL/Test/AbstractShaderProgramTest.cpp
@@ -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() {
diff --git a/src/Magnum/GL/Test/AttributeTest.cpp b/src/Magnum/GL/Test/AttributeTest.cpp
index 31525772f..b236199a6 100644
--- a/src/Magnum/GL/Test/AttributeTest.cpp
+++ b/src/Magnum/GL/Test/AttributeTest.cpp
@@ -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 */
diff --git a/src/Magnum/GL/Test/BufferImageTest.cpp b/src/Magnum/GL/Test/BufferImageTest.cpp
index acc15aca2..40f01dd2f 100644
--- a/src/Magnum/GL/Test/BufferImageTest.cpp
+++ b/src/Magnum/GL/Test/BufferImageTest.cpp
@@ -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() {
diff --git a/src/Magnum/GL/Test/BufferTest.cpp b/src/Magnum/GL/Test/BufferTest.cpp
index 205de7645..498d5f689 100644
--- a/src/Magnum/GL/Test/BufferTest.cpp
+++ b/src/Magnum/GL/Test/BufferTest.cpp
@@ -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() {
diff --git a/src/Magnum/GL/Test/BufferTextureTest.cpp b/src/Magnum/GL/Test/BufferTextureTest.cpp
index a29c71a11..8ceded2a2 100644
--- a/src/Magnum/GL/Test/BufferTextureTest.cpp
+++ b/src/Magnum/GL/Test/BufferTextureTest.cpp
@@ -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() {
diff --git a/src/Magnum/GL/Test/ContextTest.cpp b/src/Magnum/GL/Test/ContextTest.cpp
index 01fb41a4e..afcba1fff 100644
--- a/src/Magnum/GL/Test/ContextTest.cpp
+++ b/src/Magnum/GL/Test/ContextTest.cpp
@@ -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() {
diff --git a/src/Magnum/GL/Test/CubeMapTextureArrayTest.cpp b/src/Magnum/GL/Test/CubeMapTextureArrayTest.cpp
index 9ef75fb4f..1500a7fa2 100644
--- a/src/Magnum/GL/Test/CubeMapTextureArrayTest.cpp
+++ b/src/Magnum/GL/Test/CubeMapTextureArrayTest.cpp
@@ -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() {
diff --git a/src/Magnum/GL/Test/CubeMapTextureTest.cpp b/src/Magnum/GL/Test/CubeMapTextureTest.cpp
index c908be1c9..50e36faf3 100644
--- a/src/Magnum/GL/Test/CubeMapTextureTest.cpp
+++ b/src/Magnum/GL/Test/CubeMapTextureTest.cpp
@@ -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() {
diff --git a/src/Magnum/GL/Test/FramebufferTest.cpp b/src/Magnum/GL/Test/FramebufferTest.cpp
index 2411e3a37..ed0944d3c 100644
--- a/src/Magnum/GL/Test/FramebufferTest.cpp
+++ b/src/Magnum/GL/Test/FramebufferTest.cpp
@@ -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() {
diff --git a/src/Magnum/GL/Test/MeshTest.cpp b/src/Magnum/GL/Test/MeshTest.cpp
index 4b8d43cd4..b2697483d 100644
--- a/src/Magnum/GL/Test/MeshTest.cpp
+++ b/src/Magnum/GL/Test/MeshTest.cpp
@@ -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() {
diff --git a/src/Magnum/GL/Test/MultisampleTextureTest.cpp b/src/Magnum/GL/Test/MultisampleTextureTest.cpp
index ef4a9e637..c7b83a915 100644
--- a/src/Magnum/GL/Test/MultisampleTextureTest.cpp
+++ b/src/Magnum/GL/Test/MultisampleTextureTest.cpp
@@ -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() {
diff --git a/src/Magnum/GL/Test/PipelineStatisticsQueryTest.cpp b/src/Magnum/GL/Test/PipelineStatisticsQueryTest.cpp
index fb81583d9..b5e4bdbfe 100644
--- a/src/Magnum/GL/Test/PipelineStatisticsQueryTest.cpp
+++ b/src/Magnum/GL/Test/PipelineStatisticsQueryTest.cpp
@@ -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() {
diff --git a/src/Magnum/GL/Test/PrimitiveQueryTest.cpp b/src/Magnum/GL/Test/PrimitiveQueryTest.cpp
index b8049c2bd..daaa85c14 100644
--- a/src/Magnum/GL/Test/PrimitiveQueryTest.cpp
+++ b/src/Magnum/GL/Test/PrimitiveQueryTest.cpp
@@ -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() {
diff --git a/src/Magnum/GL/Test/RectangleTextureTest.cpp b/src/Magnum/GL/Test/RectangleTextureTest.cpp
index 0b2c1d155..3a6177938 100644
--- a/src/Magnum/GL/Test/RectangleTextureTest.cpp
+++ b/src/Magnum/GL/Test/RectangleTextureTest.cpp
@@ -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() {
diff --git a/src/Magnum/GL/Test/RenderbufferTest.cpp b/src/Magnum/GL/Test/RenderbufferTest.cpp
index 8ab229101..0a0176d04 100644
--- a/src/Magnum/GL/Test/RenderbufferTest.cpp
+++ b/src/Magnum/GL/Test/RenderbufferTest.cpp
@@ -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() {
diff --git a/src/Magnum/GL/Test/SampleQueryTest.cpp b/src/Magnum/GL/Test/SampleQueryTest.cpp
index 9ec3e1434..a2d0340a7 100644
--- a/src/Magnum/GL/Test/SampleQueryTest.cpp
+++ b/src/Magnum/GL/Test/SampleQueryTest.cpp
@@ -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() {
diff --git a/src/Magnum/GL/Test/ShaderTest.cpp b/src/Magnum/GL/Test/ShaderTest.cpp
index bcfec7b86..51b78c89c 100644
--- a/src/Magnum/GL/Test/ShaderTest.cpp
+++ b/src/Magnum/GL/Test/ShaderTest.cpp
@@ -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() {
diff --git a/src/Magnum/GL/Test/TextureArrayTest.cpp b/src/Magnum/GL/Test/TextureArrayTest.cpp
index b1dc5a31b..6b8473e80 100644
--- a/src/Magnum/GL/Test/TextureArrayTest.cpp
+++ b/src/Magnum/GL/Test/TextureArrayTest.cpp
@@ -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
diff --git a/src/Magnum/GL/Test/TextureTest.cpp b/src/Magnum/GL/Test/TextureTest.cpp
index da740ba8a..102f124ba 100644
--- a/src/Magnum/GL/Test/TextureTest.cpp
+++ b/src/Magnum/GL/Test/TextureTest.cpp
@@ -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
 
diff --git a/src/Magnum/GL/Test/TimeQueryTest.cpp b/src/Magnum/GL/Test/TimeQueryTest.cpp
index 616591c2a..d62cb4885 100644
--- a/src/Magnum/GL/Test/TimeQueryTest.cpp
+++ b/src/Magnum/GL/Test/TimeQueryTest.cpp
@@ -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() {
diff --git a/src/Magnum/GL/Test/TransformFeedbackTest.cpp b/src/Magnum/GL/Test/TransformFeedbackTest.cpp
index d173514cd..b91d40c6b 100644
--- a/src/Magnum/GL/Test/TransformFeedbackTest.cpp
+++ b/src/Magnum/GL/Test/TransformFeedbackTest.cpp
@@ -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() {
diff --git a/src/Magnum/Math/Test/AngleTest.cpp b/src/Magnum/Math/Test/AngleTest.cpp
index 3463c7a50..2fce5c065 100644
--- a/src/Magnum/Math/Test/AngleTest.cpp
+++ b/src/Magnum/Math/Test/AngleTest.cpp
@@ -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);
 }
 
diff --git a/src/Magnum/Math/Test/BezierTest.cpp b/src/Magnum/Math/Test/BezierTest.cpp
index 21f74503e..f87346dc8 100644
--- a/src/Magnum/Math/Test/BezierTest.cpp
+++ b/src/Magnum/Math/Test/BezierTest.cpp
@@ -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() {
diff --git a/src/Magnum/Math/Test/BoolVectorTest.cpp b/src/Magnum/Math/Test/BoolVectorTest.cpp
index c04d1a5fc..36510bb0a 100644
--- a/src/Magnum/Math/Test/BoolVectorTest.cpp
+++ b/src/Magnum/Math/Test/BoolVectorTest.cpp
@@ -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() {
diff --git a/src/Magnum/Math/Test/ColorTest.cpp b/src/Magnum/Math/Test/ColorTest.cpp
index 0c7352cc5..1f5a74348 100644
--- a/src/Magnum/Math/Test/ColorTest.cpp
+++ b/src/Magnum/Math/Test/ColorTest.cpp
@@ -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() {
diff --git a/src/Magnum/Math/Test/ComplexTest.cpp b/src/Magnum/Math/Test/ComplexTest.cpp
index b327306ab..f6fe56efd 100644
--- a/src/Magnum/Math/Test/ComplexTest.cpp
+++ b/src/Magnum/Math/Test/ComplexTest.cpp
@@ -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() {
diff --git a/src/Magnum/Math/Test/CubicHermiteTest.cpp b/src/Magnum/Math/Test/CubicHermiteTest.cpp
index 0a7e9b2e9..fa0394f63 100644
--- a/src/Magnum/Math/Test/CubicHermiteTest.cpp
+++ b/src/Magnum/Math/Test/CubicHermiteTest.cpp
@@ -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() {
diff --git a/src/Magnum/Math/Test/DualComplexTest.cpp b/src/Magnum/Math/Test/DualComplexTest.cpp
index 152a176bf..7acf807d5 100644
--- a/src/Magnum/Math/Test/DualComplexTest.cpp
+++ b/src/Magnum/Math/Test/DualComplexTest.cpp
@@ -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() {
diff --git a/src/Magnum/Math/Test/DualQuaternionTest.cpp b/src/Magnum/Math/Test/DualQuaternionTest.cpp
index df936165c..95c941c5a 100644
--- a/src/Magnum/Math/Test/DualQuaternionTest.cpp
+++ b/src/Magnum/Math/Test/DualQuaternionTest.cpp
@@ -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() {
diff --git a/src/Magnum/Math/Test/DualTest.cpp b/src/Magnum/Math/Test/DualTest.cpp
index fb0683b0c..b289c6c6b 100644
--- a/src/Magnum/Math/Test/DualTest.cpp
+++ b/src/Magnum/Math/Test/DualTest.cpp
@@ -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() {
diff --git a/src/Magnum/Math/Test/FrustumTest.cpp b/src/Magnum/Math/Test/FrustumTest.cpp
index 6194f4ffb..e22e5ec7d 100644
--- a/src/Magnum/Math/Test/FrustumTest.cpp
+++ b/src/Magnum/Math/Test/FrustumTest.cpp
@@ -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() {
diff --git a/src/Magnum/Math/Test/FunctionsTest.cpp b/src/Magnum/Math/Test/FunctionsTest.cpp
index d8b9be6df..b4d67e73e 100644
--- a/src/Magnum/Math/Test/FunctionsTest.cpp
+++ b/src/Magnum/Math/Test/FunctionsTest.cpp
@@ -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);
diff --git a/src/Magnum/Math/Test/HalfTest.cpp b/src/Magnum/Math/Test/HalfTest.cpp
index 8225ed150..ce05e53ce 100644
--- a/src/Magnum/Math/Test/HalfTest.cpp
+++ b/src/Magnum/Math/Test/HalfTest.cpp
@@ -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() {
diff --git a/src/Magnum/Math/Test/Matrix3Test.cpp b/src/Magnum/Math/Test/Matrix3Test.cpp
index 4e4a196ff..47014d65a 100644
--- a/src/Magnum/Math/Test/Matrix3Test.cpp
+++ b/src/Magnum/Math/Test/Matrix3Test.cpp
@@ -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() {
diff --git a/src/Magnum/Math/Test/Matrix4Test.cpp b/src/Magnum/Math/Test/Matrix4Test.cpp
index 4a45d200f..63f01d3e3 100644
--- a/src/Magnum/Math/Test/Matrix4Test.cpp
+++ b/src/Magnum/Math/Test/Matrix4Test.cpp
@@ -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() {
diff --git a/src/Magnum/Math/Test/MatrixTest.cpp b/src/Magnum/Math/Test/MatrixTest.cpp
index e8169fa26..6964a3655 100644
--- a/src/Magnum/Math/Test/MatrixTest.cpp
+++ b/src/Magnum/Math/Test/MatrixTest.cpp
@@ -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() {
diff --git a/src/Magnum/Math/Test/QuaternionTest.cpp b/src/Magnum/Math/Test/QuaternionTest.cpp
index f93fd1630..b31792c68 100644
--- a/src/Magnum/Math/Test/QuaternionTest.cpp
+++ b/src/Magnum/Math/Test/QuaternionTest.cpp
@@ -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() {
diff --git a/src/Magnum/Math/Test/RangeTest.cpp b/src/Magnum/Math/Test/RangeTest.cpp
index e28a30e0e..d2b81823f 100644
--- a/src/Magnum/Math/Test/RangeTest.cpp
+++ b/src/Magnum/Math/Test/RangeTest.cpp
@@ -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() {
diff --git a/src/Magnum/Math/Test/RectangularMatrixTest.cpp b/src/Magnum/Math/Test/RectangularMatrixTest.cpp
index 5f5997f74..b91c4fd78 100644
--- a/src/Magnum/Math/Test/RectangularMatrixTest.cpp
+++ b/src/Magnum/Math/Test/RectangularMatrixTest.cpp
@@ -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() {
diff --git a/src/Magnum/Math/Test/TypeTraitsTest.cpp b/src/Magnum/Math/Test/TypeTraitsTest.cpp
index d657b5164..e9cab72e9 100644
--- a/src/Magnum/Math/Test/TypeTraitsTest.cpp
+++ b/src/Magnum/Math/Test/TypeTraitsTest.cpp
@@ -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() {
diff --git a/src/Magnum/Math/Test/UnitTest.cpp b/src/Magnum/Math/Test/UnitTest.cpp
index 1bf6a2739..d61b5925c 100644
--- a/src/Magnum/Math/Test/UnitTest.cpp
+++ b/src/Magnum/Math/Test/UnitTest.cpp
@@ -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() {
diff --git a/src/Magnum/Math/Test/Vector2Test.cpp b/src/Magnum/Math/Test/Vector2Test.cpp
index 2a44c495e..1865e16a1 100644
--- a/src/Magnum/Math/Test/Vector2Test.cpp
+++ b/src/Magnum/Math/Test/Vector2Test.cpp
@@ -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() {
diff --git a/src/Magnum/Math/Test/Vector3Test.cpp b/src/Magnum/Math/Test/Vector3Test.cpp
index 911ec82cf..51fd057b8 100644
--- a/src/Magnum/Math/Test/Vector3Test.cpp
+++ b/src/Magnum/Math/Test/Vector3Test.cpp
@@ -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() {
diff --git a/src/Magnum/Math/Test/Vector4Test.cpp b/src/Magnum/Math/Test/Vector4Test.cpp
index 1c04870c7..4fc6e503a 100644
--- a/src/Magnum/Math/Test/Vector4Test.cpp
+++ b/src/Magnum/Math/Test/Vector4Test.cpp
@@ -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() {
diff --git a/src/Magnum/Math/Test/VectorTest.cpp b/src/Magnum/Math/Test/VectorTest.cpp
index b1718cf77..509a6e34b 100644
--- a/src/Magnum/Math/Test/VectorTest.cpp
+++ b/src/Magnum/Math/Test/VectorTest.cpp
@@ -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() {
diff --git a/src/Magnum/Test/ArrayTest.cpp b/src/Magnum/Test/ArrayTest.cpp
index 38c8fb9e8..6b9970333 100644
--- a/src/Magnum/Test/ArrayTest.cpp
+++ b/src/Magnum/Test/ArrayTest.cpp
@@ -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() {
diff --git a/src/Magnum/Test/ImageViewTest.cpp b/src/Magnum/Test/ImageViewTest.cpp
index 1418de59e..92d737a57 100644
--- a/src/Magnum/Test/ImageViewTest.cpp
+++ b/src/Magnum/Test/ImageViewTest.cpp
@@ -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() {
diff --git a/src/Magnum/Test/TagsTest.cpp b/src/Magnum/Test/TagsTest.cpp
index 243c1bce6..a245fc0e7 100644
--- a/src/Magnum/Test/TagsTest.cpp
+++ b/src/Magnum/Test/TagsTest.cpp
@@ -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);
 }
 
 }}}
diff --git a/src/Magnum/Vk/Test/BufferTest.cpp b/src/Magnum/Vk/Test/BufferTest.cpp
index 673b902eb..1a95326b3 100644
--- a/src/Magnum/Vk/Test/BufferTest.cpp
+++ b/src/Magnum/Vk/Test/BufferTest.cpp
@@ -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() {
diff --git a/src/Magnum/Vk/Test/CommandBufferTest.cpp b/src/Magnum/Vk/Test/CommandBufferTest.cpp
index b7c83f229..ea76ae62b 100644
--- a/src/Magnum/Vk/Test/CommandBufferTest.cpp
+++ b/src/Magnum/Vk/Test/CommandBufferTest.cpp
@@ -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() {
diff --git a/src/Magnum/Vk/Test/CommandPoolTest.cpp b/src/Magnum/Vk/Test/CommandPoolTest.cpp
index 77db008ad..f2c22ef59 100644
--- a/src/Magnum/Vk/Test/CommandPoolTest.cpp
+++ b/src/Magnum/Vk/Test/CommandPoolTest.cpp
@@ -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() {
diff --git a/src/Magnum/Vk/Test/DevicePropertiesTest.cpp b/src/Magnum/Vk/Test/DevicePropertiesTest.cpp
index 8435a7a7a..383bb8741 100644
--- a/src/Magnum/Vk/Test/DevicePropertiesTest.cpp
+++ b/src/Magnum/Vk/Test/DevicePropertiesTest.cpp
@@ -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() {
diff --git a/src/Magnum/Vk/Test/DeviceTest.cpp b/src/Magnum/Vk/Test/DeviceTest.cpp
index e5f26e5db..71739b9d9 100644
--- a/src/Magnum/Vk/Test/DeviceTest.cpp
+++ b/src/Magnum/Vk/Test/DeviceTest.cpp
@@ -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() {
diff --git a/src/Magnum/Vk/Test/DeviceVkTest.cpp b/src/Magnum/Vk/Test/DeviceVkTest.cpp
index a1a67fbf7..1cf2e8787 100644
--- a/src/Magnum/Vk/Test/DeviceVkTest.cpp
+++ b/src/Magnum/Vk/Test/DeviceVkTest.cpp
@@ -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() {
diff --git a/src/Magnum/Vk/Test/ExtensionPropertiesTest.cpp b/src/Magnum/Vk/Test/ExtensionPropertiesTest.cpp
index 744d73f35..9a486d82b 100644
--- a/src/Magnum/Vk/Test/ExtensionPropertiesTest.cpp
+++ b/src/Magnum/Vk/Test/ExtensionPropertiesTest.cpp
@@ -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() {
diff --git a/src/Magnum/Vk/Test/ExtensionsTest.cpp b/src/Magnum/Vk/Test/ExtensionsTest.cpp
index 17639045f..f9b6cb3f5 100644
--- a/src/Magnum/Vk/Test/ExtensionsTest.cpp
+++ b/src/Magnum/Vk/Test/ExtensionsTest.cpp
@@ -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() {
diff --git a/src/Magnum/Vk/Test/FenceTest.cpp b/src/Magnum/Vk/Test/FenceTest.cpp
index 84462e46c..6f0942a89 100644
--- a/src/Magnum/Vk/Test/FenceTest.cpp
+++ b/src/Magnum/Vk/Test/FenceTest.cpp
@@ -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() {
diff --git a/src/Magnum/Vk/Test/FramebufferTest.cpp b/src/Magnum/Vk/Test/FramebufferTest.cpp
index 827ba4103..279fa3c42 100644
--- a/src/Magnum/Vk/Test/FramebufferTest.cpp
+++ b/src/Magnum/Vk/Test/FramebufferTest.cpp
@@ -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() {
diff --git a/src/Magnum/Vk/Test/ImageTest.cpp b/src/Magnum/Vk/Test/ImageTest.cpp
index 36d5894be..1013fcf0a 100644
--- a/src/Magnum/Vk/Test/ImageTest.cpp
+++ b/src/Magnum/Vk/Test/ImageTest.cpp
@@ -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() {
diff --git a/src/Magnum/Vk/Test/ImageViewTest.cpp b/src/Magnum/Vk/Test/ImageViewTest.cpp
index 9579788e9..257397cdc 100644
--- a/src/Magnum/Vk/Test/ImageViewTest.cpp
+++ b/src/Magnum/Vk/Test/ImageViewTest.cpp
@@ -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() {
diff --git a/src/Magnum/Vk/Test/InstanceTest.cpp b/src/Magnum/Vk/Test/InstanceTest.cpp
index 1289d1595..267b0947d 100644
--- a/src/Magnum/Vk/Test/InstanceTest.cpp
+++ b/src/Magnum/Vk/Test/InstanceTest.cpp
@@ -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() {
diff --git a/src/Magnum/Vk/Test/IntegrationTest.cpp b/src/Magnum/Vk/Test/IntegrationTest.cpp
index ae8aee2d6..65aa675b6 100644
--- a/src/Magnum/Vk/Test/IntegrationTest.cpp
+++ b/src/Magnum/Vk/Test/IntegrationTest.cpp
@@ -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() {
diff --git a/src/Magnum/Vk/Test/LayerPropertiesTest.cpp b/src/Magnum/Vk/Test/LayerPropertiesTest.cpp
index f48f16340..048e62e56 100644
--- a/src/Magnum/Vk/Test/LayerPropertiesTest.cpp
+++ b/src/Magnum/Vk/Test/LayerPropertiesTest.cpp
@@ -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() {
diff --git a/src/Magnum/Vk/Test/MemoryTest.cpp b/src/Magnum/Vk/Test/MemoryTest.cpp
index b6375a02f..d71553b85 100644
--- a/src/Magnum/Vk/Test/MemoryTest.cpp
+++ b/src/Magnum/Vk/Test/MemoryTest.cpp
@@ -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() {
diff --git a/src/Magnum/Vk/Test/MeshLayoutTest.cpp b/src/Magnum/Vk/Test/MeshLayoutTest.cpp
index 1520926d7..da4dc839a 100644
--- a/src/Magnum/Vk/Test/MeshLayoutTest.cpp
+++ b/src/Magnum/Vk/Test/MeshLayoutTest.cpp
@@ -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() {
diff --git a/src/Magnum/Vk/Test/PipelineLayoutTest.cpp b/src/Magnum/Vk/Test/PipelineLayoutTest.cpp
index bca890674..10f19d631 100644
--- a/src/Magnum/Vk/Test/PipelineLayoutTest.cpp
+++ b/src/Magnum/Vk/Test/PipelineLayoutTest.cpp
@@ -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() {
diff --git a/src/Magnum/Vk/Test/PipelineTest.cpp b/src/Magnum/Vk/Test/PipelineTest.cpp
index 23785bcac..d34971934 100644
--- a/src/Magnum/Vk/Test/PipelineTest.cpp
+++ b/src/Magnum/Vk/Test/PipelineTest.cpp
@@ -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() {
diff --git a/src/Magnum/Vk/Test/QueueTest.cpp b/src/Magnum/Vk/Test/QueueTest.cpp
index cfe18230d..3147db1c8 100644
--- a/src/Magnum/Vk/Test/QueueTest.cpp
+++ b/src/Magnum/Vk/Test/QueueTest.cpp
@@ -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() {
diff --git a/src/Magnum/Vk/Test/RenderPassTest.cpp b/src/Magnum/Vk/Test/RenderPassTest.cpp
index c0cf0d448..2432b49a0 100644
--- a/src/Magnum/Vk/Test/RenderPassTest.cpp
+++ b/src/Magnum/Vk/Test/RenderPassTest.cpp
@@ -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() {
diff --git a/src/Magnum/Vk/Test/ShaderTest.cpp b/src/Magnum/Vk/Test/ShaderTest.cpp
index 6b236649e..5f1c804f7 100644
--- a/src/Magnum/Vk/Test/ShaderTest.cpp
+++ b/src/Magnum/Vk/Test/ShaderTest.cpp
@@ -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&>{});
 }
 
 }}}}