// Copyright 2017 The Dawn Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include <gtest/gtest.h>

#include "common/Assert.h"
#include "common/Constants.h"
#include "common/Math.h"
#include "dawn/webgpu_cpp_print.h"
#include "dawn_native/Format.h"
#include "dawn_native/d3d12/TextureCopySplitter.h"
#include "dawn_native/d3d12/d3d12_platform.h"
#include "utils/TestUtils.h"

using namespace dawn::native::d3d12;

namespace {

    struct TextureSpec {
        uint32_t x;
        uint32_t y;
        uint32_t z;
        uint32_t width;
        uint32_t height;
        uint32_t depthOrArrayLayers;
        uint32_t texelBlockSizeInBytes;
        uint32_t blockWidth = 1;
        uint32_t blockHeight = 1;
    };

    struct BufferSpec {
        uint64_t offset;
        uint32_t bytesPerRow;
        uint32_t rowsPerImage;
    };

    // Check that each copy region fits inside the buffer footprint
    void ValidateFootprints(const TextureSpec& textureSpec,
                            const BufferSpec& bufferSpec,
                            const TextureCopySubresource& copySplit,
                            wgpu::TextureDimension dimension) {
        for (uint32_t i = 0; i < copySplit.count; ++i) {
            const auto& copy = copySplit.copies[i];
            ASSERT_LE(copy.bufferOffset.x + copy.copySize.width, copy.bufferSize.width);
            ASSERT_LE(copy.bufferOffset.y + copy.copySize.height, copy.bufferSize.height);
            ASSERT_LE(copy.bufferOffset.z + copy.copySize.depthOrArrayLayers,
                      copy.bufferSize.depthOrArrayLayers);

            // If there are multiple layers, 2D texture splitter actually splits each layer
            // independently. See the details in Compute2DTextureCopySplits(). As a result,
            // if we simply expand a copy region generated by 2D texture splitter to all
            // layers, the copy region might be OOB. But that is not the approach that the current
            // 2D texture splitter is doing, although Compute2DTextureCopySubresource forwards
            // "copySize.depthOrArrayLayers" to the copy region it generated. So skip the test
            // below for 2D textures with multiple layers.
            if (textureSpec.depthOrArrayLayers <= 1 || dimension == wgpu::TextureDimension::e3D) {
                uint32_t widthInBlocks = textureSpec.width / textureSpec.blockWidth;
                uint32_t heightInBlocks = textureSpec.height / textureSpec.blockHeight;
                uint64_t minimumRequiredBufferSize =
                    bufferSpec.offset +
                    utils::RequiredBytesInCopy(bufferSpec.bytesPerRow, bufferSpec.rowsPerImage,
                                               widthInBlocks, heightInBlocks,
                                               textureSpec.depthOrArrayLayers,
                                               textureSpec.texelBlockSizeInBytes);

                // The last pixel (buffer footprint) of each copy region depends on its bufferOffset
                // and copySize. It is not the last pixel where the bufferSize ends.
                ASSERT_EQ(copy.bufferOffset.x % textureSpec.blockWidth, 0u);
                ASSERT_EQ(copy.copySize.width % textureSpec.blockWidth, 0u);
                uint32_t footprintWidth = copy.bufferOffset.x + copy.copySize.width;
                ASSERT_EQ(footprintWidth % textureSpec.blockWidth, 0u);
                uint32_t footprintWidthInBlocks = footprintWidth / textureSpec.blockWidth;

                ASSERT_EQ(copy.bufferOffset.y % textureSpec.blockHeight, 0u);
                ASSERT_EQ(copy.copySize.height % textureSpec.blockHeight, 0u);
                uint32_t footprintHeight = copy.bufferOffset.y + copy.copySize.height;
                ASSERT_EQ(footprintHeight % textureSpec.blockHeight, 0u);
                uint32_t footprintHeightInBlocks = footprintHeight / textureSpec.blockHeight;

                uint64_t bufferSizeForFootprint =
                    copy.alignedOffset +
                    utils::RequiredBytesInCopy(bufferSpec.bytesPerRow, copy.bufferSize.height,
                                               footprintWidthInBlocks, footprintHeightInBlocks,
                                               copy.bufferSize.depthOrArrayLayers,
                                               textureSpec.texelBlockSizeInBytes);

                // The buffer footprint of each copy region should not exceed the minimum required
                // buffer size. Otherwise, pixels accessed by copy may be OOB.
                ASSERT_LE(bufferSizeForFootprint, minimumRequiredBufferSize);
            }
        }
    }

    // Check that the offset is aligned
    void ValidateOffset(const TextureCopySubresource& copySplit) {
        for (uint32_t i = 0; i < copySplit.count; ++i) {
            ASSERT_TRUE(
                Align(copySplit.copies[i].alignedOffset, D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT) ==
                copySplit.copies[i].alignedOffset);
        }
    }

    bool InclusiveRangesOverlap(uint32_t minA, uint32_t maxA, uint32_t minB, uint32_t maxB) {
        return (minA <= minB && minB <= maxA) || (minB <= minA && minA <= maxB);
    }

    // Check that no pair of copy regions intersect each other
    void ValidateDisjoint(const TextureCopySubresource& copySplit) {
        for (uint32_t i = 0; i < copySplit.count; ++i) {
            const auto& a = copySplit.copies[i];
            for (uint32_t j = i + 1; j < copySplit.count; ++j) {
                const auto& b = copySplit.copies[j];
                // If textureOffset.x is 0, and copySize.width is 2, we are copying pixel 0 and
                // 1. We never touch pixel 2 on x-axis. So the copied range on x-axis should be
                // [textureOffset.x, textureOffset.x + copySize.width - 1] and both ends are
                // included.
                bool overlapX = InclusiveRangesOverlap(
                    a.textureOffset.x, a.textureOffset.x + a.copySize.width - 1, b.textureOffset.x,
                    b.textureOffset.x + b.copySize.width - 1);
                bool overlapY = InclusiveRangesOverlap(
                    a.textureOffset.y, a.textureOffset.y + a.copySize.height - 1, b.textureOffset.y,
                    b.textureOffset.y + b.copySize.height - 1);
                bool overlapZ = InclusiveRangesOverlap(
                    a.textureOffset.z, a.textureOffset.z + a.copySize.depthOrArrayLayers - 1,
                    b.textureOffset.z, b.textureOffset.z + b.copySize.depthOrArrayLayers - 1);
                ASSERT_TRUE(!overlapX || !overlapY || !overlapZ);
            }
        }
    }

    // Check that the union of the copy regions exactly covers the texture region
    void ValidateTextureBounds(const TextureSpec& textureSpec,
                               const TextureCopySubresource& copySplit) {
        ASSERT_TRUE(copySplit.count > 0);

        uint32_t minX = copySplit.copies[0].textureOffset.x;
        uint32_t minY = copySplit.copies[0].textureOffset.y;
        uint32_t minZ = copySplit.copies[0].textureOffset.z;
        uint32_t maxX = copySplit.copies[0].textureOffset.x + copySplit.copies[0].copySize.width;
        uint32_t maxY = copySplit.copies[0].textureOffset.y + copySplit.copies[0].copySize.height;
        uint32_t maxZ =
            copySplit.copies[0].textureOffset.z + copySplit.copies[0].copySize.depthOrArrayLayers;

        for (uint32_t i = 1; i < copySplit.count; ++i) {
            const auto& copy = copySplit.copies[i];
            minX = std::min(minX, copy.textureOffset.x);
            minY = std::min(minY, copy.textureOffset.y);
            minZ = std::min(minZ, copy.textureOffset.z);
            maxX = std::max(maxX, copy.textureOffset.x + copy.copySize.width);
            maxY = std::max(maxY, copy.textureOffset.y + copy.copySize.height);
            maxZ = std::max(maxZ, copy.textureOffset.z + copy.copySize.depthOrArrayLayers);
        }

        ASSERT_EQ(minX, textureSpec.x);
        ASSERT_EQ(minY, textureSpec.y);
        ASSERT_EQ(minZ, textureSpec.z);
        ASSERT_EQ(maxX, textureSpec.x + textureSpec.width);
        ASSERT_EQ(maxY, textureSpec.y + textureSpec.height);
        ASSERT_EQ(maxZ, textureSpec.z + textureSpec.depthOrArrayLayers);
    }

    // Validate that the number of pixels copied is exactly equal to the number of pixels in the
    // texture region
    void ValidatePixelCount(const TextureSpec& textureSpec,
                            const TextureCopySubresource& copySplit) {
        uint32_t count = 0;
        for (uint32_t i = 0; i < copySplit.count; ++i) {
            const auto& copy = copySplit.copies[i];
            uint32_t copiedPixels =
                copy.copySize.width * copy.copySize.height * copy.copySize.depthOrArrayLayers;
            ASSERT_GT(copiedPixels, 0u);
            count += copiedPixels;
        }
        ASSERT_EQ(count, textureSpec.width * textureSpec.height * textureSpec.depthOrArrayLayers);
    }

    // Check that every buffer offset is at the correct pixel location
    void ValidateBufferOffset(const TextureSpec& textureSpec,
                              const BufferSpec& bufferSpec,
                              const TextureCopySubresource& copySplit,
                              wgpu::TextureDimension dimension) {
        ASSERT_TRUE(copySplit.count > 0);

        uint32_t texelsPerBlock = textureSpec.blockWidth * textureSpec.blockHeight;
        for (uint32_t i = 0; i < copySplit.count; ++i) {
            const auto& copy = copySplit.copies[i];

            uint32_t bytesPerRowInTexels =
                bufferSpec.bytesPerRow / textureSpec.texelBlockSizeInBytes * texelsPerBlock;
            uint32_t slicePitchInTexels =
                bytesPerRowInTexels * (bufferSpec.rowsPerImage / textureSpec.blockHeight);
            uint32_t absoluteTexelOffset =
                copy.alignedOffset / textureSpec.texelBlockSizeInBytes * texelsPerBlock +
                copy.bufferOffset.x / textureSpec.blockWidth * texelsPerBlock +
                copy.bufferOffset.y / textureSpec.blockHeight * bytesPerRowInTexels;

            // There is one empty row at most in a 2D copy region. However, it is not true for
            // a 3D texture copy region when we are copying the last row of each slice. We may
            // need to offset a lot rows and copy.bufferOffset.y may be big.
            if (dimension == wgpu::TextureDimension::e2D) {
                ASSERT_LE(copy.bufferOffset.y, textureSpec.blockHeight);
            }
            ASSERT_EQ(copy.bufferOffset.z, 0u);

            ASSERT_GE(absoluteTexelOffset,
                      bufferSpec.offset / textureSpec.texelBlockSizeInBytes * texelsPerBlock);
            uint32_t relativeTexelOffset =
                absoluteTexelOffset -
                bufferSpec.offset / textureSpec.texelBlockSizeInBytes * texelsPerBlock;

            uint32_t z = relativeTexelOffset / slicePitchInTexels;
            uint32_t y = (relativeTexelOffset % slicePitchInTexels) / bytesPerRowInTexels;
            uint32_t x = relativeTexelOffset % bytesPerRowInTexels;

            ASSERT_EQ(copy.textureOffset.x - textureSpec.x, x);
            ASSERT_EQ(copy.textureOffset.y - textureSpec.y, y);
            ASSERT_EQ(copy.textureOffset.z - textureSpec.z, z);
        }
    }

    void ValidateCopySplit(const TextureSpec& textureSpec,
                           const BufferSpec& bufferSpec,
                           const TextureCopySubresource& copySplit,
                           wgpu::TextureDimension dimension) {
        ValidateFootprints(textureSpec, bufferSpec, copySplit, dimension);
        ValidateOffset(copySplit);
        ValidateDisjoint(copySplit);
        ValidateTextureBounds(textureSpec, copySplit);
        ValidatePixelCount(textureSpec, copySplit);
        ValidateBufferOffset(textureSpec, bufferSpec, copySplit, dimension);
    }

    std::ostream& operator<<(std::ostream& os, const TextureSpec& textureSpec) {
        os << "TextureSpec("
           << "[(" << textureSpec.x << ", " << textureSpec.y << ", " << textureSpec.z << "), ("
           << textureSpec.width << ", " << textureSpec.height << ", "
           << textureSpec.depthOrArrayLayers << ")], " << textureSpec.texelBlockSizeInBytes << ")";
        return os;
    }

    std::ostream& operator<<(std::ostream& os, const BufferSpec& bufferSpec) {
        os << "BufferSpec(" << bufferSpec.offset << ", " << bufferSpec.bytesPerRow << ", "
           << bufferSpec.rowsPerImage << ")";
        return os;
    }

    std::ostream& operator<<(std::ostream& os, const TextureCopySubresource& copySplit) {
        os << "CopySplit" << std::endl;
        for (uint32_t i = 0; i < copySplit.count; ++i) {
            const auto& copy = copySplit.copies[i];
            os << "  " << i << ": Texture at (" << copy.textureOffset.x << ", "
               << copy.textureOffset.y << ", " << copy.textureOffset.z << "), size ("
               << copy.copySize.width << ", " << copy.copySize.height << ", "
               << copy.copySize.depthOrArrayLayers << ")" << std::endl;
            os << "  " << i << ": Buffer at (" << copy.bufferOffset.x << ", " << copy.bufferOffset.y
               << ", " << copy.bufferOffset.z << "), footprint (" << copy.bufferSize.width << ", "
               << copy.bufferSize.height << ", " << copy.bufferSize.depthOrArrayLayers << ")"
               << std::endl;
        }
        return os;
    }

    // Define base texture sizes and offsets to test with: some aligned, some unaligned
    constexpr TextureSpec kBaseTextureSpecs[] = {
        {0, 0, 0, 1, 1, 1, 4},
        {0, 0, 0, 64, 1, 1, 4},
        {0, 0, 0, 128, 1, 1, 4},
        {0, 0, 0, 192, 1, 1, 4},
        {31, 16, 0, 1, 1, 1, 4},
        {64, 16, 0, 1, 1, 1, 4},
        {64, 16, 8, 1, 1, 1, 4},

        {0, 0, 0, 64, 2, 1, 4},
        {0, 0, 0, 64, 1, 2, 4},
        {0, 0, 0, 64, 2, 2, 4},
        {0, 0, 0, 128, 2, 1, 4},
        {0, 0, 0, 128, 1, 2, 4},
        {0, 0, 0, 128, 2, 2, 4},
        {0, 0, 0, 192, 2, 1, 4},
        {0, 0, 0, 192, 1, 2, 4},
        {0, 0, 0, 192, 2, 2, 4},

        {0, 0, 0, 1024, 1024, 1, 4},
        {256, 512, 0, 1024, 1024, 1, 4},
        {64, 48, 0, 1024, 1024, 1, 4},
        {64, 48, 16, 1024, 1024, 1024, 4},

        {0, 0, 0, 257, 31, 1, 4},
        {0, 0, 0, 17, 93, 1, 4},
        {59, 13, 0, 257, 31, 1, 4},
        {17, 73, 0, 17, 93, 1, 4},
        {17, 73, 59, 17, 93, 99, 4},

        {0, 0, 0, 4, 4, 1, 8, 4, 4},
        {64, 16, 0, 4, 4, 1, 8, 4, 4},
        {64, 16, 8, 4, 4, 1, 8, 4, 4},
        {0, 0, 0, 4, 4, 1, 16, 4, 4},
        {64, 16, 0, 4, 4, 1, 16, 4, 4},
        {64, 16, 8, 4, 4, 1, 16, 4, 4},

        {0, 0, 0, 1024, 1024, 1, 8, 4, 4},
        {256, 512, 0, 1024, 1024, 1, 8, 4, 4},
        {64, 48, 0, 1024, 1024, 1, 8, 4, 4},
        {64, 48, 16, 1024, 1024, 1, 8, 4, 4},
        {0, 0, 0, 1024, 1024, 1, 16, 4, 4},
        {256, 512, 0, 1024, 1024, 1, 16, 4, 4},
        {64, 48, 0, 1024, 1024, 1, 4, 16, 4},
        {64, 48, 16, 1024, 1024, 1, 16, 4, 4},
    };

    // Define base buffer sizes to work with: some offsets aligned, some unaligned. bytesPerRow is
    // the minimum required
    std::array<BufferSpec, 15> BaseBufferSpecs(const TextureSpec& textureSpec) {
        uint32_t bytesPerRow = Align(textureSpec.texelBlockSizeInBytes * textureSpec.width,
                                     kTextureBytesPerRowAlignment);

        auto alignNonPow2 = [](uint32_t value, uint32_t size) -> uint32_t {
            return value == 0 ? 0 : ((value - 1) / size + 1) * size;
        };

        return {
            BufferSpec{alignNonPow2(0, textureSpec.texelBlockSizeInBytes), bytesPerRow,
                       textureSpec.height},
            BufferSpec{alignNonPow2(256, textureSpec.texelBlockSizeInBytes), bytesPerRow,
                       textureSpec.height},
            BufferSpec{alignNonPow2(512, textureSpec.texelBlockSizeInBytes), bytesPerRow,
                       textureSpec.height},
            BufferSpec{alignNonPow2(1024, textureSpec.texelBlockSizeInBytes), bytesPerRow,
                       textureSpec.height},
            BufferSpec{alignNonPow2(1024, textureSpec.texelBlockSizeInBytes), bytesPerRow,
                       textureSpec.height * 2},

            BufferSpec{alignNonPow2(32, textureSpec.texelBlockSizeInBytes), bytesPerRow,
                       textureSpec.height},
            BufferSpec{alignNonPow2(64, textureSpec.texelBlockSizeInBytes), bytesPerRow,
                       textureSpec.height},
            BufferSpec{alignNonPow2(64, textureSpec.texelBlockSizeInBytes), bytesPerRow,
                       textureSpec.height * 2},

            BufferSpec{alignNonPow2(31, textureSpec.texelBlockSizeInBytes), bytesPerRow,
                       textureSpec.height},
            BufferSpec{alignNonPow2(257, textureSpec.texelBlockSizeInBytes), bytesPerRow,
                       textureSpec.height},
            BufferSpec{alignNonPow2(384, textureSpec.texelBlockSizeInBytes), bytesPerRow,
                       textureSpec.height},
            BufferSpec{alignNonPow2(511, textureSpec.texelBlockSizeInBytes), bytesPerRow,
                       textureSpec.height},
            BufferSpec{alignNonPow2(513, textureSpec.texelBlockSizeInBytes), bytesPerRow,
                       textureSpec.height},
            BufferSpec{alignNonPow2(1023, textureSpec.texelBlockSizeInBytes), bytesPerRow,
                       textureSpec.height},
            BufferSpec{alignNonPow2(1023, textureSpec.texelBlockSizeInBytes), bytesPerRow,
                       textureSpec.height * 2},
        };
    }

    // Define a list of values to set properties in the spec structs
    constexpr uint32_t kCheckValues[] = {1,  2,  3,  4,   5,   6,   7,    8,     // small values
                                         16, 32, 64, 128, 256, 512, 1024, 2048,  // powers of 2
                                         15, 31, 63, 127, 257, 511, 1023, 2047,  // misalignments
                                         17, 33, 65, 129, 257, 513, 1025, 2049};

}  // namespace

class CopySplitTest : public testing::TestWithParam<wgpu::TextureDimension> {
  protected:
    void DoTest(const TextureSpec& textureSpec, const BufferSpec& bufferSpec) {
        ASSERT(textureSpec.width % textureSpec.blockWidth == 0 &&
               textureSpec.height % textureSpec.blockHeight == 0);

        wgpu::TextureDimension dimension = GetParam();
        TextureCopySubresource copySplit;
        switch (dimension) {
            case wgpu::TextureDimension::e2D: {
                copySplit = Compute2DTextureCopySubresource(
                    {textureSpec.x, textureSpec.y, textureSpec.z},
                    {textureSpec.width, textureSpec.height, textureSpec.depthOrArrayLayers},
                    {textureSpec.texelBlockSizeInBytes, textureSpec.blockWidth,
                     textureSpec.blockHeight},
                    bufferSpec.offset, bufferSpec.bytesPerRow);
                break;
            }
            case wgpu::TextureDimension::e3D: {
                copySplit = Compute3DTextureCopySplits(
                    {textureSpec.x, textureSpec.y, textureSpec.z},
                    {textureSpec.width, textureSpec.height, textureSpec.depthOrArrayLayers},
                    {textureSpec.texelBlockSizeInBytes, textureSpec.blockWidth,
                     textureSpec.blockHeight},
                    bufferSpec.offset, bufferSpec.bytesPerRow, bufferSpec.rowsPerImage);
                break;
            }
            default:
                UNREACHABLE();
                break;
        }

        ValidateCopySplit(textureSpec, bufferSpec, copySplit, dimension);

        if (HasFatalFailure()) {
            std::ostringstream message;
            message << "Failed generating splits: " << textureSpec << ", " << bufferSpec
                    << std::endl
                    << dimension << " " << copySplit << std::endl;
            FAIL() << message.str();
        }
    }
};

TEST_P(CopySplitTest, General) {
    for (TextureSpec textureSpec : kBaseTextureSpecs) {
        for (BufferSpec bufferSpec : BaseBufferSpecs(textureSpec)) {
            DoTest(textureSpec, bufferSpec);
        }
    }
}

TEST_P(CopySplitTest, TextureWidth) {
    for (TextureSpec textureSpec : kBaseTextureSpecs) {
        for (uint32_t val : kCheckValues) {
            if (val % textureSpec.blockWidth != 0) {
                continue;
            }
            textureSpec.width = val;
            for (BufferSpec bufferSpec : BaseBufferSpecs(textureSpec)) {
                DoTest(textureSpec, bufferSpec);
            }
        }
    }
}

TEST_P(CopySplitTest, TextureHeight) {
    for (TextureSpec textureSpec : kBaseTextureSpecs) {
        for (uint32_t val : kCheckValues) {
            if (val % textureSpec.blockHeight != 0) {
                continue;
            }
            textureSpec.height = val;
            for (BufferSpec bufferSpec : BaseBufferSpecs(textureSpec)) {
                DoTest(textureSpec, bufferSpec);
            }
        }
    }
}

TEST_P(CopySplitTest, TextureX) {
    for (TextureSpec textureSpec : kBaseTextureSpecs) {
        for (uint32_t val : kCheckValues) {
            textureSpec.x = val;
            for (BufferSpec bufferSpec : BaseBufferSpecs(textureSpec)) {
                DoTest(textureSpec, bufferSpec);
            }
        }
    }
}

TEST_P(CopySplitTest, TextureY) {
    for (TextureSpec textureSpec : kBaseTextureSpecs) {
        for (uint32_t val : kCheckValues) {
            textureSpec.y = val;
            for (BufferSpec bufferSpec : BaseBufferSpecs(textureSpec)) {
                DoTest(textureSpec, bufferSpec);
            }
        }
    }
}

TEST_P(CopySplitTest, TexelSize) {
    for (TextureSpec textureSpec : kBaseTextureSpecs) {
        for (uint32_t texelSize : {4, 8, 16, 32, 64}) {
            textureSpec.texelBlockSizeInBytes = texelSize;
            for (BufferSpec bufferSpec : BaseBufferSpecs(textureSpec)) {
                DoTest(textureSpec, bufferSpec);
            }
        }
    }
}

TEST_P(CopySplitTest, BufferOffset) {
    for (TextureSpec textureSpec : kBaseTextureSpecs) {
        for (BufferSpec bufferSpec : BaseBufferSpecs(textureSpec)) {
            for (uint32_t val : kCheckValues) {
                bufferSpec.offset = textureSpec.texelBlockSizeInBytes * val;

                DoTest(textureSpec, bufferSpec);
            }
        }
    }
}

TEST_P(CopySplitTest, RowPitch) {
    for (TextureSpec textureSpec : kBaseTextureSpecs) {
        for (BufferSpec bufferSpec : BaseBufferSpecs(textureSpec)) {
            uint32_t baseRowPitch = bufferSpec.bytesPerRow;
            for (uint32_t i = 0; i < 5; ++i) {
                bufferSpec.bytesPerRow = baseRowPitch + i * 256;

                DoTest(textureSpec, bufferSpec);
            }
        }
    }
}

TEST_P(CopySplitTest, ImageHeight) {
    for (TextureSpec textureSpec : kBaseTextureSpecs) {
        for (BufferSpec bufferSpec : BaseBufferSpecs(textureSpec)) {
            uint32_t baseImageHeight = bufferSpec.rowsPerImage;
            for (uint32_t i = 0; i < 5; ++i) {
                bufferSpec.rowsPerImage = baseImageHeight + i * 256;

                DoTest(textureSpec, bufferSpec);
            }
        }
    }
}

INSTANTIATE_TEST_SUITE_P(,
                         CopySplitTest,
                         testing::Values(wgpu::TextureDimension::e2D, wgpu::TextureDimension::e3D));