src/tests/end2end/DeprecatedAPITests.cpp - dawn - Git at Google


            
            // Copyright 2020 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.


            // This file contains test for deprecated parts of Dawn's API while following WebGPU's evolution.

            
            // It contains test for the "old" behavior that will be deleted once users are migrated, tests that

            
            // a deprecation warning is emitted when the "old" behavior is used, and tests that an error is

            
            // emitted when both the old and the new behavior are used (when applicable).


            #include "tests/DawnTest.h"


            #include "common/Constants.h"

            
            #include "common/VertexFormatUtils.h"

            
            #include "utils/ComboRenderPipelineDescriptor.h"

            
            #include "utils/WGPUHelpers.h"


            #include <cmath>


            class DeprecationTests : public DawnTest {

            
              protected:

            
                void SetUp() override {

            
                    DawnTest::SetUp();

            
                    // Skip when validation is off because warnings might be emitted during validation calls

            
                    DAWN_TEST_UNSUPPORTED_IF(HasToggleEnabled("skip_validation"));

            
                }

            
            };


            // Test that SetBlendColor is deprecated.

            
            TEST_P(DeprecationTests, SetSetBlendColor) {

            
                wgpu::Color blendColor{1.0, 0.0, 0.0, 1.0};


                utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, 1, 1);


                wgpu::CommandEncoder encoder = device.CreateCommandEncoder();

            
                wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass.renderPassInfo);

            
                EXPECT_DEPRECATION_WARNING(pass.SetBlendColor(&blendColor));

            
                pass.EndPass();

            
            }


            // Test that setting attachment rather than view for render pass color and depth/stencil attachments

            
            // is deprecated.

            
            TEST_P(DeprecationTests, SetAttachmentDescriptorAttachment) {

            
                utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, 1, 1);

            
                wgpu::CommandEncoder encoder = device.CreateCommandEncoder();

            
                wgpu::RenderPassEncoder pass;


                // Check that using .attachment with color attachments gives the warning.

            
                wgpu::RenderPassColorAttachmentDescriptor* colorAttachment =

            
                    &renderPass.renderPassInfo.cColorAttachments[0];

            
                colorAttachment->attachment = colorAttachment->view;

            
                colorAttachment->view = nullptr;


                EXPECT_DEPRECATION_WARNING(pass = encoder.BeginRenderPass(&renderPass.renderPassInfo));

            
                pass.EndPass();


                colorAttachment->view = colorAttachment->attachment;

            
                colorAttachment->attachment = nullptr;


                // Check that using .attachment with depth/stencil attachments gives the warning.

            
                wgpu::TextureDescriptor descriptor;

            
                descriptor.dimension = wgpu::TextureDimension::e2D;

            
                descriptor.size = {1, 1, 1};

            
                descriptor.sampleCount = 1;

            
                descriptor.format = wgpu::TextureFormat::Depth24PlusStencil8;

            
                descriptor.mipLevelCount = 1;

            
                descriptor.usage = wgpu::TextureUsage::RenderAttachment;

            
                wgpu::Texture depthStencil = device.CreateTexture(&descriptor);


                wgpu::RenderPassDepthStencilAttachmentDescriptor* depthAttachment =

            
                    &renderPass.renderPassInfo.cDepthStencilAttachmentInfo;

            
                renderPass.renderPassInfo.depthStencilAttachment = depthAttachment;

            
                depthAttachment->attachment = depthStencil.CreateView();


                EXPECT_DEPRECATION_WARNING(pass = encoder.BeginRenderPass(&renderPass.renderPassInfo));

            
                pass.EndPass();

            
            }


            // Test that setting computeStage in a ComputePipelineDescriptor is deprecated.

            
            TEST_P(DeprecationTests, ComputeStage) {

            
                wgpu::ComputePipelineDescriptor csDesc;

            
                csDesc.computeStage.module = utils::CreateShaderModule(device, R"(

            
                    [[stage(compute), workgroup_size(1)]] fn main() {

            
                    })");

            
                csDesc.computeStage.entryPoint = "main";


                wgpu::ComputePipeline pipeline;

            
                EXPECT_DEPRECATION_WARNING(pipeline = device.CreateComputePipeline(&csDesc));

            
            }


            // Test that StoreOp::Clear is deprecated.

            
            TEST_P(DeprecationTests, StoreOpClear) {

            
                utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, 1, 1);

            
                wgpu::CommandEncoder encoder = device.CreateCommandEncoder();

            
                wgpu::RenderPassEncoder pass;


                // Check that a storeOp of Clear for color attachments raises a validation warning.

            
                renderPass.renderPassInfo.cColorAttachments[0].storeOp = wgpu::StoreOp::Clear;


                EXPECT_DEPRECATION_WARNING(pass = encoder.BeginRenderPass(&renderPass.renderPassInfo));

            
                pass.EndPass();


                // Check that a storeOp of Clear for depth/stencil attachments raises a validation warning.

            
                wgpu::TextureDescriptor descriptor;

            
                descriptor.dimension = wgpu::TextureDimension::e2D;

            
                descriptor.size = {1, 1, 1};

            
                descriptor.sampleCount = 1;

            
                descriptor.format = wgpu::TextureFormat::Depth24PlusStencil8;

            
                descriptor.mipLevelCount = 1;

            
                descriptor.usage = wgpu::TextureUsage::RenderAttachment;

            
                wgpu::Texture depthStencil = device.CreateTexture(&descriptor);


                wgpu::RenderPassDepthStencilAttachmentDescriptor* depthAttachment =

            
                    &renderPass.renderPassInfo.cDepthStencilAttachmentInfo;

            
                renderPass.renderPassInfo.depthStencilAttachment = depthAttachment;

            
                depthAttachment->view = depthStencil.CreateView();


                renderPass.renderPassInfo.cColorAttachments[0].storeOp = wgpu::StoreOp::Discard;

            
                depthAttachment->depthStoreOp = wgpu::StoreOp::Clear;


                EXPECT_DEPRECATION_WARNING(pass = encoder.BeginRenderPass(&renderPass.renderPassInfo));

            
                pass.EndPass();


                depthAttachment->depthStoreOp = wgpu::StoreOp::Discard;

            
                depthAttachment->stencilStoreOp = wgpu::StoreOp::Clear;


                EXPECT_DEPRECATION_WARNING(pass = encoder.BeginRenderPass(&renderPass.renderPassInfo));

            
                pass.EndPass();

            
            }


            DAWN_INSTANTIATE_TEST(DeprecationTests,

            
                                  D3D12Backend(),

            
                                  MetalBackend(),

            
                                  NullBackend(),

            
                                  OpenGLBackend(),

            
                                  OpenGLESBackend(),

            
                                  VulkanBackend());


            class ImageCopyBufferDeprecationTests : public DeprecationTests {

            
              protected:

            
                wgpu::ImageCopyTexture MakeImageCopyTexture() {

            
                    wgpu::TextureDescriptor desc = {};

            
                    desc.usage = wgpu::TextureUsage::CopySrc | wgpu::TextureUsage::CopyDst;

            
                    desc.dimension = wgpu::TextureDimension::e2D;

            
                    desc.size = {1, 1, 2};

            
                    desc.format = wgpu::TextureFormat::RGBA8Unorm;


                    wgpu::ImageCopyTexture copy;

            
                    copy.texture = device.CreateTexture(&desc);

            
                    copy.origin = {0, 0, 1};

            
                    return copy;

            
                }


                wgpu::Extent3D copySize = {1, 1, 1};

            
            };


            // Tests that deprecated blend factors properly raise a deprecation warning when used

            
            class BlendFactorDeprecationTests : public DeprecationTests {

            
              protected:

            
                // Runs the test

            
                void DoTest(const wgpu::BlendFactor blendFactor, bool deprecated) {

            
                    wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(

            
                            [[stage(vertex)]] fn main() -> [[builtin(position)]] vec4<f32> {

            
                                return vec4<f32>(0.0, 0.0, 0.0, 1.0);

            
                            }

            
                        )");

            
                    wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(

            
                            [[stage(fragment)]] fn main() -> [[location(0)]] vec4<f32> {

            
                                return vec4<f32>(1.0, 1.0, 1.0, 1.0);

            
                            }

            
                        )");


                    utils::ComboRenderPipelineDescriptor descriptor;

            
                    descriptor.vertex.module = vsModule;

            
                    descriptor.cFragment.module = fsModule;

            
                    descriptor.cTargets[0].blend = &descriptor.cBlends[0];


                    descriptor.cBlends[0].color.srcFactor = blendFactor;

            
                    if (deprecated) {

            
                        EXPECT_DEPRECATION_WARNING(device.CreateRenderPipeline(&descriptor));

            
                    } else {

            
                        device.CreateRenderPipeline(&descriptor);

            
                    }

            
                    descriptor.cBlends[0].color.srcFactor = wgpu::BlendFactor::One;


                    descriptor.cBlends[0].color.dstFactor = blendFactor;

            
                    if (deprecated) {

            
                        EXPECT_DEPRECATION_WARNING(device.CreateRenderPipeline(&descriptor));

            
                    } else {

            
                        device.CreateRenderPipeline(&descriptor);

            
                    }

            
                    descriptor.cBlends[0].color.dstFactor = wgpu::BlendFactor::Zero;


                    descriptor.cBlends[0].alpha.srcFactor = blendFactor;

            
                    if (deprecated) {

            
                        EXPECT_DEPRECATION_WARNING(device.CreateRenderPipeline(&descriptor));

            
                    } else {

            
                        device.CreateRenderPipeline(&descriptor);

            
                    }

            
                    descriptor.cBlends[0].alpha.srcFactor = wgpu::BlendFactor::One;


                    descriptor.cBlends[0].alpha.dstFactor = blendFactor;

            
                    if (deprecated) {

            
                        EXPECT_DEPRECATION_WARNING(device.CreateRenderPipeline(&descriptor));

            
                    } else {

            
                        device.CreateRenderPipeline(&descriptor);

            
                    }

            
                    descriptor.cBlends[0].alpha.dstFactor = wgpu::BlendFactor::Zero;

            
                }

            
            };


            static constexpr std::array<wgpu::BlendFactor, 13> kBlendFactors = {

            
                wgpu::BlendFactor::Zero,

            
                wgpu::BlendFactor::One,

            
                wgpu::BlendFactor::Src,

            
                wgpu::BlendFactor::OneMinusSrc,

            
                wgpu::BlendFactor::SrcAlpha,

            
                wgpu::BlendFactor::OneMinusSrcAlpha,

            
                wgpu::BlendFactor::Dst,

            
                wgpu::BlendFactor::OneMinusDst,

            
                wgpu::BlendFactor::DstAlpha,

            
                wgpu::BlendFactor::OneMinusDstAlpha,

            
                wgpu::BlendFactor::SrcAlphaSaturated,

            
                wgpu::BlendFactor::Constant,

            
                wgpu::BlendFactor::OneMinusConstant,

            
            };


            TEST_P(BlendFactorDeprecationTests, CurrentBlendFactors) {

            
                // Using the new blend factors does not emit a warning.

            
                for (auto& format : kBlendFactors) {

            
                    DoTest(format, false);

            
                }

            
            }


            static constexpr std::array<wgpu::BlendFactor, 6> kDeprecatedBlendFactors = {

            
                wgpu::BlendFactor::SrcColor,   wgpu::BlendFactor::OneMinusSrcColor,

            
                wgpu::BlendFactor::DstColor,   wgpu::BlendFactor::OneMinusDstColor,

            
                wgpu::BlendFactor::BlendColor, wgpu::BlendFactor::OneMinusBlendColor,

            
            };


            TEST_P(BlendFactorDeprecationTests, DeprecatedBlendFactors) {

            
                // Using deprecated blend factors does emit a warning.

            
                for (auto& format : kDeprecatedBlendFactors) {

            
                    DoTest(format, true);

            
                }

            
            }


            DAWN_INSTANTIATE_TEST(BlendFactorDeprecationTests,

            
                                  D3D12Backend(),

            
                                  MetalBackend(),

            
                                  NullBackend(),

            
                                  OpenGLBackend(),

            
                                  OpenGLESBackend(),

            
                                  VulkanBackend());
	// Copyright 2020 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.

	// This file contains test for deprecated parts of Dawn's API while following WebGPU's evolution.
	// It contains test for the "old" behavior that will be deleted once users are migrated, tests that
	// a deprecation warning is emitted when the "old" behavior is used, and tests that an error is
	// emitted when both the old and the new behavior are used (when applicable).

	#include "tests/DawnTest.h"

	#include "common/Constants.h"
	#include "common/VertexFormatUtils.h"
	#include "utils/ComboRenderPipelineDescriptor.h"
	#include "utils/WGPUHelpers.h"

	#include <cmath>

	class DeprecationTests : public DawnTest {
	protected:
	void SetUp() override {
	DawnTest::SetUp();
	// Skip when validation is off because warnings might be emitted during validation calls
	DAWN_TEST_UNSUPPORTED_IF(HasToggleEnabled("skip_validation"));
	}
	};

	// Test that SetBlendColor is deprecated.
	TEST_P(DeprecationTests, SetSetBlendColor) {
	wgpu::Color blendColor{1.0, 0.0, 0.0, 1.0};

	utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, 1, 1);

	wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
	wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass.renderPassInfo);
	EXPECT_DEPRECATION_WARNING(pass.SetBlendColor(&blendColor));
	pass.EndPass();
	}

	// Test that setting attachment rather than view for render pass color and depth/stencil attachments
	// is deprecated.
	TEST_P(DeprecationTests, SetAttachmentDescriptorAttachment) {
	utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, 1, 1);
	wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
	wgpu::RenderPassEncoder pass;

	// Check that using .attachment with color attachments gives the warning.
	wgpu::RenderPassColorAttachmentDescriptor* colorAttachment =
	&renderPass.renderPassInfo.cColorAttachments[0];
	colorAttachment->attachment = colorAttachment->view;
	colorAttachment->view = nullptr;

	EXPECT_DEPRECATION_WARNING(pass = encoder.BeginRenderPass(&renderPass.renderPassInfo));
	pass.EndPass();

	colorAttachment->view = colorAttachment->attachment;
	colorAttachment->attachment = nullptr;

	// Check that using .attachment with depth/stencil attachments gives the warning.
	wgpu::TextureDescriptor descriptor;
	descriptor.dimension = wgpu::TextureDimension::e2D;
	descriptor.size = {1, 1, 1};
	descriptor.sampleCount = 1;
	descriptor.format = wgpu::TextureFormat::Depth24PlusStencil8;
	descriptor.mipLevelCount = 1;
	descriptor.usage = wgpu::TextureUsage::RenderAttachment;
	wgpu::Texture depthStencil = device.CreateTexture(&descriptor);

	wgpu::RenderPassDepthStencilAttachmentDescriptor* depthAttachment =
	&renderPass.renderPassInfo.cDepthStencilAttachmentInfo;
	renderPass.renderPassInfo.depthStencilAttachment = depthAttachment;
	depthAttachment->attachment = depthStencil.CreateView();

	EXPECT_DEPRECATION_WARNING(pass = encoder.BeginRenderPass(&renderPass.renderPassInfo));
	pass.EndPass();
	}

	// Test that setting computeStage in a ComputePipelineDescriptor is deprecated.
	TEST_P(DeprecationTests, ComputeStage) {
	wgpu::ComputePipelineDescriptor csDesc;
	csDesc.computeStage.module = utils::CreateShaderModule(device, R"(
	[[stage(compute), workgroup_size(1)]] fn main() {
	})");
	csDesc.computeStage.entryPoint = "main";

	wgpu::ComputePipeline pipeline;
	EXPECT_DEPRECATION_WARNING(pipeline = device.CreateComputePipeline(&csDesc));
	}

	// Test that StoreOp::Clear is deprecated.
	TEST_P(DeprecationTests, StoreOpClear) {
	utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, 1, 1);
	wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
	wgpu::RenderPassEncoder pass;

	// Check that a storeOp of Clear for color attachments raises a validation warning.
	renderPass.renderPassInfo.cColorAttachments[0].storeOp = wgpu::StoreOp::Clear;

	EXPECT_DEPRECATION_WARNING(pass = encoder.BeginRenderPass(&renderPass.renderPassInfo));
	pass.EndPass();

	// Check that a storeOp of Clear for depth/stencil attachments raises a validation warning.
	wgpu::TextureDescriptor descriptor;
	descriptor.dimension = wgpu::TextureDimension::e2D;
	descriptor.size = {1, 1, 1};
	descriptor.sampleCount = 1;
	descriptor.format = wgpu::TextureFormat::Depth24PlusStencil8;
	descriptor.mipLevelCount = 1;
	descriptor.usage = wgpu::TextureUsage::RenderAttachment;
	wgpu::Texture depthStencil = device.CreateTexture(&descriptor);

	wgpu::RenderPassDepthStencilAttachmentDescriptor* depthAttachment =
	&renderPass.renderPassInfo.cDepthStencilAttachmentInfo;
	renderPass.renderPassInfo.depthStencilAttachment = depthAttachment;
	depthAttachment->view = depthStencil.CreateView();

	renderPass.renderPassInfo.cColorAttachments[0].storeOp = wgpu::StoreOp::Discard;
	depthAttachment->depthStoreOp = wgpu::StoreOp::Clear;

	EXPECT_DEPRECATION_WARNING(pass = encoder.BeginRenderPass(&renderPass.renderPassInfo));
	pass.EndPass();

	depthAttachment->depthStoreOp = wgpu::StoreOp::Discard;
	depthAttachment->stencilStoreOp = wgpu::StoreOp::Clear;

	EXPECT_DEPRECATION_WARNING(pass = encoder.BeginRenderPass(&renderPass.renderPassInfo));
	pass.EndPass();
	}

	DAWN_INSTANTIATE_TEST(DeprecationTests,
	D3D12Backend(),
	MetalBackend(),
	NullBackend(),
	OpenGLBackend(),
	OpenGLESBackend(),
	VulkanBackend());

	class ImageCopyBufferDeprecationTests : public DeprecationTests {
	protected:
	wgpu::ImageCopyTexture MakeImageCopyTexture() {
	wgpu::TextureDescriptor desc = {};
	desc.usage = wgpu::TextureUsage::CopySrc \| wgpu::TextureUsage::CopyDst;
	desc.dimension = wgpu::TextureDimension::e2D;
	desc.size = {1, 1, 2};
	desc.format = wgpu::TextureFormat::RGBA8Unorm;

	wgpu::ImageCopyTexture copy;
	copy.texture = device.CreateTexture(&desc);
	copy.origin = {0, 0, 1};
	return copy;
	}

	wgpu::Extent3D copySize = {1, 1, 1};
	};

	// Tests that deprecated blend factors properly raise a deprecation warning when used
	class BlendFactorDeprecationTests : public DeprecationTests {
	protected:
	// Runs the test
	void DoTest(const wgpu::BlendFactor blendFactor, bool deprecated) {
	wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
	[[stage(vertex)]] fn main() -> [[builtin(position)]] vec4<f32> {
	return vec4<f32>(0.0, 0.0, 0.0, 1.0);
	}
	)");
	wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
	[[stage(fragment)]] fn main() -> [[location(0)]] vec4<f32> {
	return vec4<f32>(1.0, 1.0, 1.0, 1.0);
	}
	)");

	utils::ComboRenderPipelineDescriptor descriptor;
	descriptor.vertex.module = vsModule;
	descriptor.cFragment.module = fsModule;
	descriptor.cTargets[0].blend = &descriptor.cBlends[0];

	descriptor.cBlends[0].color.srcFactor = blendFactor;
	if (deprecated) {
	EXPECT_DEPRECATION_WARNING(device.CreateRenderPipeline(&descriptor));
	} else {
	device.CreateRenderPipeline(&descriptor);
	}
	descriptor.cBlends[0].color.srcFactor = wgpu::BlendFactor::One;

	descriptor.cBlends[0].color.dstFactor = blendFactor;
	if (deprecated) {
	EXPECT_DEPRECATION_WARNING(device.CreateRenderPipeline(&descriptor));
	} else {
	device.CreateRenderPipeline(&descriptor);
	}
	descriptor.cBlends[0].color.dstFactor = wgpu::BlendFactor::Zero;

	descriptor.cBlends[0].alpha.srcFactor = blendFactor;
	if (deprecated) {
	EXPECT_DEPRECATION_WARNING(device.CreateRenderPipeline(&descriptor));
	} else {
	device.CreateRenderPipeline(&descriptor);
	}
	descriptor.cBlends[0].alpha.srcFactor = wgpu::BlendFactor::One;

	descriptor.cBlends[0].alpha.dstFactor = blendFactor;
	if (deprecated) {
	EXPECT_DEPRECATION_WARNING(device.CreateRenderPipeline(&descriptor));
	} else {
	device.CreateRenderPipeline(&descriptor);
	}
	descriptor.cBlends[0].alpha.dstFactor = wgpu::BlendFactor::Zero;
	}
	};

	static constexpr std::array<wgpu::BlendFactor, 13> kBlendFactors = {
	wgpu::BlendFactor::Zero,
	wgpu::BlendFactor::One,
	wgpu::BlendFactor::Src,
	wgpu::BlendFactor::OneMinusSrc,
	wgpu::BlendFactor::SrcAlpha,
	wgpu::BlendFactor::OneMinusSrcAlpha,
	wgpu::BlendFactor::Dst,
	wgpu::BlendFactor::OneMinusDst,
	wgpu::BlendFactor::DstAlpha,
	wgpu::BlendFactor::OneMinusDstAlpha,
	wgpu::BlendFactor::SrcAlphaSaturated,
	wgpu::BlendFactor::Constant,
	wgpu::BlendFactor::OneMinusConstant,
	};

	TEST_P(BlendFactorDeprecationTests, CurrentBlendFactors) {
	// Using the new blend factors does not emit a warning.
	for (auto& format : kBlendFactors) {
	DoTest(format, false);
	}
	}

	static constexpr std::array<wgpu::BlendFactor, 6> kDeprecatedBlendFactors = {
	wgpu::BlendFactor::SrcColor, wgpu::BlendFactor::OneMinusSrcColor,
	wgpu::BlendFactor::DstColor, wgpu::BlendFactor::OneMinusDstColor,
	wgpu::BlendFactor::BlendColor, wgpu::BlendFactor::OneMinusBlendColor,
	};

	TEST_P(BlendFactorDeprecationTests, DeprecatedBlendFactors) {
	// Using deprecated blend factors does emit a warning.
	for (auto& format : kDeprecatedBlendFactors) {
	DoTest(format, true);
	}
	}

	DAWN_INSTANTIATE_TEST(BlendFactorDeprecationTests,
	D3D12Backend(),
	MetalBackend(),
	NullBackend(),
	OpenGLBackend(),
	OpenGLESBackend(),
	VulkanBackend());