diff --git a/src/Magnum/GL/Test/CubeMapTextureArrayGLTest.cpp b/src/Magnum/GL/Test/CubeMapTextureArrayGLTest.cpp
index 41c9e7d56..24d2fbf05 100644
--- a/src/Magnum/GL/Test/CubeMapTextureArrayGLTest.cpp
+++ b/src/Magnum/GL/Test/CubeMapTextureArrayGLTest.cpp
@@ -676,7 +676,8 @@ void CubeMapTextureArrayGLTest::viewOnNonArray() {
 }
 
 void CubeMapTextureArrayGLTest::image() {
-    setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name);
+    auto&& data = PixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
@@ -688,28 +689,29 @@ void CubeMapTextureArrayGLTest::image() {
 
     CubeMapTextureArray texture;
     texture.setImage(0, TextureFormat::RGBA8, ImageView3D{
-        PixelStorageData[testCaseInstanceId()].storage,
+        data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, {2, 2, 6},
-        PixelStorageData[testCaseInstanceId()].dataSparse});
+        data.dataSparse});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     /** @todo How to test this on ES? */
     #ifndef MAGNUM_TARGET_GLES
-    Image3D image = texture.image(0, {PixelStorageData[testCaseInstanceId()].storage, PixelFormat::RGBA, PixelType::UnsignedByte});
+    Image3D image = texture.image(0, {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.flags(), ImageFlag3D::CubeMap|ImageFlag3D::Array);
     CORRADE_COMPARE(image.size(), Vector3i(2, 2, 6));
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset),
-        PixelStorageData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
     #endif
 }
 
 void CubeMapTextureArrayGLTest::imageBuffer() {
-    setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name);
+    auto&& data = PixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
@@ -721,45 +723,46 @@ void CubeMapTextureArrayGLTest::imageBuffer() {
 
     CubeMapTextureArray texture;
     texture.setImage(0, TextureFormat::RGBA8, BufferImage3D{
-        PixelStorageData[testCaseInstanceId()].storage,
+        data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, {2, 2, 6},
-        PixelStorageData[testCaseInstanceId()].dataSparse,
+        data.dataSparse,
         BufferUsage::StaticDraw});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     /** @todo How to test this on ES? */
     #ifndef MAGNUM_TARGET_GLES
-    BufferImage3D image = texture.image(0, {PixelStorageData[testCaseInstanceId()].storage,
+    BufferImage3D image = texture.image(0, {data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte}, BufferUsage::StaticRead);
     const auto imageData = image.buffer().data();
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.size(), Vector3i(2, 2, 6));
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset),
-        PixelStorageData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
     #endif
 }
 
 #ifndef MAGNUM_TARGET_GLES
 void CubeMapTextureArrayGLTest::imageQueryView() {
-    setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name);
+    auto&& data = PixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
         CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported.");
 
     CubeMapTextureArray texture;
     texture.setImage(0, TextureFormat::RGBA8, ImageView3D{
-        PixelStorageData[testCaseInstanceId()].storage,
+        data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, {2, 2, 6},
-        PixelStorageData[testCaseInstanceId()].dataSparse});
+        data.dataSparse});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> data{PixelStorageData[testCaseInstanceId()].offset + 2*2*6*4};
-    MutableImageView3D image{PixelStorageData[testCaseInstanceId()].storage, PixelFormat::RGBA, PixelType::UnsignedByte, {2, 2, 6}, data, ImageFlag3D::Array};
+    Containers::Array<char> imageData{data.offset + 2*2*6*4};
+    MutableImageView3D image{data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, {2, 2, 6}, imageData, ImageFlag3D::Array};
     texture.image(0, image);
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -767,14 +770,15 @@ void CubeMapTextureArrayGLTest::imageQueryView() {
     /* Doesn't matter what flags are set, they stay untouched */
     CORRADE_COMPARE(image.flags(), ImageFlag3D::Array);
     CORRADE_COMPARE(image.size(), Vector3i(2, 2, 6));
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset),
-        PixelStorageData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 #endif
 
 void CubeMapTextureArrayGLTest::compressedImage() {
-    setTestCaseDescription(CompressedPixelStorageData[testCaseInstanceId()].name);
+    auto&& data = CompressedPixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
@@ -792,35 +796,36 @@ void CubeMapTextureArrayGLTest::compressedImage() {
     #endif
 
     #ifndef MAGNUM_TARGET_GLES
-    if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #endif
 
     CubeMapTextureArray texture;
     texture.setCompressedImage(0, CompressedImageView3D{
         #ifndef MAGNUM_TARGET_GLES
-        CompressedPixelStorageData[testCaseInstanceId()].storage,
+        data.storage,
         #endif
         CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 6},
-        CompressedPixelStorageData[testCaseInstanceId()].dataSparse});
+        data.dataSparse});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     #ifndef MAGNUM_TARGET_GLES
-    CompressedImage3D image = texture.compressedImage(0, {CompressedPixelStorageData[testCaseInstanceId()].storage});
+    CompressedImage3D image = texture.compressedImage(0, {data.storage});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.flags(), ImageFlag3D::CubeMap|ImageFlag3D::Array);
     CORRADE_COMPARE(image.size(), (Vector3i{4, 4, 6}));
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(CompressedPixelStorageData[testCaseInstanceId()].offset),
-        CompressedPixelStorageData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
     #endif
 }
 
 void CubeMapTextureArrayGLTest::compressedImageBuffer() {
-    setTestCaseDescription(CompressedPixelStorageData[testCaseInstanceId()].name);
+    auto&& data = CompressedPixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
@@ -838,59 +843,60 @@ void CubeMapTextureArrayGLTest::compressedImageBuffer() {
     #endif
 
     #ifndef MAGNUM_TARGET_GLES
-    if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #endif
 
     CubeMapTextureArray texture;
     texture.setCompressedImage(0, CompressedBufferImage3D{
         #ifndef MAGNUM_TARGET_GLES
-        CompressedPixelStorageData[testCaseInstanceId()].storage,
+        data.storage,
         #endif
         CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 6},
-        CompressedPixelStorageData[testCaseInstanceId()].dataSparse,
+        data.dataSparse,
         BufferUsage::StaticDraw});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     /** @todo How to test this on ES? */
     #ifndef MAGNUM_TARGET_GLES
-    CompressedBufferImage3D image = texture.compressedImage(0, {CompressedPixelStorageData[testCaseInstanceId()].storage}, BufferUsage::StaticRead);
+    CompressedBufferImage3D image = texture.compressedImage(0, {data.storage}, BufferUsage::StaticRead);
     const auto imageData = image.buffer().data();
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.size(), (Vector3i{4, 4, 6}));
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(CompressedPixelStorageData[testCaseInstanceId()].offset),
-        CompressedPixelStorageData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
     #endif
 }
 
 #ifndef MAGNUM_TARGET_GLES
 void CubeMapTextureArrayGLTest::compressedImageQueryView() {
-    setTestCaseDescription(CompressedPixelStorageData[testCaseInstanceId()].name);
+    auto&& data = CompressedPixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
         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() << "is not supported.");
 
-    if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
 
     CubeMapTextureArray texture;
     texture.setCompressedImage(0, CompressedImageView3D{
         #ifndef MAGNUM_TARGET_GLES
-        CompressedPixelStorageData[testCaseInstanceId()].storage,
+        data.storage,
         #endif
         CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 6},
-        CompressedPixelStorageData[testCaseInstanceId()].dataSparse});
+        data.dataSparse});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> data{CompressedPixelStorageData[testCaseInstanceId()].offset + 6*16};
-    MutableCompressedImageView3D image{CompressedPixelStorageData[testCaseInstanceId()].storage, CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 6}, data, ImageFlag3D::Array};
+    Containers::Array<char> imageData{data.offset + 6*16};
+    MutableCompressedImageView3D image{data.storage, CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 6}, imageData, ImageFlag3D::Array};
     texture.compressedImage(0, image);
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -898,8 +904,8 @@ void CubeMapTextureArrayGLTest::compressedImageQueryView() {
     /* Doesn't matter what flags are set, they stay untouched */
     CORRADE_COMPARE(image.flags(), ImageFlag3D::Array);
     CORRADE_COMPARE(image.size(), (Vector3i{4, 4, 6}));
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(CompressedPixelStorageData[testCaseInstanceId()].offset),
-        CompressedPixelStorageData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 #endif
@@ -940,7 +946,8 @@ constexpr UnsignedByte SubDataComplete[]{
 #endif
 
 void CubeMapTextureArrayGLTest::subImage() {
-    setTestCaseDescription(SubPixelStorageData[testCaseInstanceId()].name);
+    auto&& data = SubPixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
@@ -954,9 +961,9 @@ void CubeMapTextureArrayGLTest::subImage() {
     texture.setImage(0, TextureFormat::RGBA8,
         ImageView3D(PixelFormat::RGBA, PixelType::UnsignedByte, {4, 4, 6}, Zero));
     texture.setSubImage(0, Vector3i(1), ImageView3D{
-        SubPixelStorageData[testCaseInstanceId()].storage,
+        data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, {2, 2, 4},
-        SubPixelStorageData[testCaseInstanceId()].dataSparse});
+        data.dataSparse});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
@@ -973,7 +980,8 @@ void CubeMapTextureArrayGLTest::subImage() {
 }
 
 void CubeMapTextureArrayGLTest::subImageBuffer() {
-    setTestCaseDescription(SubPixelStorageData[testCaseInstanceId()].name);
+    auto&& data = SubPixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
@@ -987,9 +995,9 @@ void CubeMapTextureArrayGLTest::subImageBuffer() {
     texture.setImage(0, TextureFormat::RGBA8,
         ImageView3D(PixelFormat::RGBA, PixelType::UnsignedByte, {4, 4, 6}, Zero));
     texture.setSubImage(0, Vector3i(1), BufferImage3D{
-        SubPixelStorageData[testCaseInstanceId()].storage,
+        data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, {2, 2, 4},
-        SubPixelStorageData[testCaseInstanceId()].dataSparse,
+        data.dataSparse,
         BufferUsage::StaticDraw});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -1010,7 +1018,8 @@ void CubeMapTextureArrayGLTest::subImageBuffer() {
 
 #ifndef MAGNUM_TARGET_GLES
 void CubeMapTextureArrayGLTest::subImageQuery() {
-    setTestCaseDescription(SubPixelStorageData[testCaseInstanceId()].name);
+    auto&& data = SubPixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
         CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported.");
@@ -1024,20 +1033,21 @@ void CubeMapTextureArrayGLTest::subImageQuery() {
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     Image3D image = texture.subImage(0, Range3Di::fromSize(Vector3i{1}, {2, 2, 4}),
-        {SubPixelStorageData[testCaseInstanceId()].storage,
+        {data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.flags(), ImageFlag3D::Array);
     CORRADE_COMPARE(image.size(), Vector3i(2, 2, 4));
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(SubPixelStorageData[testCaseInstanceId()].offset),
-        SubPixelStorageData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 
 void CubeMapTextureArrayGLTest::subImageQueryView() {
-    setTestCaseDescription(SubPixelStorageData[testCaseInstanceId()].name);
+    auto&& data = SubPixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
         CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported.");
@@ -1050,8 +1060,8 @@ void CubeMapTextureArrayGLTest::subImageQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> data{SubPixelStorageData[testCaseInstanceId()].offset + 2*2*4*4};
-    MutableImageView3D image{PixelStorageData[testCaseInstanceId()].storage, PixelFormat::RGBA, PixelType::UnsignedByte, {2, 2, 4}, data, ImageFlag3D::Array};
+    Containers::Array<char> imageData{data.offset + 2*2*4*4};
+    MutableImageView3D image{data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, {2, 2, 4}, imageData, ImageFlag3D::Array};
     texture.subImage(0, Range3Di::fromSize(Vector3i{1}, {2, 2, 4}), image);
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -1059,13 +1069,14 @@ void CubeMapTextureArrayGLTest::subImageQueryView() {
     /* Doesn't matter what flags are set, they stay untouched */
     CORRADE_COMPARE(image.flags(), ImageFlag3D::Array);
     CORRADE_COMPARE(image.size(), Vector3i(2, 2, 4));
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(SubPixelStorageData[testCaseInstanceId()].offset),
-        SubPixelStorageData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 
 void CubeMapTextureArrayGLTest::subImageQueryBuffer() {
-    setTestCaseDescription(SubPixelStorageData[testCaseInstanceId()].name);
+    auto&& data = SubPixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
         CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported.");
@@ -1079,15 +1090,15 @@ void CubeMapTextureArrayGLTest::subImageQueryBuffer() {
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     BufferImage3D image = texture.subImage(0, Range3Di::fromSize(Vector3i{1}, {2, 2, 4}),
-        {SubPixelStorageData[testCaseInstanceId()].storage,
+        {data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte}, BufferUsage::StaticRead);
     const auto imageData = image.buffer().data();
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.size(), Vector3i(2, 2, 4));
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(SubPixelStorageData[testCaseInstanceId()].offset),
-        SubPixelStorageData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 #endif
@@ -1159,7 +1170,8 @@ constexpr UnsignedByte CompressedSubDataComplete[] = {
 #endif
 
 void CubeMapTextureArrayGLTest::compressedSubImage() {
-    setTestCaseDescription(CompressedSubPixelStorageData[testCaseInstanceId()].name);
+    auto&& data = CompressedSubPixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
@@ -1177,7 +1189,7 @@ void CubeMapTextureArrayGLTest::compressedSubImage() {
     #endif
 
     #ifndef MAGNUM_TARGET_GLES
-    if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #endif
 
@@ -1186,10 +1198,10 @@ void CubeMapTextureArrayGLTest::compressedSubImage() {
         {12, 12, 6}, CompressedZero});
     texture.setCompressedSubImage(0, {4, 4, 1}, CompressedImageView3D{
         #ifndef MAGNUM_TARGET_GLES
-        CompressedSubPixelStorageData[testCaseInstanceId()].storage,
+        data.storage,
         #endif
         CompressedPixelFormat::RGBAS3tcDxt3, Vector3i{4},
-        CompressedSubPixelStorageData[testCaseInstanceId()].dataSparse});
+        data.dataSparse});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
@@ -1201,7 +1213,7 @@ void CubeMapTextureArrayGLTest::compressedSubImage() {
     CORRADE_COMPARE(image.size(), (Vector3i{12, 12, 6}));
 
     {
-        CORRADE_EXPECT_FAIL_IF(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && (Context::current().detectedDriver() & Context::DetectedDriver::NVidia),
+        CORRADE_EXPECT_FAIL_IF(data.storage != CompressedPixelStorage{} && (Context::current().detectedDriver() & Context::DetectedDriver::NVidia),
             "Non-default compressed pixel storage for cube map textures behaves weirdly on NVidia for client-memory images");
 
         CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()),
@@ -1212,7 +1224,8 @@ void CubeMapTextureArrayGLTest::compressedSubImage() {
 }
 
 void CubeMapTextureArrayGLTest::compressedSubImageBuffer() {
-    setTestCaseDescription(CompressedSubPixelStorageData[testCaseInstanceId()].name);
+    auto&& data = CompressedSubPixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
@@ -1230,7 +1243,7 @@ void CubeMapTextureArrayGLTest::compressedSubImageBuffer() {
     #endif
 
     #ifndef MAGNUM_TARGET_GLES
-    if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #endif
 
@@ -1239,10 +1252,10 @@ void CubeMapTextureArrayGLTest::compressedSubImageBuffer() {
         {12, 12, 6}, CompressedZero});
     texture.setCompressedSubImage(0, {4, 4, 1}, CompressedBufferImage3D{
         #ifndef MAGNUM_TARGET_GLES
-        CompressedSubPixelStorageData[testCaseInstanceId()].storage,
+        data.storage,
         #endif
         CompressedPixelFormat::RGBAS3tcDxt3, Vector3i{4},
-        CompressedSubPixelStorageData[testCaseInstanceId()].dataSparse,
+        data.dataSparse,
         BufferUsage::StaticDraw});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -1262,7 +1275,8 @@ void CubeMapTextureArrayGLTest::compressedSubImageBuffer() {
 
 #ifndef MAGNUM_TARGET_GLES
 void CubeMapTextureArrayGLTest::compressedSubImageQuery() {
-    setTestCaseDescription(CompressedSubPixelStorageData[testCaseInstanceId()].name);
+    auto&& data = CompressedSubPixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
         CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported.");
@@ -1270,9 +1284,9 @@ void CubeMapTextureArrayGLTest::compressedSubImageQuery() {
         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() << "is not supported.");
-    if(CompressedSubPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
-    if(CompressedSubPixelStorageData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
+    if(data.storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
         CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported.");
 
     CubeMapTextureArray texture;
@@ -1281,19 +1295,20 @@ void CubeMapTextureArrayGLTest::compressedSubImageQuery() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    CompressedImage3D image = texture.compressedSubImage(0, Range3Di::fromSize({4, 4, 1}, Vector3i{4}), {CompressedSubPixelStorageData[testCaseInstanceId()].storage});
+    CompressedImage3D image = texture.compressedSubImage(0, Range3Di::fromSize({4, 4, 1}, Vector3i{4}), {data.storage});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.flags(), ImageFlag3D::Array);
     CORRADE_COMPARE(image.size(), Vector3i{4});
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(CompressedSubPixelStorageData[testCaseInstanceId()].offset),
-        CompressedSubPixelStorageData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 
 void CubeMapTextureArrayGLTest::compressedSubImageQueryView() {
-    setTestCaseDescription(CompressedSubPixelStorageData[testCaseInstanceId()].name);
+    auto&& data = CompressedSubPixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
         CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported.");
@@ -1301,9 +1316,9 @@ void CubeMapTextureArrayGLTest::compressedSubImageQueryView() {
         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() << "is not supported.");
-    if(CompressedSubPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
-    if(CompressedSubPixelStorageData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
+    if(data.storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
         CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported.");
 
     CubeMapTextureArray texture;
@@ -1312,8 +1327,8 @@ void CubeMapTextureArrayGLTest::compressedSubImageQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> data{CompressedSubPixelStorageData[testCaseInstanceId()].offset + 4*16};
-    MutableCompressedImageView3D image{CompressedPixelStorageData[testCaseInstanceId()].storage, CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 4}, data, ImageFlag3D::Array};
+    Containers::Array<char> imageData{data.offset + 4*16};
+    MutableCompressedImageView3D image{data.storage, CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 4}, imageData, ImageFlag3D::Array};
     texture.compressedSubImage(0, Range3Di::fromSize({4, 4, 1}, Vector3i{4}), image);
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -1321,13 +1336,14 @@ void CubeMapTextureArrayGLTest::compressedSubImageQueryView() {
     /* Doesn't matter what flags are set, they stay untouched */
     CORRADE_COMPARE(image.flags(), ImageFlag3D::Array);
     CORRADE_COMPARE(image.size(), Vector3i{4});
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(CompressedSubPixelStorageData[testCaseInstanceId()].offset),
-        CompressedSubPixelStorageData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 
 void CubeMapTextureArrayGLTest::compressedSubImageQueryBuffer() {
-    setTestCaseDescription(CompressedSubPixelStorageData[testCaseInstanceId()].name);
+    auto&& data = CompressedSubPixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_cube_map_array>())
         CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported.");
@@ -1335,9 +1351,9 @@ void CubeMapTextureArrayGLTest::compressedSubImageQueryBuffer() {
         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() << "is not supported.");
-    if(CompressedSubPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
-    if(CompressedSubPixelStorageData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
+    if(data.storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
         CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported.");
 
     CubeMapTextureArray texture;
@@ -1346,14 +1362,14 @@ void CubeMapTextureArrayGLTest::compressedSubImageQueryBuffer() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    CompressedBufferImage3D image = texture.compressedSubImage(0, Range3Di::fromSize({4, 4, 1}, Vector3i{4}), {CompressedSubPixelStorageData[testCaseInstanceId()].storage}, BufferUsage::StaticRead);
+    CompressedBufferImage3D image = texture.compressedSubImage(0, Range3Di::fromSize({4, 4, 1}, Vector3i{4}), {data.storage}, BufferUsage::StaticRead);
     const auto imageData = image.buffer().data();
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.size(), Vector3i{4});
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(CompressedSubPixelStorageData[testCaseInstanceId()].offset),
-        CompressedSubPixelStorageData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 #endif
diff --git a/src/Magnum/GL/Test/CubeMapTextureGLTest.cpp b/src/Magnum/GL/Test/CubeMapTextureGLTest.cpp
index 608643b65..3fe7baf18 100644
--- a/src/Magnum/GL/Test/CubeMapTextureGLTest.cpp
+++ b/src/Magnum/GL/Test/CubeMapTextureGLTest.cpp
@@ -812,14 +812,15 @@ void CubeMapTextureGLTest::viewOnArray() {
 #endif
 
 void CubeMapTextureGLTest::storage() {
-    setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name);
+    auto&& data = PixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     #ifdef MAGNUM_TARGET_GLES2
     #ifndef MAGNUM_TARGET_WEBGL
-    if(PixelStorageData[testCaseInstanceId()].storage != PixelStorage{} && !Context::current().isExtensionSupported<Extensions::EXT::unpack_subimage>())
+    if(data.storage != PixelStorage{} && !Context::current().isExtensionSupported<Extensions::EXT::unpack_subimage>())
         CORRADE_SKIP(Extensions::EXT::unpack_subimage::string() << "is not supported.");
     #else
-    if(PixelStorageData[testCaseInstanceId()].storage != PixelStorage{})
+    if(data.storage != PixelStorage{})
         CORRADE_SKIP("Image unpack is not supported in WebGL 1.");
     #endif
     #endif
@@ -832,19 +833,19 @@ void CubeMapTextureGLTest::storage() {
         TextureFormat::RGBA,
         #endif
         Vector2i(2));
-    texture.setSubImage(CubeMapCoordinate::PositiveX, 0, {}, ImageView2D{PixelStorageData[testCaseInstanceId()].storage,
+    texture.setSubImage(CubeMapCoordinate::PositiveX, 0, {}, ImageView2D{data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2),
-        PixelStorageData[testCaseInstanceId()].dataSparse});
+        data.dataSparse});
     texture.setSubImage(CubeMapCoordinate::NegativeX, 0, {},
         ImageView2D{PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), Zero});
-    texture.setSubImage(CubeMapCoordinate::PositiveY, 0, {}, ImageView2D{PixelStorageData[testCaseInstanceId()].storage,
+    texture.setSubImage(CubeMapCoordinate::PositiveY, 0, {}, ImageView2D{data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2),
-        PixelStorageData[testCaseInstanceId()].dataSparse});
+        data.dataSparse});
     texture.setSubImage(CubeMapCoordinate::NegativeY, 0, {},
         ImageView2D{PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), Zero});
-    texture.setSubImage(CubeMapCoordinate::PositiveZ, 0, {}, ImageView2D{PixelStorageData[testCaseInstanceId()].storage,
+    texture.setSubImage(CubeMapCoordinate::PositiveZ, 0, {}, ImageView2D{data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2),
-        PixelStorageData[testCaseInstanceId()].dataSparse});
+        data.dataSparse});
     texture.setSubImage(CubeMapCoordinate::NegativeZ, 0, {},
         ImageView2D{PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), Zero});
 
@@ -854,50 +855,51 @@ void CubeMapTextureGLTest::storage() {
     #ifndef MAGNUM_TARGET_GLES
     {
         Image2D image = texture.image(CubeMapCoordinate::PositiveX, 0,
-            {PixelStorageData[testCaseInstanceId()].storage,
+            {data.storage,
             PixelFormat::RGBA, PixelType::UnsignedByte});
 
         MAGNUM_VERIFY_NO_GL_ERROR();
 
         CORRADE_COMPARE(image.size(), Vector2i(2));
-        CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset),
-            PixelStorageData[testCaseInstanceId()].data,
+        CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+            data.data,
             TestSuite::Compare::Container);
     } {
         Image2D image = texture.image(CubeMapCoordinate::PositiveY, 0,
-            {PixelStorageData[testCaseInstanceId()].storage,
+            {data.storage,
             PixelFormat::RGBA, PixelType::UnsignedByte});
 
         MAGNUM_VERIFY_NO_GL_ERROR();
 
         CORRADE_COMPARE(image.size(), Vector2i(2));
-        CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset),
-            PixelStorageData[testCaseInstanceId()].data,
+        CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+            data.data,
             TestSuite::Compare::Container);
     } {
         Image2D image = texture.image(CubeMapCoordinate::PositiveZ, 0,
-            {PixelStorageData[testCaseInstanceId()].storage,
+            {data.storage,
             PixelFormat::RGBA, PixelType::UnsignedByte});
 
         MAGNUM_VERIFY_NO_GL_ERROR();
 
         CORRADE_COMPARE(image.size(), Vector2i(2));
-        CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset),
-            PixelStorageData[testCaseInstanceId()].data,
+        CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+            data.data,
             TestSuite::Compare::Container);
     }
     #endif
 }
 
 void CubeMapTextureGLTest::image() {
-    setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name);
+    auto&& data = PixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     #ifdef MAGNUM_TARGET_GLES2
     #ifndef MAGNUM_TARGET_WEBGL
-    if(PixelStorageData[testCaseInstanceId()].storage != PixelStorage{} && !Context::current().isExtensionSupported<Extensions::EXT::unpack_subimage>())
+    if(data.storage != PixelStorage{} && !Context::current().isExtensionSupported<Extensions::EXT::unpack_subimage>())
         CORRADE_SKIP(Extensions::EXT::unpack_subimage::string() << "is not supported.");
     #else
-    if(PixelStorageData[testCaseInstanceId()].storage != PixelStorage{})
+    if(data.storage != PixelStorage{})
         CORRADE_SKIP("Image unpack is not supported in WebGL 1.");
     #endif
     #endif
@@ -909,19 +911,19 @@ void CubeMapTextureGLTest::image() {
     #endif
 
     CubeMapTexture texture;
-    texture.setImage(CubeMapCoordinate::PositiveX, 0, format, ImageView2D{PixelStorageData[testCaseInstanceId()].storage,
+    texture.setImage(CubeMapCoordinate::PositiveX, 0, format, ImageView2D{data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2),
-        PixelStorageData[testCaseInstanceId()].dataSparse});
+        data.dataSparse});
     texture.setImage(CubeMapCoordinate::NegativeX, 0, format,
         ImageView2D{PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), Zero});
-    texture.setImage(CubeMapCoordinate::PositiveY, 0, format, ImageView2D{PixelStorageData[testCaseInstanceId()].storage,
+    texture.setImage(CubeMapCoordinate::PositiveY, 0, format, ImageView2D{data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2),
-        PixelStorageData[testCaseInstanceId()].dataSparse});
+        data.dataSparse});
     texture.setImage(CubeMapCoordinate::NegativeY, 0, format,
         ImageView2D{PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), Zero});
-    texture.setImage(CubeMapCoordinate::PositiveZ, 0, format, ImageView2D{PixelStorageData[testCaseInstanceId()].storage,
+    texture.setImage(CubeMapCoordinate::PositiveZ, 0, format, ImageView2D{data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2),
-        PixelStorageData[testCaseInstanceId()].dataSparse});
+        data.dataSparse});
     texture.setImage(CubeMapCoordinate::NegativeZ, 0, format,
         ImageView2D{PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), Zero});
 
@@ -931,39 +933,39 @@ void CubeMapTextureGLTest::image() {
     #ifndef MAGNUM_TARGET_GLES
     {
         Image2D image = texture.image(CubeMapCoordinate::PositiveX, 0,
-            {PixelStorageData[testCaseInstanceId()].storage,
+            {data.storage,
             PixelFormat::RGBA, PixelType::UnsignedByte});
 
         MAGNUM_VERIFY_NO_GL_ERROR();
 
         CORRADE_COMPARE(image.flags(), ImageFlags2D{});
         CORRADE_COMPARE(image.size(), Vector2i(2));
-        CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset),
-            PixelStorageData[testCaseInstanceId()].data,
+        CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+            data.data,
             TestSuite::Compare::Container);
     } {
         Image2D image = texture.image(CubeMapCoordinate::PositiveY, 0,
-            {PixelStorageData[testCaseInstanceId()].storage,
+            {data.storage,
             PixelFormat::RGBA, PixelType::UnsignedByte});
 
         MAGNUM_VERIFY_NO_GL_ERROR();
 
         CORRADE_COMPARE(image.flags(), ImageFlags2D{});
         CORRADE_COMPARE(image.size(), Vector2i(2));
-        CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset),
-            PixelStorageData[testCaseInstanceId()].data,
+        CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+            data.data,
             TestSuite::Compare::Container);
     } {
         Image2D image = texture.image(CubeMapCoordinate::PositiveZ, 0,
-            {PixelStorageData[testCaseInstanceId()].storage,
+            {data.storage,
             PixelFormat::RGBA, PixelType::UnsignedByte});
 
         MAGNUM_VERIFY_NO_GL_ERROR();
 
         CORRADE_COMPARE(image.flags(), ImageFlags2D{});
         CORRADE_COMPARE(image.size(), Vector2i(2));
-        CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset),
-            PixelStorageData[testCaseInstanceId()].data,
+        CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+            data.data,
             TestSuite::Compare::Container);
     }
     #endif
@@ -971,13 +973,14 @@ void CubeMapTextureGLTest::image() {
 
 #ifndef MAGNUM_TARGET_GLES2
 void CubeMapTextureGLTest::imageBuffer() {
-    setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name);
+    auto&& data = PixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     CubeMapTexture texture;
     texture.setImage(CubeMapCoordinate::PositiveX, 0, TextureFormat::RGBA8,
-        BufferImage2D{PixelStorageData[testCaseInstanceId()].storage,
+        BufferImage2D{data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2),
-        PixelStorageData[testCaseInstanceId()].dataSparse,
+        data.dataSparse,
         BufferUsage::StaticDraw});
     texture.setImage(CubeMapCoordinate::NegativeX, 0, TextureFormat::RGBA8,
         ImageView2D{PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), Zero});
@@ -995,14 +998,14 @@ void CubeMapTextureGLTest::imageBuffer() {
     /** @todo How to test this on ES? */
     #ifndef MAGNUM_TARGET_GLES
     BufferImage2D image = texture.image(CubeMapCoordinate::PositiveX, 0,
-        {PixelStorageData[testCaseInstanceId()].storage, PixelFormat::RGBA, PixelType::UnsignedByte}, BufferUsage::StaticRead);
+        {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}, BufferUsage::StaticRead);
     const auto imageData = image.buffer().data();
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.size(), Vector2i(2));
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset),
-        PixelStorageData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
     #endif
 }
@@ -1010,20 +1013,21 @@ void CubeMapTextureGLTest::imageBuffer() {
 
 #ifndef MAGNUM_TARGET_GLES
 void CubeMapTextureGLTest::imageQueryView() {
-    setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name);
+    auto&& data = PixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     CubeMapTexture texture;
     texture.setStorage(1, TextureFormat::RGBA8, Vector2i{2})
         .setSubImage(CubeMapCoordinate::PositiveY, 0, {},
-        ImageView2D{PixelStorageData[testCaseInstanceId()].storage,
+        ImageView2D{data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2),
-        PixelStorageData[testCaseInstanceId()].dataSparse});
+        data.dataSparse});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> data{PixelStorageData[testCaseInstanceId()].offset + 2*2*4};
-    MutableImageView2D image{PixelStorageData[testCaseInstanceId()].storage,
-            PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, data, ImageFlag2D::Array};
+    Containers::Array<char> imageData{data.offset + 2*2*4};
+    MutableImageView2D image{data.storage,
+            PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, imageData, ImageFlag2D::Array};
     texture.image(CubeMapCoordinate::PositiveY, 0, image);
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -1031,8 +1035,8 @@ void CubeMapTextureGLTest::imageQueryView() {
     /* Doesn't matter what flags are set, they stay untouched */
     CORRADE_COMPARE(image.flags(), ImageFlag2D::Array);
     CORRADE_COMPARE(image.size(), Vector2i(2));
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset),
-        PixelStorageData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 
@@ -1082,14 +1086,15 @@ constexpr UnsignedByte SubDataComplete[]{
 #endif
 
 void CubeMapTextureGLTest::subImage() {
-    setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name);
+    auto&& data = PixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     #ifdef MAGNUM_TARGET_GLES2
     #ifndef MAGNUM_TARGET_WEBGL
-    if(PixelStorageData[testCaseInstanceId()].storage != PixelStorage{} && !Context::current().isExtensionSupported<Extensions::EXT::unpack_subimage>())
+    if(data.storage != PixelStorage{} && !Context::current().isExtensionSupported<Extensions::EXT::unpack_subimage>())
         CORRADE_SKIP(Extensions::EXT::unpack_subimage::string() << "is not supported.");
     #else
-    if(PixelStorageData[testCaseInstanceId()].storage != PixelStorage{})
+    if(data.storage != PixelStorage{})
         CORRADE_SKIP("Image unpack is not supported in WebGL 1.");
     #endif
     #endif
@@ -1114,9 +1119,9 @@ void CubeMapTextureGLTest::subImage() {
     texture.setImage(CubeMapCoordinate::NegativeZ, 0, format,
         ImageView2D(PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(4), Zero));
     texture.setSubImage(CubeMapCoordinate::PositiveX, 0, Vector2i(1), ImageView2D{
-        PixelStorageData[testCaseInstanceId()].storage,
+        data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2),
-        PixelStorageData[testCaseInstanceId()].dataSparse});
+        data.dataSparse});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
@@ -1134,7 +1139,8 @@ void CubeMapTextureGLTest::subImage() {
 
 #ifndef MAGNUM_TARGET_GLES2
 void CubeMapTextureGLTest::subImageBuffer() {
-    setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name);
+    auto&& data = PixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     CubeMapTexture texture;
     texture.setImage(CubeMapCoordinate::PositiveX, 0, TextureFormat::RGBA8,
@@ -1150,9 +1156,9 @@ void CubeMapTextureGLTest::subImageBuffer() {
     texture.setImage(CubeMapCoordinate::NegativeZ, 0, TextureFormat::RGBA8,
         ImageView2D(PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(4), Zero));
     texture.setSubImage(CubeMapCoordinate::PositiveX, 0, Vector2i(1), BufferImage2D{
-        PixelStorageData[testCaseInstanceId()].storage,
+        data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2),
-        PixelStorageData[testCaseInstanceId()].dataSparse,
+        data.dataSparse,
         BufferUsage::StaticDraw});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -1174,7 +1180,8 @@ void CubeMapTextureGLTest::subImageBuffer() {
 
 #ifndef MAGNUM_TARGET_GLES
 void CubeMapTextureGLTest::subImageQuery() {
-    setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name);
+    auto&& data = PixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
         CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
@@ -1186,20 +1193,21 @@ void CubeMapTextureGLTest::subImageQuery() {
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     Image3D image = texture.subImage(0, Range3Di::fromSize({1, 1, 0}, {2, 2, 1}),
-        {PixelStorageData[testCaseInstanceId()].storage,
+        {data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.flags(), ImageFlag3D::Array);
     CORRADE_COMPARE(image.size(), Vector3i(2, 2, 1));
-    CORRADE_COMPARE_AS(Containers::arrayCast<const UnsignedByte>(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset),
-        PixelStorageData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<const UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 
 void CubeMapTextureGLTest::subImageQueryView() {
-    setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name);
+    auto&& data = PixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
         CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
@@ -1210,9 +1218,9 @@ void CubeMapTextureGLTest::subImageQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> data{PixelStorageData[testCaseInstanceId()].offset + 2*2*4};
-    MutableImageView3D image{PixelStorageData[testCaseInstanceId()].storage,
-        PixelFormat::RGBA, PixelType::UnsignedByte, {2, 2, 1}, data, ImageFlag3D::Array};
+    Containers::Array<char> imageData{data.offset + 2*2*4};
+    MutableImageView3D image{data.storage,
+        PixelFormat::RGBA, PixelType::UnsignedByte, {2, 2, 1}, imageData, ImageFlag3D::Array};
     texture.subImage(0, Range3Di::fromSize({1, 1, 0}, {2, 2, 1}), image);
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -1220,13 +1228,14 @@ void CubeMapTextureGLTest::subImageQueryView() {
     /* Doesn't matter what flags are set, they stay untouched */
     CORRADE_COMPARE(image.flags(), ImageFlag3D::Array);
     CORRADE_COMPARE(image.size(), Vector3i(2, 2, 1));
-    CORRADE_COMPARE_AS(Containers::arrayCast<const UnsignedByte>(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset),
-        PixelStorageData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<const UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 
 void CubeMapTextureGLTest::subImageQueryBuffer() {
-    setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name);
+    auto&& data = PixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
         CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
@@ -1238,21 +1247,22 @@ void CubeMapTextureGLTest::subImageQueryBuffer() {
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     BufferImage3D image = texture.subImage(0, Range3Di::fromSize({1, 1, 0}, {2, 2, 1}),
-        {PixelStorageData[testCaseInstanceId()].storage,
+        {data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte}, BufferUsage::StaticRead);
     const auto imageData = image.buffer().data();
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.size(), Vector3i(2, 2, 1));
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset),
-        PixelStorageData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 #endif
 
 void CubeMapTextureGLTest::compressedImage() {
-    setTestCaseDescription(CompressedPixelStorageData[testCaseInstanceId()].name);
+    auto&& data = CompressedPixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
@@ -1266,16 +1276,16 @@ void CubeMapTextureGLTest::compressedImage() {
     #endif
 
     #ifndef MAGNUM_TARGET_GLES
-    if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #endif
 
     const CompressedImageView2D view{
         #ifndef MAGNUM_TARGET_GLES
-        CompressedPixelStorageData[testCaseInstanceId()].storage,
+        data.storage,
         #endif
         CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{4},
-        CompressedPixelStorageData[testCaseInstanceId()].dataSparse};
+        data.dataSparse};
 
     CubeMapTexture texture;
     texture.setCompressedImage(CubeMapCoordinate::PositiveX, 0, view)
@@ -1288,21 +1298,22 @@ void CubeMapTextureGLTest::compressedImage() {
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     #ifndef MAGNUM_TARGET_GLES
-    CompressedImage2D image = texture.compressedImage(CubeMapCoordinate::PositiveX, 0, {CompressedPixelStorageData[testCaseInstanceId()].storage});
+    CompressedImage2D image = texture.compressedImage(CubeMapCoordinate::PositiveX, 0, {data.storage});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.flags(), ImageFlags2D{});
     CORRADE_COMPARE(image.size(), Vector2i{4});
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(CompressedPixelStorageData[testCaseInstanceId()].offset),
-        CompressedPixelStorageData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
     #endif
 }
 
 #ifndef MAGNUM_TARGET_GLES2
 void CubeMapTextureGLTest::compressedImageBuffer() {
-    setTestCaseDescription(CompressedPixelStorageData[testCaseInstanceId()].name);
+    auto&& data = CompressedPixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
@@ -1316,16 +1327,16 @@ void CubeMapTextureGLTest::compressedImageBuffer() {
     #endif
 
     #ifndef MAGNUM_TARGET_GLES
-    if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #endif
 
     CompressedBufferImage2D buffer{
         #ifndef MAGNUM_TARGET_GLES
-        CompressedPixelStorageData[testCaseInstanceId()].storage,
+        data.storage,
         #endif
         CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{4},
-        CompressedPixelStorageData[testCaseInstanceId()].dataSparse,
+        data.dataSparse,
         BufferUsage::StaticDraw};
 
     CubeMapTexture texture;
@@ -1340,14 +1351,14 @@ void CubeMapTextureGLTest::compressedImageBuffer() {
 
     #ifndef MAGNUM_TARGET_GLES
     CompressedBufferImage2D image = texture.compressedImage(CubeMapCoordinate::PositiveX, 0,
-        {CompressedPixelStorageData[testCaseInstanceId()].storage}, BufferUsage::StaticRead);
+        {data.storage}, BufferUsage::StaticRead);
     const auto imageData = image.buffer().data();
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.size(), Vector2i{4});
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(CompressedPixelStorageData[testCaseInstanceId()].offset),
-        CompressedPixelStorageData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
     #endif
 }
@@ -1355,18 +1366,19 @@ void CubeMapTextureGLTest::compressedImageBuffer() {
 
 #ifndef MAGNUM_TARGET_GLES
 void CubeMapTextureGLTest::compressedImageQueryView() {
-    setTestCaseDescription(CompressedPixelStorageData[testCaseInstanceId()].name);
+    auto&& data = CompressedPixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
         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>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
 
     const CompressedImageView2D view{
-        CompressedPixelStorageData[testCaseInstanceId()].storage,
+        data.storage,
         CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{4},
-        CompressedPixelStorageData[testCaseInstanceId()].dataSparse};
+        data.dataSparse};
 
     CubeMapTexture texture;
     texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, Vector2i{4})
@@ -1374,8 +1386,8 @@ void CubeMapTextureGLTest::compressedImageQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> data{CompressedPixelStorageData[testCaseInstanceId()].offset + 16};
-    MutableCompressedImageView2D image{CompressedPixelStorageData[testCaseInstanceId()].storage, CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{4}, data, ImageFlag2D::Array};
+    Containers::Array<char> imageData{data.offset + 16};
+    MutableCompressedImageView2D image{data.storage, CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{4}, imageData, ImageFlag2D::Array};
     texture.compressedImage(CubeMapCoordinate::PositiveZ, 0, image);
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -1383,8 +1395,8 @@ void CubeMapTextureGLTest::compressedImageQueryView() {
     /* Doesn't matter what flags are set, they stay untouched */
     CORRADE_COMPARE(image.flags(), ImageFlag2D::Array);
     CORRADE_COMPARE(image.size(), Vector2i{4});
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(CompressedPixelStorageData[testCaseInstanceId()].offset),
-        CompressedPixelStorageData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 
@@ -1470,7 +1482,8 @@ void CubeMapTextureGLTest::compressedImageQueryViewBadFormat() {
 
 #if !(defined(MAGNUM_TARGET_GLES2) && defined(MAGNUM_TARGET_WEBGL))
 void CubeMapTextureGLTest::immutableCompressedImage() {
-    setTestCaseDescription(CompressedPixelStorageData[testCaseInstanceId()].name);
+    auto&& data = CompressedPixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_storage>())
@@ -1491,7 +1504,7 @@ void CubeMapTextureGLTest::immutableCompressedImage() {
     #endif
 
     #ifndef MAGNUM_TARGET_GLES
-    if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #endif
 
@@ -1504,10 +1517,10 @@ void CubeMapTextureGLTest::immutableCompressedImage() {
 
     const CompressedImageView2D view{
         #ifndef MAGNUM_TARGET_GLES
-        CompressedPixelStorageData[testCaseInstanceId()].storage,
+        data.storage,
         #endif
         CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{4},
-        CompressedPixelStorageData[testCaseInstanceId()].dataSparse};
+        data.dataSparse};
 
     CubeMapTexture texture;
     texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, Vector2i{4})
@@ -1521,13 +1534,13 @@ void CubeMapTextureGLTest::immutableCompressedImage() {
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     #ifndef MAGNUM_TARGET_GLES
-    CompressedImage2D image = texture.compressedImage(CubeMapCoordinate::NegativeY, 0, {CompressedPixelStorageData[testCaseInstanceId()].storage});
+    CompressedImage2D image = texture.compressedImage(CubeMapCoordinate::NegativeY, 0, {data.storage});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.size(), Vector2i{4});
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(CompressedPixelStorageData[testCaseInstanceId()].offset),
-        CompressedPixelStorageData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
     #endif
 }
@@ -1563,7 +1576,8 @@ constexpr UnsignedByte CompressedSubDataComplete[]{
 #endif
 
 void CubeMapTextureGLTest::compressedSubImage() {
-    setTestCaseDescription(CompressedPixelStorageData[testCaseInstanceId()].name);
+    auto&& data = CompressedPixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
@@ -1577,7 +1591,7 @@ void CubeMapTextureGLTest::compressedSubImage() {
     #endif
 
     #ifndef MAGNUM_TARGET_GLES
-    if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #endif
 
@@ -1596,10 +1610,10 @@ void CubeMapTextureGLTest::compressedSubImage() {
         CompressedImageView2D{CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{12}, CompressedZero});
     texture.setCompressedSubImage(CubeMapCoordinate::PositiveX, 0, Vector2i{4}, CompressedImageView2D{
         #ifndef MAGNUM_TARGET_GLES
-        CompressedPixelStorageData[testCaseInstanceId()].storage,
+        data.storage,
         #endif
         CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{4},
-        CompressedPixelStorageData[testCaseInstanceId()].dataSparse});
+        data.dataSparse});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
@@ -1611,7 +1625,7 @@ void CubeMapTextureGLTest::compressedSubImage() {
     CORRADE_COMPARE(image.size(), Vector2i{12});
 
     {
-        CORRADE_EXPECT_FAIL_IF(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && Context::current().isExtensionSupported<Extensions::ARB::direct_state_access>() && (Context::current().detectedDriver() & Context::DetectedDriver::NVidia),
+        CORRADE_EXPECT_FAIL_IF(data.storage != CompressedPixelStorage{} && Context::current().isExtensionSupported<Extensions::ARB::direct_state_access>() && (Context::current().detectedDriver() & Context::DetectedDriver::NVidia),
             "Non-default compressed pixel storage for cube map textures behaves weirdly on NVidia for client-memory images when using ARB_direct_state_access");
 
         CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()),
@@ -1623,7 +1637,8 @@ void CubeMapTextureGLTest::compressedSubImage() {
 
 #ifndef MAGNUM_TARGET_GLES2
 void CubeMapTextureGLTest::compressedSubImageBuffer() {
-    setTestCaseDescription(CompressedPixelStorageData[testCaseInstanceId()].name);
+    auto&& data = CompressedPixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
@@ -1637,7 +1652,7 @@ void CubeMapTextureGLTest::compressedSubImageBuffer() {
     #endif
 
     #ifndef MAGNUM_TARGET_GLES
-    if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #endif
 
@@ -1656,10 +1671,10 @@ void CubeMapTextureGLTest::compressedSubImageBuffer() {
         CompressedImageView2D{CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{12}, CompressedZero});
     texture.setCompressedSubImage(CubeMapCoordinate::PositiveX, 0, Vector2i{4}, CompressedBufferImage2D{
         #ifndef MAGNUM_TARGET_GLES
-        CompressedPixelStorageData[testCaseInstanceId()].storage,
+        data.storage,
         #endif
         CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{4},
-        CompressedPixelStorageData[testCaseInstanceId()].dataSparse,
+        data.dataSparse,
         BufferUsage::StaticDraw});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -1681,15 +1696,16 @@ void CubeMapTextureGLTest::compressedSubImageBuffer() {
 
 #ifndef MAGNUM_TARGET_GLES
 void CubeMapTextureGLTest::compressedSubImageQuery() {
-    setTestCaseDescription(CompressedPixelStorageData[testCaseInstanceId()].name);
+    auto&& data = CompressedPixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
         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() << "is not supported.");
-    if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
-    if(CompressedPixelStorageData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
+    if(data.storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
         CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported.");
 
     CubeMapTexture texture;
@@ -1698,26 +1714,27 @@ void CubeMapTextureGLTest::compressedSubImageQuery() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    CompressedImage3D image = texture.compressedSubImage(0, Range3Di::fromSize({4, 4, 0}, {4, 4, 1}), {CompressedPixelStorageData[testCaseInstanceId()].storage});
+    CompressedImage3D image = texture.compressedSubImage(0, Range3Di::fromSize({4, 4, 0}, {4, 4, 1}), {data.storage});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.size(), (Vector3i{4, 4, 1}));
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(CompressedPixelStorageData[testCaseInstanceId()].offset),
-        CompressedPixelStorageData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 
 void CubeMapTextureGLTest::compressedSubImageQueryView() {
-    setTestCaseDescription(CompressedPixelStorageData[testCaseInstanceId()].name);
+    auto&& data = CompressedPixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
         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() << "is not supported.");
-    if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
-    if(CompressedPixelStorageData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
+    if(data.storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
         CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported.");
 
     CubeMapTexture texture;
@@ -1726,8 +1743,8 @@ void CubeMapTextureGLTest::compressedSubImageQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> data{CompressedPixelStorageData[testCaseInstanceId()].offset + 16};
-    MutableCompressedImageView3D image{CompressedPixelStorageData[testCaseInstanceId()].storage, CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 1}, data, ImageFlag3D::Array};
+    Containers::Array<char> imageData{data.offset + 16};
+    MutableCompressedImageView3D image{data.storage, CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 1}, imageData, ImageFlag3D::Array};
     texture.compressedSubImage(0, Range3Di::fromSize({4, 4, 0}, {4, 4, 1}), image);
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -1735,8 +1752,8 @@ void CubeMapTextureGLTest::compressedSubImageQueryView() {
     /* Doesn't matter what flags are set, they stay untouched */
     CORRADE_COMPARE(image.flags(), ImageFlag3D::Array);
     CORRADE_COMPARE(image.size(), (Vector3i{4, 4, 1}));
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(CompressedPixelStorageData[testCaseInstanceId()].offset),
-        CompressedPixelStorageData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 
@@ -1820,15 +1837,16 @@ void CubeMapTextureGLTest::compressedSubImageQueryViewBadFormat() {
 }
 
 void CubeMapTextureGLTest::compressedSubImageQueryBuffer() {
-    setTestCaseDescription(CompressedPixelStorageData[testCaseInstanceId()].name);
+    auto&& data = CompressedPixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
         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() << "is not supported.");
-    if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
-    if(CompressedPixelStorageData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
+    if(data.storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
         CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported.");
 
     CubeMapTexture texture;
@@ -1837,21 +1855,22 @@ void CubeMapTextureGLTest::compressedSubImageQueryBuffer() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    CompressedBufferImage3D image = texture.compressedSubImage(0, Range3Di::fromSize({4, 4, 0}, {4, 4, 1}), {CompressedPixelStorageData[testCaseInstanceId()].storage}, BufferUsage::StaticRead);
+    CompressedBufferImage3D image = texture.compressedSubImage(0, Range3Di::fromSize({4, 4, 0}, {4, 4, 1}), {data.storage}, BufferUsage::StaticRead);
     const auto imageData = image.buffer().data();
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.size(), (Vector3i{4, 4, 1}));
     CORRADE_COMPARE_AS(
-        Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(CompressedPixelStorageData[testCaseInstanceId()].offset),
-        CompressedPixelStorageData[testCaseInstanceId()].data,
+        Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 #endif
 
 void CubeMapTextureGLTest::image3D() {
-    setTestCaseDescription(FullPixelStorageData[testCaseInstanceId()].name);
+    auto&& data = FullPixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     #if !(defined(MAGNUM_TARGET_GLES2) && defined(MAGNUM_TARGET_WEBGL))
     constexpr TextureFormat format = TextureFormat::RGBA8;
@@ -1863,23 +1882,23 @@ void CubeMapTextureGLTest::image3D() {
     texture.setStorage(1, format, Vector2i{2, 2})
         .setSubImage(0, {}, ImageView3D{
             PixelFormat::RGBA, PixelType::UnsignedByte, {2, 2, 6},
-            FullPixelStorageData[testCaseInstanceId()].data});
+            data.data});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     #ifndef MAGNUM_TARGET_GLES
     Image3D image = texture.image(0,
-        {FullPixelStorageData[testCaseInstanceId()].storage, PixelFormat::RGBA, PixelType::UnsignedByte});
+        {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.flags(), ImageFlag3D::CubeMap);
     CORRADE_COMPARE(image.size(), Vector3i(2, 2, 6));
     {
-        CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa) && FullPixelStorageData[testCaseInstanceId()].storage != PixelStorage{},
+        CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa) && data.storage != PixelStorage{},
             "Mesa drivers can't handle non-default pixel storage for full cubemap image queries.");
-        CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(FullPixelStorageData[testCaseInstanceId()].offset),
-            FullPixelStorageData[testCaseInstanceId()].data,
+        CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+            data.data,
             TestSuite::Compare::Container);
     }
     #endif
@@ -1887,20 +1906,21 @@ void CubeMapTextureGLTest::image3D() {
 
 #ifndef MAGNUM_TARGET_GLES2
 void CubeMapTextureGLTest::image3DBuffer() {
-    setTestCaseDescription(FullPixelStorageData[testCaseInstanceId()].name);
+    auto&& data = FullPixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     CubeMapTexture texture;
     texture.setStorage(1, TextureFormat::RGBA8, Vector2i{2})
         .setSubImage(0, {}, BufferImage3D{
             PixelFormat::RGBA, PixelType::UnsignedByte, {2, 2, 6},
-            FullPixelStorageData[testCaseInstanceId()].data,
+            data.data,
             BufferUsage::StaticDraw});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     #ifndef MAGNUM_TARGET_GLES
     BufferImage3D image = texture.image(0,
-        {FullPixelStorageData[testCaseInstanceId()].storage, PixelFormat::RGBA,
+        {data.storage, PixelFormat::RGBA,
             PixelType::UnsignedByte}, BufferUsage::StaticRead);
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -1908,10 +1928,10 @@ void CubeMapTextureGLTest::image3DBuffer() {
     CORRADE_COMPARE(image.size(), Vector3i(2, 2, 6));
     const auto imageData = image.buffer().data();
     {
-        CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa) && FullPixelStorageData[testCaseInstanceId()].storage != PixelStorage{},
+        CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa) && data.storage != PixelStorage{},
             "Mesa drivers can't handle non-default pixel storage for full cubemap image queries.");
-        CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(FullPixelStorageData[testCaseInstanceId()].offset),
-            FullPixelStorageData[testCaseInstanceId()].data, TestSuite::Compare::Container);
+        CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(data.offset),
+            data.data, TestSuite::Compare::Container);
     }
     #endif
 }
@@ -1919,18 +1939,19 @@ void CubeMapTextureGLTest::image3DBuffer() {
 
 #ifndef MAGNUM_TARGET_GLES
 void CubeMapTextureGLTest::image3DQueryView() {
-    setTestCaseDescription(FullPixelStorageData[testCaseInstanceId()].name);
+    auto&& data = FullPixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     CubeMapTexture texture;
     texture.setStorage(1, TextureFormat::RGBA8, Vector2i{2, 2})
         .setSubImage(0, {}, ImageView3D{
             PixelFormat::RGBA, PixelType::UnsignedByte, {2, 2, 6},
-            FullPixelStorageData[testCaseInstanceId()].data});
+            data.data});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> data{FullPixelStorageData[testCaseInstanceId()].offset + 2*2*6*4};
-    MutableImageView3D image{FullPixelStorageData[testCaseInstanceId()].storage, PixelFormat::RGBA, PixelType::UnsignedByte, {2, 2, 6}, data, ImageFlag3D::Array};
+    Containers::Array<char> imageData{data.offset + 2*2*6*4};
+    MutableImageView3D image{data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, {2, 2, 6}, imageData, ImageFlag3D::Array};
     texture.image(0, image);
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -1939,10 +1960,10 @@ void CubeMapTextureGLTest::image3DQueryView() {
     CORRADE_COMPARE(image.flags(), ImageFlag3D::Array);
     CORRADE_COMPARE(image.size(), Vector3i(2, 2, 6));
     {
-        CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa) && FullPixelStorageData[testCaseInstanceId()].storage != PixelStorage{},
+        CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa) && data.storage != PixelStorage{},
             "Mesa drivers can't handle non-default pixel storage for full cubemap image queries.");
-        CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(FullPixelStorageData[testCaseInstanceId()].offset),
-            FullPixelStorageData[testCaseInstanceId()].data,
+        CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+            data.data,
             TestSuite::Compare::Container);
     }
 }
@@ -1985,20 +2006,21 @@ void CubeMapTextureGLTest::image3DQueryViewBadSize() {
 
 #ifndef MAGNUM_TARGET_GLES
 void CubeMapTextureGLTest::compressedImage3D() {
-    setTestCaseDescription(CompressedFullPixelStorageData[testCaseInstanceId()].name);
+    auto&& data = CompressedFullPixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::direct_state_access>())
         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() << "is not supported.");
-    if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
 
     CubeMapTexture texture;
     texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, Vector2i{4})
         .setCompressedSubImage(0, {}, CompressedImageView3D{
             CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 6},
-            CompressedFullPixelStorageData[testCaseInstanceId()].data});
+            data.data});
 
     {
         bool fails(Context::current().detectedDriver() & Context::DetectedDriver::Amd);
@@ -2009,7 +2031,7 @@ void CubeMapTextureGLTest::compressedImage3D() {
         if(fails) CORRADE_SKIP("Skipping the rest of the test");
     }
 
-    CompressedImage3D image = texture.compressedImage(0, {CompressedFullPixelStorageData[testCaseInstanceId()].storage});
+    CompressedImage3D image = texture.compressedImage(0, {data.storage});
 
     {
         #ifdef CORRADE_TARGET_WINDOWS
@@ -2027,29 +2049,30 @@ void CubeMapTextureGLTest::compressedImage3D() {
     CORRADE_COMPARE(image.flags(), ImageFlag3D::CubeMap);
     CORRADE_COMPARE(image.size(), (Vector3i{4, 4, 6}));
     {
-        CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa) && CompressedFullPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{},
+        CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa) && data.storage != CompressedPixelStorage{},
             "Mesa drivers can't handle non-default pixel storage for full cubemap image queries.");
-        CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(CompressedFullPixelStorageData[testCaseInstanceId()].offset),
-            CompressedFullPixelStorageData[testCaseInstanceId()].data,
+        CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+            data.data,
             TestSuite::Compare::Container);
     }
 }
 
 void CubeMapTextureGLTest::compressedImage3DBuffer() {
-    setTestCaseDescription(CompressedFullPixelStorageData[testCaseInstanceId()].name);
+    auto&& data = CompressedFullPixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::direct_state_access>())
         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() << "is not supported.");
-    if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
 
     CubeMapTexture texture;
     texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, Vector2i{4})
         .setCompressedSubImage(0, {}, CompressedBufferImage3D{
             CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 6},
-            CompressedFullPixelStorageData[testCaseInstanceId()].data,
+            data.data,
             BufferUsage::StaticDraw});
 
     {
@@ -2061,7 +2084,7 @@ void CubeMapTextureGLTest::compressedImage3DBuffer() {
         if(fails) CORRADE_SKIP("Skipping the rest of the test");
     }
 
-    CompressedBufferImage3D image = texture.compressedImage(0, {CompressedFullPixelStorageData[testCaseInstanceId()].storage}, BufferUsage::StaticRead);
+    CompressedBufferImage3D image = texture.compressedImage(0, {data.storage}, BufferUsage::StaticRead);
 
     {
         #ifdef CORRADE_TARGET_WINDOWS
@@ -2079,29 +2102,30 @@ void CubeMapTextureGLTest::compressedImage3DBuffer() {
     CORRADE_COMPARE(image.size(), (Vector3i{4, 4, 6}));
     const auto imageData = image.buffer().data();
     {
-        CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa) && CompressedFullPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{},
+        CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa) && data.storage != CompressedPixelStorage{},
             "Mesa drivers can't handle non-default pixel storage for full cubemap image queries.");
-        CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(CompressedFullPixelStorageData[testCaseInstanceId()].offset),
-            CompressedFullPixelStorageData[testCaseInstanceId()].data,
+        CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(data.offset),
+            data.data,
             TestSuite::Compare::Container);
     }
 }
 
 void CubeMapTextureGLTest::compressedImage3DQueryView() {
-    setTestCaseDescription(CompressedFullPixelStorageData[testCaseInstanceId()].name);
+    auto&& data = CompressedFullPixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::direct_state_access>())
         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() << "is not supported.");
-    if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
 
     CubeMapTexture texture;
     texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, Vector2i{4})
         .setCompressedSubImage(0, {}, CompressedImageView3D{
             CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 6},
-            CompressedFullPixelStorageData[testCaseInstanceId()].data});
+            data.data});
 
     {
         bool fails(Context::current().detectedDriver() & Context::DetectedDriver::Amd);
@@ -2112,8 +2136,8 @@ void CubeMapTextureGLTest::compressedImage3DQueryView() {
         if(fails) CORRADE_SKIP("Skipping the rest of the test");
     }
 
-    Containers::Array<char> data{CompressedFullPixelStorageData[testCaseInstanceId()].offset + 16*6};
-    MutableCompressedImageView3D image{CompressedFullPixelStorageData[testCaseInstanceId()].storage, CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 6}, data, ImageFlag3D::Array};
+    Containers::Array<char> imageData{data.offset + 16*6};
+    MutableCompressedImageView3D image{data.storage, CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 6}, imageData, ImageFlag3D::Array};
     texture.compressedImage(0, image);
 
     {
@@ -2133,10 +2157,10 @@ void CubeMapTextureGLTest::compressedImage3DQueryView() {
     CORRADE_COMPARE(image.flags(), ImageFlag3D::Array);
     CORRADE_COMPARE(image.size(), (Vector3i{4, 4, 6}));
     {
-        CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa) && CompressedFullPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{},
+        CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa) && data.storage != CompressedPixelStorage{},
             "Mesa drivers can't handle non-default pixel storage for full cubemap image queries.");
-        CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(CompressedFullPixelStorageData[testCaseInstanceId()].offset),
-            CompressedFullPixelStorageData[testCaseInstanceId()].data,
+        CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+            data.data,
             TestSuite::Compare::Container);
     }
 }
diff --git a/src/Magnum/GL/Test/RectangleTextureGLTest.cpp b/src/Magnum/GL/Test/RectangleTextureGLTest.cpp
index d00c168e2..6764d5a1d 100644
--- a/src/Magnum/GL/Test/RectangleTextureGLTest.cpp
+++ b/src/Magnum/GL/Test/RectangleTextureGLTest.cpp
@@ -374,74 +374,77 @@ void RectangleTextureGLTest::view() {
 }
 
 void RectangleTextureGLTest::image() {
-    setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name);
+    auto&& data = PixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_rectangle>())
         CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() << "is not supported.");
 
     RectangleTexture texture;
     texture.setImage(TextureFormat::RGBA8, ImageView2D{
-        PixelStorageData[testCaseInstanceId()].storage,
+        data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2),
-        PixelStorageData[testCaseInstanceId()].dataSparse});
+        data.dataSparse});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Image2D image = texture.image({PixelStorageData[testCaseInstanceId()].storage,
+    Image2D image = texture.image({data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.flags(), ImageFlag2D{});
     CORRADE_COMPARE(image.size(), Vector2i(2));
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset),
-        PixelStorageData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 
 void RectangleTextureGLTest::imageBuffer() {
-    setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name);
+    auto&& data = PixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_rectangle>())
         CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() << "is not supported.");
 
     RectangleTexture texture;
     texture.setImage(TextureFormat::RGBA8, BufferImage2D{
-        PixelStorageData[testCaseInstanceId()].storage,
+        data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2),
-        PixelStorageData[testCaseInstanceId()].dataSparse,
+        data.dataSparse,
         BufferUsage::StaticDraw});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    BufferImage2D image = texture.image({PixelStorageData[testCaseInstanceId()].storage,
+    BufferImage2D image = texture.image({data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte}, BufferUsage::StaticRead);
     const auto imageData = image.buffer().data();
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.size(), Vector2i(2));
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset),
-        PixelStorageData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 
 void RectangleTextureGLTest::imageQueryView() {
-    setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name);
+    auto&& data = PixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_rectangle>())
         CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() << "is not supported.");
 
     RectangleTexture texture;
     texture.setImage(TextureFormat::RGBA8, ImageView2D{
-        PixelStorageData[testCaseInstanceId()].storage,
+        data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2),
-        PixelStorageData[testCaseInstanceId()].dataSparse});
+        data.dataSparse});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> data{PixelStorageData[testCaseInstanceId()].offset + 2*2*4};
-    MutableImageView2D image{PixelStorageData[testCaseInstanceId()].storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, data, ImageFlag2D::Array};
+    Containers::Array<char> imageData{data.offset + 2*2*4};
+    MutableImageView2D image{data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, imageData, ImageFlag2D::Array};
     texture.image(image);
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -449,8 +452,8 @@ void RectangleTextureGLTest::imageQueryView() {
     /* Doesn't matter what flags are set, they stay untouched */
     CORRADE_COMPARE(image.flags(), ImageFlag2D::Array);
     CORRADE_COMPARE(image.size(), Vector2i(2));
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset),
-        PixelStorageData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 
@@ -463,7 +466,8 @@ constexpr UnsignedByte SubDataComplete[]{
 };
 
 void RectangleTextureGLTest::subImage() {
-    setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name);
+    auto&& data = PixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_rectangle>())
         CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() << "is not supported.");
@@ -472,9 +476,9 @@ void RectangleTextureGLTest::subImage() {
     texture.setImage(TextureFormat::RGBA8,
         ImageView2D(PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(4), Zero));
     texture.setSubImage(Vector2i(1), ImageView2D{
-        PixelStorageData[testCaseInstanceId()].storage,
+        data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2),
-        PixelStorageData[testCaseInstanceId()].dataSparse});
+        data.dataSparse});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
@@ -488,7 +492,8 @@ void RectangleTextureGLTest::subImage() {
 }
 
 void RectangleTextureGLTest::subImageBuffer() {
-    setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name);
+    auto&& data = PixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_rectangle>())
         CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() << "is not supported.");
@@ -497,9 +502,9 @@ void RectangleTextureGLTest::subImageBuffer() {
     texture.setImage(TextureFormat::RGBA8,
         ImageView2D(PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(4), Zero));
     texture.setSubImage(Vector2i(1), BufferImage2D{
-        PixelStorageData[testCaseInstanceId()].storage,
+        data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2),
-        PixelStorageData[testCaseInstanceId()].dataSparse,
+        data.dataSparse,
         BufferUsage::StaticDraw});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -516,7 +521,8 @@ void RectangleTextureGLTest::subImageBuffer() {
 }
 
 void RectangleTextureGLTest::subImageQuery() {
-    setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name);
+    auto&& data = PixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_rectangle>())
         CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() << "is not supported.");
@@ -530,20 +536,21 @@ void RectangleTextureGLTest::subImageQuery() {
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     Image2D image = texture.subImage(Range2Di::fromSize(Vector2i{1}, Vector2i{2}),
-        {PixelStorageData[testCaseInstanceId()].storage,
+        {data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.flags(), ImageFlag2D{});
     CORRADE_COMPARE(image.size(), Vector2i{2});
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset),
-        PixelStorageData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 
 void RectangleTextureGLTest::subImageQueryView() {
-    setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name);
+    auto&& data = PixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_rectangle>())
         CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() << "is not supported.");
@@ -556,8 +563,8 @@ void RectangleTextureGLTest::subImageQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> data{PixelStorageData[testCaseInstanceId()].offset + 2*2*4};
-    MutableImageView2D image{PixelStorageData[testCaseInstanceId()].storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, data, ImageFlag2D::Array};
+    Containers::Array<char> imageData{data.offset + 2*2*4};
+    MutableImageView2D image{data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, imageData, ImageFlag2D::Array};
     texture.subImage(Range2Di::fromSize(Vector2i{1}, Vector2i{2}), image);
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -565,13 +572,14 @@ void RectangleTextureGLTest::subImageQueryView() {
     /* Doesn't matter what flags are set, they stay untouched */
     CORRADE_COMPARE(image.flags(), ImageFlag2D::Array);
     CORRADE_COMPARE(image.size(), Vector2i{2});
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset),
-        PixelStorageData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 
 void RectangleTextureGLTest::subImageQueryBuffer() {
-    setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name);
+    auto&& data = PixelStorageData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_rectangle>())
         CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() << "is not supported.");
@@ -585,15 +593,15 @@ void RectangleTextureGLTest::subImageQueryBuffer() {
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     BufferImage2D image = texture.subImage(Range2Di::fromSize(Vector2i{1}, Vector2i{2}),
-        {PixelStorageData[testCaseInstanceId()].storage,
+        {data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte}, BufferUsage::StaticRead);
     const auto imageData = image.buffer().data();
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.size(), Vector2i{2});
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset),
-        PixelStorageData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 
diff --git a/src/Magnum/GL/Test/TextureArrayGLTest.cpp b/src/Magnum/GL/Test/TextureArrayGLTest.cpp
index 1b8cb6afa..bb2b7f164 100644
--- a/src/Magnum/GL/Test/TextureArrayGLTest.cpp
+++ b/src/Magnum/GL/Test/TextureArrayGLTest.cpp
@@ -1089,73 +1089,76 @@ void TextureArrayGLTest::view2DOnCubeMapArray() {
 
 #ifndef MAGNUM_TARGET_GLES
 void TextureArrayGLTest::image1D() {
-    setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name);
+    auto&& data = PixelStorage1DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
         CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
 
     Texture1DArray texture;
     texture.setImage(0, TextureFormat::RGBA8, ImageView2D{
-        PixelStorage1DData[testCaseInstanceId()].storage,
-        PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), PixelStorage1DData[testCaseInstanceId()].dataSparse});
+        data.storage,
+        PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), data.dataSparse});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Image2D image = texture.image(0, {PixelStorage1DData[testCaseInstanceId()].storage,
+    Image2D image = texture.image(0, {data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.flags(), ImageFlag2D::Array);
     CORRADE_COMPARE(image.size(), Vector2i(2));
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(PixelStorage1DData[testCaseInstanceId()].offset),
-        PixelStorage1DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 
 void TextureArrayGLTest::image1DBuffer() {
-    setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name);
+    auto&& data = PixelStorage1DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
         CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
 
     Texture1DArray texture;
     texture.setImage(0, TextureFormat::RGBA8, BufferImage2D{
-        PixelStorage1DData[testCaseInstanceId()].storage,
-        PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), PixelStorage1DData[testCaseInstanceId()].dataSparse,
+        data.storage,
+        PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), data.dataSparse,
         BufferUsage::StaticDraw});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     BufferImage2D image = texture.image(0,
-        {PixelStorage1DData[testCaseInstanceId()].storage,
+        {data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte}, BufferUsage::StaticRead);
     auto imageData = image.buffer().data();
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.size(), Vector2i(2));
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(PixelStorage1DData[testCaseInstanceId()].offset),
-        PixelStorage1DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 
 void TextureArrayGLTest::image1DQueryView() {
-    setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name);
+    auto&& data = PixelStorage1DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
         CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
 
     Texture1DArray texture;
     texture.setImage(0, TextureFormat::RGBA8, ImageView2D{
-        PixelStorage1DData[testCaseInstanceId()].storage,
-        PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), PixelStorage1DData[testCaseInstanceId()].dataSparse});
+        data.storage,
+        PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), data.dataSparse});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> data{PixelStorage1DData[testCaseInstanceId()].offset + 2*2*4};
-    MutableImageView2D image{PixelStorage1DData[testCaseInstanceId()].storage,
-        PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, data, ImageFlag2D::Array};
+    Containers::Array<char> imageData{data.offset + 2*2*4};
+    MutableImageView2D image{data.storage,
+        PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, imageData, ImageFlag2D::Array};
     texture.image(0, image);
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -1163,8 +1166,8 @@ void TextureArrayGLTest::image1DQueryView() {
     /* Doesn't matter what flags are set, they stay untouched */
     CORRADE_COMPARE(image.flags(), ImageFlag2D::Array);
     CORRADE_COMPARE(image.size(), Vector2i(2));
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(PixelStorage1DData[testCaseInstanceId()].offset),
-        PixelStorage1DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 
@@ -1177,7 +1180,8 @@ constexpr UnsignedByte SubData1DComplete[] = {
 };
 
 void TextureArrayGLTest::subImage1D() {
-    setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name);
+    auto&& data = PixelStorage1DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
         CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
@@ -1186,8 +1190,8 @@ void TextureArrayGLTest::subImage1D() {
     texture.setImage(0, TextureFormat::RGBA8,
         ImageView2D(PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(4), Zero1D));
     texture.setSubImage(0, Vector2i(1), ImageView2D{
-        PixelStorage1DData[testCaseInstanceId()].storage,
-        PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), PixelStorage1DData[testCaseInstanceId()].dataSparse});
+        data.storage,
+        PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), data.dataSparse});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
@@ -1202,7 +1206,8 @@ void TextureArrayGLTest::subImage1D() {
 }
 
 void TextureArrayGLTest::subImage1DBuffer() {
-    setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name);
+    auto&& data = PixelStorage1DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
         CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
@@ -1211,9 +1216,9 @@ void TextureArrayGLTest::subImage1DBuffer() {
     texture.setImage(0, TextureFormat::RGBA8,
         ImageView2D(PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(4), Zero1D));
     texture.setSubImage(0, Vector2i(1), BufferImage2D{
-        PixelStorage1DData[testCaseInstanceId()].storage,
+        data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2),
-        PixelStorage1DData[testCaseInstanceId()].dataSparse,
+        data.dataSparse,
         BufferUsage::StaticDraw});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -1230,7 +1235,8 @@ void TextureArrayGLTest::subImage1DBuffer() {
 }
 
 void TextureArrayGLTest::subImage1DQuery() {
-    setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name);
+    auto&& data = PixelStorage1DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
         CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
@@ -1244,20 +1250,21 @@ void TextureArrayGLTest::subImage1DQuery() {
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     Image2D image = texture.subImage(0, Range2Di::fromSize(Vector2i{1}, Vector2i{2}),
-        {PixelStorage1DData[testCaseInstanceId()].storage,
+        {data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.flags(), ImageFlag2D::Array);
     CORRADE_COMPARE(image.size(), Vector2i{2});
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(PixelStorage1DData[testCaseInstanceId()].offset),
-        PixelStorage1DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 
 void TextureArrayGLTest::subImage1DQueryView() {
-    setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name);
+    auto&& data = PixelStorage1DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
         CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
@@ -1270,9 +1277,9 @@ void TextureArrayGLTest::subImage1DQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> data{PixelStorage1DData[testCaseInstanceId()].offset + 2*2*4};
-    MutableImageView2D image{PixelStorage1DData[testCaseInstanceId()].storage,
-        PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, data, ImageFlag2D::Array};
+    Containers::Array<char> imageData{data.offset + 2*2*4};
+    MutableImageView2D image{data.storage,
+        PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, imageData, ImageFlag2D::Array};
     texture.subImage(0, Range2Di::fromSize(Vector2i{1}, Vector2i{2}), image);
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -1280,13 +1287,14 @@ void TextureArrayGLTest::subImage1DQueryView() {
     /* Doesn't matter what flags are set, they stay untouched */
     CORRADE_COMPARE(image.flags(), ImageFlag2D::Array);
     CORRADE_COMPARE(image.size(), Vector2i{2});
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(PixelStorage1DData[testCaseInstanceId()].offset),
-        PixelStorage1DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 
 void TextureArrayGLTest::subImage1DQueryBuffer() {
-    setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name);
+    auto&& data = PixelStorage1DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
         CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
@@ -1300,7 +1308,7 @@ void TextureArrayGLTest::subImage1DQueryBuffer() {
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     BufferImage2D image = texture.subImage(0, Range2Di::fromSize(Vector2i{1}, Vector2i{2}),
-        {PixelStorage1DData[testCaseInstanceId()].storage,
+        {data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte}, BufferUsage::StaticRead);
     auto imageData = image.buffer().data();
 
@@ -1309,8 +1317,8 @@ void TextureArrayGLTest::subImage1DQueryBuffer() {
     CORRADE_COMPARE(image.size(), Vector2i{2});
 
     /* Was broken on NV since 370.xx (May 2017), fixed in 390.25 (Mar 2018) */
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(PixelStorage1DData[testCaseInstanceId()].offset),
-        PixelStorage1DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 
@@ -1348,7 +1356,8 @@ void TextureArrayGLTest::compressedSubImage1DQueryBuffer() {
 #endif
 
 void TextureArrayGLTest::image2D() {
-    setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name);
+    auto&& data = PixelStorage2DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
@@ -1357,29 +1366,30 @@ void TextureArrayGLTest::image2D() {
 
     Texture2DArray texture;
     texture.setImage(0, TextureFormat::RGBA8, ImageView3D{
-        PixelStorage2DData[testCaseInstanceId()].storage,
+        data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i(2),
-        PixelStorage2DData[testCaseInstanceId()].dataSparse});
+        data.dataSparse});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     /** @todo How to test this on ES? */
     #ifndef MAGNUM_TARGET_GLES
-    Image3D image = texture.image(0, {PixelStorage2DData[testCaseInstanceId()].storage,
+    Image3D image = texture.image(0, {data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.flags(), ImageFlag3D::Array);
     CORRADE_COMPARE(image.size(), Vector3i(2));
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(PixelStorage2DData[testCaseInstanceId()].offset),
-        PixelStorage2DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
     #endif
 }
 
 void TextureArrayGLTest::image2DBuffer() {
-    setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name);
+    auto&& data = PixelStorage2DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
@@ -1388,53 +1398,54 @@ void TextureArrayGLTest::image2DBuffer() {
 
     Texture2DArray texture;
     texture.setImage(0, TextureFormat::RGBA8, BufferImage3D{
-        PixelStorage2DData[testCaseInstanceId()].storage,
+        data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i(2),
-        PixelStorage2DData[testCaseInstanceId()].dataSparse,
+        data.dataSparse,
         BufferUsage::StaticDraw});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     /** @todo How to test this on ES? */
     #ifndef MAGNUM_TARGET_GLES
-    BufferImage3D image = texture.image(0, {PixelStorage2DData[testCaseInstanceId()].storage,
+    BufferImage3D image = texture.image(0, {data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte}, BufferUsage::StaticRead);
     auto imageData = image.buffer().data();
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.size(), Vector3i(2));
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(PixelStorage2DData[testCaseInstanceId()].offset),
-        PixelStorage2DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
     #endif
 }
 
 #ifndef MAGNUM_TARGET_GLES
 void TextureArrayGLTest::image2DQueryView() {
-    setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name);
+    auto&& data = PixelStorage2DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
         CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
 
     Texture2DArray texture;
     texture.setImage(0, TextureFormat::RGBA8, ImageView3D{
-        PixelStorage2DData[testCaseInstanceId()].storage,
+        data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i(2),
-        PixelStorage2DData[testCaseInstanceId()].dataSparse});
+        data.dataSparse});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> data{PixelStorage2DData[testCaseInstanceId()].offset + 2*2*2*4};
-    MutableImageView3D image{PixelStorage2DData[testCaseInstanceId()].storage,
-        PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i{2}, data};
+    Containers::Array<char> imageData{data.offset + 2*2*2*4};
+    MutableImageView3D image{data.storage,
+        PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i{2}, imageData};
     texture.image(0, image);
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.size(), Vector3i(2));
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(PixelStorage2DData[testCaseInstanceId()].offset),
-        PixelStorage2DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 #endif
@@ -1466,7 +1477,8 @@ constexpr UnsignedByte SubData2DComplete[]{
 #endif
 
 void TextureArrayGLTest::subImage2D() {
-    setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name);
+    auto&& data = PixelStorage2DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
@@ -1477,9 +1489,9 @@ void TextureArrayGLTest::subImage2D() {
     texture.setImage(0, TextureFormat::RGBA8,
         ImageView3D(PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i(4), Zero2D));
     texture.setSubImage(0, Vector3i(1), ImageView3D{
-        PixelStorage2DData[testCaseInstanceId()].storage,
+        data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i(2),
-        PixelStorage2DData[testCaseInstanceId()].dataSparse});
+        data.dataSparse});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
@@ -1497,7 +1509,8 @@ void TextureArrayGLTest::subImage2D() {
 }
 
 void TextureArrayGLTest::subImage2DBuffer() {
-    setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name);
+    auto&& data = PixelStorage2DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
@@ -1508,9 +1521,9 @@ void TextureArrayGLTest::subImage2DBuffer() {
     texture.setImage(0, TextureFormat::RGBA8,
         ImageView3D(PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i(4), Zero2D));
     texture.setSubImage(0, Vector3i(1), BufferImage3D{
-        PixelStorage2DData[testCaseInstanceId()].storage,
+        data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i(2),
-        PixelStorage2DData[testCaseInstanceId()].dataSparse,
+        data.dataSparse,
         BufferUsage::StaticDraw});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -1531,7 +1544,8 @@ void TextureArrayGLTest::subImage2DBuffer() {
 
 #ifndef MAGNUM_TARGET_GLES
 void TextureArrayGLTest::subImage2DQuery() {
-    setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name);
+    auto&& data = PixelStorage2DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
         CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
@@ -1545,20 +1559,21 @@ void TextureArrayGLTest::subImage2DQuery() {
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     Image3D image = texture.subImage(0, Range3Di::fromSize(Vector3i{1}, Vector3i{2}),
-        {PixelStorage2DData[testCaseInstanceId()].storage,
+        {data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.flags(), ImageFlag3D::Array);
     CORRADE_COMPARE(image.size(), Vector3i{2});
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(PixelStorage2DData[testCaseInstanceId()].offset),
-        PixelStorage2DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 
 void TextureArrayGLTest::subImage2DQueryView() {
-    setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name);
+    auto&& data = PixelStorage2DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
         CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
@@ -1571,9 +1586,9 @@ void TextureArrayGLTest::subImage2DQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> data{PixelStorage2DData[testCaseInstanceId()].offset + 2*2*2*4};
-    MutableImageView3D image{PixelStorage2DData[testCaseInstanceId()].storage,
-        PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i{2}, data, ImageFlag3D::Array};
+    Containers::Array<char> imageData{data.offset + 2*2*2*4};
+    MutableImageView3D image{data.storage,
+        PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i{2}, imageData, ImageFlag3D::Array};
     texture.subImage(0, Range3Di::fromSize(Vector3i{1}, Vector3i{2}), image);
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -1581,13 +1596,14 @@ void TextureArrayGLTest::subImage2DQueryView() {
     /* Doesn't matter what flags are set, they stay untouched */
     CORRADE_COMPARE(image.flags(), ImageFlag3D::Array);
     CORRADE_COMPARE(image.size(), Vector3i{2});
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(PixelStorage2DData[testCaseInstanceId()].offset),
-        PixelStorage2DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 
 void TextureArrayGLTest::subImage2DQueryBuffer() {
-    setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name);
+    auto&& data = PixelStorage2DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
         CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
@@ -1601,21 +1617,22 @@ void TextureArrayGLTest::subImage2DQueryBuffer() {
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     BufferImage3D image = texture.subImage(0, Range3Di::fromSize(Vector3i{1}, Vector3i{2}),
-        {PixelStorage2DData[testCaseInstanceId()].storage,
+        {data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte}, BufferUsage::StaticRead);
     const auto imageData = image.buffer().data();
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.size(), Vector3i{2});
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(PixelStorage2DData[testCaseInstanceId()].offset),
-        PixelStorage2DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 #endif
 
 void TextureArrayGLTest::compressedImage2D() {
-    setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name);
+    auto&& data = CompressedPixelStorage2DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
@@ -1633,35 +1650,36 @@ void TextureArrayGLTest::compressedImage2D() {
     #endif
 
     #ifndef MAGNUM_TARGET_GLES
-    if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #endif
 
     Texture2DArray texture;
     texture.setCompressedImage(0, CompressedImageView3D{
         #ifndef MAGNUM_TARGET_GLES
-        CompressedPixelStorage2DData[testCaseInstanceId()].storage,
+        data.storage,
         #endif
         CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 2},
-        CompressedPixelStorage2DData[testCaseInstanceId()].dataSparse});
+        data.dataSparse});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     #ifndef MAGNUM_TARGET_GLES
-    CompressedImage3D image = texture.compressedImage(0, {CompressedPixelStorage2DData[testCaseInstanceId()].storage});
+    CompressedImage3D image = texture.compressedImage(0, {data.storage});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.flags(), ImageFlag3D::Array);
     CORRADE_COMPARE(image.size(), (Vector3i{4, 4, 2}));
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(CompressedPixelStorage2DData[testCaseInstanceId()].offset),
-        CompressedPixelStorage2DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
     #endif
 }
 
 void TextureArrayGLTest::compressedImage2DBuffer() {
-    setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name);
+    auto&& data = CompressedPixelStorage2DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
@@ -1679,63 +1697,64 @@ void TextureArrayGLTest::compressedImage2DBuffer() {
     #endif
 
     #ifndef MAGNUM_TARGET_GLES
-    if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #endif
 
     Texture2DArray texture;
     texture.setCompressedImage(0, CompressedBufferImage3D{
         #ifndef MAGNUM_TARGET_GLES
-        CompressedPixelStorage2DData[testCaseInstanceId()].storage,
+        data.storage,
         #endif
         CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 2},
-        CompressedPixelStorage2DData[testCaseInstanceId()].dataSparse,
+        data.dataSparse,
         BufferUsage::StaticDraw});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     #ifndef MAGNUM_TARGET_GLES
-    CompressedBufferImage3D image = texture.compressedImage(0, {CompressedPixelStorage2DData[testCaseInstanceId()].storage}, BufferUsage::StaticRead);
+    CompressedBufferImage3D image = texture.compressedImage(0, {data.storage}, BufferUsage::StaticRead);
     const auto imageData = image.buffer().data();
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.size(), (Vector3i{4, 4, 2}));
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(CompressedPixelStorage2DData[testCaseInstanceId()].offset),
-        CompressedPixelStorage2DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
     #endif
 }
 
 #ifndef MAGNUM_TARGET_GLES
 void TextureArrayGLTest::compressedImage2DQueryView() {
-    setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name);
+    auto&& data = CompressedPixelStorage2DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
         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() << "is not supported.");
 
-    if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
 
     Texture2DArray texture;
     texture.setCompressedImage(0, CompressedImageView3D{
-        CompressedPixelStorage2DData[testCaseInstanceId()].storage,
+        data.storage,
         CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 2},
-        CompressedPixelStorage2DData[testCaseInstanceId()].dataSparse});
+        data.dataSparse});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> data{CompressedPixelStorage2DData[testCaseInstanceId()].offset + 2*16};
-    MutableCompressedImageView3D image{CompressedPixelStorage2DData[testCaseInstanceId()].storage, CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 2}, data};
+    Containers::Array<char> imageData{data.offset + 2*16};
+    MutableCompressedImageView3D image{data.storage, CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 2}, imageData};
     texture.compressedImage(0, image);
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.size(), (Vector3i{4, 4, 2}));
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(CompressedPixelStorage2DData[testCaseInstanceId()].offset),
-        CompressedPixelStorage2DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 #endif
@@ -1777,7 +1796,8 @@ constexpr UnsignedByte CompressedSubData2DComplete[]{
 #endif
 
 void TextureArrayGLTest::compressedSubImage2D() {
-    setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name);
+    auto&& data = CompressedPixelStorage2DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
@@ -1795,7 +1815,7 @@ void TextureArrayGLTest::compressedSubImage2D() {
     #endif
 
     #ifndef MAGNUM_TARGET_GLES
-    if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #endif
 
@@ -1804,10 +1824,10 @@ void TextureArrayGLTest::compressedSubImage2D() {
         Vector3i{12, 4, 4}, CompressedZero2D});
     texture.setCompressedSubImage(0, {4, 0, 1}, CompressedImageView3D{
         #ifndef MAGNUM_TARGET_GLES
-        CompressedPixelStorage2DData[testCaseInstanceId()].storage,
+        data.storage,
         #endif
         CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 2},
-        CompressedPixelStorage2DData[testCaseInstanceId()].dataSparse});
+        data.dataSparse});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
@@ -1819,7 +1839,7 @@ void TextureArrayGLTest::compressedSubImage2D() {
     CORRADE_COMPARE(image.size(), (Vector3i{12, 4, 4}));
 
     {
-        CORRADE_EXPECT_FAIL_IF(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && (Context::current().detectedDriver() & Context::DetectedDriver::NVidia),
+        CORRADE_EXPECT_FAIL_IF(data.storage != CompressedPixelStorage{} && (Context::current().detectedDriver() & Context::DetectedDriver::NVidia),
             "Non-default compressed pixel storage for array textures behaves weirdly on NVidia");
 
         CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()),
@@ -1830,7 +1850,8 @@ void TextureArrayGLTest::compressedSubImage2D() {
 }
 
 void TextureArrayGLTest::compressedSubImage2DBuffer() {
-    setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name);
+    auto&& data = CompressedPixelStorage2DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
@@ -1848,7 +1869,7 @@ void TextureArrayGLTest::compressedSubImage2DBuffer() {
     #endif
 
     #ifndef MAGNUM_TARGET_GLES
-    if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #endif
 
@@ -1857,10 +1878,10 @@ void TextureArrayGLTest::compressedSubImage2DBuffer() {
         Vector3i{12, 4, 4}, CompressedZero2D});
     texture.setCompressedSubImage(0, {4, 0, 1}, CompressedBufferImage3D{
         #ifndef MAGNUM_TARGET_GLES
-        CompressedPixelStorage2DData[testCaseInstanceId()].storage,
+        data.storage,
         #endif
         CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 2},
-        CompressedPixelStorage2DData[testCaseInstanceId()].dataSparse,
+        data.dataSparse,
         BufferUsage::StaticDraw});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -1880,7 +1901,8 @@ void TextureArrayGLTest::compressedSubImage2DBuffer() {
 
 #ifndef MAGNUM_TARGET_GLES
 void TextureArrayGLTest::compressedSubImage2DQuery() {
-    setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name);
+    auto&& data = CompressedPixelStorage2DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
         CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
@@ -1888,9 +1910,9 @@ void TextureArrayGLTest::compressedSubImage2DQuery() {
         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() << "is not supported.");
-    if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
-    if(CompressedPixelStorage2DData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
+    if(data.storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
         CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported.");
 
     Texture2DArray texture;
@@ -1900,19 +1922,20 @@ void TextureArrayGLTest::compressedSubImage2DQuery() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    CompressedImage3D image = texture.compressedSubImage(0, Range3Di::fromSize({4, 0, 1}, {4, 4, 2}), {CompressedPixelStorage2DData[testCaseInstanceId()].storage});
+    CompressedImage3D image = texture.compressedSubImage(0, Range3Di::fromSize({4, 0, 1}, {4, 4, 2}), {data.storage});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.flags(), ImageFlag3D::Array);
     CORRADE_COMPARE(image.size(), (Vector3i{4, 4, 2}));
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(CompressedPixelStorage2DData[testCaseInstanceId()].offset),
-        CompressedPixelStorage2DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 
 void TextureArrayGLTest::compressedSubImage2DQueryView() {
-    setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name);
+    auto&& data = CompressedPixelStorage2DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
         CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
@@ -1920,9 +1943,9 @@ void TextureArrayGLTest::compressedSubImage2DQueryView() {
         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() << "is not supported.");
-    if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
-    if(CompressedPixelStorage2DData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
+    if(data.storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
         CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported.");
 
     Texture2DArray texture;
@@ -1932,8 +1955,8 @@ void TextureArrayGLTest::compressedSubImage2DQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> data{CompressedPixelStorage2DData[testCaseInstanceId()].offset + 2*16};
-    MutableCompressedImageView3D image{CompressedPixelStorage2DData[testCaseInstanceId()].storage, CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 2}, data, ImageFlag3D::Array};
+    Containers::Array<char> imageData{data.offset + 2*16};
+    MutableCompressedImageView3D image{data.storage, CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 2}, imageData, ImageFlag3D::Array};
     texture.compressedSubImage(0, Range3Di::fromSize({4, 0, 1}, {4, 4, 2}), image);
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -1941,13 +1964,14 @@ void TextureArrayGLTest::compressedSubImage2DQueryView() {
     /* Doesn't matter what flags are set, they stay untouched */
     CORRADE_COMPARE(image.flags(), ImageFlag3D::Array);
     CORRADE_COMPARE(image.size(), (Vector3i{4, 4, 2}));
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(CompressedPixelStorage2DData[testCaseInstanceId()].offset),
-        CompressedPixelStorage2DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 
 void TextureArrayGLTest::compressedSubImage2DQueryBuffer() {
-    setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name);
+    auto&& data = CompressedPixelStorage2DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_array>())
         CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
@@ -1955,9 +1979,9 @@ void TextureArrayGLTest::compressedSubImage2DQueryBuffer() {
         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() << "is not supported.");
-    if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
-    if(CompressedPixelStorage2DData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
+    if(data.storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
         CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported.");
 
     Texture2DArray texture;
@@ -1969,7 +1993,7 @@ void TextureArrayGLTest::compressedSubImage2DQueryBuffer() {
 
     CompressedBufferImage3D image = texture.compressedSubImage(0, Range3Di::fromSize({4, 0, 1}, {4, 4, 2}), {
         #ifndef MAGNUM_TARGET_GLES
-        CompressedPixelStorage2DData[testCaseInstanceId()].storage
+        data.storage
         #endif
     }, BufferUsage::StaticRead);
     const auto imageData = image.buffer().data();
@@ -1977,8 +2001,8 @@ void TextureArrayGLTest::compressedSubImage2DQueryBuffer() {
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.size(), (Vector3i{4, 4, 2}));
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(CompressedPixelStorage2DData[testCaseInstanceId()].offset),
-        CompressedPixelStorage2DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 
diff --git a/src/Magnum/GL/Test/TextureGLTest.cpp b/src/Magnum/GL/Test/TextureGLTest.cpp
index 0195dcd71..0d148650c 100644
--- a/src/Magnum/GL/Test/TextureGLTest.cpp
+++ b/src/Magnum/GL/Test/TextureGLTest.cpp
@@ -1587,66 +1587,69 @@ void TextureGLTest::view3D() {
 
 #ifndef MAGNUM_TARGET_GLES
 void TextureGLTest::image1D() {
-    setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name);
+    auto&& data = PixelStorage1DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     Texture1D texture;
     texture.setImage(0, TextureFormat::RGBA8, ImageView1D{
-        PixelStorage1DData[testCaseInstanceId()].storage,
+        data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, 2,
-        PixelStorage1DData[testCaseInstanceId()].dataSparse});
+        data.dataSparse});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Image1D image = texture.image(0, {PixelStorage1DData[testCaseInstanceId()].storage,
+    Image1D image = texture.image(0, {data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.flags(), ImageFlags1D{});
     CORRADE_COMPARE(image.size(), 2);
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(PixelStorage1DData[testCaseInstanceId()].offset),
-        PixelStorage1DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 
 void TextureGLTest::image1DBuffer() {
-    setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name);
+    auto&& data = PixelStorage1DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     Texture1D texture;
     texture.setImage(0, TextureFormat::RGBA8, BufferImage1D{
-        PixelStorage1DData[testCaseInstanceId()].storage,
+        data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, 2,
-        PixelStorage1DData[testCaseInstanceId()].dataSparse,
+        data.dataSparse,
         BufferUsage::StaticDraw});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     BufferImage1D image = texture.image(0,
-        {PixelStorage1DData[testCaseInstanceId()].storage, PixelFormat::RGBA, PixelType::UnsignedByte}, BufferUsage::StaticDraw);
+        {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}, BufferUsage::StaticDraw);
     const auto imageData = image.buffer().data();
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.size(), 2);
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(PixelStorage1DData[testCaseInstanceId()].offset),
-        PixelStorage1DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 
 void TextureGLTest::image1DQueryView() {
-    setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name);
+    auto&& data = PixelStorage1DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     Texture1D texture;
     texture.setImage(0, TextureFormat::RGBA8, ImageView1D{
-        PixelStorage1DData[testCaseInstanceId()].storage,
+        data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, 2,
-        PixelStorage1DData[testCaseInstanceId()].dataSparse});
+        data.dataSparse});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> data{PixelStorage1DData[testCaseInstanceId()].offset + 2*4};
-    MutableImageView1D image{PixelStorage1DData[testCaseInstanceId()].storage,
-        PixelFormat::RGBA, PixelType::UnsignedByte, 2, data};
+    Containers::Array<char> imageData{data.offset + 2*4};
+    MutableImageView1D image{data.storage,
+        PixelFormat::RGBA, PixelType::UnsignedByte, 2, imageData};
     texture.image(0, image);
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -1654,8 +1657,8 @@ void TextureGLTest::image1DQueryView() {
     /* Doesn't matter what flags are set, they stay untouched */
     CORRADE_COMPARE(image.flags(), ImageFlags1D{});
     CORRADE_COMPARE(image.size(), 2);
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(PixelStorage1DData[testCaseInstanceId()].offset),
-        PixelStorage1DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 
@@ -1665,15 +1668,16 @@ constexpr UnsignedByte SubData1DComplete[]{
 };
 
 void TextureGLTest::subImage1D() {
-    setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name);
+    auto&& data = PixelStorage1DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     Texture1D texture;
     texture.setImage(0, TextureFormat::RGBA8,
         ImageView1D(PixelFormat::RGBA, PixelType::UnsignedByte, 4, Zero1D));
     texture.setSubImage(0, 1, ImageView1D{
-        PixelStorage1DData[testCaseInstanceId()].storage,
+        data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, 2,
-        PixelStorage1DData[testCaseInstanceId()].dataSparse});
+        data.dataSparse});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
@@ -1688,15 +1692,16 @@ void TextureGLTest::subImage1D() {
 }
 
 void TextureGLTest::subImage1DBuffer() {
-    setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name);
+    auto&& data = PixelStorage1DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     Texture1D texture;
     texture.setImage(0, TextureFormat::RGBA8,
         ImageView1D(PixelFormat::RGBA, PixelType::UnsignedByte, 4, Zero1D));
     texture.setSubImage(0, 1, BufferImage1D{
-        PixelStorage1DData[testCaseInstanceId()].storage,
+        data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, 2,
-        PixelStorage1DData[testCaseInstanceId()].dataSparse,
+        data.dataSparse,
         BufferUsage::StaticDraw});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -1712,7 +1717,8 @@ void TextureGLTest::subImage1DBuffer() {
 }
 
 void TextureGLTest::subImage1DQuery() {
-    setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name);
+    auto&& data = PixelStorage1DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
         CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
@@ -1724,20 +1730,21 @@ void TextureGLTest::subImage1DQuery() {
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     Image1D image = texture.subImage(0, Range1Di::fromSize(1, 2),
-        {PixelStorage1DData[testCaseInstanceId()].storage,
+        {data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.flags(), ImageFlags1D{});
     CORRADE_COMPARE(image.size(), 2);
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(PixelStorage1DData[testCaseInstanceId()].offset),
-        PixelStorage1DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 
 void TextureGLTest::subImage1DQueryView() {
-    setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name);
+    auto&& data = PixelStorage1DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
         CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
@@ -1748,9 +1755,9 @@ void TextureGLTest::subImage1DQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> data{PixelStorage1DData[testCaseInstanceId()].offset + 2*4};
-    MutableImageView1D image{PixelStorage1DData[testCaseInstanceId()].storage,
-        PixelFormat::RGBA, PixelType::UnsignedByte, 2, data};
+    Containers::Array<char> imageData{data.offset + 2*4};
+    MutableImageView1D image{data.storage,
+        PixelFormat::RGBA, PixelType::UnsignedByte, 2, imageData};
     texture.subImage(0, Range1Di::fromSize(1, 2), image);
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -1758,13 +1765,14 @@ void TextureGLTest::subImage1DQueryView() {
     /* Doesn't matter what flags are set, they stay untouched */
     CORRADE_COMPARE(image.flags(), ImageFlags1D{});
     CORRADE_COMPARE(image.size(), 2);
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(PixelStorage1DData[testCaseInstanceId()].offset),
-        PixelStorage1DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 
 void TextureGLTest::subImage1DQueryBuffer() {
-    setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name);
+    auto&& data = PixelStorage1DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
         CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
@@ -1776,15 +1784,15 @@ void TextureGLTest::subImage1DQueryBuffer() {
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     BufferImage1D image = texture.subImage(0, Range1Di::fromSize(1, 2),
-        {PixelStorage1DData[testCaseInstanceId()].storage,
+        {data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte}, BufferUsage::StaticRead);
     const auto imageData = image.buffer().data();
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.size(), 2);
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(PixelStorage1DData[testCaseInstanceId()].offset),
-        PixelStorage1DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 
@@ -1822,14 +1830,15 @@ void TextureGLTest::compressedSubImage1DQueryBuffer() {
 #endif
 
 void TextureGLTest::image2D() {
-    setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name);
+    auto&& data = PixelStorage2DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     #ifdef MAGNUM_TARGET_GLES2
     #ifndef MAGNUM_TARGET_WEBGL
-    if(PixelStorage2DData[testCaseInstanceId()].storage != PixelStorage{} && !Context::current().isExtensionSupported<Extensions::EXT::unpack_subimage>())
+    if(data.storage != PixelStorage{} && !Context::current().isExtensionSupported<Extensions::EXT::unpack_subimage>())
         CORRADE_SKIP(Extensions::EXT::unpack_subimage::string() << "is not supported.");
     #else
-    if(PixelStorage2DData[testCaseInstanceId()].storage != PixelStorage{})
+    if(data.storage != PixelStorage{})
         CORRADE_SKIP("Image unpack is not supported in WebGL 1.");
     #endif
     #endif
@@ -1841,37 +1850,37 @@ void TextureGLTest::image2D() {
         #else
         TextureFormat::RGBA,
         #endif
-        ImageView2D{
-        PixelStorage2DData[testCaseInstanceId()].storage,
-        PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2),
-        PixelStorage2DData[testCaseInstanceId()].dataSparse});
+        ImageView2D{data.storage,
+            PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2),
+            data.dataSparse});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     /** @todo How to test this on ES? */
     #ifndef MAGNUM_TARGET_GLES
-    Image2D image = texture.image(0, {PixelStorage2DData[testCaseInstanceId()].storage,
+    Image2D image = texture.image(0, {data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.flags(), ImageFlags2D{});
     CORRADE_COMPARE(image.size(), Vector2i(2));
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(PixelStorage2DData[testCaseInstanceId()].offset),
-        PixelStorage2DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
     #endif
 }
 
 #ifndef MAGNUM_TARGET_GLES2
 void TextureGLTest::image2DBuffer() {
-    setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name);
+    auto&& data = PixelStorage2DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     Texture2D texture;
     texture.setImage(0, TextureFormat::RGBA8, BufferImage2D{
-        PixelStorage2DData[testCaseInstanceId()].storage,
+        data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2),
-        PixelStorage2DData[testCaseInstanceId()].dataSparse,
+        data.dataSparse,
         BufferUsage::StaticDraw});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -1879,15 +1888,15 @@ void TextureGLTest::image2DBuffer() {
     /** @todo How to test this on ES? */
     #ifndef MAGNUM_TARGET_GLES
     BufferImage2D image = texture.image(0,
-        {PixelStorage2DData[testCaseInstanceId()].storage,
+        {data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte}, BufferUsage::StaticRead);
     const auto imageData = image.buffer().data();
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.size(), Vector2i(2));
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(PixelStorage2DData[testCaseInstanceId()].offset),
-        PixelStorage2DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
     #endif
 }
@@ -1895,19 +1904,20 @@ void TextureGLTest::image2DBuffer() {
 
 #ifndef MAGNUM_TARGET_GLES
 void TextureGLTest::image2DQueryView() {
-    setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name);
+    auto&& data = PixelStorage2DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     Texture2D texture;
     texture.setImage(0, TextureFormat::RGBA8, ImageView2D{
-        PixelStorage2DData[testCaseInstanceId()].storage,
+        data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2),
-        PixelStorage2DData[testCaseInstanceId()].dataSparse});
+        data.dataSparse});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> data{PixelStorage2DData[testCaseInstanceId()].offset + 2*2*4};
-    MutableImageView2D image{PixelStorage2DData[testCaseInstanceId()].storage,
-        PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, data, ImageFlag2D::Array};
+    Containers::Array<char> imageData{data.offset + 2*2*4};
+    MutableImageView2D image{data.storage,
+        PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, imageData, ImageFlag2D::Array};
     texture.image(0, image);
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -1915,8 +1925,8 @@ void TextureGLTest::image2DQueryView() {
     /* Doesn't matter what flags are set, they stay untouched */
     CORRADE_COMPARE(image.flags(), ImageFlag2D::Array);
     CORRADE_COMPARE(image.size(), Vector2i(2));
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(PixelStorage2DData[testCaseInstanceId()].offset),
-        PixelStorage2DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 #endif
@@ -1933,14 +1943,15 @@ constexpr UnsignedByte SubData2DComplete[]{
 #endif
 
 void TextureGLTest::subImage2D() {
-    setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name);
+    auto&& data = PixelStorage2DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     #ifdef MAGNUM_TARGET_GLES2
     #ifndef MAGNUM_TARGET_WEBGL
-    if(PixelStorage2DData[testCaseInstanceId()].storage != PixelStorage{} && !Context::current().isExtensionSupported<Extensions::EXT::unpack_subimage>())
+    if(data.storage != PixelStorage{} && !Context::current().isExtensionSupported<Extensions::EXT::unpack_subimage>())
         CORRADE_SKIP(Extensions::EXT::unpack_subimage::string() << "is not supported.");
     #else
-    if(PixelStorage2DData[testCaseInstanceId()].storage != PixelStorage{})
+    if(data.storage != PixelStorage{})
         CORRADE_SKIP("Image unpack is not supported in WebGL 1.");
     #endif
     #endif
@@ -1953,9 +1964,9 @@ void TextureGLTest::subImage2D() {
         TextureFormat::RGBA,
         #endif
         ImageView2D(PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(4), Zero2D));
-    texture.setSubImage(0, Vector2i(1), ImageView2D{PixelStorage2DData[testCaseInstanceId()].storage,
+    texture.setSubImage(0, Vector2i(1), ImageView2D{data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2),
-        PixelStorage2DData[testCaseInstanceId()].dataSparse});
+        data.dataSparse});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
@@ -1974,14 +1985,15 @@ void TextureGLTest::subImage2D() {
 
 #ifndef MAGNUM_TARGET_GLES2
 void TextureGLTest::subImage2DBuffer() {
-    setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name);
+    auto&& data = PixelStorage2DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     Texture2D texture;
     texture.setImage(0, TextureFormat::RGBA8,
         ImageView2D(PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(4), Zero2D));
-    texture.setSubImage(0, Vector2i(1), BufferImage2D{PixelStorage2DData[testCaseInstanceId()].storage,
+    texture.setSubImage(0, Vector2i(1), BufferImage2D{data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2),
-        PixelStorage2DData[testCaseInstanceId()].dataSparse,
+        data.dataSparse,
         BufferUsage::StaticDraw});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -2002,7 +2014,8 @@ void TextureGLTest::subImage2DBuffer() {
 
 #ifndef MAGNUM_TARGET_GLES
 void TextureGLTest::subImage2DQuery() {
-    setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name);
+    auto&& data = PixelStorage2DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
         CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
@@ -2014,20 +2027,21 @@ void TextureGLTest::subImage2DQuery() {
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     Image2D image = texture.subImage(0, Range2Di::fromSize(Vector2i{1}, Vector2i{2}),
-        {PixelStorage2DData[testCaseInstanceId()].storage,
+        {data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.flags(), ImageFlags2D{});
     CORRADE_COMPARE(image.size(), Vector2i{2});
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(PixelStorage2DData[testCaseInstanceId()].offset),
-        PixelStorage2DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 
 void TextureGLTest::subImage2DQueryView() {
-    setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name);
+    auto&& data = PixelStorage2DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
         CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
@@ -2038,9 +2052,9 @@ void TextureGLTest::subImage2DQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> data{PixelStorage2DData[testCaseInstanceId()].offset + 2*2*4};
-    MutableImageView2D image{PixelStorage2DData[testCaseInstanceId()].storage,
-        PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, data, ImageFlag2D::Array};
+    Containers::Array<char> imageData{data.offset + 2*2*4};
+    MutableImageView2D image{data.storage,
+        PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, imageData, ImageFlag2D::Array};
     texture.subImage(0, Range2Di::fromSize(Vector2i{1}, Vector2i{2}), image);
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -2048,13 +2062,14 @@ void TextureGLTest::subImage2DQueryView() {
     /* Doesn't matter what flags are set, they stay untouched */
     CORRADE_COMPARE(image.flags(), ImageFlag2D::Array);
     CORRADE_COMPARE(image.size(), Vector2i{2});
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(PixelStorage2DData[testCaseInstanceId()].offset),
-        PixelStorage2DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 
 void TextureGLTest::subImage2DQueryBuffer() {
-    setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name);
+    auto&& data = PixelStorage2DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
         CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
@@ -2066,21 +2081,22 @@ void TextureGLTest::subImage2DQueryBuffer() {
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     BufferImage2D image = texture.subImage(0, Range2Di::fromSize(Vector2i{1}, Vector2i{2}),
-        {PixelStorage2DData[testCaseInstanceId()].storage,
+        {data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte}, BufferUsage::StaticRead);
     const auto imageData = image.buffer().data();
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.size(), Vector2i{2});
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(PixelStorage2DData[testCaseInstanceId()].offset),
-        PixelStorage2DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 #endif
 
 void TextureGLTest::compressedImage2D() {
-    setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name);
+    auto&& data = CompressedPixelStorage2DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
@@ -2094,37 +2110,38 @@ void TextureGLTest::compressedImage2D() {
     #endif
 
     #ifndef MAGNUM_TARGET_GLES
-    if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #endif
 
     Texture2D texture;
     texture.setCompressedImage(0, CompressedImageView2D{
         #ifndef MAGNUM_TARGET_GLES
-        CompressedPixelStorage2DData[testCaseInstanceId()].storage,
+        data.storage,
         #endif
         CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{4},
-        CompressedPixelStorage2DData[testCaseInstanceId()].dataSparse});
+        data.dataSparse});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     #ifndef MAGNUM_TARGET_GLES
-    CompressedImage2D image = texture.compressedImage(0, {CompressedPixelStorage2DData[testCaseInstanceId()].storage});
+    CompressedImage2D image = texture.compressedImage(0, {data.storage});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.flags(), ImageFlags2D{});
     CORRADE_COMPARE(image.size(), Vector2i{4});
 
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(CompressedPixelStorage2DData[testCaseInstanceId()].offset),
-        CompressedPixelStorage2DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
     #endif
 }
 
 #ifndef MAGNUM_TARGET_GLES2
 void TextureGLTest::compressedImage2DBuffer() {
-    setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name);
+    auto&& data = CompressedPixelStorage2DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
@@ -2138,30 +2155,30 @@ void TextureGLTest::compressedImage2DBuffer() {
     #endif
 
     #ifndef MAGNUM_TARGET_GLES
-    if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #endif
 
     Texture2D texture;
     texture.setCompressedImage(0, CompressedBufferImage2D{
         #ifndef MAGNUM_TARGET_GLES
-        CompressedPixelStorage2DData[testCaseInstanceId()].storage,
+        data.storage,
         #endif
         CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{4},
-        CompressedPixelStorage2DData[testCaseInstanceId()].dataSparse,
+        data.dataSparse,
         BufferUsage::StaticDraw});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     #ifndef MAGNUM_TARGET_GLES
-    CompressedBufferImage2D image = texture.compressedImage(0, {CompressedPixelStorage2DData[testCaseInstanceId()].storage}, BufferUsage::StaticRead);
+    CompressedBufferImage2D image = texture.compressedImage(0, {data.storage}, BufferUsage::StaticRead);
     const auto imageData = image.buffer().data();
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.size(), Vector2i{4});
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(CompressedPixelStorage2DData[testCaseInstanceId()].offset),
-        CompressedPixelStorage2DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
     #endif
 }
@@ -2169,24 +2186,25 @@ void TextureGLTest::compressedImage2DBuffer() {
 
 #ifndef MAGNUM_TARGET_GLES
 void TextureGLTest::compressedImage2DQueryView() {
-    setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name);
+    auto&& data = CompressedPixelStorage2DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
         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>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
 
     Texture2D texture;
     texture.setCompressedImage(0, CompressedImageView2D{
-        CompressedPixelStorage2DData[testCaseInstanceId()].storage,
+        data.storage,
         CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{4},
-        CompressedPixelStorage2DData[testCaseInstanceId()].dataSparse});
+        data.dataSparse});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> data{CompressedPixelStorage2DData[testCaseInstanceId()].offset + 1*16};
-    MutableCompressedImageView2D image{CompressedPixelStorage2DData[testCaseInstanceId()].storage, CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{4}, data, ImageFlag2D::Array};
+    Containers::Array<char> imageData{data.offset + 1*16};
+    MutableCompressedImageView2D image{data.storage, CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{4}, imageData, ImageFlag2D::Array};
     texture.compressedImage(0, image);
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -2195,8 +2213,8 @@ void TextureGLTest::compressedImage2DQueryView() {
     CORRADE_COMPARE(image.flags(), ImageFlag2D::Array);
     CORRADE_COMPARE(image.size(), Vector2i{4});
 
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(CompressedPixelStorage2DData[testCaseInstanceId()].offset),
-        CompressedPixelStorage2DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 #endif
@@ -2217,7 +2235,8 @@ constexpr UnsignedByte CompressedSubData2DComplete[]{
 #endif
 
 void TextureGLTest::compressedSubImage2D() {
-    setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name);
+    auto&& data = CompressedPixelStorage2DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
@@ -2231,7 +2250,7 @@ void TextureGLTest::compressedSubImage2D() {
     #endif
 
     #ifndef MAGNUM_TARGET_GLES
-    if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #endif
 
@@ -2240,10 +2259,10 @@ void TextureGLTest::compressedSubImage2D() {
         {12, 4}, CompressedZero2D});
     texture.setCompressedSubImage(0, {4, 0}, CompressedImageView2D{
         #ifndef MAGNUM_TARGET_GLES
-        CompressedPixelStorage2DData[testCaseInstanceId()].storage,
+        data.storage,
         #endif
         CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{4},
-        CompressedPixelStorage2DData[testCaseInstanceId()].dataSparse});
+        data.dataSparse});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
@@ -2261,7 +2280,8 @@ void TextureGLTest::compressedSubImage2D() {
 
 #ifndef MAGNUM_TARGET_GLES2
 void TextureGLTest::compressedSubImage2DBuffer() {
-    setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name);
+    auto&& data = CompressedPixelStorage2DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
@@ -2275,7 +2295,7 @@ void TextureGLTest::compressedSubImage2DBuffer() {
     #endif
 
     #ifndef MAGNUM_TARGET_GLES
-    if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #endif
 
@@ -2284,10 +2304,10 @@ void TextureGLTest::compressedSubImage2DBuffer() {
         {12, 4}, CompressedZero2D});
     texture.setCompressedSubImage(0, {4, 0}, CompressedBufferImage2D{
         #ifndef MAGNUM_TARGET_GLES
-        CompressedPixelStorage2DData[testCaseInstanceId()].storage,
+        data.storage,
         #endif
         CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{4},
-        CompressedPixelStorage2DData[testCaseInstanceId()].dataSparse,
+        data.dataSparse,
         BufferUsage::StaticDraw});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -2308,15 +2328,16 @@ void TextureGLTest::compressedSubImage2DBuffer() {
 
 #ifndef MAGNUM_TARGET_GLES
 void TextureGLTest::compressedSubImage2DQuery() {
-    setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name);
+    auto&& data = CompressedPixelStorage2DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
         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() << "is not supported.");
-    if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
-    if(CompressedPixelStorage2DData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
+    if(data.storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
         CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported.");
 
     Texture2D texture;
@@ -2326,27 +2347,28 @@ void TextureGLTest::compressedSubImage2DQuery() {
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CompressedImage2D image = texture.compressedSubImage(0, Range2Di::fromSize({4, 0}, Vector2i{4}),
-        {CompressedPixelStorage2DData[testCaseInstanceId()].storage});
+        {data.storage});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.flags(), ImageFlags2D{});
     CORRADE_COMPARE(image.size(), Vector2i{4});
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(CompressedPixelStorage2DData[testCaseInstanceId()].offset),
-        CompressedPixelStorage2DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 
 void TextureGLTest::compressedSubImage2DQueryView() {
-    setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name);
+    auto&& data = CompressedPixelStorage2DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
         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() << "is not supported.");
-    if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
-    if(CompressedPixelStorage2DData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
+    if(data.storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
         CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported.");
 
     Texture2D texture;
@@ -2355,8 +2377,8 @@ void TextureGLTest::compressedSubImage2DQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> data{CompressedPixelStorage2DData[testCaseInstanceId()].offset + 1*16};
-    MutableCompressedImageView2D image{CompressedPixelStorage2DData[testCaseInstanceId()].storage, CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{4}, data, ImageFlag2D::Array};
+    Containers::Array<char> imageData{data.offset + 1*16};
+    MutableCompressedImageView2D image{data.storage, CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{4}, imageData, ImageFlag2D::Array};
     texture.compressedSubImage(0, Range2Di::fromSize({4, 0}, Vector2i{4}), image);
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -2364,21 +2386,22 @@ void TextureGLTest::compressedSubImage2DQueryView() {
     /* Doesn't matter what flags are set, they stay untouched */
     CORRADE_COMPARE(image.flags(), ImageFlag2D::Array);
     CORRADE_COMPARE(image.size(), Vector2i{4});
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(CompressedPixelStorage2DData[testCaseInstanceId()].offset),
-        CompressedPixelStorage2DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 
 void TextureGLTest::compressedSubImage2DQueryBuffer() {
-    setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name);
+    auto&& data = CompressedPixelStorage2DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
         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() << "is not supported.");
-    if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
-    if(CompressedPixelStorage2DData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
+    if(data.storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
         CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported.");
 
     Texture2D texture;
@@ -2388,61 +2411,63 @@ void TextureGLTest::compressedSubImage2DQueryBuffer() {
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CompressedBufferImage2D image = texture.compressedSubImage(0, Range2Di::fromSize({4, 0}, Vector2i{4}),
-        {CompressedPixelStorage2DData[testCaseInstanceId()].storage}, BufferUsage::StaticRead);
+        {data.storage}, BufferUsage::StaticRead);
     const auto imageData = image.buffer().data();
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.size(), Vector2i{4});
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(CompressedPixelStorage2DData[testCaseInstanceId()].offset),
-        CompressedPixelStorage2DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 #endif
 
 #if !(defined(MAGNUM_TARGET_GLES2) && defined(MAGNUM_TARGET_WEBGL))
 void TextureGLTest::image3D() {
-    setTestCaseDescription(PixelStorage3DData[testCaseInstanceId()].name);
+    auto&& data = PixelStorage3DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     #ifdef MAGNUM_TARGET_GLES2
     if(!Context::current().isExtensionSupported<Extensions::OES::texture_3D>())
         CORRADE_SKIP(Extensions::OES::texture_3D::string() << "is not supported.");
-    if(PixelStorage3DData[testCaseInstanceId()].storage != PixelStorage{} && !Context::current().isExtensionSupported<Extensions::EXT::unpack_subimage>())
+    if(data.storage != PixelStorage{} && !Context::current().isExtensionSupported<Extensions::EXT::unpack_subimage>())
         CORRADE_SKIP(Extensions::EXT::unpack_subimage::string() << "is not supported.");
     #endif
 
     Texture3D texture;
     texture.setImage(0, TextureFormat::RGBA8, ImageView3D{
-        PixelStorage3DData[testCaseInstanceId()].storage,
+        data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i(2),
-        PixelStorage3DData[testCaseInstanceId()].dataSparse});
+        data.dataSparse});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     /** @todo How to test this on ES? */
     #ifndef MAGNUM_TARGET_GLES
-    Image3D image = texture.image(0, {PixelStorage3DData[testCaseInstanceId()].storage,
+    Image3D image = texture.image(0, {data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.flags(), ImageFlags3D{});
     CORRADE_COMPARE(image.size(), Vector3i(2));
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(PixelStorage3DData[testCaseInstanceId()].offset),
-        PixelStorage3DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
     #endif
 }
 
 #ifndef MAGNUM_TARGET_GLES2
 void TextureGLTest::image3DBuffer() {
-    setTestCaseDescription(PixelStorage3DData[testCaseInstanceId()].name);
+    auto&& data = PixelStorage3DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     Texture3D texture;
     texture.setImage(0, TextureFormat::RGBA8, BufferImage3D{
-        PixelStorage3DData[testCaseInstanceId()].storage,
+        data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i(2),
-        PixelStorage3DData[testCaseInstanceId()].dataSparse,
+        data.dataSparse,
         BufferUsage::StaticDraw});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -2450,15 +2475,15 @@ void TextureGLTest::image3DBuffer() {
     /** @todo How to test this on ES? */
     #ifndef MAGNUM_TARGET_GLES
     BufferImage3D image = texture.image(0,
-        {PixelStorage3DData[testCaseInstanceId()].storage, PixelFormat::RGBA, PixelType::UnsignedByte},
+        {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte},
         BufferUsage::StaticRead);
     const auto imageData = image.buffer().data();
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.size(), Vector3i(2));
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(PixelStorage3DData[testCaseInstanceId()].offset),
-        PixelStorage3DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
     #endif
 }
@@ -2466,19 +2491,20 @@ void TextureGLTest::image3DBuffer() {
 
 #ifndef MAGNUM_TARGET_GLES
 void TextureGLTest::image3DQueryView() {
-    setTestCaseDescription(PixelStorage3DData[testCaseInstanceId()].name);
+    auto&& data = PixelStorage3DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     Texture3D texture;
     texture.setImage(0, TextureFormat::RGBA8, ImageView3D{
-        PixelStorage3DData[testCaseInstanceId()].storage,
+        data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i(2),
-        PixelStorage3DData[testCaseInstanceId()].dataSparse});
+        data.dataSparse});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> data{PixelStorage3DData[testCaseInstanceId()].offset + 2*2*2*4};
-    MutableImageView3D image{PixelStorage3DData[testCaseInstanceId()].storage,
-        PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i{2}, data, ImageFlag3D::Array};
+    Containers::Array<char> imageData{data.offset + 2*2*2*4};
+    MutableImageView3D image{data.storage,
+        PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i{2}, imageData, ImageFlag3D::Array};
     texture.image(0, image);
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -2486,8 +2512,8 @@ void TextureGLTest::image3DQueryView() {
     /* Doesn't matter what flags are set, they stay untouched */
     CORRADE_COMPARE(image.flags(), ImageFlag3D::Array);
     CORRADE_COMPARE(image.size(), Vector3i(2));
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(PixelStorage3DData[testCaseInstanceId()].offset),
-        PixelStorage3DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 #endif
@@ -2519,21 +2545,22 @@ constexpr UnsignedByte SubData3DComplete[]{
 #endif
 
 void TextureGLTest::subImage3D() {
-    setTestCaseDescription(PixelStorage3DData[testCaseInstanceId()].name);
+    auto&& data = PixelStorage3DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     #ifdef MAGNUM_TARGET_GLES2
     if(!Context::current().isExtensionSupported<Extensions::OES::texture_3D>())
         CORRADE_SKIP(Extensions::OES::texture_3D::string() << "is not supported.");
-    if(PixelStorage3DData[testCaseInstanceId()].storage != PixelStorage{} && !Context::current().isExtensionSupported<Extensions::EXT::unpack_subimage>())
+    if(data.storage != PixelStorage{} && !Context::current().isExtensionSupported<Extensions::EXT::unpack_subimage>())
         CORRADE_SKIP(Extensions::EXT::unpack_subimage::string() << "is not supported.");
     #endif
 
     Texture3D texture;
     texture.setImage(0, TextureFormat::RGBA8,
         ImageView3D(PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i(4), Zero3D));
-    texture.setSubImage(0, Vector3i(1), ImageView3D{PixelStorage3DData[testCaseInstanceId()].storage,
+    texture.setSubImage(0, Vector3i(1), ImageView3D{data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i(2),
-        PixelStorage3DData[testCaseInstanceId()].dataSparse});
+        data.dataSparse});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
@@ -2552,15 +2579,16 @@ void TextureGLTest::subImage3D() {
 
 #ifndef MAGNUM_TARGET_GLES2
 void TextureGLTest::subImage3DBuffer() {
-    setTestCaseDescription(PixelStorage3DData[testCaseInstanceId()].name);
+    auto&& data = PixelStorage3DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     Texture3D texture;
     texture.setImage(0, TextureFormat::RGBA8,
         ImageView3D(PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i(4), Zero3D));
     texture.setSubImage(0, Vector3i(1), BufferImage3D{
-        PixelStorage3DData[testCaseInstanceId()].storage,
+        data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i(2),
-        PixelStorage3DData[testCaseInstanceId()].dataSparse,
+        data.dataSparse,
         BufferUsage::StaticDraw});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -2582,7 +2610,8 @@ void TextureGLTest::subImage3DBuffer() {
 
 #ifndef MAGNUM_TARGET_GLES
 void TextureGLTest::subImage3DQuery() {
-    setTestCaseDescription(PixelStorage3DData[testCaseInstanceId()].name);
+    auto&& data = PixelStorage3DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
         CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
@@ -2594,20 +2623,20 @@ void TextureGLTest::subImage3DQuery() {
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     Image3D image = texture.subImage(0, Range3Di::fromSize(Vector3i{1}, Vector3i{2}),
-        {PixelStorage3DData[testCaseInstanceId()].storage,
-        PixelFormat::RGBA, PixelType::UnsignedByte});
+        {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.flags(), ImageFlags3D{});
     CORRADE_COMPARE(image.size(), Vector3i{2});
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(PixelStorage3DData[testCaseInstanceId()].offset),
-        PixelStorage3DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 
 void TextureGLTest::subImage3DQueryView() {
-    setTestCaseDescription(PixelStorage3DData[testCaseInstanceId()].name);
+    auto&& data = PixelStorage3DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
         CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
@@ -2618,9 +2647,9 @@ void TextureGLTest::subImage3DQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> data{PixelStorage3DData[testCaseInstanceId()].offset + 2*2*2*4};
-    MutableImageView3D image{PixelStorage3DData[testCaseInstanceId()].storage,
-        PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i{2}, data, ImageFlag3D::Array};
+    Containers::Array<char> imageData{data.offset + 2*2*2*4};
+    MutableImageView3D image{data.storage,
+        PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i{2}, imageData, ImageFlag3D::Array};
     texture.subImage(0, Range3Di::fromSize(Vector3i{1}, Vector3i{2}), image);
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -2628,13 +2657,14 @@ void TextureGLTest::subImage3DQueryView() {
     /* Doesn't matter what flags are set, they stay untouched */
     CORRADE_COMPARE(image.flags(), ImageFlag3D::Array);
     CORRADE_COMPARE(image.size(), Vector3i{2});
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(PixelStorage3DData[testCaseInstanceId()].offset),
-        PixelStorage3DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 
 void TextureGLTest::subImage3DQueryBuffer() {
-    setTestCaseDescription(PixelStorage3DData[testCaseInstanceId()].name);
+    auto&& data = PixelStorage3DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
         CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
@@ -2646,7 +2676,7 @@ void TextureGLTest::subImage3DQueryBuffer() {
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     BufferImage3D image = texture.subImage(0, Range3Di::fromSize(Vector3i{1}, Vector3i{2}),
-        {PixelStorage3DData[testCaseInstanceId()].storage,
+        {data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte}, BufferUsage::StaticRead);
     const auto imageData = image.buffer().data();
 
@@ -2655,14 +2685,15 @@ void TextureGLTest::subImage3DQueryBuffer() {
     CORRADE_COMPARE(image.size(), Vector3i{2});
     CORRADE_EXPECT_FAIL_IF(Context::current().detectedDriver() & Context::DetectedDriver::Mesa,
         "Mesa has this broken since 21.2, worked fine with 21.1.");
-    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(PixelStorage3DData[testCaseInstanceId()].offset),
-        PixelStorage3DData[testCaseInstanceId()].data,
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(data.offset),
+        data.data,
         TestSuite::Compare::Container);
 }
 #endif
 
 void TextureGLTest::compressedImage3D() {
-    setTestCaseDescription(CompressedPixelStorage3DData[testCaseInstanceId()].name);
+    auto&& data = CompressedPixelStorage3DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     #if defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
     CORRADE_SKIP("No 3D texture compression format available on OpenGL ES 2.0.");
@@ -2670,7 +2701,7 @@ void TextureGLTest::compressedImage3D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_compression_bptc>())
         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>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_bptc>())
@@ -2679,25 +2710,25 @@ void TextureGLTest::compressedImage3D() {
 
     Texture3D texture;
     texture.setCompressedImage(0, CompressedImageView3D{
-        CompressedPixelStorage3DData[testCaseInstanceId()].storage,
+        data.storage,
         CompressedPixelFormat::RGBABptcUnorm, Vector3i{4},
-        CompressedPixelStorage3DData[testCaseInstanceId()].dataSparse});
+        data.dataSparse});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     /** @todo How to test this on ES? */
     #ifndef MAGNUM_TARGET_GLES
-    CompressedImage3D image = texture.compressedImage(0, {CompressedPixelStorage3DData[testCaseInstanceId()].storage});
+    CompressedImage3D image = texture.compressedImage(0, {data.storage});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.flags(), ImageFlags3D{});
     CORRADE_COMPARE(image.size(), Vector3i{4});
     {
-        CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa) && CompressedPixelStorage3DData[testCaseInstanceId()].storage != CompressedPixelStorage{},
+        CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa) && data.storage != CompressedPixelStorage{},
             "Mesa drivers can't handle non-default compressed 3D pixel storage.");
-        CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(CompressedPixelStorage3DData[testCaseInstanceId()].offset),
-            CompressedPixelStorage3DData[testCaseInstanceId()].data,
+        CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+            data.data,
             TestSuite::Compare::Container);
     }
     #endif
@@ -2706,12 +2737,13 @@ void TextureGLTest::compressedImage3D() {
 
 #ifndef MAGNUM_TARGET_GLES2
 void TextureGLTest::compressedImage3DBuffer() {
-    setTestCaseDescription(CompressedPixelStorage3DData[testCaseInstanceId()].name);
+    auto&& data = CompressedPixelStorage3DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_compression_bptc>())
         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>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_bptc>())
@@ -2720,26 +2752,26 @@ void TextureGLTest::compressedImage3DBuffer() {
 
     Texture3D texture;
     texture.setCompressedImage(0, CompressedBufferImage3D{
-        CompressedPixelStorage3DData[testCaseInstanceId()].storage,
+        data.storage,
         CompressedPixelFormat::RGBABptcUnorm, Vector3i{4},
-        CompressedPixelStorage3DData[testCaseInstanceId()].dataSparse,
+        data.dataSparse,
         BufferUsage::StaticDraw});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     /** @todo How to test this on ES? */
     #ifndef MAGNUM_TARGET_GLES
-    CompressedBufferImage3D image = texture.compressedImage(0, {CompressedPixelStorage3DData[testCaseInstanceId()].storage}, BufferUsage::StaticRead);
+    CompressedBufferImage3D image = texture.compressedImage(0, {data.storage}, BufferUsage::StaticRead);
     const auto imageData = image.buffer().data();
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE(image.size(), Vector3i{4});
     {
-        CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa) && CompressedPixelStorage3DData[testCaseInstanceId()].storage != CompressedPixelStorage{},
+        CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa) && data.storage != CompressedPixelStorage{},
             "Mesa drivers can't handle non-default compressed 3D pixel storage.");
-        CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(CompressedPixelStorage3DData[testCaseInstanceId()].offset),
-            CompressedPixelStorage3DData[testCaseInstanceId()].data,
+        CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(data.offset),
+            data.data,
             TestSuite::Compare::Container);
     }
     #endif
@@ -2748,23 +2780,24 @@ void TextureGLTest::compressedImage3DBuffer() {
 
 #ifndef MAGNUM_TARGET_GLES
 void TextureGLTest::compressedImage3DQueryView() {
-    setTestCaseDescription(CompressedPixelStorage3DData[testCaseInstanceId()].name);
+    auto&& data = CompressedPixelStorage3DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_compression_bptc>())
         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>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
 
     Texture3D texture;
     texture.setCompressedImage(0, CompressedImageView3D{
-        CompressedPixelStorage3DData[testCaseInstanceId()].storage,
+        data.storage,
         CompressedPixelFormat::RGBABptcUnorm, Vector3i{4},
-        CompressedPixelStorage3DData[testCaseInstanceId()].dataSparse});
+        data.dataSparse});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> data{CompressedPixelStorage2DData[testCaseInstanceId()].offset + 64};
-    MutableCompressedImageView3D image{CompressedPixelStorage2DData[testCaseInstanceId()].storage, CompressedPixelFormat::RGBABptcUnorm, Vector3i{4}, data, ImageFlag3D::Array};
+    Containers::Array<char> imageData{data.offset + 64};
+    MutableCompressedImageView3D image{data.storage, CompressedPixelFormat::RGBABptcUnorm, Vector3i{4}, imageData, ImageFlag3D::Array};
     texture.compressedImage(0, image);
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -2773,10 +2806,10 @@ void TextureGLTest::compressedImage3DQueryView() {
     CORRADE_COMPARE(image.flags(), ImageFlag3D::Array);
     CORRADE_COMPARE(image.size(), Vector3i{4});
     {
-        CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa) && CompressedPixelStorage3DData[testCaseInstanceId()].storage != CompressedPixelStorage{},
+        CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa) && data.storage != CompressedPixelStorage{},
             "Mesa drivers can't handle non-default compressed 3D pixel storage.");
-        CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(CompressedPixelStorage3DData[testCaseInstanceId()].offset),
-            CompressedPixelStorage3DData[testCaseInstanceId()].data,
+        CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+            data.data,
             TestSuite::Compare::Container);
     }
 }
@@ -2829,7 +2862,8 @@ constexpr UnsignedByte CompressedSubData3DComplete[]{
 #endif
 
 void TextureGLTest::compressedSubImage3D() {
-    setTestCaseDescription(CompressedPixelStorage3DData[testCaseInstanceId()].name);
+    auto&& data = CompressedPixelStorage3DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     #if defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
     CORRADE_SKIP("No 3D texture compression format available on OpenGL ES 2.0.");
@@ -2837,7 +2871,7 @@ void TextureGLTest::compressedSubImage3D() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_compression_bptc>())
         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>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_bptc>())
@@ -2847,9 +2881,9 @@ void TextureGLTest::compressedSubImage3D() {
     Texture3D texture;
     texture.setCompressedImage(0, CompressedImageView3D{CompressedPixelFormat::RGBABptcUnorm,
         {12, 4, 4}, CompressedZero3D});
-    texture.setCompressedSubImage(0, {4, 0, 0}, CompressedImageView3D{CompressedPixelStorage3DData[testCaseInstanceId()].storage,
+    texture.setCompressedSubImage(0, {4, 0, 0}, CompressedImageView3D{data.storage,
         CompressedPixelFormat::RGBABptcUnorm, Vector3i{4},
-        CompressedPixelStorage3DData[testCaseInstanceId()].dataSparse});
+        data.dataSparse});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
@@ -2862,7 +2896,7 @@ void TextureGLTest::compressedSubImage3D() {
     CORRADE_COMPARE(image.size(), (Vector3i{12, 4, 4}));
 
     {
-        CORRADE_EXPECT_FAIL_IF(CompressedPixelStorage3DData[testCaseInstanceId()].storage == CompressedPixelStorage{} && (Context::current().detectedDriver() & Context::DetectedDriver::NVidia),
+        CORRADE_EXPECT_FAIL_IF(data.storage == CompressedPixelStorage{} && (Context::current().detectedDriver() & Context::DetectedDriver::NVidia),
             "Default compressed pixel storage behaves weirdly with BPTC compression on NVidia.");
         CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa),
             "Mesa drivers can't handle compressed 3D pixel storage for subimages.");
@@ -2876,12 +2910,13 @@ void TextureGLTest::compressedSubImage3D() {
 
 #ifndef MAGNUM_TARGET_GLES2
 void TextureGLTest::compressedSubImage3DBuffer() {
-    setTestCaseDescription(CompressedPixelStorage3DData[testCaseInstanceId()].name);
+    auto&& data = CompressedPixelStorage3DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::texture_compression_bptc>())
         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>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
     #else
     if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_bptc>())
@@ -2891,9 +2926,9 @@ void TextureGLTest::compressedSubImage3DBuffer() {
     Texture3D texture;
     texture.setCompressedImage(0, CompressedImageView3D{CompressedPixelFormat::RGBABptcUnorm,
         {12, 4, 4}, CompressedZero3D});
-    texture.setCompressedSubImage(0, {4, 0, 0}, CompressedImageView3D{CompressedPixelStorage3DData[testCaseInstanceId()].storage,
+    texture.setCompressedSubImage(0, {4, 0, 0}, CompressedImageView3D{data.storage,
         CompressedPixelFormat::RGBABptcUnorm, Vector3i{4},
-        CompressedPixelStorage3DData[testCaseInstanceId()].dataSparse});
+        data.dataSparse});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
@@ -2907,7 +2942,7 @@ void TextureGLTest::compressedSubImage3DBuffer() {
     CORRADE_COMPARE(image.size(), (Vector3i{12, 4, 4}));
 
     {
-        CORRADE_EXPECT_FAIL_IF(CompressedPixelStorage3DData[testCaseInstanceId()].storage == CompressedPixelStorage{} && (Context::current().detectedDriver() & Context::DetectedDriver::NVidia),
+        CORRADE_EXPECT_FAIL_IF(data.storage == CompressedPixelStorage{} && (Context::current().detectedDriver() & Context::DetectedDriver::NVidia),
             "Default compressed pixel storage behaves weirdly with BPTC compression on NVidia.");
         CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa),
             "Mesa drivers can't handle compressed 3D pixel storage for subimages.");
@@ -2921,15 +2956,16 @@ void TextureGLTest::compressedSubImage3DBuffer() {
 
 #ifndef MAGNUM_TARGET_GLES
 void TextureGLTest::compressedSubImage3DQuery() {
-    setTestCaseDescription(CompressedPixelStorage3DData[testCaseInstanceId()].name);
+    auto&& data = CompressedPixelStorage3DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
         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() << "is not supported.");
-    if(CompressedPixelStorage3DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
-    if(CompressedPixelStorage3DData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
+    if(data.storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
         CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported.");
 
     Texture3D texture;
@@ -2939,7 +2975,7 @@ void TextureGLTest::compressedSubImage3DQuery() {
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CompressedImage3D image = texture.compressedSubImage(0, Range3Di::fromSize({4, 0, 0}, Vector3i{4}),
-        {CompressedPixelStorage3DData[testCaseInstanceId()].storage});
+        {data.storage});
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
@@ -2947,26 +2983,27 @@ void TextureGLTest::compressedSubImage3DQuery() {
     CORRADE_COMPARE(image.size(), (Vector3i{4}));
 
     {
-        CORRADE_EXPECT_FAIL_IF(CompressedPixelStorage3DData[testCaseInstanceId()].storage == CompressedPixelStorage{} && (Context::current().detectedDriver() & Context::DetectedDriver::NVidia),
+        CORRADE_EXPECT_FAIL_IF(data.storage == CompressedPixelStorage{} && (Context::current().detectedDriver() & Context::DetectedDriver::NVidia),
             "Default compressed pixel storage behaves weirdly with BPTC compression on NVidia.");
         CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa),
             "Mesa drivers can't handle compressed 3D pixel storage for subimages.");
-        CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(CompressedPixelStorage3DData[testCaseInstanceId()].offset),
-            CompressedPixelStorage3DData[testCaseInstanceId()].data,
+        CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+            data.data,
             TestSuite::Compare::Container);
     }
 }
 
 void TextureGLTest::compressedSubImage3DQueryView() {
-    setTestCaseDescription(CompressedPixelStorage3DData[testCaseInstanceId()].name);
+    auto&& data = CompressedPixelStorage3DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
         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() << "is not supported.");
-    if(CompressedPixelStorage3DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
-    if(CompressedPixelStorage3DData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
+    if(data.storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
         CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported.");
 
     Texture3D texture;
@@ -2975,8 +3012,8 @@ void TextureGLTest::compressedSubImage3DQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> data{CompressedPixelStorage2DData[testCaseInstanceId()].offset + 64};
-    MutableCompressedImageView3D image{CompressedPixelStorage2DData[testCaseInstanceId()].storage, CompressedPixelFormat::RGBABptcUnorm, Vector3i{4}, data, ImageFlag3D::Array};
+    Containers::Array<char> imageData{data.offset + 64};
+    MutableCompressedImageView3D image{data.storage, CompressedPixelFormat::RGBABptcUnorm, Vector3i{4}, imageData, ImageFlag3D::Array};
     texture.compressedSubImage(0, Range3Di::fromSize({4, 0, 0}, Vector3i{4}), image);
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -2986,26 +3023,27 @@ void TextureGLTest::compressedSubImage3DQueryView() {
     CORRADE_COMPARE(image.size(), (Vector3i{4}));
 
     {
-        CORRADE_EXPECT_FAIL_IF(CompressedPixelStorage3DData[testCaseInstanceId()].storage == CompressedPixelStorage{} && (Context::current().detectedDriver() & Context::DetectedDriver::NVidia),
+        CORRADE_EXPECT_FAIL_IF(data.storage == CompressedPixelStorage{} && (Context::current().detectedDriver() & Context::DetectedDriver::NVidia),
             "Default compressed pixel storage behaves weirdly with BPTC compression on NVidia.");
         CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa),
             "Mesa drivers can't handle compressed 3D pixel storage for subimages.");
-        CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(CompressedPixelStorage3DData[testCaseInstanceId()].offset),
-            CompressedPixelStorage3DData[testCaseInstanceId()].data,
+        CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
+            data.data,
             TestSuite::Compare::Container);
     }
 }
 
 void TextureGLTest::compressedSubImage3DQueryBuffer() {
-    setTestCaseDescription(CompressedPixelStorage3DData[testCaseInstanceId()].name);
+    auto&& data = CompressedPixelStorage3DData[testCaseInstanceId()];
+    setTestCaseDescription(data.name);
 
     if(!Context::current().isExtensionSupported<Extensions::ARB::get_texture_sub_image>())
         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() << "is not supported.");
-    if(CompressedPixelStorage3DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
+    if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
         CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
-    if(CompressedPixelStorage3DData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
+    if(data.storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
         CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported.");
 
     Texture3D texture;
@@ -3015,7 +3053,7 @@ void TextureGLTest::compressedSubImage3DQueryBuffer() {
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CompressedBufferImage3D image = texture.compressedSubImage(0, Range3Di::fromSize({4, 0, 0}, Vector3i{4}),
-        {CompressedPixelStorage3DData[testCaseInstanceId()].storage}, BufferUsage::StaticRead);
+        {data.storage}, BufferUsage::StaticRead);
     const auto imageData = image.buffer().data();
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -3023,12 +3061,12 @@ void TextureGLTest::compressedSubImage3DQueryBuffer() {
     CORRADE_COMPARE(image.size(), Vector3i{4});
 
     {
-        CORRADE_EXPECT_FAIL_IF(CompressedPixelStorage3DData[testCaseInstanceId()].storage == CompressedPixelStorage{} && (Context::current().detectedDriver() & Context::DetectedDriver::NVidia),
+        CORRADE_EXPECT_FAIL_IF(data.storage == CompressedPixelStorage{} && (Context::current().detectedDriver() & Context::DetectedDriver::NVidia),
             "Default compressed pixel storage behaves weirdly with BPTC compression on NVidia.");
         CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa),
             "Mesa drivers can't handle compressed 3D pixel storage for subimages.");
-        CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(CompressedPixelStorage3DData[testCaseInstanceId()].offset),
-            CompressedPixelStorage3DData[testCaseInstanceId()].data,
+        CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(data.offset),
+            data.data,
             TestSuite::Compare::Container);
     }
 }