Test: adapt to changes in CORRADE_SKIP().

Chose to update the tests instead of adding a compatibility DebugStl.h
include to Tester.h, which would have a significant impact on compile
times.

src/Magnum/Audio/Test/BufferALTest.cpp

@@ -84,7 +84,7 @@ void BufferALTest::properties() {
 
 void BufferALTest::loopPoints() {
     if(!_context.isExtensionSupported<Audio::Extensions::AL::SOFT::loop_points>())
-        CORRADE_SKIP(Extensions::AL::SOFT::loop_points::string() + std::string{" is not supported."});
+        CORRADE_SKIP(Extensions::AL::SOFT::loop_points::string() << "is not supported.");
 
     Buffer buf;
     constexpr char data[] { 25, 17, 24, 122, 67, 24, 48, 96 };
@@ -95,7 +95,7 @@ void BufferALTest::loopPoints() {
 
 void BufferALTest::setLoopPoints() {
     if(!_context.isExtensionSupported<Audio::Extensions::AL::SOFT::loop_points>())
-        CORRADE_SKIP(Extensions::AL::SOFT::loop_points::string() + std::string{" is not supported."});
+        CORRADE_SKIP(Extensions::AL::SOFT::loop_points::string() << "is not supported.");
 
     Buffer buf;
     constexpr char data[] { 25, 17, 24, 122, 67, 24, 48, 96 };
@@ -106,7 +106,7 @@ void BufferALTest::setLoopPoints() {
 
 void BufferALTest::setLoopSince() {
     if(!_context.isExtensionSupported<Audio::Extensions::AL::SOFT::loop_points>())
-        CORRADE_SKIP(Extensions::AL::SOFT::loop_points::string() + std::string{" is not supported."});
+        CORRADE_SKIP(Extensions::AL::SOFT::loop_points::string() << "is not supported.");
 
     Buffer buf;
     constexpr char data[] { 25, 17, 24, 122, 67, 24, 48, 96 };
@@ -117,7 +117,7 @@ void BufferALTest::setLoopSince() {
 
 void BufferALTest::setLoopUntil() {
     if(!_context.isExtensionSupported<Audio::Extensions::AL::SOFT::loop_points>())
-        CORRADE_SKIP(Extensions::AL::SOFT::loop_points::string() + std::string{" is not supported."});
+        CORRADE_SKIP(Extensions::AL::SOFT::loop_points::string() << "is not supported.");
 
     Buffer buf;
     constexpr char data[] { 25, 17, 24, 122, 67, 24, 48, 96 };
@@ -128,7 +128,7 @@ void BufferALTest::setLoopUntil() {
 
 void BufferALTest::resetLoopPoints() {
     if(!_context.isExtensionSupported<Audio::Extensions::AL::SOFT::loop_points>())
-        CORRADE_SKIP(Extensions::AL::SOFT::loop_points::string() + std::string{" is not supported."});
+        CORRADE_SKIP(Extensions::AL::SOFT::loop_points::string() << "is not supported.");
 
     Buffer buf;
     constexpr char data[] { 25, 17, 24, 122, 67, 24, 48, 96 };

src/Magnum/Audio/Test/ContextALTest.cpp

@@ -131,7 +131,7 @@ void ContextALTest::isExtensionUnsupported() {
     Context context;
 
     if(context.isExtensionSupported<Extensions::ALC::SOFTX::HRTF>())
-        CORRADE_SKIP("Extension" + std::string{Extensions::ALC::SOFTX::HRTF::string()} + " is supported, can't test.");
+        CORRADE_SKIP("Extension" << Extensions::ALC::SOFTX::HRTF::string() << "is supported, can't test.");
 
     CORRADE_VERIFY(!context.isExtensionSupported<Extensions::ALC::SOFTX::HRTF>());
     CORRADE_VERIFY(!context.isExtensionDisabled<Extensions::ALC::SOFTX::HRTF>());

src/Magnum/DebugTools/Test/BufferDataGLTest.cpp

@@ -49,10 +49,10 @@ constexpr Int Data[] = {2, 7, 5, 13, 25};
 void BufferDataGLTest::data() {
     #ifndef MAGNUM_TARGET_GLES
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::map_buffer_range>())
-        CORRADE_SKIP(GL::Extensions::ARB::map_buffer_range::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::ARB::map_buffer_range::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_GLES2)
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::EXT::map_buffer_range>())
-        CORRADE_SKIP(GL::Extensions::EXT::map_buffer_range::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::EXT::map_buffer_range::string() << "is not supported.");
     #endif
 
     GL::Buffer buffer;
@@ -66,10 +66,10 @@ void BufferDataGLTest::data() {
 void BufferDataGLTest::subData() {
     #ifndef MAGNUM_TARGET_GLES
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::map_buffer_range>())
-        CORRADE_SKIP(GL::Extensions::ARB::map_buffer_range::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::ARB::map_buffer_range::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_GLES2)
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::EXT::map_buffer_range>())
-        CORRADE_SKIP(GL::Extensions::EXT::map_buffer_range::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::EXT::map_buffer_range::string() << "is not supported.");
     #endif
 
     GL::Buffer buffer;

src/Magnum/DebugTools/Test/FrameProfilerGLTest.cpp

@@ -81,19 +81,19 @@ void FrameProfilerGLTest::test() {
     if(data.values & GLFrameProfiler::Value::GpuDuration) {
         #ifndef MAGNUM_TARGET_GLES
         if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::timer_query>())
-            CORRADE_SKIP(GL::Extensions::ARB::timer_query::string() + std::string(" is not available"));
+            CORRADE_SKIP(GL::Extensions::ARB::timer_query::string() << "is not supported.");
         #elif defined(MAGNUM_TARGET_WEBGL) && !defined(MAGNUM_TARGET_GLES2)
         if(!GL::Context::current().isExtensionSupported<GL::Extensions::EXT::disjoint_timer_query_webgl2>())
-            CORRADE_SKIP(GL::Extensions::EXT::disjoint_timer_query_webgl2::string() + std::string(" is not available"));
+            CORRADE_SKIP(GL::Extensions::EXT::disjoint_timer_query_webgl2::string() << "is not supported.");
         #else
         if(!GL::Context::current().isExtensionSupported<GL::Extensions::EXT::disjoint_timer_query>())
-            CORRADE_SKIP(GL::Extensions::EXT::disjoint_timer_query::string() + std::string(" is not available"));
+            CORRADE_SKIP(GL::Extensions::EXT::disjoint_timer_query::string() << "is not supported.");
         #endif
     }
 
     #ifndef MAGNUM_TARGET_GLES
     if((data.values & GLFrameProfiler::Value::VertexFetchRatio) && !GL::Context::current().isExtensionSupported<GL::Extensions::ARB::pipeline_statistics_query>())
-        CORRADE_SKIP(GL::Extensions::ARB::pipeline_statistics_query::string() + std::string(" is not available"));
+        CORRADE_SKIP(GL::Extensions::ARB::pipeline_statistics_query::string() << "is not supported.");
     #endif
 
     /* Bind some FB to avoid errors on contexts w/o default FB */
@@ -188,7 +188,7 @@ void FrameProfilerGLTest::test() {
 #ifndef MAGNUM_TARGET_GLES
 void FrameProfilerGLTest::vertexFetchRatioDivisionByZero() {
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::pipeline_statistics_query>())
-        CORRADE_SKIP(GL::Extensions::ARB::pipeline_statistics_query::string() + std::string(" is not available"));
+        CORRADE_SKIP(GL::Extensions::ARB::pipeline_statistics_query::string() << "is not supported.");
 
     GLFrameProfiler profiler{GLFrameProfiler::Value::VertexFetchRatio, 4};
 
@@ -214,7 +214,7 @@ void FrameProfilerGLTest::vertexFetchRatioDivisionByZero() {
 
 void FrameProfilerGLTest::primitiveClipRatioDivisionByZero() {
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::pipeline_statistics_query>())
-        CORRADE_SKIP(GL::Extensions::ARB::pipeline_statistics_query::string() + std::string(" is not available"));
+        CORRADE_SKIP(GL::Extensions::ARB::pipeline_statistics_query::string() << "is not supported.");
 
     GLFrameProfiler profiler{GLFrameProfiler::Value::PrimitiveClipRatio, 4};
 

src/Magnum/DebugTools/Test/TextureImageGLTest.cpp

@@ -208,7 +208,7 @@ constexpr UnsignedInt Data2DUInt[] = { 0xcafebabe,
 void TextureImageGLTest::subImage2DUInt() {
     #ifndef MAGNUM_TARGET_GLES
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::EXT::texture_integer>())
-        CORRADE_SKIP(GL::Extensions::EXT::texture_integer::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::EXT::texture_integer::string() << "is not supported.");
     #endif
 
     GL::Texture2D texture;

src/Magnum/GL/Test/AbstractQueryGLTest.cpp

@@ -56,7 +56,7 @@ AbstractQueryGLTest::AbstractQueryGLTest() {
 void AbstractQueryGLTest::construct() {
     #ifdef MAGNUM_TARGET_GLES2
     if(!Context::current().isExtensionSupported<Extensions::EXT::occlusion_query_boolean>())
-        CORRADE_SKIP(Extensions::EXT::occlusion_query_boolean::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::occlusion_query_boolean::string() << "is not supported.");
     #endif
 
     {
@@ -76,7 +76,7 @@ void AbstractQueryGLTest::construct() {
 void AbstractQueryGLTest::constructMove() {
     #ifdef MAGNUM_TARGET_GLES2
     if(!Context::current().isExtensionSupported<Extensions::EXT::occlusion_query_boolean>())
-        CORRADE_SKIP(Extensions::EXT::occlusion_query_boolean::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::occlusion_query_boolean::string() << "is not supported.");
     #endif
 
     #ifndef MAGNUM_TARGET_GLES
@@ -114,7 +114,7 @@ void AbstractQueryGLTest::constructMove() {
 void AbstractQueryGLTest::label() {
     #ifdef MAGNUM_TARGET_GLES2
     if(!Context::current().isExtensionSupported<Extensions::EXT::occlusion_query_boolean>())
-        CORRADE_SKIP(Extensions::EXT::occlusion_query_boolean::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::occlusion_query_boolean::string() << "is not supported.");
     #endif
 
     /* No-Op version is tested in AbstractObjectGLTest */

src/Magnum/GL/Test/AbstractShaderProgramGLTest.cpp

@@ -269,7 +269,7 @@ void AbstractShaderProgramGLTest::create() {
 void AbstractShaderProgramGLTest::createMultipleOutputs() {
     #ifndef MAGNUM_TARGET_GLES
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
-        CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() << "is not supported.");
 
     Utility::Resource rs("AbstractShaderProgramGLTest");
 
@@ -326,9 +326,9 @@ void AbstractShaderProgramGLTest::createMultipleOutputs() {
 #ifndef MAGNUM_TARGET_GLES
 void AbstractShaderProgramGLTest::createMultipleOutputsIndexed() {
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
-        CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() << "is not supported.");
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::blend_func_extended>())
-        CORRADE_SKIP(GL::Extensions::ARB::blend_func_extended::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::ARB::blend_func_extended::string() << "is not supported.");
 
     Utility::Resource rs("AbstractShaderProgramGLTest");
 
@@ -590,7 +590,7 @@ MyDoubleShader::MyDoubleShader() {
 
 void AbstractShaderProgramGLTest::uniformDouble() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::gpu_shader_fp64>())
-        CORRADE_SKIP(Extensions::ARB::gpu_shader_fp64::string() + std::string{" is not supported."});
+        CORRADE_SKIP(Extensions::ARB::gpu_shader_fp64::string() << "is not supported.");
 
     MyDoubleShader shader;
 
@@ -603,7 +603,7 @@ void AbstractShaderProgramGLTest::uniformDouble() {
 
 void AbstractShaderProgramGLTest::uniformDoubleVector() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::gpu_shader_fp64>())
-        CORRADE_SKIP(Extensions::ARB::gpu_shader_fp64::string() + std::string{" is not supported."});
+        CORRADE_SKIP(Extensions::ARB::gpu_shader_fp64::string() << "is not supported.");
 
     MyDoubleShader shader;
 
@@ -616,7 +616,7 @@ void AbstractShaderProgramGLTest::uniformDoubleVector() {
 
 void AbstractShaderProgramGLTest::uniformDoubleMatrix() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::gpu_shader_fp64>())
-        CORRADE_SKIP(Extensions::ARB::gpu_shader_fp64::string() + std::string{" is not supported."});
+        CORRADE_SKIP(Extensions::ARB::gpu_shader_fp64::string() << "is not supported.");
 
     MyDoubleShader shader;
 
@@ -629,7 +629,7 @@ void AbstractShaderProgramGLTest::uniformDoubleMatrix() {
 
 void AbstractShaderProgramGLTest::uniformDoubleArray() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::gpu_shader_fp64>())
-        CORRADE_SKIP(Extensions::ARB::gpu_shader_fp64::string() + std::string{" is not supported."});
+        CORRADE_SKIP(Extensions::ARB::gpu_shader_fp64::string() << "is not supported.");
 
     MyDoubleShader shader;
 
@@ -654,7 +654,7 @@ void AbstractShaderProgramGLTest::uniformDoubleArray() {
 void AbstractShaderProgramGLTest::createUniformBlocks() {
     #ifndef MAGNUM_TARGET_GLES
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::uniform_buffer_object>())
-        CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
     #endif
 
     Utility::Resource rs("AbstractShaderProgramGLTest");
@@ -711,7 +711,7 @@ void AbstractShaderProgramGLTest::createUniformBlocks() {
 void AbstractShaderProgramGLTest::uniformBlockIndexNotFound() {
     #ifndef MAGNUM_TARGET_GLES
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::uniform_buffer_object>())
-        CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
     #endif
 
     MyPublicShader program;
@@ -790,7 +790,7 @@ UniformBlockShader::UniformBlockShader() {
 void AbstractShaderProgramGLTest::uniformBlock() {
     #ifndef MAGNUM_TARGET_GLES
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::uniform_buffer_object>())
-        CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
     #endif
 
     UniformBlockShader shader;
@@ -807,7 +807,7 @@ void AbstractShaderProgramGLTest::uniformBlock() {
 void AbstractShaderProgramGLTest::compute() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::compute_shader>())
-        CORRADE_SKIP(Extensions::ARB::compute_shader::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compute_shader::string() << "is not supported.");
     #else
     if(!Context::current().isVersionSupported(Version::GLES310))
         CORRADE_SKIP("OpenGL ES 3.1 is not supported.");

src/Magnum/GL/Test/AbstractTextureGLTest.cpp

@@ -186,7 +186,7 @@ void AbstractTextureGLTest::subImageQueryViewBadSize() {
     #endif
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
 
     Texture2D texture;
     texture.setStorage(1, TextureFormat::RGBA8, Vector2i{2});
@@ -208,7 +208,7 @@ void AbstractTextureGLTest::compressedImageQueryViewNullptr() {
     #endif
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
 
     Texture2D texture;
     texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, Vector2i{4});
@@ -229,7 +229,7 @@ void AbstractTextureGLTest::compressedImageQueryViewBadSize() {
     #endif
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
 
     Texture2D texture;
     texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, Vector2i{4});
@@ -251,7 +251,7 @@ void AbstractTextureGLTest::compressedImageQueryViewBadDataSize() {
     #endif
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
 
     Texture2D texture;
     texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, Vector2i{4});
@@ -273,7 +273,7 @@ void AbstractTextureGLTest::compressedImageQueryViewBadFormat() {
     #endif
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
 
     Texture2D texture;
     texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, Vector2i{4});
@@ -295,11 +295,11 @@ void AbstractTextureGLTest::compressedSubImageQueryViewNullptr() {
     #endif
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
-        CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported.");
 
     Texture2D texture;
     texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, Vector2i{4});
@@ -320,11 +320,11 @@ void AbstractTextureGLTest::compressedSubImageQueryViewBadSize() {
     #endif
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
-        CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported.");
 
     Texture2D texture;
     texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, Vector2i{4});
@@ -346,11 +346,11 @@ void AbstractTextureGLTest::compressedSubImageQueryViewBadDataSize() {
     #endif
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
-        CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported.");
 
     Texture2D texture;
     texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, Vector2i{4});
@@ -372,11 +372,11 @@ void AbstractTextureGLTest::compressedSubImageQueryViewBadFormat() {
     #endif
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
-        CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported.");
 
     Texture2D texture;
     texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, Vector2i{4});

src/Magnum/GL/Test/BufferGLTest.cpp

@@ -207,7 +207,7 @@ void BufferGLTest::label() {
 void BufferGLTest::bindBase() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::uniform_buffer_object>())
-        CORRADE_SKIP(Extensions::ARB::uniform_buffer_object::string() + std::string{" is not supported."});
+        CORRADE_SKIP(Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
     #endif
 
     Buffer buffer;
@@ -231,7 +231,7 @@ void BufferGLTest::bindBase() {
 void BufferGLTest::bindRange() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::uniform_buffer_object>())
-        CORRADE_SKIP(Extensions::ARB::uniform_buffer_object::string() + std::string{" is not supported."});
+        CORRADE_SKIP(Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
     #endif
 
     /* Check that we have correct offset alignment */
@@ -329,7 +329,7 @@ void BufferGLTest::data() {
 void BufferGLTest::map() {
     #ifdef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::OES::mapbuffer>())
-        CORRADE_SKIP(Extensions::OES::mapbuffer::string() + std::string(" is not supported"));
+        CORRADE_SKIP(Extensions::OES::mapbuffer::string() << "is not supported.");
     #endif
     Buffer buffer;
 
@@ -365,10 +365,10 @@ void BufferGLTest::map() {
 void BufferGLTest::mapRange() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::map_buffer_range>())
-        CORRADE_SKIP(Extensions::ARB::map_buffer_range::string() + std::string(" is not supported"));
+        CORRADE_SKIP(Extensions::ARB::map_buffer_range::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_GLES2)
     if(!Context::current().isExtensionSupported<Extensions::EXT::map_buffer_range>())
-        CORRADE_SKIP(Extensions::EXT::map_buffer_range::string() + std::string(" is not supported"));
+        CORRADE_SKIP(Extensions::EXT::map_buffer_range::string() << "is not supported.");
     #endif
 
     constexpr char data[] = {2, 7, 5, 13, 25};
@@ -397,10 +397,10 @@ void BufferGLTest::mapRange() {
 void BufferGLTest::mapRangeExplicitFlush() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::map_buffer_range>())
-        CORRADE_SKIP(Extensions::ARB::map_buffer_range::string() + std::string(" is not supported"));
+        CORRADE_SKIP(Extensions::ARB::map_buffer_range::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_GLES2)
     if(!Context::current().isExtensionSupported<Extensions::EXT::map_buffer_range>())
-        CORRADE_SKIP(Extensions::EXT::map_buffer_range::string() + std::string(" is not supported"));
+        CORRADE_SKIP(Extensions::EXT::map_buffer_range::string() << "is not supported.");
     #endif
 
     constexpr char data[] = {2, 7, 5, 13, 25};

src/Magnum/GL/Test/BufferTextureGLTest.cpp

@@ -95,10 +95,10 @@ BufferTextureGLTest::BufferTextureGLTest() {
 void BufferTextureGLTest::construct() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_buffer_object>())
-        CORRADE_SKIP(Extensions::ARB::texture_buffer_object::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_buffer_object::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_buffer>())
-        CORRADE_SKIP(Extensions::EXT::texture_buffer::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_buffer::string() << "is not supported.");
     #endif
 
     {
@@ -123,10 +123,10 @@ void BufferTextureGLTest::constructMove() {
 void BufferTextureGLTest::wrap() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_buffer_object>())
-        CORRADE_SKIP(Extensions::ARB::texture_buffer_object::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_buffer_object::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_buffer>())
-        CORRADE_SKIP(Extensions::EXT::texture_buffer::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_buffer::string() << "is not supported.");
     #endif
 
     GLuint id;
@@ -146,10 +146,10 @@ void BufferTextureGLTest::wrap() {
 void BufferTextureGLTest::bind() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_buffer_object>())
-        CORRADE_SKIP(Extensions::ARB::texture_buffer_object::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_buffer_object::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_buffer>())
-        CORRADE_SKIP(Extensions::EXT::texture_buffer::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_buffer::string() << "is not supported.");
     #endif
 
     BufferTexture texture;
@@ -173,12 +173,12 @@ void BufferTextureGLTest::bind() {
 void BufferTextureGLTest::bindImage() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_buffer_object>())
-        CORRADE_SKIP(Extensions::ARB::texture_buffer_object::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_buffer_object::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::shader_image_load_store>())
-        CORRADE_SKIP(Extensions::ARB::shader_image_load_store::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::shader_image_load_store::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_buffer>())
-        CORRADE_SKIP(Extensions::EXT::texture_buffer::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_buffer::string() << "is not supported.");
     if(!Context::current().isVersionSupported(Version::GLES310))
         CORRADE_SKIP("OpenGL ES 3.1 is not supported.");
     #endif
@@ -210,10 +210,10 @@ void BufferTextureGLTest::bindImage() {
 void BufferTextureGLTest::setBuffer() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_buffer_object>())
-        CORRADE_SKIP(Extensions::ARB::texture_buffer_object::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_buffer_object::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_buffer>())
-        CORRADE_SKIP(Extensions::EXT::texture_buffer::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_buffer::string() << "is not supported.");
     #endif
 
     BufferTexture texture;
@@ -240,10 +240,10 @@ void BufferTextureGLTest::setBuffer() {
 void BufferTextureGLTest::setBufferEmptyFirst() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_buffer_object>())
-        CORRADE_SKIP(Extensions::ARB::texture_buffer_object::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_buffer_object::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_buffer>())
-        CORRADE_SKIP(Extensions::EXT::texture_buffer::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_buffer::string() << "is not supported.");
     #endif
 
     BufferTexture texture;
@@ -276,12 +276,12 @@ void BufferTextureGLTest::setBufferEmptyFirst() {
 void BufferTextureGLTest::setBufferOffset() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_buffer_object>())
-        CORRADE_SKIP(Extensions::ARB::texture_buffer_object::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_buffer_object::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_buffer_range>())
-        CORRADE_SKIP(Extensions::ARB::texture_buffer_range::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_buffer_range::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_buffer>())
-        CORRADE_SKIP(Extensions::EXT::texture_buffer::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_buffer::string() << "is not supported.");
     #endif
 
     /* Check that we have correct offset alignment */
@@ -314,10 +314,10 @@ void BufferTextureGLTest::setBufferOffset() {
 void BufferTextureGLTest::resetBuffer() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_buffer_object>())
-        CORRADE_SKIP(Extensions::ARB::texture_buffer_object::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_buffer_object::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_buffer>())
-        CORRADE_SKIP(Extensions::EXT::texture_buffer::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_buffer::string() << "is not supported.");
     #endif
 
     BufferTexture texture;
@@ -351,7 +351,7 @@ void BufferTextureGLTest::resetBuffer() {
 #if defined(CORRADE_TARGET_APPLE) && !defined(CORRADE_TARGET_IOS)
 void BufferTextureGLTest::appleSetBufferSubData() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_buffer_object>())
-        CORRADE_SKIP(Extensions::ARB::texture_buffer_object::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_buffer_object::string() << "is not supported.");
 
     BufferTexture texture;
     Buffer buffer{Buffer::TargetHint::Texture};
@@ -373,7 +373,7 @@ void BufferTextureGLTest::appleSetBufferSubData() {
 
 void BufferTextureGLTest::appleSetUnrelatedBufferData() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_buffer_object>())
-        CORRADE_SKIP(Extensions::ARB::texture_buffer_object::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_buffer_object::string() << "is not supported.");
 
     BufferTexture texture;
     Buffer buffer{Buffer::TargetHint::Texture};
@@ -396,7 +396,7 @@ void BufferTextureGLTest::appleSetUnrelatedBufferData() {
 
 void BufferTextureGLTest::appleSetBufferQueryData() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_buffer_object>())
-        CORRADE_SKIP(Extensions::ARB::texture_buffer_object::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_buffer_object::string() << "is not supported.");
 
     BufferTexture texture;
     Buffer buffer{Buffer::TargetHint::Texture};
@@ -419,7 +419,7 @@ void BufferTextureGLTest::appleSetBufferQueryData() {
 
 void BufferTextureGLTest::appleSetBufferMap() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_buffer_object>())
-        CORRADE_SKIP(Extensions::ARB::texture_buffer_object::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_buffer_object::string() << "is not supported.");
 
     BufferTexture texture;
     Buffer buffer{Buffer::TargetHint::Texture};
@@ -445,7 +445,7 @@ void BufferTextureGLTest::appleSetBufferMap() {
 
 void BufferTextureGLTest::appleSetBufferMapRange() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_buffer_object>())
-        CORRADE_SKIP(Extensions::ARB::texture_buffer_object::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_buffer_object::string() << "is not supported.");
 
     BufferTexture texture;
     Buffer buffer{Buffer::TargetHint::Texture};
@@ -476,7 +476,7 @@ void BufferTextureGLTest::appleSetBufferMapRange() {
 
 void BufferTextureGLTest::appleBindUnrelatedTextureInBetween() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_buffer_object>())
-        CORRADE_SKIP(Extensions::ARB::texture_buffer_object::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_buffer_object::string() << "is not supported.");
 
     BufferTexture texture;
     Buffer buffer{Buffer::TargetHint::Texture};

src/Magnum/GL/Test/ContextGLTest.cpp

@@ -260,9 +260,9 @@ void ContextGLTest::constructConfiguration() {
     CORRADE_VERIFY(Context::hasCurrent());
 
     if(data.needsExtensionPresent && !Context::current().isExtensionSupported(*data.needsExtensionPresent))
-        CORRADE_SKIP(data.needsExtensionPresent->string() + std::string{" is not supported, skippping"});
+        CORRADE_SKIP(data.needsExtensionPresent->string() << "is not supported.");
     if(data.needsExtensionMissing && Context::current().isExtensionSupported(*data.needsExtensionMissing))
-        CORRADE_SKIP(data.needsExtensionMissing->string() + std::string{" is supported, skippping"});
+        CORRADE_SKIP(data.needsExtensionMissing->string() << "is supported.");
 
     std::ostringstream out;
     {
@@ -297,7 +297,7 @@ void ContextGLTest::constructMove() {
     CORRADE_VERIFY(Context::hasCurrent());
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_filter_anisotropic>())
-        CORRADE_SKIP(Extensions::EXT::texture_filter_anisotropic::string() + std::string{" is not supported, skipping"});
+        CORRADE_SKIP(Extensions::EXT::texture_filter_anisotropic::string() << "is not supported.");
 
     Context* current = &Context::current();
     Context::makeCurrent(nullptr);
@@ -457,7 +457,7 @@ void ContextGLTest::isVersionSupported() {
 #ifndef MAGNUM_TARGET_GLES
 void ContextGLTest::isVersionSupportedES() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::ES2_compatibility>())
-        CORRADE_SKIP(Extensions::ARB::ES2_compatibility::string() + std::string(" extension should not be supported, can't test"));
+        CORRADE_SKIP(Extensions::ARB::ES2_compatibility::string() << "should not be supported, can't test.");
 
     /* No assertions should be fired */
     CORRADE_VERIFY(Context::current().isVersionSupported(Version::GLES200));
@@ -475,13 +475,13 @@ void ContextGLTest::supportedVersion() {
 void ContextGLTest::isExtensionSupported() {
     #ifndef MAGNUM_TARGET_GLES
     if(Context::current().isExtensionSupported<Extensions::GREMEDY::string_marker>())
-        CORRADE_SKIP(Extensions::GREMEDY::string_marker::string() + std::string(" extension should not be supported, can't test"));
+        CORRADE_SKIP(Extensions::GREMEDY::string_marker::string() << "should not be supported, can't test.");
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_filter_anisotropic>())
-        CORRADE_SKIP(Extensions::EXT::texture_filter_anisotropic::string() + std::string(" extension should be supported, can't test"));
+        CORRADE_SKIP(Extensions::EXT::texture_filter_anisotropic::string() << "should be supported, can't test.");
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::explicit_attrib_location>())
-        CORRADE_SKIP(Extensions::ARB::explicit_attrib_location::string() + std::string(" extension should be supported, can't test"));
+        CORRADE_SKIP(Extensions::ARB::explicit_attrib_location::string() << "should be supported, can't test.");
 
     /* Test that we have proper extension list parser */
     Containers::Array<Containers::StringView> extensions = Context::current().extensionStrings();
@@ -501,10 +501,10 @@ void ContextGLTest::isExtensionSupported() {
 void ContextGLTest::isExtensionDisabled() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::vertex_array_object>())
-        CORRADE_SKIP(Extensions::ARB::vertex_array_object::string() + std::string(" extension should be supported, can't test"));
+        CORRADE_SKIP(Extensions::ARB::vertex_array_object::string() << "should be supported, can't test.");
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::explicit_attrib_location>())
-        CORRADE_SKIP(Extensions::ARB::explicit_attrib_location::string() + std::string(" extension should be supported, can't test"));
+        CORRADE_SKIP(Extensions::ARB::explicit_attrib_location::string() << "should be supported, can't test.");
 
     /* This is not disabled anywhere */
     CORRADE_VERIFY(!Context::current().isExtensionDisabled<Extensions::ARB::vertex_array_object>());

src/Magnum/GL/Test/CubeMapTextureArrayGLTest.cpp

@@ -329,10 +329,10 @@ CubeMapTextureArrayGLTest::CubeMapTextureArrayGLTest() {
 void CubeMapTextureArrayGLTest::construct() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() << "is not supported.");
     #endif
 
     {
@@ -357,10 +357,10 @@ void CubeMapTextureArrayGLTest::constructMove() {
 void CubeMapTextureArrayGLTest::wrap() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() << "is not supported.");
     #endif
 
     GLuint id;
@@ -380,10 +380,10 @@ void CubeMapTextureArrayGLTest::wrap() {
 void CubeMapTextureArrayGLTest::bind() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() << "is not supported.");
     #endif
 
     CubeMapTextureArray texture;
@@ -407,12 +407,12 @@ void CubeMapTextureArrayGLTest::bind() {
 void CubeMapTextureArrayGLTest::bindImage() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::shader_image_load_store>())
-        CORRADE_SKIP(Extensions::ARB::shader_image_load_store::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::shader_image_load_store::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() << "is not supported.");
     if(!Context::current().isVersionSupported(Version::GLES310))
         CORRADE_SKIP("OpenGL ES 3.1 is not supported.");
     #endif
@@ -447,10 +447,10 @@ template<class T> void CubeMapTextureArrayGLTest::sampling() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() << "is not supported.");
     #endif
 
     CubeMapTextureArray texture;
@@ -479,13 +479,13 @@ template<class T> void CubeMapTextureArrayGLTest::sampling() {
 void CubeMapTextureArrayGLTest::samplingSrgbDecode() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() << "is not supported.");
     #endif
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_sRGB_decode>())
-        CORRADE_SKIP(Extensions::EXT::texture_sRGB_decode::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_sRGB_decode::string() << "is not supported.");
 
     CubeMapTextureArray texture;
     texture.setSrgbDecode(false);
@@ -496,14 +496,14 @@ void CubeMapTextureArrayGLTest::samplingSrgbDecode() {
 void CubeMapTextureArrayGLTest::samplingBorderInteger() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_integer>())
-        CORRADE_SKIP(Extensions::EXT::texture_integer::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_integer::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_border_clamp>())
-        CORRADE_SKIP(Extensions::EXT::texture_border_clamp::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_border_clamp::string() << "is not supported.");
     #endif
 
     CubeMapTextureArray a;
@@ -519,12 +519,12 @@ void CubeMapTextureArrayGLTest::samplingBorderInteger() {
 void CubeMapTextureArrayGLTest::samplingSwizzle() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_swizzle>())
-        CORRADE_SKIP(Extensions::ARB::texture_swizzle::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_swizzle::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() << "is not supported.");
     #endif
 
     CubeMapTextureArray texture;
@@ -536,12 +536,12 @@ void CubeMapTextureArrayGLTest::samplingSwizzle() {
 void CubeMapTextureArrayGLTest::samplingDepthStencilMode() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::stencil_texturing>())
-        CORRADE_SKIP(Extensions::ARB::stencil_texturing::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::stencil_texturing::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() << "is not supported.");
     #endif
 
     CubeMapTextureArray texture;
@@ -553,9 +553,9 @@ void CubeMapTextureArrayGLTest::samplingDepthStencilMode() {
 #ifdef MAGNUM_TARGET_GLES
 void CubeMapTextureArrayGLTest::samplingBorder() {
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_border_clamp>())
-        CORRADE_SKIP(Extensions::EXT::texture_border_clamp::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_border_clamp::string() << "is not supported.");
 
     CubeMapTextureArray texture;
     texture.setWrapping(SamplerWrapping::ClampToBorder)
@@ -568,10 +568,10 @@ void CubeMapTextureArrayGLTest::samplingBorder() {
 void CubeMapTextureArrayGLTest::storage() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() << "is not supported.");
     #endif
 
     CubeMapTextureArray texture;
@@ -594,10 +594,10 @@ void CubeMapTextureArrayGLTest::image() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() << "is not supported.");
     #endif
 
     CubeMapTextureArray texture;
@@ -626,10 +626,10 @@ void CubeMapTextureArrayGLTest::imageBuffer() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() << "is not supported.");
     #endif
 
     CubeMapTextureArray texture;
@@ -661,7 +661,7 @@ void CubeMapTextureArrayGLTest::imageQueryView() {
     setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported.");
 
     CubeMapTextureArray texture;
     texture.setImage(0, TextureFormat::RGBA8, ImageView3D{
@@ -689,22 +689,22 @@ void CubeMapTextureArrayGLTest::compressedImage() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() << "is not supported.");
     #endif
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::ANGLE::texture_compression_dxt3>())
-        CORRADE_SKIP(Extensions::ANGLE::texture_compression_dxt3::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ANGLE::texture_compression_dxt3::string() << "is not supported.");
     #endif
 
     #ifndef MAGNUM_TARGET_GLES
     if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #endif
 
     CubeMapTextureArray texture;
@@ -734,22 +734,22 @@ void CubeMapTextureArrayGLTest::compressedImageBuffer() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() << "is not supported.");
     #endif
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::ANGLE::texture_compression_dxt3>())
-        CORRADE_SKIP(Extensions::ANGLE::texture_compression_dxt3::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ANGLE::texture_compression_dxt3::string() << "is not supported.");
     #endif
 
     #ifndef MAGNUM_TARGET_GLES
     if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #endif
 
     CubeMapTextureArray texture;
@@ -782,12 +782,12 @@ void CubeMapTextureArrayGLTest::compressedImageQueryView() {
     setTestCaseDescription(CompressedPixelStorageData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
 
     if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
 
     CubeMapTextureArray texture;
     texture.setCompressedImage(0, CompressedImageView3D{
@@ -852,10 +852,10 @@ void CubeMapTextureArrayGLTest::subImage() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() << "is not supported.");
     #endif
 
     CubeMapTextureArray texture;
@@ -885,10 +885,10 @@ void CubeMapTextureArrayGLTest::subImageBuffer() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() << "is not supported.");
     #endif
 
     CubeMapTextureArray texture;
@@ -921,9 +921,9 @@ void CubeMapTextureArrayGLTest::subImageQuery() {
     setTestCaseDescription(SubPixelStorageData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
 
     CubeMapTextureArray texture;
     texture.setStorage(1, TextureFormat::RGBA8, {4, 4, 6})
@@ -947,9 +947,9 @@ void CubeMapTextureArrayGLTest::subImageQueryView() {
     setTestCaseDescription(SubPixelStorageData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
 
     CubeMapTextureArray texture;
     texture.setStorage(1, TextureFormat::RGBA8, {4, 4, 6})
@@ -973,9 +973,9 @@ void CubeMapTextureArrayGLTest::subImageQueryBuffer() {
     setTestCaseDescription(SubPixelStorageData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
 
     CubeMapTextureArray texture;
     texture.setStorage(1, TextureFormat::RGBA8, {4, 4, 6})
@@ -1068,22 +1068,22 @@ void CubeMapTextureArrayGLTest::compressedSubImage() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() << "is not supported.");
     #endif
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::ANGLE::texture_compression_dxt3>())
-        CORRADE_SKIP(Extensions::ANGLE::texture_compression_dxt3::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ANGLE::texture_compression_dxt3::string() << "is not supported.");
     #endif
 
     #ifndef MAGNUM_TARGET_GLES
     if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #endif
 
     CubeMapTextureArray texture;
@@ -1121,22 +1121,22 @@ void CubeMapTextureArrayGLTest::compressedSubImageBuffer() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() << "is not supported.");
     #endif
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::ANGLE::texture_compression_dxt3>())
-        CORRADE_SKIP(Extensions::ANGLE::texture_compression_dxt3::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ANGLE::texture_compression_dxt3::string() << "is not supported.");
     #endif
 
     #ifndef MAGNUM_TARGET_GLES
     if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #endif
 
     CubeMapTextureArray texture;
@@ -1170,15 +1170,15 @@ void CubeMapTextureArrayGLTest::compressedSubImageQuery() {
     setTestCaseDescription(CompressedSubPixelStorageData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
     if(CompressedSubPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     if(CompressedSubPixelStorageData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
-        CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported.");
 
     CubeMapTextureArray texture;
     texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, {12, 12, 6})
@@ -1200,15 +1200,15 @@ void CubeMapTextureArrayGLTest::compressedSubImageQueryView() {
     setTestCaseDescription(CompressedSubPixelStorageData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
     if(CompressedSubPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     if(CompressedSubPixelStorageData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
-        CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported.");
 
     CubeMapTextureArray texture;
     texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, {12, 12, 6})
@@ -1232,15 +1232,15 @@ void CubeMapTextureArrayGLTest::compressedSubImageQueryBuffer() {
     setTestCaseDescription(CompressedSubPixelStorageData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
     if(CompressedSubPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     if(CompressedSubPixelStorageData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
-        CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported.");
 
     CubeMapTextureArray texture;
     texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, {12, 12, 6})
@@ -1263,12 +1263,12 @@ void CubeMapTextureArrayGLTest::compressedSubImageQueryBuffer() {
 void CubeMapTextureArrayGLTest::generateMipmap() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() << "is not supported.");
     #endif
 
     CubeMapTextureArray texture;
@@ -1295,10 +1295,10 @@ void CubeMapTextureArrayGLTest::generateMipmap() {
 void CubeMapTextureArrayGLTest::invalidateImage() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() << "is not supported.");
     #endif
 
     CubeMapTextureArray texture;
@@ -1311,10 +1311,10 @@ void CubeMapTextureArrayGLTest::invalidateImage() {
 void CubeMapTextureArrayGLTest::invalidateSubImage() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() << "is not supported.");
     #endif
 
     CubeMapTextureArray texture;

src/Magnum/GL/Test/CubeMapTextureGLTest.cpp

@@ -490,7 +490,7 @@ void CubeMapTextureGLTest::bind() {
 void CubeMapTextureGLTest::bindImage() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::shader_image_load_store>())
-        CORRADE_SKIP(Extensions::ARB::shader_image_load_store::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::shader_image_load_store::string() << "is not supported.");
     #else
     if(!Context::current().isVersionSupported(Version::GLES310))
         CORRADE_SKIP("OpenGL ES 3.1 is not supported.");
@@ -557,10 +557,10 @@ template<class T> void CubeMapTextureGLTest::sampling() {
 void CubeMapTextureGLTest::samplingSrgbDecode() {
     #ifdef MAGNUM_TARGET_GLES2
     if(!Context::current().isExtensionSupported<Extensions::EXT::sRGB>())
-        CORRADE_SKIP(Extensions::EXT::sRGB::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::sRGB::string() << "is not supported.");
     #endif
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_sRGB_decode>())
-        CORRADE_SKIP(Extensions::EXT::texture_sRGB_decode::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_sRGB_decode::string() << "is not supported.");
 
     CubeMapTexture texture;
     texture.setSrgbDecode(false);
@@ -573,7 +573,7 @@ void CubeMapTextureGLTest::samplingSrgbDecode() {
 void CubeMapTextureGLTest::samplingSwizzle() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_swizzle>())
-        CORRADE_SKIP(Extensions::ARB::texture_swizzle::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_swizzle::string() << "is not supported.");
     #endif
 
     CubeMapTexture texture;
@@ -586,7 +586,7 @@ void CubeMapTextureGLTest::samplingSwizzle() {
 #if defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
 void CubeMapTextureGLTest::samplingMaxLevel() {
     if(!Context::current().isExtensionSupported<Extensions::APPLE::texture_max_level>())
-        CORRADE_SKIP(Extensions::APPLE::texture_max_level::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::APPLE::texture_max_level::string() << "is not supported.");
 
     CubeMapTexture texture;
     texture.setMaxLevel(750);
@@ -597,7 +597,7 @@ void CubeMapTextureGLTest::samplingMaxLevel() {
 void CubeMapTextureGLTest::samplingCompare() {
     if(!Context::current().isExtensionSupported<Extensions::EXT::shadow_samplers>() ||
        !Context::current().isExtensionSupported<Extensions::NV::shadow_samplers_cube>())
-        CORRADE_SKIP(Extensions::NV::shadow_samplers_cube::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::NV::shadow_samplers_cube::string() << "is not supported.");
 
     CubeMapTexture texture;
     texture.setCompareMode(SamplerCompareMode::CompareRefToTexture)
@@ -611,10 +611,10 @@ void CubeMapTextureGLTest::samplingCompare() {
 void CubeMapTextureGLTest::samplingBorderInteger() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_integer>())
-        CORRADE_SKIP(Extensions::EXT::texture_integer::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_integer::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_border_clamp>())
-        CORRADE_SKIP(Extensions::EXT::texture_border_clamp::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_border_clamp::string() << "is not supported.");
     #endif
 
     CubeMapTexture a;
@@ -630,7 +630,7 @@ void CubeMapTextureGLTest::samplingBorderInteger() {
 void CubeMapTextureGLTest::samplingDepthStencilMode() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::stencil_texturing>())
-        CORRADE_SKIP(Extensions::ARB::stencil_texturing::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::stencil_texturing::string() << "is not supported.");
     #else
     if(!Context::current().isVersionSupported(Version::GLES310))
         CORRADE_SKIP("OpenGL ES 3.1 not supported.");
@@ -695,7 +695,7 @@ void CubeMapTextureGLTest::storage() {
     #ifdef MAGNUM_TARGET_GLES2
     #ifndef MAGNUM_TARGET_WEBGL
     if(PixelStorageData[testCaseInstanceId()].storage != PixelStorage{} && !Context::current().isExtensionSupported<Extensions::EXT::unpack_subimage>())
-        CORRADE_SKIP(Extensions::EXT::unpack_subimage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::unpack_subimage::string() << "is not supported.");
     #else
     if(PixelStorageData[testCaseInstanceId()].storage != PixelStorage{})
         CORRADE_SKIP("Image unpack is not supported in WebGL 1.");
@@ -773,7 +773,7 @@ void CubeMapTextureGLTest::image() {
     #ifdef MAGNUM_TARGET_GLES2
     #ifndef MAGNUM_TARGET_WEBGL
     if(PixelStorageData[testCaseInstanceId()].storage != PixelStorage{} && !Context::current().isExtensionSupported<Extensions::EXT::unpack_subimage>())
-        CORRADE_SKIP(Extensions::EXT::unpack_subimage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::unpack_subimage::string() << "is not supported.");
     #else
     if(PixelStorageData[testCaseInstanceId()].storage != PixelStorage{})
         CORRADE_SKIP("Image unpack is not supported in WebGL 1.");
@@ -964,7 +964,7 @@ void CubeMapTextureGLTest::subImage() {
     #ifdef MAGNUM_TARGET_GLES2
     #ifndef MAGNUM_TARGET_WEBGL
     if(PixelStorageData[testCaseInstanceId()].storage != PixelStorage{} && !Context::current().isExtensionSupported<Extensions::EXT::unpack_subimage>())
-        CORRADE_SKIP(Extensions::EXT::unpack_subimage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::unpack_subimage::string() << "is not supported.");
     #else
     if(PixelStorageData[testCaseInstanceId()].storage != PixelStorage{})
         CORRADE_SKIP("Image unpack is not supported in WebGL 1.");
@@ -1054,7 +1054,7 @@ void CubeMapTextureGLTest::subImageQuery() {
     setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
 
     CubeMapTexture texture;
     texture.setStorage(1, TextureFormat::RGBA8, Vector2i{4})
@@ -1078,7 +1078,7 @@ void CubeMapTextureGLTest::subImageQueryView() {
     setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
 
     CubeMapTexture texture;
     texture.setStorage(1, TextureFormat::RGBA8, Vector2i{4})
@@ -1103,7 +1103,7 @@ void CubeMapTextureGLTest::subImageQueryBuffer() {
     setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
 
     CubeMapTexture texture;
     texture.setStorage(1, TextureFormat::RGBA8, Vector2i{4})
@@ -1130,18 +1130,18 @@ void CubeMapTextureGLTest::compressedImage() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_WEBGL)
     if(!Context::current().isExtensionSupported<Extensions::WEBGL::compressed_texture_s3tc>())
-        CORRADE_SKIP(Extensions::WEBGL::compressed_texture_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::WEBGL::compressed_texture_s3tc::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::ANGLE::texture_compression_dxt3>())
-        CORRADE_SKIP(Extensions::ANGLE::texture_compression_dxt3::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ANGLE::texture_compression_dxt3::string() << "is not supported.");
     #endif
 
     #ifndef MAGNUM_TARGET_GLES
     if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #endif
 
     const CompressedImageView2D view{
@@ -1179,18 +1179,18 @@ void CubeMapTextureGLTest::compressedImageBuffer() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_WEBGL)
     if(!Context::current().isExtensionSupported<Extensions::WEBGL::compressed_texture_s3tc>())
-        CORRADE_SKIP(Extensions::WEBGL::compressed_texture_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::WEBGL::compressed_texture_s3tc::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::ANGLE::texture_compression_dxt3>())
-        CORRADE_SKIP(Extensions::ANGLE::texture_compression_dxt3::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ANGLE::texture_compression_dxt3::string() << "is not supported.");
     #endif
 
     #ifndef MAGNUM_TARGET_GLES
     if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #endif
 
     CompressedBufferImage2D buffer{
@@ -1231,10 +1231,10 @@ void CubeMapTextureGLTest::compressedImageQueryView() {
     setTestCaseDescription(CompressedPixelStorageData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
 
     if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
 
     const CompressedImageView2D view{
         CompressedPixelStorageData[testCaseInstanceId()].storage,
@@ -1265,7 +1265,7 @@ void CubeMapTextureGLTest::compressedImageQueryViewNullptr() {
     #endif
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
 
     CubeMapTexture texture;
     texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, Vector2i{4});
@@ -1286,7 +1286,7 @@ void CubeMapTextureGLTest::compressedImageQueryViewBadSize() {
     #endif
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
 
     CubeMapTexture texture;
     texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, Vector2i{4});
@@ -1308,7 +1308,7 @@ void CubeMapTextureGLTest::compressedImageQueryViewBadDataSize() {
     #endif
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
 
     CubeMapTexture texture;
     texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, Vector2i{4});
@@ -1330,7 +1330,7 @@ void CubeMapTextureGLTest::compressedImageQueryViewBadFormat() {
     #endif
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
 
     CubeMapTexture texture;
     texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, Vector2i{4});
@@ -1353,25 +1353,25 @@ void CubeMapTextureGLTest::immutableCompressedImage() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_storage>())
-        CORRADE_SKIP(Extensions::ARB::texture_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_storage::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_GLES2)
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_storage>())
-        CORRADE_SKIP(Extensions::EXT::texture_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_storage::string() << "is not supported.");
     #endif
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_WEBGL)
     if(!Context::current().isExtensionSupported<Extensions::WEBGL::compressed_texture_s3tc>())
-        CORRADE_SKIP(Extensions::WEBGL::compressed_texture_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::WEBGL::compressed_texture_s3tc::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::ANGLE::texture_compression_dxt3>())
-        CORRADE_SKIP(Extensions::ANGLE::texture_compression_dxt3::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ANGLE::texture_compression_dxt3::string() << "is not supported.");
     #endif
 
     #ifndef MAGNUM_TARGET_GLES
     if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #endif
 
     /* Testing that GL_TEXTURE_COMPRESSED_IMAGE_SIZE is consistent and returns
@@ -1446,18 +1446,18 @@ void CubeMapTextureGLTest::compressedSubImage() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_WEBGL)
     if(!Context::current().isExtensionSupported<Extensions::WEBGL::compressed_texture_s3tc>())
-        CORRADE_SKIP(Extensions::WEBGL::compressed_texture_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::WEBGL::compressed_texture_s3tc::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::ANGLE::texture_compression_dxt3>())
-        CORRADE_SKIP(Extensions::ANGLE::texture_compression_dxt3::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ANGLE::texture_compression_dxt3::string() << "is not supported.");
     #endif
 
     #ifndef MAGNUM_TARGET_GLES
     if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #endif
 
     CubeMapTexture texture;
@@ -1506,18 +1506,18 @@ void CubeMapTextureGLTest::compressedSubImageBuffer() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_WEBGL)
     if(!Context::current().isExtensionSupported<Extensions::WEBGL::compressed_texture_s3tc>())
-        CORRADE_SKIP(Extensions::WEBGL::compressed_texture_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::WEBGL::compressed_texture_s3tc::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::ANGLE::texture_compression_dxt3>())
-        CORRADE_SKIP(Extensions::ANGLE::texture_compression_dxt3::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ANGLE::texture_compression_dxt3::string() << "is not supported.");
     #endif
 
     #ifndef MAGNUM_TARGET_GLES
     if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #endif
 
     CubeMapTexture texture;
@@ -1563,13 +1563,13 @@ void CubeMapTextureGLTest::compressedSubImageQuery() {
     setTestCaseDescription(CompressedPixelStorageData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
     if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     if(CompressedPixelStorageData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
-        CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported.");
 
     CubeMapTexture texture;
     texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, Vector2i{12})
@@ -1591,13 +1591,13 @@ void CubeMapTextureGLTest::compressedSubImageQueryView() {
     setTestCaseDescription(CompressedPixelStorageData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
     if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     if(CompressedPixelStorageData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
-        CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported.");
 
     CubeMapTexture texture;
     texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, Vector2i{12})
@@ -1623,7 +1623,7 @@ void CubeMapTextureGLTest::compressedSubImageQueryViewNullptr() {
     #endif
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
 
     CubeMapTexture texture;
     texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, Vector2i{12});
@@ -1644,7 +1644,7 @@ void CubeMapTextureGLTest::compressedSubImageQueryViewBadSize() {
     #endif
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
 
     CubeMapTexture texture;
     texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, Vector2i{12});
@@ -1666,7 +1666,7 @@ void CubeMapTextureGLTest::compressedSubImageQueryViewBadDataSize() {
     #endif
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
 
     CubeMapTexture texture;
     texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, Vector2i{12});
@@ -1688,7 +1688,7 @@ void CubeMapTextureGLTest::compressedSubImageQueryViewBadFormat() {
     #endif
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
 
     CubeMapTexture texture;
     texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, Vector2i{12});
@@ -1708,13 +1708,13 @@ void CubeMapTextureGLTest::compressedSubImageQueryBuffer() {
     setTestCaseDescription(CompressedPixelStorageData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
     if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     if(CompressedPixelStorageData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
-        CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported.");
 
     CubeMapTexture texture;
     texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, Vector2i{12})
@@ -1740,7 +1740,7 @@ void CubeMapTextureGLTest::fullImageQuery() {
     setTestCaseDescription(FullPixelStorageData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::direct_state_access>())
-        CORRADE_SKIP(Extensions::ARB::direct_state_access::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::direct_state_access::string() << "is not supported.");
 
     CubeMapTexture texture;
     texture.setStorage(1, TextureFormat::RGBA8, Vector2i{2, 2})
@@ -1769,7 +1769,7 @@ void CubeMapTextureGLTest::fullImageQueryView() {
     setTestCaseDescription(FullPixelStorageData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::direct_state_access>())
-        CORRADE_SKIP(Extensions::ARB::direct_state_access::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::direct_state_access::string() << "is not supported.");
 
     CubeMapTexture texture;
     texture.setStorage(1, TextureFormat::RGBA8, Vector2i{2, 2})
@@ -1838,7 +1838,7 @@ void CubeMapTextureGLTest::fullImageQueryBuffer() {
     setTestCaseDescription(FullPixelStorageData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::direct_state_access>())
-        CORRADE_SKIP(Extensions::ARB::direct_state_access::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::direct_state_access::string() << "is not supported.");
 
     CubeMapTexture texture;
     texture.setStorage(1, TextureFormat::RGBA8, Vector2i{2})
@@ -1869,11 +1869,11 @@ void CubeMapTextureGLTest::compressedFullImageQuery() {
     setTestCaseDescription(CompressedFullPixelStorageData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::direct_state_access>())
-        CORRADE_SKIP(Extensions::ARB::direct_state_access::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::direct_state_access::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
     if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
 
     CubeMapTexture texture;
     texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, Vector2i{4})
@@ -1919,11 +1919,11 @@ void CubeMapTextureGLTest::compressedFullImageQueryView() {
     setTestCaseDescription(CompressedFullPixelStorageData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::direct_state_access>())
-        CORRADE_SKIP(Extensions::ARB::direct_state_access::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::direct_state_access::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
     if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
 
     CubeMapTexture texture;
     texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, Vector2i{4})
@@ -1973,7 +1973,7 @@ void CubeMapTextureGLTest::compressedFullImageQueryViewNullptr() {
     #endif
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
 
     CubeMapTexture texture;
     texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, Vector2i{4});
@@ -1994,7 +1994,7 @@ void CubeMapTextureGLTest::compressedFullImageQueryViewBadSize() {
     #endif
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
 
     CubeMapTexture texture;
     texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, Vector2i{4});
@@ -2016,7 +2016,7 @@ void CubeMapTextureGLTest::compressedFullImageQueryViewBadDataSize() {
     #endif
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
 
     CubeMapTexture texture;
     texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, Vector2i{4});
@@ -2038,7 +2038,7 @@ void CubeMapTextureGLTest::compressedFullImageQueryViewBadFormat() {
     #endif
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
 
     CubeMapTexture texture;
     texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, Vector2i{4});
@@ -2058,11 +2058,11 @@ void CubeMapTextureGLTest::compressedFullImageQueryBuffer() {
     setTestCaseDescription(CompressedFullPixelStorageData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::direct_state_access>())
-        CORRADE_SKIP(Extensions::ARB::direct_state_access::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::direct_state_access::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
     if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
 
     CubeMapTexture texture;
     texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, Vector2i{4})

src/Magnum/GL/Test/DebugOutputGLTest.cpp

@@ -71,7 +71,7 @@ DebugOutputGLTest::DebugOutputGLTest() {
 
 void DebugOutputGLTest::setCallbackDefault() {
     if(!Context::current().isExtensionSupported<Extensions::KHR::debug>())
-        CORRADE_SKIP(Extensions::KHR::debug::string() + std::string(" is not supported"));
+        CORRADE_SKIP(Extensions::KHR::debug::string() << "is not supported.");
 
     DebugOutput::setDefaultCallback();
 
@@ -102,7 +102,7 @@ void DebugOutputGLTest::teardown() {
 
 void DebugOutputGLTest::setEnabled() {
     if(!Context::current().isExtensionSupported<Extensions::KHR::debug>())
-        CORRADE_SKIP(Extensions::KHR::debug::string() + std::string(" is not supported"));
+        CORRADE_SKIP(Extensions::KHR::debug::string() << "is not supported.");
 
     /* Try at least some combinations. Calling a less-specific version will
        reset the more-specific setting from earlier. */
@@ -142,7 +142,7 @@ void DebugOutputGLTest::messageNoOp() {
 
 void DebugOutputGLTest::message() {
     if(!Context::current().isExtensionSupported<Extensions::KHR::debug>())
-        CORRADE_SKIP(Extensions::KHR::debug::string() + std::string(" is not supported"));
+        CORRADE_SKIP(Extensions::KHR::debug::string() << "is not supported.");
 
     /* Need to be careful, because the test runner is using debug output too */
     DebugMessage::insert(DebugMessage::Source::Application, DebugMessage::Type::Marker,
@@ -185,7 +185,7 @@ void DebugOutputGLTest::groupNoOp() {
 
 void DebugOutputGLTest::group() {
     if(!Context::current().isExtensionSupported<Extensions::KHR::debug>())
-        CORRADE_SKIP(Extensions::KHR::debug::string() + std::string(" is not supported"));
+        CORRADE_SKIP(Extensions::KHR::debug::string() << "is not supported.");
 
     /* Need to be careful, because the test runner is using debug output too */
     {

src/Magnum/GL/Test/FramebufferGLTest.cpp

@@ -326,7 +326,7 @@ FramebufferGLTest::FramebufferGLTest() {
 void FramebufferGLTest::construct() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     #endif
 
     {
@@ -343,7 +343,7 @@ void FramebufferGLTest::construct() {
 void FramebufferGLTest::constructMove() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     #endif
 
     Framebuffer a({{32, 16}, {128, 256}});
@@ -375,7 +375,7 @@ void FramebufferGLTest::constructMove() {
 void FramebufferGLTest::wrap() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     #endif
 
     GLuint id;
@@ -396,7 +396,7 @@ void FramebufferGLTest::wrap() {
 void FramebufferGLTest::label() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     #endif
 
     /* No-Op version is tested in AbstractObjectGLTest */
@@ -419,7 +419,7 @@ void FramebufferGLTest::label() {
 void FramebufferGLTest::attachRenderbuffer() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     #endif
 
     Renderbuffer color;
@@ -471,7 +471,7 @@ void FramebufferGLTest::attachRenderbuffer() {
 void FramebufferGLTest::attachRenderbufferMultisample() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_GLES2)
     if(!Context::current().isExtensionSupported<Extensions::ANGLE::framebuffer_multisample>() &&
        !Context::current().isExtensionSupported<Extensions::NV::framebuffer_multisample>())
@@ -510,7 +510,7 @@ void FramebufferGLTest::attachRenderbufferMultisample() {
 #ifndef MAGNUM_TARGET_GLES
 void FramebufferGLTest::attachTexture1D() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
 
     Texture1D color;
     color.setStorage(1, TextureFormat::RGBA8, 128);
@@ -531,7 +531,7 @@ void FramebufferGLTest::attachTexture1D() {
 void FramebufferGLTest::attachTexture2D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     #endif
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -602,10 +602,10 @@ void FramebufferGLTest::attachTexture2D() {
 void FramebufferGLTest::attachTexture3D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_GLES2)
     if(!Context::current().isExtensionSupported<Extensions::OES::texture_3D>())
-        CORRADE_SKIP(Extensions::OES::texture_3D::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::OES::texture_3D::string() << "is not supported.");
     #endif
 
     Texture3D color;
@@ -629,9 +629,9 @@ void FramebufferGLTest::attachTexture3D() {
 #ifndef MAGNUM_TARGET_GLES
 void FramebufferGLTest::attachTexture1DArray() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
 
     Texture1DArray color;
     color.setStorage(1, TextureFormat::RGBA8, {128, 8});
@@ -653,9 +653,9 @@ void FramebufferGLTest::attachTexture1DArray() {
 void FramebufferGLTest::attachTexture2DArray() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
     #endif
 
     Texture2DArray color;
@@ -678,9 +678,9 @@ void FramebufferGLTest::attachTexture2DArray() {
 void FramebufferGLTest::attachTexture2DMultisample() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_multisample>())
-        CORRADE_SKIP(Extensions::ARB::texture_multisample::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::texture_multisample::string() << "is not supported.");
     #else
     if(!Context::current().isVersionSupported(Version::GLES310))
         CORRADE_SKIP("OpenGL ES 3.1 is not supported.");
@@ -708,12 +708,12 @@ void FramebufferGLTest::attachTexture2DMultisample() {
 void FramebufferGLTest::attachTexture2DMultisampleArray() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_multisample>())
-        CORRADE_SKIP(Extensions::ARB::texture_multisample::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::texture_multisample::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::OES::texture_storage_multisample_2d_array>())
-        CORRADE_SKIP(Extensions::OES::texture_storage_multisample_2d_array::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::OES::texture_storage_multisample_2d_array::string() << "is not supported.");
     #endif
 
     MultisampleTexture2DArray color;
@@ -739,9 +739,9 @@ void FramebufferGLTest::attachTexture2DMultisampleArray() {
 #ifndef MAGNUM_TARGET_GLES
 void FramebufferGLTest::attachRectangleTexture() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_rectangle>())
-        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() << "is not supported.");
 
     RectangleTexture color;
     color.setStorage(TextureFormat::RGBA8, Vector2i(128));
@@ -762,7 +762,7 @@ void FramebufferGLTest::attachRectangleTexture() {
 void FramebufferGLTest::attachCubeMapTexture() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     #endif
 
     Framebuffer framebuffer({{}, Vector2i(128)});
@@ -823,12 +823,12 @@ void FramebufferGLTest::attachCubeMapTexture() {
 void FramebufferGLTest::attachCubeMapTextureArray() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() << "is not supported.");
     #endif
 
     CubeMapTextureArray color;
@@ -851,12 +851,12 @@ void FramebufferGLTest::attachCubeMapTextureArray() {
 void FramebufferGLTest::attachLayeredTexture3D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::geometry_shader4>())
-        CORRADE_SKIP(Extensions::ARB::geometry_shader4::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::geometry_shader4::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::geometry_shader>())
-        CORRADE_SKIP(Extensions::EXT::geometry_shader::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::EXT::geometry_shader::string() << "is not supported.");
     #endif
 
     Texture3D color;
@@ -873,9 +873,9 @@ void FramebufferGLTest::attachLayeredTexture3D() {
 #ifndef MAGNUM_TARGET_GLES
 void FramebufferGLTest::attachLayeredTexture1DArray() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::geometry_shader4>())
-        CORRADE_SKIP(Extensions::ARB::geometry_shader4::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::geometry_shader4::string() << "is not supported.");
 
     Texture1DArray color;
     color.setStorage(1, TextureFormat::RGBA8, {128, 8});
@@ -896,12 +896,12 @@ void FramebufferGLTest::attachLayeredTexture1DArray() {
 void FramebufferGLTest::attachLayeredTexture2DArray() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::geometry_shader4>())
-        CORRADE_SKIP(Extensions::ARB::geometry_shader4::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::geometry_shader4::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::geometry_shader>())
-        CORRADE_SKIP(Extensions::EXT::geometry_shader::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::EXT::geometry_shader::string() << "is not supported.");
     #endif
 
     Texture2DArray color;
@@ -922,12 +922,12 @@ void FramebufferGLTest::attachLayeredTexture2DArray() {
 void FramebufferGLTest::attachLayeredCubeMapTexture() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::geometry_shader4>())
-        CORRADE_SKIP(Extensions::ARB::geometry_shader4::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::geometry_shader4::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::geometry_shader>())
-        CORRADE_SKIP(Extensions::EXT::geometry_shader::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::EXT::geometry_shader::string() << "is not supported.");
     #endif
 
     CubeMapTexture color;
@@ -948,16 +948,16 @@ void FramebufferGLTest::attachLayeredCubeMapTexture() {
 void FramebufferGLTest::attachLayeredCubeMapTextureArray() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::geometry_shader4>())
-        CORRADE_SKIP(Extensions::ARB::geometry_shader4::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::geometry_shader4::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::geometry_shader>())
-        CORRADE_SKIP(Extensions::EXT::geometry_shader::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::EXT::geometry_shader::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() << "is not supported.");
     #endif
 
     CubeMapTextureArray color;
@@ -978,16 +978,16 @@ void FramebufferGLTest::attachLayeredCubeMapTextureArray() {
 void FramebufferGLTest::attachLayeredTexture2DMultisampleArray() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::geometry_shader4>())
-        CORRADE_SKIP(Extensions::ARB::geometry_shader4::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::geometry_shader4::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_multisample>())
-        CORRADE_SKIP(Extensions::ARB::texture_multisample::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::texture_multisample::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::geometry_shader>())
-        CORRADE_SKIP(Extensions::EXT::geometry_shader::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::EXT::geometry_shader::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::OES::texture_storage_multisample_2d_array>())
-        CORRADE_SKIP(Extensions::OES::texture_storage_multisample_2d_array::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::OES::texture_storage_multisample_2d_array::string() << "is not supported.");
     #endif
 
     MultisampleTexture2DArray color;
@@ -1013,7 +1013,7 @@ void FramebufferGLTest::attachLayeredTexture2DMultisampleArray() {
 void FramebufferGLTest::detach() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     #endif
 
     Framebuffer framebuffer({{}, Vector2i(128)});
@@ -1027,11 +1027,11 @@ void FramebufferGLTest::detach() {
 void FramebufferGLTest::multipleColorOutputs() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_GLES2)
     #ifdef MAGNUM_TARGET_WEBGL
     if(!Context::current().isExtensionSupported<Extensions::WEBGL::draw_buffers>())
-        CORRADE_SKIP(Extensions::WEBGL::draw_buffers::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::WEBGL::draw_buffers::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::draw_buffers>() &&
        !Context::current().isExtensionSupported<Extensions::NV::draw_buffers>())
@@ -1095,7 +1095,7 @@ void FramebufferGLTest::multipleColorOutputs() {
 void FramebufferGLTest::clear() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     #endif
 
     Renderbuffer color;
@@ -1368,7 +1368,7 @@ void FramebufferGLTest::clearDepthStencil() {
 void FramebufferGLTest::invalidate() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     #endif
 
     Renderbuffer color;
@@ -1397,7 +1397,7 @@ void FramebufferGLTest::invalidate() {
 void FramebufferGLTest::invalidateSub() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     #endif
 
     Renderbuffer color;
@@ -1429,7 +1429,7 @@ void FramebufferGLTest::read() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     #endif
 
     Renderbuffer color;
@@ -1560,7 +1560,7 @@ void FramebufferGLTest::readView() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     #endif
 
     Renderbuffer color;
@@ -1610,7 +1610,7 @@ void FramebufferGLTest::readViewNullptr() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     #endif
 
     Renderbuffer color;
@@ -1638,7 +1638,7 @@ void FramebufferGLTest::readViewBadSize() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     #endif
 
     Renderbuffer color;
@@ -1664,7 +1664,7 @@ void FramebufferGLTest::readViewBadSize() {
 void FramebufferGLTest::readBuffer() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     #endif
 
     Renderbuffer color;
@@ -1712,7 +1712,7 @@ constexpr char ZeroStorage[4*4*4*6]{};
 #ifndef MAGNUM_TARGET_GLES
 void FramebufferGLTest::copyImageTexture1D() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
 
     Texture2D storage;
     storage.setStorage(1, TextureFormat::RGBA8, Vector2i{4})
@@ -1736,7 +1736,7 @@ void FramebufferGLTest::copyImageTexture1D() {
 void FramebufferGLTest::copyImageTexture2D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     #endif
 
     Texture2D storage;
@@ -1780,9 +1780,9 @@ void FramebufferGLTest::copyImageTexture2D() {
 #ifndef MAGNUM_TARGET_GLES
 void FramebufferGLTest::copyImageTexture1DArray() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
 
     Texture2D storage;
     storage.setStorage(1, TextureFormat::RGBA8, Vector2i{4})
@@ -1806,9 +1806,9 @@ void FramebufferGLTest::copyImageTexture1DArray() {
 
 void FramebufferGLTest::copyImageRectangleTexture() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_rectangle>())
-        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() << "is not supported.");
 
     Texture2D storage;
     storage.setStorage(1, TextureFormat::RGBA8, Vector2i{4})
@@ -1834,7 +1834,7 @@ void FramebufferGLTest::copyImageRectangleTexture() {
 void FramebufferGLTest::copyImageCubeMapTexture() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     #endif
 
     #ifndef MAGNUM_TARGET_GLES2
@@ -1885,7 +1885,7 @@ void FramebufferGLTest::copyImageCubeMapTexture() {
 #ifndef MAGNUM_TARGET_GLES
 void FramebufferGLTest::copySubImageTexture1D() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
 
     Texture2D storage;
     storage.setStorage(1, TextureFormat::RGBA8, Vector2i{4})
@@ -1911,7 +1911,7 @@ void FramebufferGLTest::copySubImageTexture1D() {
 void FramebufferGLTest::copySubImageTexture2D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     #endif
 
     Texture2D storage;
@@ -1959,10 +1959,10 @@ void FramebufferGLTest::copySubImageTexture2D() {
 void FramebufferGLTest::copySubImageTexture3D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_GLES2)
     if(!Context::current().isExtensionSupported<Extensions::OES::texture_3D>())
-        CORRADE_SKIP(Extensions::OES::texture_3D::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::OES::texture_3D::string() << "is not supported.");
     #endif
 
     Texture2D storage;
@@ -2011,9 +2011,9 @@ void FramebufferGLTest::copySubImageTexture3D() {
 #ifndef MAGNUM_TARGET_GLES
 void FramebufferGLTest::copySubImageTexture1DArray() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
 
     Texture2D storage;
     storage.setStorage(1, TextureFormat::RGBA8, Vector2i{4})
@@ -2043,9 +2043,9 @@ void FramebufferGLTest::copySubImageTexture1DArray() {
 void FramebufferGLTest::copySubImageTexture2DArray() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
     #endif
 
     Texture2D storage;
@@ -2082,9 +2082,9 @@ void FramebufferGLTest::copySubImageTexture2DArray() {
 #ifndef MAGNUM_TARGET_GLES
 void FramebufferGLTest::copySubImageRectangleTexture() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_rectangle>())
-        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() << "is not supported.");
 
     Texture2D storage;
     storage.setStorage(1, TextureFormat::RGBA8, Vector2i{4})
@@ -2113,7 +2113,7 @@ void FramebufferGLTest::copySubImageRectangleTexture() {
 void FramebufferGLTest::copySubImageCubeMapTexture() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     #endif
 
     Texture2D storage;
@@ -2161,12 +2161,12 @@ void FramebufferGLTest::copySubImageCubeMapTexture() {
 void FramebufferGLTest::copySubImageCubeMapTextureArray() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_cube_map_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::EXT::texture_cube_map_array::string() << "is not supported.");
     #endif
 
     Texture2D storage;
@@ -2224,7 +2224,7 @@ void FramebufferGLTest::copySubImageCubeMapTextureArray() {
 void FramebufferGLTest::blit() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_GLES2)
     if(!Context::current().isExtensionSupported<Extensions::NV::framebuffer_blit>() &&
        !Context::current().isExtensionSupported<Extensions::ANGLE::framebuffer_blit>())
@@ -2277,7 +2277,7 @@ void FramebufferGLTest::implementationColorReadFormat() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(data.integer && !GL::Context::current().isExtensionSupported<GL::Extensions::EXT::texture_integer>())
-        CORRADE_SKIP(GL::Extensions::EXT::texture_integer::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::EXT::texture_integer::string() << "is not supported.");
     #endif
 
     Renderbuffer color;

src/Magnum/GL/Test/MeshGLTest.cpp

@@ -468,10 +468,10 @@ void MeshGLTest::constructMove() {
 void MeshGLTest::wrap() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::vertex_array_object>())
-        CORRADE_SKIP(Extensions::ARB::vertex_array_object::string() + std::string{" is not supported."});
+        CORRADE_SKIP(Extensions::ARB::vertex_array_object::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_GLES2)
     if(!Context::current().isExtensionSupported<Extensions::OES::vertex_array_object>())
-        CORRADE_SKIP(Extensions::OES::vertex_array_object::string() + std::string{" is not supported."});
+        CORRADE_SKIP(Extensions::OES::vertex_array_object::string() << "is not supported.");
     #endif
 
     GLuint id;
@@ -514,10 +514,10 @@ template<class T> void MeshGLTest::primitive() {
 void MeshGLTest::label() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::vertex_array_object>())
-        CORRADE_SKIP(Extensions::ARB::vertex_array_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::vertex_array_object::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_GLES2)
     if(!Context::current().isExtensionSupported<Extensions::OES::vertex_array_object>())
-        CORRADE_SKIP(Extensions::OES::vertex_array_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::OES::vertex_array_object::string() << "is not supported.");
     #endif
 
     /* No-Op version is tested in AbstractObjectGLTest */
@@ -730,7 +730,7 @@ template<class T> T Checker::get(PixelFormat format, PixelType type) {
 void MeshGLTest::addVertexBufferUnsignedInt() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::gpu_shader4>())
-        CORRADE_SKIP(Extensions::EXT::gpu_shader4::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::EXT::gpu_shader4::string() << "is not supported.");
     #endif
 
     constexpr UnsignedInt data[] = { 0, 157, 35681 };
@@ -763,7 +763,7 @@ void MeshGLTest::addVertexBufferUnsignedInt() {
 void MeshGLTest::addVertexBufferInt() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::gpu_shader4>())
-        CORRADE_SKIP(Extensions::EXT::gpu_shader4::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::EXT::gpu_shader4::string() << "is not supported.");
     #endif
 
     constexpr Int data[] = { 0, 457931, 27530 };
@@ -843,7 +843,7 @@ void MeshGLTest::addVertexBufferFloat() {
 #ifndef MAGNUM_TARGET_GLES
 void MeshGLTest::addVertexBufferDouble() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::vertex_attrib_64bit>())
-        CORRADE_SKIP(Extensions::ARB::vertex_attrib_64bit::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::vertex_attrib_64bit::string() << "is not supported.");
 
     const Double data[] = { 0.0, -0.7, Math::unpack<Double, UnsignedShort>(45828) };
     Buffer buffer;
@@ -877,7 +877,7 @@ void MeshGLTest::addVertexBufferDouble() {
 void MeshGLTest::addVertexBufferVectorNui() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::gpu_shader4>())
-        CORRADE_SKIP(Extensions::EXT::gpu_shader4::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::EXT::gpu_shader4::string() << "is not supported.");
     #endif
 
     constexpr Vector3ui data[] = { {}, {37448, 547686, 156}, {27592, 157, 25} };
@@ -910,7 +910,7 @@ void MeshGLTest::addVertexBufferVectorNui() {
 void MeshGLTest::addVertexBufferVectorNi() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::gpu_shader4>())
-        CORRADE_SKIP(Extensions::EXT::gpu_shader4::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::EXT::gpu_shader4::string() << "is not supported.");
     #endif
 
     constexpr Vector2i data[] = { {}, {-37448, 547686}, {27592, -157} };
@@ -990,7 +990,7 @@ void MeshGLTest::addVertexBufferVectorN() {
 #ifndef MAGNUM_TARGET_GLES
 void MeshGLTest::addVertexBufferVectorNd() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::vertex_attrib_64bit>())
-        CORRADE_SKIP(Extensions::ARB::vertex_attrib_64bit::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::vertex_attrib_64bit::string() << "is not supported.");
 
     const Vector4d data[] = {
         {}, {0.0, -0.9, 1.0, 1.25},
@@ -1077,7 +1077,7 @@ void MeshGLTest::addVertexBufferMatrixNxN() {
 #ifndef MAGNUM_TARGET_GLES
 void MeshGLTest::addVertexBufferMatrixNxNd() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::vertex_attrib_64bit>())
-        CORRADE_SKIP(Extensions::ARB::vertex_attrib_64bit::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::vertex_attrib_64bit::string() << "is not supported.");
 
     const Matrix3x3d data[] = {
         {},
@@ -1161,7 +1161,7 @@ void MeshGLTest::addVertexBufferMatrixMxN() {
 #ifndef MAGNUM_TARGET_GLES
 void MeshGLTest::addVertexBufferMatrixMxNd() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::vertex_attrib_64bit>())
-        CORRADE_SKIP(Extensions::ARB::vertex_attrib_64bit::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::vertex_attrib_64bit::string() << "is not supported.");
 
     const Matrix3x4d data[] = {
         {},
@@ -1211,7 +1211,7 @@ void MeshGLTest::addVertexBufferMatrixMxNd() {
 void MeshGLTest::addVertexBufferUnsignedIntWithUnsignedShort() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::gpu_shader4>())
-        CORRADE_SKIP(Extensions::EXT::gpu_shader4::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::EXT::gpu_shader4::string() << "is not supported.");
     #endif
 
     constexpr UnsignedShort data[] = { 0, 49563, 2128, 3821, 16583 };
@@ -1249,7 +1249,7 @@ void MeshGLTest::addVertexBufferUnsignedIntWithUnsignedShort() {
 void MeshGLTest::addVertexBufferUnsignedIntWithShort() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::gpu_shader4>())
-        CORRADE_SKIP(Extensions::EXT::gpu_shader4::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::EXT::gpu_shader4::string() << "is not supported.");
     #endif
 
     constexpr Short data[] = { 0, 24563, 2128, 3821, 16583 };
@@ -1287,7 +1287,7 @@ void MeshGLTest::addVertexBufferUnsignedIntWithShort() {
 void MeshGLTest::addVertexBufferIntWithUnsignedShort() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::gpu_shader4>())
-        CORRADE_SKIP(Extensions::EXT::gpu_shader4::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::EXT::gpu_shader4::string() << "is not supported.");
     #endif
 
     constexpr UnsignedShort data[] = { 0, 49563, 2128, 3821, 16583 };
@@ -1325,7 +1325,7 @@ void MeshGLTest::addVertexBufferIntWithUnsignedShort() {
 void MeshGLTest::addVertexBufferIntWithShort() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::gpu_shader4>())
-        CORRADE_SKIP(Extensions::EXT::gpu_shader4::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::EXT::gpu_shader4::string() << "is not supported.");
     #endif
 
     constexpr Short data[] = { 0, 24563, 2128, 3821, -16583 };
@@ -1365,10 +1365,10 @@ void MeshGLTest::addVertexBufferIntWithShort() {
 void MeshGLTest::addVertexBufferFloatWithHalf() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::half_float_vertex>())
-        CORRADE_SKIP(Extensions::ARB::half_float_vertex::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::half_float_vertex::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_GLES2)
     if(!Context::current().isExtensionSupported<Extensions::OES::vertex_half_float>())
-        CORRADE_SKIP(Extensions::OES::vertex_half_float::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::OES::vertex_half_float::string() << "is not supported.");
     #endif
 
     const Half data[] = { 0.0_h, -0.7_h, Half(Math::unpack<Float, UnsignedByte>(186)) };
@@ -1432,7 +1432,7 @@ void MeshGLTest::addVertexBufferFloatWithDouble() {
 void MeshGLTest::addVertexBufferVector3WithUnsignedInt10f11f11fRev() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::vertex_type_10f_11f_11f_rev>())
-        CORRADE_SKIP(Extensions::ARB::vertex_type_10f_11f_11f_rev::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::vertex_type_10f_11f_11f_rev::string() << "is not supported.");
     #endif
 
     Buffer buffer;
@@ -1461,7 +1461,7 @@ void MeshGLTest::addVertexBufferVector3WithUnsignedInt10f11f11fRev() {
 void MeshGLTest::addVertexBufferVector4WithUnsignedInt2101010Rev() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::vertex_type_2_10_10_10_rev>())
-        CORRADE_SKIP(Extensions::ARB::vertex_type_2_10_10_10_rev::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::vertex_type_2_10_10_10_rev::string() << "is not supported.");
     #endif
 
     Buffer buffer;
@@ -1488,7 +1488,7 @@ void MeshGLTest::addVertexBufferVector4WithUnsignedInt2101010Rev() {
 void MeshGLTest::addVertexBufferVector4WithInt2101010Rev() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::vertex_type_2_10_10_10_rev>())
-        CORRADE_SKIP(Extensions::ARB::vertex_type_2_10_10_10_rev::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::vertex_type_2_10_10_10_rev::string() << "is not supported.");
     #endif
 
     Buffer buffer;
@@ -1610,7 +1610,7 @@ void MeshGLTest::addVertexBufferNormalized() {
 #ifndef MAGNUM_TARGET_GLES
 void MeshGLTest::addVertexBufferBGRA() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::vertex_array_bgra>())
-        CORRADE_SKIP(Extensions::ARB::vertex_array_bgra::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::vertex_array_bgra::string() << "is not supported.");
 
     constexpr Color4ub data[] = { {}, {0, 128, 64, 161}, {96, 24, 156, 225} };
     Buffer buffer;
@@ -1870,7 +1870,7 @@ void MeshGLTest::addVertexBufferTransferOwnwership() {
 void MeshGLTest::addVertexBufferInstancedTransferOwnwership() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::draw_instanced>())
-        CORRADE_SKIP(Extensions::ARB::draw_instanced::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::draw_instanced::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_GLES2)
     #ifndef MAGNUM_TARGET_WEBGL
     if(!Context::current().isExtensionSupported<Extensions::ANGLE::instanced_arrays>() &&
@@ -1879,7 +1879,7 @@ void MeshGLTest::addVertexBufferInstancedTransferOwnwership() {
         CORRADE_SKIP("Required extension is not available.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::ANGLE::instanced_arrays>())
-        CORRADE_SKIP(Extensions::ANGLE::instanced_arrays::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ANGLE::instanced_arrays::string() << "is not supported.");
     #endif
     #endif
 
@@ -1945,7 +1945,7 @@ void MeshGLTest::addVertexBufferDynamicTransferOwnwership() {
 void MeshGLTest::addVertexBufferInstancedDynamicTransferOwnwership() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::draw_instanced>())
-        CORRADE_SKIP(Extensions::ARB::draw_instanced::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::draw_instanced::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_GLES2)
     #ifndef MAGNUM_TARGET_WEBGL
     if(!Context::current().isExtensionSupported<Extensions::ANGLE::instanced_arrays>() &&
@@ -1954,7 +1954,7 @@ void MeshGLTest::addVertexBufferInstancedDynamicTransferOwnwership() {
         CORRADE_SKIP("Required extension is not available.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::ANGLE::instanced_arrays>())
-        CORRADE_SKIP(Extensions::ANGLE::instanced_arrays::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ANGLE::instanced_arrays::string() << "is not supported.");
     #endif
     #endif
 
@@ -2120,7 +2120,7 @@ template<class T> void MeshGLTest::setIndexBufferRange() {
 void MeshGLTest::setIndexBufferUnsignedInt() {
     #ifdef MAGNUM_TARGET_GLES2
     if(!Context::current().isExtensionSupported<Extensions::OES::element_index_uint>())
-        CORRADE_SKIP(Extensions::OES::element_index_uint::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::OES::element_index_uint::string() << "is not supported.");
     #endif
 
     Buffer vertices;
@@ -2232,12 +2232,12 @@ template<class T> void MeshGLTest::setIndexBufferRangeTransferOwnership() {
 void MeshGLTest::unbindVAOWhenSettingIndexBufferData() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::vertex_array_object>())
-        CORRADE_SKIP(Extensions::ARB::vertex_array_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::vertex_array_object::string() << "is not supported.");
     if(Context::current().isExtensionSupported<Extensions::ARB::direct_state_access>())
         CORRADE_SKIP(Extensions::ARB::direct_state_access::string() + std::string(" is active which circumvents the issue tested here."));
     #elif defined(MAGNUM_TARGET_GLES2)
     if(!Context::current().isExtensionSupported<Extensions::OES::vertex_array_object>())
-        CORRADE_SKIP(Extensions::OES::vertex_array_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::OES::vertex_array_object::string() << "is not supported.");
     #endif
 
     typedef Attribute<0, Float> Attribute;
@@ -2287,12 +2287,12 @@ void MeshGLTest::unbindVAOWhenSettingIndexBufferData() {
 void MeshGLTest::unbindIndexBufferWhenBindingVao() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::vertex_array_object>())
-        CORRADE_SKIP(Extensions::ARB::vertex_array_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::vertex_array_object::string() << "is not supported.");
     if(Context::current().isExtensionSupported<Extensions::ARB::direct_state_access>())
         CORRADE_SKIP(Extensions::ARB::direct_state_access::string() + std::string(" is active which circumvents the issue tested here."));
     #elif defined(MAGNUM_TARGET_GLES2)
     if(!Context::current().isExtensionSupported<Extensions::OES::vertex_array_object>())
-        CORRADE_SKIP(Extensions::OES::vertex_array_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::OES::vertex_array_object::string() << "is not supported.");
     #endif
 
     typedef Attribute<0, Float> Attribute;
@@ -2349,12 +2349,12 @@ void MeshGLTest::unbindIndexBufferWhenBindingVao() {
 void MeshGLTest::resetIndexBufferBindingWhenBindingVao() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::vertex_array_object>())
-        CORRADE_SKIP(Extensions::ARB::vertex_array_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::vertex_array_object::string() << "is not supported.");
     if(Context::current().isExtensionSupported<Extensions::ARB::direct_state_access>())
         CORRADE_SKIP(Extensions::ARB::direct_state_access::string() + std::string(" is active which circumvents the issue tested here."));
     #elif defined(MAGNUM_TARGET_GLES2)
     if(!Context::current().isExtensionSupported<Extensions::OES::vertex_array_object>())
-        CORRADE_SKIP(Extensions::OES::vertex_array_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::OES::vertex_array_object::string() << "is not supported.");
     #endif
 
     typedef Attribute<0, Float> Attribute;
@@ -2409,10 +2409,10 @@ void MeshGLTest::resetIndexBufferBindingWhenBindingVao() {
 void MeshGLTest::unbindVAOBeforeEnteringExternalSection() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::vertex_array_object>())
-        CORRADE_SKIP(Extensions::ARB::vertex_array_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::vertex_array_object::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_GLES2)
     if(!Context::current().isExtensionSupported<Extensions::OES::vertex_array_object>())
-        CORRADE_SKIP(Extensions::OES::vertex_array_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::OES::vertex_array_object::string() << "is not supported.");
     #endif
 
     typedef Attribute<0, Float> Attribute;
@@ -2539,7 +2539,7 @@ void MeshGLTest::bindScratchVaoWhenEnteringExternalSection() {
 void MeshGLTest::setBaseVertex() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::draw_elements_base_vertex>())
-        CORRADE_SKIP(Extensions::ARB::draw_elements_base_vertex::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::draw_elements_base_vertex::string() << "is not supported.");
     #elif !defined(MAGNUM_TARGET_WEBGL)
     if(!Context::current().isExtensionSupported<Extensions::OES::draw_elements_base_vertex>() &&
        !Context::current().isExtensionSupported<Extensions::EXT::draw_elements_base_vertex>())
@@ -2646,7 +2646,7 @@ void MeshGLTest::setInstanceCount() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::draw_instanced>())
-        CORRADE_SKIP(Extensions::ARB::draw_instanced::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::draw_instanced::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_GLES2)
     #ifndef MAGNUM_TARGET_WEBGL
     if(!Context::current().isExtensionSupported<Extensions::ANGLE::instanced_arrays>() &&
@@ -2657,7 +2657,7 @@ void MeshGLTest::setInstanceCount() {
         CORRADE_SKIP("Required extension is not available.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::ANGLE::instanced_arrays>())
-        CORRADE_SKIP(Extensions::ANGLE::instanced_arrays::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ANGLE::instanced_arrays::string() << "is not supported.");
     #endif
     #endif
 
@@ -2695,9 +2695,9 @@ void MeshGLTest::setInstanceCountBaseInstance() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::draw_instanced>())
-        CORRADE_SKIP(Extensions::ARB::draw_instanced::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::draw_instanced::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::base_instance>())
-        CORRADE_SKIP(Extensions::ARB::base_instance::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::base_instance::string() << "is not supported.");
     #elif !defined(MAGNUM_TARGET_WEBGL)
     if(!Context::current().isExtensionSupported<Extensions::ANGLE::base_vertex_base_instance>())
         CORRADE_SKIP(Extensions::ANGLE::base_vertex_base_instance::string() + std::string{" is not available."});
@@ -2759,7 +2759,7 @@ void MeshGLTest::setInstanceCountIndexed() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::draw_instanced>())
-        CORRADE_SKIP(Extensions::ARB::draw_instanced::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::draw_instanced::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_GLES2)
     #ifndef MAGNUM_TARGET_WEBGL
     if(!Context::current().isExtensionSupported<Extensions::ANGLE::instanced_arrays>() &&
@@ -2770,7 +2770,7 @@ void MeshGLTest::setInstanceCountIndexed() {
         CORRADE_SKIP("Required extension is not available.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::ANGLE::instanced_arrays>())
-        CORRADE_SKIP(Extensions::ANGLE::instanced_arrays::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ANGLE::instanced_arrays::string() << "is not supported.");
     #endif
     #endif
 
@@ -2810,9 +2810,9 @@ void MeshGLTest::setInstanceCountIndexedBaseInstance() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::draw_instanced>())
-        CORRADE_SKIP(Extensions::ARB::draw_instanced::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::draw_instanced::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::base_instance>())
-        CORRADE_SKIP(Extensions::ARB::base_instance::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::base_instance::string() << "is not supported.");
     #elif !defined(MAGNUM_TARGET_WEBGL)
     if(!Context::current().isExtensionSupported<Extensions::ANGLE::base_vertex_base_instance>())
         CORRADE_SKIP(Extensions::ANGLE::base_vertex_base_instance::string() + std::string{" is not available."});
@@ -2881,9 +2881,9 @@ void MeshGLTest::setInstanceCountIndexedBaseVertex() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::draw_instanced>())
-        CORRADE_SKIP(Extensions::ARB::draw_instanced::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::draw_instanced::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::draw_elements_base_vertex>())
-        CORRADE_SKIP(Extensions::ARB::draw_elements_base_vertex::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::draw_elements_base_vertex::string() << "is not supported.");
     #elif !defined(MAGNUM_TARGET_WEBGL)
     if(!Context::current().isExtensionSupported<Extensions::OES::draw_elements_base_vertex>() &&
        !Context::current().isExtensionSupported<Extensions::EXT::draw_elements_base_vertex>())
@@ -2963,11 +2963,11 @@ void MeshGLTest::setInstanceCountIndexedBaseVertexBaseInstance() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::draw_instanced>())
-        CORRADE_SKIP(Extensions::ARB::draw_instanced::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::draw_instanced::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::draw_elements_base_vertex>())
-        CORRADE_SKIP(Extensions::ARB::draw_elements_base_vertex::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::draw_elements_base_vertex::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::base_instance>())
-        CORRADE_SKIP(Extensions::ARB::base_instance::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::base_instance::string() << "is not supported.");
     #elif !defined(MAGNUM_TARGET_WEBGL)
     if(!Context::current().isExtensionSupported<Extensions::ANGLE::base_vertex_base_instance>())
         CORRADE_SKIP(Extensions::ANGLE::base_vertex_base_instance::string() + std::string{" is not available."});
@@ -3036,9 +3036,9 @@ void MeshGLTest::setInstanceCountIndexedBaseVertexBaseInstanceNoExtensionAvailab
 void MeshGLTest::addVertexBufferInstancedFloat() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::draw_instanced>())
-        CORRADE_SKIP(Extensions::ARB::draw_instanced::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::draw_instanced::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::instanced_arrays>())
-        CORRADE_SKIP(Extensions::ARB::instanced_arrays::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::instanced_arrays::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_GLES2)
     #ifndef MAGNUM_TARGET_WEBGL
     if(!Context::current().isExtensionSupported<Extensions::ANGLE::instanced_arrays>() &&
@@ -3047,7 +3047,7 @@ void MeshGLTest::addVertexBufferInstancedFloat() {
         CORRADE_SKIP("Required extension is not available.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::ANGLE::instanced_arrays>())
-        CORRADE_SKIP(Extensions::ANGLE::instanced_arrays::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ANGLE::instanced_arrays::string() << "is not supported.");
     #endif
     #endif
 
@@ -3085,11 +3085,11 @@ void MeshGLTest::addVertexBufferInstancedFloat() {
 void MeshGLTest::addVertexBufferInstancedInteger() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::draw_instanced>())
-        CORRADE_SKIP(Extensions::ARB::draw_instanced::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::draw_instanced::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::instanced_arrays>())
-        CORRADE_SKIP(Extensions::ARB::instanced_arrays::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::instanced_arrays::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::EXT::gpu_shader4>())
-        CORRADE_SKIP(Extensions::EXT::gpu_shader4::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::EXT::gpu_shader4::string() << "is not supported.");
     #endif
 
     typedef Attribute<0, UnsignedInt> Attribute;
@@ -3121,11 +3121,11 @@ void MeshGLTest::addVertexBufferInstancedInteger() {
 #ifndef MAGNUM_TARGET_GLES
 void MeshGLTest::addVertexBufferInstancedDouble() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::draw_instanced>())
-        CORRADE_SKIP(Extensions::ARB::draw_instanced::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::draw_instanced::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::instanced_arrays>())
-        CORRADE_SKIP(Extensions::ARB::instanced_arrays::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::instanced_arrays::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::vertex_attrib_64bit>())
-        CORRADE_SKIP(Extensions::ARB::vertex_attrib_64bit::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::vertex_attrib_64bit::string() << "is not supported.");
 
     typedef Attribute<0, Double> Attribute;
 
@@ -3156,9 +3156,9 @@ void MeshGLTest::addVertexBufferInstancedDouble() {
 void MeshGLTest::resetDivisorAfterInstancedDraw() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::draw_instanced>())
-        CORRADE_SKIP(Extensions::ARB::draw_instanced::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::draw_instanced::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::instanced_arrays>())
-        CORRADE_SKIP(Extensions::ARB::instanced_arrays::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::instanced_arrays::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_GLES2)
     #ifndef MAGNUM_TARGET_WEBGL
     if(!Context::current().isExtensionSupported<Extensions::ANGLE::instanced_arrays>() &&
@@ -3167,7 +3167,7 @@ void MeshGLTest::resetDivisorAfterInstancedDraw() {
         CORRADE_SKIP("Required extension is not available.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::ANGLE::instanced_arrays>())
-        CORRADE_SKIP(Extensions::ANGLE::instanced_arrays::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ANGLE::instanced_arrays::string() << "is not supported.");
     #endif
     #endif
 
@@ -3377,7 +3377,7 @@ void MeshGLTest::multiDrawInstanced() {
 void MeshGLTest::multiDrawBaseVertex() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::draw_elements_base_vertex>())
-        CORRADE_SKIP(Extensions::ARB::draw_elements_base_vertex::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::draw_elements_base_vertex::string() << "is not supported.");
     #elif !defined(MAGNUM_TARGET_WEBGL)
     if(!Context::current().isExtensionSupported<Extensions::OES::draw_elements_base_vertex>() &&
        !Context::current().isExtensionSupported<Extensions::EXT::draw_elements_base_vertex>())

src/Magnum/GL/Test/MultisampleTextureGLTest.cpp

@@ -90,7 +90,7 @@ MultisampleTextureGLTest::MultisampleTextureGLTest() {
 void MultisampleTextureGLTest::construct2D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_multisample>())
-        CORRADE_SKIP(Extensions::ARB::texture_multisample::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_multisample::string() << "is not supported.");
     #else
     if(!Context::current().isVersionSupported(Version::GLES310))
         CORRADE_SKIP("OpenGL ES 3.1 is not supported.");
@@ -109,10 +109,10 @@ void MultisampleTextureGLTest::construct2D() {
 void MultisampleTextureGLTest::construct2DArray() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_multisample>())
-        CORRADE_SKIP(Extensions::ARB::texture_multisample::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_multisample::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::OES::texture_storage_multisample_2d_array>())
-        CORRADE_SKIP(Extensions::OES::texture_storage_multisample_2d_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::OES::texture_storage_multisample_2d_array::string() << "is not supported.");
     #endif
 
     {
@@ -137,7 +137,7 @@ void MultisampleTextureGLTest::constructMove() {
 void MultisampleTextureGLTest::wrap2D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_multisample>())
-        CORRADE_SKIP(Extensions::ARB::texture_multisample::string() + std::string{" is not supported."});
+        CORRADE_SKIP(Extensions::ARB::texture_multisample::string() << "is not supported.");
     #else
     if(!Context::current().isVersionSupported(Version::GLES310))
         CORRADE_SKIP("OpenGL ES 3.1 is not supported.");
@@ -160,10 +160,10 @@ void MultisampleTextureGLTest::wrap2D() {
 void MultisampleTextureGLTest::wrap2DArray() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_multisample>())
-        CORRADE_SKIP(Extensions::ARB::texture_multisample::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_multisample::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::OES::texture_storage_multisample_2d_array>())
-        CORRADE_SKIP(Extensions::OES::texture_storage_multisample_2d_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::OES::texture_storage_multisample_2d_array::string() << "is not supported.");
     #endif
 
     GLuint id;
@@ -183,7 +183,7 @@ void MultisampleTextureGLTest::wrap2DArray() {
 void MultisampleTextureGLTest::bind2D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_multisample>())
-        CORRADE_SKIP(Extensions::ARB::texture_multisample::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_multisample::string() << "is not supported.");
     #else
     if(!Context::current().isVersionSupported(Version::GLES310))
         CORRADE_SKIP("OpenGL ES 3.1 is not supported.");
@@ -210,10 +210,10 @@ void MultisampleTextureGLTest::bind2D() {
 void MultisampleTextureGLTest::bind2DArray() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_multisample>())
-        CORRADE_SKIP(Extensions::ARB::texture_multisample::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_multisample::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::OES::texture_storage_multisample_2d_array>())
-        CORRADE_SKIP(Extensions::OES::texture_storage_multisample_2d_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::OES::texture_storage_multisample_2d_array::string() << "is not supported.");
     #endif
 
     MultisampleTexture2DArray texture;
@@ -237,12 +237,12 @@ void MultisampleTextureGLTest::bind2DArray() {
 void MultisampleTextureGLTest::bindImage2D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_multisample>())
-        CORRADE_SKIP(Extensions::ARB::texture_multisample::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_multisample::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::shader_image_load_store>())
-        CORRADE_SKIP(Extensions::ARB::shader_image_load_store::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::shader_image_load_store::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::OES::texture_storage_multisample_2d_array>())
-        CORRADE_SKIP(Extensions::OES::texture_storage_multisample_2d_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::OES::texture_storage_multisample_2d_array::string() << "is not supported.");
     if(!Context::current().isVersionSupported(Version::GLES310))
         CORRADE_SKIP("OpenGL ES 3.1 is not supported.");
     #endif
@@ -273,12 +273,12 @@ void MultisampleTextureGLTest::bindImage2D() {
 void MultisampleTextureGLTest::bindImage2DArray() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_multisample>())
-        CORRADE_SKIP(Extensions::ARB::texture_multisample::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_multisample::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::shader_image_load_store>())
-        CORRADE_SKIP(Extensions::ARB::shader_image_load_store::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::shader_image_load_store::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::OES::texture_storage_multisample_2d_array>())
-        CORRADE_SKIP(Extensions::OES::texture_storage_multisample_2d_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::OES::texture_storage_multisample_2d_array::string() << "is not supported.");
     if(!Context::current().isVersionSupported(Version::GLES310))
         CORRADE_SKIP("OpenGL ES 3.1 is not supported.");
     #endif
@@ -312,7 +312,7 @@ void MultisampleTextureGLTest::bindImage2DArray() {
 void MultisampleTextureGLTest::storage2D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_multisample>())
-        CORRADE_SKIP(Extensions::ARB::texture_multisample::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_multisample::string() << "is not supported.");
     #else
     if(!Context::current().isVersionSupported(Version::GLES310))
         CORRADE_SKIP("OpenGL ES 3.1 is not supported.");
@@ -333,10 +333,10 @@ void MultisampleTextureGLTest::storage2D() {
 void MultisampleTextureGLTest::storage2DArray() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_multisample>())
-        CORRADE_SKIP(Extensions::ARB::texture_multisample::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_multisample::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::OES::texture_storage_multisample_2d_array>())
-        CORRADE_SKIP(Extensions::OES::texture_storage_multisample_2d_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::OES::texture_storage_multisample_2d_array::string() << "is not supported.");
     #endif
 
     MultisampleTexture2DArray texture;
@@ -354,7 +354,7 @@ void MultisampleTextureGLTest::storage2DArray() {
 void MultisampleTextureGLTest::invalidateImage2D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_multisample>())
-        CORRADE_SKIP(Extensions::ARB::texture_multisample::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_multisample::string() << "is not supported.");
     #else
     if(!Context::current().isVersionSupported(Version::GLES310))
         CORRADE_SKIP("OpenGL ES 3.1 is not supported.");
@@ -372,10 +372,10 @@ void MultisampleTextureGLTest::invalidateImage2D() {
 void MultisampleTextureGLTest::invalidateImage2DArray() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_multisample>())
-        CORRADE_SKIP(Extensions::ARB::texture_multisample::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_multisample::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::OES::texture_storage_multisample_2d_array>())
-        CORRADE_SKIP(Extensions::OES::texture_storage_multisample_2d_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::OES::texture_storage_multisample_2d_array::string() << "is not supported.");
     #endif
 
     MultisampleTexture2DArray texture;
@@ -390,7 +390,7 @@ void MultisampleTextureGLTest::invalidateImage2DArray() {
 void MultisampleTextureGLTest::invalidateSubImage2D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_multisample>())
-        CORRADE_SKIP(Extensions::ARB::texture_multisample::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_multisample::string() << "is not supported.");
     #else
     if(!Context::current().isVersionSupported(Version::GLES310))
         CORRADE_SKIP("OpenGL ES 3.1 is not supported.");
@@ -408,10 +408,10 @@ void MultisampleTextureGLTest::invalidateSubImage2D() {
 void MultisampleTextureGLTest::invalidateSubImage2DArray() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_multisample>())
-        CORRADE_SKIP(Extensions::ARB::texture_multisample::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_multisample::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::OES::texture_storage_multisample_2d_array>())
-        CORRADE_SKIP(Extensions::OES::texture_storage_multisample_2d_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::OES::texture_storage_multisample_2d_array::string() << "is not supported.");
     #endif
 
     MultisampleTexture2DArray texture;

src/Magnum/GL/Test/PipelineStatisticsQueryGLTest.cpp

@@ -66,7 +66,7 @@ void PipelineStatisticsQueryGLTest::constructMove() {
 
 void PipelineStatisticsQueryGLTest::wrap() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::pipeline_statistics_query>())
-        CORRADE_SKIP(Extensions::ARB::pipeline_statistics_query::string() + std::string(" is not available"));
+        CORRADE_SKIP(Extensions::ARB::pipeline_statistics_query::string() << "is not available");
 
     GLuint id;
     glGenQueries(1, &id);
@@ -84,7 +84,7 @@ void PipelineStatisticsQueryGLTest::wrap() {
 
 void PipelineStatisticsQueryGLTest::queryVerticesSubmitted() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::pipeline_statistics_query>())
-        CORRADE_SKIP(Extensions::ARB::pipeline_statistics_query::string() + std::string(" is not available"));
+        CORRADE_SKIP(Extensions::ARB::pipeline_statistics_query::string() << "is not available");
 
     /* Bind some FB to avoid errors on contexts w/o default FB */
     Renderbuffer color;

src/Magnum/GL/Test/PixelStorageGLTest.cpp

@@ -102,7 +102,7 @@ constexpr const char ActualData[] = {
 void PixelStorageGLTest::unpack2D() {
     #ifdef MAGNUM_TARGET_GLES2
     if(!Context::current().isExtensionSupported<Extensions::EXT::unpack_subimage>())
-        CORRADE_SKIP(Extensions::EXT::unpack_subimage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::unpack_subimage::string() << "is not supported.");
     #endif
 
     ImageView2D image{PixelStorage{}
@@ -142,7 +142,7 @@ void PixelStorageGLTest::unpack2D() {
 void PixelStorageGLTest::pack2D() {
     #ifdef MAGNUM_TARGET_GLES2
     if(!Context::current().isExtensionSupported<Extensions::NV::pack_subimage>())
-        CORRADE_SKIP(Extensions::NV::pack_subimage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::NV::pack_subimage::string() << "is not supported.");
     #endif
 
     ImageView2D actual{PixelFormat::RGB, PixelType::UnsignedByte, {2, 3}, ActualData};
@@ -287,7 +287,7 @@ constexpr const UnsignedByte ActualCompressedData[] = {
 
 void PixelStorageGLTest::unpackCompressed2D() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
 
     CompressedPixelStorage storage;
     storage.setCompressedBlockSize({4, 4, 1})
@@ -314,7 +314,7 @@ void PixelStorageGLTest::unpackCompressed2D() {
 
 void PixelStorageGLTest::packCompressed2D() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
 
     CompressedImageView2D actual{CompressedPixelFormat::RGBAS3tcDxt3, {4, 4}, ActualCompressedData};
 
@@ -393,7 +393,7 @@ constexpr const UnsignedByte CompressedData3D[] = {
 
 void PixelStorageGLTest::unpackCompressed3D() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
 
     CompressedPixelStorage storage;
     storage.setCompressedBlockSize({4, 4, 1})
@@ -421,7 +421,7 @@ void PixelStorageGLTest::unpackCompressed3D() {
 
 void PixelStorageGLTest::packCompressed3D() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
 
     CompressedImageView3D actual{CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 1}, ActualCompressedData};
 

src/Magnum/GL/Test/PrimitiveQueryGLTest.cpp

@@ -96,7 +96,7 @@ void PrimitiveQueryGLTest::constructMove() {
 void PrimitiveQueryGLTest::wrap() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::transform_feedback2>())
-        CORRADE_SKIP(Extensions::ARB::transform_feedback2::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::transform_feedback2::string() << "is not supported.");
     #endif
 
     GLuint id;
@@ -117,10 +117,10 @@ void PrimitiveQueryGLTest::wrap() {
 void PrimitiveQueryGLTest::primitivesGenerated() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::transform_feedback>())
-        CORRADE_SKIP(Extensions::EXT::transform_feedback::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::EXT::transform_feedback::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::geometry_shader>())
-        CORRADE_SKIP(Extensions::EXT::geometry_shader::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::EXT::geometry_shader::string() << "is not supported.");
     #endif
 
     /* Bind some FB to avoid errors on contexts w/o default FB */
@@ -199,7 +199,7 @@ void PrimitiveQueryGLTest::primitivesGenerated() {
 #ifndef MAGNUM_TARGET_GLES
 void PrimitiveQueryGLTest::primitivesGeneratedIndexed() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::transform_feedback3>())
-        CORRADE_SKIP(Extensions::ARB::transform_feedback3::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::transform_feedback3::string() << "is not supported.");
 
     /* Bind some FB to avoid errors on contexts w/o default FB */
     Renderbuffer color;
@@ -262,7 +262,7 @@ void PrimitiveQueryGLTest::primitivesGeneratedIndexed() {
 void PrimitiveQueryGLTest::transformFeedbackPrimitivesWritten() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::transform_feedback2>())
-        CORRADE_SKIP(Extensions::ARB::transform_feedback2::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::transform_feedback2::string() << "is not supported.");
     #endif
 
     /* Bind some FB to avoid errors on contexts w/o default FB */
@@ -341,7 +341,7 @@ void PrimitiveQueryGLTest::transformFeedbackPrimitivesWritten() {
 void PrimitiveQueryGLTest::transformFeedbackOverflow() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::transform_feedback_overflow_query>())
-        CORRADE_SKIP(Extensions::ARB::transform_feedback_overflow_query::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::transform_feedback_overflow_query::string() << "is not supported.");
     #endif
 
     /* Bind some FB to avoid errors on contexts w/o default FB */

src/Magnum/GL/Test/RectangleTextureGLTest.cpp

@@ -157,7 +157,7 @@ RectangleTextureGLTest::RectangleTextureGLTest() {
 
 void RectangleTextureGLTest::construct() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_rectangle>())
-        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() << "is not supported.");
 
     {
         RectangleTexture texture;
@@ -180,7 +180,7 @@ void RectangleTextureGLTest::constructMove() {
 
 void RectangleTextureGLTest::wrap() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_rectangle>())
-        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() << "is not supported.");
 
     GLuint id;
     glGenTextures(1, &id);
@@ -198,7 +198,7 @@ void RectangleTextureGLTest::wrap() {
 
 void RectangleTextureGLTest::bind() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_rectangle>())
-        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() << "is not supported.");
 
     RectangleTexture texture;
     texture.bind(15);
@@ -220,9 +220,9 @@ void RectangleTextureGLTest::bind() {
 
 void RectangleTextureGLTest::bindImage() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_rectangle>())
-        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::shader_image_load_store>())
-        CORRADE_SKIP(Extensions::ARB::shader_image_load_store::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::shader_image_load_store::string() << "is not supported.");
 
     RectangleTexture texture;
     texture.setStorage(TextureFormat::RGBA8, Vector2i{32})
@@ -248,7 +248,7 @@ template<class T> void RectangleTextureGLTest::sampling() {
         "GenericSampler" : "GLSampler");
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_rectangle>())
-        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() << "is not supported.");
 
     RectangleTexture texture;
     texture.setMinificationFilter(T::Filter::Linear)
@@ -264,9 +264,9 @@ template<class T> void RectangleTextureGLTest::sampling() {
 
 void RectangleTextureGLTest::samplingSrgbDecode() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_rectangle>())
-        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_sRGB_decode>())
-        CORRADE_SKIP(Extensions::EXT::texture_sRGB_decode::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_sRGB_decode::string() << "is not supported.");
 
     RectangleTexture texture;
     texture.setSrgbDecode(false);
@@ -276,9 +276,9 @@ void RectangleTextureGLTest::samplingSrgbDecode() {
 
 void RectangleTextureGLTest::samplingBorderInteger() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_rectangle>())
-        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_integer>())
-        CORRADE_SKIP(Extensions::EXT::texture_integer::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_integer::string() << "is not supported.");
 
     RectangleTexture a;
     a.setWrapping(SamplerWrapping::ClampToBorder)
@@ -292,9 +292,9 @@ void RectangleTextureGLTest::samplingBorderInteger() {
 
 void RectangleTextureGLTest::samplingSwizzle() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_rectangle>())
-        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_swizzle>())
-        CORRADE_SKIP(Extensions::ARB::texture_swizzle::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_swizzle::string() << "is not supported.");
 
     RectangleTexture texture;
     texture.setSwizzle<'b', 'g', 'r', '0'>();
@@ -304,9 +304,9 @@ void RectangleTextureGLTest::samplingSwizzle() {
 
 void RectangleTextureGLTest::samplingDepthStencilMode() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_rectangle>())
-        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::stencil_texturing>())
-        CORRADE_SKIP(Extensions::ARB::stencil_texturing::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::stencil_texturing::string() << "is not supported.");
 
     RectangleTexture texture;
     texture.setDepthStencilMode(SamplerDepthStencilMode::StencilIndex);
@@ -316,7 +316,7 @@ void RectangleTextureGLTest::samplingDepthStencilMode() {
 
 void RectangleTextureGLTest::storage() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_rectangle>())
-        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() << "is not supported.");
 
     RectangleTexture texture;
     texture.setStorage(TextureFormat::RGBA8, Vector2i(32));
@@ -332,7 +332,7 @@ void RectangleTextureGLTest::image() {
     setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_rectangle>())
-        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() << "is not supported.");
 
     RectangleTexture texture;
     texture.setImage(TextureFormat::RGBA8, ImageView2D{
@@ -357,7 +357,7 @@ void RectangleTextureGLTest::imageBuffer() {
     setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_rectangle>())
-        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() << "is not supported.");
 
     RectangleTexture texture;
     texture.setImage(TextureFormat::RGBA8, BufferImage2D{
@@ -384,7 +384,7 @@ void RectangleTextureGLTest::imageQueryView() {
     setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_rectangle>())
-        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() << "is not supported.");
 
     RectangleTexture texture;
     texture.setImage(TextureFormat::RGBA8, ImageView2D{
@@ -418,7 +418,7 @@ void RectangleTextureGLTest::subImage() {
     setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_rectangle>())
-        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() << "is not supported.");
 
     RectangleTexture texture;
     texture.setImage(TextureFormat::RGBA8,
@@ -443,7 +443,7 @@ void RectangleTextureGLTest::subImageBuffer() {
     setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_rectangle>())
-        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() << "is not supported.");
 
     RectangleTexture texture;
     texture.setImage(TextureFormat::RGBA8,
@@ -471,9 +471,9 @@ void RectangleTextureGLTest::subImageQuery() {
     setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_rectangle>())
-        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
 
     RectangleTexture texture;
     texture.setStorage(TextureFormat::RGBA8, Vector2i{4})
@@ -497,9 +497,9 @@ void RectangleTextureGLTest::subImageQueryView() {
     setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_rectangle>())
-        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
 
     RectangleTexture texture;
     texture.setStorage(TextureFormat::RGBA8, Vector2i{4})
@@ -523,9 +523,9 @@ void RectangleTextureGLTest::subImageQueryBuffer() {
     setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_rectangle>())
-        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
 
     RectangleTexture texture;
     texture.setStorage(TextureFormat::RGBA8, Vector2i{4})
@@ -580,7 +580,7 @@ void RectangleTextureGLTest::compressedSubImageQueryBuffer() {
 
 void RectangleTextureGLTest::invalidateImage() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_rectangle>())
-        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() << "is not supported.");
 
     RectangleTexture texture;
     texture.setStorage(TextureFormat::RGBA8, Vector2i(32));
@@ -591,7 +591,7 @@ void RectangleTextureGLTest::invalidateImage() {
 
 void RectangleTextureGLTest::invalidateSubImage() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_rectangle>())
-        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() << "is not supported.");
 
     RectangleTexture texture;
     texture.setStorage(TextureFormat::RGBA8, Vector2i(32));

src/Magnum/GL/Test/RenderbufferGLTest.cpp

@@ -71,7 +71,7 @@ RenderbufferGLTest::RenderbufferGLTest() {
 void RenderbufferGLTest::construct() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     #endif
 
     {
@@ -87,7 +87,7 @@ void RenderbufferGLTest::construct() {
 void RenderbufferGLTest::constructMove() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     #endif
 
     Renderbuffer a;
@@ -117,7 +117,7 @@ void RenderbufferGLTest::constructMove() {
 void RenderbufferGLTest::wrap() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     #endif
 
     GLuint id;
@@ -138,7 +138,7 @@ void RenderbufferGLTest::wrap() {
 void RenderbufferGLTest::label() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     #endif
     if(!Context::current().isExtensionSupported<Extensions::KHR::debug>() &&
        !Context::current().isExtensionSupported<Extensions::EXT::debug_label>())
@@ -159,7 +159,7 @@ void RenderbufferGLTest::label() {
 void RenderbufferGLTest::setStorage() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     #endif
 
     Renderbuffer renderbuffer;
@@ -177,7 +177,7 @@ void RenderbufferGLTest::setStorage() {
 void RenderbufferGLTest::setStorageMultisample() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_GLES2)
     if(!Context::current().isExtensionSupported<Extensions::ANGLE::framebuffer_multisample>() &&
        !Context::current().isExtensionSupported<Extensions::NV::framebuffer_multisample>())

src/Magnum/GL/Test/RendererGLTest.cpp

@@ -240,10 +240,10 @@ void RendererGLTest::pointCoord() {
 void RendererGLTest::patchParameters() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::tessellation_shader>())
-        CORRADE_SKIP(Extensions::ARB::tessellation_shader::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::tessellation_shader::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::tessellation_shader>())
-        CORRADE_SKIP(Extensions::EXT::tessellation_shader::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::EXT::tessellation_shader::string() << "is not supported.");
     #endif
 
     /* All we can do is check for GL errors */
@@ -260,10 +260,10 @@ void RendererGLTest::patchParameters() {
 void RendererGLTest::drawBuffersIndexed() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::draw_buffers2>())
-        CORRADE_SKIP(Extensions::EXT::draw_buffers2::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::EXT::draw_buffers2::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::draw_buffers_indexed>())
-        CORRADE_SKIP(Extensions::EXT::draw_buffers_indexed::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::EXT::draw_buffers_indexed::string() << "is not supported.");
     #endif
 
     /* Call the draw-buffer dependent functions, only expect that no GL error
@@ -277,10 +277,10 @@ void RendererGLTest::drawBuffersIndexed() {
 void RendererGLTest::drawBuffersBlend() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::draw_buffers_blend>())
-        CORRADE_SKIP(Extensions::ARB::draw_buffers_blend::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::ARB::draw_buffers_blend::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::draw_buffers_indexed>())
-        CORRADE_SKIP(Extensions::EXT::draw_buffers_indexed::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::EXT::draw_buffers_indexed::string() << "is not supported.");
     #endif
 
     /* Call the draw-buffer dependent functions, only expect that no GL error

src/Magnum/GL/Test/SampleQueryGLTest.cpp

@@ -76,7 +76,7 @@ void SampleQueryGLTest::constructMove() {
 void SampleQueryGLTest::wrap() {
     #ifdef MAGNUM_TARGET_GLES2
     if(!Context::current().isExtensionSupported<Extensions::EXT::occlusion_query_boolean>())
-        CORRADE_SKIP(Extensions::EXT::occlusion_query_boolean::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::EXT::occlusion_query_boolean::string() << "is not supported.");
     #endif
 
     GLuint id;
@@ -161,7 +161,7 @@ MyShader::MyShader() {
 void SampleQueryGLTest::querySamplesPassed() {
     #ifdef MAGNUM_TARGET_GLES2
     if(!Context::current().isExtensionSupported<Extensions::EXT::occlusion_query_boolean>())
-        CORRADE_SKIP(Extensions::EXT::occlusion_query_boolean::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::EXT::occlusion_query_boolean::string() << "is not supported.");
     #endif
 
     Renderbuffer renderbuffer;
@@ -219,7 +219,7 @@ void SampleQueryGLTest::querySamplesPassed() {
 #ifndef MAGNUM_TARGET_GLES
 void SampleQueryGLTest::conditionalRender() {
     if(!Context::current().isExtensionSupported<Extensions::NV::conditional_render>())
-        CORRADE_SKIP(Extensions::NV::conditional_render::string() + std::string(" is not available."));
+        CORRADE_SKIP(Extensions::NV::conditional_render::string() << "is not supported.");
 
     Renderbuffer renderbuffer;
     renderbuffer.setStorage(RenderbufferFormat::RGBA8, Vector2i(32));

src/Magnum/GL/Test/TextureArrayGLTest.cpp

@@ -409,7 +409,7 @@ TextureArrayGLTest::TextureArrayGLTest() {
 #ifndef MAGNUM_TARGET_GLES
 void TextureArrayGLTest::construct1D() {
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
 
     {
         Texture1DArray texture;
@@ -425,7 +425,7 @@ void TextureArrayGLTest::construct1D() {
 void TextureArrayGLTest::construct2D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
     #endif
 
     {
@@ -467,7 +467,7 @@ void TextureArrayGLTest::wrap1D() {
 void TextureArrayGLTest::wrap2D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
     #endif
 
     GLuint id;
@@ -487,7 +487,7 @@ void TextureArrayGLTest::wrap2D() {
 #ifndef MAGNUM_TARGET_GLES
 void TextureArrayGLTest::bind1D() {
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
 
     Texture1DArray texture;
     texture.bind(15);
@@ -511,7 +511,7 @@ void TextureArrayGLTest::bind1D() {
 void TextureArrayGLTest::bind2D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
     #endif
 
     Texture2DArray texture;
@@ -536,7 +536,7 @@ void TextureArrayGLTest::bind2D() {
 #ifndef MAGNUM_TARGET_GLES
 void TextureArrayGLTest::bindImage1D() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::shader_image_load_store>())
-        CORRADE_SKIP(Extensions::ARB::shader_image_load_store::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::shader_image_load_store::string() << "is not supported.");
 
     Texture1DArray texture;
     texture.setStorage(1, TextureFormat::RGBA8, {32, 4})
@@ -564,7 +564,7 @@ void TextureArrayGLTest::bindImage1D() {
 void TextureArrayGLTest::bindImage2D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::shader_image_load_store>())
-        CORRADE_SKIP(Extensions::ARB::shader_image_load_store::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::shader_image_load_store::string() << "is not supported.");
     #else
     if(!Context::current().isVersionSupported(Version::GLES310))
         CORRADE_SKIP("OpenGL ES 3.1 is not supported.");
@@ -601,7 +601,7 @@ template<class T> void TextureArrayGLTest::sampling1D() {
         "GenericSampler" : "GLSampler");
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
 
     Texture1DArray texture;
     texture.setMinificationFilter(T::Filter::Linear, T::Mipmap::Linear)
@@ -622,9 +622,9 @@ template<class T> void TextureArrayGLTest::sampling1D() {
 
 void TextureArrayGLTest::samplingSrgbDecode1D() {
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_sRGB_decode>())
-        CORRADE_SKIP(Extensions::EXT::texture_sRGB_decode::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_sRGB_decode::string() << "is not supported.");
 
     Texture1DArray texture;
     texture.setSrgbDecode(false);
@@ -634,9 +634,9 @@ void TextureArrayGLTest::samplingSrgbDecode1D() {
 
 void TextureArrayGLTest::samplingSwizzle1D() {
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_swizzle>())
-        CORRADE_SKIP(Extensions::ARB::texture_swizzle::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_swizzle::string() << "is not supported.");
 
     Texture1DArray texture;
     texture.setSwizzle<'b', 'g', 'r', '0'>();
@@ -646,9 +646,9 @@ void TextureArrayGLTest::samplingSwizzle1D() {
 
 void TextureArrayGLTest::samplingBorderInteger1D() {
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_integer>())
-        CORRADE_SKIP(Extensions::EXT::texture_integer::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_integer::string() << "is not supported.");
 
     Texture1DArray a;
     a.setWrapping(SamplerWrapping::ClampToBorder)
@@ -662,9 +662,9 @@ void TextureArrayGLTest::samplingBorderInteger1D() {
 
 void TextureArrayGLTest::samplingDepthStencilMode1D() {
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::stencil_texturing>())
-        CORRADE_SKIP(Extensions::ARB::stencil_texturing::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::stencil_texturing::string() << "is not supported.");
 
     Texture1DArray texture;
     texture.setDepthStencilMode(SamplerDepthStencilMode::StencilIndex);
@@ -679,7 +679,7 @@ template<class T> void TextureArrayGLTest::sampling2D() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
     #endif
 
     Texture2DArray texture;
@@ -714,10 +714,10 @@ template<class T> void TextureArrayGLTest::sampling2D() {
 void TextureArrayGLTest::samplingSrgbDecode2D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
     #endif
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_sRGB_decode>())
-        CORRADE_SKIP(Extensions::EXT::texture_sRGB_decode::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_sRGB_decode::string() << "is not supported.");
 
     Texture2DArray texture;
     texture.setSrgbDecode(false);
@@ -730,9 +730,9 @@ void TextureArrayGLTest::samplingSrgbDecode2D() {
 void TextureArrayGLTest::samplingSwizzle2D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_swizzle>())
-        CORRADE_SKIP(Extensions::ARB::texture_swizzle::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_swizzle::string() << "is not supported.");
     #endif
 
     Texture2DArray texture;
@@ -745,7 +745,7 @@ void TextureArrayGLTest::samplingSwizzle2D() {
 #if defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
 void TextureArrayGLTest::samplingMaxLevel2D() {
     if(!Context::current().isExtensionSupported<Extensions::APPLE::texture_max_level>())
-        CORRADE_SKIP(Extensions::APPLE::texture_max_level::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::APPLE::texture_max_level::string() << "is not supported.");
 
     Texture2DArray texture;
     texture.setMaxLevel(750);
@@ -756,7 +756,7 @@ void TextureArrayGLTest::samplingMaxLevel2D() {
 void TextureArrayGLTest::samplingCompare2D() {
     if(!Context::current().isExtensionSupported<Extensions::EXT::shadow_samplers>() ||
        !Context::current().isExtensionSupported<Extensions::NV::shadow_samplers_array>())
-        CORRADE_SKIP(Extensions::NV::shadow_samplers_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::NV::shadow_samplers_array::string() << "is not supported.");
 
     Texture2DArray texture;
     texture.setCompareMode(SamplerCompareMode::CompareRefToTexture)
@@ -770,12 +770,12 @@ void TextureArrayGLTest::samplingCompare2D() {
 void TextureArrayGLTest::samplingBorderInteger2D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_integer>())
-        CORRADE_SKIP(Extensions::EXT::texture_integer::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_integer::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_border_clamp>())
-        CORRADE_SKIP(Extensions::EXT::texture_border_clamp::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_border_clamp::string() << "is not supported.");
     #endif
 
     Texture2DArray a;
@@ -793,9 +793,9 @@ void TextureArrayGLTest::samplingBorderInteger2D() {
 void TextureArrayGLTest::samplingDepthStencilMode2D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::stencil_texturing>())
-        CORRADE_SKIP(Extensions::ARB::stencil_texturing::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::stencil_texturing::string() << "is not supported.");
     #else
     if(!Context::current().isVersionSupported(Version::GLES310))
         CORRADE_SKIP("OpenGL ES 3.1 is not supported.");
@@ -825,7 +825,7 @@ void TextureArrayGLTest::samplingBorder2D() {
 #ifndef MAGNUM_TARGET_GLES
 void TextureArrayGLTest::storage1D() {
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
 
     Texture1DArray texture;
     texture.setStorage(5, TextureFormat::RGBA8, Vector2i(32));
@@ -846,7 +846,7 @@ void TextureArrayGLTest::storage1D() {
 void TextureArrayGLTest::storage2D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
     #endif
 
     Texture2DArray texture;
@@ -876,7 +876,7 @@ void TextureArrayGLTest::image1D() {
     setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
 
     Texture1DArray texture;
     texture.setImage(0, TextureFormat::RGBA8, ImageView2D{
@@ -900,7 +900,7 @@ void TextureArrayGLTest::image1DBuffer() {
     setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
 
     Texture1DArray texture;
     texture.setImage(0, TextureFormat::RGBA8, BufferImage2D{
@@ -927,7 +927,7 @@ void TextureArrayGLTest::image1DQueryView() {
     setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
 
     Texture1DArray texture;
     texture.setImage(0, TextureFormat::RGBA8, ImageView2D{
@@ -961,7 +961,7 @@ void TextureArrayGLTest::subImage1D() {
     setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
 
     Texture1DArray texture;
     texture.setImage(0, TextureFormat::RGBA8,
@@ -986,7 +986,7 @@ void TextureArrayGLTest::subImage1DBuffer() {
     setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
 
     Texture1DArray texture;
     texture.setImage(0, TextureFormat::RGBA8,
@@ -1014,9 +1014,9 @@ void TextureArrayGLTest::subImage1DQuery() {
     setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
 
     Texture1DArray texture;
     texture.setStorage(1, TextureFormat::RGBA8, Vector2i{4})
@@ -1040,9 +1040,9 @@ void TextureArrayGLTest::subImage1DQueryView() {
     setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
 
     Texture1DArray texture;
     texture.setStorage(1, TextureFormat::RGBA8, Vector2i{4})
@@ -1067,9 +1067,9 @@ void TextureArrayGLTest::subImage1DQueryBuffer() {
     setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
 
     Texture1DArray texture;
     texture.setStorage(1, TextureFormat::RGBA8, Vector2i{4})
@@ -1130,7 +1130,7 @@ void TextureArrayGLTest::image2D() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
     #endif
 
     Texture2DArray texture;
@@ -1160,7 +1160,7 @@ void TextureArrayGLTest::image2DBuffer() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
     #endif
 
     Texture2DArray texture;
@@ -1192,7 +1192,7 @@ void TextureArrayGLTest::image2DQueryView() {
     setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
 
     Texture2DArray texture;
     texture.setImage(0, TextureFormat::RGBA8, ImageView3D{
@@ -1247,7 +1247,7 @@ void TextureArrayGLTest::subImage2D() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
     #endif
 
     Texture2DArray texture;
@@ -1278,7 +1278,7 @@ void TextureArrayGLTest::subImage2DBuffer() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
     #endif
 
     Texture2DArray texture;
@@ -1311,9 +1311,9 @@ void TextureArrayGLTest::subImage2DQuery() {
     setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
 
     Texture2DArray texture;
     texture.setStorage(1, TextureFormat::RGBA8, Vector3i{4})
@@ -1337,9 +1337,9 @@ void TextureArrayGLTest::subImage2DQueryView() {
     setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
 
     Texture2DArray texture;
     texture.setStorage(1, TextureFormat::RGBA8, Vector3i{4})
@@ -1364,9 +1364,9 @@ void TextureArrayGLTest::subImage2DQueryBuffer() {
     setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
 
     Texture2DArray texture;
     texture.setStorage(1, TextureFormat::RGBA8, Vector3i{4})
@@ -1393,22 +1393,22 @@ void TextureArrayGLTest::compressedImage2D() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
     #endif
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_WEBGL)
     if(!Context::current().isExtensionSupported<Extensions::WEBGL::compressed_texture_s3tc>())
-        CORRADE_SKIP(Extensions::WEBGL::compressed_texture_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::WEBGL::compressed_texture_s3tc::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::ANGLE::texture_compression_dxt3>())
-        CORRADE_SKIP(Extensions::ANGLE::texture_compression_dxt3::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ANGLE::texture_compression_dxt3::string() << "is not supported.");
     #endif
 
     #ifndef MAGNUM_TARGET_GLES
     if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #endif
 
     Texture2DArray texture;
@@ -1438,22 +1438,22 @@ void TextureArrayGLTest::compressedImage2DBuffer() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
     #endif
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_WEBGL)
     if(!Context::current().isExtensionSupported<Extensions::WEBGL::compressed_texture_s3tc>())
-        CORRADE_SKIP(Extensions::WEBGL::compressed_texture_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::WEBGL::compressed_texture_s3tc::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::ANGLE::texture_compression_dxt3>())
-        CORRADE_SKIP(Extensions::ANGLE::texture_compression_dxt3::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ANGLE::texture_compression_dxt3::string() << "is not supported.");
     #endif
 
     #ifndef MAGNUM_TARGET_GLES
     if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #endif
 
     Texture2DArray texture;
@@ -1485,12 +1485,12 @@ void TextureArrayGLTest::compressedImage2DQueryView() {
     setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
 
     if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
 
     Texture2DArray texture;
     texture.setCompressedImage(0, CompressedImageView3D{
@@ -1554,22 +1554,22 @@ void TextureArrayGLTest::compressedSubImage2D() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
     #endif
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_WEBGL)
     if(!Context::current().isExtensionSupported<Extensions::WEBGL::compressed_texture_s3tc>())
-        CORRADE_SKIP(Extensions::WEBGL::compressed_texture_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::WEBGL::compressed_texture_s3tc::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::ANGLE::texture_compression_dxt3>())
-        CORRADE_SKIP(Extensions::ANGLE::texture_compression_dxt3::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ANGLE::texture_compression_dxt3::string() << "is not supported.");
     #endif
 
     #ifndef MAGNUM_TARGET_GLES
     if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #endif
 
     Texture2DArray texture;
@@ -1607,22 +1607,22 @@ void TextureArrayGLTest::compressedSubImage2DBuffer() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
     #endif
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_WEBGL)
     if(!Context::current().isExtensionSupported<Extensions::WEBGL::compressed_texture_s3tc>())
-        CORRADE_SKIP(Extensions::WEBGL::compressed_texture_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::WEBGL::compressed_texture_s3tc::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::ANGLE::texture_compression_dxt3>())
-        CORRADE_SKIP(Extensions::ANGLE::texture_compression_dxt3::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ANGLE::texture_compression_dxt3::string() << "is not supported.");
     #endif
 
     #ifndef MAGNUM_TARGET_GLES
     if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #endif
 
     Texture2DArray texture;
@@ -1656,15 +1656,15 @@ void TextureArrayGLTest::compressedSubImage2DQuery() {
     setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
     if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     if(CompressedPixelStorage2DData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
-        CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported.");
 
     Texture2DArray texture;
     texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, {12, 4, 4})
@@ -1687,15 +1687,15 @@ void TextureArrayGLTest::compressedSubImage2DQueryView() {
     setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
     if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     if(CompressedPixelStorage2DData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
-        CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported.");
 
     Texture2DArray texture;
     texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, {12, 4, 4})
@@ -1720,15 +1720,15 @@ void TextureArrayGLTest::compressedSubImage2DQueryBuffer() {
     setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
     if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     if(CompressedPixelStorage2DData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
-        CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported.");
 
     Texture2DArray texture;
     texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, {12, 4, 4})
@@ -1754,9 +1754,9 @@ void TextureArrayGLTest::compressedSubImage2DQueryBuffer() {
 
 void TextureArrayGLTest::generateMipmap1D() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
 
     Texture1DArray texture;
     texture.setImage(0, TextureFormat::RGBA8,
@@ -1783,9 +1783,9 @@ void TextureArrayGLTest::generateMipmap1D() {
 void TextureArrayGLTest::generateMipmap2D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
     #endif
 
     Texture2DArray texture;
@@ -1817,7 +1817,7 @@ void TextureArrayGLTest::generateMipmap2D() {
 #ifndef MAGNUM_TARGET_GLES
 void TextureArrayGLTest::invalidateImage1D() {
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
 
     Texture1DArray texture;
     texture.setStorage(2, TextureFormat::RGBA8, Vector2i(32));
@@ -1830,7 +1830,7 @@ void TextureArrayGLTest::invalidateImage1D() {
 void TextureArrayGLTest::invalidateImage2D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
     #endif
 
     Texture2DArray texture;
@@ -1843,7 +1843,7 @@ void TextureArrayGLTest::invalidateImage2D() {
 #ifndef MAGNUM_TARGET_GLES
 void TextureArrayGLTest::invalidateSubImage1D() {
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
 
     Texture1DArray texture;
     texture.setStorage(2, TextureFormat::RGBA8, Vector2i(32));
@@ -1856,7 +1856,7 @@ void TextureArrayGLTest::invalidateSubImage1D() {
 void TextureArrayGLTest::invalidateSubImage2D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
-        CORRADE_SKIP(Extensions::EXT::texture_array::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
     #endif
 
     Texture2DArray texture;

src/Magnum/GL/Test/TextureGLTest.cpp

@@ -680,7 +680,7 @@ void TextureGLTest::construct2D() {
 void TextureGLTest::construct3D() {
     #ifdef MAGNUM_TARGET_GLES2
     if(!Context::current().isExtensionSupported<Extensions::OES::texture_3D>())
-        CORRADE_SKIP(Extensions::OES::texture_3D::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::OES::texture_3D::string() << "is not supported.");
     #endif
 
     {
@@ -739,7 +739,7 @@ void TextureGLTest::wrap2D() {
 void TextureGLTest::wrap3D() {
     #ifdef MAGNUM_TARGET_GLES2
     if(!Context::current().isExtensionSupported<Extensions::OES::texture_3D>())
-        CORRADE_SKIP(Extensions::OES::texture_3D::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::OES::texture_3D::string() << "is not supported.");
     #endif
 
     GLuint id;
@@ -801,7 +801,7 @@ void TextureGLTest::bind2D() {
 void TextureGLTest::bind3D() {
     #ifdef MAGNUM_TARGET_GLES2
     if(!Context::current().isExtensionSupported<Extensions::OES::texture_3D>())
-        CORRADE_SKIP(Extensions::OES::texture_3D::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::OES::texture_3D::string() << "is not supported.");
     #endif
 
     Texture3D texture;
@@ -827,7 +827,7 @@ void TextureGLTest::bind3D() {
 #ifndef MAGNUM_TARGET_GLES
 void TextureGLTest::bindImage1D() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::shader_image_load_store>())
-        CORRADE_SKIP(Extensions::ARB::shader_image_load_store::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::shader_image_load_store::string() << "is not supported.");
 
     Texture1D texture;
     texture.setStorage(1, TextureFormat::RGBA8, 32)
@@ -852,7 +852,7 @@ void TextureGLTest::bindImage1D() {
 void TextureGLTest::bindImage2D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::shader_image_load_store>())
-        CORRADE_SKIP(Extensions::ARB::shader_image_load_store::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::shader_image_load_store::string() << "is not supported.");
     #else
     if(!Context::current().isVersionSupported(Version::GLES310))
         CORRADE_SKIP("OpenGL ES 3.1 is not supported.");
@@ -882,7 +882,7 @@ void TextureGLTest::bindImage2D() {
 void TextureGLTest::bindImage3D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::shader_image_load_store>())
-        CORRADE_SKIP(Extensions::ARB::shader_image_load_store::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::shader_image_load_store::string() << "is not supported.");
     #else
     if(!Context::current().isVersionSupported(Version::GLES310))
         CORRADE_SKIP("OpenGL ES 3.1 is not supported.");
@@ -937,7 +937,7 @@ template<class T> void TextureGLTest::sampling1D() {
 
 void TextureGLTest::samplingSrgbDecode1D() {
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_sRGB_decode>())
-        CORRADE_SKIP(Extensions::EXT::texture_sRGB_decode::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_sRGB_decode::string() << "is not supported.");
 
     Texture1D texture;
     texture.setSrgbDecode(false);
@@ -947,7 +947,7 @@ void TextureGLTest::samplingSrgbDecode1D() {
 
 void TextureGLTest::samplingSwizzle1D() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_swizzle>())
-        CORRADE_SKIP(Extensions::ARB::texture_swizzle::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_swizzle::string() << "is not supported.");
 
     Texture1D texture;
     texture.setSwizzle<'b', 'g', 'r', '0'>();
@@ -957,7 +957,7 @@ void TextureGLTest::samplingSwizzle1D() {
 
 void TextureGLTest::samplingBorderInteger1D() {
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_integer>())
-        CORRADE_SKIP(Extensions::EXT::texture_integer::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_integer::string() << "is not supported.");
 
     Texture1D a;
     a.setWrapping(SamplerWrapping::ClampToBorder)
@@ -971,7 +971,7 @@ void TextureGLTest::samplingBorderInteger1D() {
 
 void TextureGLTest::samplingDepthStencilMode1D() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::stencil_texturing>())
-        CORRADE_SKIP(Extensions::ARB::stencil_texturing::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::stencil_texturing::string() << "is not supported.");
 
     Texture1D texture;
     texture.setDepthStencilMode(SamplerDepthStencilMode::StencilIndex);
@@ -1016,10 +1016,10 @@ template<class T> void TextureGLTest::sampling2D() {
 void TextureGLTest::samplingSrgbDecode2D() {
     #ifdef MAGNUM_TARGET_GLES2
     if(!Context::current().isExtensionSupported<Extensions::EXT::sRGB>())
-        CORRADE_SKIP(Extensions::EXT::sRGB::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::sRGB::string() << "is not supported.");
     #endif
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_sRGB_decode>())
-        CORRADE_SKIP(Extensions::EXT::texture_sRGB_decode::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_sRGB_decode::string() << "is not supported.");
 
     Texture2D texture;
     texture.setSrgbDecode(false);
@@ -1032,7 +1032,7 @@ void TextureGLTest::samplingSrgbDecode2D() {
 void TextureGLTest::samplingSwizzle2D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_swizzle>())
-        CORRADE_SKIP(Extensions::ARB::texture_swizzle::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_swizzle::string() << "is not supported.");
     #endif
 
     Texture2D texture;
@@ -1045,7 +1045,7 @@ void TextureGLTest::samplingSwizzle2D() {
 #if defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
 void TextureGLTest::samplingMaxLevel2D() {
     if(!Context::current().isExtensionSupported<Extensions::APPLE::texture_max_level>())
-        CORRADE_SKIP(Extensions::APPLE::texture_max_level::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::APPLE::texture_max_level::string() << "is not supported.");
 
     Texture2D texture;
     texture.setMaxLevel(750);
@@ -1055,7 +1055,7 @@ void TextureGLTest::samplingMaxLevel2D() {
 
 void TextureGLTest::samplingCompare2D() {
     if(!Context::current().isExtensionSupported<Extensions::EXT::shadow_samplers>())
-        CORRADE_SKIP(Extensions::EXT::shadow_samplers::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::shadow_samplers::string() << "is not supported.");
 
     Texture2D texture;
     texture.setCompareMode(SamplerCompareMode::CompareRefToTexture)
@@ -1069,10 +1069,10 @@ void TextureGLTest::samplingCompare2D() {
 void TextureGLTest::samplingBorderInteger2D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_integer>())
-        CORRADE_SKIP(Extensions::EXT::texture_integer::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_integer::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_border_clamp>())
-        CORRADE_SKIP(Extensions::EXT::texture_border_clamp::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_border_clamp::string() << "is not supported.");
     #endif
 
     Texture2D a;
@@ -1088,7 +1088,7 @@ void TextureGLTest::samplingBorderInteger2D() {
 void TextureGLTest::samplingDepthStencilMode2D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::stencil_texturing>())
-        CORRADE_SKIP(Extensions::ARB::stencil_texturing::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::stencil_texturing::string() << "is not supported.");
     #else
     if(!Context::current().isVersionSupported(Version::GLES310))
         CORRADE_SKIP("OpenGL ES 3.1 is not supported.");
@@ -1122,7 +1122,7 @@ template<class T> void TextureGLTest::sampling3D() {
 
     #ifdef MAGNUM_TARGET_GLES2
     if(!Context::current().isExtensionSupported<Extensions::OES::texture_3D>())
-        CORRADE_SKIP(Extensions::OES::texture_3D::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::OES::texture_3D::string() << "is not supported.");
     #endif
 
     Texture3D texture;
@@ -1152,12 +1152,12 @@ template<class T> void TextureGLTest::sampling3D() {
 void TextureGLTest::samplingSrgbDecode3D() {
     #ifdef MAGNUM_TARGET_GLES2
     if(!Context::current().isExtensionSupported<Extensions::OES::texture_3D>())
-        CORRADE_SKIP(Extensions::OES::texture_3D::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::OES::texture_3D::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::EXT::sRGB>())
-        CORRADE_SKIP(Extensions::EXT::sRGB::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::sRGB::string() << "is not supported.");
     #endif
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_sRGB_decode>())
-        CORRADE_SKIP(Extensions::EXT::texture_sRGB_decode::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_sRGB_decode::string() << "is not supported.");
 
     Texture3D texture;
     texture.setSrgbDecode(false);
@@ -1170,7 +1170,7 @@ void TextureGLTest::samplingSrgbDecode3D() {
 void TextureGLTest::samplingSwizzle3D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_swizzle>())
-        CORRADE_SKIP(Extensions::ARB::texture_swizzle::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_swizzle::string() << "is not supported.");
     #endif
 
     Texture3D texture;
@@ -1183,9 +1183,9 @@ void TextureGLTest::samplingSwizzle3D() {
 #if defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
 void TextureGLTest::samplingMaxLevel3D() {
     if(!Context::current().isExtensionSupported<Extensions::OES::texture_3D>())
-        CORRADE_SKIP(Extensions::OES::texture_3D::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::OES::texture_3D::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::APPLE::texture_max_level>())
-        CORRADE_SKIP(Extensions::APPLE::texture_max_level::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::APPLE::texture_max_level::string() << "is not supported.");
 
     Texture3D texture;
     texture.setMaxLevel(750);
@@ -1198,10 +1198,10 @@ void TextureGLTest::samplingMaxLevel3D() {
 void TextureGLTest::samplingBorderInteger3D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_integer>())
-        CORRADE_SKIP(Extensions::EXT::texture_integer::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_integer::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_border_clamp>())
-        CORRADE_SKIP(Extensions::EXT::texture_border_clamp::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_border_clamp::string() << "is not supported.");
     #endif
 
     Texture3D a;
@@ -1217,7 +1217,7 @@ void TextureGLTest::samplingBorderInteger3D() {
 void TextureGLTest::samplingDepthStencilMode3D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::stencil_texturing>())
-        CORRADE_SKIP(Extensions::ARB::stencil_texturing::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::stencil_texturing::string() << "is not supported.");
     #else
     if(!Context::current().isVersionSupported(Version::GLES310))
         CORRADE_SKIP("OpenGL ES 3.1 is not supported.");
@@ -1234,7 +1234,7 @@ void TextureGLTest::samplingDepthStencilMode3D() {
 void TextureGLTest::samplingBorder3D() {
     #ifdef MAGNUM_TARGET_GLES2
     if(!Context::current().isExtensionSupported<Extensions::OES::texture_3D>())
-        CORRADE_SKIP(Extensions::OES::texture_3D::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::OES::texture_3D::string() << "is not supported.");
     #endif
 
     if(!Context::current().isExtensionSupported<Extensions::NV::texture_border_clamp>() &&
@@ -1301,7 +1301,7 @@ void TextureGLTest::storage2D() {
 void TextureGLTest::storage3D() {
     #ifdef MAGNUM_TARGET_GLES2
     if(!Context::current().isExtensionSupported<Extensions::OES::texture_3D>())
-        CORRADE_SKIP(Extensions::OES::texture_3D::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::OES::texture_3D::string() << "is not supported.");
     #endif
 
     Texture3D texture;
@@ -1454,7 +1454,7 @@ void TextureGLTest::subImage1DQuery() {
     setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
 
     Texture1D texture;
     texture.setStorage(1, TextureFormat::RGBA8, 4)
@@ -1478,7 +1478,7 @@ void TextureGLTest::subImage1DQueryView() {
     setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
 
     Texture1D texture;
     texture.setStorage(1, TextureFormat::RGBA8, 4)
@@ -1503,7 +1503,7 @@ void TextureGLTest::subImage1DQueryBuffer() {
     setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
 
     Texture1D texture;
     texture.setStorage(1, TextureFormat::RGBA8, 4)
@@ -1563,7 +1563,7 @@ void TextureGLTest::image2D() {
     #ifdef MAGNUM_TARGET_GLES2
     #ifndef MAGNUM_TARGET_WEBGL
     if(PixelStorage2DData[testCaseInstanceId()].storage != PixelStorage{} && !Context::current().isExtensionSupported<Extensions::EXT::unpack_subimage>())
-        CORRADE_SKIP(Extensions::EXT::unpack_subimage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::unpack_subimage::string() << "is not supported.");
     #else
     if(PixelStorage2DData[testCaseInstanceId()].storage != PixelStorage{})
         CORRADE_SKIP("Image unpack is not supported in WebGL 1.");
@@ -1671,7 +1671,7 @@ void TextureGLTest::subImage2D() {
     #ifdef MAGNUM_TARGET_GLES2
     #ifndef MAGNUM_TARGET_WEBGL
     if(PixelStorage2DData[testCaseInstanceId()].storage != PixelStorage{} && !Context::current().isExtensionSupported<Extensions::EXT::unpack_subimage>())
-        CORRADE_SKIP(Extensions::EXT::unpack_subimage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::unpack_subimage::string() << "is not supported.");
     #else
     if(PixelStorage2DData[testCaseInstanceId()].storage != PixelStorage{})
         CORRADE_SKIP("Image unpack is not supported in WebGL 1.");
@@ -1738,7 +1738,7 @@ void TextureGLTest::subImage2DQuery() {
     setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
 
     Texture2D texture;
     texture.setStorage(1, TextureFormat::RGBA8, Vector2i{4})
@@ -1762,7 +1762,7 @@ void TextureGLTest::subImage2DQueryView() {
     setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
 
     Texture2D texture;
     texture.setStorage(1, TextureFormat::RGBA8, Vector2i{4})
@@ -1787,7 +1787,7 @@ void TextureGLTest::subImage2DQueryBuffer() {
     setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
 
     Texture2D texture;
     texture.setStorage(1, TextureFormat::RGBA8, Vector2i{4})
@@ -1814,18 +1814,18 @@ void TextureGLTest::compressedImage2D() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_WEBGL)
     if(!Context::current().isExtensionSupported<Extensions::WEBGL::compressed_texture_s3tc>())
-        CORRADE_SKIP(Extensions::WEBGL::compressed_texture_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::WEBGL::compressed_texture_s3tc::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::ANGLE::texture_compression_dxt3>())
-        CORRADE_SKIP(Extensions::ANGLE::texture_compression_dxt3::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ANGLE::texture_compression_dxt3::string() << "is not supported.");
     #endif
 
     #ifndef MAGNUM_TARGET_GLES
     if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #endif
 
     Texture2D texture;
@@ -1857,18 +1857,18 @@ void TextureGLTest::compressedImage2DBuffer() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_WEBGL)
     if(!Context::current().isExtensionSupported<Extensions::WEBGL::compressed_texture_s3tc>())
-        CORRADE_SKIP(Extensions::WEBGL::compressed_texture_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::WEBGL::compressed_texture_s3tc::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::ANGLE::texture_compression_dxt3>())
-        CORRADE_SKIP(Extensions::ANGLE::texture_compression_dxt3::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ANGLE::texture_compression_dxt3::string() << "is not supported.");
     #endif
 
     #ifndef MAGNUM_TARGET_GLES
     if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #endif
 
     Texture2D texture;
@@ -1901,10 +1901,10 @@ void TextureGLTest::compressedImage2DQueryView() {
     setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
 
     if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
 
     Texture2D texture;
     texture.setCompressedImage(0, CompressedImageView2D{
@@ -1948,18 +1948,18 @@ void TextureGLTest::compressedSubImage2D() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_WEBGL)
     if(!Context::current().isExtensionSupported<Extensions::WEBGL::compressed_texture_s3tc>())
-        CORRADE_SKIP(Extensions::WEBGL::compressed_texture_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::WEBGL::compressed_texture_s3tc::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::ANGLE::texture_compression_dxt3>())
-        CORRADE_SKIP(Extensions::ANGLE::texture_compression_dxt3::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ANGLE::texture_compression_dxt3::string() << "is not supported.");
     #endif
 
     #ifndef MAGNUM_TARGET_GLES
     if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #endif
 
     Texture2D texture;
@@ -1992,18 +1992,18 @@ void TextureGLTest::compressedSubImage2DBuffer() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_WEBGL)
     if(!Context::current().isExtensionSupported<Extensions::WEBGL::compressed_texture_s3tc>())
-        CORRADE_SKIP(Extensions::WEBGL::compressed_texture_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::WEBGL::compressed_texture_s3tc::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::ANGLE::texture_compression_dxt3>())
-        CORRADE_SKIP(Extensions::ANGLE::texture_compression_dxt3::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ANGLE::texture_compression_dxt3::string() << "is not supported.");
     #endif
 
     #ifndef MAGNUM_TARGET_GLES
     if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #endif
 
     Texture2D texture;
@@ -2038,13 +2038,13 @@ void TextureGLTest::compressedSubImage2DQuery() {
     setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
     if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     if(CompressedPixelStorage2DData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
-        CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported.");
 
     Texture2D texture;
     texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, {12, 4})
@@ -2067,13 +2067,13 @@ void TextureGLTest::compressedSubImage2DQueryView() {
     setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
     if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     if(CompressedPixelStorage2DData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
-        CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported.");
 
     Texture2D texture;
     texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, {12, 4})
@@ -2097,13 +2097,13 @@ void TextureGLTest::compressedSubImage2DQueryBuffer() {
     setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
     if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     if(CompressedPixelStorage2DData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
-        CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported.");
 
     Texture2D texture;
     texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, {12, 4})
@@ -2130,9 +2130,9 @@ void TextureGLTest::image3D() {
 
     #ifdef MAGNUM_TARGET_GLES2
     if(!Context::current().isExtensionSupported<Extensions::OES::texture_3D>())
-        CORRADE_SKIP(Extensions::OES::texture_3D::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::OES::texture_3D::string() << "is not supported.");
     if(PixelStorage3DData[testCaseInstanceId()].storage != PixelStorage{} && !Context::current().isExtensionSupported<Extensions::EXT::unpack_subimage>())
-        CORRADE_SKIP(Extensions::EXT::unpack_subimage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::unpack_subimage::string() << "is not supported.");
     #endif
 
     Texture3D texture;
@@ -2244,9 +2244,9 @@ void TextureGLTest::subImage3D() {
 
     #ifdef MAGNUM_TARGET_GLES2
     if(!Context::current().isExtensionSupported<Extensions::OES::texture_3D>())
-        CORRADE_SKIP(Extensions::OES::texture_3D::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::OES::texture_3D::string() << "is not supported.");
     if(PixelStorage3DData[testCaseInstanceId()].storage != PixelStorage{} && !Context::current().isExtensionSupported<Extensions::EXT::unpack_subimage>())
-        CORRADE_SKIP(Extensions::EXT::unpack_subimage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::unpack_subimage::string() << "is not supported.");
     #endif
 
     Texture3D texture;
@@ -2306,7 +2306,7 @@ void TextureGLTest::subImage3DQuery() {
     setTestCaseDescription(PixelStorage3DData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
 
     Texture3D texture;
     texture.setStorage(1, TextureFormat::RGBA8, Vector3i{4})
@@ -2330,7 +2330,7 @@ void TextureGLTest::subImage3DQueryView() {
     setTestCaseDescription(PixelStorage3DData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
 
     Texture3D texture;
     texture.setStorage(1, TextureFormat::RGBA8, Vector3i{4})
@@ -2355,7 +2355,7 @@ void TextureGLTest::subImage3DQueryBuffer() {
     setTestCaseDescription(PixelStorage3DData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
 
     Texture3D texture;
     texture.setStorage(1, TextureFormat::RGBA8, Vector3i{4})
@@ -2385,12 +2385,12 @@ void TextureGLTest::compressedImage3D() {
     #else
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_compression_bptc>())
-        CORRADE_SKIP(Extensions::ARB::texture_compression_bptc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_compression_bptc::string() << "is not supported.");
     if(CompressedPixelStorage3DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_bptc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_bptc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_bptc::string() << "is not supported.");
     #endif
 
     Texture3D texture;
@@ -2425,12 +2425,12 @@ void TextureGLTest::compressedImage3DBuffer() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_compression_bptc>())
-        CORRADE_SKIP(Extensions::ARB::texture_compression_bptc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_compression_bptc::string() << "is not supported.");
     if(CompressedPixelStorage3DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_bptc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_bptc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_bptc::string() << "is not supported.");
     #endif
 
     Texture3D texture;
@@ -2466,9 +2466,9 @@ void TextureGLTest::compressedImage3DQueryView() {
     setTestCaseDescription(CompressedPixelStorage3DData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_compression_bptc>())
-        CORRADE_SKIP(Extensions::ARB::texture_compression_bptc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_compression_bptc::string() << "is not supported.");
     if(CompressedPixelStorage3DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
 
     Texture3D texture;
     texture.setCompressedImage(0, CompressedImageView3D{
@@ -2549,12 +2549,12 @@ void TextureGLTest::compressedSubImage3D() {
     #else
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_compression_bptc>())
-        CORRADE_SKIP(Extensions::ARB::texture_compression_bptc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_compression_bptc::string() << "is not supported.");
     if(CompressedPixelStorage3DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_bptc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_bptc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_bptc::string() << "is not supported.");
     #endif
 
     Texture3D texture;
@@ -2593,12 +2593,12 @@ void TextureGLTest::compressedSubImage3DBuffer() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_compression_bptc>())
-        CORRADE_SKIP(Extensions::ARB::texture_compression_bptc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_compression_bptc::string() << "is not supported.");
     if(CompressedPixelStorage3DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_bptc>())
-        CORRADE_SKIP(Extensions::EXT::texture_compression_bptc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::texture_compression_bptc::string() << "is not supported.");
     #endif
 
     Texture3D texture;
@@ -2637,13 +2637,13 @@ void TextureGLTest::compressedSubImage3DQuery() {
     setTestCaseDescription(CompressedPixelStorage3DData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_compression_bptc>())
-        CORRADE_SKIP(Extensions::ARB::texture_compression_bptc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_compression_bptc::string() << "is not supported.");
     if(CompressedPixelStorage3DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     if(CompressedPixelStorage3DData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
-        CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported.");
 
     Texture3D texture;
     texture.setStorage(1, TextureFormat::CompressedRGBABptcUnorm, {12, 4, 4})
@@ -2673,13 +2673,13 @@ void TextureGLTest::compressedSubImage3DQueryView() {
     setTestCaseDescription(CompressedPixelStorage3DData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_compression_bptc>())
-        CORRADE_SKIP(Extensions::ARB::texture_compression_bptc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_compression_bptc::string() << "is not supported.");
     if(CompressedPixelStorage3DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     if(CompressedPixelStorage3DData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
-        CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported.");
 
     Texture3D texture;
     texture.setStorage(1, TextureFormat::CompressedRGBABptcUnorm, {12, 4, 4})
@@ -2710,13 +2710,13 @@ void TextureGLTest::compressedSubImage3DQueryBuffer() {
     setTestCaseDescription(CompressedPixelStorage3DData[testCaseInstanceId()].name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
-        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_compression_bptc>())
-        CORRADE_SKIP(Extensions::ARB::texture_compression_bptc::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::texture_compression_bptc::string() << "is not supported.");
     if(CompressedPixelStorage3DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
-        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     if(CompressedPixelStorage3DData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
-        CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported.");
 
     Texture3D texture;
     texture.setStorage(1, TextureFormat::CompressedRGBABptcUnorm, {12, 4, 4})
@@ -2748,7 +2748,7 @@ void TextureGLTest::compressedSubImage3DQueryBuffer() {
 #ifndef MAGNUM_TARGET_GLES
 void TextureGLTest::generateMipmap1D() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
 
     Texture1D texture;
     texture.setImage(0, TextureFormat::RGBA8,
@@ -2775,7 +2775,7 @@ void TextureGLTest::generateMipmap1D() {
 void TextureGLTest::generateMipmap2D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     #endif
 
     Texture2D texture;
@@ -2814,10 +2814,10 @@ void TextureGLTest::generateMipmap2D() {
 void TextureGLTest::generateMipmap3D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::framebuffer_object>())
-        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::framebuffer_object::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_GLES2)
     if(!Context::current().isExtensionSupported<Extensions::OES::texture_3D>())
-        CORRADE_SKIP(Extensions::OES::texture_3D::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::OES::texture_3D::string() << "is not supported.");
     #endif
 
     Texture3D texture;
@@ -2876,7 +2876,7 @@ void TextureGLTest::invalidateImage2D() {
 void TextureGLTest::invalidateImage3D() {
     #ifdef MAGNUM_TARGET_GLES2
     if(!Context::current().isExtensionSupported<Extensions::OES::texture_3D>())
-        CORRADE_SKIP(Extensions::OES::texture_3D::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::OES::texture_3D::string() << "is not supported.");
     #endif
 
     Texture3D texture;
@@ -2915,7 +2915,7 @@ void TextureGLTest::invalidateSubImage2D() {
 void TextureGLTest::invalidateSubImage3D() {
     #ifdef MAGNUM_TARGET_GLES2
     if(!Context::current().isExtensionSupported<Extensions::OES::texture_3D>())
-        CORRADE_SKIP(Extensions::OES::texture_3D::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::OES::texture_3D::string() << "is not supported.");
     #endif
 
     Texture3D texture;
@@ -2929,7 +2929,7 @@ void TextureGLTest::invalidateSubImage3D() {
 void TextureGLTest::srgbStorage() {
     #ifdef MAGNUM_TARGET_GLES2
     if(!Context::current().isExtensionSupported<Extensions::EXT::sRGB>())
-        CORRADE_SKIP(Extensions::EXT::sRGB::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::sRGB::string() << "is not supported.");
     #endif
 
     Texture2D texture;
@@ -2959,7 +2959,7 @@ void TextureGLTest::srgbStorage() {
 void TextureGLTest::srgbAlphaStorage() {
     #ifdef MAGNUM_TARGET_GLES2
     if(!Context::current().isExtensionSupported<Extensions::EXT::sRGB>())
-        CORRADE_SKIP(Extensions::EXT::sRGB::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::EXT::sRGB::string() << "is not supported.");
     #endif
 
     Texture2D texture;

src/Magnum/GL/Test/TimeQueryGLTest.cpp

@@ -65,13 +65,13 @@ void TimeQueryGLTest::constructMove() {
 void TimeQueryGLTest::wrap() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::timer_query>())
-        CORRADE_SKIP(Extensions::ARB::timer_query::string() + std::string(" is not available"));
+        CORRADE_SKIP(Extensions::ARB::timer_query::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_WEBGL) && !defined(MAGNUM_TARGET_GLES2)
     if(!Context::current().isExtensionSupported<Extensions::EXT::disjoint_timer_query_webgl2>())
-        CORRADE_SKIP(Extensions::EXT::disjoint_timer_query_webgl2::string() + std::string(" is not available"));
+        CORRADE_SKIP(Extensions::EXT::disjoint_timer_query_webgl2::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::disjoint_timer_query>())
-        CORRADE_SKIP(Extensions::EXT::disjoint_timer_query::string() + std::string(" is not available"));
+        CORRADE_SKIP(Extensions::EXT::disjoint_timer_query::string() << "is not supported.");
     #endif
 
     GLuint id;
@@ -99,13 +99,13 @@ void TimeQueryGLTest::wrap() {
 void TimeQueryGLTest::queryTime() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::timer_query>())
-        CORRADE_SKIP(Extensions::ARB::timer_query::string() + std::string(" is not available"));
+        CORRADE_SKIP(Extensions::ARB::timer_query::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_WEBGL) && !defined(MAGNUM_TARGET_GLES2)
     if(!Context::current().isExtensionSupported<Extensions::EXT::disjoint_timer_query_webgl2>())
-        CORRADE_SKIP(Extensions::EXT::disjoint_timer_query_webgl2::string() + std::string(" is not available"));
+        CORRADE_SKIP(Extensions::EXT::disjoint_timer_query_webgl2::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::disjoint_timer_query>())
-        CORRADE_SKIP(Extensions::EXT::disjoint_timer_query::string() + std::string(" is not available"));
+        CORRADE_SKIP(Extensions::EXT::disjoint_timer_query::string() << "is not supported.");
     #endif
 
     Renderbuffer renderbuffer;
@@ -144,13 +144,13 @@ void TimeQueryGLTest::queryTime() {
 void TimeQueryGLTest::queryTimestamp() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::timer_query>())
-        CORRADE_SKIP(Extensions::ARB::timer_query::string() + std::string(" is not available"));
+        CORRADE_SKIP(Extensions::ARB::timer_query::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_WEBGL) && !defined(MAGNUM_TARGET_GLES2)
     if(!Context::current().isExtensionSupported<Extensions::EXT::disjoint_timer_query_webgl2>())
-        CORRADE_SKIP(Extensions::EXT::disjoint_timer_query_webgl2::string() + std::string(" is not available"));
+        CORRADE_SKIP(Extensions::EXT::disjoint_timer_query_webgl2::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::disjoint_timer_query>())
-        CORRADE_SKIP(Extensions::EXT::disjoint_timer_query::string() + std::string(" is not available"));
+        CORRADE_SKIP(Extensions::EXT::disjoint_timer_query::string() << "is not supported.");
     #endif
 
     Renderbuffer renderbuffer;

src/Magnum/GL/Test/TransformFeedbackGLTest.cpp

@@ -114,7 +114,7 @@ TransformFeedbackGLTest::TransformFeedbackGLTest() {
 void TransformFeedbackGLTest::construct() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::transform_feedback2>())
-        CORRADE_SKIP(Extensions::ARB::transform_feedback2::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::transform_feedback2::string() << "is not supported.");
     #endif
 
     {
@@ -130,7 +130,7 @@ void TransformFeedbackGLTest::construct() {
 void TransformFeedbackGLTest::constructMove() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::transform_feedback2>())
-        CORRADE_SKIP(Extensions::ARB::transform_feedback2::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::transform_feedback2::string() << "is not supported.");
     #endif
 
     TransformFeedback a;
@@ -160,7 +160,7 @@ void TransformFeedbackGLTest::constructMove() {
 void TransformFeedbackGLTest::wrap() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::transform_feedback2>())
-        CORRADE_SKIP(Extensions::ARB::transform_feedback2::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::transform_feedback2::string() << "is not supported.");
     #endif
 
     GLuint id;
@@ -182,7 +182,7 @@ void TransformFeedbackGLTest::label() {
     /* No-Op version is tested in AbstractObjectGLTest */
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::transform_feedback2>())
-        CORRADE_SKIP(Extensions::ARB::transform_feedback2::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::transform_feedback2::string() << "is not supported.");
     #endif
     if(!Context::current().isExtensionSupported<Extensions::KHR::debug>() &&
        !Context::current().isExtensionSupported<Extensions::EXT::debug_label>())
@@ -263,7 +263,7 @@ XfbShader::XfbShader() {
 void TransformFeedbackGLTest::attachBase() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::transform_feedback2>())
-        CORRADE_SKIP(Extensions::ARB::transform_feedback2::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::transform_feedback2::string() << "is not supported.");
     #endif
 
     /* Bind some FB to avoid errors on contexts w/o default FB */
@@ -310,7 +310,7 @@ void TransformFeedbackGLTest::attachBase() {
 void TransformFeedbackGLTest::attachRange() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::transform_feedback2>())
-        CORRADE_SKIP(Extensions::ARB::transform_feedback2::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::transform_feedback2::string() << "is not supported.");
     #endif
 
     /* Bind some FB to avoid errors on contexts w/o default FB */
@@ -399,7 +399,7 @@ XfbMultiShader::XfbMultiShader() {
 void TransformFeedbackGLTest::attachBases() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::transform_feedback2>())
-        CORRADE_SKIP(Extensions::ARB::transform_feedback2::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::transform_feedback2::string() << "is not supported.");
     #endif
 
     /* Bind some FB to avoid errors on contexts w/o default FB */
@@ -453,7 +453,7 @@ void TransformFeedbackGLTest::attachBases() {
 void TransformFeedbackGLTest::attachRanges() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::transform_feedback2>())
-        CORRADE_SKIP(Extensions::ARB::transform_feedback2::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::transform_feedback2::string() << "is not supported.");
     #endif
 
     /* Bind some FB to avoid errors on contexts w/o default FB */
@@ -511,7 +511,7 @@ void TransformFeedbackGLTest::attachRanges() {
 void TransformFeedbackGLTest::interleaved() {
     /* ARB_transform_feedback3 needed for gl_SkipComponents1 */
     if(!Context::current().isExtensionSupported<Extensions::ARB::transform_feedback3>())
-        CORRADE_SKIP(Extensions::ARB::transform_feedback3::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::transform_feedback3::string() << "is not supported.");
 
     /* Bind some FB to avoid errors on contexts w/o default FB */
     Renderbuffer color;
@@ -584,11 +584,11 @@ void TransformFeedbackGLTest::draw() {
 
     /* ARB_transform_feedback2 needed as base, other optional */
     if(!Context::current().isExtensionSupported<Extensions::ARB::transform_feedback2>())
-        CORRADE_SKIP(Extensions::ARB::transform_feedback2::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::transform_feedback2::string() << "is not supported.");
     if(DrawData[testCaseInstanceId()].stream && (!Context::current().isExtensionSupported<Extensions::ARB::transform_feedback3>() || TransformFeedback::maxVertexStreams() < 2))
         CORRADE_SKIP(Extensions::ARB::transform_feedback3::string() + std::string(" is not supported well enough."));
     if(DrawData[testCaseInstanceId()].instances && !Context::current().isExtensionSupported<Extensions::ARB::transform_feedback_instanced>())
-        CORRADE_SKIP(Extensions::ARB::transform_feedback_instanced::string() + std::string(" is not supported."));
+        CORRADE_SKIP(Extensions::ARB::transform_feedback_instanced::string() << "is not supported.");
 
     /* Bind some FB to avoid errors on contexts w/o default FB */
     Renderbuffer color;

src/Magnum/MeshTools/Test/CompileGLTest.cpp

@@ -380,7 +380,7 @@ template<class T> void CompileGLTest::twoDimensions() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(data.flags & Flag::ObjectId && !GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
-        CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() << "is not supported.");
     #endif
 
     #ifdef MAGNUM_BUILD_DEPRECATED
@@ -558,7 +558,7 @@ template<class T> void CompileGLTest::threeDimensions() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(data.flags & Flag::ObjectId && !GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
-        CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() << "is not supported.");
     #endif
 
     #ifdef MAGNUM_BUILD_DEPRECATED
@@ -852,10 +852,10 @@ template<class T> void CompileGLTest::threeDimensions() {
         #if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
         #ifndef MAGNUM_TARGET_GLES
         if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::geometry_shader4>())
-            CORRADE_SKIP(GL::Extensions::ARB::geometry_shader4::string() + std::string(" is not supported"));
+            CORRADE_SKIP(GL::Extensions::ARB::geometry_shader4::string() << "is not supported.");
         #else
         if(!GL::Context::current().isExtensionSupported<GL::Extensions::EXT::geometry_shader>())
-            CORRADE_SKIP(GL::Extensions::EXT::geometry_shader::string() + std::string(" is not supported"));
+            CORRADE_SKIP(GL::Extensions::EXT::geometry_shader::string() << "is not supported.");
         #endif
 
         _framebuffer.clear(GL::FramebufferClear::Color);

src/Magnum/Shaders/Test/FlatGLTest.cpp

@@ -306,7 +306,7 @@ template<UnsignedInt dimensions> void FlatGLTest::construct() {
 
     #ifndef MAGNUM_TARGET_GLES
     if((data.flags & Flat2D::Flag::ObjectId) && !GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
-        CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() << "is not supported.");
     #endif
 
     Flat<dimensions> shader{data.flags};
@@ -1045,7 +1045,7 @@ void FlatGLTest::renderObjectId2D() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
-        CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() << "is not supported.");
     #endif
 
     CORRADE_COMPARE(_framebuffer.checkStatus(GL::FramebufferTarget::Draw), GL::Framebuffer::Status::Complete);
@@ -1103,7 +1103,7 @@ void FlatGLTest::renderObjectId3D() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
-        CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() << "is not supported.");
     #endif
 
     CORRADE_COMPARE(_framebuffer.checkStatus(GL::FramebufferTarget::Draw), GL::Framebuffer::Status::Complete);
@@ -1166,7 +1166,7 @@ void FlatGLTest::renderObjectId3D() {
 void FlatGLTest::renderInstanced2D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::instanced_arrays>())
-        CORRADE_SKIP(GL::Extensions::ARB::instanced_arrays::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::ARB::instanced_arrays::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_GLES2)
     #ifndef MAGNUM_TARGET_WEBGL
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::ANGLE::instanced_arrays>() &&
@@ -1175,7 +1175,7 @@ void FlatGLTest::renderInstanced2D() {
         CORRADE_SKIP("GL_{ANGLE,EXT,NV}_instanced_arrays is not supported");
     #else
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::ANGLE::instanced_arrays>())
-        CORRADE_SKIP(GL::Extensions::ANGLE::instanced_arrays::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::ANGLE::instanced_arrays::string() << "is not supported.");
     #endif
     #endif
 
@@ -1250,7 +1250,7 @@ void FlatGLTest::renderInstanced2D() {
 void FlatGLTest::renderInstanced3D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::instanced_arrays>())
-        CORRADE_SKIP(GL::Extensions::ARB::instanced_arrays::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::ARB::instanced_arrays::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_GLES2)
     #ifndef MAGNUM_TARGET_WEBGL
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::ANGLE::instanced_arrays>() &&
@@ -1259,7 +1259,7 @@ void FlatGLTest::renderInstanced3D() {
         CORRADE_SKIP("GL_{ANGLE,EXT,NV}_instanced_arrays is not supported");
     #else
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::ANGLE::instanced_arrays>())
-        CORRADE_SKIP(GL::Extensions::ANGLE::instanced_arrays::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::ANGLE::instanced_arrays::string() << "is not supported.");
     #endif
     #endif
 

src/Magnum/Shaders/Test/MeshVisualizerGLTest.cpp

@@ -544,7 +544,7 @@ void MeshVisualizerGLTest::construct2D() {
 
     #ifndef MAGNUM_TARGET_GLES
     if((data.flags & MeshVisualizer2D::Flag::InstancedObjectId) && !GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
-        CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() << "is not supported.");
     #endif
 
     #if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
@@ -586,7 +586,7 @@ void MeshVisualizerGLTest::construct3D() {
 
     #ifndef MAGNUM_TARGET_GLES
     if((data.flags & MeshVisualizer3D::Flag::InstancedObjectId) && !GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
-        CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() << "is not supported.");
     #endif
 
     #if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
@@ -626,10 +626,10 @@ void MeshVisualizerGLTest::construct3D() {
 void MeshVisualizerGLTest::constructWireframeGeometryShader2D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::geometry_shader4>())
-        CORRADE_SKIP(GL::Extensions::ARB::geometry_shader4::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::ARB::geometry_shader4::string() << "is not supported.");
     #else
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::EXT::geometry_shader>())
-        CORRADE_SKIP(GL::Extensions::EXT::geometry_shader::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::EXT::geometry_shader::string() << "is not supported.");
     #endif
 
     #ifdef MAGNUM_TARGET_GLES
@@ -654,10 +654,10 @@ void MeshVisualizerGLTest::constructGeometryShader3D() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::geometry_shader4>())
-        CORRADE_SKIP(GL::Extensions::ARB::geometry_shader4::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::ARB::geometry_shader4::string() << "is not supported.");
     #else
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::EXT::geometry_shader>())
-        CORRADE_SKIP(GL::Extensions::EXT::geometry_shader::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::EXT::geometry_shader::string() << "is not supported.");
     #endif
 
     #ifdef MAGNUM_TARGET_GLES
@@ -713,10 +713,10 @@ void MeshVisualizerGLTest::construct3DGeometryShaderDisabledButNeeded() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::geometry_shader4>())
-        CORRADE_SKIP(GL::Extensions::ARB::geometry_shader4::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::ARB::geometry_shader4::string() << "is not supported.");
     #else
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::EXT::geometry_shader>())
-        CORRADE_SKIP(GL::Extensions::EXT::geometry_shader::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::EXT::geometry_shader::string() << "is not supported.");
     #endif
 
     std::ostringstream out;
@@ -733,10 +733,10 @@ void MeshVisualizerGLTest::construct3DConflictingBitangentInput() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::geometry_shader4>())
-        CORRADE_SKIP(GL::Extensions::ARB::geometry_shader4::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::ARB::geometry_shader4::string() << "is not supported.");
     #else
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::EXT::geometry_shader>())
-        CORRADE_SKIP(GL::Extensions::EXT::geometry_shader::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::EXT::geometry_shader::string() << "is not supported.");
     #endif
 
     std::ostringstream out;
@@ -900,10 +900,10 @@ void MeshVisualizerGLTest::setTangentBitangentNormalNotEnabled3D() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::geometry_shader4>())
-        CORRADE_SKIP(GL::Extensions::ARB::geometry_shader4::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::ARB::geometry_shader4::string() << "is not supported.");
     #else
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::EXT::geometry_shader>())
-        CORRADE_SKIP(GL::Extensions::EXT::geometry_shader::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::EXT::geometry_shader::string() << "is not supported.");
     #endif
 
     std::ostringstream out;
@@ -961,10 +961,10 @@ void MeshVisualizerGLTest::renderTeardown() {
 void MeshVisualizerGLTest::renderDefaultsWireframe2D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::geometry_shader4>())
-        CORRADE_SKIP(GL::Extensions::ARB::geometry_shader4::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::ARB::geometry_shader4::string() << "is not supported.");
     #else
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::EXT::geometry_shader>())
-        CORRADE_SKIP(GL::Extensions::EXT::geometry_shader::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::EXT::geometry_shader::string() << "is not supported.");
     #endif
 
     #ifdef MAGNUM_TARGET_GLES
@@ -1010,10 +1010,10 @@ void MeshVisualizerGLTest::renderDefaultsWireframe2D() {
 void MeshVisualizerGLTest::renderDefaultsWireframe3D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::geometry_shader4>())
-        CORRADE_SKIP(GL::Extensions::ARB::geometry_shader4::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::ARB::geometry_shader4::string() << "is not supported.");
     #else
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::EXT::geometry_shader>())
-        CORRADE_SKIP(GL::Extensions::EXT::geometry_shader::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::EXT::geometry_shader::string() << "is not supported.");
     #endif
 
     #ifdef MAGNUM_TARGET_GLES
@@ -1064,7 +1064,7 @@ void MeshVisualizerGLTest::renderDefaultsObjectId2D() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
-        CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() << "is not supported.");
     #endif
 
     /* Configure a texture with preset filtering and wrapping. The goal here is
@@ -1113,7 +1113,7 @@ void MeshVisualizerGLTest::renderDefaultsObjectId3D() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
-        CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() << "is not supported.");
     #endif
 
     /* Configure a texture with preset filtering and wrapping. The goal here is
@@ -1308,10 +1308,10 @@ void MeshVisualizerGLTest::renderDefaultsPrimitiveId3D() {
 void MeshVisualizerGLTest::renderDefaultsTangentBitangentNormal() {
     #ifndef MAGNUM_TARGET_GLES
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::geometry_shader4>())
-        CORRADE_SKIP(GL::Extensions::ARB::geometry_shader4::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::ARB::geometry_shader4::string() << "is not supported.");
     #else
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::EXT::geometry_shader>())
-        CORRADE_SKIP(GL::Extensions::EXT::geometry_shader::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::EXT::geometry_shader::string() << "is not supported.");
     #endif
 
     GL::Mesh sphere = MeshTools::compile(Primitives::uvSphereSolid(4, 8,
@@ -1347,10 +1347,10 @@ void MeshVisualizerGLTest::renderWireframe2D() {
     #if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
     #ifndef MAGNUM_TARGET_GLES
     if(!(data.flags & MeshVisualizer2D::Flag::NoGeometryShader) && !GL::Context::current().isExtensionSupported<GL::Extensions::ARB::geometry_shader4>())
-        CORRADE_SKIP(GL::Extensions::ARB::geometry_shader4::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::ARB::geometry_shader4::string() << "is not supported.");
     #else
     if(!(data.flags & MeshVisualizer2D::Flag::NoGeometryShader) && !GL::Context::current().isExtensionSupported<GL::Extensions::EXT::geometry_shader>())
-        CORRADE_SKIP(GL::Extensions::EXT::geometry_shader::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::EXT::geometry_shader::string() << "is not supported.");
     #endif
 
     #ifdef MAGNUM_TARGET_GLES
@@ -1439,10 +1439,10 @@ void MeshVisualizerGLTest::renderWireframe3D() {
     #if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
     #ifndef MAGNUM_TARGET_GLES
     if(!(data.flags & MeshVisualizer3D::Flag::NoGeometryShader) && !GL::Context::current().isExtensionSupported<GL::Extensions::ARB::geometry_shader4>())
-        CORRADE_SKIP(GL::Extensions::ARB::geometry_shader4::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::ARB::geometry_shader4::string() << "is not supported.");
     #else
     if(!(data.flags & MeshVisualizer3D::Flag::NoGeometryShader) && !GL::Context::current().isExtensionSupported<GL::Extensions::EXT::geometry_shader>())
-        CORRADE_SKIP(GL::Extensions::EXT::geometry_shader::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::EXT::geometry_shader::string() << "is not supported.");
     #endif
 
     #ifdef MAGNUM_TARGET_GLES
@@ -1539,7 +1539,7 @@ void MeshVisualizerGLTest::renderObjectVertexPrimitiveId2D() {
 
     #ifndef MAGNUM_TARGET_GLES
     if((data.flags2D & MeshVisualizer2D::Flag::InstancedObjectId) && !GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
-        CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() << "is not supported.");
     #endif
 
     /* Interestingly for PrimitiveIdFromVertexId gl_VertexID in SwiftShader
@@ -1558,10 +1558,10 @@ void MeshVisualizerGLTest::renderObjectVertexPrimitiveId2D() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(data.flags2D & MeshVisualizer2D::Flag::Wireframe && !(data.flags2D & MeshVisualizer2D::Flag::NoGeometryShader) && !GL::Context::current().isExtensionSupported<GL::Extensions::ARB::geometry_shader4>())
-        CORRADE_SKIP(GL::Extensions::ARB::geometry_shader4::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::ARB::geometry_shader4::string() << "is not supported.");
     #else
     if(data.flags2D & MeshVisualizer2D::Flag::Wireframe && !(data.flags2D & MeshVisualizer2D::Flag::NoGeometryShader) && !GL::Context::current().isExtensionSupported<GL::Extensions::EXT::geometry_shader>())
-        CORRADE_SKIP(GL::Extensions::EXT::geometry_shader::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::EXT::geometry_shader::string() << "is not supported.");
     #endif
     #endif
 
@@ -1639,7 +1639,7 @@ void MeshVisualizerGLTest::renderObjectVertexPrimitiveId3D() {
 
     #ifndef MAGNUM_TARGET_GLES
     if((data.flags3D & MeshVisualizer3D::Flag::InstancedObjectId) && !GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
-        CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() << "is not supported.");
     #endif
 
     /* Interestingly for PrimitiveIdFromVertexId gl_VertexID in SwiftShader
@@ -1658,10 +1658,10 @@ void MeshVisualizerGLTest::renderObjectVertexPrimitiveId3D() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(data.flags3D & MeshVisualizer3D::Flag::Wireframe && !(data.flags3D & MeshVisualizer3D::Flag::NoGeometryShader) && !GL::Context::current().isExtensionSupported<GL::Extensions::ARB::geometry_shader4>())
-        CORRADE_SKIP(GL::Extensions::ARB::geometry_shader4::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::ARB::geometry_shader4::string() << "is not supported.");
     #else
     if(data.flags3D & MeshVisualizer3D::Flag::Wireframe && !(data.flags3D & MeshVisualizer3D::Flag::NoGeometryShader) && !GL::Context::current().isExtensionSupported<GL::Extensions::EXT::geometry_shader>())
-        CORRADE_SKIP(GL::Extensions::EXT::geometry_shader::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::EXT::geometry_shader::string() << "is not supported.");
     #endif
     #endif
 
@@ -1746,10 +1746,10 @@ void MeshVisualizerGLTest::renderObjectVertexPrimitiveId3D() {
 void MeshVisualizerGLTest::renderWireframe3DPerspective() {
     #ifndef MAGNUM_TARGET_GLES
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::geometry_shader4>())
-        CORRADE_SKIP(GL::Extensions::ARB::geometry_shader4::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::ARB::geometry_shader4::string() << "is not supported.");
     #else
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::EXT::geometry_shader>())
-        CORRADE_SKIP(GL::Extensions::EXT::geometry_shader::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::EXT::geometry_shader::string() << "is not supported.");
     #endif
 
     GL::Mesh plane = MeshTools::compile(Primitives::planeSolid());
@@ -1790,10 +1790,10 @@ void MeshVisualizerGLTest::renderTangentBitangentNormal() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::geometry_shader4>())
-        CORRADE_SKIP(GL::Extensions::ARB::geometry_shader4::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::ARB::geometry_shader4::string() << "is not supported.");
     #else
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::EXT::geometry_shader>())
-        CORRADE_SKIP(GL::Extensions::EXT::geometry_shader::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::EXT::geometry_shader::string() << "is not supported.");
     #endif
 
     GL::Renderer::enable(GL::Renderer::Feature::DepthTest);

src/Magnum/Shaders/Test/PhongGLTest.cpp

@@ -600,7 +600,7 @@ void PhongGLTest::construct() {
 
     #ifndef MAGNUM_TARGET_GLES
     if((data.flags & Phong::Flag::ObjectId) && !GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
-        CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() << "is not supported.");
     #endif
 
     Phong shader{data.flags, data.lightCount};
@@ -1432,7 +1432,7 @@ void PhongGLTest::renderObjectId() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
-        CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() << "is not supported.");
     #endif
 
     CORRADE_COMPARE(_framebuffer.checkStatus(GL::FramebufferTarget::Draw), GL::Framebuffer::Status::Complete);
@@ -1752,7 +1752,7 @@ void PhongGLTest::renderInstanced() {
 
     #ifndef MAGNUM_TARGET_GLES
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::instanced_arrays>())
-        CORRADE_SKIP(GL::Extensions::ARB::instanced_arrays::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::ARB::instanced_arrays::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_GLES2)
     #ifndef MAGNUM_TARGET_WEBGL
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::ANGLE::instanced_arrays>() &&
@@ -1761,7 +1761,7 @@ void PhongGLTest::renderInstanced() {
         CORRADE_SKIP("GL_{ANGLE,EXT,NV}_instanced_arrays is not supported");
     #else
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::ANGLE::instanced_arrays>())
-        CORRADE_SKIP(GL::Extensions::ANGLE::instanced_arrays::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::ANGLE::instanced_arrays::string() << "is not supported.");
     #endif
     #endif
 

src/Magnum/Text/Test/RendererGLTest.cpp

@@ -263,7 +263,7 @@ void RendererGLTest::renderMeshIndexType() {
 void RendererGLTest::mutableText() {
     #ifndef MAGNUM_TARGET_GLES
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::map_buffer_range>())
-        CORRADE_SKIP(GL::Extensions::ARB::map_buffer_range::string() + std::string(" is not supported"));
+        CORRADE_SKIP(GL::Extensions::ARB::map_buffer_range::string() << "is not supported.");
     #elif defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::EXT::map_buffer_range>() &&
        !GL::Context::current().isExtensionSupported<GL::Extensions::OES::mapbuffer>())

src/Magnum/TextureTools/Test/DistanceFieldGLTest.cpp

@@ -216,7 +216,7 @@ void DistanceFieldGLTest::test() {
 void DistanceFieldGLTest::benchmark() {
     #ifdef MAGNUM_TARGET_GLES
     if(!GL::Context::current().isExtensionSupported<GL::Extensions::EXT::disjoint_timer_query>())
-        CORRADE_SKIP(GL::Extensions::EXT::disjoint_timer_query::string() + std::string{" is not supported, can't benchmark"});
+        CORRADE_SKIP(GL::Extensions::EXT::disjoint_timer_query::string() << "is not supported, can't benchmark");
     #endif
 
     Containers::Pointer<Trade::AbstractImporter> importer;