// Copyright 2018 The Dawn & Tint Authors
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice, this
//    list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice,
//    this list of conditions and the following disclaimer in the documentation
//    and/or other materials provided with the distribution.
//
// 3. Neither the name of the copyright holder nor the names of its
//    contributors may be used to endorse or promote products derived from
//    this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#include <array>
#include <vector>

#include "dawn/tests/unittests/validation/ValidationTest.h"
#include "dawn/utils/WGPUHelpers.h"

namespace dawn {
namespace {

class TextureViewValidationTest : public ValidationTest {};

constexpr uint32_t kWidth = 32u;
constexpr uint32_t kHeight = 32u;
constexpr uint32_t kDepth = 6u;
constexpr uint32_t kDefaultMipLevels = 6u;

constexpr wgpu::TextureFormat kDefaultTextureFormat = wgpu::TextureFormat::RGBA8Unorm;

wgpu::Texture Create2DArrayTexture(wgpu::Device& device,
                                   uint32_t arrayLayerCount,
                                   uint32_t width = kWidth,
                                   uint32_t height = kHeight,
                                   uint32_t mipLevelCount = kDefaultMipLevels,
                                   uint32_t sampleCount = 1) {
    wgpu::TextureDescriptor descriptor;
    descriptor.dimension = wgpu::TextureDimension::e2D;
    descriptor.size.width = width;
    descriptor.size.height = height;
    descriptor.size.depthOrArrayLayers = arrayLayerCount;
    descriptor.sampleCount = sampleCount;
    descriptor.format = kDefaultTextureFormat;
    descriptor.mipLevelCount = mipLevelCount;
    descriptor.usage = wgpu::TextureUsage::TextureBinding | wgpu::TextureUsage::RenderAttachment;
    return device.CreateTexture(&descriptor);
}

wgpu::Texture Create3DTexture(wgpu::Device& device) {
    wgpu::TextureDescriptor descriptor;
    descriptor.dimension = wgpu::TextureDimension::e3D;
    descriptor.size = {kWidth, kHeight, kDepth};
    descriptor.sampleCount = 1;
    descriptor.format = kDefaultTextureFormat;
    descriptor.mipLevelCount = kDefaultMipLevels;
    descriptor.usage = wgpu::TextureUsage::TextureBinding;
    return device.CreateTexture(&descriptor);
}

wgpu::Texture Create1DTexture(wgpu::Device& device) {
    wgpu::TextureDescriptor descriptor;
    descriptor.dimension = wgpu::TextureDimension::e1D;
    descriptor.size = {kWidth, 1, 1};
    descriptor.format = kDefaultTextureFormat;
    descriptor.usage = wgpu::TextureUsage::TextureBinding;
    return device.CreateTexture(&descriptor);
}

wgpu::Texture CreateDepthStencilTexture(wgpu::Device& device, wgpu::TextureFormat format) {
    wgpu::TextureDescriptor descriptor = {};
    descriptor.size = {kWidth, kHeight, kDepth};
    descriptor.usage = wgpu::TextureUsage::TextureBinding | wgpu::TextureUsage::RenderAttachment;
    descriptor.mipLevelCount = kDefaultMipLevels;
    descriptor.format = format;
    return device.CreateTexture(&descriptor);
}

wgpu::TextureViewDescriptor CreateDefaultViewDescriptor(wgpu::TextureViewDimension dimension) {
    wgpu::TextureViewDescriptor descriptor;
    descriptor.format = kDefaultTextureFormat;
    descriptor.dimension = dimension;
    descriptor.baseMipLevel = 0;
    if (dimension != wgpu::TextureViewDimension::e1D) {
        descriptor.mipLevelCount = kDefaultMipLevels;
    }
    descriptor.baseArrayLayer = 0;
    descriptor.arrayLayerCount = 1;
    return descriptor;
}

// Test creating texture view on a 2D non-array texture
TEST_F(TextureViewValidationTest, CreateTextureViewOnTexture2D) {
    wgpu::Texture texture = Create2DArrayTexture(device, 1);

    wgpu::TextureViewDescriptor base2DTextureViewDescriptor =
        CreateDefaultViewDescriptor(wgpu::TextureViewDimension::e2D);

    // It is an error to create a view with zero 'arrayLayerCount'.
    {
        wgpu::TextureViewDescriptor descriptor = base2DTextureViewDescriptor;
        descriptor.arrayLayerCount = 0;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
    }

    // It is an error to create a view with zero 'mipLevelCount'.
    {
        wgpu::TextureViewDescriptor descriptor = base2DTextureViewDescriptor;
        descriptor.mipLevelCount = 0;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
    }

    // It is OK to create a 2D texture view on a 2D texture.
    {
        wgpu::TextureViewDescriptor descriptor = base2DTextureViewDescriptor;
        descriptor.arrayLayerCount = 1;
        texture.CreateView(&descriptor);
    }

    // It is an error to view a layer past the end of the texture.
    {
        wgpu::TextureViewDescriptor descriptor = base2DTextureViewDescriptor;
        descriptor.arrayLayerCount = 2;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
    }

    // It is OK to create a 1-layer 2D array texture view on a 2D texture.
    {
        wgpu::TextureViewDescriptor descriptor = base2DTextureViewDescriptor;
        descriptor.dimension = wgpu::TextureViewDimension::e2DArray;
        descriptor.arrayLayerCount = 1;
        texture.CreateView(&descriptor);
    }

    // It is an error to create a 3D texture view on a 2D texture.
    {
        wgpu::TextureViewDescriptor descriptor = base2DTextureViewDescriptor;
        descriptor.dimension = wgpu::TextureViewDimension::e3D;
        descriptor.arrayLayerCount = 1;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
    }

    // baseMipLevel == k && mipLevelCount == WGPU_MIP_LEVEL_COUNT_UNDEFINED means to use levels
    // k..end.
    {
        wgpu::TextureViewDescriptor descriptor = base2DTextureViewDescriptor;
        descriptor.mipLevelCount = WGPU_MIP_LEVEL_COUNT_UNDEFINED;

        descriptor.baseMipLevel = 0;
        texture.CreateView(&descriptor);
        descriptor.baseMipLevel = 1;
        texture.CreateView(&descriptor);
        descriptor.baseMipLevel = kDefaultMipLevels - 1;
        texture.CreateView(&descriptor);
        descriptor.baseMipLevel = kDefaultMipLevels;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
    }

    // It is an error to make the mip level out of range.
    {
        wgpu::TextureViewDescriptor descriptor = base2DTextureViewDescriptor;
        descriptor.baseMipLevel = 0;
        descriptor.mipLevelCount = kDefaultMipLevels + 1;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
        descriptor.baseMipLevel = 1;
        descriptor.mipLevelCount = kDefaultMipLevels;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
        descriptor.baseMipLevel = kDefaultMipLevels - 1;
        descriptor.mipLevelCount = 2;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
        descriptor.baseMipLevel = kDefaultMipLevels;
        descriptor.mipLevelCount = 1;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
    }
}

// Test creating texture view on a 2D array texture
TEST_F(TextureViewValidationTest, CreateTextureViewOnTexture2DArray) {
    constexpr uint32_t kDefaultArrayLayers = 6;

    wgpu::Texture texture = Create2DArrayTexture(device, kDefaultArrayLayers);

    wgpu::TextureViewDescriptor base2DArrayTextureViewDescriptor =
        CreateDefaultViewDescriptor(wgpu::TextureViewDimension::e2DArray);

    // It is an error to create a view with zero 'arrayLayerCount'.
    {
        wgpu::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor;
        descriptor.dimension = wgpu::TextureViewDimension::e2D;
        descriptor.arrayLayerCount = 0;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
    }

    // It is an error to create a view with zero 'mipLevelCount'.
    {
        wgpu::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor;
        descriptor.dimension = wgpu::TextureViewDimension::e2D;
        descriptor.mipLevelCount = 0;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
    }

    // It is OK to create a 2D texture view on a 2D array texture.
    {
        wgpu::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor;
        descriptor.dimension = wgpu::TextureViewDimension::e2D;
        descriptor.arrayLayerCount = 1;
        texture.CreateView(&descriptor);
    }

    // It is OK to create a 2D array texture view on a 2D array texture.
    {
        wgpu::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor;
        descriptor.arrayLayerCount = kDefaultArrayLayers;
        texture.CreateView(&descriptor);
    }

    // It is an error to create a 3D texture view on a 2D array texture.
    {
        wgpu::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor;
        descriptor.dimension = wgpu::TextureViewDimension::e3D;
        descriptor.arrayLayerCount = 1;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
    }

    // It is an error to create a 1D texture view on a 2D array texture.
    {
        wgpu::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor;
        descriptor.dimension = wgpu::TextureViewDimension::e1D;
        descriptor.arrayLayerCount = 1;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
    }

    // baseArrayLayer == k && arrayLayerCount == wgpu::kArrayLayerCountUndefined means to use
    // layers k..end.
    {
        wgpu::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor;
        descriptor.arrayLayerCount = wgpu::kArrayLayerCountUndefined;

        descriptor.baseArrayLayer = 0;
        texture.CreateView(&descriptor);
        descriptor.baseArrayLayer = 1;
        texture.CreateView(&descriptor);
        descriptor.baseArrayLayer = kDefaultArrayLayers - 1;
        texture.CreateView(&descriptor);
        descriptor.baseArrayLayer = kDefaultArrayLayers;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
    }

    // It is an error for the array layer range of the view to exceed that of the texture.
    {
        wgpu::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor;
        descriptor.baseArrayLayer = 0;
        descriptor.arrayLayerCount = kDefaultArrayLayers + 1;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
        descriptor.baseArrayLayer = 1;
        descriptor.arrayLayerCount = kDefaultArrayLayers;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
        descriptor.baseArrayLayer = kDefaultArrayLayers - 1;
        descriptor.arrayLayerCount = 2;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
        descriptor.baseArrayLayer = kDefaultArrayLayers;
        descriptor.arrayLayerCount = 1;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
    }
}

// Test creating texture view on a 3D texture
TEST_F(TextureViewValidationTest, CreateTextureViewOnTexture3D) {
    wgpu::Texture texture = Create3DTexture(device);

    wgpu::TextureViewDescriptor base3DTextureViewDescriptor =
        CreateDefaultViewDescriptor(wgpu::TextureViewDimension::e3D);

    // It is an error to create a view with zero 'arrayLayerCount'.
    {
        wgpu::TextureViewDescriptor descriptor = base3DTextureViewDescriptor;
        descriptor.arrayLayerCount = 0;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
    }

    // It is an error to create a view with zero 'mipLevelCount'.
    {
        wgpu::TextureViewDescriptor descriptor = base3DTextureViewDescriptor;
        descriptor.mipLevelCount = 0;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
    }

    // It is OK to create a 3D texture view on a 3D texture.
    {
        wgpu::TextureViewDescriptor descriptor = base3DTextureViewDescriptor;
        texture.CreateView(&descriptor);
    }

    // It is an error to create a 1D/2D/2DArray/Cube/CubeArray texture view on a 3D texture.
    {
        wgpu::TextureViewDimension invalidDimensions[] = {
            wgpu::TextureViewDimension::e1D,       wgpu::TextureViewDimension::e2D,
            wgpu::TextureViewDimension::e2DArray,  wgpu::TextureViewDimension::Cube,
            wgpu::TextureViewDimension::CubeArray,
        };
        for (wgpu::TextureViewDimension dimension : invalidDimensions) {
            wgpu::TextureViewDescriptor descriptor = base3DTextureViewDescriptor;
            descriptor.dimension = dimension;
            if (dimension == wgpu::TextureViewDimension::Cube ||
                dimension == wgpu::TextureViewDimension::CubeArray) {
                descriptor.arrayLayerCount = 6;
            }
            ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
        }
    }

    // baseMipLevel == k && mipLevelCount == WGPU_MIP_LEVEL_COUNT_UNDEFINED means to use levels
    // k..end.
    {
        wgpu::TextureViewDescriptor descriptor = base3DTextureViewDescriptor;
        descriptor.mipLevelCount = WGPU_MIP_LEVEL_COUNT_UNDEFINED;

        descriptor.baseMipLevel = 0;
        texture.CreateView(&descriptor);
        descriptor.baseMipLevel = 1;
        texture.CreateView(&descriptor);
        descriptor.baseMipLevel = kDefaultMipLevels - 1;
        texture.CreateView(&descriptor);
        descriptor.baseMipLevel = kDefaultMipLevels;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
    }

    // It is an error to make the mip level out of range.
    {
        wgpu::TextureViewDescriptor descriptor = base3DTextureViewDescriptor;
        descriptor.baseMipLevel = 0;
        descriptor.mipLevelCount = kDefaultMipLevels + 1;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
        descriptor.baseMipLevel = 1;
        descriptor.mipLevelCount = kDefaultMipLevels;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
        descriptor.baseMipLevel = kDefaultMipLevels - 1;
        descriptor.mipLevelCount = 2;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
        descriptor.baseMipLevel = kDefaultMipLevels;
        descriptor.mipLevelCount = 1;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
    }

    // baseArrayLayer == k && arrayLayerCount == wgpu::kArrayLayerCountUndefined means to use
    // layers k..end. But baseArrayLayer must be 0, and arrayLayerCount must be 1 at most for 3D
    // texture view.
    {
        wgpu::TextureViewDescriptor descriptor = base3DTextureViewDescriptor;
        descriptor.arrayLayerCount = wgpu::kArrayLayerCountUndefined;
        descriptor.baseArrayLayer = 0;
        texture.CreateView(&descriptor);
        descriptor.baseArrayLayer = 1;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));

        descriptor.baseArrayLayer = 0;
        descriptor.arrayLayerCount = 1;
        texture.CreateView(&descriptor);
        descriptor.arrayLayerCount = 2;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
        descriptor.arrayLayerCount = kDepth;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
    }
}

// Test creating texture view on a 1D texture
TEST_F(TextureViewValidationTest, CreateTextureViewOnTexture1D) {
    wgpu::Texture texture = Create1DTexture(device);

    wgpu::TextureViewDescriptor base1DTextureViewDescriptor =
        CreateDefaultViewDescriptor(wgpu::TextureViewDimension::e1D);

    // It is an error to create a view with zero 'arrayLayerCount'.
    {
        wgpu::TextureViewDescriptor descriptor = base1DTextureViewDescriptor;
        descriptor.arrayLayerCount = 0;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
    }

    // It is an error to create a view with zero 'mipLevelCount'.
    {
        wgpu::TextureViewDescriptor descriptor = base1DTextureViewDescriptor;
        descriptor.mipLevelCount = 0;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
    }

    // It is OK to create a 1D texture view on a 1D texture.
    {
        wgpu::TextureViewDescriptor descriptor = base1DTextureViewDescriptor;
        texture.CreateView(&descriptor);
    }

    // It is an error to create a 2D/2DArray/Cube/CubeArray/3D texture view on a 1D texture.
    {
        wgpu::TextureViewDimension invalidDimensions[] = {
            wgpu::TextureViewDimension::e2D,  wgpu::TextureViewDimension::e2DArray,
            wgpu::TextureViewDimension::Cube, wgpu::TextureViewDimension::CubeArray,
            wgpu::TextureViewDimension::e3D,
        };
        for (wgpu::TextureViewDimension dimension : invalidDimensions) {
            wgpu::TextureViewDescriptor descriptor = base1DTextureViewDescriptor;
            descriptor.dimension = dimension;
            ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
        }
    }

    // No tests for setting mip levels / array layer ranges because 1D textures can only have
    // a single mip and layer.
}

// Test creating texture view on a multisampled 2D texture
TEST_F(TextureViewValidationTest, CreateTextureViewOnMultisampledTexture2D) {
    wgpu::Texture texture = Create2DArrayTexture(device, /* arrayLayerCount */ 1, kWidth, kHeight,
                                                 /* mipLevelCount */ 1, /* sampleCount */ 4);

    // It is OK to create a 2D texture view on a multisampled 2D texture.
    {
        wgpu::TextureViewDescriptor descriptor = {};
        texture.CreateView(&descriptor);
    }

    // It is an error to create a 1-layer 2D array texture view on a multisampled 2D texture.
    {
        wgpu::TextureViewDescriptor descriptor = {};
        descriptor.dimension = wgpu::TextureViewDimension::e2DArray;
        descriptor.arrayLayerCount = 1;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
    }

    // It is an error to create a 1D texture view on a multisampled 2D texture.
    {
        wgpu::TextureViewDescriptor descriptor = {};
        descriptor.dimension = wgpu::TextureViewDimension::e1D;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
    }

    // It is an error to create a 3D texture view on a multisampled 2D texture.
    {
        wgpu::TextureViewDescriptor descriptor = {};
        descriptor.dimension = wgpu::TextureViewDimension::e3D;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
    }
}

// Using the "none" ("default") values validates the same as explicitly
// specifying the values they're supposed to default to.
// Variant for a 2D texture with more than 1 array layer.
TEST_F(TextureViewValidationTest, TextureViewDescriptorDefaults2DArray) {
    constexpr uint32_t kDefaultArrayLayers = 8;
    wgpu::Texture texture = Create2DArrayTexture(device, kDefaultArrayLayers);

    { texture.CreateView(); }
    {
        wgpu::TextureViewDescriptor descriptor;
        descriptor.format = wgpu::TextureFormat::Undefined;
        texture.CreateView(&descriptor);
        descriptor.format = wgpu::TextureFormat::RGBA8Unorm;
        texture.CreateView(&descriptor);
        descriptor.format = wgpu::TextureFormat::R8Unorm;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
    }
    {
        wgpu::TextureViewDescriptor descriptor;
        descriptor.dimension = wgpu::TextureViewDimension::Undefined;
        texture.CreateView(&descriptor);
        descriptor.dimension = wgpu::TextureViewDimension::e2DArray;
        texture.CreateView(&descriptor);
        // Setting view dimension to 2D, its arrayLayer will default to 1. And view creation
        // will success.
        descriptor.dimension = wgpu::TextureViewDimension::e2D;
        texture.CreateView(&descriptor);
        // Setting view dimension to Cube, its arrayLayer will default to 6.
        descriptor.dimension = wgpu::TextureViewDimension::Cube;
        texture.CreateView(&descriptor);
        descriptor.baseArrayLayer = 2;
        texture.CreateView(&descriptor);
        descriptor.baseArrayLayer = 3;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
        // Setting view dimension to CubeArray, its arrayLayer will default to
        // size.depthOrArrayLayers (kDefaultArrayLayers) - baseArrayLayer.
        descriptor.dimension = wgpu::TextureViewDimension::CubeArray;
        descriptor.baseArrayLayer = 0;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
        descriptor.baseArrayLayer = 2;
        texture.CreateView(&descriptor);
        descriptor.baseArrayLayer = 3;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
    }
    {
        wgpu::TextureViewDescriptor descriptor;

        // Setting array layers to > 1 with an explicit dimensionality of 2D will
        // causes an error.
        descriptor.arrayLayerCount = kDefaultArrayLayers;
        descriptor.dimension = wgpu::TextureViewDimension::e2D;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
        // Setting view dimension to Undefined will result in a dimension of 2DArray because the
        // underlying texture has > 1 array layers.
        descriptor.dimension = wgpu::TextureViewDimension::Undefined;
        texture.CreateView(&descriptor);
        descriptor.dimension = wgpu::TextureViewDimension::e2DArray;
        texture.CreateView(&descriptor);

        descriptor.mipLevelCount = kDefaultMipLevels;
        texture.CreateView(&descriptor);
    }
}

// Using the "none" ("default") values validates the same as explicitly
// specifying the values they're supposed to default to.
// Variant for a 2D texture with only 1 array layer.
TEST_F(TextureViewValidationTest, TextureViewDescriptorDefaults2DNonArray) {
    constexpr uint32_t kDefaultArrayLayers = 1;
    wgpu::Texture texture = Create2DArrayTexture(device, kDefaultArrayLayers);

    { texture.CreateView(); }
    {
        wgpu::TextureViewDescriptor descriptor;
        descriptor.format = wgpu::TextureFormat::Undefined;
        texture.CreateView(&descriptor);
        descriptor.format = wgpu::TextureFormat::RGBA8Unorm;
        texture.CreateView(&descriptor);
        descriptor.format = wgpu::TextureFormat::R8Unorm;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
    }
    {
        wgpu::TextureViewDescriptor descriptor;
        descriptor.dimension = wgpu::TextureViewDimension::Undefined;
        texture.CreateView(&descriptor);
        descriptor.dimension = wgpu::TextureViewDimension::e2D;
        texture.CreateView(&descriptor);
        descriptor.dimension = wgpu::TextureViewDimension::e2DArray;
        texture.CreateView(&descriptor);
    }
    {
        wgpu::TextureViewDescriptor descriptor;
        descriptor.arrayLayerCount = wgpu::kArrayLayerCountUndefined;
        texture.CreateView(&descriptor);
        descriptor.arrayLayerCount = 1;
        texture.CreateView(&descriptor);
        descriptor.arrayLayerCount = 2;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
    }
    {
        wgpu::TextureViewDescriptor descriptor;
        descriptor.mipLevelCount = kDefaultMipLevels;
        texture.CreateView(&descriptor);
        descriptor.arrayLayerCount = kDefaultArrayLayers;
        texture.CreateView(&descriptor);
    }
}

// Using the "none" ("default") values validates the same as explicitly
// specifying the values they're supposed to default to.
// Variant for a 3D texture.
TEST_F(TextureViewValidationTest, TextureViewDescriptorDefaults3D) {
    wgpu::Texture texture = Create3DTexture(device);

    { texture.CreateView(); }
    {
        wgpu::TextureViewDescriptor descriptor;
        descriptor.format = wgpu::TextureFormat::Undefined;
        texture.CreateView(&descriptor);
        descriptor.format = wgpu::TextureFormat::RGBA8Unorm;
        texture.CreateView(&descriptor);
        descriptor.format = wgpu::TextureFormat::R8Unorm;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
    }
    {
        wgpu::TextureViewDescriptor descriptor;
        descriptor.dimension = wgpu::TextureViewDimension::Undefined;
        texture.CreateView(&descriptor);
        descriptor.dimension = wgpu::TextureViewDimension::e3D;
        texture.CreateView(&descriptor);
        descriptor.dimension = wgpu::TextureViewDimension::e2DArray;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
        descriptor.dimension = wgpu::TextureViewDimension::e2D;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
    }
    {
        wgpu::TextureViewDescriptor descriptor;
        descriptor.arrayLayerCount = wgpu::kArrayLayerCountUndefined;
        texture.CreateView(&descriptor);
        descriptor.arrayLayerCount = 1;
        texture.CreateView(&descriptor);
        descriptor.arrayLayerCount = 2;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
    }
    {
        wgpu::TextureViewDescriptor descriptor;
        descriptor.mipLevelCount = kDefaultMipLevels;
        texture.CreateView(&descriptor);
        descriptor.arrayLayerCount = kDepth;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
    }
}

// Regression test for crbug.com/1314049. Format default depends on the aspect.
// Test that computing the default does not crash if the aspect is invalid.
TEST_F(TextureViewValidationTest, TextureViewDescriptorDefaultsInvalidAspect) {
    wgpu::Texture texture =
        CreateDepthStencilTexture(device, wgpu::TextureFormat::Depth24PlusStencil8);

    wgpu::TextureViewDescriptor viewDesc = {};
    viewDesc.aspect = static_cast<wgpu::TextureAspect>(-1);

    // Validation should catch the invalid aspect.
    ASSERT_DEVICE_ERROR(texture.CreateView(&viewDesc),
                        testing::HasSubstr("is invalid for WGPUTextureAspect"));
}

// Test creating cube map texture view
TEST_F(TextureViewValidationTest, CreateCubeMapTextureView) {
    constexpr uint32_t kDefaultArrayLayers = 16;

    wgpu::Texture texture = Create2DArrayTexture(device, kDefaultArrayLayers);

    wgpu::TextureViewDescriptor base2DArrayTextureViewDescriptor =
        CreateDefaultViewDescriptor(wgpu::TextureViewDimension::e2DArray);

    // It is an error to create a view with zero 'arrayLayerCount'.
    {
        wgpu::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor;
        descriptor.dimension = wgpu::TextureViewDimension::Cube;
        descriptor.arrayLayerCount = 0;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
    }

    // It is an error to create a view with zero 'mipLevelCount'.
    {
        wgpu::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor;
        descriptor.dimension = wgpu::TextureViewDimension::Cube;
        descriptor.mipLevelCount = 0;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
    }

    // It is OK to create a cube map texture view with arrayLayerCount == 6.
    {
        wgpu::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor;
        descriptor.dimension = wgpu::TextureViewDimension::Cube;
        descriptor.arrayLayerCount = 6;
        texture.CreateView(&descriptor);
    }

    // It is an error to create a cube map texture view with arrayLayerCount != 6.
    {
        wgpu::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor;
        descriptor.dimension = wgpu::TextureViewDimension::Cube;
        descriptor.arrayLayerCount = 3;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
    }

    // It is OK to create a cube map array texture view with arrayLayerCount % 6 == 0.
    {
        wgpu::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor;
        descriptor.dimension = wgpu::TextureViewDimension::CubeArray;
        descriptor.arrayLayerCount = 12;
        texture.CreateView(&descriptor);
    }

    // It is an error to create a cube map array texture view with arrayLayerCount % 6 != 0.
    {
        wgpu::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor;
        descriptor.dimension = wgpu::TextureViewDimension::CubeArray;
        descriptor.arrayLayerCount = 11;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
    }

    // It is an error to create a cube map texture view with width != height.
    {
        wgpu::Texture nonSquareTexture = Create2DArrayTexture(device, 18, 32, 16, 5);

        wgpu::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor;
        descriptor.dimension = wgpu::TextureViewDimension::Cube;
        descriptor.arrayLayerCount = 6;
        ASSERT_DEVICE_ERROR(nonSquareTexture.CreateView(&descriptor));
    }

    // It is an error to create a cube map array texture view with width != height.
    {
        wgpu::Texture nonSquareTexture = Create2DArrayTexture(device, 18, 32, 16, 5);

        wgpu::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor;
        descriptor.dimension = wgpu::TextureViewDimension::CubeArray;
        descriptor.arrayLayerCount = 12;
        ASSERT_DEVICE_ERROR(nonSquareTexture.CreateView(&descriptor));
    }
}

// Test the format compatibility rules when creating a texture view.
TEST_F(TextureViewValidationTest, TextureViewFormatCompatibility) {
    wgpu::TextureDescriptor textureDesc = {};
    textureDesc.size.width = 4;
    textureDesc.size.height = 4;
    textureDesc.usage = wgpu::TextureUsage::TextureBinding;

    wgpu::TextureViewDescriptor viewDesc = {};

    // It is an error to create an sRGB texture view from an RGB texture, without viewFormats.
    {
        textureDesc.format = wgpu::TextureFormat::RGBA8Unorm;
        viewDesc.format = wgpu::TextureFormat::RGBA8UnormSrgb;
        wgpu::Texture texture = device.CreateTexture(&textureDesc);
        ASSERT_DEVICE_ERROR(texture.CreateView(&viewDesc));
    }

    // It is an error to create an RGB texture view from an sRGB texture, without viewFormats.
    {
        textureDesc.format = wgpu::TextureFormat::BGRA8UnormSrgb;
        viewDesc.format = wgpu::TextureFormat::BGRA8Unorm;
        wgpu::Texture texture = device.CreateTexture(&textureDesc);
        ASSERT_DEVICE_ERROR(texture.CreateView(&viewDesc));
    }

    // It is an error to create a texture view with a depth-stencil format of an RGBA texture.
    {
        textureDesc.format = wgpu::TextureFormat::RGBA8Unorm;
        viewDesc.format = wgpu::TextureFormat::Depth24PlusStencil8;
        wgpu::Texture texture = device.CreateTexture(&textureDesc);
        ASSERT_DEVICE_ERROR(texture.CreateView(&viewDesc));
    }

    // It is an error to create a texture view with a depth format of a depth-stencil texture.
    {
        textureDesc.format = wgpu::TextureFormat::Depth24PlusStencil8;
        viewDesc.format = wgpu::TextureFormat::Depth24Plus;
        wgpu::Texture texture = device.CreateTexture(&textureDesc);
        ASSERT_DEVICE_ERROR(texture.CreateView(&viewDesc));
    }

    // It is invalid to create a texture view with a combined depth-stencil format if only
    // the depth aspect is selected.
    {
        textureDesc.format = wgpu::TextureFormat::Depth24PlusStencil8;
        viewDesc.format = wgpu::TextureFormat::Depth24PlusStencil8;
        viewDesc.aspect = wgpu::TextureAspect::DepthOnly;
        wgpu::Texture texture = device.CreateTexture(&textureDesc);
        ASSERT_DEVICE_ERROR(texture.CreateView(&viewDesc));
    }

    // It is invalid to create a texture view with a combined depth-stencil format if only
    // the stencil aspect is selected.
    {
        textureDesc.format = wgpu::TextureFormat::Depth24PlusStencil8;
        viewDesc.format = wgpu::TextureFormat::Depth24PlusStencil8;
        viewDesc.aspect = wgpu::TextureAspect::StencilOnly;
        wgpu::Texture texture = device.CreateTexture(&textureDesc);
        ASSERT_DEVICE_ERROR(texture.CreateView(&viewDesc));
    }

    // It is valid to create a texture view with a depth format of a depth-stencil texture
    // if the depth only aspect is selected.
    {
        textureDesc.format = wgpu::TextureFormat::Depth24PlusStencil8;
        viewDesc.format = wgpu::TextureFormat::Depth24Plus;
        viewDesc.aspect = wgpu::TextureAspect::DepthOnly;
        wgpu::Texture texture = device.CreateTexture(&textureDesc);
        texture.CreateView(&viewDesc);

        viewDesc = {};
    }

    // Prep for testing a single view format in viewFormats.
    wgpu::TextureFormat viewFormat;
    textureDesc.viewFormats = &viewFormat;
    textureDesc.viewFormatCount = 1;

    // An aspect format is not a valid view format of a depth-stencil texture.
    {
        textureDesc.format = wgpu::TextureFormat::Depth24PlusStencil8;
        viewFormat = wgpu::TextureFormat::Depth24Plus;
        ASSERT_DEVICE_ERROR(device.CreateTexture(&textureDesc));
    }

    // Test that a RGBA texture can be viewed as both RGBA and RGBASrgb, but not BGRA or
    // BGRASrgb
    {
        textureDesc.format = wgpu::TextureFormat::RGBA8Unorm;
        viewFormat = wgpu::TextureFormat::RGBA8UnormSrgb;
        wgpu::Texture texture = device.CreateTexture(&textureDesc);

        viewDesc.format = wgpu::TextureFormat::RGBA8UnormSrgb;
        texture.CreateView(&viewDesc);

        viewDesc.format = wgpu::TextureFormat::RGBA8Unorm;
        texture.CreateView(&viewDesc);

        viewDesc.format = wgpu::TextureFormat::BGRA8Unorm;
        ASSERT_DEVICE_ERROR(texture.CreateView(&viewDesc));

        viewDesc.format = wgpu::TextureFormat::BGRA8UnormSrgb;
        ASSERT_DEVICE_ERROR(texture.CreateView(&viewDesc));
    }

    // Test that a BGRASrgb texture can be viewed as both BGRA and BGRASrgb, but not RGBA or
    // RGBASrgb
    {
        textureDesc.format = wgpu::TextureFormat::BGRA8UnormSrgb;
        viewFormat = wgpu::TextureFormat::BGRA8Unorm;
        wgpu::Texture texture = device.CreateTexture(&textureDesc);

        viewDesc.format = wgpu::TextureFormat::BGRA8Unorm;
        texture.CreateView(&viewDesc);

        viewDesc.format = wgpu::TextureFormat::BGRA8UnormSrgb;
        texture.CreateView(&viewDesc);

        viewDesc.format = wgpu::TextureFormat::RGBA8Unorm;
        ASSERT_DEVICE_ERROR(texture.CreateView(&viewDesc));

        viewDesc.format = wgpu::TextureFormat::RGBA8UnormSrgb;
        ASSERT_DEVICE_ERROR(texture.CreateView(&viewDesc));
    }

    // Test an RGBA format may be viewed as RGBA (same)
    {
        textureDesc.format = wgpu::TextureFormat::RGBA8Unorm;
        viewFormat = wgpu::TextureFormat::RGBA8Unorm;
        wgpu::Texture texture = device.CreateTexture(&textureDesc);

        viewDesc.format = wgpu::TextureFormat::RGBA8Unorm;
        texture.CreateView(&viewDesc);

        viewDesc.format = wgpu::TextureFormat::RGBA8UnormSrgb;
        ASSERT_DEVICE_ERROR(texture.CreateView(&viewDesc));
    }

    // Test that duplicate, and multiple view formats are allowed.
    {
        std::array<wgpu::TextureFormat, 5> viewFormats = {
            wgpu::TextureFormat::RGBA8UnormSrgb, wgpu::TextureFormat::RGBA8Unorm,
            wgpu::TextureFormat::RGBA8Unorm,     wgpu::TextureFormat::RGBA8UnormSrgb,
            wgpu::TextureFormat::RGBA8Unorm,
        };
        textureDesc.viewFormats = viewFormats.data();
        textureDesc.viewFormatCount = viewFormats.size();

        textureDesc.format = wgpu::TextureFormat::RGBA8Unorm;
        wgpu::Texture texture = device.CreateTexture(&textureDesc);

        viewDesc.format = wgpu::TextureFormat::RGBA8UnormSrgb;
        texture.CreateView(&viewDesc);

        viewDesc.format = wgpu::TextureFormat::RGBA8Unorm;
        texture.CreateView(&viewDesc);

        viewDesc.format = wgpu::TextureFormat::BGRA8Unorm;
        ASSERT_DEVICE_ERROR(texture.CreateView(&viewDesc));

        viewDesc.format = wgpu::TextureFormat::BGRA8UnormSrgb;
        ASSERT_DEVICE_ERROR(texture.CreateView(&viewDesc));
    }
}

// Test that it's valid to create a texture view from a destroyed texture
TEST_F(TextureViewValidationTest, DestroyCreateTextureView) {
    wgpu::Texture texture = Create2DArrayTexture(device, 1);
    wgpu::TextureViewDescriptor descriptor =
        CreateDefaultViewDescriptor(wgpu::TextureViewDimension::e2D);
    texture.Destroy();
    texture.CreateView(&descriptor);
}

// Test that the selected TextureAspects must exist in the texture format
TEST_F(TextureViewValidationTest, AspectMustExist) {
    wgpu::TextureDescriptor descriptor = {};
    descriptor.size = {1, 1, 1};
    descriptor.usage = wgpu::TextureUsage::TextureBinding | wgpu::TextureUsage::RenderAttachment;

    // Can select: All and DepthOnly from Depth32Float, but not StencilOnly
    {
        descriptor.format = wgpu::TextureFormat::Depth32Float;
        wgpu::Texture texture = device.CreateTexture(&descriptor);

        wgpu::TextureViewDescriptor viewDescriptor = {};
        viewDescriptor.aspect = wgpu::TextureAspect::All;
        texture.CreateView(&viewDescriptor);

        viewDescriptor.aspect = wgpu::TextureAspect::DepthOnly;
        texture.CreateView(&viewDescriptor);

        viewDescriptor.aspect = wgpu::TextureAspect::StencilOnly;
        ASSERT_DEVICE_ERROR(texture.CreateView(&viewDescriptor));
    }

    // Can select: All, DepthOnly, and StencilOnly from Depth24PlusStencil8
    {
        descriptor.format = wgpu::TextureFormat::Depth24PlusStencil8;
        wgpu::Texture texture = device.CreateTexture(&descriptor);

        wgpu::TextureViewDescriptor viewDescriptor = {};
        viewDescriptor.aspect = wgpu::TextureAspect::All;
        texture.CreateView(&viewDescriptor);

        viewDescriptor.aspect = wgpu::TextureAspect::DepthOnly;
        texture.CreateView(&viewDescriptor);

        viewDescriptor.aspect = wgpu::TextureAspect::StencilOnly;
        texture.CreateView(&viewDescriptor);
    }

    // Can select: All from RGBA8Unorm
    {
        descriptor.format = wgpu::TextureFormat::RGBA8Unorm;
        wgpu::Texture texture = device.CreateTexture(&descriptor);

        wgpu::TextureViewDescriptor viewDescriptor = {};
        viewDescriptor.aspect = wgpu::TextureAspect::All;
        texture.CreateView(&viewDescriptor);

        viewDescriptor.aspect = wgpu::TextureAspect::DepthOnly;
        ASSERT_DEVICE_ERROR(texture.CreateView(&viewDescriptor));

        viewDescriptor.aspect = wgpu::TextureAspect::StencilOnly;
        ASSERT_DEVICE_ERROR(texture.CreateView(&viewDescriptor));
    }
}

// Test that CreateErrorView creates an invalid texture view but doesn't produce an error.
TEST_F(TextureViewValidationTest, CreateErrorView) {
    wgpu::Texture texture = Create2DArrayTexture(device, 1);
    wgpu::TextureViewDescriptor descriptor =
        CreateDefaultViewDescriptor(wgpu::TextureViewDimension::e2D);

    // Creating the error texture view doesn't produce an error.
    wgpu::TextureView view = texture.CreateErrorView(&descriptor);

    // Using the error texture view will throw an error.
    wgpu::BindGroupLayout layout = utils::MakeBindGroupLayout(
        device, {{0, wgpu::ShaderStage::Fragment, wgpu::TextureSampleType::Float}});
    ASSERT_DEVICE_ERROR(utils::MakeBindGroup(device, layout, {{0, view}}));
}

// Tests that texture view usage is validated for the texture view format and is compatible with the
// source texture usages
TEST_F(TextureViewValidationTest, Usage) {
    wgpu::TextureFormat viewFormats[] = {wgpu::TextureFormat::RGBA8Unorm,
                                         wgpu::TextureFormat::RGBA8UnormSrgb};

    wgpu::TextureDescriptor textureDescriptor;
    textureDescriptor.dimension = wgpu::TextureDimension::e2D;
    textureDescriptor.size.width = kWidth;
    textureDescriptor.size.height = kHeight;
    textureDescriptor.sampleCount = 1;
    textureDescriptor.format = wgpu::TextureFormat::RGBA8Unorm;
    textureDescriptor.mipLevelCount = 1;
    textureDescriptor.usage = wgpu::TextureUsage::TextureBinding |
                              wgpu::TextureUsage::RenderAttachment |
                              wgpu::TextureUsage::StorageBinding;
    textureDescriptor.viewFormats = viewFormats;
    textureDescriptor.viewFormatCount = 2;
    wgpu::Texture texture = device.CreateTexture(&textureDescriptor);

    wgpu::TextureViewDescriptor base2DTextureViewDescriptor;
    base2DTextureViewDescriptor.format = kDefaultTextureFormat;
    base2DTextureViewDescriptor.dimension = wgpu::TextureViewDimension::e2D;
    base2DTextureViewDescriptor.baseMipLevel = 0;
    base2DTextureViewDescriptor.mipLevelCount = 1;
    base2DTextureViewDescriptor.baseArrayLayer = 0;
    base2DTextureViewDescriptor.arrayLayerCount = 1;

    // It is an error to request a usage outside of the source texture's usage
    {
        wgpu::TextureViewDescriptor descriptor = base2DTextureViewDescriptor;
        descriptor.usage |= wgpu::TextureUsage::CopyDst;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
    }

    // It is an error to create a view with RGBA8UnormSrgb and default usage which includes
    // StorageBinding
    {
        wgpu::TextureViewDescriptor descriptor = base2DTextureViewDescriptor;
        descriptor.format = wgpu::TextureFormat::RGBA8UnormSrgb;
        descriptor.usage = wgpu::TextureUsage::None;

        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
    }

    // A view can be created for RGBA8UnormSrgb with a compatible subset of usages
    {
        wgpu::TextureViewDescriptor descriptor = base2DTextureViewDescriptor;
        descriptor.format = wgpu::TextureFormat::RGBA8UnormSrgb;
        descriptor.usage =
            wgpu::TextureUsage::TextureBinding | wgpu::TextureUsage::RenderAttachment;
        texture.CreateView(&descriptor);
    }
}

// Test setting swizzle when creating a texture view requires feature.
TEST_F(TextureViewValidationTest, SwizzleRequiresFeature) {
    wgpu::TextureDescriptor textureDesc = {};
    textureDesc.size = {kWidth, kHeight, kDepth};
    textureDesc.usage = wgpu::TextureUsage::StorageBinding | wgpu::TextureUsage::RenderAttachment;
    textureDesc.format = kDefaultTextureFormat;
    wgpu::Texture texture = device.CreateTexture(&textureDesc);

    wgpu::TextureViewDescriptor viewDesc = {};
    wgpu::TextureComponentSwizzleDescriptor swizzleDesc = {};
    viewDesc.nextInChain = &swizzleDesc;
    ASSERT_DEVICE_ERROR(texture.CreateView(&viewDesc));
}

enum class SwizzleChannel { R, G, B, A };

class ComponentSwizzleTextureViewValidationTests : public ValidationTest {
  protected:
    std::vector<wgpu::FeatureName> GetRequiredFeatures() override {
        return {wgpu::FeatureName::TextureComponentSwizzle};
    }

    wgpu::TextureComponentSwizzleDescriptor GetIdenticalButOneSwizzleDesc(
        SwizzleChannel channel,
        std::optional<wgpu::ComponentSwizzle> swizzle = std::nullopt) {
        wgpu::TextureComponentSwizzleDescriptor desc = {};
        switch (channel) {
            case (SwizzleChannel::R): {
                desc.swizzle.r = swizzle.value_or(wgpu::ComponentSwizzle::Zero);
                break;
            }
            case (SwizzleChannel::G): {
                desc.swizzle.g = swizzle.value_or(wgpu::ComponentSwizzle::One);
                break;
            }
            case (SwizzleChannel::B): {
                desc.swizzle.b = swizzle.value_or(wgpu::ComponentSwizzle::R);
                break;
            }
            case (SwizzleChannel::A): {
                desc.swizzle.a = swizzle.value_or(wgpu::ComponentSwizzle::G);
                break;
            }
        }
        return desc;
    }
};

// Test setting invalid component swizzle when creating a texture view fails.
TEST_F(ComponentSwizzleTextureViewValidationTests, InvalidComponentSwizzle) {
    wgpu::TextureDescriptor textureDesc = {};
    textureDesc.size = {kWidth, kHeight, kDepth};
    textureDesc.usage = wgpu::TextureUsage::StorageBinding | wgpu::TextureUsage::RenderAttachment;
    textureDesc.format = kDefaultTextureFormat;
    wgpu::Texture texture = device.CreateTexture(&textureDesc);

    // Control case: identity swizzle
    wgpu::TextureViewDescriptor viewDesc = {};
    wgpu::TextureComponentSwizzleDescriptor swizzleDesc = {};
    viewDesc.nextInChain = &swizzleDesc;
    texture.CreateView(&viewDesc);

    // Invalid component swizzle for each channel
    for (auto changedChannel :
         {SwizzleChannel::R, SwizzleChannel::G, SwizzleChannel::B, SwizzleChannel::A}) {
        swizzleDesc =
            GetIdenticalButOneSwizzleDesc(changedChannel, static_cast<wgpu::ComponentSwizzle>(-1));
        ASSERT_DEVICE_ERROR(texture.CreateView(&viewDesc));
    }
}

// Test storage binding requires identity swizzle.
TEST_F(ComponentSwizzleTextureViewValidationTests, StorageBindingRequiresIdentitySwizzle) {
    wgpu::TextureDescriptor textureDesc = {};
    textureDesc.size = {kWidth, kHeight, 1};
    textureDesc.usage = wgpu::TextureUsage::StorageBinding;
    textureDesc.format = kDefaultTextureFormat;
    wgpu::Texture texture = device.CreateTexture(&textureDesc);

    wgpu::TextureViewDescriptor viewDesc = {};
    wgpu::TextureComponentSwizzleDescriptor swizzleDesc = {};
    viewDesc.nextInChain = &swizzleDesc;

    wgpu::ComputePipelineDescriptor cpDesc;
    cpDesc.compute.module = utils::CreateShaderModule(device, R"(
        @group(0) @binding(0) var texture : texture_storage_2d<rgba8unorm, read>;

        @compute @workgroup_size(1) fn main() {
          var res : vec4f = textureLoad(texture, vec2i(0, 0));
        })");
    wgpu::ComputePipeline cp = device.CreateComputePipeline(&cpDesc);

    // Control case: identity swizzle
    utils::MakeBindGroup(device, cp.GetBindGroupLayout(0), {{0, texture.CreateView(&viewDesc)}});

    // Non-identical swizzle cases
    for (auto changedChannel :
         {SwizzleChannel::R, SwizzleChannel::G, SwizzleChannel::B, SwizzleChannel::A}) {
        swizzleDesc = GetIdenticalButOneSwizzleDesc(changedChannel);
        ASSERT_DEVICE_ERROR(utils::MakeBindGroup(device, cp.GetBindGroupLayout(0),
                                                 {{0, texture.CreateView(&viewDesc)}}),
                            testing::HasSubstr("must be identity"));
    }
}

// Test color attachment requires identity swizzle.
TEST_F(ComponentSwizzleTextureViewValidationTests, ColorAttachmentRequiresIdentitySwizzle) {
    wgpu::Texture texture = Create2DArrayTexture(device, /*arrayLayerCount=*/1, kWidth, kHeight,
                                                 /*mipLevelCount=*/1);
    wgpu::TextureViewDescriptor viewDesc = {};
    wgpu::TextureComponentSwizzleDescriptor swizzleDesc = {};
    viewDesc.nextInChain = &swizzleDesc;

    // Control case: identity swizzle
    {
        utils::ComboRenderPassDescriptor renderPassDesc({texture.CreateView(&viewDesc)});
        wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder();
        wgpu::RenderPassEncoder renderPassEncoder = commandEncoder.BeginRenderPass(&renderPassDesc);
        renderPassEncoder.End();
        commandEncoder.Finish();
    }

    // Non-identical swizzle cases
    for (auto changedChannel :
         {SwizzleChannel::R, SwizzleChannel::G, SwizzleChannel::B, SwizzleChannel::A}) {
        swizzleDesc = GetIdenticalButOneSwizzleDesc(changedChannel);
        utils::ComboRenderPassDescriptor renderPassDesc({texture.CreateView(&viewDesc)});
        wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder();
        wgpu::RenderPassEncoder renderPassEncoder = commandEncoder.BeginRenderPass(&renderPassDesc);
        renderPassEncoder.End();
        ASSERT_DEVICE_ERROR(commandEncoder.Finish(),
                            testing::HasSubstr("The color attachment swizzle must be identity"));
    }
}

// Test resolve target requires identity swizzle.
TEST_F(ComponentSwizzleTextureViewValidationTests, ResolveTargetRequiresIdentitySwizzle) {
    wgpu::Texture texture = Create2DArrayTexture(device, /*arrayLayerCount=*/1, kWidth, kHeight,
                                                 /*mipLevelCount=*/1, /*sampleCount=*/4);
    wgpu::TextureView view = texture.CreateView();

    wgpu::Texture resolveTargetTexture =
        Create2DArrayTexture(device, /*arrayLayerCount=*/1, kWidth, kHeight,
                             /*mipLevelCount=*/1);
    wgpu::TextureViewDescriptor viewDesc = {};
    wgpu::TextureComponentSwizzleDescriptor swizzleDesc = {};
    viewDesc.nextInChain = &swizzleDesc;

    // Control case: identity swizzle
    {
        utils::ComboRenderPassDescriptor renderPassDesc({view});
        renderPassDesc.cColorAttachments[0].resolveTarget =
            resolveTargetTexture.CreateView(&viewDesc);
        wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder();
        wgpu::RenderPassEncoder renderPassEncoder = commandEncoder.BeginRenderPass(&renderPassDesc);
        renderPassEncoder.End();
        commandEncoder.Finish();
    }

    // Non-identical swizzle cases
    for (auto changedChannel :
         {SwizzleChannel::R, SwizzleChannel::G, SwizzleChannel::B, SwizzleChannel::A}) {
        swizzleDesc = GetIdenticalButOneSwizzleDesc(changedChannel);
        utils::ComboRenderPassDescriptor renderPassDesc({view});
        renderPassDesc.cColorAttachments[0].resolveTarget =
            resolveTargetTexture.CreateView(&viewDesc);
        wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder();
        wgpu::RenderPassEncoder renderPassEncoder = commandEncoder.BeginRenderPass(&renderPassDesc);
        renderPassEncoder.End();
        ASSERT_DEVICE_ERROR(commandEncoder.Finish(),
                            testing::HasSubstr("The resolve target swizzle must be identity"));
    }
}

// Test depth stencil attachment requires identity swizzle.
TEST_F(ComponentSwizzleTextureViewValidationTests, DepthStencilAttachmentRequiresIdentitySwizzle) {
    wgpu::Texture texture = Create2DArrayTexture(device, /*arrayLayerCount=*/1, kWidth, kHeight,
                                                 /*mipLevelCount=*/1);
    wgpu::TextureView view = texture.CreateView();

    wgpu::TextureDescriptor textureDesc = {};
    textureDesc.size = {kWidth, kHeight, 1};
    textureDesc.usage = wgpu::TextureUsage::RenderAttachment;
    textureDesc.format = wgpu::TextureFormat::Depth24PlusStencil8;
    wgpu::Texture depthStencilTexture = device.CreateTexture(&textureDesc);

    wgpu::TextureViewDescriptor viewDesc = {};
    viewDesc.aspect = wgpu::TextureAspect::All;
    wgpu::TextureComponentSwizzleDescriptor swizzleDesc = {};
    viewDesc.nextInChain = &swizzleDesc;

    // Control case: identity swizzle
    {
        utils::ComboRenderPassDescriptor renderPassDesc({view},
                                                        depthStencilTexture.CreateView(&viewDesc));
        wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder();
        wgpu::RenderPassEncoder renderPassEncoder = commandEncoder.BeginRenderPass(&renderPassDesc);
        renderPassEncoder.End();
        commandEncoder.Finish();
    }

    // Non-identical swizzle cases
    for (auto changedChannel :
         {SwizzleChannel::R, SwizzleChannel::G, SwizzleChannel::B, SwizzleChannel::A}) {
        swizzleDesc = GetIdenticalButOneSwizzleDesc(changedChannel);
        utils::ComboRenderPassDescriptor renderPassDesc({view},
                                                        depthStencilTexture.CreateView(&viewDesc));
        wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder();
        wgpu::RenderPassEncoder renderPassEncoder = commandEncoder.BeginRenderPass(&renderPassDesc);
        renderPassEncoder.End();
        ASSERT_DEVICE_ERROR(
            commandEncoder.Finish(),
            testing::HasSubstr("The depth stencil attachment swizzle must be identity"));
    }
}

class D32S8TextureViewValidationTests : public ValidationTest {
  protected:
    std::vector<wgpu::FeatureName> GetRequiredFeatures() override {
        return {wgpu::FeatureName::Depth32FloatStencil8};
    }
};

// Test that the selected TextureAspects must exist in the Depth32FloatStencil8 texture format
TEST_F(D32S8TextureViewValidationTests, AspectMustExist) {
    wgpu::Texture texture =
        CreateDepthStencilTexture(device, wgpu::TextureFormat::Depth32FloatStencil8);

    // Can select: All, DepthOnly, and StencilOnly from Depth32FloatStencil8
    {
        wgpu::TextureViewDescriptor viewDescriptor = {};
        viewDescriptor.aspect = wgpu::TextureAspect::All;
        texture.CreateView(&viewDescriptor);

        viewDescriptor.aspect = wgpu::TextureAspect::DepthOnly;
        texture.CreateView(&viewDescriptor);

        viewDescriptor.aspect = wgpu::TextureAspect::StencilOnly;
        texture.CreateView(&viewDescriptor);
    }
}

// Test the format compatibility rules when creating a texture view.
TEST_F(D32S8TextureViewValidationTests, TextureViewFormatCompatibility) {
    wgpu::Texture texture =
        CreateDepthStencilTexture(device, wgpu::TextureFormat::Depth32FloatStencil8);

    wgpu::TextureViewDescriptor base2DTextureViewDescriptor =
        CreateDefaultViewDescriptor(wgpu::TextureViewDimension::e2D);

    // It is an error to create a texture view in color format on a depth-stencil texture.
    {
        wgpu::TextureViewDescriptor descriptor = base2DTextureViewDescriptor;
        descriptor.format = wgpu::TextureFormat::RGBA8Unorm;
        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
    }
}

class TexelBufferViewValidationTest : public ValidationTest {
  protected:
    wgpu::Buffer CreateTexelBuffer(uint64_t size, wgpu::BufferUsage usage) {
        wgpu::BufferDescriptor desc;
        desc.size = size;
        desc.usage = usage;
        return device.CreateBuffer(&desc);
    }
};

// Valid texel buffer view creation
TEST_F(TexelBufferViewValidationTest, CreationSuccess) {
    constexpr uint64_t kSize = 4 * 4;  // 4 texels of RGBA8Uint
    wgpu::Buffer buffer =
        CreateTexelBuffer(kSize, wgpu::BufferUsage::TexelBuffer | wgpu::BufferUsage::CopySrc);

    wgpu::TexelBufferViewDescriptor viewDesc;
    viewDesc.format = wgpu::TextureFormat::RGBA8Uint;
    viewDesc.offset = 0;
    viewDesc.size = kSize;

    buffer.CreateTexelView(&viewDesc);
}

// Format must not be undefined
TEST_F(TexelBufferViewValidationTest, UndefinedFormat) {
    wgpu::Buffer buffer = CreateTexelBuffer(256, wgpu::BufferUsage::TexelBuffer);

    wgpu::TexelBufferViewDescriptor viewDesc;
    viewDesc.format = wgpu::TextureFormat::Undefined;
    viewDesc.offset = 0;
    viewDesc.size = 256;

    ASSERT_DEVICE_ERROR(buffer.CreateTexelView(&viewDesc));
}

// Offset must be aligned to the texel size
TEST_F(TexelBufferViewValidationTest, OffsetAlignment) {
    wgpu::Buffer buffer = CreateTexelBuffer(512, wgpu::BufferUsage::TexelBuffer);

    wgpu::TexelBufferViewDescriptor viewDesc;
    viewDesc.format = wgpu::TextureFormat::RGBA8Uint;
    viewDesc.offset = 2;  // Not aligned to 4-byte texel
    viewDesc.size = 256;

    ASSERT_DEVICE_ERROR(buffer.CreateTexelView(&viewDesc));
}

// Size must be multiple of texel size
TEST_F(TexelBufferViewValidationTest, SizeMustBeMultipleOfTexel) {
    wgpu::Buffer buffer = CreateTexelBuffer(512, wgpu::BufferUsage::TexelBuffer);

    wgpu::TexelBufferViewDescriptor viewDesc;
    viewDesc.format = wgpu::TextureFormat::RGBA8Uint;
    viewDesc.offset = 256;
    viewDesc.size = 3;  // Not multiple of 4-byte texel

    ASSERT_DEVICE_ERROR(buffer.CreateTexelView(&viewDesc));
}

// Range may not exceed buffer size
TEST_F(TexelBufferViewValidationTest, RangeExceedsBuffer) {
    wgpu::Buffer buffer = CreateTexelBuffer(256, wgpu::BufferUsage::TexelBuffer);

    wgpu::TexelBufferViewDescriptor viewDesc;
    viewDesc.format = wgpu::TextureFormat::RGBA8Uint;
    viewDesc.offset = 0;
    viewDesc.size = 512;  // Larger than buffer

    ASSERT_DEVICE_ERROR(buffer.CreateTexelView(&viewDesc));
}

// Depth formats are not allowed
TEST_F(TexelBufferViewValidationTest, DepthFormatNotAllowed) {
    wgpu::Buffer buffer = CreateTexelBuffer(256, wgpu::BufferUsage::TexelBuffer);

    wgpu::TexelBufferViewDescriptor viewDesc;
    viewDesc.format = wgpu::TextureFormat::Depth24Plus;
    viewDesc.offset = 0;
    viewDesc.size = 256;

    ASSERT_DEVICE_ERROR(buffer.CreateTexelView(&viewDesc));
}

// R32Float is allowed
TEST_F(TexelBufferViewValidationTest, R32FloatAllowed) {
    wgpu::Buffer buffer = CreateTexelBuffer(256, wgpu::BufferUsage::TexelBuffer);

    wgpu::TexelBufferViewDescriptor viewDesc;
    viewDesc.format = wgpu::TextureFormat::R32Float;
    viewDesc.offset = 0;
    viewDesc.size = 256;

    buffer.CreateTexelView(&viewDesc);
}

// RG8Uint is not a supported texel format
TEST_F(TexelBufferViewValidationTest, ColorFormatNotAllowed) {
    wgpu::Buffer buffer = CreateTexelBuffer(256, wgpu::BufferUsage::TexelBuffer);

    wgpu::TexelBufferViewDescriptor viewDesc;
    viewDesc.format = wgpu::TextureFormat::RG8Uint;
    viewDesc.offset = 0;
    viewDesc.size = 256;

    ASSERT_DEVICE_ERROR(buffer.CreateTexelView(&viewDesc));
}

}  // anonymous namespace
}  // namespace dawn