From 45b51f5df785069594fea29d59b76a0559d3a4e1 Mon Sep 17 00:00:00 2001 From: Corentin Wallez Date: Mon, 28 Oct 2019 22:15:47 +0000 Subject: [PATCH] Make unittests and fuzzers use webgpu.h BUG=dawn:22 Change-Id: Iff5465ad7a9456f9c6b2ee380af748b3afc129b7 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/12741 Commit-Queue: Kai Ninomiya Reviewed-by: Austin Eng Reviewed-by: Kai Ninomiya --- BUILD.gn | 12 +- generator/dawn_json_generator.py | 8 +- .../{mock_api.cpp => mock_webgpu.cpp} | 54 +- .../templates/{mock_api.h => mock_webgpu.h} | 94 +-- .../DawnWireServerAndFrontendFuzzer.cpp | 12 +- src/tests/unittests/ObjectBaseTests.cpp | 2 +- .../validation/BindGroupValidationTests.cpp | 428 ++++++------- .../validation/BufferValidationTests.cpp | 312 +++++----- .../CommandBufferValidationTests.cpp | 122 ++-- .../ComputeIndirectValidationTests.cpp | 18 +- .../validation/ComputePassValidationTests.cpp | 76 +-- .../CopyCommandsValidationTests.cpp | 580 +++++++++--------- .../validation/DebugMarkerValidationTests.cpp | 46 +- .../DrawIndirectValidationTests.cpp | 22 +- .../DynamicStateCommandValidationTests.cpp | 112 ++-- .../validation/ErrorScopeValidationTests.cpp | 86 ++- .../validation/FenceValidationTests.cpp | 70 +-- .../validation/QueueSubmitValidationTests.cpp | 18 +- .../RenderBundleValidationTests.cpp | 384 ++++++------ .../RenderPassDescriptorValidationTests.cpp | 318 +++++----- .../validation/RenderPassValidationTests.cpp | 40 +- .../RenderPipelineValidationTests.cpp | 80 +-- .../validation/SamplerValidationTests.cpp | 8 +- .../validation/TextureValidationTests.cpp | 152 ++--- .../validation/TextureViewValidationTests.cpp | 156 ++--- .../validation/ToggleValidationTests.cpp | 6 +- .../unittests/validation/ValidationTest.cpp | 32 +- .../unittests/validation/ValidationTest.h | 20 +- .../VertexBufferValidationTests.cpp | 30 +- .../validation/VertexInputValidationTests.cpp | 10 +- .../unittests/wire/WireArgumentTests.cpp | 210 +++---- src/tests/unittests/wire/WireBasicTests.cpp | 26 +- .../unittests/wire/WireBufferMappingTests.cpp | 284 +++++---- .../unittests/wire/WireErrorCallbackTests.cpp | 114 ++-- src/tests/unittests/wire/WireFenceTests.cpp | 118 ++-- .../unittests/wire/WireInjectTextureTests.cpp | 12 +- .../wire/WireMemoryTransferServiceTests.cpp | 215 ++++--- .../unittests/wire/WireOptionalTests.cpp | 105 ++-- src/tests/unittests/wire/WireTest.cpp | 2 +- src/tests/unittests/wire/WireTest.h | 6 +- 40 files changed, 2200 insertions(+), 2200 deletions(-) rename generator/templates/{mock_api.cpp => mock_webgpu.cpp} (69%) rename generator/templates/{mock_api.h => mock_webgpu.h} (61%) diff --git a/BUILD.gn b/BUILD.gn index cf9d1c0062..b186c00d7a 100644 --- a/BUILD.gn +++ b/BUILD.gn @@ -740,11 +740,11 @@ static_library("dawn_bindings") { # Dawn test targets ############################################################################### -dawn_json_generator("mock_dawn_gen") { - target = "mock_dawn" +dawn_json_generator("mock_webgpu_gen") { + target = "mock_webgpu" outputs = [ - "src/dawn/mock_dawn.h", - "src/dawn/mock_dawn.cpp", + "src/dawn/mock_webgpu.h", + "src/dawn/mock_webgpu.cpp", ] } @@ -756,7 +756,7 @@ test("dawn_unittests") { ":libdawn_native", ":libdawn_native_sources", ":libdawn_wire", - ":mock_dawn_gen", + ":mock_webgpu_gen", "${dawn_root}/src/common", "${dawn_root}/src/dawn:dawncpp", "${dawn_root}/src/dawn:libdawn_proc", @@ -767,7 +767,7 @@ test("dawn_unittests") { deps += [ ":libdawn_native_headers" ] configs += [ ":libdawn_native_internal" ] - sources = get_target_outputs(":mock_dawn_gen") + sources = get_target_outputs(":mock_webgpu_gen") sources += [ "src/dawn_wire/client/ClientMemoryTransferService_mock.cpp", "src/dawn_wire/client/ClientMemoryTransferService_mock.h", diff --git a/generator/dawn_json_generator.py b/generator/dawn_json_generator.py index e9428bbce7..f957f014f3 100644 --- a/generator/dawn_json_generator.py +++ b/generator/dawn_json_generator.py @@ -482,7 +482,7 @@ class MultiGeneratorFromDawnJSON(Generator): return 'Generates code for various target from Dawn.json.' def add_commandline_arguments(self, parser): - allowed_targets = ['dawn_headers', 'dawncpp_headers', 'dawncpp', 'dawn_proc', 'mock_dawn', 'dawn_wire', "dawn_native_utils"] + allowed_targets = ['dawn_headers', 'dawncpp_headers', 'dawncpp', 'dawn_proc', 'mock_webgpu', 'dawn_wire', "dawn_native_utils"] parser.add_argument('--dawn-json', required=True, type=str, help ='The DAWN JSON definition to use.') parser.add_argument('--wire-json', default=None, type=str, help='The DAWN WIRE JSON definition to use.') @@ -542,9 +542,9 @@ class MultiGeneratorFromDawnJSON(Generator): if 'dawncpp' in targets: renders.append(FileRender('webgpu_cpp.cpp', 'src/dawn/webgpu_cpp.cpp', [base_params, api_params, cpp_params])) - if 'mock_dawn' in targets: - renders.append(FileRender('mock_api.h', 'src/dawn/mock_dawn.h', [base_params, api_params, c_params])) - renders.append(FileRender('mock_api.cpp', 'src/dawn/mock_dawn.cpp', [base_params, api_params, c_params])) + if 'mock_webgpu' in targets: + renders.append(FileRender('mock_webgpu.h', 'src/dawn/mock_webgpu.h', [base_params, api_params, c_params])) + renders.append(FileRender('mock_webgpu.cpp', 'src/dawn/mock_webgpu.cpp', [base_params, api_params, c_params])) if 'dawn_native_utils' in targets: frontend_params = [ diff --git a/generator/templates/mock_api.cpp b/generator/templates/mock_webgpu.cpp similarity index 69% rename from generator/templates/mock_api.cpp rename to generator/templates/mock_webgpu.cpp index 4b451a3de1..fb92d70b19 100644 --- a/generator/templates/mock_api.cpp +++ b/generator/templates/mock_webgpu.cpp @@ -12,7 +12,7 @@ //* See the License for the specific language governing permissions and //* limitations under the License. -#include "mock_dawn.h" +#include "mock_webgpu.h" using namespace testing; @@ -40,7 +40,7 @@ namespace { ProcTableAsClass::~ProcTableAsClass() { } -void ProcTableAsClass::GetProcTableAndDevice(DawnProcTable* table, DawnDevice* device) { +void ProcTableAsClass::GetProcTableAndDevice(DawnProcTable* table, WGPUDevice* device) { *device = GetNewDevice(); {% for type in by_category["object"] %} @@ -50,9 +50,9 @@ void ProcTableAsClass::GetProcTableAndDevice(DawnProcTable* table, DawnDevice* d {% endfor %} } -void ProcTableAsClass::DeviceSetUncapturedErrorCallback(DawnDevice self, - DawnErrorCallback callback, - void* userdata) { +void ProcTableAsClass::DeviceSetUncapturedErrorCallback(WGPUDevice self, + WGPUErrorCallback callback, + void* userdata) { auto object = reinterpret_cast(self); object->deviceErrorCallback = callback; object->userdata1 = userdata; @@ -60,13 +60,15 @@ void ProcTableAsClass::DeviceSetUncapturedErrorCallback(DawnDevice self, OnDeviceSetUncapturedErrorCallback(self, callback, userdata); } -bool ProcTableAsClass::DevicePopErrorScope(DawnDevice self, DawnErrorCallback callback, void* userdata) { +bool ProcTableAsClass::DevicePopErrorScope(WGPUDevice self, + WGPUErrorCallback callback, + void* userdata) { return OnDevicePopErrorScopeCallback(self, callback, userdata); } -void ProcTableAsClass::DeviceCreateBufferMappedAsync(DawnDevice self, - const DawnBufferDescriptor* descriptor, - DawnBufferCreateMappedCallback callback, +void ProcTableAsClass::DeviceCreateBufferMappedAsync(WGPUDevice self, + const WGPUBufferDescriptor* descriptor, + WGPUBufferCreateMappedCallback callback, void* userdata) { auto object = reinterpret_cast(self); object->createBufferMappedCallback = callback; @@ -75,8 +77,8 @@ void ProcTableAsClass::DeviceCreateBufferMappedAsync(DawnDevice self, OnDeviceCreateBufferMappedAsyncCallback(self, descriptor, callback, userdata); } -void ProcTableAsClass::BufferMapReadAsync(DawnBuffer self, - DawnBufferMapReadCallback callback, +void ProcTableAsClass::BufferMapReadAsync(WGPUBuffer self, + WGPUBufferMapReadCallback callback, void* userdata) { auto object = reinterpret_cast(self); object->mapReadCallback = callback; @@ -85,8 +87,8 @@ void ProcTableAsClass::BufferMapReadAsync(DawnBuffer self, OnBufferMapReadAsyncCallback(self, callback, userdata); } -void ProcTableAsClass::BufferMapWriteAsync(DawnBuffer self, - DawnBufferMapWriteCallback callback, +void ProcTableAsClass::BufferMapWriteAsync(WGPUBuffer self, + WGPUBufferMapWriteCallback callback, void* userdata) { auto object = reinterpret_cast(self); object->mapWriteCallback = callback; @@ -95,9 +97,9 @@ void ProcTableAsClass::BufferMapWriteAsync(DawnBuffer self, OnBufferMapWriteAsyncCallback(self, callback, userdata); } -void ProcTableAsClass::FenceOnCompletion(DawnFence self, +void ProcTableAsClass::FenceOnCompletion(WGPUFence self, uint64_t value, - DawnFenceOnCompletionCallback callback, + WGPUFenceOnCompletionCallback callback, void* userdata) { auto object = reinterpret_cast(self); object->fenceOnCompletionCallback = callback; @@ -106,26 +108,36 @@ void ProcTableAsClass::FenceOnCompletion(DawnFence self, OnFenceOnCompletionCallback(self, value, callback, userdata); } -void ProcTableAsClass::CallDeviceErrorCallback(DawnDevice device, DawnErrorType type, const char* message) { +void ProcTableAsClass::CallDeviceErrorCallback(WGPUDevice device, + WGPUErrorType type, + const char* message) { auto object = reinterpret_cast(device); object->deviceErrorCallback(type, message, object->userdata1); } -void ProcTableAsClass::CallCreateBufferMappedCallback(DawnDevice device, DawnBufferMapAsyncStatus status, DawnCreateBufferMappedResult result) { +void ProcTableAsClass::CallCreateBufferMappedCallback(WGPUDevice device, + WGPUBufferMapAsyncStatus status, + WGPUCreateBufferMappedResult result) { auto object = reinterpret_cast(device); object->createBufferMappedCallback(status, result, object->userdata1); } -void ProcTableAsClass::CallMapReadCallback(DawnBuffer buffer, DawnBufferMapAsyncStatus status, const void* data, uint64_t dataLength) { +void ProcTableAsClass::CallMapReadCallback(WGPUBuffer buffer, + WGPUBufferMapAsyncStatus status, + const void* data, + uint64_t dataLength) { auto object = reinterpret_cast(buffer); object->mapReadCallback(status, data, dataLength, object->userdata1); } -void ProcTableAsClass::CallMapWriteCallback(DawnBuffer buffer, DawnBufferMapAsyncStatus status, void* data, uint64_t dataLength) { +void ProcTableAsClass::CallMapWriteCallback(WGPUBuffer buffer, + WGPUBufferMapAsyncStatus status, + void* data, + uint64_t dataLength) { auto object = reinterpret_cast(buffer); object->mapWriteCallback(status, data, dataLength, object->userdata1); } -void ProcTableAsClass::CallFenceOnCompletionCallback(DawnFence fence, - DawnFenceCompletionStatus status) { +void ProcTableAsClass::CallFenceOnCompletionCallback(WGPUFence fence, + WGPUFenceCompletionStatus status) { auto object = reinterpret_cast(fence); object->fenceOnCompletionCallback(status, object->userdata1); } diff --git a/generator/templates/mock_api.h b/generator/templates/mock_webgpu.h similarity index 61% rename from generator/templates/mock_api.h rename to generator/templates/mock_webgpu.h index bbd515ad4b..15f9832f1e 100644 --- a/generator/templates/mock_api.h +++ b/generator/templates/mock_webgpu.h @@ -12,11 +12,11 @@ //* See the License for the specific language governing permissions and //* limitations under the License. -#ifndef MOCK_DAWN_H -#define MOCK_DAWN_H +#ifndef MOCK_WEBGPU_H +#define MOCK_WEBGPU_H -#include #include +#include #include #include @@ -28,7 +28,7 @@ class ProcTableAsClass { public: virtual ~ProcTableAsClass(); - void GetProcTableAndDevice(DawnProcTable* table, DawnDevice* device); + void GetProcTableAndDevice(DawnProcTable* table, WGPUDevice* device); // Creates an object that can be returned by a mocked call as in WillOnce(Return(foo)). // It returns an object of the write type that isn't equal to any previously returned object. @@ -52,61 +52,61 @@ class ProcTableAsClass { {% endfor %} // Stores callback and userdata and calls the On* methods - void DeviceSetUncapturedErrorCallback(DawnDevice self, - DawnErrorCallback callback, + void DeviceSetUncapturedErrorCallback(WGPUDevice self, + WGPUErrorCallback callback, void* userdata); - bool DevicePopErrorScope(DawnDevice self, DawnErrorCallback callback, void* userdata); - void DeviceCreateBufferMappedAsync(DawnDevice self, - const DawnBufferDescriptor* descriptor, - DawnBufferCreateMappedCallback callback, + bool DevicePopErrorScope(WGPUDevice self, WGPUErrorCallback callback, void* userdata); + void DeviceCreateBufferMappedAsync(WGPUDevice self, + const WGPUBufferDescriptor* descriptor, + WGPUBufferCreateMappedCallback callback, void* userdata); - void BufferMapReadAsync(DawnBuffer self, - DawnBufferMapReadCallback callback, + void BufferMapReadAsync(WGPUBuffer self, + WGPUBufferMapReadCallback callback, void* userdata); - void BufferMapWriteAsync(DawnBuffer self, - DawnBufferMapWriteCallback callback, + void BufferMapWriteAsync(WGPUBuffer self, + WGPUBufferMapWriteCallback callback, void* userdata); - void FenceOnCompletion(DawnFence self, + void FenceOnCompletion(WGPUFence self, uint64_t value, - DawnFenceOnCompletionCallback callback, + WGPUFenceOnCompletionCallback callback, void* userdata); // Special cased mockable methods - virtual void OnDeviceSetUncapturedErrorCallback(DawnDevice device, - DawnErrorCallback callback, + virtual void OnDeviceSetUncapturedErrorCallback(WGPUDevice device, + WGPUErrorCallback callback, void* userdata) = 0; - virtual bool OnDevicePopErrorScopeCallback(DawnDevice device, - DawnErrorCallback callback, + virtual bool OnDevicePopErrorScopeCallback(WGPUDevice device, + WGPUErrorCallback callback, void* userdata) = 0; - virtual void OnDeviceCreateBufferMappedAsyncCallback(DawnDevice self, - const DawnBufferDescriptor* descriptor, - DawnBufferCreateMappedCallback callback, + virtual void OnDeviceCreateBufferMappedAsyncCallback(WGPUDevice self, + const WGPUBufferDescriptor* descriptor, + WGPUBufferCreateMappedCallback callback, void* userdata) = 0; - virtual void OnBufferMapReadAsyncCallback(DawnBuffer buffer, - DawnBufferMapReadCallback callback, + virtual void OnBufferMapReadAsyncCallback(WGPUBuffer buffer, + WGPUBufferMapReadCallback callback, void* userdata) = 0; - virtual void OnBufferMapWriteAsyncCallback(DawnBuffer buffer, - DawnBufferMapWriteCallback callback, + virtual void OnBufferMapWriteAsyncCallback(WGPUBuffer buffer, + WGPUBufferMapWriteCallback callback, void* userdata) = 0; - virtual void OnFenceOnCompletionCallback(DawnFence fence, + virtual void OnFenceOnCompletionCallback(WGPUFence fence, uint64_t value, - DawnFenceOnCompletionCallback callback, + WGPUFenceOnCompletionCallback callback, void* userdata) = 0; // Calls the stored callbacks - void CallDeviceErrorCallback(DawnDevice device, DawnErrorType type, const char* message); - void CallCreateBufferMappedCallback(DawnDevice device, DawnBufferMapAsyncStatus status, DawnCreateBufferMappedResult result); - void CallMapReadCallback(DawnBuffer buffer, DawnBufferMapAsyncStatus status, const void* data, uint64_t dataLength); - void CallMapWriteCallback(DawnBuffer buffer, DawnBufferMapAsyncStatus status, void* data, uint64_t dataLength); - void CallFenceOnCompletionCallback(DawnFence fence, DawnFenceCompletionStatus status); + void CallDeviceErrorCallback(WGPUDevice device, WGPUErrorType type, const char* message); + void CallCreateBufferMappedCallback(WGPUDevice device, WGPUBufferMapAsyncStatus status, WGPUCreateBufferMappedResult result); + void CallMapReadCallback(WGPUBuffer buffer, WGPUBufferMapAsyncStatus status, const void* data, uint64_t dataLength); + void CallMapWriteCallback(WGPUBuffer buffer, WGPUBufferMapAsyncStatus status, void* data, uint64_t dataLength); + void CallFenceOnCompletionCallback(WGPUFence fence, WGPUFenceCompletionStatus status); struct Object { ProcTableAsClass* procs = nullptr; - DawnErrorCallback deviceErrorCallback = nullptr; - DawnBufferCreateMappedCallback createBufferMappedCallback = nullptr; - DawnBufferMapReadCallback mapReadCallback = nullptr; - DawnBufferMapWriteCallback mapWriteCallback = nullptr; - DawnFenceOnCompletionCallback fenceOnCompletionCallback = nullptr; + WGPUErrorCallback deviceErrorCallback = nullptr; + WGPUBufferCreateMappedCallback createBufferMappedCallback = nullptr; + WGPUBufferMapReadCallback mapReadCallback = nullptr; + WGPUBufferMapWriteCallback mapWriteCallback = nullptr; + WGPUFenceOnCompletionCallback fenceOnCompletionCallback = nullptr; void* userdata1 = 0; void* userdata2 = 0; }; @@ -138,16 +138,16 @@ class MockProcTable : public ProcTableAsClass { MOCK_METHOD1({{as_MethodSuffix(type.name, Name("release"))}}, void({{as_cType(type.name)}} self)); {% endfor %} - MOCK_METHOD3(OnDeviceSetUncapturedErrorCallback, void(DawnDevice device, DawnErrorCallback callback, void* userdata)); - MOCK_METHOD3(OnDevicePopErrorScopeCallback, bool(DawnDevice device, DawnErrorCallback callback, void* userdata)); - MOCK_METHOD4(OnDeviceCreateBufferMappedAsyncCallback, void(DawnDevice device, const DawnBufferDescriptor* descriptor, DawnBufferCreateMappedCallback callback, void* userdata)); - MOCK_METHOD3(OnBufferMapReadAsyncCallback, void(DawnBuffer buffer, DawnBufferMapReadCallback callback, void* userdata)); - MOCK_METHOD3(OnBufferMapWriteAsyncCallback, void(DawnBuffer buffer, DawnBufferMapWriteCallback callback, void* userdata)); + MOCK_METHOD3(OnDeviceSetUncapturedErrorCallback, void(WGPUDevice device, WGPUErrorCallback callback, void* userdata)); + MOCK_METHOD3(OnDevicePopErrorScopeCallback, bool(WGPUDevice device, WGPUErrorCallback callback, void* userdata)); + MOCK_METHOD4(OnDeviceCreateBufferMappedAsyncCallback, void(WGPUDevice device, const WGPUBufferDescriptor* descriptor, WGPUBufferCreateMappedCallback callback, void* userdata)); + MOCK_METHOD3(OnBufferMapReadAsyncCallback, void(WGPUBuffer buffer, WGPUBufferMapReadCallback callback, void* userdata)); + MOCK_METHOD3(OnBufferMapWriteAsyncCallback, void(WGPUBuffer buffer, WGPUBufferMapWriteCallback callback, void* userdata)); MOCK_METHOD4(OnFenceOnCompletionCallback, - void(DawnFence fence, + void(WGPUFence fence, uint64_t value, - DawnFenceOnCompletionCallback callback, + WGPUFenceOnCompletionCallback callback, void* userdata)); }; -#endif // MOCK_DAWN_H +#endif // MOCK_WEBGPU_H diff --git a/src/fuzzers/DawnWireServerAndFrontendFuzzer.cpp b/src/fuzzers/DawnWireServerAndFrontendFuzzer.cpp index aacdac6fbf..ad904b7e6d 100644 --- a/src/fuzzers/DawnWireServerAndFrontendFuzzer.cpp +++ b/src/fuzzers/DawnWireServerAndFrontendFuzzer.cpp @@ -14,7 +14,7 @@ #include "common/Assert.h" #include "dawn/dawn_proc.h" -#include "dawn/dawncpp.h" +#include "dawn/webgpu_cpp.h" #include "dawn_native/DawnNative.h" #include "dawn_wire/WireServer.h" @@ -36,10 +36,10 @@ class DevNull : public dawn_wire::CommandSerializer { std::vector buf; }; -static DawnProcDeviceCreateSwapChain originalDeviceCreateSwapChain = nullptr; +static WGPUProcDeviceCreateSwapChain originalDeviceCreateSwapChain = nullptr; -DawnSwapChain ErrorDeviceCreateSwapChain(DawnDevice device, const DawnSwapChainDescriptor*) { - DawnSwapChainDescriptor desc; +WGPUSwapChain ErrorDeviceCreateSwapChain(WGPUDevice device, const WGPUSwapChainDescriptor*) { + WGPUSwapChainDescriptor desc; desc.nextInChain = nullptr; desc.label = nullptr; // A 0 implementation will trigger a swapchain creation error. @@ -65,10 +65,10 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { std::vector adapters = instance->GetAdapters(); - dawn::Device nullDevice; + wgpu::Device nullDevice; for (dawn_native::Adapter adapter : adapters) { if (adapter.GetBackendType() == dawn_native::BackendType::Null) { - nullDevice = dawn::Device::Acquire(adapter.CreateDevice()); + nullDevice = wgpu::Device::Acquire(adapter.CreateDevice()); break; } } diff --git a/src/tests/unittests/ObjectBaseTests.cpp b/src/tests/unittests/ObjectBaseTests.cpp index 376d004190..6c3f2d7403 100644 --- a/src/tests/unittests/ObjectBaseTests.cpp +++ b/src/tests/unittests/ObjectBaseTests.cpp @@ -14,7 +14,7 @@ #include -#include "dawn/dawncpp.h" +#include "dawn/webgpu_cpp.h" class Object : public wgpu::ObjectBase { public: diff --git a/src/tests/unittests/validation/BindGroupValidationTests.cpp b/src/tests/unittests/validation/BindGroupValidationTests.cpp index 3844b160ac..1cd4a96f1e 100644 --- a/src/tests/unittests/validation/BindGroupValidationTests.cpp +++ b/src/tests/unittests/validation/BindGroupValidationTests.cpp @@ -24,48 +24,48 @@ class BindGroupValidationTest : public ValidationTest { void SetUp() override { // Create objects to use as resources inside test bind groups. { - dawn::BufferDescriptor descriptor; + wgpu::BufferDescriptor descriptor; descriptor.size = 1024; - descriptor.usage = dawn::BufferUsage::Uniform; + descriptor.usage = wgpu::BufferUsage::Uniform; mUBO = device.CreateBuffer(&descriptor); } { - dawn::BufferDescriptor descriptor; + wgpu::BufferDescriptor descriptor; descriptor.size = 1024; - descriptor.usage = dawn::BufferUsage::Storage; + descriptor.usage = wgpu::BufferUsage::Storage; mSSBO = device.CreateBuffer(&descriptor); } { - dawn::SamplerDescriptor descriptor = utils::GetDefaultSamplerDescriptor(); + wgpu::SamplerDescriptor descriptor = utils::GetDefaultSamplerDescriptor(); mSampler = device.CreateSampler(&descriptor); } { - dawn::TextureDescriptor descriptor; - descriptor.dimension = dawn::TextureDimension::e2D; + wgpu::TextureDescriptor descriptor; + descriptor.dimension = wgpu::TextureDimension::e2D; descriptor.size = {16, 16, 1}; descriptor.arrayLayerCount = 1; descriptor.sampleCount = 1; - descriptor.format = dawn::TextureFormat::RGBA8Unorm; + descriptor.format = wgpu::TextureFormat::RGBA8Unorm; descriptor.mipLevelCount = 1; - descriptor.usage = dawn::TextureUsage::Sampled; + descriptor.usage = wgpu::TextureUsage::Sampled; mSampledTexture = device.CreateTexture(&descriptor); mSampledTextureView = mSampledTexture.CreateView(); } } protected: - dawn::Buffer mUBO; - dawn::Buffer mSSBO; - dawn::Sampler mSampler; - dawn::Texture mSampledTexture; - dawn::TextureView mSampledTextureView; + wgpu::Buffer mUBO; + wgpu::Buffer mSSBO; + wgpu::Sampler mSampler; + wgpu::Texture mSampledTexture; + wgpu::TextureView mSampledTextureView; }; // Test the validation of BindGroupDescriptor::nextInChain TEST_F(BindGroupValidationTest, NextInChainNullptr) { - dawn::BindGroupLayout layout = utils::MakeBindGroupLayout(device, {}); + wgpu::BindGroupLayout layout = utils::MakeBindGroupLayout(device, {}); - dawn::BindGroupDescriptor descriptor; + wgpu::BindGroupDescriptor descriptor; descriptor.layout = layout; descriptor.bindingCount = 0; descriptor.bindings = nullptr; @@ -81,8 +81,8 @@ TEST_F(BindGroupValidationTest, NextInChainNullptr) { // Check constraints on bindingCount TEST_F(BindGroupValidationTest, bindingCountMismatch) { - dawn::BindGroupLayout layout = utils::MakeBindGroupLayout( - device, {{0, dawn::ShaderStage::Fragment, dawn::BindingType::Sampler}}); + wgpu::BindGroupLayout layout = utils::MakeBindGroupLayout( + device, {{0, wgpu::ShaderStage::Fragment, wgpu::BindingType::Sampler}}); // Control case: check that a descriptor with one binding is ok utils::MakeBindGroup(device, layout, {{0, mSampler}}); @@ -93,8 +93,8 @@ TEST_F(BindGroupValidationTest, bindingCountMismatch) { // Check constraints on BindGroupBinding::binding TEST_F(BindGroupValidationTest, WrongBindings) { - dawn::BindGroupLayout layout = utils::MakeBindGroupLayout( - device, {{0, dawn::ShaderStage::Fragment, dawn::BindingType::Sampler}}); + wgpu::BindGroupLayout layout = utils::MakeBindGroupLayout( + device, {{0, wgpu::ShaderStage::Fragment, wgpu::BindingType::Sampler}}); // Control case: check that a descriptor with a binding matching the layout's is ok utils::MakeBindGroup(device, layout, {{0, mSampler}}); @@ -108,9 +108,9 @@ TEST_F(BindGroupValidationTest, WrongBindings) { // Check that the same binding cannot be set twice TEST_F(BindGroupValidationTest, BindingSetTwice) { - dawn::BindGroupLayout layout = utils::MakeBindGroupLayout( - device, {{0, dawn::ShaderStage::Fragment, dawn::BindingType::Sampler}, - {1, dawn::ShaderStage::Fragment, dawn::BindingType::Sampler}}); + wgpu::BindGroupLayout layout = utils::MakeBindGroupLayout( + device, {{0, wgpu::ShaderStage::Fragment, wgpu::BindingType::Sampler}, + {1, wgpu::ShaderStage::Fragment, wgpu::BindingType::Sampler}}); // Control case: check that different bindings work utils::MakeBindGroup(device, layout, { @@ -127,10 +127,10 @@ TEST_F(BindGroupValidationTest, BindingSetTwice) { // Check that a sampler binding must contain exactly one sampler TEST_F(BindGroupValidationTest, SamplerBindingType) { - dawn::BindGroupLayout layout = utils::MakeBindGroupLayout( - device, {{0, dawn::ShaderStage::Fragment, dawn::BindingType::Sampler}}); + wgpu::BindGroupLayout layout = utils::MakeBindGroupLayout( + device, {{0, wgpu::ShaderStage::Fragment, wgpu::BindingType::Sampler}}); - dawn::BindGroupBinding binding; + wgpu::BindGroupBinding binding; binding.binding = 0; binding.sampler = nullptr; binding.textureView = nullptr; @@ -138,7 +138,7 @@ TEST_F(BindGroupValidationTest, SamplerBindingType) { binding.offset = 0; binding.size = 0; - dawn::BindGroupDescriptor descriptor; + wgpu::BindGroupDescriptor descriptor; descriptor.layout = layout; descriptor.bindingCount = 1; descriptor.bindings = &binding; @@ -162,10 +162,10 @@ TEST_F(BindGroupValidationTest, SamplerBindingType) { // Setting the sampler to an error sampler is an error. { - dawn::SamplerDescriptor samplerDesc = utils::GetDefaultSamplerDescriptor(); - samplerDesc.minFilter = static_cast(0xFFFFFFFF); + wgpu::SamplerDescriptor samplerDesc = utils::GetDefaultSamplerDescriptor(); + samplerDesc.minFilter = static_cast(0xFFFFFFFF); - dawn::Sampler errorSampler; + wgpu::Sampler errorSampler; ASSERT_DEVICE_ERROR(errorSampler = device.CreateSampler(&samplerDesc)); binding.sampler = errorSampler; @@ -176,10 +176,10 @@ TEST_F(BindGroupValidationTest, SamplerBindingType) { // Check that a texture binding must contain exactly a texture view TEST_F(BindGroupValidationTest, TextureBindingType) { - dawn::BindGroupLayout layout = utils::MakeBindGroupLayout( - device, {{0, dawn::ShaderStage::Fragment, dawn::BindingType::SampledTexture}}); + wgpu::BindGroupLayout layout = utils::MakeBindGroupLayout( + device, {{0, wgpu::ShaderStage::Fragment, wgpu::BindingType::SampledTexture}}); - dawn::BindGroupBinding binding; + wgpu::BindGroupBinding binding; binding.binding = 0; binding.sampler = nullptr; binding.textureView = nullptr; @@ -187,7 +187,7 @@ TEST_F(BindGroupValidationTest, TextureBindingType) { binding.offset = 0; binding.size = 0; - dawn::BindGroupDescriptor descriptor; + wgpu::BindGroupDescriptor descriptor; descriptor.layout = layout; descriptor.bindingCount = 1; descriptor.bindings = &binding; @@ -211,15 +211,15 @@ TEST_F(BindGroupValidationTest, TextureBindingType) { // Setting the texture view to an error texture view is an error. { - dawn::TextureViewDescriptor viewDesc; - viewDesc.format = dawn::TextureFormat::RGBA8Unorm; - viewDesc.dimension = dawn::TextureViewDimension::e2D; + wgpu::TextureViewDescriptor viewDesc; + viewDesc.format = wgpu::TextureFormat::RGBA8Unorm; + viewDesc.dimension = wgpu::TextureViewDimension::e2D; viewDesc.baseMipLevel = 0; viewDesc.mipLevelCount = 0; viewDesc.baseArrayLayer = 0; viewDesc.arrayLayerCount = 1000; - dawn::TextureView errorView; + wgpu::TextureView errorView; ASSERT_DEVICE_ERROR(errorView = mSampledTexture.CreateView(&viewDesc)); binding.textureView = errorView; @@ -230,10 +230,10 @@ TEST_F(BindGroupValidationTest, TextureBindingType) { // Check that a buffer binding must contain exactly a buffer TEST_F(BindGroupValidationTest, BufferBindingType) { - dawn::BindGroupLayout layout = utils::MakeBindGroupLayout( - device, {{0, dawn::ShaderStage::Fragment, dawn::BindingType::UniformBuffer}}); + wgpu::BindGroupLayout layout = utils::MakeBindGroupLayout( + device, {{0, wgpu::ShaderStage::Fragment, wgpu::BindingType::UniformBuffer}}); - dawn::BindGroupBinding binding; + wgpu::BindGroupBinding binding; binding.binding = 0; binding.sampler = nullptr; binding.textureView = nullptr; @@ -241,7 +241,7 @@ TEST_F(BindGroupValidationTest, BufferBindingType) { binding.offset = 0; binding.size = 0; - dawn::BindGroupDescriptor descriptor; + wgpu::BindGroupDescriptor descriptor; descriptor.layout = layout; descriptor.bindingCount = 1; descriptor.bindings = &binding; @@ -265,11 +265,11 @@ TEST_F(BindGroupValidationTest, BufferBindingType) { // Setting the buffer to an error buffer is an error. { - dawn::BufferDescriptor bufferDesc; + wgpu::BufferDescriptor bufferDesc; bufferDesc.size = 1024; - bufferDesc.usage = static_cast(0xFFFFFFFF); + bufferDesc.usage = static_cast(0xFFFFFFFF); - dawn::Buffer errorBuffer; + wgpu::Buffer errorBuffer; ASSERT_DEVICE_ERROR(errorBuffer = device.CreateBuffer(&bufferDesc)); binding.buffer = errorBuffer; @@ -280,78 +280,78 @@ TEST_F(BindGroupValidationTest, BufferBindingType) { // Check that a texture must have the correct usage TEST_F(BindGroupValidationTest, TextureUsage) { - dawn::BindGroupLayout layout = utils::MakeBindGroupLayout( - device, {{0, dawn::ShaderStage::Fragment, dawn::BindingType::SampledTexture}}); + wgpu::BindGroupLayout layout = utils::MakeBindGroupLayout( + device, {{0, wgpu::ShaderStage::Fragment, wgpu::BindingType::SampledTexture}}); // Control case: setting a sampleable texture view works. utils::MakeBindGroup(device, layout, {{0, mSampledTextureView}}); // Make an output attachment texture and try to set it for a SampledTexture binding - dawn::TextureDescriptor descriptor; - descriptor.dimension = dawn::TextureDimension::e2D; + wgpu::TextureDescriptor descriptor; + descriptor.dimension = wgpu::TextureDimension::e2D; descriptor.size = {16, 16, 1}; descriptor.arrayLayerCount = 1; descriptor.sampleCount = 1; - descriptor.format = dawn::TextureFormat::RGBA8Unorm; + descriptor.format = wgpu::TextureFormat::RGBA8Unorm; descriptor.mipLevelCount = 1; - descriptor.usage = dawn::TextureUsage::OutputAttachment; - dawn::Texture outputTexture = device.CreateTexture(&descriptor); - dawn::TextureView outputTextureView = outputTexture.CreateView(); + descriptor.usage = wgpu::TextureUsage::OutputAttachment; + wgpu::Texture outputTexture = device.CreateTexture(&descriptor); + wgpu::TextureView outputTextureView = outputTexture.CreateView(); ASSERT_DEVICE_ERROR(utils::MakeBindGroup(device, layout, {{0, outputTextureView}})); } // Check that a texture must have the correct component type TEST_F(BindGroupValidationTest, TextureComponentType) { - dawn::BindGroupLayout layout = utils::MakeBindGroupLayout( - device, {{0, dawn::ShaderStage::Fragment, dawn::BindingType::SampledTexture, false, false, - dawn::TextureViewDimension::e2D, dawn::TextureComponentType::Float}}); + wgpu::BindGroupLayout layout = utils::MakeBindGroupLayout( + device, {{0, wgpu::ShaderStage::Fragment, wgpu::BindingType::SampledTexture, false, false, + wgpu::TextureViewDimension::e2D, wgpu::TextureComponentType::Float}}); // Control case: setting a Float typed texture view works. utils::MakeBindGroup(device, layout, {{0, mSampledTextureView}}); // Make a Uint component typed texture and try to set it to a Float component binding. - dawn::TextureDescriptor descriptor; - descriptor.dimension = dawn::TextureDimension::e2D; + wgpu::TextureDescriptor descriptor; + descriptor.dimension = wgpu::TextureDimension::e2D; descriptor.size = {16, 16, 1}; descriptor.arrayLayerCount = 1; descriptor.sampleCount = 1; - descriptor.format = dawn::TextureFormat::RGBA8Uint; + descriptor.format = wgpu::TextureFormat::RGBA8Uint; descriptor.mipLevelCount = 1; - descriptor.usage = dawn::TextureUsage::Sampled; - dawn::Texture uintTexture = device.CreateTexture(&descriptor); - dawn::TextureView uintTextureView = uintTexture.CreateView(); + descriptor.usage = wgpu::TextureUsage::Sampled; + wgpu::Texture uintTexture = device.CreateTexture(&descriptor); + wgpu::TextureView uintTextureView = uintTexture.CreateView(); ASSERT_DEVICE_ERROR(utils::MakeBindGroup(device, layout, {{0, uintTextureView}})); } // Check that a texture must have the correct dimension TEST_F(BindGroupValidationTest, TextureDimension) { - dawn::BindGroupLayout layout = utils::MakeBindGroupLayout( - device, {{0, dawn::ShaderStage::Fragment, dawn::BindingType::SampledTexture, false, false, - dawn::TextureViewDimension::e2D, dawn::TextureComponentType::Float}}); + wgpu::BindGroupLayout layout = utils::MakeBindGroupLayout( + device, {{0, wgpu::ShaderStage::Fragment, wgpu::BindingType::SampledTexture, false, false, + wgpu::TextureViewDimension::e2D, wgpu::TextureComponentType::Float}}); // Control case: setting a 2D texture view works. utils::MakeBindGroup(device, layout, {{0, mSampledTextureView}}); // Make a 2DArray texture and try to set it to a 2D binding. - dawn::TextureDescriptor descriptor; - descriptor.dimension = dawn::TextureDimension::e2D; + wgpu::TextureDescriptor descriptor; + descriptor.dimension = wgpu::TextureDimension::e2D; descriptor.size = {16, 16, 1}; descriptor.arrayLayerCount = 2; descriptor.sampleCount = 1; - descriptor.format = dawn::TextureFormat::RGBA8Uint; + descriptor.format = wgpu::TextureFormat::RGBA8Uint; descriptor.mipLevelCount = 1; - descriptor.usage = dawn::TextureUsage::Sampled; - dawn::Texture arrayTexture = device.CreateTexture(&descriptor); - dawn::TextureView arrayTextureView = arrayTexture.CreateView(); + descriptor.usage = wgpu::TextureUsage::Sampled; + wgpu::Texture arrayTexture = device.CreateTexture(&descriptor); + wgpu::TextureView arrayTextureView = arrayTexture.CreateView(); ASSERT_DEVICE_ERROR(utils::MakeBindGroup(device, layout, {{0, arrayTextureView}})); } // Check that a UBO must have the correct usage TEST_F(BindGroupValidationTest, BufferUsageUBO) { - dawn::BindGroupLayout layout = utils::MakeBindGroupLayout( - device, {{0, dawn::ShaderStage::Fragment, dawn::BindingType::UniformBuffer}}); + wgpu::BindGroupLayout layout = utils::MakeBindGroupLayout( + device, {{0, wgpu::ShaderStage::Fragment, wgpu::BindingType::UniformBuffer}}); // Control case: using a buffer with the uniform usage works utils::MakeBindGroup(device, layout, {{0, mUBO, 0, 256}}); @@ -362,8 +362,8 @@ TEST_F(BindGroupValidationTest, BufferUsageUBO) { // Check that a SSBO must have the correct usage TEST_F(BindGroupValidationTest, BufferUsageSSBO) { - dawn::BindGroupLayout layout = utils::MakeBindGroupLayout( - device, {{0, dawn::ShaderStage::Fragment, dawn::BindingType::StorageBuffer}}); + wgpu::BindGroupLayout layout = utils::MakeBindGroupLayout( + device, {{0, wgpu::ShaderStage::Fragment, wgpu::BindingType::StorageBuffer}}); // Control case: using a buffer with the storage usage works utils::MakeBindGroup(device, layout, {{0, mSSBO, 0, 256}}); @@ -374,9 +374,9 @@ TEST_F(BindGroupValidationTest, BufferUsageSSBO) { // Tests constraints on the buffer offset for bind groups. TEST_F(BindGroupValidationTest, BufferOffsetAlignment) { - dawn::BindGroupLayout layout = utils::MakeBindGroupLayout( + wgpu::BindGroupLayout layout = utils::MakeBindGroupLayout( device, { - {0, dawn::ShaderStage::Vertex, dawn::BindingType::UniformBuffer}, + {0, wgpu::ShaderStage::Vertex, wgpu::BindingType::UniformBuffer}, }); // Check that offset 0 is valid @@ -393,15 +393,15 @@ TEST_F(BindGroupValidationTest, BufferOffsetAlignment) { // Tests constraints to be sure the buffer binding fits in the buffer TEST_F(BindGroupValidationTest, BufferBindingOOB) { - dawn::BindGroupLayout layout = utils::MakeBindGroupLayout( + wgpu::BindGroupLayout layout = utils::MakeBindGroupLayout( device, { - {0, dawn::ShaderStage::Vertex, dawn::BindingType::UniformBuffer}, + {0, wgpu::ShaderStage::Vertex, wgpu::BindingType::UniformBuffer}, }); - dawn::BufferDescriptor descriptor; + wgpu::BufferDescriptor descriptor; descriptor.size = 1024; - descriptor.usage = dawn::BufferUsage::Uniform; - dawn::Buffer buffer = device.CreateBuffer(&descriptor); + descriptor.usage = wgpu::BufferUsage::Uniform; + wgpu::Buffer buffer = device.CreateBuffer(&descriptor); // Success case, touching the start of the buffer works utils::MakeBindGroup(device, layout, {{0, buffer, 0, 256}}); @@ -412,7 +412,7 @@ TEST_F(BindGroupValidationTest, BufferBindingOOB) { // Success case, touching the full buffer works utils::MakeBindGroup(device, layout, {{0, buffer, 0, 1024}}); - utils::MakeBindGroup(device, layout, {{0, buffer, 0, dawn::kWholeSize}}); + utils::MakeBindGroup(device, layout, {{0, buffer, 0, wgpu::kWholeSize}}); // Error case, offset is OOB ASSERT_DEVICE_ERROR(utils::MakeBindGroup(device, layout, {{0, buffer, 256*5, 0}})); @@ -422,7 +422,7 @@ TEST_F(BindGroupValidationTest, BufferBindingOOB) { // Error case, offset+size is OOB ASSERT_DEVICE_ERROR(utils::MakeBindGroup(device, layout, {{0, buffer, 1024, 256}})); - ASSERT_DEVICE_ERROR(utils::MakeBindGroup(device, layout, {{0, buffer, 256, dawn::kWholeSize}})); + ASSERT_DEVICE_ERROR(utils::MakeBindGroup(device, layout, {{0, buffer, 256, wgpu::kWholeSize}})); // Error case, offset+size overflows to be 0 ASSERT_DEVICE_ERROR(utils::MakeBindGroup(device, layout, {{0, buffer, 256, uint32_t(0) - uint32_t(256)}})); @@ -430,17 +430,17 @@ TEST_F(BindGroupValidationTest, BufferBindingOOB) { // Test what happens when the layout is an error. TEST_F(BindGroupValidationTest, ErrorLayout) { - dawn::BindGroupLayout goodLayout = utils::MakeBindGroupLayout( + wgpu::BindGroupLayout goodLayout = utils::MakeBindGroupLayout( device, { - {0, dawn::ShaderStage::Vertex, dawn::BindingType::UniformBuffer}, + {0, wgpu::ShaderStage::Vertex, wgpu::BindingType::UniformBuffer}, }); - dawn::BindGroupLayout errorLayout; + wgpu::BindGroupLayout errorLayout; ASSERT_DEVICE_ERROR( errorLayout = utils::MakeBindGroupLayout( device, { - {0, dawn::ShaderStage::Vertex, dawn::BindingType::UniformBuffer}, - {0, dawn::ShaderStage::Vertex, dawn::BindingType::UniformBuffer}, + {0, wgpu::ShaderStage::Vertex, wgpu::BindingType::UniformBuffer}, + {0, wgpu::ShaderStage::Vertex, wgpu::BindingType::UniformBuffer}, })); // Control case, creating with the good layout works @@ -452,10 +452,10 @@ TEST_F(BindGroupValidationTest, ErrorLayout) { class BindGroupLayoutValidationTest : public ValidationTest { public: - void TestCreateBindGroupLayout(dawn::BindGroupLayoutBinding* binding, + void TestCreateBindGroupLayout(wgpu::BindGroupLayoutBinding* binding, uint32_t count, bool expected) { - dawn::BindGroupLayoutDescriptor descriptor; + wgpu::BindGroupLayoutDescriptor descriptor; descriptor.bindingCount = count; descriptor.bindings = binding; @@ -467,8 +467,8 @@ class BindGroupLayoutValidationTest : public ValidationTest { } } - void TestCreatePipelineLayout(dawn::BindGroupLayout* bgl, uint32_t count, bool expected) { - dawn::PipelineLayoutDescriptor descriptor; + void TestCreatePipelineLayout(wgpu::BindGroupLayout* bgl, uint32_t count, bool expected) { + wgpu::PipelineLayoutDescriptor descriptor; descriptor.bindGroupLayoutCount = count; descriptor.bindGroupLayouts = bgl; @@ -484,13 +484,13 @@ class BindGroupLayoutValidationTest : public ValidationTest { // Tests setting OOB checks for kMaxBindingsPerGroup in bind group layouts. TEST_F(BindGroupLayoutValidationTest, BindGroupLayoutBindingOOB) { // Checks that kMaxBindingsPerGroup - 1 is valid. - utils::MakeBindGroupLayout(device, {{kMaxBindingsPerGroup - 1, dawn::ShaderStage::Vertex, - dawn::BindingType::UniformBuffer}}); + utils::MakeBindGroupLayout(device, {{kMaxBindingsPerGroup - 1, wgpu::ShaderStage::Vertex, + wgpu::BindingType::UniformBuffer}}); // Checks that kMaxBindingsPerGroup is OOB ASSERT_DEVICE_ERROR(utils::MakeBindGroupLayout( device, - {{kMaxBindingsPerGroup, dawn::ShaderStage::Vertex, dawn::BindingType::UniformBuffer}})); + {{kMaxBindingsPerGroup, wgpu::ShaderStage::Vertex, wgpu::BindingType::UniformBuffer}})); } // This test verifies that the BindGroupLayout bindings are correctly validated, even if the @@ -498,8 +498,8 @@ TEST_F(BindGroupLayoutValidationTest, BindGroupLayoutBindingOOB) { TEST_F(BindGroupLayoutValidationTest, BindGroupBinding) { utils::MakeBindGroupLayout(device, { - {1, dawn::ShaderStage::Vertex, dawn::BindingType::UniformBuffer}, - {0, dawn::ShaderStage::Vertex, dawn::BindingType::UniformBuffer}, + {1, wgpu::ShaderStage::Vertex, wgpu::BindingType::UniformBuffer}, + {0, wgpu::ShaderStage::Vertex, wgpu::BindingType::UniformBuffer}, }); } @@ -507,22 +507,22 @@ TEST_F(BindGroupLayoutValidationTest, BindGroupBinding) { TEST_F(BindGroupLayoutValidationTest, DynamicAndTypeCompatibility) { utils::MakeBindGroupLayout( device, { - {0, dawn::ShaderStage::Compute, dawn::BindingType::UniformBuffer, true}, + {0, wgpu::ShaderStage::Compute, wgpu::BindingType::UniformBuffer, true}, }); utils::MakeBindGroupLayout( device, { - {0, dawn::ShaderStage::Compute, dawn::BindingType::StorageBuffer, true}, + {0, wgpu::ShaderStage::Compute, wgpu::BindingType::StorageBuffer, true}, }); ASSERT_DEVICE_ERROR(utils::MakeBindGroupLayout( device, { - {0, dawn::ShaderStage::Compute, dawn::BindingType::SampledTexture, true}, + {0, wgpu::ShaderStage::Compute, wgpu::BindingType::SampledTexture, true}, })); ASSERT_DEVICE_ERROR(utils::MakeBindGroupLayout( device, { - {0, dawn::ShaderStage::Compute, dawn::BindingType::Sampler, true}, + {0, wgpu::ShaderStage::Compute, wgpu::BindingType::Sampler, true}, })); } @@ -530,12 +530,12 @@ TEST_F(BindGroupLayoutValidationTest, DynamicAndTypeCompatibility) { TEST_F(BindGroupLayoutValidationTest, BindGroupLayoutVisibilityNone) { utils::MakeBindGroupLayout(device, { - {0, dawn::ShaderStage::Vertex, dawn::BindingType::UniformBuffer}, + {0, wgpu::ShaderStage::Vertex, wgpu::BindingType::UniformBuffer}, }); - dawn::BindGroupLayoutBinding binding = {0, dawn::ShaderStage::None, - dawn::BindingType::UniformBuffer}; - dawn::BindGroupLayoutDescriptor descriptor; + wgpu::BindGroupLayoutBinding binding = {0, wgpu::ShaderStage::None, + wgpu::BindingType::UniformBuffer}; + wgpu::BindGroupLayoutDescriptor descriptor; descriptor.bindingCount = 1; descriptor.bindings = &binding; device.CreateBindGroupLayout(&descriptor); @@ -543,23 +543,23 @@ TEST_F(BindGroupLayoutValidationTest, BindGroupLayoutVisibilityNone) { // Check that dynamic buffer numbers exceed maximum value in one bind group layout. TEST_F(BindGroupLayoutValidationTest, DynamicBufferNumberLimit) { - dawn::BindGroupLayout bgl[2]; - std::vector maxUniformDB; - std::vector maxStorageDB; + wgpu::BindGroupLayout bgl[2]; + std::vector maxUniformDB; + std::vector maxStorageDB; for (uint32_t i = 0; i < kMaxDynamicUniformBufferCount; ++i) { maxUniformDB.push_back( - {i, dawn::ShaderStage::Compute, dawn::BindingType::UniformBuffer, true}); + {i, wgpu::ShaderStage::Compute, wgpu::BindingType::UniformBuffer, true}); } for (uint32_t i = 0; i < kMaxDynamicStorageBufferCount; ++i) { maxStorageDB.push_back( - {i, dawn::ShaderStage::Compute, dawn::BindingType::StorageBuffer, true}); + {i, wgpu::ShaderStage::Compute, wgpu::BindingType::StorageBuffer, true}); } - auto MakeBindGroupLayout = [&](dawn::BindGroupLayoutBinding* binding, - uint32_t count) -> dawn::BindGroupLayout { - dawn::BindGroupLayoutDescriptor descriptor; + auto MakeBindGroupLayout = [&](wgpu::BindGroupLayoutBinding* binding, + uint32_t count) -> wgpu::BindGroupLayout { + wgpu::BindGroupLayoutDescriptor descriptor; descriptor.bindingCount = count; descriptor.bindings = binding; return device.CreateBindGroupLayout(&descriptor); @@ -577,7 +577,7 @@ TEST_F(BindGroupLayoutValidationTest, DynamicBufferNumberLimit) { bgl[0] = MakeBindGroupLayout(maxUniformDB.data(), maxUniformDB.size()); bgl[1] = utils::MakeBindGroupLayout( device, { - {0, dawn::ShaderStage::Compute, dawn::BindingType::UniformBuffer, true}, + {0, wgpu::ShaderStage::Compute, wgpu::BindingType::UniformBuffer, true}, }); TestCreatePipelineLayout(bgl, 2, false); @@ -588,7 +588,7 @@ TEST_F(BindGroupLayoutValidationTest, DynamicBufferNumberLimit) { bgl[0] = MakeBindGroupLayout(maxStorageDB.data(), maxStorageDB.size()); bgl[1] = utils::MakeBindGroupLayout( device, { - {0, dawn::ShaderStage::Compute, dawn::BindingType::StorageBuffer, true}, + {0, wgpu::ShaderStage::Compute, wgpu::BindingType::StorageBuffer, true}, }); TestCreatePipelineLayout(bgl, 2, false); @@ -596,15 +596,15 @@ TEST_F(BindGroupLayoutValidationTest, DynamicBufferNumberLimit) { // Check dynamic uniform buffers exceed maximum in bind group layout. { - maxUniformDB.push_back({kMaxDynamicUniformBufferCount, dawn::ShaderStage::Compute, - dawn::BindingType::UniformBuffer, true}); + maxUniformDB.push_back({kMaxDynamicUniformBufferCount, wgpu::ShaderStage::Compute, + wgpu::BindingType::UniformBuffer, true}); TestCreateBindGroupLayout(maxUniformDB.data(), maxUniformDB.size(), false); } // Check dynamic storage buffers exceed maximum in bind group layout. { - maxStorageDB.push_back({kMaxDynamicStorageBufferCount, dawn::ShaderStage::Compute, - dawn::BindingType::StorageBuffer, true}); + maxStorageDB.push_back({kMaxDynamicStorageBufferCount, wgpu::ShaderStage::Compute, + wgpu::BindingType::StorageBuffer, true}); TestCreateBindGroupLayout(maxStorageDB.data(), maxStorageDB.size(), false); } } @@ -616,32 +616,32 @@ class SetBindGroupValidationTest : public ValidationTest { public: void SetUp() override { mBindGroupLayout = utils::MakeBindGroupLayout( - device, {{0, dawn::ShaderStage::Compute | dawn::ShaderStage::Fragment, - dawn::BindingType::UniformBuffer, true}, - {1, dawn::ShaderStage::Compute | dawn::ShaderStage::Fragment, - dawn::BindingType::StorageBuffer, true}}); + device, {{0, wgpu::ShaderStage::Compute | wgpu::ShaderStage::Fragment, + wgpu::BindingType::UniformBuffer, true}, + {1, wgpu::ShaderStage::Compute | wgpu::ShaderStage::Fragment, + wgpu::BindingType::StorageBuffer, true}}); } - dawn::Buffer CreateBuffer(uint64_t bufferSize, dawn::BufferUsage usage) { - dawn::BufferDescriptor bufferDescriptor; + wgpu::Buffer CreateBuffer(uint64_t bufferSize, wgpu::BufferUsage usage) { + wgpu::BufferDescriptor bufferDescriptor; bufferDescriptor.size = bufferSize; bufferDescriptor.usage = usage; return device.CreateBuffer(&bufferDescriptor); } - dawn::BindGroupLayout mBindGroupLayout; - dawn::Buffer mUniformBuffer; - dawn::Buffer mStorageBuffer; + wgpu::BindGroupLayout mBindGroupLayout; + wgpu::Buffer mUniformBuffer; + wgpu::Buffer mStorageBuffer; - dawn::RenderPipeline CreateRenderPipeline() { - dawn::ShaderModule vsModule = + wgpu::RenderPipeline CreateRenderPipeline() { + wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, utils::SingleShaderStage::Vertex, R"( #version 450 void main() { })"); - dawn::ShaderModule fsModule = + wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, utils::SingleShaderStage::Fragment, R"( #version 450 layout(std140, set = 0, binding = 0) uniform uBuffer { @@ -657,14 +657,14 @@ class SetBindGroupValidationTest : public ValidationTest { utils::ComboRenderPipelineDescriptor pipelineDescriptor(device); pipelineDescriptor.vertexStage.module = vsModule; pipelineDescriptor.cFragmentStage.module = fsModule; - dawn::PipelineLayout pipelineLayout = + wgpu::PipelineLayout pipelineLayout = utils::MakeBasicPipelineLayout(device, &mBindGroupLayout); pipelineDescriptor.layout = pipelineLayout; return device.CreateRenderPipeline(&pipelineDescriptor); } - dawn::ComputePipeline CreateComputePipeline() { - dawn::ShaderModule csModule = + wgpu::ComputePipeline CreateComputePipeline() { + wgpu::ShaderModule csModule = utils::CreateShaderModule(device, utils::SingleShaderStage::Compute, R"( #version 450 const uint kTileSize = 4; @@ -681,10 +681,10 @@ class SetBindGroupValidationTest : public ValidationTest { void main() { })"); - dawn::PipelineLayout pipelineLayout = + wgpu::PipelineLayout pipelineLayout = utils::MakeBasicPipelineLayout(device, &mBindGroupLayout); - dawn::ComputePipelineDescriptor csDesc; + wgpu::ComputePipelineDescriptor csDesc; csDesc.layout = pipelineLayout; csDesc.computeStage.module = csModule; csDesc.computeStage.entryPoint = "main"; @@ -692,15 +692,15 @@ class SetBindGroupValidationTest : public ValidationTest { return device.CreateComputePipeline(&csDesc); } - void TestRenderPassBindGroup(dawn::BindGroup bindGroup, + void TestRenderPassBindGroup(wgpu::BindGroup bindGroup, uint64_t* offsets, uint32_t count, bool expectation) { - dawn::RenderPipeline renderPipeline = CreateRenderPipeline(); + wgpu::RenderPipeline renderPipeline = CreateRenderPipeline(); DummyRenderPass renderPass(device); - dawn::CommandEncoder commandEncoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder renderPassEncoder = commandEncoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder renderPassEncoder = commandEncoder.BeginRenderPass(&renderPass); renderPassEncoder.SetPipeline(renderPipeline); renderPassEncoder.SetBindGroup(0, bindGroup, count, offsets); renderPassEncoder.Draw(3, 1, 0, 0); @@ -712,14 +712,14 @@ class SetBindGroupValidationTest : public ValidationTest { } } - void TestComputePassBindGroup(dawn::BindGroup bindGroup, + void TestComputePassBindGroup(wgpu::BindGroup bindGroup, uint64_t* offsets, uint32_t count, bool expectation) { - dawn::ComputePipeline computePipeline = CreateComputePipeline(); + wgpu::ComputePipeline computePipeline = CreateComputePipeline(); - dawn::CommandEncoder commandEncoder = device.CreateCommandEncoder(); - dawn::ComputePassEncoder computePassEncoder = commandEncoder.BeginComputePass(); + wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); + wgpu::ComputePassEncoder computePassEncoder = commandEncoder.BeginComputePass(); computePassEncoder.SetPipeline(computePipeline); computePassEncoder.SetBindGroup(0, bindGroup, count, offsets); computePassEncoder.Dispatch(1, 1, 1); @@ -735,9 +735,9 @@ class SetBindGroupValidationTest : public ValidationTest { // This is the test case that should work. TEST_F(SetBindGroupValidationTest, Basic) { // Set up the bind group. - dawn::Buffer uniformBuffer = CreateBuffer(kBufferSize, dawn::BufferUsage::Uniform); - dawn::Buffer storageBuffer = CreateBuffer(kBufferSize, dawn::BufferUsage::Storage); - dawn::BindGroup bindGroup = utils::MakeBindGroup( + wgpu::Buffer uniformBuffer = CreateBuffer(kBufferSize, wgpu::BufferUsage::Uniform); + wgpu::Buffer storageBuffer = CreateBuffer(kBufferSize, wgpu::BufferUsage::Storage); + wgpu::BindGroup bindGroup = utils::MakeBindGroup( device, mBindGroupLayout, {{0, uniformBuffer, 0, kBindingSize}, {1, storageBuffer, 0, kBindingSize}}); @@ -751,9 +751,9 @@ TEST_F(SetBindGroupValidationTest, Basic) { // Test cases that test dynamic offsets count mismatch with bind group layout. TEST_F(SetBindGroupValidationTest, DynamicOffsetsMismatch) { // Set up bind group. - dawn::Buffer uniformBuffer = CreateBuffer(kBufferSize, dawn::BufferUsage::Uniform); - dawn::Buffer storageBuffer = CreateBuffer(kBufferSize, dawn::BufferUsage::Storage); - dawn::BindGroup bindGroup = utils::MakeBindGroup( + wgpu::Buffer uniformBuffer = CreateBuffer(kBufferSize, wgpu::BufferUsage::Uniform); + wgpu::Buffer storageBuffer = CreateBuffer(kBufferSize, wgpu::BufferUsage::Storage); + wgpu::BindGroup bindGroup = utils::MakeBindGroup( device, mBindGroupLayout, {{0, uniformBuffer, 0, kBindingSize}, {1, storageBuffer, 0, kBindingSize}}); @@ -768,9 +768,9 @@ TEST_F(SetBindGroupValidationTest, DynamicOffsetsMismatch) { // Test cases that test dynamic offsets not aligned TEST_F(SetBindGroupValidationTest, DynamicOffsetsNotAligned) { // Set up bind group. - dawn::Buffer uniformBuffer = CreateBuffer(kBufferSize, dawn::BufferUsage::Uniform); - dawn::Buffer storageBuffer = CreateBuffer(kBufferSize, dawn::BufferUsage::Storage); - dawn::BindGroup bindGroup = utils::MakeBindGroup( + wgpu::Buffer uniformBuffer = CreateBuffer(kBufferSize, wgpu::BufferUsage::Uniform); + wgpu::Buffer storageBuffer = CreateBuffer(kBufferSize, wgpu::BufferUsage::Storage); + wgpu::BindGroup bindGroup = utils::MakeBindGroup( device, mBindGroupLayout, {{0, uniformBuffer, 0, kBindingSize}, {1, storageBuffer, 0, kBindingSize}}); @@ -785,9 +785,9 @@ TEST_F(SetBindGroupValidationTest, DynamicOffsetsNotAligned) { // Test cases that test dynamic uniform buffer out of bound situation. TEST_F(SetBindGroupValidationTest, OffsetOutOfBoundDynamicUniformBuffer) { // Set up bind group. - dawn::Buffer uniformBuffer = CreateBuffer(kBufferSize, dawn::BufferUsage::Uniform); - dawn::Buffer storageBuffer = CreateBuffer(kBufferSize, dawn::BufferUsage::Storage); - dawn::BindGroup bindGroup = utils::MakeBindGroup( + wgpu::Buffer uniformBuffer = CreateBuffer(kBufferSize, wgpu::BufferUsage::Uniform); + wgpu::Buffer storageBuffer = CreateBuffer(kBufferSize, wgpu::BufferUsage::Storage); + wgpu::BindGroup bindGroup = utils::MakeBindGroup( device, mBindGroupLayout, {{0, uniformBuffer, 0, kBindingSize}, {1, storageBuffer, 0, kBindingSize}}); @@ -802,9 +802,9 @@ TEST_F(SetBindGroupValidationTest, OffsetOutOfBoundDynamicUniformBuffer) { // Test cases that test dynamic storage buffer out of bound situation. TEST_F(SetBindGroupValidationTest, OffsetOutOfBoundDynamicStorageBuffer) { // Set up bind group. - dawn::Buffer uniformBuffer = CreateBuffer(kBufferSize, dawn::BufferUsage::Uniform); - dawn::Buffer storageBuffer = CreateBuffer(kBufferSize, dawn::BufferUsage::Storage); - dawn::BindGroup bindGroup = utils::MakeBindGroup( + wgpu::Buffer uniformBuffer = CreateBuffer(kBufferSize, wgpu::BufferUsage::Uniform); + wgpu::Buffer storageBuffer = CreateBuffer(kBufferSize, wgpu::BufferUsage::Storage); + wgpu::BindGroup bindGroup = utils::MakeBindGroup( device, mBindGroupLayout, {{0, uniformBuffer, 0, kBindingSize}, {1, storageBuffer, 0, kBindingSize}}); @@ -819,9 +819,9 @@ TEST_F(SetBindGroupValidationTest, OffsetOutOfBoundDynamicStorageBuffer) { // Test cases that test dynamic uniform buffer out of bound situation because of binding size. TEST_F(SetBindGroupValidationTest, BindingSizeOutOfBoundDynamicUniformBuffer) { // Set up bind group, but binding size is larger than - dawn::Buffer uniformBuffer = CreateBuffer(kBufferSize, dawn::BufferUsage::Uniform); - dawn::Buffer storageBuffer = CreateBuffer(kBufferSize, dawn::BufferUsage::Storage); - dawn::BindGroup bindGroup = utils::MakeBindGroup( + wgpu::Buffer uniformBuffer = CreateBuffer(kBufferSize, wgpu::BufferUsage::Uniform); + wgpu::Buffer storageBuffer = CreateBuffer(kBufferSize, wgpu::BufferUsage::Storage); + wgpu::BindGroup bindGroup = utils::MakeBindGroup( device, mBindGroupLayout, {{0, uniformBuffer, 0, kBindingSize}, {1, storageBuffer, 0, kBindingSize}}); @@ -836,9 +836,9 @@ TEST_F(SetBindGroupValidationTest, BindingSizeOutOfBoundDynamicUniformBuffer) { // Test cases that test dynamic storage buffer out of bound situation because of binding size. TEST_F(SetBindGroupValidationTest, BindingSizeOutOfBoundDynamicStorageBuffer) { - dawn::Buffer uniformBuffer = CreateBuffer(kBufferSize, dawn::BufferUsage::Uniform); - dawn::Buffer storageBuffer = CreateBuffer(kBufferSize, dawn::BufferUsage::Storage); - dawn::BindGroup bindGroup = utils::MakeBindGroup( + wgpu::Buffer uniformBuffer = CreateBuffer(kBufferSize, wgpu::BufferUsage::Uniform); + wgpu::Buffer storageBuffer = CreateBuffer(kBufferSize, wgpu::BufferUsage::Storage); + wgpu::BindGroup bindGroup = utils::MakeBindGroup( device, mBindGroupLayout, {{0, uniformBuffer, 0, kBindingSize}, {1, storageBuffer, 0, kBindingSize}}); // Dynamic offset + offset isn't larger than buffer size. @@ -854,7 +854,7 @@ TEST_F(SetBindGroupValidationTest, BindingSizeOutOfBoundDynamicStorageBuffer) { // SetBindGroup TEST_F(SetBindGroupValidationTest, ErrorBindGroup) { // Bindgroup creation fails because not all bindings are specified. - dawn::BindGroup bindGroup; + wgpu::BindGroup bindGroup; ASSERT_DEVICE_ERROR(bindGroup = utils::MakeBindGroup(device, mBindGroupLayout, {})); TestRenderPassBindGroup(bindGroup, nullptr, 0, false); @@ -871,8 +871,8 @@ class SetBindGroupPersistenceValidationTest : public ValidationTest { })"); } - dawn::Buffer CreateBuffer(uint64_t bufferSize, dawn::BufferUsage usage) { - dawn::BufferDescriptor bufferDescriptor; + wgpu::Buffer CreateBuffer(uint64_t bufferSize, wgpu::BufferUsage usage) { + wgpu::BufferDescriptor bufferDescriptor; bufferDescriptor.size = bufferSize; bufferDescriptor.usage = usage; @@ -880,34 +880,34 @@ class SetBindGroupPersistenceValidationTest : public ValidationTest { } // Generates bind group layouts and a pipeline from a 2D list of binding types. - std::tuple, dawn::RenderPipeline> SetUpLayoutsAndPipeline( - std::vector> layouts) { - std::vector bindGroupLayouts(layouts.size()); + std::tuple, wgpu::RenderPipeline> SetUpLayoutsAndPipeline( + std::vector> layouts) { + std::vector bindGroupLayouts(layouts.size()); // Iterate through the desired bind group layouts. for (uint32_t l = 0; l < layouts.size(); ++l) { const auto& layout = layouts[l]; - std::vector bindings(layout.size()); + std::vector bindings(layout.size()); // Iterate through binding types and populate a list of BindGroupLayoutBindings. for (uint32_t b = 0; b < layout.size(); ++b) { - bindings[b] = {b, dawn::ShaderStage::Fragment, layout[b], false}; + bindings[b] = {b, wgpu::ShaderStage::Fragment, layout[b], false}; } // Create the bind group layout. - dawn::BindGroupLayoutDescriptor bglDescriptor; + wgpu::BindGroupLayoutDescriptor bglDescriptor; bglDescriptor.bindingCount = static_cast(bindings.size()); bglDescriptor.bindings = bindings.data(); bindGroupLayouts[l] = device.CreateBindGroupLayout(&bglDescriptor); } // Create a pipeline layout from the list of bind group layouts. - dawn::PipelineLayoutDescriptor pipelineLayoutDescriptor; + wgpu::PipelineLayoutDescriptor pipelineLayoutDescriptor; pipelineLayoutDescriptor.bindGroupLayoutCount = static_cast(bindGroupLayouts.size()); pipelineLayoutDescriptor.bindGroupLayouts = bindGroupLayouts.data(); - dawn::PipelineLayout pipelineLayout = + wgpu::PipelineLayout pipelineLayout = device.CreatePipelineLayout(&pipelineLayoutDescriptor); std::stringstream ss; @@ -918,13 +918,13 @@ class SetBindGroupPersistenceValidationTest : public ValidationTest { const auto& layout = layouts[l]; for (uint32_t b = 0; b < layout.size(); ++b) { - dawn::BindingType binding = layout[b]; + wgpu::BindingType binding = layout[b]; ss << "layout(std140, set = " << l << ", binding = " << b << ") "; switch (binding) { - case dawn::BindingType::StorageBuffer: + case wgpu::BindingType::StorageBuffer: ss << "buffer SBuffer"; break; - case dawn::BindingType::UniformBuffer: + case wgpu::BindingType::UniformBuffer: ss << "uniform UBuffer"; break; default: @@ -937,51 +937,51 @@ class SetBindGroupPersistenceValidationTest : public ValidationTest { ss << "layout(location = 0) out vec4 fragColor;\n"; ss << "void main() { fragColor = vec4(0.0, 1.0, 0.0, 1.0); }\n"; - dawn::ShaderModule fsModule = + wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, utils::SingleShaderStage::Fragment, ss.str().c_str()); utils::ComboRenderPipelineDescriptor pipelineDescriptor(device); pipelineDescriptor.vertexStage.module = mVsModule; pipelineDescriptor.cFragmentStage.module = fsModule; pipelineDescriptor.layout = pipelineLayout; - dawn::RenderPipeline pipeline = device.CreateRenderPipeline(&pipelineDescriptor); + wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&pipelineDescriptor); return std::make_tuple(bindGroupLayouts, pipeline); } private: - dawn::ShaderModule mVsModule; + wgpu::ShaderModule mVsModule; }; // Test it is valid to set bind groups before setting the pipeline. TEST_F(SetBindGroupPersistenceValidationTest, BindGroupBeforePipeline) { - std::vector bindGroupLayouts; - dawn::RenderPipeline pipeline; + std::vector bindGroupLayouts; + wgpu::RenderPipeline pipeline; std::tie(bindGroupLayouts, pipeline) = SetUpLayoutsAndPipeline({{ {{ - dawn::BindingType::UniformBuffer, - dawn::BindingType::UniformBuffer, + wgpu::BindingType::UniformBuffer, + wgpu::BindingType::UniformBuffer, }}, {{ - dawn::BindingType::StorageBuffer, - dawn::BindingType::UniformBuffer, + wgpu::BindingType::StorageBuffer, + wgpu::BindingType::UniformBuffer, }}, }}); - dawn::Buffer uniformBuffer = CreateBuffer(kBufferSize, dawn::BufferUsage::Uniform); - dawn::Buffer storageBuffer = CreateBuffer(kBufferSize, dawn::BufferUsage::Storage); + wgpu::Buffer uniformBuffer = CreateBuffer(kBufferSize, wgpu::BufferUsage::Uniform); + wgpu::Buffer storageBuffer = CreateBuffer(kBufferSize, wgpu::BufferUsage::Storage); - dawn::BindGroup bindGroup0 = utils::MakeBindGroup( + wgpu::BindGroup bindGroup0 = utils::MakeBindGroup( device, bindGroupLayouts[0], {{0, uniformBuffer, 0, kBindingSize}, {1, uniformBuffer, 0, kBindingSize}}); - dawn::BindGroup bindGroup1 = utils::MakeBindGroup( + wgpu::BindGroup bindGroup1 = utils::MakeBindGroup( device, bindGroupLayouts[1], {{0, storageBuffer, 0, kBindingSize}, {1, uniformBuffer, 0, kBindingSize}}); DummyRenderPass renderPass(device); - dawn::CommandEncoder commandEncoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder renderPassEncoder = commandEncoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder renderPassEncoder = commandEncoder.BeginRenderPass(&renderPass); renderPassEncoder.SetBindGroup(0, bindGroup0); renderPassEncoder.SetBindGroup(1, bindGroup1); @@ -996,50 +996,50 @@ TEST_F(SetBindGroupPersistenceValidationTest, BindGroupBeforePipeline) { // Test that it is valid to draw with bind groups that are not "inherited". They persist // after a pipeline change. TEST_F(SetBindGroupPersistenceValidationTest, NotVulkanInheritance) { - std::vector bindGroupLayoutsA; - dawn::RenderPipeline pipelineA; + std::vector bindGroupLayoutsA; + wgpu::RenderPipeline pipelineA; std::tie(bindGroupLayoutsA, pipelineA) = SetUpLayoutsAndPipeline({{ {{ - dawn::BindingType::UniformBuffer, - dawn::BindingType::StorageBuffer, + wgpu::BindingType::UniformBuffer, + wgpu::BindingType::StorageBuffer, }}, {{ - dawn::BindingType::UniformBuffer, - dawn::BindingType::UniformBuffer, + wgpu::BindingType::UniformBuffer, + wgpu::BindingType::UniformBuffer, }}, }}); - std::vector bindGroupLayoutsB; - dawn::RenderPipeline pipelineB; + std::vector bindGroupLayoutsB; + wgpu::RenderPipeline pipelineB; std::tie(bindGroupLayoutsB, pipelineB) = SetUpLayoutsAndPipeline({{ {{ - dawn::BindingType::StorageBuffer, - dawn::BindingType::UniformBuffer, + wgpu::BindingType::StorageBuffer, + wgpu::BindingType::UniformBuffer, }}, {{ - dawn::BindingType::UniformBuffer, - dawn::BindingType::UniformBuffer, + wgpu::BindingType::UniformBuffer, + wgpu::BindingType::UniformBuffer, }}, }}); - dawn::Buffer uniformBuffer = CreateBuffer(kBufferSize, dawn::BufferUsage::Uniform); - dawn::Buffer storageBuffer = CreateBuffer(kBufferSize, dawn::BufferUsage::Storage); + wgpu::Buffer uniformBuffer = CreateBuffer(kBufferSize, wgpu::BufferUsage::Uniform); + wgpu::Buffer storageBuffer = CreateBuffer(kBufferSize, wgpu::BufferUsage::Storage); - dawn::BindGroup bindGroupA0 = utils::MakeBindGroup( + wgpu::BindGroup bindGroupA0 = utils::MakeBindGroup( device, bindGroupLayoutsA[0], {{0, uniformBuffer, 0, kBindingSize}, {1, storageBuffer, 0, kBindingSize}}); - dawn::BindGroup bindGroupA1 = utils::MakeBindGroup( + wgpu::BindGroup bindGroupA1 = utils::MakeBindGroup( device, bindGroupLayoutsA[1], {{0, uniformBuffer, 0, kBindingSize}, {1, uniformBuffer, 0, kBindingSize}}); - dawn::BindGroup bindGroupB0 = utils::MakeBindGroup( + wgpu::BindGroup bindGroupB0 = utils::MakeBindGroup( device, bindGroupLayoutsB[0], {{0, storageBuffer, 0, kBindingSize}, {1, uniformBuffer, 0, kBindingSize}}); DummyRenderPass renderPass(device); - dawn::CommandEncoder commandEncoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder renderPassEncoder = commandEncoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder renderPassEncoder = commandEncoder.BeginRenderPass(&renderPass); renderPassEncoder.SetPipeline(pipelineA); renderPassEncoder.SetBindGroup(0, bindGroupA0); diff --git a/src/tests/unittests/validation/BufferValidationTests.cpp b/src/tests/unittests/validation/BufferValidationTests.cpp index dcd5816099..6326630dbd 100644 --- a/src/tests/unittests/validation/BufferValidationTests.cpp +++ b/src/tests/unittests/validation/BufferValidationTests.cpp @@ -23,14 +23,14 @@ using namespace testing; class MockBufferMapReadCallback { public: MOCK_METHOD4(Call, - void(DawnBufferMapAsyncStatus status, + void(WGPUBufferMapAsyncStatus status, const uint32_t* ptr, uint64_t dataLength, void* userdata)); }; static std::unique_ptr mockBufferMapReadCallback; -static void ToMockBufferMapReadCallback(DawnBufferMapAsyncStatus status, +static void ToMockBufferMapReadCallback(WGPUBufferMapAsyncStatus status, const void* ptr, uint64_t dataLength, void* userdata) { @@ -42,14 +42,14 @@ static void ToMockBufferMapReadCallback(DawnBufferMapAsyncStatus status, class MockBufferMapWriteCallback { public: MOCK_METHOD4(Call, - void(DawnBufferMapAsyncStatus status, + void(WGPUBufferMapAsyncStatus status, uint32_t* ptr, uint64_t dataLength, void* userdata)); }; static std::unique_ptr mockBufferMapWriteCallback; -static void ToMockBufferMapWriteCallback(DawnBufferMapAsyncStatus status, +static void ToMockBufferMapWriteCallback(WGPUBufferMapAsyncStatus status, void* ptr, uint64_t dataLength, void* userdata) { @@ -60,37 +60,37 @@ static void ToMockBufferMapWriteCallback(DawnBufferMapAsyncStatus status, class BufferValidationTest : public ValidationTest { protected: - dawn::Buffer CreateMapReadBuffer(uint64_t size) { - dawn::BufferDescriptor descriptor; - descriptor.size = size; - descriptor.usage = dawn::BufferUsage::MapRead; + wgpu::Buffer CreateMapReadBuffer(uint64_t size) { + wgpu::BufferDescriptor descriptor; + descriptor.size = size; + descriptor.usage = wgpu::BufferUsage::MapRead; - return device.CreateBuffer(&descriptor); - } - dawn::Buffer CreateMapWriteBuffer(uint64_t size) { - dawn::BufferDescriptor descriptor; - descriptor.size = size; - descriptor.usage = dawn::BufferUsage::MapWrite; + return device.CreateBuffer(&descriptor); + } + wgpu::Buffer CreateMapWriteBuffer(uint64_t size) { + wgpu::BufferDescriptor descriptor; + descriptor.size = size; + descriptor.usage = wgpu::BufferUsage::MapWrite; - return device.CreateBuffer(&descriptor); - } - dawn::Buffer CreateSetSubDataBuffer(uint64_t size) { - dawn::BufferDescriptor descriptor; - descriptor.size = size; - descriptor.usage = dawn::BufferUsage::CopyDst; + return device.CreateBuffer(&descriptor); + } + wgpu::Buffer CreateSetSubDataBuffer(uint64_t size) { + wgpu::BufferDescriptor descriptor; + descriptor.size = size; + descriptor.usage = wgpu::BufferUsage::CopyDst; - return device.CreateBuffer(&descriptor); - } + return device.CreateBuffer(&descriptor); + } - dawn::CreateBufferMappedResult CreateBufferMapped(uint64_t size, dawn::BufferUsage usage) { - dawn::BufferDescriptor descriptor; - descriptor.size = size; - descriptor.usage = usage; + wgpu::CreateBufferMappedResult CreateBufferMapped(uint64_t size, wgpu::BufferUsage usage) { + wgpu::BufferDescriptor descriptor; + descriptor.size = size; + descriptor.usage = usage; - return device.CreateBufferMapped(&descriptor); - } + return device.CreateBufferMapped(&descriptor); + } - dawn::Queue queue; + wgpu::Queue queue; private: void SetUp() override { @@ -114,9 +114,9 @@ class BufferValidationTest : public ValidationTest { TEST_F(BufferValidationTest, CreationSuccess) { // Success { - dawn::BufferDescriptor descriptor; + wgpu::BufferDescriptor descriptor; descriptor.size = 4; - descriptor.usage = dawn::BufferUsage::Uniform; + descriptor.usage = wgpu::BufferUsage::Uniform; device.CreateBuffer(&descriptor); } @@ -126,36 +126,36 @@ TEST_F(BufferValidationTest, CreationSuccess) { TEST_F(BufferValidationTest, CreationMapUsageRestrictions) { // MapRead with CopyDst is ok { - dawn::BufferDescriptor descriptor; + wgpu::BufferDescriptor descriptor; descriptor.size = 4; - descriptor.usage = dawn::BufferUsage::MapRead | dawn::BufferUsage::CopyDst; + descriptor.usage = wgpu::BufferUsage::MapRead | wgpu::BufferUsage::CopyDst; device.CreateBuffer(&descriptor); } // MapRead with something else is an error { - dawn::BufferDescriptor descriptor; + wgpu::BufferDescriptor descriptor; descriptor.size = 4; - descriptor.usage = dawn::BufferUsage::MapRead | dawn::BufferUsage::Uniform; + descriptor.usage = wgpu::BufferUsage::MapRead | wgpu::BufferUsage::Uniform; ASSERT_DEVICE_ERROR(device.CreateBuffer(&descriptor)); } // MapWrite with CopySrc is ok { - dawn::BufferDescriptor descriptor; + wgpu::BufferDescriptor descriptor; descriptor.size = 4; - descriptor.usage = dawn::BufferUsage::MapWrite | dawn::BufferUsage::CopySrc; + descriptor.usage = wgpu::BufferUsage::MapWrite | wgpu::BufferUsage::CopySrc; device.CreateBuffer(&descriptor); } // MapWrite with something else is an error { - dawn::BufferDescriptor descriptor; + wgpu::BufferDescriptor descriptor; descriptor.size = 4; - descriptor.usage = dawn::BufferUsage::MapWrite | dawn::BufferUsage::Uniform; + descriptor.usage = wgpu::BufferUsage::MapWrite | wgpu::BufferUsage::Uniform; ASSERT_DEVICE_ERROR(device.CreateBuffer(&descriptor)); } @@ -163,12 +163,12 @@ TEST_F(BufferValidationTest, CreationMapUsageRestrictions) { // Test the success case for mapping buffer for reading TEST_F(BufferValidationTest, MapReadSuccess) { - dawn::Buffer buf = CreateMapReadBuffer(4); + wgpu::Buffer buf = CreateMapReadBuffer(4); buf.MapReadAsync(ToMockBufferMapReadCallback, nullptr); EXPECT_CALL(*mockBufferMapReadCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, Ne(nullptr), 4u, _)) + Call(WGPUBufferMapAsyncStatus_Success, Ne(nullptr), 4u, _)) .Times(1); queue.Submit(0, nullptr); @@ -177,12 +177,12 @@ TEST_F(BufferValidationTest, MapReadSuccess) { // Test the success case for mapping buffer for writing TEST_F(BufferValidationTest, MapWriteSuccess) { - dawn::Buffer buf = CreateMapWriteBuffer(4); + wgpu::Buffer buf = CreateMapWriteBuffer(4); buf.MapWriteAsync(ToMockBufferMapWriteCallback, nullptr); EXPECT_CALL(*mockBufferMapWriteCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, Ne(nullptr), 4u, _)) + Call(WGPUBufferMapAsyncStatus_Success, Ne(nullptr), 4u, _)) .Times(1); queue.Submit(0, nullptr); @@ -191,7 +191,7 @@ TEST_F(BufferValidationTest, MapWriteSuccess) { // Test the success case for CreateBufferMapped TEST_F(BufferValidationTest, CreateBufferMappedSuccess) { - dawn::CreateBufferMappedResult result = CreateBufferMapped(4, dawn::BufferUsage::MapWrite); + wgpu::CreateBufferMappedResult result = CreateBufferMapped(4, wgpu::BufferUsage::MapWrite); ASSERT_NE(result.data, nullptr); ASSERT_EQ(result.dataLength, 4u); result.buffer.Unmap(); @@ -199,7 +199,7 @@ TEST_F(BufferValidationTest, CreateBufferMappedSuccess) { // Test the success case for non-mappable CreateBufferMapped TEST_F(BufferValidationTest, NonMappableCreateBufferMappedSuccess) { - dawn::CreateBufferMappedResult result = CreateBufferMapped(4, dawn::BufferUsage::CopySrc); + wgpu::CreateBufferMappedResult result = CreateBufferMapped(4, wgpu::BufferUsage::CopySrc); ASSERT_NE(result.data, nullptr); ASSERT_EQ(result.dataLength, 4u); result.buffer.Unmap(); @@ -207,14 +207,13 @@ TEST_F(BufferValidationTest, NonMappableCreateBufferMappedSuccess) { // Test map reading a buffer with wrong current usage TEST_F(BufferValidationTest, MapReadWrongUsage) { - dawn::BufferDescriptor descriptor; + wgpu::BufferDescriptor descriptor; descriptor.size = 4; - descriptor.usage = dawn::BufferUsage::CopyDst; + descriptor.usage = wgpu::BufferUsage::CopyDst; - dawn::Buffer buf = device.CreateBuffer(&descriptor); + wgpu::Buffer buf = device.CreateBuffer(&descriptor); - EXPECT_CALL(*mockBufferMapReadCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, 0u, _)) + EXPECT_CALL(*mockBufferMapReadCallback, Call(WGPUBufferMapAsyncStatus_Error, nullptr, 0u, _)) .Times(1); ASSERT_DEVICE_ERROR(buf.MapReadAsync(ToMockBufferMapReadCallback, nullptr)); @@ -222,14 +221,13 @@ TEST_F(BufferValidationTest, MapReadWrongUsage) { // Test map writing a buffer with wrong current usage TEST_F(BufferValidationTest, MapWriteWrongUsage) { - dawn::BufferDescriptor descriptor; + wgpu::BufferDescriptor descriptor; descriptor.size = 4; - descriptor.usage = dawn::BufferUsage::CopySrc; + descriptor.usage = wgpu::BufferUsage::CopySrc; - dawn::Buffer buf = device.CreateBuffer(&descriptor); + wgpu::Buffer buf = device.CreateBuffer(&descriptor); - EXPECT_CALL(*mockBufferMapWriteCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, 0u, _)) + EXPECT_CALL(*mockBufferMapWriteCallback, Call(WGPUBufferMapAsyncStatus_Error, nullptr, 0u, _)) .Times(1); ASSERT_DEVICE_ERROR(buf.MapWriteAsync(ToMockBufferMapWriteCallback, nullptr)); @@ -237,15 +235,15 @@ TEST_F(BufferValidationTest, MapWriteWrongUsage) { // Test map reading a buffer that is already mapped TEST_F(BufferValidationTest, MapReadAlreadyMapped) { - dawn::Buffer buf = CreateMapReadBuffer(4); + wgpu::Buffer buf = CreateMapReadBuffer(4); buf.MapReadAsync(ToMockBufferMapReadCallback, this + 0); EXPECT_CALL(*mockBufferMapReadCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, Ne(nullptr), 4u, this + 0)) + Call(WGPUBufferMapAsyncStatus_Success, Ne(nullptr), 4u, this + 0)) .Times(1); EXPECT_CALL(*mockBufferMapReadCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, 0u, this + 1)) + Call(WGPUBufferMapAsyncStatus_Error, nullptr, 0u, this + 1)) .Times(1); ASSERT_DEVICE_ERROR(buf.MapReadAsync(ToMockBufferMapReadCallback, this + 1)); @@ -254,15 +252,15 @@ TEST_F(BufferValidationTest, MapReadAlreadyMapped) { // Test map writing a buffer that is already mapped TEST_F(BufferValidationTest, MapWriteAlreadyMapped) { - dawn::Buffer buf = CreateMapWriteBuffer(4); + wgpu::Buffer buf = CreateMapWriteBuffer(4); buf.MapWriteAsync(ToMockBufferMapWriteCallback, this + 0); EXPECT_CALL(*mockBufferMapWriteCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, Ne(nullptr), 4u, this + 0)) + Call(WGPUBufferMapAsyncStatus_Success, Ne(nullptr), 4u, this + 0)) .Times(1); EXPECT_CALL(*mockBufferMapWriteCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, 0u, this + 1)) + Call(WGPUBufferMapAsyncStatus_Error, nullptr, 0u, this + 1)) .Times(1); ASSERT_DEVICE_ERROR(buf.MapWriteAsync(ToMockBufferMapWriteCallback, this + 1)); @@ -272,12 +270,11 @@ TEST_F(BufferValidationTest, MapWriteAlreadyMapped) { // Test unmapping before having the result gives UNKNOWN - for reading TEST_F(BufferValidationTest, MapReadUnmapBeforeResult) { - dawn::Buffer buf = CreateMapReadBuffer(4); + wgpu::Buffer buf = CreateMapReadBuffer(4); buf.MapReadAsync(ToMockBufferMapReadCallback, nullptr); - EXPECT_CALL(*mockBufferMapReadCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, nullptr, 0u, _)) + EXPECT_CALL(*mockBufferMapReadCallback, Call(WGPUBufferMapAsyncStatus_Unknown, nullptr, 0u, _)) .Times(1); buf.Unmap(); @@ -288,12 +285,11 @@ TEST_F(BufferValidationTest, MapReadUnmapBeforeResult) { // Test unmapping before having the result gives UNKNOWN - for writing TEST_F(BufferValidationTest, MapWriteUnmapBeforeResult) { - dawn::Buffer buf = CreateMapWriteBuffer(4); + wgpu::Buffer buf = CreateMapWriteBuffer(4); buf.MapWriteAsync(ToMockBufferMapWriteCallback, nullptr); - EXPECT_CALL(*mockBufferMapWriteCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, nullptr, 0u, _)) + EXPECT_CALL(*mockBufferMapWriteCallback, Call(WGPUBufferMapAsyncStatus_Unknown, nullptr, 0u, _)) .Times(1); buf.Unmap(); @@ -307,12 +303,12 @@ TEST_F(BufferValidationTest, MapWriteUnmapBeforeResult) { // when its external ref count reaches 0. TEST_F(BufferValidationTest, DISABLED_MapReadDestroyBeforeResult) { { - dawn::Buffer buf = CreateMapReadBuffer(4); + wgpu::Buffer buf = CreateMapReadBuffer(4); buf.MapReadAsync(ToMockBufferMapReadCallback, nullptr); EXPECT_CALL(*mockBufferMapReadCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, nullptr, 0u, _)) + Call(WGPUBufferMapAsyncStatus_Unknown, nullptr, 0u, _)) .Times(1); } @@ -326,12 +322,12 @@ TEST_F(BufferValidationTest, DISABLED_MapReadDestroyBeforeResult) { // when its external ref count reaches 0. TEST_F(BufferValidationTest, DISABLED_MapWriteDestroyBeforeResult) { { - dawn::Buffer buf = CreateMapWriteBuffer(4); + wgpu::Buffer buf = CreateMapWriteBuffer(4); buf.MapWriteAsync(ToMockBufferMapWriteCallback, nullptr); EXPECT_CALL(*mockBufferMapWriteCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, nullptr, 0u, _)) + Call(WGPUBufferMapAsyncStatus_Unknown, nullptr, 0u, _)) .Times(1); } @@ -343,19 +339,19 @@ TEST_F(BufferValidationTest, DISABLED_MapWriteDestroyBeforeResult) { // When a MapRead is cancelled with Unmap it might still be in flight, test doing a new request // works as expected and we don't get the cancelled request's data. TEST_F(BufferValidationTest, MapReadUnmapBeforeResultThenMapAgain) { - dawn::Buffer buf = CreateMapReadBuffer(4); + wgpu::Buffer buf = CreateMapReadBuffer(4); buf.MapReadAsync(ToMockBufferMapReadCallback, this + 0); EXPECT_CALL(*mockBufferMapReadCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, nullptr, 0u, this + 0)) + Call(WGPUBufferMapAsyncStatus_Unknown, nullptr, 0u, this + 0)) .Times(1); buf.Unmap(); buf.MapReadAsync(ToMockBufferMapReadCallback, this + 1); EXPECT_CALL(*mockBufferMapReadCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, Ne(nullptr), 4u, this + 1)) + Call(WGPUBufferMapAsyncStatus_Success, Ne(nullptr), 4u, this + 1)) .Times(1); queue.Submit(0, nullptr); } @@ -364,31 +360,31 @@ TEST_F(BufferValidationTest, MapReadUnmapBeforeResultThenMapAgain) { // When a MapWrite is cancelled with Unmap it might still be in flight, test doing a new request // works as expected and we don't get the cancelled request's data. TEST_F(BufferValidationTest, MapWriteUnmapBeforeResultThenMapAgain) { - dawn::Buffer buf = CreateMapWriteBuffer(4); + wgpu::Buffer buf = CreateMapWriteBuffer(4); buf.MapWriteAsync(ToMockBufferMapWriteCallback, this + 0); EXPECT_CALL(*mockBufferMapWriteCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, nullptr, 0u, this + 0)) + Call(WGPUBufferMapAsyncStatus_Unknown, nullptr, 0u, this + 0)) .Times(1); buf.Unmap(); buf.MapWriteAsync(ToMockBufferMapWriteCallback, this + 1); EXPECT_CALL(*mockBufferMapWriteCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, Ne(nullptr), 4u, this + 1)) + Call(WGPUBufferMapAsyncStatus_Success, Ne(nullptr), 4u, this + 1)) .Times(1); queue.Submit(0, nullptr); } // Test that the MapReadCallback isn't fired twice when unmap() is called inside the callback TEST_F(BufferValidationTest, UnmapInsideMapReadCallback) { - dawn::Buffer buf = CreateMapReadBuffer(4); + wgpu::Buffer buf = CreateMapReadBuffer(4); buf.MapReadAsync(ToMockBufferMapReadCallback, nullptr); EXPECT_CALL(*mockBufferMapReadCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, Ne(nullptr), 4u, _)) + Call(WGPUBufferMapAsyncStatus_Success, Ne(nullptr), 4u, _)) .WillOnce(InvokeWithoutArgs([&]() { buf.Unmap(); })); queue.Submit(0, nullptr); @@ -396,12 +392,12 @@ TEST_F(BufferValidationTest, UnmapInsideMapReadCallback) { // Test that the MapWriteCallback isn't fired twice when unmap() is called inside the callback TEST_F(BufferValidationTest, UnmapInsideMapWriteCallback) { - dawn::Buffer buf = CreateMapWriteBuffer(4); + wgpu::Buffer buf = CreateMapWriteBuffer(4); buf.MapWriteAsync(ToMockBufferMapWriteCallback, nullptr); EXPECT_CALL(*mockBufferMapWriteCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, Ne(nullptr), 4u, _)) + Call(WGPUBufferMapAsyncStatus_Success, Ne(nullptr), 4u, _)) .WillOnce(InvokeWithoutArgs([&]() { buf.Unmap(); })); queue.Submit(0, nullptr); @@ -409,33 +405,33 @@ TEST_F(BufferValidationTest, UnmapInsideMapWriteCallback) { // Test that the MapReadCallback isn't fired twice the buffer external refcount reaches 0 in the callback TEST_F(BufferValidationTest, DestroyInsideMapReadCallback) { - dawn::Buffer buf = CreateMapReadBuffer(4); + wgpu::Buffer buf = CreateMapReadBuffer(4); buf.MapReadAsync(ToMockBufferMapReadCallback, nullptr); EXPECT_CALL(*mockBufferMapReadCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, Ne(nullptr), 4u, _)) - .WillOnce(InvokeWithoutArgs([&]() { buf = dawn::Buffer(); })); + Call(WGPUBufferMapAsyncStatus_Success, Ne(nullptr), 4u, _)) + .WillOnce(InvokeWithoutArgs([&]() { buf = wgpu::Buffer(); })); queue.Submit(0, nullptr); } // Test that the MapWriteCallback isn't fired twice the buffer external refcount reaches 0 in the callback TEST_F(BufferValidationTest, DestroyInsideMapWriteCallback) { - dawn::Buffer buf = CreateMapWriteBuffer(4); + wgpu::Buffer buf = CreateMapWriteBuffer(4); buf.MapWriteAsync(ToMockBufferMapWriteCallback, nullptr); EXPECT_CALL(*mockBufferMapWriteCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, Ne(nullptr), 4u, _)) - .WillOnce(InvokeWithoutArgs([&]() { buf = dawn::Buffer(); })); + Call(WGPUBufferMapAsyncStatus_Success, Ne(nullptr), 4u, _)) + .WillOnce(InvokeWithoutArgs([&]() { buf = wgpu::Buffer(); })); queue.Submit(0, nullptr); } // Test the success case for Buffer::SetSubData TEST_F(BufferValidationTest, SetSubDataSuccess) { - dawn::Buffer buf = CreateSetSubDataBuffer(4); + wgpu::Buffer buf = CreateSetSubDataBuffer(4); uint32_t foo = 0x01020304; buf.SetSubData(0, sizeof(foo), &foo); @@ -443,7 +439,7 @@ TEST_F(BufferValidationTest, SetSubDataSuccess) { // Test error case for SetSubData out of bounds TEST_F(BufferValidationTest, SetSubDataOutOfBounds) { - dawn::Buffer buf = CreateSetSubDataBuffer(1); + wgpu::Buffer buf = CreateSetSubDataBuffer(1); uint8_t foo[2] = {0, 0}; ASSERT_DEVICE_ERROR(buf.SetSubData(0, 2, foo)); @@ -451,7 +447,7 @@ TEST_F(BufferValidationTest, SetSubDataOutOfBounds) { // Test error case for SetSubData out of bounds with an overflow TEST_F(BufferValidationTest, SetSubDataOutOfBoundsOverflow) { - dawn::Buffer buf = CreateSetSubDataBuffer(1000); + wgpu::Buffer buf = CreateSetSubDataBuffer(1000); uint8_t foo[2] = {0, 0}; @@ -464,11 +460,11 @@ TEST_F(BufferValidationTest, SetSubDataOutOfBoundsOverflow) { // Test error case for SetSubData with the wrong usage TEST_F(BufferValidationTest, SetSubDataWrongUsage) { - dawn::BufferDescriptor descriptor; + wgpu::BufferDescriptor descriptor; descriptor.size = 4; - descriptor.usage = dawn::BufferUsage::Vertex; + descriptor.usage = wgpu::BufferUsage::Vertex; - dawn::Buffer buf = device.CreateBuffer(&descriptor); + wgpu::Buffer buf = device.CreateBuffer(&descriptor); uint8_t foo = 0; ASSERT_DEVICE_ERROR(buf.SetSubData(0, sizeof(foo), &foo)); @@ -476,11 +472,11 @@ TEST_F(BufferValidationTest, SetSubDataWrongUsage) { // Test SetSubData with unaligned size TEST_F(BufferValidationTest, SetSubDataWithUnalignedSize) { - dawn::BufferDescriptor descriptor; + wgpu::BufferDescriptor descriptor; descriptor.size = 4; - descriptor.usage = dawn::BufferUsage::CopySrc | dawn::BufferUsage::CopyDst; + descriptor.usage = wgpu::BufferUsage::CopySrc | wgpu::BufferUsage::CopyDst; - dawn::Buffer buf = device.CreateBuffer(&descriptor); + wgpu::Buffer buf = device.CreateBuffer(&descriptor); uint8_t value = 123; ASSERT_DEVICE_ERROR(buf.SetSubData(0, sizeof(value), &value)); @@ -488,11 +484,11 @@ TEST_F(BufferValidationTest, SetSubDataWithUnalignedSize) { // Test SetSubData with unaligned offset TEST_F(BufferValidationTest, SetSubDataWithUnalignedOffset) { - dawn::BufferDescriptor descriptor; + wgpu::BufferDescriptor descriptor; descriptor.size = 4000; - descriptor.usage = dawn::BufferUsage::CopySrc | dawn::BufferUsage::CopyDst; + descriptor.usage = wgpu::BufferUsage::CopySrc | wgpu::BufferUsage::CopyDst; - dawn::Buffer buf = device.CreateBuffer(&descriptor); + wgpu::Buffer buf = device.CreateBuffer(&descriptor); uint64_t kOffset = 2999; uint32_t value = 0x01020304; @@ -502,11 +498,11 @@ TEST_F(BufferValidationTest, SetSubDataWithUnalignedOffset) { // Test that it is valid to destroy an unmapped buffer TEST_F(BufferValidationTest, DestroyUnmappedBuffer) { { - dawn::Buffer buf = CreateMapReadBuffer(4); + wgpu::Buffer buf = CreateMapReadBuffer(4); buf.Destroy(); } { - dawn::Buffer buf = CreateMapWriteBuffer(4); + wgpu::Buffer buf = CreateMapWriteBuffer(4); buf.Destroy(); } } @@ -514,12 +510,12 @@ TEST_F(BufferValidationTest, DestroyUnmappedBuffer) { // Test that it is valid to destroy a mapped buffer TEST_F(BufferValidationTest, DestroyMappedBuffer) { { - dawn::Buffer buf = CreateMapReadBuffer(4); + wgpu::Buffer buf = CreateMapReadBuffer(4); buf.MapReadAsync(ToMockBufferMapReadCallback, nullptr); buf.Destroy(); } { - dawn::Buffer buf = CreateMapWriteBuffer(4); + wgpu::Buffer buf = CreateMapWriteBuffer(4); buf.MapWriteAsync(ToMockBufferMapWriteCallback, nullptr); buf.Destroy(); } @@ -528,21 +524,21 @@ TEST_F(BufferValidationTest, DestroyMappedBuffer) { // Test that destroying a buffer implicitly unmaps it TEST_F(BufferValidationTest, DestroyMappedBufferCausesImplicitUnmap) { { - dawn::Buffer buf = CreateMapReadBuffer(4); + wgpu::Buffer buf = CreateMapReadBuffer(4); buf.MapReadAsync(ToMockBufferMapReadCallback, this + 0); // Buffer is destroyed. Callback should be called with UNKNOWN status EXPECT_CALL(*mockBufferMapReadCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, nullptr, 0, this + 0)) + Call(WGPUBufferMapAsyncStatus_Unknown, nullptr, 0, this + 0)) .Times(1); buf.Destroy(); queue.Submit(0, nullptr); } { - dawn::Buffer buf = CreateMapWriteBuffer(4); + wgpu::Buffer buf = CreateMapWriteBuffer(4); buf.MapWriteAsync(ToMockBufferMapWriteCallback, this + 1); // Buffer is destroyed. Callback should be called with UNKNOWN status EXPECT_CALL(*mockBufferMapWriteCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, nullptr, 0, this + 1)) + Call(WGPUBufferMapAsyncStatus_Unknown, nullptr, 0, this + 1)) .Times(1); buf.Destroy(); queue.Submit(0, nullptr); @@ -551,7 +547,7 @@ TEST_F(BufferValidationTest, DestroyMappedBufferCausesImplicitUnmap) { // Test that it is valid to Destroy a destroyed buffer TEST_F(BufferValidationTest, DestroyDestroyedBuffer) { - dawn::Buffer buf = CreateSetSubDataBuffer(4); + wgpu::Buffer buf = CreateSetSubDataBuffer(4); buf.Destroy(); buf.Destroy(); } @@ -559,12 +555,12 @@ TEST_F(BufferValidationTest, DestroyDestroyedBuffer) { // Test that it is invalid to Unmap a destroyed buffer TEST_F(BufferValidationTest, UnmapDestroyedBuffer) { { - dawn::Buffer buf = CreateMapReadBuffer(4); + wgpu::Buffer buf = CreateMapReadBuffer(4); buf.Destroy(); ASSERT_DEVICE_ERROR(buf.Unmap()); } { - dawn::Buffer buf = CreateMapWriteBuffer(4); + wgpu::Buffer buf = CreateMapWriteBuffer(4); buf.Destroy(); ASSERT_DEVICE_ERROR(buf.Unmap()); } @@ -573,12 +569,12 @@ TEST_F(BufferValidationTest, UnmapDestroyedBuffer) { // Test that it is invalid to map a destroyed buffer TEST_F(BufferValidationTest, MapDestroyedBuffer) { { - dawn::Buffer buf = CreateMapReadBuffer(4); + wgpu::Buffer buf = CreateMapReadBuffer(4); buf.Destroy(); ASSERT_DEVICE_ERROR(buf.MapReadAsync(ToMockBufferMapReadCallback, nullptr)); } { - dawn::Buffer buf = CreateMapWriteBuffer(4); + wgpu::Buffer buf = CreateMapWriteBuffer(4); buf.Destroy(); ASSERT_DEVICE_ERROR(buf.MapWriteAsync(ToMockBufferMapWriteCallback, nullptr)); } @@ -586,7 +582,7 @@ TEST_F(BufferValidationTest, MapDestroyedBuffer) { // Test that it is invalid to call SetSubData on a destroyed buffer TEST_F(BufferValidationTest, SetSubDataDestroyedBuffer) { - dawn::Buffer buf = CreateSetSubDataBuffer(4); + wgpu::Buffer buf = CreateSetSubDataBuffer(4); buf.Destroy(); uint8_t foo = 0; ASSERT_DEVICE_ERROR(buf.SetSubData(0, sizeof(foo), &foo)); @@ -595,13 +591,13 @@ TEST_F(BufferValidationTest, SetSubDataDestroyedBuffer) { // Test that is is invalid to Map a mapped buffer TEST_F(BufferValidationTest, MapMappedBuffer) { { - dawn::Buffer buf = CreateMapReadBuffer(4); + wgpu::Buffer buf = CreateMapReadBuffer(4); buf.MapReadAsync(ToMockBufferMapReadCallback, nullptr); ASSERT_DEVICE_ERROR(buf.MapReadAsync(ToMockBufferMapReadCallback, nullptr)); queue.Submit(0, nullptr); } { - dawn::Buffer buf = CreateMapWriteBuffer(4); + wgpu::Buffer buf = CreateMapWriteBuffer(4); buf.MapWriteAsync(ToMockBufferMapWriteCallback, nullptr); ASSERT_DEVICE_ERROR(buf.MapWriteAsync(ToMockBufferMapWriteCallback, nullptr)); queue.Submit(0, nullptr); @@ -611,12 +607,12 @@ TEST_F(BufferValidationTest, MapMappedBuffer) { // Test that is is invalid to Map a CreateBufferMapped buffer TEST_F(BufferValidationTest, MapCreateBufferMappedBuffer) { { - dawn::Buffer buf = CreateBufferMapped(4, dawn::BufferUsage::MapRead).buffer; + wgpu::Buffer buf = CreateBufferMapped(4, wgpu::BufferUsage::MapRead).buffer; ASSERT_DEVICE_ERROR(buf.MapReadAsync(ToMockBufferMapReadCallback, nullptr)); queue.Submit(0, nullptr); } { - dawn::Buffer buf = CreateBufferMapped(4, dawn::BufferUsage::MapWrite).buffer; + wgpu::Buffer buf = CreateBufferMapped(4, wgpu::BufferUsage::MapWrite).buffer; ASSERT_DEVICE_ERROR(buf.MapWriteAsync(ToMockBufferMapWriteCallback, nullptr)); queue.Submit(0, nullptr); } @@ -625,14 +621,14 @@ TEST_F(BufferValidationTest, MapCreateBufferMappedBuffer) { // Test that it is invalid to call SetSubData on a mapped buffer TEST_F(BufferValidationTest, SetSubDataMappedBuffer) { { - dawn::Buffer buf = CreateMapReadBuffer(4); + wgpu::Buffer buf = CreateMapReadBuffer(4); buf.MapReadAsync(ToMockBufferMapReadCallback, nullptr); uint8_t foo = 0; ASSERT_DEVICE_ERROR(buf.SetSubData(0, sizeof(foo), &foo)); queue.Submit(0, nullptr); } { - dawn::Buffer buf = CreateMapWriteBuffer(4); + wgpu::Buffer buf = CreateMapWriteBuffer(4); buf.MapWriteAsync(ToMockBufferMapWriteCallback, nullptr); uint8_t foo = 0; ASSERT_DEVICE_ERROR(buf.SetSubData(0, sizeof(foo), &foo)); @@ -642,73 +638,73 @@ TEST_F(BufferValidationTest, SetSubDataMappedBuffer) { // Test that it is valid to submit a buffer in a queue with a map usage if it is unmapped TEST_F(BufferValidationTest, SubmitBufferWithMapUsage) { - dawn::BufferDescriptor descriptorA; + wgpu::BufferDescriptor descriptorA; descriptorA.size = 4; - descriptorA.usage = dawn::BufferUsage::CopySrc | dawn::BufferUsage::MapWrite; + descriptorA.usage = wgpu::BufferUsage::CopySrc | wgpu::BufferUsage::MapWrite; - dawn::BufferDescriptor descriptorB; + wgpu::BufferDescriptor descriptorB; descriptorB.size = 4; - descriptorB.usage = dawn::BufferUsage::CopyDst | dawn::BufferUsage::MapRead; + descriptorB.usage = wgpu::BufferUsage::CopyDst | wgpu::BufferUsage::MapRead; - dawn::Buffer bufA = device.CreateBuffer(&descriptorA); - dawn::Buffer bufB = device.CreateBuffer(&descriptorB); + wgpu::Buffer bufA = device.CreateBuffer(&descriptorA); + wgpu::Buffer bufB = device.CreateBuffer(&descriptorB); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); encoder.CopyBufferToBuffer(bufA, 0, bufB, 0, 4); - dawn::CommandBuffer commands = encoder.Finish(); + wgpu::CommandBuffer commands = encoder.Finish(); queue.Submit(1, &commands); } // Test that it is invalid to submit a mapped buffer in a queue TEST_F(BufferValidationTest, SubmitMappedBuffer) { - dawn::BufferDescriptor descriptorA; + wgpu::BufferDescriptor descriptorA; descriptorA.size = 4; - descriptorA.usage = dawn::BufferUsage::CopySrc | dawn::BufferUsage::MapWrite; + descriptorA.usage = wgpu::BufferUsage::CopySrc | wgpu::BufferUsage::MapWrite; - dawn::BufferDescriptor descriptorB; + wgpu::BufferDescriptor descriptorB; descriptorB.size = 4; - descriptorB.usage = dawn::BufferUsage::CopyDst | dawn::BufferUsage::MapRead; + descriptorB.usage = wgpu::BufferUsage::CopyDst | wgpu::BufferUsage::MapRead; { - dawn::Buffer bufA = device.CreateBuffer(&descriptorA); - dawn::Buffer bufB = device.CreateBuffer(&descriptorB); + wgpu::Buffer bufA = device.CreateBuffer(&descriptorA); + wgpu::Buffer bufB = device.CreateBuffer(&descriptorB); bufA.MapWriteAsync(ToMockBufferMapWriteCallback, nullptr); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); encoder.CopyBufferToBuffer(bufA, 0, bufB, 0, 4); - dawn::CommandBuffer commands = encoder.Finish(); + wgpu::CommandBuffer commands = encoder.Finish(); ASSERT_DEVICE_ERROR(queue.Submit(1, &commands)); queue.Submit(0, nullptr); } { - dawn::Buffer bufA = device.CreateBuffer(&descriptorA); - dawn::Buffer bufB = device.CreateBuffer(&descriptorB); + wgpu::Buffer bufA = device.CreateBuffer(&descriptorA); + wgpu::Buffer bufB = device.CreateBuffer(&descriptorB); bufB.MapReadAsync(ToMockBufferMapReadCallback, nullptr); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); encoder.CopyBufferToBuffer(bufA, 0, bufB, 0, 4); - dawn::CommandBuffer commands = encoder.Finish(); + wgpu::CommandBuffer commands = encoder.Finish(); ASSERT_DEVICE_ERROR(queue.Submit(1, &commands)); queue.Submit(0, nullptr); } { - dawn::Buffer bufA = device.CreateBufferMapped(&descriptorA).buffer; - dawn::Buffer bufB = device.CreateBuffer(&descriptorB); + wgpu::Buffer bufA = device.CreateBufferMapped(&descriptorA).buffer; + wgpu::Buffer bufB = device.CreateBuffer(&descriptorB); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); encoder.CopyBufferToBuffer(bufA, 0, bufB, 0, 4); - dawn::CommandBuffer commands = encoder.Finish(); + wgpu::CommandBuffer commands = encoder.Finish(); ASSERT_DEVICE_ERROR(queue.Submit(1, &commands)); queue.Submit(0, nullptr); } { - dawn::Buffer bufA = device.CreateBuffer(&descriptorA); - dawn::Buffer bufB = device.CreateBufferMapped(&descriptorB).buffer; + wgpu::Buffer bufA = device.CreateBuffer(&descriptorA); + wgpu::Buffer bufB = device.CreateBufferMapped(&descriptorB).buffer; - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); encoder.CopyBufferToBuffer(bufA, 0, bufB, 0, 4); - dawn::CommandBuffer commands = encoder.Finish(); + wgpu::CommandBuffer commands = encoder.Finish(); ASSERT_DEVICE_ERROR(queue.Submit(1, &commands)); queue.Submit(0, nullptr); } @@ -716,34 +712,34 @@ TEST_F(BufferValidationTest, SubmitMappedBuffer) { // Test that it is invalid to submit a destroyed buffer in a queue TEST_F(BufferValidationTest, SubmitDestroyedBuffer) { - dawn::BufferDescriptor descriptorA; + wgpu::BufferDescriptor descriptorA; descriptorA.size = 4; - descriptorA.usage = dawn::BufferUsage::CopySrc; + descriptorA.usage = wgpu::BufferUsage::CopySrc; - dawn::BufferDescriptor descriptorB; + wgpu::BufferDescriptor descriptorB; descriptorB.size = 4; - descriptorB.usage = dawn::BufferUsage::CopyDst; + descriptorB.usage = wgpu::BufferUsage::CopyDst; - dawn::Buffer bufA = device.CreateBuffer(&descriptorA); - dawn::Buffer bufB = device.CreateBuffer(&descriptorB); + wgpu::Buffer bufA = device.CreateBuffer(&descriptorA); + wgpu::Buffer bufB = device.CreateBuffer(&descriptorB); bufA.Destroy(); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); encoder.CopyBufferToBuffer(bufA, 0, bufB, 0, 4); - dawn::CommandBuffer commands = encoder.Finish(); + wgpu::CommandBuffer commands = encoder.Finish(); ASSERT_DEVICE_ERROR(queue.Submit(1, &commands)); } // Test that a map usage is required to call Unmap TEST_F(BufferValidationTest, UnmapWithoutMapUsage) { - dawn::Buffer buf = CreateSetSubDataBuffer(4); + wgpu::Buffer buf = CreateSetSubDataBuffer(4); ASSERT_DEVICE_ERROR(buf.Unmap()); } // Test that it is valid to call Unmap on a buffer that is not mapped TEST_F(BufferValidationTest, UnmapUnmappedBuffer) { { - dawn::Buffer buf = CreateMapReadBuffer(4); + wgpu::Buffer buf = CreateMapReadBuffer(4); // Buffer starts unmapped. Unmap should succeed. buf.Unmap(); buf.MapReadAsync(ToMockBufferMapReadCallback, nullptr); @@ -752,7 +748,7 @@ TEST_F(BufferValidationTest, UnmapUnmappedBuffer) { buf.Unmap(); } { - dawn::Buffer buf = CreateMapWriteBuffer(4); + wgpu::Buffer buf = CreateMapWriteBuffer(4); // Buffer starts unmapped. Unmap should succeed. buf.Unmap(); buf.MapWriteAsync(ToMockBufferMapWriteCallback, nullptr); diff --git a/src/tests/unittests/validation/CommandBufferValidationTests.cpp b/src/tests/unittests/validation/CommandBufferValidationTests.cpp index 6bdae68e92..cc4ab6798c 100644 --- a/src/tests/unittests/validation/CommandBufferValidationTests.cpp +++ b/src/tests/unittests/validation/CommandBufferValidationTests.cpp @@ -30,24 +30,24 @@ TEST_F(CommandBufferValidationTest, EndedMidRenderPass) { // Control case, command buffer ended after the pass is ended. { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&dummyRenderPass); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&dummyRenderPass); pass.EndPass(); encoder.Finish(); } // Error case, command buffer ended mid-pass. { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&dummyRenderPass); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&dummyRenderPass); ASSERT_DEVICE_ERROR(encoder.Finish()); } // Error case, command buffer ended mid-pass. Trying to use encoders after Finish // should fail too. { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&dummyRenderPass); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&dummyRenderPass); ASSERT_DEVICE_ERROR(encoder.Finish()); ASSERT_DEVICE_ERROR(pass.EndPass()); } @@ -57,24 +57,24 @@ TEST_F(CommandBufferValidationTest, EndedMidRenderPass) { TEST_F(CommandBufferValidationTest, EndedMidComputePass) { // Control case, command buffer ended after the pass is ended. { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); - dawn::ComputePassEncoder pass = encoder.BeginComputePass(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::ComputePassEncoder pass = encoder.BeginComputePass(); pass.EndPass(); encoder.Finish(); } // Error case, command buffer ended mid-pass. { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); - dawn::ComputePassEncoder pass = encoder.BeginComputePass(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::ComputePassEncoder pass = encoder.BeginComputePass(); ASSERT_DEVICE_ERROR(encoder.Finish()); } // Error case, command buffer ended mid-pass. Trying to use encoders after Finish // should fail too. { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); - dawn::ComputePassEncoder pass = encoder.BeginComputePass(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::ComputePassEncoder pass = encoder.BeginComputePass(); ASSERT_DEVICE_ERROR(encoder.Finish()); ASSERT_DEVICE_ERROR(pass.EndPass()); } @@ -86,16 +86,16 @@ TEST_F(CommandBufferValidationTest, RenderPassEndedTwice) { // Control case, pass is ended once { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&dummyRenderPass); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&dummyRenderPass); pass.EndPass(); encoder.Finish(); } // Error case, pass ended twice { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&dummyRenderPass); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&dummyRenderPass); pass.EndPass(); pass.EndPass(); ASSERT_DEVICE_ERROR(encoder.Finish()); @@ -106,16 +106,16 @@ TEST_F(CommandBufferValidationTest, RenderPassEndedTwice) { TEST_F(CommandBufferValidationTest, ComputePassEndedTwice) { // Control case, pass is ended once. { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); - dawn::ComputePassEncoder pass = encoder.BeginComputePass(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::ComputePassEncoder pass = encoder.BeginComputePass(); pass.EndPass(); encoder.Finish(); } // Error case, pass ended twice { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); - dawn::ComputePassEncoder pass = encoder.BeginComputePass(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::ComputePassEncoder pass = encoder.BeginComputePass(); pass.EndPass(); pass.EndPass(); ASSERT_DEVICE_ERROR(encoder.Finish()); @@ -128,9 +128,9 @@ TEST_F(CommandBufferValidationTest, BeginComputePassBeforeEndPreviousPass) { // Beginning a compute pass before ending a render pass causes an error. { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder renderPass = encoder.BeginRenderPass(&dummyRenderPass); - dawn::ComputePassEncoder computePass = encoder.BeginComputePass(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder renderPass = encoder.BeginRenderPass(&dummyRenderPass); + wgpu::ComputePassEncoder computePass = encoder.BeginComputePass(); computePass.EndPass(); renderPass.EndPass(); ASSERT_DEVICE_ERROR(encoder.Finish()); @@ -138,9 +138,9 @@ TEST_F(CommandBufferValidationTest, BeginComputePassBeforeEndPreviousPass) { // Beginning a compute pass before ending a compute pass causes an error. { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); - dawn::ComputePassEncoder computePass1 = encoder.BeginComputePass(); - dawn::ComputePassEncoder computePass2 = encoder.BeginComputePass(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::ComputePassEncoder computePass1 = encoder.BeginComputePass(); + wgpu::ComputePassEncoder computePass2 = encoder.BeginComputePass(); computePass2.EndPass(); computePass1.EndPass(); ASSERT_DEVICE_ERROR(encoder.Finish()); @@ -150,12 +150,12 @@ TEST_F(CommandBufferValidationTest, BeginComputePassBeforeEndPreviousPass) { // Test that encoding command after a successful finish produces an error TEST_F(CommandBufferValidationTest, CallsAfterASuccessfulFinish) { // A buffer that can be used in CopyBufferToBuffer - dawn::BufferDescriptor copyBufferDesc; + wgpu::BufferDescriptor copyBufferDesc; copyBufferDesc.size = 16; - copyBufferDesc.usage = dawn::BufferUsage::CopySrc | dawn::BufferUsage::CopyDst; - dawn::Buffer copyBuffer = device.CreateBuffer(©BufferDesc); + copyBufferDesc.usage = wgpu::BufferUsage::CopySrc | wgpu::BufferUsage::CopyDst; + wgpu::Buffer copyBuffer = device.CreateBuffer(©BufferDesc); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); encoder.Finish(); ASSERT_DEVICE_ERROR(encoder.CopyBufferToBuffer(copyBuffer, 0, copyBuffer, 0, 0)); @@ -164,18 +164,18 @@ TEST_F(CommandBufferValidationTest, CallsAfterASuccessfulFinish) { // Test that encoding command after a failed finish produces an error TEST_F(CommandBufferValidationTest, CallsAfterAFailedFinish) { // A buffer that can be used in CopyBufferToBuffer - dawn::BufferDescriptor copyBufferDesc; + wgpu::BufferDescriptor copyBufferDesc; copyBufferDesc.size = 16; - copyBufferDesc.usage = dawn::BufferUsage::CopySrc | dawn::BufferUsage::CopyDst; - dawn::Buffer copyBuffer = device.CreateBuffer(©BufferDesc); + copyBufferDesc.usage = wgpu::BufferUsage::CopySrc | wgpu::BufferUsage::CopyDst; + wgpu::Buffer copyBuffer = device.CreateBuffer(©BufferDesc); // A buffer that can't be used in CopyBufferToBuffer - dawn::BufferDescriptor bufferDesc; + wgpu::BufferDescriptor bufferDesc; bufferDesc.size = 16; - bufferDesc.usage = dawn::BufferUsage::Uniform; - dawn::Buffer buffer = device.CreateBuffer(&bufferDesc); + bufferDesc.usage = wgpu::BufferUsage::Uniform; + wgpu::Buffer buffer = device.CreateBuffer(&bufferDesc); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); encoder.CopyBufferToBuffer(buffer, 0, buffer, 0, 0); ASSERT_DEVICE_ERROR(encoder.Finish()); @@ -185,15 +185,15 @@ TEST_F(CommandBufferValidationTest, CallsAfterAFailedFinish) { // Test that using a single buffer in multiple read usages in the same pass is allowed. TEST_F(CommandBufferValidationTest, BufferWithMultipleReadUsage) { // Create a buffer used as both vertex and index buffer. - dawn::BufferDescriptor bufferDescriptor; - bufferDescriptor.usage = dawn::BufferUsage::Vertex | dawn::BufferUsage::Index; + wgpu::BufferDescriptor bufferDescriptor; + bufferDescriptor.usage = wgpu::BufferUsage::Vertex | wgpu::BufferUsage::Index; bufferDescriptor.size = 4; - dawn::Buffer buffer = device.CreateBuffer(&bufferDescriptor); + wgpu::Buffer buffer = device.CreateBuffer(&bufferDescriptor); // Use the buffer as both index and vertex in the same pass - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); DummyRenderPass dummyRenderPass(device); - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&dummyRenderPass); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&dummyRenderPass); pass.SetIndexBuffer(buffer); pass.SetVertexBuffer(0, buffer); pass.EndPass(); @@ -203,20 +203,20 @@ TEST_F(CommandBufferValidationTest, BufferWithMultipleReadUsage) { // Test that using the same buffer as both readable and writable in the same pass is disallowed TEST_F(CommandBufferValidationTest, BufferWithReadAndWriteUsage) { // Create a buffer that will be used as an index buffer and as a storage buffer - dawn::BufferDescriptor bufferDescriptor; - bufferDescriptor.usage = dawn::BufferUsage::Storage | dawn::BufferUsage::Index; + wgpu::BufferDescriptor bufferDescriptor; + bufferDescriptor.usage = wgpu::BufferUsage::Storage | wgpu::BufferUsage::Index; bufferDescriptor.size = 4; - dawn::Buffer buffer = device.CreateBuffer(&bufferDescriptor); + wgpu::Buffer buffer = device.CreateBuffer(&bufferDescriptor); // Create the bind group to use the buffer as storage - dawn::BindGroupLayout bgl = utils::MakeBindGroupLayout( - device, {{0, dawn::ShaderStage::Vertex, dawn::BindingType::StorageBuffer}}); - dawn::BindGroup bg = utils::MakeBindGroup(device, bgl, {{0, buffer, 0, 4}}); + wgpu::BindGroupLayout bgl = utils::MakeBindGroupLayout( + device, {{0, wgpu::ShaderStage::Vertex, wgpu::BindingType::StorageBuffer}}); + wgpu::BindGroup bg = utils::MakeBindGroup(device, bgl, {{0, buffer, 0, 4}}); // Use the buffer as both index and storage in the same pass - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); DummyRenderPass dummyRenderPass(device); - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&dummyRenderPass); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&dummyRenderPass); pass.SetIndexBuffer(buffer); pass.SetBindGroup(0, bg); pass.EndPass(); @@ -226,28 +226,28 @@ TEST_F(CommandBufferValidationTest, BufferWithReadAndWriteUsage) { // Test that using the same texture as both readable and writable in the same pass is disallowed TEST_F(CommandBufferValidationTest, TextureWithReadAndWriteUsage) { // Create a texture that will be used both as a sampled texture and a render target - dawn::TextureDescriptor textureDescriptor; - textureDescriptor.usage = dawn::TextureUsage::Sampled | dawn::TextureUsage::OutputAttachment; - textureDescriptor.format = dawn::TextureFormat::RGBA8Unorm; - textureDescriptor.dimension = dawn::TextureDimension::e2D; + wgpu::TextureDescriptor textureDescriptor; + textureDescriptor.usage = wgpu::TextureUsage::Sampled | wgpu::TextureUsage::OutputAttachment; + textureDescriptor.format = wgpu::TextureFormat::RGBA8Unorm; + textureDescriptor.dimension = wgpu::TextureDimension::e2D; textureDescriptor.size = {1, 1, 1}; textureDescriptor.arrayLayerCount = 1; textureDescriptor.sampleCount = 1; textureDescriptor.mipLevelCount = 1; - dawn::Texture texture = device.CreateTexture(&textureDescriptor); - dawn::TextureView view = texture.CreateView(); + wgpu::Texture texture = device.CreateTexture(&textureDescriptor); + wgpu::TextureView view = texture.CreateView(); // Create the bind group to use the texture as sampled - dawn::BindGroupLayout bgl = utils::MakeBindGroupLayout( - device, {{0, dawn::ShaderStage::Vertex, dawn::BindingType::SampledTexture}}); - dawn::BindGroup bg = utils::MakeBindGroup(device, bgl, {{0, view}}); + wgpu::BindGroupLayout bgl = utils::MakeBindGroupLayout( + device, {{0, wgpu::ShaderStage::Vertex, wgpu::BindingType::SampledTexture}}); + wgpu::BindGroup bg = utils::MakeBindGroup(device, bgl, {{0, view}}); // Create the render pass that will use the texture as an output attachment utils::ComboRenderPassDescriptor renderPass({view}); // Use the texture as both sampeld and output attachment in the same pass - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); pass.SetBindGroup(0, bg); pass.EndPass(); ASSERT_DEVICE_ERROR(encoder.Finish()); diff --git a/src/tests/unittests/validation/ComputeIndirectValidationTests.cpp b/src/tests/unittests/validation/ComputeIndirectValidationTests.cpp index 93551ed969..6bd5f8ec3b 100644 --- a/src/tests/unittests/validation/ComputeIndirectValidationTests.cpp +++ b/src/tests/unittests/validation/ComputeIndirectValidationTests.cpp @@ -22,7 +22,7 @@ class ComputeIndirectValidationTest : public ValidationTest { void SetUp() override { ValidationTest::SetUp(); - dawn::ShaderModule computeModule = + wgpu::ShaderModule computeModule = utils::CreateShaderModule(device, utils::SingleShaderStage::Compute, R"( #version 450 layout(local_size_x = 1) in; @@ -30,16 +30,16 @@ class ComputeIndirectValidationTest : public ValidationTest { })"); // Set up compute pipeline - dawn::PipelineLayout pl = utils::MakeBasicPipelineLayout(device, nullptr); + wgpu::PipelineLayout pl = utils::MakeBasicPipelineLayout(device, nullptr); - dawn::ComputePipelineDescriptor csDesc; + wgpu::ComputePipelineDescriptor csDesc; csDesc.layout = pl; csDesc.computeStage.module = computeModule; csDesc.computeStage.entryPoint = "main"; pipeline = device.CreateComputePipeline(&csDesc); } - void ValidateExpectation(dawn::CommandEncoder encoder, utils::Expectation expectation) { + void ValidateExpectation(wgpu::CommandEncoder encoder, utils::Expectation expectation) { if (expectation == utils::Expectation::Success) { encoder.Finish(); } else { @@ -50,11 +50,11 @@ class ComputeIndirectValidationTest : public ValidationTest { void TestIndirectOffset(utils::Expectation expectation, std::initializer_list bufferList, uint64_t indirectOffset) { - dawn::Buffer indirectBuffer = - utils::CreateBufferFromData(device, dawn::BufferUsage::Indirect, bufferList); + wgpu::Buffer indirectBuffer = + utils::CreateBufferFromData(device, wgpu::BufferUsage::Indirect, bufferList); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); - dawn::ComputePassEncoder pass = encoder.BeginComputePass(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::ComputePassEncoder pass = encoder.BeginComputePass(); pass.SetPipeline(pipeline); pass.DispatchIndirect(indirectBuffer, indirectOffset); pass.EndPass(); @@ -62,7 +62,7 @@ class ComputeIndirectValidationTest : public ValidationTest { ValidateExpectation(encoder, expectation); } - dawn::ComputePipeline pipeline; + wgpu::ComputePipeline pipeline; }; // Verify out of bounds indirect dispatch calls are caught early diff --git a/src/tests/unittests/validation/ComputePassValidationTests.cpp b/src/tests/unittests/validation/ComputePassValidationTests.cpp index 5560604081..b9f9e94fc0 100644 --- a/src/tests/unittests/validation/ComputePassValidationTests.cpp +++ b/src/tests/unittests/validation/ComputePassValidationTests.cpp @@ -20,12 +20,12 @@ class ComputePassValidationTest : public ValidationTest {}; // Test that it is invalid to use a buffer with both read and write usages in a compute pass. TEST_F(ComputePassValidationTest, ReadWriteUsage) { - dawn::BufferDescriptor bufferDesc = {}; - bufferDesc.usage = dawn::BufferUsage::Storage | dawn::BufferUsage::Uniform; + wgpu::BufferDescriptor bufferDesc = {}; + bufferDesc.usage = wgpu::BufferUsage::Storage | wgpu::BufferUsage::Uniform; bufferDesc.size = 4; - dawn::Buffer buffer = device.CreateBuffer(&bufferDesc); + wgpu::Buffer buffer = device.CreateBuffer(&bufferDesc); - dawn::ShaderModule module = + wgpu::ShaderModule module = utils::CreateShaderModule(device, utils::SingleShaderStage::Compute, R"( #version 450 layout(std430, set = 0, binding = 0) buffer BufA { uint bufA; }; @@ -33,26 +33,26 @@ TEST_F(ComputePassValidationTest, ReadWriteUsage) { void main() {} )"); - dawn::BindGroupLayout bgl = utils::MakeBindGroupLayout( - device, {{0, dawn::ShaderStage::Compute, dawn::BindingType::StorageBuffer}, - {1, dawn::ShaderStage::Compute, dawn::BindingType::UniformBuffer}}); + wgpu::BindGroupLayout bgl = utils::MakeBindGroupLayout( + device, {{0, wgpu::ShaderStage::Compute, wgpu::BindingType::StorageBuffer}, + {1, wgpu::ShaderStage::Compute, wgpu::BindingType::UniformBuffer}}); - dawn::BindGroup bindGroup = utils::MakeBindGroup(device, bgl, + wgpu::BindGroup bindGroup = utils::MakeBindGroup(device, bgl, { {0, buffer, 0, 4}, {1, buffer, 0, 4}, }); - dawn::PipelineLayout layout = utils::MakeBasicPipelineLayout(device, &bgl); + wgpu::PipelineLayout layout = utils::MakeBasicPipelineLayout(device, &bgl); - dawn::ComputePipelineDescriptor pipelineDesc = {}; + wgpu::ComputePipelineDescriptor pipelineDesc = {}; pipelineDesc.layout = layout; pipelineDesc.computeStage.module = module; pipelineDesc.computeStage.entryPoint = "main"; - dawn::ComputePipeline pipeline = device.CreateComputePipeline(&pipelineDesc); + wgpu::ComputePipeline pipeline = device.CreateComputePipeline(&pipelineDesc); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); - dawn::ComputePassEncoder pass = encoder.BeginComputePass(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::ComputePassEncoder pass = encoder.BeginComputePass(); pass.SetPipeline(pipeline); pass.SetBindGroup(0, bindGroup); @@ -65,33 +65,33 @@ TEST_F(ComputePassValidationTest, ReadWriteUsage) { // Test that it is valid to use a buffer with a single write usage multiple times in a compute pass. TEST_F(ComputePassValidationTest, MultipleWrites) { - dawn::BufferDescriptor bufferDesc = {}; - bufferDesc.usage = dawn::BufferUsage::Storage; + wgpu::BufferDescriptor bufferDesc = {}; + bufferDesc.usage = wgpu::BufferUsage::Storage; bufferDesc.size = 4; - dawn::Buffer buffer = device.CreateBuffer(&bufferDesc); + wgpu::Buffer buffer = device.CreateBuffer(&bufferDesc); - dawn::ShaderModule module = + wgpu::ShaderModule module = utils::CreateShaderModule(device, utils::SingleShaderStage::Compute, R"( #version 450 layout(std430, set = 0, binding = 0) buffer Buf { uint buf; }; void main() {} )"); - dawn::BindGroupLayout bgl = utils::MakeBindGroupLayout( - device, {{0, dawn::ShaderStage::Compute, dawn::BindingType::StorageBuffer}}); + wgpu::BindGroupLayout bgl = utils::MakeBindGroupLayout( + device, {{0, wgpu::ShaderStage::Compute, wgpu::BindingType::StorageBuffer}}); - dawn::BindGroup bindGroup = utils::MakeBindGroup(device, bgl, {{0, buffer, 0, 4}}); + wgpu::BindGroup bindGroup = utils::MakeBindGroup(device, bgl, {{0, buffer, 0, 4}}); - dawn::PipelineLayout layout = utils::MakeBasicPipelineLayout(device, &bgl); + wgpu::PipelineLayout layout = utils::MakeBasicPipelineLayout(device, &bgl); - dawn::ComputePipelineDescriptor pipelineDesc = {}; + wgpu::ComputePipelineDescriptor pipelineDesc = {}; pipelineDesc.layout = layout; pipelineDesc.computeStage.module = module; pipelineDesc.computeStage.entryPoint = "main"; - dawn::ComputePipeline pipeline = device.CreateComputePipeline(&pipelineDesc); + wgpu::ComputePipeline pipeline = device.CreateComputePipeline(&pipelineDesc); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); - dawn::ComputePassEncoder pass = encoder.BeginComputePass(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::ComputePassEncoder pass = encoder.BeginComputePass(); pass.SetPipeline(pipeline); pass.SetBindGroup(0, bindGroup); @@ -105,12 +105,12 @@ TEST_F(ComputePassValidationTest, MultipleWrites) { // Test that it is valid to use a buffer with a single write usage multiple times in a compute pass, // even if the buffer is referenced in separate bind groups. TEST_F(ComputePassValidationTest, MultipleWritesSeparateBindGroups) { - dawn::BufferDescriptor bufferDesc = {}; - bufferDesc.usage = dawn::BufferUsage::Storage; + wgpu::BufferDescriptor bufferDesc = {}; + bufferDesc.usage = wgpu::BufferUsage::Storage; bufferDesc.size = 4; - dawn::Buffer buffer = device.CreateBuffer(&bufferDesc); + wgpu::Buffer buffer = device.CreateBuffer(&bufferDesc); - dawn::ShaderModule module = + wgpu::ShaderModule module = utils::CreateShaderModule(device, utils::SingleShaderStage::Compute, R"( #version 450 #define kNumValues 100 @@ -118,22 +118,22 @@ TEST_F(ComputePassValidationTest, MultipleWritesSeparateBindGroups) { void main() {} )"); - dawn::BindGroupLayout bgl = utils::MakeBindGroupLayout( - device, {{0, dawn::ShaderStage::Compute, dawn::BindingType::StorageBuffer}}); + wgpu::BindGroupLayout bgl = utils::MakeBindGroupLayout( + device, {{0, wgpu::ShaderStage::Compute, wgpu::BindingType::StorageBuffer}}); - dawn::BindGroup bindGroupA = utils::MakeBindGroup(device, bgl, {{0, buffer, 0, 4}}); - dawn::BindGroup bindGroupB = utils::MakeBindGroup(device, bgl, {{0, buffer, 0, 4}}); + wgpu::BindGroup bindGroupA = utils::MakeBindGroup(device, bgl, {{0, buffer, 0, 4}}); + wgpu::BindGroup bindGroupB = utils::MakeBindGroup(device, bgl, {{0, buffer, 0, 4}}); - dawn::PipelineLayout layout = utils::MakeBasicPipelineLayout(device, &bgl); + wgpu::PipelineLayout layout = utils::MakeBasicPipelineLayout(device, &bgl); - dawn::ComputePipelineDescriptor pipelineDesc = {}; + wgpu::ComputePipelineDescriptor pipelineDesc = {}; pipelineDesc.layout = layout; pipelineDesc.computeStage.module = module; pipelineDesc.computeStage.entryPoint = "main"; - dawn::ComputePipeline pipeline = device.CreateComputePipeline(&pipelineDesc); + wgpu::ComputePipeline pipeline = device.CreateComputePipeline(&pipelineDesc); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); - dawn::ComputePassEncoder pass = encoder.BeginComputePass(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::ComputePassEncoder pass = encoder.BeginComputePass(); pass.SetPipeline(pipeline); pass.SetBindGroup(0, bindGroupA); diff --git a/src/tests/unittests/validation/CopyCommandsValidationTests.cpp b/src/tests/unittests/validation/CopyCommandsValidationTests.cpp index 4f6a5d20f6..edc2639656 100644 --- a/src/tests/unittests/validation/CopyCommandsValidationTests.cpp +++ b/src/tests/unittests/validation/CopyCommandsValidationTests.cpp @@ -20,23 +20,23 @@ class CopyCommandTest : public ValidationTest { protected: - dawn::Buffer CreateBuffer(uint64_t size, dawn::BufferUsage usage) { - dawn::BufferDescriptor descriptor; + wgpu::Buffer CreateBuffer(uint64_t size, wgpu::BufferUsage usage) { + wgpu::BufferDescriptor descriptor; descriptor.size = size; descriptor.usage = usage; return device.CreateBuffer(&descriptor); } - dawn::Texture Create2DTexture(uint32_t width, + wgpu::Texture Create2DTexture(uint32_t width, uint32_t height, uint32_t mipLevelCount, uint32_t arrayLayerCount, - dawn::TextureFormat format, - dawn::TextureUsage usage, + wgpu::TextureFormat format, + wgpu::TextureUsage usage, uint32_t sampleCount = 1) { - dawn::TextureDescriptor descriptor; - descriptor.dimension = dawn::TextureDimension::e2D; + wgpu::TextureDescriptor descriptor; + descriptor.dimension = wgpu::TextureDimension::e2D; descriptor.size.width = width; descriptor.size.height = height; descriptor.size.depth = 1; @@ -45,16 +45,16 @@ class CopyCommandTest : public ValidationTest { descriptor.format = format; descriptor.mipLevelCount = mipLevelCount; descriptor.usage = usage; - dawn::Texture tex = device.CreateTexture(&descriptor); + wgpu::Texture tex = device.CreateTexture(&descriptor); return tex; } // TODO(jiawei.shao@intel.com): support more pixel formats - uint32_t TextureFormatPixelSize(dawn::TextureFormat format) { + uint32_t TextureFormatPixelSize(wgpu::TextureFormat format) { switch (format) { - case dawn::TextureFormat::RG8Unorm: + case wgpu::TextureFormat::RG8Unorm: return 2; - case dawn::TextureFormat::RGBA8Unorm: + case wgpu::TextureFormat::RGBA8Unorm: return 4; default: UNREACHABLE(); @@ -66,13 +66,13 @@ class CopyCommandTest : public ValidationTest { uint32_t width, uint32_t height, uint32_t depth, - dawn::TextureFormat format = dawn::TextureFormat::RGBA8Unorm) { + wgpu::TextureFormat format = wgpu::TextureFormat::RGBA8Unorm) { uint32_t bytesPerPixel = TextureFormatPixelSize(format); uint32_t rowPitch = Align(width * bytesPerPixel, kTextureRowPitchAlignment); return (rowPitch * (height - 1) + width * bytesPerPixel) * depth; } - void ValidateExpectation(dawn::CommandEncoder encoder, utils::Expectation expectation) { + void ValidateExpectation(wgpu::CommandEncoder encoder, utils::Expectation expectation) { if (expectation == utils::Expectation::Success) { encoder.Finish(); } else { @@ -81,63 +81,63 @@ class CopyCommandTest : public ValidationTest { } void TestB2TCopy(utils::Expectation expectation, - dawn::Buffer srcBuffer, + wgpu::Buffer srcBuffer, uint64_t srcOffset, uint32_t srcRowPitch, uint32_t srcImageHeight, - dawn::Texture destTexture, + wgpu::Texture destTexture, uint32_t destLevel, uint32_t destSlice, - dawn::Origin3D destOrigin, - dawn::Extent3D extent3D) { - dawn::BufferCopyView bufferCopyView = + wgpu::Origin3D destOrigin, + wgpu::Extent3D extent3D) { + wgpu::BufferCopyView bufferCopyView = utils::CreateBufferCopyView(srcBuffer, srcOffset, srcRowPitch, srcImageHeight); - dawn::TextureCopyView textureCopyView = + wgpu::TextureCopyView textureCopyView = utils::CreateTextureCopyView(destTexture, destLevel, destSlice, destOrigin); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); encoder.CopyBufferToTexture(&bufferCopyView, &textureCopyView, &extent3D); ValidateExpectation(encoder, expectation); } void TestT2BCopy(utils::Expectation expectation, - dawn::Texture srcTexture, + wgpu::Texture srcTexture, uint32_t srcLevel, uint32_t srcSlice, - dawn::Origin3D srcOrigin, - dawn::Buffer destBuffer, + wgpu::Origin3D srcOrigin, + wgpu::Buffer destBuffer, uint64_t destOffset, uint32_t destRowPitch, uint32_t destImageHeight, - dawn::Extent3D extent3D) { - dawn::BufferCopyView bufferCopyView = + wgpu::Extent3D extent3D) { + wgpu::BufferCopyView bufferCopyView = utils::CreateBufferCopyView(destBuffer, destOffset, destRowPitch, destImageHeight); - dawn::TextureCopyView textureCopyView = + wgpu::TextureCopyView textureCopyView = utils::CreateTextureCopyView(srcTexture, srcLevel, srcSlice, srcOrigin); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); encoder.CopyTextureToBuffer(&textureCopyView, &bufferCopyView, &extent3D); ValidateExpectation(encoder, expectation); } void TestT2TCopy(utils::Expectation expectation, - dawn::Texture srcTexture, + wgpu::Texture srcTexture, uint32_t srcLevel, uint32_t srcSlice, - dawn::Origin3D srcOrigin, - dawn::Texture dstTexture, + wgpu::Origin3D srcOrigin, + wgpu::Texture dstTexture, uint32_t dstLevel, uint32_t dstSlice, - dawn::Origin3D dstOrigin, - dawn::Extent3D extent3D) { - dawn::TextureCopyView srcTextureCopyView = + wgpu::Origin3D dstOrigin, + wgpu::Extent3D extent3D) { + wgpu::TextureCopyView srcTextureCopyView = utils::CreateTextureCopyView(srcTexture, srcLevel, srcSlice, srcOrigin); - dawn::TextureCopyView dstTextureCopyView = + wgpu::TextureCopyView dstTextureCopyView = utils::CreateTextureCopyView(dstTexture, dstLevel, dstSlice, dstOrigin); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); encoder.CopyTextureToTexture(&srcTextureCopyView, &dstTextureCopyView, &extent3D); ValidateExpectation(encoder, expectation); @@ -150,12 +150,12 @@ class CopyCommandTest_B2B : public CopyCommandTest {}; // Test a successfull B2B copy TEST_F(CopyCommandTest_B2B, Success) { - dawn::Buffer source = CreateBuffer(16, dawn::BufferUsage::CopySrc); - dawn::Buffer destination = CreateBuffer(16, dawn::BufferUsage::CopyDst); + wgpu::Buffer source = CreateBuffer(16, wgpu::BufferUsage::CopySrc); + wgpu::Buffer destination = CreateBuffer(16, wgpu::BufferUsage::CopyDst); // Copy different copies, including some that touch the OOB condition { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); encoder.CopyBufferToBuffer(source, 0, destination, 0, 16); encoder.CopyBufferToBuffer(source, 8, destination, 0, 8); encoder.CopyBufferToBuffer(source, 0, destination, 8, 8); @@ -164,7 +164,7 @@ TEST_F(CopyCommandTest_B2B, Success) { // Empty copies are valid { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); encoder.CopyBufferToBuffer(source, 0, destination, 0, 0); encoder.CopyBufferToBuffer(source, 0, destination, 16, 0); encoder.CopyBufferToBuffer(source, 16, destination, 0, 0); @@ -174,19 +174,19 @@ TEST_F(CopyCommandTest_B2B, Success) { // Test B2B copies with OOB TEST_F(CopyCommandTest_B2B, OutOfBounds) { - dawn::Buffer source = CreateBuffer(16, dawn::BufferUsage::CopySrc); - dawn::Buffer destination = CreateBuffer(16, dawn::BufferUsage::CopyDst); + wgpu::Buffer source = CreateBuffer(16, wgpu::BufferUsage::CopySrc); + wgpu::Buffer destination = CreateBuffer(16, wgpu::BufferUsage::CopyDst); // OOB on the source { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); encoder.CopyBufferToBuffer(source, 8, destination, 0, 12); ASSERT_DEVICE_ERROR(encoder.Finish()); } // OOB on the destination { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); encoder.CopyBufferToBuffer(source, 0, destination, 8, 12); ASSERT_DEVICE_ERROR(encoder.Finish()); } @@ -194,20 +194,20 @@ TEST_F(CopyCommandTest_B2B, OutOfBounds) { // Test B2B copies with incorrect buffer usage TEST_F(CopyCommandTest_B2B, BadUsage) { - dawn::Buffer source = CreateBuffer(16, dawn::BufferUsage::CopySrc); - dawn::Buffer destination = CreateBuffer(16, dawn::BufferUsage::CopyDst); - dawn::Buffer vertex = CreateBuffer(16, dawn::BufferUsage::Vertex); + wgpu::Buffer source = CreateBuffer(16, wgpu::BufferUsage::CopySrc); + wgpu::Buffer destination = CreateBuffer(16, wgpu::BufferUsage::CopyDst); + wgpu::Buffer vertex = CreateBuffer(16, wgpu::BufferUsage::Vertex); // Source with incorrect usage { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); encoder.CopyBufferToBuffer(vertex, 0, destination, 0, 16); ASSERT_DEVICE_ERROR(encoder.Finish()); } // Destination with incorrect usage { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); encoder.CopyBufferToBuffer(source, 0, vertex, 0, 16); ASSERT_DEVICE_ERROR(encoder.Finish()); } @@ -215,29 +215,29 @@ TEST_F(CopyCommandTest_B2B, BadUsage) { // Test B2B copies with unaligned data size TEST_F(CopyCommandTest_B2B, UnalignedSize) { - dawn::Buffer source = CreateBuffer(16, dawn::BufferUsage::CopySrc); - dawn::Buffer destination = CreateBuffer(16, dawn::BufferUsage::CopyDst); + wgpu::Buffer source = CreateBuffer(16, wgpu::BufferUsage::CopySrc); + wgpu::Buffer destination = CreateBuffer(16, wgpu::BufferUsage::CopyDst); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); encoder.CopyBufferToBuffer(source, 8, destination, 0, sizeof(uint8_t)); ASSERT_DEVICE_ERROR(encoder.Finish()); } // Test B2B copies with unaligned offset TEST_F(CopyCommandTest_B2B, UnalignedOffset) { - dawn::Buffer source = CreateBuffer(16, dawn::BufferUsage::CopySrc); - dawn::Buffer destination = CreateBuffer(16, dawn::BufferUsage::CopyDst); + wgpu::Buffer source = CreateBuffer(16, wgpu::BufferUsage::CopySrc); + wgpu::Buffer destination = CreateBuffer(16, wgpu::BufferUsage::CopyDst); // Unaligned source offset { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); encoder.CopyBufferToBuffer(source, 9, destination, 0, 4); ASSERT_DEVICE_ERROR(encoder.Finish()); } // Unaligned destination offset { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); encoder.CopyBufferToBuffer(source, 8, destination, 1, 4); ASSERT_DEVICE_ERROR(encoder.Finish()); } @@ -245,22 +245,22 @@ TEST_F(CopyCommandTest_B2B, UnalignedOffset) { // Test B2B copies with buffers in error state cause errors. TEST_F(CopyCommandTest_B2B, BuffersInErrorState) { - dawn::BufferDescriptor errorBufferDescriptor; + wgpu::BufferDescriptor errorBufferDescriptor; errorBufferDescriptor.size = 4; - errorBufferDescriptor.usage = dawn::BufferUsage::MapRead | dawn::BufferUsage::CopySrc; - ASSERT_DEVICE_ERROR(dawn::Buffer errorBuffer = device.CreateBuffer(&errorBufferDescriptor)); + errorBufferDescriptor.usage = wgpu::BufferUsage::MapRead | wgpu::BufferUsage::CopySrc; + ASSERT_DEVICE_ERROR(wgpu::Buffer errorBuffer = device.CreateBuffer(&errorBufferDescriptor)); constexpr uint64_t bufferSize = 4; - dawn::Buffer validBuffer = CreateBuffer(bufferSize, dawn::BufferUsage::CopySrc); + wgpu::Buffer validBuffer = CreateBuffer(bufferSize, wgpu::BufferUsage::CopySrc); { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); encoder.CopyBufferToBuffer(errorBuffer, 0, validBuffer, 0, 4); ASSERT_DEVICE_ERROR(encoder.Finish()); } { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); encoder.CopyBufferToBuffer(validBuffer, 0, errorBuffer, 0, 4); ASSERT_DEVICE_ERROR(encoder.Finish()); } @@ -271,9 +271,9 @@ class CopyCommandTest_B2T : public CopyCommandTest {}; // Test a successfull B2T copy TEST_F(CopyCommandTest_B2T, Success) { uint64_t bufferSize = BufferSizeForTextureCopy(4, 4, 1); - dawn::Buffer source = CreateBuffer(bufferSize, dawn::BufferUsage::CopySrc); - dawn::Texture destination = - Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopyDst); + wgpu::Buffer source = CreateBuffer(bufferSize, wgpu::BufferUsage::CopySrc); + wgpu::Texture destination = + Create2DTexture(16, 16, 5, 1, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::CopyDst); // Different copies, including some that touch the OOB condition { @@ -324,9 +324,9 @@ TEST_F(CopyCommandTest_B2T, Success) { // Test OOB conditions on the buffer TEST_F(CopyCommandTest_B2T, OutOfBoundsOnBuffer) { uint64_t bufferSize = BufferSizeForTextureCopy(4, 4, 1); - dawn::Buffer source = CreateBuffer(bufferSize, dawn::BufferUsage::CopySrc); - dawn::Texture destination = - Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopyDst); + wgpu::Buffer source = CreateBuffer(bufferSize, wgpu::BufferUsage::CopySrc); + wgpu::Texture destination = + Create2DTexture(16, 16, 5, 1, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::CopyDst); // OOB on the buffer because we copy too many pixels TestB2TCopy(utils::Expectation::Failure, source, 0, 256, 0, destination, 0, 0, {0, 0, 0}, @@ -346,7 +346,7 @@ TEST_F(CopyCommandTest_B2T, OutOfBoundsOnBuffer) { { uint32_t sourceBufferSize = BufferSizeForTextureCopy(7, 3, 1); ASSERT_TRUE(256 * 3 > sourceBufferSize) << "row pitch * height should overflow buffer"; - dawn::Buffer sourceBuffer = CreateBuffer(sourceBufferSize, dawn::BufferUsage::CopySrc); + wgpu::Buffer sourceBuffer = CreateBuffer(sourceBufferSize, wgpu::BufferUsage::CopySrc); TestB2TCopy(utils::Expectation::Success, source, 0, 256, 0, destination, 0, 0, {0, 0, 0}, {7, 3, 1}); @@ -356,9 +356,9 @@ TEST_F(CopyCommandTest_B2T, OutOfBoundsOnBuffer) { // Test OOB conditions on the texture TEST_F(CopyCommandTest_B2T, OutOfBoundsOnTexture) { uint64_t bufferSize = BufferSizeForTextureCopy(4, 4, 1); - dawn::Buffer source = CreateBuffer(bufferSize, dawn::BufferUsage::CopySrc); - dawn::Texture destination = - Create2DTexture(16, 16, 5, 2, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopyDst); + wgpu::Buffer source = CreateBuffer(bufferSize, wgpu::BufferUsage::CopySrc); + wgpu::Texture destination = + Create2DTexture(16, 16, 5, 2, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::CopyDst); // OOB on the texture because x + width overflows TestB2TCopy(utils::Expectation::Failure, source, 0, 256, 0, destination, 0, 0, {13, 12, 0}, @@ -383,9 +383,9 @@ TEST_F(CopyCommandTest_B2T, OutOfBoundsOnTexture) { // Test that we force Z=0 and Depth=1 on copies to 2D textures TEST_F(CopyCommandTest_B2T, ZDepthConstraintFor2DTextures) { - dawn::Buffer source = CreateBuffer(16 * 4, dawn::BufferUsage::CopySrc); - dawn::Texture destination = - Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopyDst); + wgpu::Buffer source = CreateBuffer(16 * 4, wgpu::BufferUsage::CopySrc); + wgpu::Texture destination = + Create2DTexture(16, 16, 5, 1, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::CopyDst); // Z=1 on an empty copy still errors TestB2TCopy(utils::Expectation::Failure, source, 0, 0, 0, destination, 0, 0, {0, 0, 1}, @@ -398,12 +398,12 @@ TEST_F(CopyCommandTest_B2T, ZDepthConstraintFor2DTextures) { // Test B2T copies with incorrect buffer usage TEST_F(CopyCommandTest_B2T, IncorrectUsage) { - dawn::Buffer source = CreateBuffer(16 * 4, dawn::BufferUsage::CopySrc); - dawn::Buffer vertex = CreateBuffer(16 * 4, dawn::BufferUsage::Vertex); - dawn::Texture destination = - Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopyDst); - dawn::Texture sampled = - Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::Sampled); + wgpu::Buffer source = CreateBuffer(16 * 4, wgpu::BufferUsage::CopySrc); + wgpu::Buffer vertex = CreateBuffer(16 * 4, wgpu::BufferUsage::Vertex); + wgpu::Texture destination = + Create2DTexture(16, 16, 5, 1, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::CopyDst); + wgpu::Texture sampled = + Create2DTexture(16, 16, 5, 1, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::Sampled); // Incorrect source usage TestB2TCopy(utils::Expectation::Failure, vertex, 0, 256, 0, destination, 0, 0, {0, 0, 0}, @@ -416,9 +416,9 @@ TEST_F(CopyCommandTest_B2T, IncorrectUsage) { TEST_F(CopyCommandTest_B2T, IncorrectRowPitch) { uint64_t bufferSize = BufferSizeForTextureCopy(128, 16, 1); - dawn::Buffer source = CreateBuffer(bufferSize, dawn::BufferUsage::CopySrc); - dawn::Texture destination = Create2DTexture(128, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm, - dawn::TextureUsage::CopyDst); + wgpu::Buffer source = CreateBuffer(bufferSize, wgpu::BufferUsage::CopySrc); + wgpu::Texture destination = Create2DTexture(128, 16, 5, 1, wgpu::TextureFormat::RGBA8Unorm, + wgpu::TextureUsage::CopyDst); // Default row pitch is not 256-byte aligned TestB2TCopy(utils::Expectation::Failure, source, 0, 0, 0, destination, 0, 0, {0, 0, 0}, @@ -435,9 +435,9 @@ TEST_F(CopyCommandTest_B2T, IncorrectRowPitch) { TEST_F(CopyCommandTest_B2T, ImageHeightConstraint) { uint64_t bufferSize = BufferSizeForTextureCopy(5, 5, 1); - dawn::Buffer source = CreateBuffer(bufferSize, dawn::BufferUsage::CopySrc); - dawn::Texture destination = - Create2DTexture(16, 16, 1, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopyDst); + wgpu::Buffer source = CreateBuffer(bufferSize, wgpu::BufferUsage::CopySrc); + wgpu::Texture destination = + Create2DTexture(16, 16, 1, 1, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::CopyDst); // Image height is zero (Valid) TestB2TCopy(utils::Expectation::Success, source, 0, 256, 0, destination, 0, 0, {0, 0, 0}, @@ -459,9 +459,9 @@ TEST_F(CopyCommandTest_B2T, ImageHeightConstraint) { // Test B2T copies with incorrect buffer offset usage TEST_F(CopyCommandTest_B2T, IncorrectBufferOffset) { uint64_t bufferSize = BufferSizeForTextureCopy(4, 4, 1); - dawn::Buffer source = CreateBuffer(bufferSize, dawn::BufferUsage::CopySrc); - dawn::Texture destination = - Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopyDst); + wgpu::Buffer source = CreateBuffer(bufferSize, wgpu::BufferUsage::CopySrc); + wgpu::Texture destination = + Create2DTexture(16, 16, 5, 1, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::CopyDst); // Correct usage TestB2TCopy(utils::Expectation::Success, source, bufferSize - 4, 256, 0, destination, 0, 0, @@ -481,9 +481,9 @@ TEST_F(CopyCommandTest_B2T, IncorrectBufferOffset) { // Test multisampled textures cannot be used in B2T copies. TEST_F(CopyCommandTest_B2T, CopyToMultisampledTexture) { uint64_t bufferSize = BufferSizeForTextureCopy(16, 16, 1); - dawn::Buffer source = CreateBuffer(bufferSize, dawn::BufferUsage::CopySrc); - dawn::Texture destination = Create2DTexture(2, 2, 1, 1, dawn::TextureFormat::RGBA8Unorm, - dawn::TextureUsage::CopyDst, 4); + wgpu::Buffer source = CreateBuffer(bufferSize, wgpu::BufferUsage::CopySrc); + wgpu::Texture destination = Create2DTexture(2, 2, 1, 1, wgpu::TextureFormat::RGBA8Unorm, + wgpu::TextureUsage::CopyDst, 4); TestB2TCopy(utils::Expectation::Failure, source, 0, 256, 0, destination, 0, 0, {0, 0, 0}, {2, 2, 1}); @@ -491,39 +491,39 @@ TEST_F(CopyCommandTest_B2T, CopyToMultisampledTexture) { // Test B2T copies with buffer or texture in error state causes errors. TEST_F(CopyCommandTest_B2T, BufferOrTextureInErrorState) { - dawn::BufferDescriptor errorBufferDescriptor; + wgpu::BufferDescriptor errorBufferDescriptor; errorBufferDescriptor.size = 4; - errorBufferDescriptor.usage = dawn::BufferUsage::MapRead | dawn::BufferUsage::CopySrc; - ASSERT_DEVICE_ERROR(dawn::Buffer errorBuffer = device.CreateBuffer(&errorBufferDescriptor)); + errorBufferDescriptor.usage = wgpu::BufferUsage::MapRead | wgpu::BufferUsage::CopySrc; + ASSERT_DEVICE_ERROR(wgpu::Buffer errorBuffer = device.CreateBuffer(&errorBufferDescriptor)); - dawn::TextureDescriptor errorTextureDescriptor; + wgpu::TextureDescriptor errorTextureDescriptor; errorTextureDescriptor.arrayLayerCount = 0; - ASSERT_DEVICE_ERROR(dawn::Texture errorTexture = device.CreateTexture(&errorTextureDescriptor)); + ASSERT_DEVICE_ERROR(wgpu::Texture errorTexture = device.CreateTexture(&errorTextureDescriptor)); - dawn::BufferCopyView errorBufferCopyView = utils::CreateBufferCopyView(errorBuffer, 0, 0, 0); - dawn::TextureCopyView errorTextureCopyView = + wgpu::BufferCopyView errorBufferCopyView = utils::CreateBufferCopyView(errorBuffer, 0, 0, 0); + wgpu::TextureCopyView errorTextureCopyView = utils::CreateTextureCopyView(errorTexture, 0, 0, {1, 1, 1}); - dawn::Extent3D extent3D = {1, 1, 1}; + wgpu::Extent3D extent3D = {1, 1, 1}; { - dawn::Texture destination = Create2DTexture(16, 16, 1, 1, dawn::TextureFormat::RGBA8Unorm, - dawn::TextureUsage::CopyDst); - dawn::TextureCopyView textureCopyView = + wgpu::Texture destination = Create2DTexture(16, 16, 1, 1, wgpu::TextureFormat::RGBA8Unorm, + wgpu::TextureUsage::CopyDst); + wgpu::TextureCopyView textureCopyView = utils::CreateTextureCopyView(destination, 0, 0, {1, 1, 1}); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); encoder.CopyBufferToTexture(&errorBufferCopyView, &textureCopyView, &extent3D); ASSERT_DEVICE_ERROR(encoder.Finish()); } { uint64_t bufferSize = BufferSizeForTextureCopy(4, 4, 1); - dawn::Buffer source = CreateBuffer(bufferSize, dawn::BufferUsage::CopySrc); + wgpu::Buffer source = CreateBuffer(bufferSize, wgpu::BufferUsage::CopySrc); - dawn::BufferCopyView bufferCopyView = utils::CreateBufferCopyView(source, 0, 0, 0); + wgpu::BufferCopyView bufferCopyView = utils::CreateBufferCopyView(source, 0, 0, 0); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); encoder.CopyBufferToTexture(&bufferCopyView, &errorTextureCopyView, &extent3D); ASSERT_DEVICE_ERROR(encoder.Finish()); } @@ -535,40 +535,40 @@ TEST_F(CopyCommandTest_B2T, TextureCopyBufferSizeLastRowComputation) { constexpr uint32_t kWidth = 4; constexpr uint32_t kHeight = 4; - constexpr std::array kFormats = {dawn::TextureFormat::RGBA8Unorm, - dawn::TextureFormat::RG8Unorm}; + constexpr std::array kFormats = {wgpu::TextureFormat::RGBA8Unorm, + wgpu::TextureFormat::RG8Unorm}; { // kRowPitch * (kHeight - 1) + kWidth is not large enough to be the valid buffer size in // this test because the buffer sizes in B2T copies are not in texels but in bytes. constexpr uint32_t kInvalidBufferSize = kRowPitch * (kHeight - 1) + kWidth; - for (dawn::TextureFormat format : kFormats) { - dawn::Buffer source = CreateBuffer(kInvalidBufferSize, dawn::BufferUsage::CopySrc); - dawn::Texture destination = - Create2DTexture(kWidth, kHeight, 1, 1, format, dawn::TextureUsage::CopyDst); + for (wgpu::TextureFormat format : kFormats) { + wgpu::Buffer source = CreateBuffer(kInvalidBufferSize, wgpu::BufferUsage::CopySrc); + wgpu::Texture destination = + Create2DTexture(kWidth, kHeight, 1, 1, format, wgpu::TextureUsage::CopyDst); TestB2TCopy(utils::Expectation::Failure, source, 0, kRowPitch, 0, destination, 0, 0, {0, 0, 0}, {kWidth, kHeight, 1}); } } { - for (dawn::TextureFormat format : kFormats) { + for (wgpu::TextureFormat format : kFormats) { uint32_t validBufferSize = BufferSizeForTextureCopy(kWidth, kHeight, 1, format); - dawn::Texture destination = - Create2DTexture(kWidth, kHeight, 1, 1, format, dawn::TextureUsage::CopyDst); + wgpu::Texture destination = + Create2DTexture(kWidth, kHeight, 1, 1, format, wgpu::TextureUsage::CopyDst); // Verify the return value of BufferSizeForTextureCopy() is exactly the minimum valid // buffer size in this test. { uint32_t invalidBuffferSize = validBufferSize - 1; - dawn::Buffer source = CreateBuffer(invalidBuffferSize, dawn::BufferUsage::CopySrc); + wgpu::Buffer source = CreateBuffer(invalidBuffferSize, wgpu::BufferUsage::CopySrc); TestB2TCopy(utils::Expectation::Failure, source, 0, kRowPitch, 0, destination, 0, 0, {0, 0, 0}, {kWidth, kHeight, 1}); } { - dawn::Buffer source = CreateBuffer(validBufferSize, dawn::BufferUsage::CopySrc); + wgpu::Buffer source = CreateBuffer(validBufferSize, wgpu::BufferUsage::CopySrc); TestB2TCopy(utils::Expectation::Success, source, 0, kRowPitch, 0, destination, 0, 0, {0, 0, 0}, {kWidth, kHeight, 1}); } @@ -579,10 +579,10 @@ TEST_F(CopyCommandTest_B2T, TextureCopyBufferSizeLastRowComputation) { // Test copy from buffer to mip map of non square texture TEST_F(CopyCommandTest_B2T, CopyToMipmapOfNonSquareTexture) { uint64_t bufferSize = BufferSizeForTextureCopy(4, 2, 1); - dawn::Buffer source = CreateBuffer(bufferSize, dawn::BufferUsage::CopySrc); + wgpu::Buffer source = CreateBuffer(bufferSize, wgpu::BufferUsage::CopySrc); uint32_t maxMipmapLevel = 3; - dawn::Texture destination = Create2DTexture( - 4, 2, maxMipmapLevel, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopyDst); + wgpu::Texture destination = Create2DTexture( + 4, 2, maxMipmapLevel, 1, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::CopyDst); // Copy to top level mip map TestB2TCopy(utils::Expectation::Success, source, 0, 256, 0, destination, maxMipmapLevel - 1, 0, @@ -606,9 +606,9 @@ class CopyCommandTest_T2B : public CopyCommandTest {}; // Test a successfull T2B copy TEST_F(CopyCommandTest_T2B, Success) { uint64_t bufferSize = BufferSizeForTextureCopy(4, 4, 1); - dawn::Texture source = - Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopySrc); - dawn::Buffer destination = CreateBuffer(bufferSize, dawn::BufferUsage::CopyDst); + wgpu::Texture source = + Create2DTexture(16, 16, 5, 1, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::CopySrc); + wgpu::Buffer destination = CreateBuffer(bufferSize, wgpu::BufferUsage::CopyDst); // Different copies, including some that touch the OOB condition { @@ -659,9 +659,9 @@ TEST_F(CopyCommandTest_T2B, Success) { // Test OOB conditions on the texture TEST_F(CopyCommandTest_T2B, OutOfBoundsOnTexture) { uint64_t bufferSize = BufferSizeForTextureCopy(4, 4, 1); - dawn::Texture source = - Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopySrc); - dawn::Buffer destination = CreateBuffer(bufferSize, dawn::BufferUsage::CopyDst); + wgpu::Texture source = + Create2DTexture(16, 16, 5, 1, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::CopySrc); + wgpu::Buffer destination = CreateBuffer(bufferSize, wgpu::BufferUsage::CopyDst); // OOB on the texture because x + width overflows TestT2BCopy(utils::Expectation::Failure, source, 0, 0, {13, 12, 0}, destination, 0, 256, 0, @@ -683,9 +683,9 @@ TEST_F(CopyCommandTest_T2B, OutOfBoundsOnTexture) { // Test OOB conditions on the buffer TEST_F(CopyCommandTest_T2B, OutOfBoundsOnBuffer) { uint64_t bufferSize = BufferSizeForTextureCopy(4, 4, 1); - dawn::Texture source = - Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopySrc); - dawn::Buffer destination = CreateBuffer(bufferSize, dawn::BufferUsage::CopyDst); + wgpu::Texture source = + Create2DTexture(16, 16, 5, 1, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::CopySrc); + wgpu::Buffer destination = CreateBuffer(bufferSize, wgpu::BufferUsage::CopyDst); // OOB on the buffer because we copy too many pixels TestT2BCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, destination, 0, 256, 0, @@ -705,8 +705,8 @@ TEST_F(CopyCommandTest_T2B, OutOfBoundsOnBuffer) { { uint32_t destinationBufferSize = BufferSizeForTextureCopy(7, 3, 1); ASSERT_TRUE(256 * 3 > destinationBufferSize) << "row pitch * height should overflow buffer"; - dawn::Buffer destinationBuffer = - CreateBuffer(destinationBufferSize, dawn::BufferUsage::CopyDst); + wgpu::Buffer destinationBuffer = + CreateBuffer(destinationBufferSize, wgpu::BufferUsage::CopyDst); TestT2BCopy(utils::Expectation::Success, source, 0, 0, {0, 0, 0}, destinationBuffer, 0, 256, 0, {7, 3, 1}); } @@ -715,9 +715,9 @@ TEST_F(CopyCommandTest_T2B, OutOfBoundsOnBuffer) { // Test that we force Z=0 and Depth=1 on copies from to 2D textures TEST_F(CopyCommandTest_T2B, ZDepthConstraintFor2DTextures) { uint64_t bufferSize = BufferSizeForTextureCopy(4, 4, 1); - dawn::Texture source = - Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopySrc); - dawn::Buffer destination = CreateBuffer(bufferSize, dawn::BufferUsage::CopyDst); + wgpu::Texture source = + Create2DTexture(16, 16, 5, 1, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::CopySrc); + wgpu::Buffer destination = CreateBuffer(bufferSize, wgpu::BufferUsage::CopyDst); // Z=1 on an empty copy still errors TestT2BCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 1}, destination, 0, 0, 0, @@ -731,12 +731,12 @@ TEST_F(CopyCommandTest_T2B, ZDepthConstraintFor2DTextures) { // Test T2B copies with incorrect buffer usage TEST_F(CopyCommandTest_T2B, IncorrectUsage) { uint64_t bufferSize = BufferSizeForTextureCopy(4, 4, 1); - dawn::Texture source = - Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopySrc); - dawn::Texture sampled = - Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::Sampled); - dawn::Buffer destination = CreateBuffer(bufferSize, dawn::BufferUsage::CopyDst); - dawn::Buffer vertex = CreateBuffer(bufferSize, dawn::BufferUsage::Vertex); + wgpu::Texture source = + Create2DTexture(16, 16, 5, 1, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::CopySrc); + wgpu::Texture sampled = + Create2DTexture(16, 16, 5, 1, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::Sampled); + wgpu::Buffer destination = CreateBuffer(bufferSize, wgpu::BufferUsage::CopyDst); + wgpu::Buffer vertex = CreateBuffer(bufferSize, wgpu::BufferUsage::Vertex); // Incorrect source usage TestT2BCopy(utils::Expectation::Failure, sampled, 0, 0, {0, 0, 0}, destination, 0, 256, 0, @@ -748,9 +748,9 @@ TEST_F(CopyCommandTest_T2B, IncorrectUsage) { TEST_F(CopyCommandTest_T2B, IncorrectRowPitch) { uint64_t bufferSize = BufferSizeForTextureCopy(128, 16, 1); - dawn::Texture source = Create2DTexture(128, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm, - dawn::TextureUsage::CopyDst); - dawn::Buffer destination = CreateBuffer(bufferSize, dawn::BufferUsage::CopySrc); + wgpu::Texture source = Create2DTexture(128, 16, 5, 1, wgpu::TextureFormat::RGBA8Unorm, + wgpu::TextureUsage::CopyDst); + wgpu::Buffer destination = CreateBuffer(bufferSize, wgpu::BufferUsage::CopySrc); // Default row pitch is not 256-byte aligned TestT2BCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, destination, 0, 256, 0, @@ -767,9 +767,9 @@ TEST_F(CopyCommandTest_T2B, IncorrectRowPitch) { TEST_F(CopyCommandTest_T2B, ImageHeightConstraint) { uint64_t bufferSize = BufferSizeForTextureCopy(5, 5, 1); - dawn::Texture source = - Create2DTexture(16, 16, 1, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopySrc); - dawn::Buffer destination = CreateBuffer(bufferSize, dawn::BufferUsage::CopyDst); + wgpu::Texture source = + Create2DTexture(16, 16, 1, 1, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::CopySrc); + wgpu::Buffer destination = CreateBuffer(bufferSize, wgpu::BufferUsage::CopyDst); // Image height is zero (Valid) TestT2BCopy(utils::Expectation::Success, source, 0, 0, {0, 0, 0}, destination, 0, 256, 0, @@ -791,9 +791,9 @@ TEST_F(CopyCommandTest_T2B, ImageHeightConstraint) { // Test T2B copies with incorrect buffer offset usage TEST_F(CopyCommandTest_T2B, IncorrectBufferOffset) { uint64_t bufferSize = BufferSizeForTextureCopy(128, 16, 1); - dawn::Texture source = Create2DTexture(128, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm, - dawn::TextureUsage::CopySrc); - dawn::Buffer destination = CreateBuffer(bufferSize, dawn::BufferUsage::CopyDst); + wgpu::Texture source = Create2DTexture(128, 16, 5, 1, wgpu::TextureFormat::RGBA8Unorm, + wgpu::TextureUsage::CopySrc); + wgpu::Buffer destination = CreateBuffer(bufferSize, wgpu::BufferUsage::CopyDst); // Correct usage TestT2BCopy(utils::Expectation::Success, source, 0, 0, {0, 0, 0}, destination, bufferSize - 4, @@ -810,10 +810,10 @@ TEST_F(CopyCommandTest_T2B, IncorrectBufferOffset) { // Test multisampled textures cannot be used in T2B copies. TEST_F(CopyCommandTest_T2B, CopyFromMultisampledTexture) { - dawn::Texture source = Create2DTexture(2, 2, 1, 1, dawn::TextureFormat::RGBA8Unorm, - dawn::TextureUsage::CopySrc, 4); + wgpu::Texture source = Create2DTexture(2, 2, 1, 1, wgpu::TextureFormat::RGBA8Unorm, + wgpu::TextureUsage::CopySrc, 4); uint64_t bufferSize = BufferSizeForTextureCopy(16, 16, 1); - dawn::Buffer destination = CreateBuffer(bufferSize, dawn::BufferUsage::CopyDst); + wgpu::Buffer destination = CreateBuffer(bufferSize, wgpu::BufferUsage::CopyDst); TestT2BCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, destination, 0, 256, 0, {2, 2, 1}); @@ -821,39 +821,39 @@ TEST_F(CopyCommandTest_T2B, CopyFromMultisampledTexture) { // Test T2B copies with buffer or texture in error state cause errors. TEST_F(CopyCommandTest_T2B, BufferOrTextureInErrorState) { - dawn::BufferDescriptor errorBufferDescriptor; + wgpu::BufferDescriptor errorBufferDescriptor; errorBufferDescriptor.size = 4; - errorBufferDescriptor.usage = dawn::BufferUsage::MapRead | dawn::BufferUsage::CopySrc; - ASSERT_DEVICE_ERROR(dawn::Buffer errorBuffer = device.CreateBuffer(&errorBufferDescriptor)); + errorBufferDescriptor.usage = wgpu::BufferUsage::MapRead | wgpu::BufferUsage::CopySrc; + ASSERT_DEVICE_ERROR(wgpu::Buffer errorBuffer = device.CreateBuffer(&errorBufferDescriptor)); - dawn::TextureDescriptor errorTextureDescriptor; + wgpu::TextureDescriptor errorTextureDescriptor; errorTextureDescriptor.arrayLayerCount = 0; - ASSERT_DEVICE_ERROR(dawn::Texture errorTexture = device.CreateTexture(&errorTextureDescriptor)); + ASSERT_DEVICE_ERROR(wgpu::Texture errorTexture = device.CreateTexture(&errorTextureDescriptor)); - dawn::BufferCopyView errorBufferCopyView = utils::CreateBufferCopyView(errorBuffer, 0, 0, 0); - dawn::TextureCopyView errorTextureCopyView = + wgpu::BufferCopyView errorBufferCopyView = utils::CreateBufferCopyView(errorBuffer, 0, 0, 0); + wgpu::TextureCopyView errorTextureCopyView = utils::CreateTextureCopyView(errorTexture, 0, 0, {1, 1, 1}); - dawn::Extent3D extent3D = {1, 1, 1}; + wgpu::Extent3D extent3D = {1, 1, 1}; { uint64_t bufferSize = BufferSizeForTextureCopy(4, 4, 1); - dawn::Buffer source = CreateBuffer(bufferSize, dawn::BufferUsage::CopySrc); + wgpu::Buffer source = CreateBuffer(bufferSize, wgpu::BufferUsage::CopySrc); - dawn::BufferCopyView bufferCopyView = utils::CreateBufferCopyView(source, 0, 0, 0); + wgpu::BufferCopyView bufferCopyView = utils::CreateBufferCopyView(source, 0, 0, 0); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); encoder.CopyTextureToBuffer(&errorTextureCopyView, &bufferCopyView, &extent3D); ASSERT_DEVICE_ERROR(encoder.Finish()); } { - dawn::Texture destination = Create2DTexture(16, 16, 1, 1, dawn::TextureFormat::RGBA8Unorm, - dawn::TextureUsage::CopyDst); - dawn::TextureCopyView textureCopyView = + wgpu::Texture destination = Create2DTexture(16, 16, 1, 1, wgpu::TextureFormat::RGBA8Unorm, + wgpu::TextureUsage::CopyDst); + wgpu::TextureCopyView textureCopyView = utils::CreateTextureCopyView(destination, 0, 0, {1, 1, 1}); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); encoder.CopyTextureToBuffer(&textureCopyView, &errorBufferCopyView, &extent3D); ASSERT_DEVICE_ERROR(encoder.Finish()); } @@ -865,43 +865,43 @@ TEST_F(CopyCommandTest_T2B, TextureCopyBufferSizeLastRowComputation) { constexpr uint32_t kWidth = 4; constexpr uint32_t kHeight = 4; - constexpr std::array kFormats = {dawn::TextureFormat::RGBA8Unorm, - dawn::TextureFormat::RG8Unorm}; + constexpr std::array kFormats = {wgpu::TextureFormat::RGBA8Unorm, + wgpu::TextureFormat::RG8Unorm}; { // kRowPitch * (kHeight - 1) + kWidth is not large enough to be the valid buffer size in // this test because the buffer sizes in T2B copies are not in texels but in bytes. constexpr uint32_t kInvalidBufferSize = kRowPitch * (kHeight - 1) + kWidth; - for (dawn::TextureFormat format : kFormats) { - dawn::Texture source = - Create2DTexture(kWidth, kHeight, 1, 1, format, dawn::TextureUsage::CopyDst); + for (wgpu::TextureFormat format : kFormats) { + wgpu::Texture source = + Create2DTexture(kWidth, kHeight, 1, 1, format, wgpu::TextureUsage::CopyDst); - dawn::Buffer destination = CreateBuffer(kInvalidBufferSize, dawn::BufferUsage::CopySrc); + wgpu::Buffer destination = CreateBuffer(kInvalidBufferSize, wgpu::BufferUsage::CopySrc); TestT2BCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, destination, 0, kRowPitch, 0, {kWidth, kHeight, 1}); } } { - for (dawn::TextureFormat format : kFormats) { + for (wgpu::TextureFormat format : kFormats) { uint32_t validBufferSize = BufferSizeForTextureCopy(kWidth, kHeight, 1, format); - dawn::Texture source = - Create2DTexture(kWidth, kHeight, 1, 1, format, dawn::TextureUsage::CopySrc); + wgpu::Texture source = + Create2DTexture(kWidth, kHeight, 1, 1, format, wgpu::TextureUsage::CopySrc); // Verify the return value of BufferSizeForTextureCopy() is exactly the minimum valid // buffer size in this test. { uint32_t invalidBufferSize = validBufferSize - 1; - dawn::Buffer destination = - CreateBuffer(invalidBufferSize, dawn::BufferUsage::CopyDst); + wgpu::Buffer destination = + CreateBuffer(invalidBufferSize, wgpu::BufferUsage::CopyDst); TestT2BCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, destination, 0, kRowPitch, 0, {kWidth, kHeight, 1}); } { - dawn::Buffer destination = - CreateBuffer(validBufferSize, dawn::BufferUsage::CopyDst); + wgpu::Buffer destination = + CreateBuffer(validBufferSize, wgpu::BufferUsage::CopyDst); TestT2BCopy(utils::Expectation::Success, source, 0, 0, {0, 0, 0}, destination, 0, kRowPitch, 0, {kWidth, kHeight, 1}); } @@ -912,10 +912,10 @@ TEST_F(CopyCommandTest_T2B, TextureCopyBufferSizeLastRowComputation) { // Test copy from mip map of non square texture to buffer TEST_F(CopyCommandTest_T2B, CopyFromMipmapOfNonSquareTexture) { uint32_t maxMipmapLevel = 3; - dawn::Texture source = Create2DTexture(4, 2, maxMipmapLevel, 1, dawn::TextureFormat::RGBA8Unorm, - dawn::TextureUsage::CopySrc); + wgpu::Texture source = Create2DTexture(4, 2, maxMipmapLevel, 1, wgpu::TextureFormat::RGBA8Unorm, + wgpu::TextureUsage::CopySrc); uint64_t bufferSize = BufferSizeForTextureCopy(4, 2, 1); - dawn::Buffer destination = CreateBuffer(bufferSize, dawn::BufferUsage::CopyDst); + wgpu::Buffer destination = CreateBuffer(bufferSize, wgpu::BufferUsage::CopyDst); // Copy from top level mip map TestT2BCopy(utils::Expectation::Success, source, maxMipmapLevel - 1, 0, {0, 0, 0}, destination, @@ -937,10 +937,10 @@ TEST_F(CopyCommandTest_T2B, CopyFromMipmapOfNonSquareTexture) { class CopyCommandTest_T2T : public CopyCommandTest {}; TEST_F(CopyCommandTest_T2T, Success) { - dawn::Texture source = - Create2DTexture(16, 16, 5, 2, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopySrc); - dawn::Texture destination = - Create2DTexture(16, 16, 5, 2, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopyDst); + wgpu::Texture source = + Create2DTexture(16, 16, 5, 2, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::CopySrc); + wgpu::Texture destination = + Create2DTexture(16, 16, 5, 2, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::CopyDst); // Different copies, including some that touch the OOB condition { @@ -990,10 +990,10 @@ TEST_F(CopyCommandTest_T2T, Success) { } TEST_F(CopyCommandTest_T2T, IncorrectUsage) { - dawn::Texture source = - Create2DTexture(16, 16, 5, 2, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopySrc); - dawn::Texture destination = - Create2DTexture(16, 16, 5, 2, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopyDst); + wgpu::Texture source = + Create2DTexture(16, 16, 5, 2, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::CopySrc); + wgpu::Texture destination = + Create2DTexture(16, 16, 5, 2, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::CopyDst); // Incorrect source usage causes failure TestT2TCopy(utils::Expectation::Failure, destination, 0, 0, {0, 0, 0}, destination, 0, 0, @@ -1005,10 +1005,10 @@ TEST_F(CopyCommandTest_T2T, IncorrectUsage) { } TEST_F(CopyCommandTest_T2T, OutOfBounds) { - dawn::Texture source = - Create2DTexture(16, 16, 5, 2, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopySrc); - dawn::Texture destination = - Create2DTexture(16, 16, 5, 2, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopyDst); + wgpu::Texture source = + Create2DTexture(16, 16, 5, 2, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::CopySrc); + wgpu::Texture destination = + Create2DTexture(16, 16, 5, 2, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::CopyDst); // OOB on source { @@ -1058,10 +1058,10 @@ TEST_F(CopyCommandTest_T2T, OutOfBounds) { } TEST_F(CopyCommandTest_T2T, 2DTextureDepthConstraints) { - dawn::Texture source = - Create2DTexture(16, 16, 5, 2, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopySrc); - dawn::Texture destination = - Create2DTexture(16, 16, 5, 2, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopyDst); + wgpu::Texture source = + Create2DTexture(16, 16, 5, 2, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::CopySrc); + wgpu::Texture destination = + Create2DTexture(16, 16, 5, 2, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::CopyDst); // Empty copy on source with z > 0 fails TestT2TCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 1}, destination, 0, 0, {0, 0, 0}, @@ -1077,10 +1077,10 @@ TEST_F(CopyCommandTest_T2T, 2DTextureDepthConstraints) { } TEST_F(CopyCommandTest_T2T, 2DTextureDepthStencil) { - dawn::Texture source = Create2DTexture(16, 16, 1, 1, dawn::TextureFormat::Depth24PlusStencil8, - dawn::TextureUsage::CopySrc); - dawn::Texture destination = Create2DTexture( - 16, 16, 1, 1, dawn::TextureFormat::Depth24PlusStencil8, dawn::TextureUsage::CopyDst); + wgpu::Texture source = Create2DTexture(16, 16, 1, 1, wgpu::TextureFormat::Depth24PlusStencil8, + wgpu::TextureUsage::CopySrc); + wgpu::Texture destination = Create2DTexture( + 16, 16, 1, 1, wgpu::TextureFormat::Depth24PlusStencil8, wgpu::TextureUsage::CopyDst); // Success when entire depth stencil subresource is copied TestT2TCopy(utils::Expectation::Success, source, 0, 0, {0, 0, 0}, destination, 0, 0, {0, 0, 0}, @@ -1092,10 +1092,10 @@ TEST_F(CopyCommandTest_T2T, 2DTextureDepthStencil) { } TEST_F(CopyCommandTest_T2T, FormatsMismatch) { - dawn::Texture source = - Create2DTexture(16, 16, 5, 2, dawn::TextureFormat::RGBA8Uint, dawn::TextureUsage::CopySrc); - dawn::Texture destination = - Create2DTexture(16, 16, 5, 2, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopyDst); + wgpu::Texture source = + Create2DTexture(16, 16, 5, 2, wgpu::TextureFormat::RGBA8Uint, wgpu::TextureUsage::CopySrc); + wgpu::Texture destination = + Create2DTexture(16, 16, 5, 2, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::CopyDst); // Failure when formats don't match TestT2TCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, destination, 0, 0, {0, 0, 0}, @@ -1103,12 +1103,12 @@ TEST_F(CopyCommandTest_T2T, FormatsMismatch) { } TEST_F(CopyCommandTest_T2T, MultisampledCopies) { - dawn::Texture sourceMultiSampled1x = Create2DTexture( - 16, 16, 1, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopySrc, 1); - dawn::Texture sourceMultiSampled4x = Create2DTexture( - 16, 16, 1, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopySrc, 4); - dawn::Texture destinationMultiSampled4x = Create2DTexture( - 16, 16, 1, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopyDst, 4); + wgpu::Texture sourceMultiSampled1x = Create2DTexture( + 16, 16, 1, 1, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::CopySrc, 1); + wgpu::Texture sourceMultiSampled4x = Create2DTexture( + 16, 16, 1, 1, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::CopySrc, 4); + wgpu::Texture destinationMultiSampled4x = Create2DTexture( + 16, 16, 1, 1, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::CopyDst, 4); // Success when entire multisampled subresource is copied { @@ -1131,10 +1131,10 @@ TEST_F(CopyCommandTest_T2T, MultisampledCopies) { // Test copy to mip map of non square textures TEST_F(CopyCommandTest_T2T, CopyToMipmapOfNonSquareTexture) { uint32_t maxMipmapLevel = 3; - dawn::Texture source = Create2DTexture(4, 2, maxMipmapLevel, 1, dawn::TextureFormat::RGBA8Unorm, - dawn::TextureUsage::CopySrc); - dawn::Texture destination = Create2DTexture( - 4, 2, maxMipmapLevel, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopyDst); + wgpu::Texture source = Create2DTexture(4, 2, maxMipmapLevel, 1, wgpu::TextureFormat::RGBA8Unorm, + wgpu::TextureUsage::CopySrc); + wgpu::Texture destination = Create2DTexture( + 4, 2, maxMipmapLevel, 1, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::CopyDst); // Copy to top level mip map TestT2TCopy(utils::Expectation::Success, source, maxMipmapLevel - 1, 0, {0, 0, 0}, destination, maxMipmapLevel - 1, 0, {0, 0, 0}, {1, 1, 1}); @@ -1159,34 +1159,34 @@ class CopyCommandTest_CompressedTextureFormats : public CopyCommandTest { } protected: - dawn::Texture Create2DTexture(dawn::TextureFormat format, + wgpu::Texture Create2DTexture(wgpu::TextureFormat format, uint32_t mipmapLevels = 1, uint32_t width = kWidth, uint32_t height = kHeight) { - constexpr dawn::TextureUsage kUsage = - dawn::TextureUsage::CopyDst | dawn::TextureUsage::CopySrc | dawn::TextureUsage::Sampled; + constexpr wgpu::TextureUsage kUsage = + wgpu::TextureUsage::CopyDst | wgpu::TextureUsage::CopySrc | wgpu::TextureUsage::Sampled; constexpr uint32_t kArrayLayers = 1; return CopyCommandTest::Create2DTexture(width, height, mipmapLevels, kArrayLayers, format, kUsage, 1); } - static uint32_t CompressedFormatBlockSizeInBytes(dawn::TextureFormat format) { + static uint32_t CompressedFormatBlockSizeInBytes(wgpu::TextureFormat format) { switch (format) { - case dawn::TextureFormat::BC1RGBAUnorm: - case dawn::TextureFormat::BC1RGBAUnormSrgb: - case dawn::TextureFormat::BC4RSnorm: - case dawn::TextureFormat::BC4RUnorm: + case wgpu::TextureFormat::BC1RGBAUnorm: + case wgpu::TextureFormat::BC1RGBAUnormSrgb: + case wgpu::TextureFormat::BC4RSnorm: + case wgpu::TextureFormat::BC4RUnorm: return 8; - case dawn::TextureFormat::BC2RGBAUnorm: - case dawn::TextureFormat::BC2RGBAUnormSrgb: - case dawn::TextureFormat::BC3RGBAUnorm: - case dawn::TextureFormat::BC3RGBAUnormSrgb: - case dawn::TextureFormat::BC5RGSnorm: - case dawn::TextureFormat::BC5RGUnorm: - case dawn::TextureFormat::BC6HRGBSfloat: - case dawn::TextureFormat::BC6HRGBUfloat: - case dawn::TextureFormat::BC7RGBAUnorm: - case dawn::TextureFormat::BC7RGBAUnormSrgb: + case wgpu::TextureFormat::BC2RGBAUnorm: + case wgpu::TextureFormat::BC2RGBAUnormSrgb: + case wgpu::TextureFormat::BC3RGBAUnorm: + case wgpu::TextureFormat::BC3RGBAUnormSrgb: + case wgpu::TextureFormat::BC5RGSnorm: + case wgpu::TextureFormat::BC5RGUnorm: + case wgpu::TextureFormat::BC6HRGBSfloat: + case wgpu::TextureFormat::BC6HRGBUfloat: + case wgpu::TextureFormat::BC7RGBAUnorm: + case wgpu::TextureFormat::BC7RGBAUnormSrgb: return 16; default: UNREACHABLE(); @@ -1195,15 +1195,15 @@ class CopyCommandTest_CompressedTextureFormats : public CopyCommandTest { } void TestBothTBCopies(utils::Expectation expectation, - dawn::Buffer buffer, + wgpu::Buffer buffer, uint64_t bufferOffset, uint32_t bufferRowPitch, uint32_t imageHeight, - dawn::Texture texture, + wgpu::Texture texture, uint32_t level, uint32_t arraySlice, - dawn::Origin3D origin, - dawn::Extent3D extent3D) { + wgpu::Origin3D origin, + wgpu::Extent3D extent3D) { TestB2TCopy(expectation, buffer, bufferOffset, bufferRowPitch, imageHeight, texture, level, arraySlice, origin, extent3D); TestT2BCopy(expectation, texture, level, arraySlice, origin, buffer, bufferOffset, @@ -1211,15 +1211,15 @@ class CopyCommandTest_CompressedTextureFormats : public CopyCommandTest { } void TestBothT2TCopies(utils::Expectation expectation, - dawn::Texture texture1, + wgpu::Texture texture1, uint32_t level1, uint32_t slice1, - dawn::Origin3D origin1, - dawn::Texture texture2, + wgpu::Origin3D origin1, + wgpu::Texture texture2, uint32_t level2, uint32_t slice2, - dawn::Origin3D origin2, - dawn::Extent3D extent3D) { + wgpu::Origin3D origin2, + wgpu::Extent3D extent3D) { TestT2TCopy(expectation, texture1, level1, slice1, origin1, texture2, level2, slice2, origin2, extent3D); TestT2TCopy(expectation, texture2, level2, slice2, origin2, texture1, level1, slice1, @@ -1229,24 +1229,24 @@ class CopyCommandTest_CompressedTextureFormats : public CopyCommandTest { static constexpr uint32_t kWidth = 16; static constexpr uint32_t kHeight = 16; - const std::array kBCFormats = { - dawn::TextureFormat::BC1RGBAUnorm, dawn::TextureFormat::BC1RGBAUnormSrgb, - dawn::TextureFormat::BC2RGBAUnorm, dawn::TextureFormat::BC2RGBAUnormSrgb, - dawn::TextureFormat::BC3RGBAUnorm, dawn::TextureFormat::BC3RGBAUnormSrgb, - dawn::TextureFormat::BC4RUnorm, dawn::TextureFormat::BC4RSnorm, - dawn::TextureFormat::BC5RGUnorm, dawn::TextureFormat::BC5RGSnorm, - dawn::TextureFormat::BC6HRGBUfloat, dawn::TextureFormat::BC6HRGBSfloat, - dawn::TextureFormat::BC7RGBAUnorm, dawn::TextureFormat::BC7RGBAUnormSrgb}; + const std::array kBCFormats = { + wgpu::TextureFormat::BC1RGBAUnorm, wgpu::TextureFormat::BC1RGBAUnormSrgb, + wgpu::TextureFormat::BC2RGBAUnorm, wgpu::TextureFormat::BC2RGBAUnormSrgb, + wgpu::TextureFormat::BC3RGBAUnorm, wgpu::TextureFormat::BC3RGBAUnormSrgb, + wgpu::TextureFormat::BC4RUnorm, wgpu::TextureFormat::BC4RSnorm, + wgpu::TextureFormat::BC5RGUnorm, wgpu::TextureFormat::BC5RGSnorm, + wgpu::TextureFormat::BC6HRGBUfloat, wgpu::TextureFormat::BC6HRGBSfloat, + wgpu::TextureFormat::BC7RGBAUnorm, wgpu::TextureFormat::BC7RGBAUnormSrgb}; }; // Tests to verify that bufferOffset must be a multiple of the compressed texture blocks in bytes // in buffer-to-texture or texture-to-buffer copies with compressed texture formats. TEST_F(CopyCommandTest_CompressedTextureFormats, BufferOffset) { - dawn::Buffer buffer = - CreateBuffer(512, dawn::BufferUsage::CopySrc | dawn::BufferUsage::CopyDst); + wgpu::Buffer buffer = + CreateBuffer(512, wgpu::BufferUsage::CopySrc | wgpu::BufferUsage::CopyDst); - for (dawn::TextureFormat bcFormat : kBCFormats) { - dawn::Texture texture = Create2DTexture(bcFormat); + for (wgpu::TextureFormat bcFormat : kBCFormats) { + wgpu::Texture texture = Create2DTexture(bcFormat); // Valid usages of BufferOffset in B2T and T2B copies with compressed texture formats. { @@ -1270,8 +1270,8 @@ TEST_F(CopyCommandTest_CompressedTextureFormats, BufferOffset) { // Note that in Dawn we require RowPitch be a multiple of 256, which ensures RowPitch will always be // the multiple of compressed texture block width in bytes. TEST_F(CopyCommandTest_CompressedTextureFormats, RowPitch) { - dawn::Buffer buffer = - CreateBuffer(1024, dawn::BufferUsage::CopySrc | dawn::BufferUsage::CopyDst); + wgpu::Buffer buffer = + CreateBuffer(1024, wgpu::BufferUsage::CopySrc | wgpu::BufferUsage::CopyDst); { constexpr uint32_t kTestWidth = 160; @@ -1280,8 +1280,8 @@ TEST_F(CopyCommandTest_CompressedTextureFormats, RowPitch) { // Failures on the RowPitch that is not large enough. { constexpr uint32_t kSmallRowPitch = 256; - for (dawn::TextureFormat bcFormat : kBCFormats) { - dawn::Texture texture = Create2DTexture(bcFormat, 1, kTestWidth, kTestHeight); + for (wgpu::TextureFormat bcFormat : kBCFormats) { + wgpu::Texture texture = Create2DTexture(bcFormat, 1, kTestWidth, kTestHeight); TestBothTBCopies(utils::Expectation::Failure, buffer, 0, kSmallRowPitch, 4, texture, 0, 0, {0, 0, 0}, {kTestWidth, 4, 1}); } @@ -1289,8 +1289,8 @@ TEST_F(CopyCommandTest_CompressedTextureFormats, RowPitch) { // Test it is not valid to use a RowPitch that is not a multiple of 256. { - for (dawn::TextureFormat bcFormat : kBCFormats) { - dawn::Texture texture = Create2DTexture(bcFormat, 1, kTestWidth, kTestHeight); + for (wgpu::TextureFormat bcFormat : kBCFormats) { + wgpu::Texture texture = Create2DTexture(bcFormat, 1, kTestWidth, kTestHeight); uint32_t inValidRowPitch = kTestWidth / 4 * CompressedFormatBlockSizeInBytes(bcFormat); ASSERT_NE(0u, inValidRowPitch % 256); @@ -1301,8 +1301,8 @@ TEST_F(CopyCommandTest_CompressedTextureFormats, RowPitch) { // Test the smallest valid RowPitch should work. { - for (dawn::TextureFormat bcFormat : kBCFormats) { - dawn::Texture texture = Create2DTexture(bcFormat, 1, kTestWidth, kTestHeight); + for (wgpu::TextureFormat bcFormat : kBCFormats) { + wgpu::Texture texture = Create2DTexture(bcFormat, 1, kTestWidth, kTestHeight); uint32_t smallestValidRowPitch = Align(kTestWidth / 4 * CompressedFormatBlockSizeInBytes(bcFormat), 256); TestBothTBCopies(utils::Expectation::Success, buffer, 0, smallestValidRowPitch, 4, @@ -1318,8 +1318,8 @@ TEST_F(CopyCommandTest_CompressedTextureFormats, RowPitch) { { constexpr uint32_t kValidWidth = 128; - for (dawn::TextureFormat bcFormat : kBCFormats) { - dawn::Texture texture = Create2DTexture(bcFormat, 1, kValidWidth, kTestHeight); + for (wgpu::TextureFormat bcFormat : kBCFormats) { + wgpu::Texture texture = Create2DTexture(bcFormat, 1, kValidWidth, kTestHeight); TestBothTBCopies(utils::Expectation::Success, buffer, 0, kZeroRowPitch, 4, texture, 0, 0, {0, 0, 0}, {kValidWidth, 4, 1}); } @@ -1327,8 +1327,8 @@ TEST_F(CopyCommandTest_CompressedTextureFormats, RowPitch) { { constexpr uint32_t kInValidWidth = 16; - for (dawn::TextureFormat bcFormat : kBCFormats) { - dawn::Texture texture = Create2DTexture(bcFormat, 1, kInValidWidth, kTestHeight); + for (wgpu::TextureFormat bcFormat : kBCFormats) { + wgpu::Texture texture = Create2DTexture(bcFormat, 1, kInValidWidth, kTestHeight); TestBothTBCopies(utils::Expectation::Failure, buffer, 0, kZeroRowPitch, 4, texture, 0, 0, {0, 0, 0}, {kInValidWidth, 4, 1}); } @@ -1339,11 +1339,11 @@ TEST_F(CopyCommandTest_CompressedTextureFormats, RowPitch) { // Tests to verify that imageHeight must be a multiple of the compressed texture block height in // buffer-to-texture or texture-to-buffer copies with compressed texture formats. TEST_F(CopyCommandTest_CompressedTextureFormats, ImageHeight) { - dawn::Buffer buffer = - CreateBuffer(512, dawn::BufferUsage::CopySrc | dawn::BufferUsage::CopyDst); + wgpu::Buffer buffer = + CreateBuffer(512, wgpu::BufferUsage::CopySrc | wgpu::BufferUsage::CopyDst); - for (dawn::TextureFormat bcFormat : kBCFormats) { - dawn::Texture texture = Create2DTexture(bcFormat); + for (wgpu::TextureFormat bcFormat : kBCFormats) { + wgpu::Texture texture = Create2DTexture(bcFormat); // Valid usages of imageHeight in B2T and T2B copies with compressed texture formats. { @@ -1365,14 +1365,14 @@ TEST_F(CopyCommandTest_CompressedTextureFormats, ImageHeight) { // ImageOffset.y must be a multiple of the compressed texture block height in buffer-to-texture, // texture-to-buffer or texture-to-texture copies with compressed texture formats. TEST_F(CopyCommandTest_CompressedTextureFormats, ImageOffset) { - dawn::Buffer buffer = - CreateBuffer(512, dawn::BufferUsage::CopySrc | dawn::BufferUsage::CopyDst); + wgpu::Buffer buffer = + CreateBuffer(512, wgpu::BufferUsage::CopySrc | wgpu::BufferUsage::CopyDst); - for (dawn::TextureFormat bcFormat : kBCFormats) { - dawn::Texture texture = Create2DTexture(bcFormat); - dawn::Texture texture2 = Create2DTexture(bcFormat); + for (wgpu::TextureFormat bcFormat : kBCFormats) { + wgpu::Texture texture = Create2DTexture(bcFormat); + wgpu::Texture texture2 = Create2DTexture(bcFormat); - constexpr dawn::Origin3D kSmallestValidOrigin3D = {4, 4, 0}; + constexpr wgpu::Origin3D kSmallestValidOrigin3D = {4, 4, 0}; // Valid usages of ImageOffset in B2T, T2B and T2T copies with compressed texture formats. { @@ -1384,7 +1384,7 @@ TEST_F(CopyCommandTest_CompressedTextureFormats, ImageOffset) { // Failures on invalid ImageOffset.x. { - constexpr dawn::Origin3D kInvalidOrigin3D = {kSmallestValidOrigin3D.x - 1, + constexpr wgpu::Origin3D kInvalidOrigin3D = {kSmallestValidOrigin3D.x - 1, kSmallestValidOrigin3D.y, 0}; TestBothTBCopies(utils::Expectation::Failure, buffer, 0, 256, 4, texture, 0, 0, kInvalidOrigin3D, {4, 4, 1}); @@ -1394,7 +1394,7 @@ TEST_F(CopyCommandTest_CompressedTextureFormats, ImageOffset) { // Failures on invalid ImageOffset.y. { - constexpr dawn::Origin3D kInvalidOrigin3D = {kSmallestValidOrigin3D.x, + constexpr wgpu::Origin3D kInvalidOrigin3D = {kSmallestValidOrigin3D.x, kSmallestValidOrigin3D.y - 1, 0}; TestBothTBCopies(utils::Expectation::Failure, buffer, 0, 256, 4, texture, 0, 0, kInvalidOrigin3D, {4, 4, 1}); @@ -1408,18 +1408,18 @@ TEST_F(CopyCommandTest_CompressedTextureFormats, ImageOffset) { // ImageExtent.y must be a multiple of the compressed texture block height in buffer-to-texture, // texture-to-buffer or texture-to-texture copies with compressed texture formats. TEST_F(CopyCommandTest_CompressedTextureFormats, ImageExtent) { - dawn::Buffer buffer = - CreateBuffer(512, dawn::BufferUsage::CopySrc | dawn::BufferUsage::CopyDst); + wgpu::Buffer buffer = + CreateBuffer(512, wgpu::BufferUsage::CopySrc | wgpu::BufferUsage::CopyDst); constexpr uint32_t kMipmapLevels = 3; constexpr uint32_t kTestWidth = 60; constexpr uint32_t kTestHeight = 60; - for (dawn::TextureFormat bcFormat : kBCFormats) { - dawn::Texture texture = Create2DTexture(bcFormat, kMipmapLevels, kTestWidth, kTestHeight); - dawn::Texture texture2 = Create2DTexture(bcFormat, kMipmapLevels, kTestWidth, kTestHeight); + for (wgpu::TextureFormat bcFormat : kBCFormats) { + wgpu::Texture texture = Create2DTexture(bcFormat, kMipmapLevels, kTestWidth, kTestHeight); + wgpu::Texture texture2 = Create2DTexture(bcFormat, kMipmapLevels, kTestWidth, kTestHeight); - constexpr dawn::Extent3D kSmallestValidExtent3D = {4, 4, 1}; + constexpr wgpu::Extent3D kSmallestValidExtent3D = {4, 4, 1}; // Valid usages of ImageExtent in B2T, T2B and T2T copies with compressed texture formats. { @@ -1433,7 +1433,7 @@ TEST_F(CopyCommandTest_CompressedTextureFormats, ImageExtent) { // and non-zero mipmap levels. { constexpr uint32_t kTestMipmapLevel = 2; - constexpr dawn::Origin3D kTestOrigin = { + constexpr wgpu::Origin3D kTestOrigin = { (kTestWidth >> kTestMipmapLevel) - kSmallestValidExtent3D.width + 1, (kTestHeight >> kTestMipmapLevel) - kSmallestValidExtent3D.height + 1, 0}; @@ -1445,7 +1445,7 @@ TEST_F(CopyCommandTest_CompressedTextureFormats, ImageExtent) { // Failures on invalid ImageExtent.x. { - constexpr dawn::Extent3D kInValidExtent3D = {kSmallestValidExtent3D.width - 1, + constexpr wgpu::Extent3D kInValidExtent3D = {kSmallestValidExtent3D.width - 1, kSmallestValidExtent3D.height, 1}; TestBothTBCopies(utils::Expectation::Failure, buffer, 0, 256, 4, texture, 0, 0, {0, 0, 0}, kInValidExtent3D); @@ -1455,7 +1455,7 @@ TEST_F(CopyCommandTest_CompressedTextureFormats, ImageExtent) { // Failures on invalid ImageExtent.y. { - constexpr dawn::Extent3D kInValidExtent3D = {kSmallestValidExtent3D.width, + constexpr wgpu::Extent3D kInValidExtent3D = {kSmallestValidExtent3D.width, kSmallestValidExtent3D.height - 1, 1}; TestBothTBCopies(utils::Expectation::Failure, buffer, 0, 256, 4, texture, 0, 0, {0, 0, 0}, kInValidExtent3D); diff --git a/src/tests/unittests/validation/DebugMarkerValidationTests.cpp b/src/tests/unittests/validation/DebugMarkerValidationTests.cpp index 7a343dbf82..49520cb9d7 100644 --- a/src/tests/unittests/validation/DebugMarkerValidationTests.cpp +++ b/src/tests/unittests/validation/DebugMarkerValidationTests.cpp @@ -22,9 +22,9 @@ class DebugMarkerValidationTest : public ValidationTest {}; TEST_F(DebugMarkerValidationTest, RenderSuccess) { DummyRenderPass renderPass(device); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); { - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); pass.PushDebugGroup("Event Start"); pass.PushDebugGroup("Event Start"); pass.InsertDebugMarker("Marker"); @@ -40,9 +40,9 @@ TEST_F(DebugMarkerValidationTest, RenderSuccess) { TEST_F(DebugMarkerValidationTest, RenderUnbalancedPush) { DummyRenderPass renderPass(device); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); { - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); pass.PushDebugGroup("Event Start"); pass.PushDebugGroup("Event Start"); pass.InsertDebugMarker("Marker"); @@ -57,9 +57,9 @@ TEST_F(DebugMarkerValidationTest, RenderUnbalancedPush) { TEST_F(DebugMarkerValidationTest, RenderUnbalancedPop) { DummyRenderPass renderPass(device); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); { - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); pass.PushDebugGroup("Event Start"); pass.InsertDebugMarker("Marker"); pass.PopDebugGroup(); @@ -72,9 +72,9 @@ TEST_F(DebugMarkerValidationTest, RenderUnbalancedPop) { // Correct usage of debug markers should succeed in compute pass. TEST_F(DebugMarkerValidationTest, ComputeSuccess) { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); { - dawn::ComputePassEncoder pass = encoder.BeginComputePass(); + wgpu::ComputePassEncoder pass = encoder.BeginComputePass(); pass.PushDebugGroup("Event Start"); pass.PushDebugGroup("Event Start"); pass.InsertDebugMarker("Marker"); @@ -88,9 +88,9 @@ TEST_F(DebugMarkerValidationTest, ComputeSuccess) { // A PushDebugGroup call without a following PopDebugGroup produces an error in compute pass. TEST_F(DebugMarkerValidationTest, ComputeUnbalancedPush) { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); { - dawn::ComputePassEncoder pass = encoder.BeginComputePass(); + wgpu::ComputePassEncoder pass = encoder.BeginComputePass(); pass.PushDebugGroup("Event Start"); pass.PushDebugGroup("Event Start"); pass.InsertDebugMarker("Marker"); @@ -103,9 +103,9 @@ TEST_F(DebugMarkerValidationTest, ComputeUnbalancedPush) { // A PopDebugGroup call without a preceding PushDebugGroup produces an error in compute pass. TEST_F(DebugMarkerValidationTest, ComputeUnbalancedPop) { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); { - dawn::ComputePassEncoder pass = encoder.BeginComputePass(); + wgpu::ComputePassEncoder pass = encoder.BeginComputePass(); pass.PushDebugGroup("Event Start"); pass.InsertDebugMarker("Marker"); pass.PopDebugGroup(); @@ -118,7 +118,7 @@ TEST_F(DebugMarkerValidationTest, ComputeUnbalancedPop) { // Correct usage of debug markers should succeed in command encoder. TEST_F(DebugMarkerValidationTest, CommandEncoderSuccess) { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); encoder.PushDebugGroup("Event Start"); encoder.PushDebugGroup("Event Start"); encoder.InsertDebugMarker("Marker"); @@ -129,7 +129,7 @@ TEST_F(DebugMarkerValidationTest, CommandEncoderSuccess) { // A PushDebugGroup call without a following PopDebugGroup produces an error in command encoder. TEST_F(DebugMarkerValidationTest, CommandEncoderUnbalancedPush) { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); encoder.PushDebugGroup("Event Start"); encoder.PushDebugGroup("Event Start"); encoder.InsertDebugMarker("Marker"); @@ -139,7 +139,7 @@ TEST_F(DebugMarkerValidationTest, CommandEncoderUnbalancedPush) { // A PopDebugGroup call without a preceding PushDebugGroup produces an error in command encoder. TEST_F(DebugMarkerValidationTest, CommandEncoderUnbalancedPop) { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); encoder.PushDebugGroup("Event Start"); encoder.InsertDebugMarker("Marker"); encoder.PopDebugGroup(); @@ -149,10 +149,10 @@ TEST_F(DebugMarkerValidationTest, CommandEncoderUnbalancedPop) { // It is possible to nested pushes in a compute pass in a command encoder. TEST_F(DebugMarkerValidationTest, NestedComputeInCommandEncoder) { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); encoder.PushDebugGroup("Event Start"); { - dawn::ComputePassEncoder pass = encoder.BeginComputePass(); + wgpu::ComputePassEncoder pass = encoder.BeginComputePass(); pass.PushDebugGroup("Event Start"); pass.InsertDebugMarker("Marker"); pass.PopDebugGroup(); @@ -164,10 +164,10 @@ TEST_F(DebugMarkerValidationTest, NestedComputeInCommandEncoder) { // Command encoder and compute pass pushes must be balanced independently. TEST_F(DebugMarkerValidationTest, NestedComputeInCommandEncoderIndependent) { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); encoder.PushDebugGroup("Event Start"); { - dawn::ComputePassEncoder pass = encoder.BeginComputePass(); + wgpu::ComputePassEncoder pass = encoder.BeginComputePass(); pass.InsertDebugMarker("Marker"); pass.PopDebugGroup(); pass.EndPass(); @@ -179,10 +179,10 @@ TEST_F(DebugMarkerValidationTest, NestedComputeInCommandEncoderIndependent) { TEST_F(DebugMarkerValidationTest, NestedRenderInCommandEncoder) { DummyRenderPass renderPass(device); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); encoder.PushDebugGroup("Event Start"); { - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); pass.PushDebugGroup("Event Start"); pass.InsertDebugMarker("Marker"); pass.PopDebugGroup(); @@ -196,10 +196,10 @@ TEST_F(DebugMarkerValidationTest, NestedRenderInCommandEncoder) { TEST_F(DebugMarkerValidationTest, NestedRenderInCommandEncoderIndependent) { DummyRenderPass renderPass(device); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); encoder.PushDebugGroup("Event Start"); { - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); pass.InsertDebugMarker("Marker"); pass.PopDebugGroup(); pass.EndPass(); diff --git a/src/tests/unittests/validation/DrawIndirectValidationTests.cpp b/src/tests/unittests/validation/DrawIndirectValidationTests.cpp index 61818ddbb1..4b30651416 100644 --- a/src/tests/unittests/validation/DrawIndirectValidationTests.cpp +++ b/src/tests/unittests/validation/DrawIndirectValidationTests.cpp @@ -23,14 +23,14 @@ class DrawIndirectValidationTest : public ValidationTest { void SetUp() override { ValidationTest::SetUp(); - dawn::ShaderModule vsModule = + wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, utils::SingleShaderStage::Vertex, R"( #version 450 void main() { gl_Position = vec4(0.0); })"); - dawn::ShaderModule fsModule = + wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, utils::SingleShaderStage::Fragment, R"( #version 450 layout(location = 0) out vec4 fragColor; @@ -39,7 +39,7 @@ class DrawIndirectValidationTest : public ValidationTest { })"); // Set up render pipeline - dawn::PipelineLayout pipelineLayout = utils::MakeBasicPipelineLayout(device, nullptr); + wgpu::PipelineLayout pipelineLayout = utils::MakeBasicPipelineLayout(device, nullptr); utils::ComboRenderPipelineDescriptor descriptor(device); descriptor.layout = pipelineLayout; @@ -49,7 +49,7 @@ class DrawIndirectValidationTest : public ValidationTest { pipeline = device.CreateRenderPipeline(&descriptor); } - void ValidateExpectation(dawn::CommandEncoder encoder, utils::Expectation expectation) { + void ValidateExpectation(wgpu::CommandEncoder encoder, utils::Expectation expectation) { if (expectation == utils::Expectation::Success) { encoder.Finish(); } else { @@ -73,17 +73,17 @@ class DrawIndirectValidationTest : public ValidationTest { std::initializer_list bufferList, uint64_t indirectOffset, bool indexed) { - dawn::Buffer indirectBuffer = - utils::CreateBufferFromData(device, dawn::BufferUsage::Indirect, bufferList); + wgpu::Buffer indirectBuffer = + utils::CreateBufferFromData(device, wgpu::BufferUsage::Indirect, bufferList); DummyRenderPass renderPass(device); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); pass.SetPipeline(pipeline); if (indexed) { uint32_t zeros[100] = {}; - dawn::Buffer indexBuffer = - utils::CreateBufferFromData(device, zeros, sizeof(zeros), dawn::BufferUsage::Index); + wgpu::Buffer indexBuffer = + utils::CreateBufferFromData(device, zeros, sizeof(zeros), wgpu::BufferUsage::Index); pass.SetIndexBuffer(indexBuffer); pass.DrawIndexedIndirect(indirectBuffer, indirectOffset); } else { @@ -94,7 +94,7 @@ class DrawIndirectValidationTest : public ValidationTest { ValidateExpectation(encoder, expectation); } - dawn::RenderPipeline pipeline; + wgpu::RenderPipeline pipeline; }; // Verify out of bounds indirect draw calls are caught early diff --git a/src/tests/unittests/validation/DynamicStateCommandValidationTests.cpp b/src/tests/unittests/validation/DynamicStateCommandValidationTests.cpp index c2ae7642f5..dc04dd7609 100644 --- a/src/tests/unittests/validation/DynamicStateCommandValidationTests.cpp +++ b/src/tests/unittests/validation/DynamicStateCommandValidationTests.cpp @@ -22,9 +22,9 @@ class SetViewportTest : public ValidationTest {}; TEST_F(SetViewportTest, Success) { DummyRenderPass renderPass(device); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); { - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); pass.SetViewport(0.0, 0.0, 1.0, 1.0, 0.0, 1.0); pass.EndPass(); } @@ -37,8 +37,8 @@ TEST_F(SetViewportTest, ViewportParameterNaN) { // x or y is NaN. { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); pass.SetViewport(NAN, 0.0, 1.0, 1.0, 0.0, 1.0); pass.EndPass(); ASSERT_DEVICE_ERROR(encoder.Finish()); @@ -46,8 +46,8 @@ TEST_F(SetViewportTest, ViewportParameterNaN) { // width or height is NaN. { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); pass.SetViewport(0.0, 0.0, NAN, 1.0, 0.0, 1.0); pass.EndPass(); ASSERT_DEVICE_ERROR(encoder.Finish()); @@ -55,8 +55,8 @@ TEST_F(SetViewportTest, ViewportParameterNaN) { // minDepth or maxDepth is NaN. { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); pass.SetViewport(0.0, 0.0, 1.0, 1.0, NAN, 1.0); pass.EndPass(); ASSERT_DEVICE_ERROR(encoder.Finish()); @@ -69,8 +69,8 @@ TEST_F(SetViewportTest, EmptyViewport) { // Width of viewport is zero. { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); pass.SetViewport(0.0, 0.0, 0.0, 1.0, 0.0, 1.0); pass.EndPass(); ASSERT_DEVICE_ERROR(encoder.Finish()); @@ -78,8 +78,8 @@ TEST_F(SetViewportTest, EmptyViewport) { // Height of viewport is zero. { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); pass.SetViewport(0.0, 0.0, 1.0, 0.0, 0.0, 1.0); pass.EndPass(); ASSERT_DEVICE_ERROR(encoder.Finish()); @@ -87,8 +87,8 @@ TEST_F(SetViewportTest, EmptyViewport) { // Both width and height of viewport are zero. { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); pass.SetViewport(0.0, 0.0, 0.0, 0.0, 0.0, 1.0); pass.EndPass(); ASSERT_DEVICE_ERROR(encoder.Finish()); @@ -99,9 +99,9 @@ TEST_F(SetViewportTest, EmptyViewport) { TEST_F(SetViewportTest, ViewportLargerThanFramebuffer) { DummyRenderPass renderPass(device); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); { - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); pass.SetViewport(0.0, 0.0, renderPass.width + 1, renderPass.height + 1, 0.0, 1.0); pass.EndPass(); } @@ -112,9 +112,9 @@ TEST_F(SetViewportTest, ViewportLargerThanFramebuffer) { TEST_F(SetViewportTest, NegativeX) { DummyRenderPass renderPass(device); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); { - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); pass.SetViewport(-1.0, 0.0, 1.0, 1.0, 0.0, 1.0); pass.EndPass(); } @@ -125,9 +125,9 @@ TEST_F(SetViewportTest, NegativeX) { TEST_F(SetViewportTest, NegativeY) { DummyRenderPass renderPass(device); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); { - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); pass.SetViewport(0.0, -1.0, 1.0, 1.0, 0.0, 1.0); pass.EndPass(); } @@ -138,9 +138,9 @@ TEST_F(SetViewportTest, NegativeY) { TEST_F(SetViewportTest, NegativeWidth) { DummyRenderPass renderPass(device); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); { - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); pass.SetViewport(0.0, 0.0, -1.0, 1.0, 0.0, 1.0); pass.EndPass(); ASSERT_DEVICE_ERROR(encoder.Finish()); @@ -151,9 +151,9 @@ TEST_F(SetViewportTest, NegativeWidth) { TEST_F(SetViewportTest, NegativeHeight) { DummyRenderPass renderPass(device); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); { - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); pass.SetViewport(0.0, 0.0, 0.0, -1.0, 0.0, 1.0); pass.EndPass(); ASSERT_DEVICE_ERROR(encoder.Finish()); @@ -165,16 +165,16 @@ TEST_F(SetViewportTest, MinDepthOutOfRange) { DummyRenderPass renderPass(device); { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); pass.SetViewport(0.0, 0.0, 1.0, 1.0, -1.0, 1.0); pass.EndPass(); ASSERT_DEVICE_ERROR(encoder.Finish()); } { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); pass.SetViewport(0.0, 0.0, 1.0, 1.0, 2.0, 1.0); pass.EndPass(); ASSERT_DEVICE_ERROR(encoder.Finish()); @@ -186,16 +186,16 @@ TEST_F(SetViewportTest, MaxDepthOutOfRange) { DummyRenderPass renderPass(device); { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); pass.SetViewport(0.0, 0.0, 1.0, 1.0, 0.0, -1.0); pass.EndPass(); ASSERT_DEVICE_ERROR(encoder.Finish()); } { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); pass.SetViewport(0.0, 0.0, 1.0, 1.0, 0.0, 2.0); pass.EndPass(); ASSERT_DEVICE_ERROR(encoder.Finish()); @@ -207,16 +207,16 @@ TEST_F(SetViewportTest, MinDepthEqualOrLessThanMaxDepth) { DummyRenderPass renderPass(device); { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); pass.SetViewport(0.0, 0.0, 1.0, 1.0, 0.5, 0.5); pass.EndPass(); encoder.Finish(); } { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); pass.SetViewport(0.0, 0.0, 1.0, 1.0, 0.8, 0.5); pass.EndPass(); encoder.Finish(); @@ -230,9 +230,9 @@ class SetScissorRectTest : public ValidationTest { TEST_F(SetScissorRectTest, Success) { DummyRenderPass renderPass(device); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); { - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); pass.SetScissorRect(0, 0, 1, 1); pass.EndPass(); } @@ -245,8 +245,8 @@ TEST_F(SetScissorRectTest, EmptyScissor) { // Width of scissor rect is zero. { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); pass.SetScissorRect(0, 0, 0, 1); pass.EndPass(); ASSERT_DEVICE_ERROR(encoder.Finish()); @@ -254,8 +254,8 @@ TEST_F(SetScissorRectTest, EmptyScissor) { // Height of scissor rect is zero. { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); pass.SetScissorRect(0, 0, 1, 0); pass.EndPass(); ASSERT_DEVICE_ERROR(encoder.Finish()); @@ -263,8 +263,8 @@ TEST_F(SetScissorRectTest, EmptyScissor) { // Both width and height of scissor rect are zero. { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); pass.SetScissorRect(0, 0, 0, 0); pass.EndPass(); ASSERT_DEVICE_ERROR(encoder.Finish()); @@ -275,9 +275,9 @@ TEST_F(SetScissorRectTest, EmptyScissor) { TEST_F(SetScissorRectTest, ScissorLargerThanFramebuffer) { DummyRenderPass renderPass(device); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); { - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); pass.SetScissorRect(0, 0, renderPass.width + 1, renderPass.height + 1); pass.EndPass(); } @@ -291,10 +291,10 @@ class SetBlendColorTest : public ValidationTest { TEST_F(SetBlendColorTest, Success) { DummyRenderPass renderPass(device); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); { - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); - constexpr dawn::Color kTransparentBlack{0.0f, 0.0f, 0.0f, 0.0f}; + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + constexpr wgpu::Color kTransparentBlack{0.0f, 0.0f, 0.0f, 0.0f}; pass.SetBlendColor(&kTransparentBlack); pass.EndPass(); } @@ -305,10 +305,10 @@ TEST_F(SetBlendColorTest, Success) { TEST_F(SetBlendColorTest, AnyValueAllowed) { DummyRenderPass renderPass(device); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); { - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); - constexpr dawn::Color kAnyColorValue{-1.0f, 42.0f, -0.0f, 0.0f}; + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + constexpr wgpu::Color kAnyColorValue{-1.0f, 42.0f, -0.0f, 0.0f}; pass.SetBlendColor(&kAnyColorValue); pass.EndPass(); } @@ -322,9 +322,9 @@ class SetStencilReferenceTest : public ValidationTest { TEST_F(SetStencilReferenceTest, Success) { DummyRenderPass renderPass(device); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); { - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); pass.SetStencilReference(0); pass.EndPass(); } @@ -335,9 +335,9 @@ TEST_F(SetStencilReferenceTest, Success) { TEST_F(SetStencilReferenceTest, AllBitsAllowed) { DummyRenderPass renderPass(device); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); { - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); pass.SetStencilReference(0xFFFFFFFF); pass.EndPass(); } diff --git a/src/tests/unittests/validation/ErrorScopeValidationTests.cpp b/src/tests/unittests/validation/ErrorScopeValidationTests.cpp index 8d2c749234..817ce70d69 100644 --- a/src/tests/unittests/validation/ErrorScopeValidationTests.cpp +++ b/src/tests/unittests/validation/ErrorScopeValidationTests.cpp @@ -20,11 +20,11 @@ using namespace testing; class MockDevicePopErrorScopeCallback { public: - MOCK_METHOD3(Call, void(DawnErrorType type, const char* message, void* userdata)); + MOCK_METHOD3(Call, void(WGPUErrorType type, const char* message, void* userdata)); }; static std::unique_ptr mockDevicePopErrorScopeCallback; -static void ToMockDevicePopErrorScopeCallback(DawnErrorType type, +static void ToMockDevicePopErrorScopeCallback(WGPUErrorType type, const char* message, void* userdata) { mockDevicePopErrorScopeCallback->Call(type, message, userdata); @@ -46,73 +46,71 @@ class ErrorScopeValidationTest : public ValidationTest { // Test the simple success case. TEST_F(ErrorScopeValidationTest, Success) { - device.PushErrorScope(dawn::ErrorFilter::Validation); + device.PushErrorScope(wgpu::ErrorFilter::Validation); - EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(DAWN_ERROR_TYPE_NO_ERROR, _, this)).Times(1); + EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(WGPUErrorType_NoError, _, this)).Times(1); device.PopErrorScope(ToMockDevicePopErrorScopeCallback, this); } // Test the simple case where the error scope catches an error. TEST_F(ErrorScopeValidationTest, CatchesError) { - device.PushErrorScope(dawn::ErrorFilter::Validation); + device.PushErrorScope(wgpu::ErrorFilter::Validation); - dawn::BufferDescriptor desc = {}; - desc.usage = static_cast(DAWN_BUFFER_USAGE_FORCE32); + wgpu::BufferDescriptor desc = {}; + desc.usage = static_cast(WGPUBufferUsage_Force32); device.CreateBuffer(&desc); - EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(DAWN_ERROR_TYPE_VALIDATION, _, this)) - .Times(1); + EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(WGPUErrorType_Validation, _, this)).Times(1); device.PopErrorScope(ToMockDevicePopErrorScopeCallback, this); } // Test that errors bubble to the parent scope if not handled by the current scope. TEST_F(ErrorScopeValidationTest, ErrorBubbles) { - device.PushErrorScope(dawn::ErrorFilter::Validation); - device.PushErrorScope(dawn::ErrorFilter::OutOfMemory); + device.PushErrorScope(wgpu::ErrorFilter::Validation); + device.PushErrorScope(wgpu::ErrorFilter::OutOfMemory); - dawn::BufferDescriptor desc = {}; - desc.usage = static_cast(DAWN_BUFFER_USAGE_FORCE32); + wgpu::BufferDescriptor desc = {}; + desc.usage = static_cast(WGPUBufferUsage_Force32); device.CreateBuffer(&desc); // OutOfMemory does not match Validation error. - EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(DAWN_ERROR_TYPE_NO_ERROR, _, this)).Times(1); + EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(WGPUErrorType_NoError, _, this)).Times(1); device.PopErrorScope(ToMockDevicePopErrorScopeCallback, this); // Parent validation error scope captures the error. - EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(DAWN_ERROR_TYPE_VALIDATION, _, this + 1)) + EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(WGPUErrorType_Validation, _, this + 1)) .Times(1); device.PopErrorScope(ToMockDevicePopErrorScopeCallback, this + 1); } // Test that if an error scope matches an error, it does not bubble to the parent scope. TEST_F(ErrorScopeValidationTest, HandledErrorsStopBubbling) { - device.PushErrorScope(dawn::ErrorFilter::OutOfMemory); - device.PushErrorScope(dawn::ErrorFilter::Validation); + device.PushErrorScope(wgpu::ErrorFilter::OutOfMemory); + device.PushErrorScope(wgpu::ErrorFilter::Validation); - dawn::BufferDescriptor desc = {}; - desc.usage = static_cast(DAWN_BUFFER_USAGE_FORCE32); + wgpu::BufferDescriptor desc = {}; + desc.usage = static_cast(WGPUBufferUsage_Force32); device.CreateBuffer(&desc); // Inner scope catches the error. - EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(DAWN_ERROR_TYPE_VALIDATION, _, this)) - .Times(1); + EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(WGPUErrorType_Validation, _, this)).Times(1); device.PopErrorScope(ToMockDevicePopErrorScopeCallback, this); // Parent scope does not see the error. - EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(DAWN_ERROR_TYPE_NO_ERROR, _, this + 1)) + EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(WGPUErrorType_NoError, _, this + 1)) .Times(1); device.PopErrorScope(ToMockDevicePopErrorScopeCallback, this + 1); } // Test that if no error scope handles an error, it goes to the device UncapturedError callback TEST_F(ErrorScopeValidationTest, UnhandledErrorsMatchUncapturedErrorCallback) { - device.PushErrorScope(dawn::ErrorFilter::OutOfMemory); + device.PushErrorScope(wgpu::ErrorFilter::OutOfMemory); - dawn::BufferDescriptor desc = {}; - desc.usage = static_cast(DAWN_BUFFER_USAGE_FORCE32); + wgpu::BufferDescriptor desc = {}; + desc.usage = static_cast(WGPUBufferUsage_Force32); ASSERT_DEVICE_ERROR(device.CreateBuffer(&desc)); - EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(DAWN_ERROR_TYPE_NO_ERROR, _, this)).Times(1); + EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(WGPUErrorType_NoError, _, this)).Times(1); device.PopErrorScope(ToMockDevicePopErrorScopeCallback, this); } @@ -123,9 +121,9 @@ TEST_F(ErrorScopeValidationTest, PushPopBalanced) { // Too many pops { - device.PushErrorScope(dawn::ErrorFilter::Validation); + device.PushErrorScope(wgpu::ErrorFilter::Validation); - EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(DAWN_ERROR_TYPE_NO_ERROR, _, this + 1)) + EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(WGPUErrorType_NoError, _, this + 1)) .Times(1); device.PopErrorScope(ToMockDevicePopErrorScopeCallback, this + 1); @@ -136,13 +134,13 @@ TEST_F(ErrorScopeValidationTest, PushPopBalanced) { // Test that error scopes do not call their callbacks until after an enclosed Queue::Submit // completes TEST_F(ErrorScopeValidationTest, CallbackAfterQueueSubmit) { - dawn::Queue queue = device.CreateQueue(); + wgpu::Queue queue = device.CreateQueue(); - device.PushErrorScope(dawn::ErrorFilter::OutOfMemory); + device.PushErrorScope(wgpu::ErrorFilter::OutOfMemory); queue.Submit(0, nullptr); device.PopErrorScope(ToMockDevicePopErrorScopeCallback, this); - EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(DAWN_ERROR_TYPE_NO_ERROR, _, this)).Times(1); + EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(WGPUErrorType_NoError, _, this)).Times(1); // Side effects of Queue::Submit only are seen after Tick() device.Tick(); @@ -151,16 +149,16 @@ TEST_F(ErrorScopeValidationTest, CallbackAfterQueueSubmit) { // Test that parent error scopes do not call their callbacks until after an enclosed Queue::Submit // completes TEST_F(ErrorScopeValidationTest, CallbackAfterQueueSubmitNested) { - dawn::Queue queue = device.CreateQueue(); + wgpu::Queue queue = device.CreateQueue(); - device.PushErrorScope(dawn::ErrorFilter::OutOfMemory); - device.PushErrorScope(dawn::ErrorFilter::OutOfMemory); + device.PushErrorScope(wgpu::ErrorFilter::OutOfMemory); + device.PushErrorScope(wgpu::ErrorFilter::OutOfMemory); queue.Submit(0, nullptr); device.PopErrorScope(ToMockDevicePopErrorScopeCallback, this); device.PopErrorScope(ToMockDevicePopErrorScopeCallback, this + 1); - EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(DAWN_ERROR_TYPE_NO_ERROR, _, this)).Times(1); - EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(DAWN_ERROR_TYPE_NO_ERROR, _, this + 1)) + EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(WGPUErrorType_NoError, _, this)).Times(1); + EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(WGPUErrorType_NoError, _, this + 1)) .Times(1); // Side effects of Queue::Submit only are seen after Tick() @@ -169,18 +167,18 @@ TEST_F(ErrorScopeValidationTest, CallbackAfterQueueSubmitNested) { // Test a callback that returns asynchronously followed by a synchronous one TEST_F(ErrorScopeValidationTest, AsynchronousThenSynchronous) { - dawn::Queue queue = device.CreateQueue(); + wgpu::Queue queue = device.CreateQueue(); - device.PushErrorScope(dawn::ErrorFilter::OutOfMemory); + device.PushErrorScope(wgpu::ErrorFilter::OutOfMemory); queue.Submit(0, nullptr); device.PopErrorScope(ToMockDevicePopErrorScopeCallback, this); - EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(DAWN_ERROR_TYPE_NO_ERROR, _, this + 1)) + EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(WGPUErrorType_NoError, _, this + 1)) .Times(1); - device.PushErrorScope(dawn::ErrorFilter::OutOfMemory); + device.PushErrorScope(wgpu::ErrorFilter::OutOfMemory); device.PopErrorScope(ToMockDevicePopErrorScopeCallback, this + 1); - EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(DAWN_ERROR_TYPE_NO_ERROR, _, this)).Times(1); + EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(WGPUErrorType_NoError, _, this)).Times(1); // Side effects of Queue::Submit only are seen after Tick() device.Tick(); @@ -188,12 +186,12 @@ TEST_F(ErrorScopeValidationTest, AsynchronousThenSynchronous) { // Test that if the device is destroyed before the callback occurs, it is called with UNKNOWN. TEST_F(ErrorScopeValidationTest, DeviceDestroyedBeforeCallback) { - dawn::Queue queue = device.CreateQueue(); + wgpu::Queue queue = device.CreateQueue(); - device.PushErrorScope(dawn::ErrorFilter::OutOfMemory); + device.PushErrorScope(wgpu::ErrorFilter::OutOfMemory); queue.Submit(0, nullptr); device.PopErrorScope(ToMockDevicePopErrorScopeCallback, this); - EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(DAWN_ERROR_TYPE_UNKNOWN, _, this)).Times(1); + EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(WGPUErrorType_Unknown, _, this)).Times(1); device = nullptr; } diff --git a/src/tests/unittests/validation/FenceValidationTests.cpp b/src/tests/unittests/validation/FenceValidationTests.cpp index 8cb1787b3a..4a24cf027d 100644 --- a/src/tests/unittests/validation/FenceValidationTests.cpp +++ b/src/tests/unittests/validation/FenceValidationTests.cpp @@ -20,23 +20,23 @@ using namespace testing; class MockFenceOnCompletionCallback { public: - MOCK_METHOD2(Call, void(DawnFenceCompletionStatus status, void* userdata)); + MOCK_METHOD2(Call, void(WGPUFenceCompletionStatus status, void* userdata)); }; struct FenceOnCompletionExpectation { - dawn::Fence fence; + wgpu::Fence fence; uint64_t value; - DawnFenceCompletionStatus status; + WGPUFenceCompletionStatus status; }; static std::unique_ptr mockFenceOnCompletionCallback; -static void ToMockFenceOnCompletionCallback(DawnFenceCompletionStatus status, void* userdata) { +static void ToMockFenceOnCompletionCallback(WGPUFenceCompletionStatus status, void* userdata) { mockFenceOnCompletionCallback->Call(status, userdata); } class FenceValidationTest : public ValidationTest { protected: - void TestOnCompletion(dawn::Fence fence, uint64_t value, DawnFenceCompletionStatus status) { + void TestOnCompletion(wgpu::Fence fence, uint64_t value, WGPUFenceCompletionStatus status) { FenceOnCompletionExpectation* expectation = new FenceOnCompletionExpectation; expectation->fence = fence; expectation->value = value; @@ -50,7 +50,7 @@ class FenceValidationTest : public ValidationTest { device.Tick(); } - dawn::Queue queue; + wgpu::Queue queue; private: void SetUp() override { @@ -72,7 +72,7 @@ class FenceValidationTest : public ValidationTest { TEST_F(FenceValidationTest, CreationSuccess) { // Success { - dawn::FenceDescriptor descriptor; + wgpu::FenceDescriptor descriptor; descriptor.initialValue = 0; queue.CreateFence(&descriptor); } @@ -81,9 +81,9 @@ TEST_F(FenceValidationTest, CreationSuccess) { TEST_F(FenceValidationTest, GetCompletedValue) { // Starts at initial value { - dawn::FenceDescriptor descriptor; + wgpu::FenceDescriptor descriptor; descriptor.initialValue = 1; - dawn::Fence fence = queue.CreateFence(&descriptor); + wgpu::Fence fence = queue.CreateFence(&descriptor); EXPECT_EQ(fence.GetCompletedValue(), 1u); } } @@ -91,35 +91,33 @@ TEST_F(FenceValidationTest, GetCompletedValue) { // Test that OnCompletion handlers are called immediately for // already completed fence values TEST_F(FenceValidationTest, OnCompletionImmediate) { - dawn::FenceDescriptor descriptor; + wgpu::FenceDescriptor descriptor; descriptor.initialValue = 1; - dawn::Fence fence = queue.CreateFence(&descriptor); + wgpu::Fence fence = queue.CreateFence(&descriptor); - EXPECT_CALL(*mockFenceOnCompletionCallback, - Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, this + 0)) + EXPECT_CALL(*mockFenceOnCompletionCallback, Call(WGPUFenceCompletionStatus_Success, this + 0)) .Times(1); fence.OnCompletion(0u, ToMockFenceOnCompletionCallback, this + 0); - EXPECT_CALL(*mockFenceOnCompletionCallback, - Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, this + 1)) + EXPECT_CALL(*mockFenceOnCompletionCallback, Call(WGPUFenceCompletionStatus_Success, this + 1)) .Times(1); fence.OnCompletion(1u, ToMockFenceOnCompletionCallback, this + 1); } // Test setting OnCompletion handlers for values > signaled value TEST_F(FenceValidationTest, OnCompletionLargerThanSignaled) { - dawn::FenceDescriptor descriptor; + wgpu::FenceDescriptor descriptor; descriptor.initialValue = 1; - dawn::Fence fence = queue.CreateFence(&descriptor); + wgpu::Fence fence = queue.CreateFence(&descriptor); // Cannot signal for values > signaled value - EXPECT_CALL(*mockFenceOnCompletionCallback, Call(DAWN_FENCE_COMPLETION_STATUS_ERROR, nullptr)) + EXPECT_CALL(*mockFenceOnCompletionCallback, Call(WGPUFenceCompletionStatus_Error, nullptr)) .Times(1); ASSERT_DEVICE_ERROR(fence.OnCompletion(2u, ToMockFenceOnCompletionCallback, nullptr)); // Can set handler after signaling queue.Signal(fence, 2); - EXPECT_CALL(*mockFenceOnCompletionCallback, Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, nullptr)) + EXPECT_CALL(*mockFenceOnCompletionCallback, Call(WGPUFenceCompletionStatus_Success, nullptr)) .Times(1); fence.OnCompletion(2u, ToMockFenceOnCompletionCallback, nullptr); @@ -127,14 +125,14 @@ TEST_F(FenceValidationTest, OnCompletionLargerThanSignaled) { } TEST_F(FenceValidationTest, GetCompletedValueInsideCallback) { - dawn::FenceDescriptor descriptor; + wgpu::FenceDescriptor descriptor; descriptor.initialValue = 1; - dawn::Fence fence = queue.CreateFence(&descriptor); + wgpu::Fence fence = queue.CreateFence(&descriptor); queue.Signal(fence, 3); fence.OnCompletion(2u, ToMockFenceOnCompletionCallback, nullptr); - EXPECT_CALL(*mockFenceOnCompletionCallback, Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, nullptr)) - .WillOnce(Invoke([&](DawnFenceCompletionStatus status, void* userdata) { + EXPECT_CALL(*mockFenceOnCompletionCallback, Call(WGPUFenceCompletionStatus_Success, nullptr)) + .WillOnce(Invoke([&](WGPUFenceCompletionStatus status, void* userdata) { EXPECT_EQ(fence.GetCompletedValue(), 3u); })); @@ -142,13 +140,13 @@ TEST_F(FenceValidationTest, GetCompletedValueInsideCallback) { } TEST_F(FenceValidationTest, GetCompletedValueAfterCallback) { - dawn::FenceDescriptor descriptor; + wgpu::FenceDescriptor descriptor; descriptor.initialValue = 1; - dawn::Fence fence = queue.CreateFence(&descriptor); + wgpu::Fence fence = queue.CreateFence(&descriptor); queue.Signal(fence, 2); fence.OnCompletion(2u, ToMockFenceOnCompletionCallback, nullptr); - EXPECT_CALL(*mockFenceOnCompletionCallback, Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, nullptr)) + EXPECT_CALL(*mockFenceOnCompletionCallback, Call(WGPUFenceCompletionStatus_Success, nullptr)) .Times(1); Flush(); @@ -156,9 +154,9 @@ TEST_F(FenceValidationTest, GetCompletedValueAfterCallback) { } TEST_F(FenceValidationTest, SignalError) { - dawn::FenceDescriptor descriptor; + wgpu::FenceDescriptor descriptor; descriptor.initialValue = 1; - dawn::Fence fence = queue.CreateFence(&descriptor); + wgpu::Fence fence = queue.CreateFence(&descriptor); // value < fence signaled value ASSERT_DEVICE_ERROR(queue.Signal(fence, 0)); @@ -168,9 +166,9 @@ TEST_F(FenceValidationTest, SignalError) { } TEST_F(FenceValidationTest, SignalSuccess) { - dawn::FenceDescriptor descriptor; + wgpu::FenceDescriptor descriptor; descriptor.initialValue = 1; - dawn::Fence fence = queue.CreateFence(&descriptor); + wgpu::Fence fence = queue.CreateFence(&descriptor); // Success queue.Signal(fence, 2); @@ -185,22 +183,22 @@ TEST_F(FenceValidationTest, SignalSuccess) { // Test it is invalid to signal a fence on a different queue than it was created on TEST_F(FenceValidationTest, SignalWrongQueue) { - dawn::Queue queue2 = device.CreateQueue(); + wgpu::Queue queue2 = device.CreateQueue(); - dawn::FenceDescriptor descriptor; + wgpu::FenceDescriptor descriptor; descriptor.initialValue = 1; - dawn::Fence fence = queue.CreateFence(&descriptor); + wgpu::Fence fence = queue.CreateFence(&descriptor); ASSERT_DEVICE_ERROR(queue2.Signal(fence, 2)); } // Test that signaling a fence on a wrong queue does not update fence signaled value TEST_F(FenceValidationTest, SignalWrongQueueDoesNotUpdateValue) { - dawn::Queue queue2 = device.CreateQueue(); + wgpu::Queue queue2 = device.CreateQueue(); - dawn::FenceDescriptor descriptor; + wgpu::FenceDescriptor descriptor; descriptor.initialValue = 1; - dawn::Fence fence = queue.CreateFence(&descriptor); + wgpu::Fence fence = queue.CreateFence(&descriptor); ASSERT_DEVICE_ERROR(queue2.Signal(fence, 2)); diff --git a/src/tests/unittests/validation/QueueSubmitValidationTests.cpp b/src/tests/unittests/validation/QueueSubmitValidationTests.cpp index 0f2a2e881d..4c030141f6 100644 --- a/src/tests/unittests/validation/QueueSubmitValidationTests.cpp +++ b/src/tests/unittests/validation/QueueSubmitValidationTests.cpp @@ -21,7 +21,7 @@ namespace { class QueueSubmitValidationTest : public ValidationTest { }; -static void StoreTrueMapWriteCallback(DawnBufferMapAsyncStatus status, +static void StoreTrueMapWriteCallback(WGPUBufferMapAsyncStatus status, void*, uint64_t, void* userdata) { @@ -31,24 +31,24 @@ static void StoreTrueMapWriteCallback(DawnBufferMapAsyncStatus status, // Test submitting with a mapped buffer is disallowed TEST_F(QueueSubmitValidationTest, SubmitWithMappedBuffer) { // Create a map-write buffer. - dawn::BufferDescriptor descriptor; - descriptor.usage = dawn::BufferUsage::MapWrite | dawn::BufferUsage::CopySrc; + wgpu::BufferDescriptor descriptor; + descriptor.usage = wgpu::BufferUsage::MapWrite | wgpu::BufferUsage::CopySrc; descriptor.size = 4; - dawn::Buffer buffer = device.CreateBuffer(&descriptor); + wgpu::Buffer buffer = device.CreateBuffer(&descriptor); // Create a fake copy destination buffer - descriptor.usage = dawn::BufferUsage::CopyDst; - dawn::Buffer targetBuffer = device.CreateBuffer(&descriptor); + descriptor.usage = wgpu::BufferUsage::CopyDst; + wgpu::Buffer targetBuffer = device.CreateBuffer(&descriptor); // Create a command buffer that reads from the mappable buffer. - dawn::CommandBuffer commands; + wgpu::CommandBuffer commands; { - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); encoder.CopyBufferToBuffer(buffer, 0, targetBuffer, 0, 4); commands = encoder.Finish(); } - dawn::Queue queue = device.CreateQueue(); + wgpu::Queue queue = device.CreateQueue(); // Submitting when the buffer has never been mapped should succeed queue.Submit(1, &commands); diff --git a/src/tests/unittests/validation/RenderBundleValidationTests.cpp b/src/tests/unittests/validation/RenderBundleValidationTests.cpp index 3c962700f8..b2dbb34629 100644 --- a/src/tests/unittests/validation/RenderBundleValidationTests.cpp +++ b/src/tests/unittests/validation/RenderBundleValidationTests.cpp @@ -47,16 +47,16 @@ namespace { void main() { })"); - dawn::BindGroupLayout bgls[] = { + wgpu::BindGroupLayout bgls[] = { utils::MakeBindGroupLayout( - device, {{0, dawn::ShaderStage::Vertex, dawn::BindingType::UniformBuffer}}), + device, {{0, wgpu::ShaderStage::Vertex, wgpu::BindingType::UniformBuffer}}), utils::MakeBindGroupLayout( device, { - {0, dawn::ShaderStage::Fragment, dawn::BindingType::UniformBuffer}, - {1, dawn::ShaderStage::Fragment, dawn::BindingType::StorageBuffer}, + {0, wgpu::ShaderStage::Fragment, wgpu::BindingType::UniformBuffer}, + {1, wgpu::ShaderStage::Fragment, wgpu::BindingType::StorageBuffer}, })}; - dawn::PipelineLayoutDescriptor pipelineLayoutDesc = {}; + wgpu::PipelineLayoutDescriptor pipelineLayoutDesc = {}; pipelineLayoutDesc.bindGroupLayoutCount = 2; pipelineLayoutDesc.bindGroupLayouts = bgls; @@ -67,22 +67,22 @@ namespace { pipeline = device.CreateRenderPipeline(&descriptor); float data[4]; - dawn::Buffer buffer = utils::CreateBufferFromData(device, data, 4 * sizeof(float), - dawn::BufferUsage::Uniform); + wgpu::Buffer buffer = utils::CreateBufferFromData(device, data, 4 * sizeof(float), + wgpu::BufferUsage::Uniform); constexpr static float kVertices[] = {-1.f, 1.f, 1.f, -1.f, -1.f, 1.f}; vertexBuffer = utils::CreateBufferFromData(device, kVertices, sizeof(kVertices), - dawn::BufferUsage::Vertex); + wgpu::BufferUsage::Vertex); // Dummy storage buffer. - dawn::Buffer storageBuffer = utils::CreateBufferFromData( - device, kVertices, sizeof(kVertices), dawn::BufferUsage::Storage); + wgpu::Buffer storageBuffer = utils::CreateBufferFromData( + device, kVertices, sizeof(kVertices), wgpu::BufferUsage::Storage); // Vertex buffer with storage usage for testing read+write error usage. vertexStorageBuffer = utils::CreateBufferFromData(device, kVertices, sizeof(kVertices), - dawn::BufferUsage::Vertex | dawn::BufferUsage::Storage); + wgpu::BufferUsage::Vertex | wgpu::BufferUsage::Storage); bg0 = utils::MakeBindGroup(device, bgls[0], {{0, buffer, 0, 4 * sizeof(float)}}); bg1 = utils::MakeBindGroup( @@ -101,19 +101,19 @@ namespace { descriptor->cVertexInput.bufferCount = 1; descriptor->cVertexInput.cBuffers[0].stride = 2 * sizeof(float); descriptor->cVertexInput.cBuffers[0].attributeCount = 1; - descriptor->cVertexInput.cAttributes[0].format = dawn::VertexFormat::Float2; + descriptor->cVertexInput.cAttributes[0].format = wgpu::VertexFormat::Float2; descriptor->cVertexInput.cAttributes[0].shaderLocation = 0; } - dawn::ShaderModule vsModule; - dawn::ShaderModule fsModule; - dawn::PipelineLayout pipelineLayout; - dawn::RenderPipeline pipeline; - dawn::Buffer vertexBuffer; - dawn::Buffer vertexStorageBuffer; - dawn::BindGroup bg0; - dawn::BindGroup bg1; - dawn::BindGroup bg1Vertex; + wgpu::ShaderModule vsModule; + wgpu::ShaderModule fsModule; + wgpu::PipelineLayout pipelineLayout; + wgpu::RenderPipeline pipeline; + wgpu::Buffer vertexBuffer; + wgpu::Buffer vertexStorageBuffer; + wgpu::BindGroup bg0; + wgpu::BindGroup bg1; + wgpu::BindGroup bg1Vertex; }; } // anonymous namespace @@ -126,11 +126,11 @@ TEST_F(RenderBundleValidationTest, Empty) { desc.colorFormatsCount = 1; desc.cColorFormats[0] = renderPass.attachmentFormat; - dawn::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); - dawn::RenderBundle renderBundle = renderBundleEncoder.Finish(); + wgpu::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); + wgpu::RenderBundle renderBundle = renderBundleEncoder.Finish(); - dawn::CommandEncoder commandEncoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); pass.ExecuteBundles(1, &renderBundle); pass.EndPass(); commandEncoder.Finish(); @@ -140,8 +140,8 @@ TEST_F(RenderBundleValidationTest, Empty) { TEST_F(RenderBundleValidationTest, ZeroBundles) { DummyRenderPass renderPass(device); - dawn::CommandEncoder commandEncoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); pass.ExecuteBundles(0, nullptr); pass.EndPass(); commandEncoder.Finish(); @@ -155,16 +155,16 @@ TEST_F(RenderBundleValidationTest, SimpleSuccess) { desc.colorFormatsCount = 1; desc.cColorFormats[0] = renderPass.attachmentFormat; - dawn::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); + wgpu::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); renderBundleEncoder.SetPipeline(pipeline); renderBundleEncoder.SetBindGroup(0, bg0); renderBundleEncoder.SetBindGroup(1, bg1); renderBundleEncoder.SetVertexBuffer(0, vertexBuffer); renderBundleEncoder.Draw(3, 0, 0, 0); - dawn::RenderBundle renderBundle = renderBundleEncoder.Finish(); + wgpu::RenderBundle renderBundle = renderBundleEncoder.Finish(); - dawn::CommandEncoder commandEncoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); pass.ExecuteBundles(1, &renderBundle); pass.EndPass(); commandEncoder.Finish(); @@ -180,7 +180,7 @@ TEST_F(RenderBundleValidationTest, DebugGroups) { // Test a single debug group works. { - dawn::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); + wgpu::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); renderBundleEncoder.PushDebugGroup("group"); renderBundleEncoder.PopDebugGroup(); renderBundleEncoder.Finish(); @@ -188,7 +188,7 @@ TEST_F(RenderBundleValidationTest, DebugGroups) { // Test nested debug groups work. { - dawn::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); + wgpu::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); renderBundleEncoder.PushDebugGroup("group"); renderBundleEncoder.PushDebugGroup("group2"); renderBundleEncoder.PopDebugGroup(); @@ -198,14 +198,14 @@ TEST_F(RenderBundleValidationTest, DebugGroups) { // Test popping when no group is pushed is invalid. { - dawn::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); + wgpu::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); renderBundleEncoder.PopDebugGroup(); ASSERT_DEVICE_ERROR(renderBundleEncoder.Finish()); } // Test popping too many times is invalid. { - dawn::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); + wgpu::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); renderBundleEncoder.PushDebugGroup("group"); renderBundleEncoder.PopDebugGroup(); renderBundleEncoder.PopDebugGroup(); @@ -214,14 +214,14 @@ TEST_F(RenderBundleValidationTest, DebugGroups) { // Test that a single debug group must be popped. { - dawn::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); + wgpu::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); renderBundleEncoder.PushDebugGroup("group"); ASSERT_DEVICE_ERROR(renderBundleEncoder.Finish()); } // Test that all debug groups must be popped. { - dawn::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); + wgpu::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); renderBundleEncoder.PushDebugGroup("group"); renderBundleEncoder.PushDebugGroup("group2"); renderBundleEncoder.PopDebugGroup(); @@ -239,9 +239,9 @@ TEST_F(RenderBundleValidationTest, StateInheritance) { // Render bundle does not inherit pipeline so the draw is invalid. { - dawn::CommandEncoder commandEncoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); - dawn::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); + wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); + wgpu::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); pass.SetPipeline(pipeline); @@ -249,7 +249,7 @@ TEST_F(RenderBundleValidationTest, StateInheritance) { renderBundleEncoder.SetBindGroup(1, bg1); renderBundleEncoder.SetVertexBuffer(0, vertexBuffer); renderBundleEncoder.Draw(3, 0, 0, 0); - ASSERT_DEVICE_ERROR(dawn::RenderBundle renderBundle = renderBundleEncoder.Finish()); + ASSERT_DEVICE_ERROR(wgpu::RenderBundle renderBundle = renderBundleEncoder.Finish()); pass.ExecuteBundles(1, &renderBundle); pass.EndPass(); @@ -258,9 +258,9 @@ TEST_F(RenderBundleValidationTest, StateInheritance) { // Render bundle does not inherit bind groups so the draw is invalid. { - dawn::CommandEncoder commandEncoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); - dawn::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); + wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); + wgpu::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); pass.SetBindGroup(0, bg0); pass.SetBindGroup(1, bg1); @@ -268,7 +268,7 @@ TEST_F(RenderBundleValidationTest, StateInheritance) { renderBundleEncoder.SetPipeline(pipeline); renderBundleEncoder.SetVertexBuffer(0, vertexBuffer); renderBundleEncoder.Draw(3, 0, 0, 0); - ASSERT_DEVICE_ERROR(dawn::RenderBundle renderBundle = renderBundleEncoder.Finish()); + ASSERT_DEVICE_ERROR(wgpu::RenderBundle renderBundle = renderBundleEncoder.Finish()); pass.ExecuteBundles(1, &renderBundle); pass.EndPass(); @@ -277,9 +277,9 @@ TEST_F(RenderBundleValidationTest, StateInheritance) { // Render bundle does not inherit pipeline and bind groups so the draw is invalid. { - dawn::CommandEncoder commandEncoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); - dawn::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); + wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); + wgpu::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); pass.SetPipeline(pipeline); pass.SetBindGroup(0, bg0); @@ -287,7 +287,7 @@ TEST_F(RenderBundleValidationTest, StateInheritance) { renderBundleEncoder.SetVertexBuffer(0, vertexBuffer); renderBundleEncoder.Draw(3, 0, 0, 0); - ASSERT_DEVICE_ERROR(dawn::RenderBundle renderBundle = renderBundleEncoder.Finish()); + ASSERT_DEVICE_ERROR(wgpu::RenderBundle renderBundle = renderBundleEncoder.Finish()); pass.ExecuteBundles(1, &renderBundle); pass.EndPass(); @@ -296,9 +296,9 @@ TEST_F(RenderBundleValidationTest, StateInheritance) { // Render bundle does not inherit buffers so the draw is invalid. { - dawn::CommandEncoder commandEncoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); - dawn::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); + wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); + wgpu::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); pass.SetVertexBuffer(0, vertexBuffer); @@ -306,7 +306,7 @@ TEST_F(RenderBundleValidationTest, StateInheritance) { renderBundleEncoder.SetBindGroup(0, bg0); renderBundleEncoder.SetBindGroup(1, bg1); renderBundleEncoder.Draw(3, 0, 0, 0); - ASSERT_DEVICE_ERROR(dawn::RenderBundle renderBundle = renderBundleEncoder.Finish()); + ASSERT_DEVICE_ERROR(wgpu::RenderBundle renderBundle = renderBundleEncoder.Finish()); pass.ExecuteBundles(1, &renderBundle); pass.EndPass(); @@ -324,12 +324,12 @@ TEST_F(RenderBundleValidationTest, StatePersistence) { // Render bundle does not persist pipeline so the draw is invalid. { - dawn::CommandEncoder commandEncoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); - dawn::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); + wgpu::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); renderBundleEncoder.SetPipeline(pipeline); - dawn::RenderBundle renderBundle = renderBundleEncoder.Finish(); + wgpu::RenderBundle renderBundle = renderBundleEncoder.Finish(); pass.ExecuteBundles(1, &renderBundle); pass.SetBindGroup(0, bg0); @@ -343,13 +343,13 @@ TEST_F(RenderBundleValidationTest, StatePersistence) { // Render bundle does not persist bind groups so the draw is invalid. { - dawn::CommandEncoder commandEncoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); - dawn::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); + wgpu::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); renderBundleEncoder.SetBindGroup(0, bg0); renderBundleEncoder.SetBindGroup(1, bg1); - dawn::RenderBundle renderBundle = renderBundleEncoder.Finish(); + wgpu::RenderBundle renderBundle = renderBundleEncoder.Finish(); pass.ExecuteBundles(1, &renderBundle); pass.SetPipeline(pipeline); @@ -362,14 +362,14 @@ TEST_F(RenderBundleValidationTest, StatePersistence) { // Render bundle does not persist pipeline and bind groups so the draw is invalid. { - dawn::CommandEncoder commandEncoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); - dawn::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); + wgpu::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); renderBundleEncoder.SetPipeline(pipeline); renderBundleEncoder.SetBindGroup(0, bg0); renderBundleEncoder.SetBindGroup(1, bg1); - dawn::RenderBundle renderBundle = renderBundleEncoder.Finish(); + wgpu::RenderBundle renderBundle = renderBundleEncoder.Finish(); pass.ExecuteBundles(1, &renderBundle); pass.SetVertexBuffer(0, vertexBuffer); @@ -381,12 +381,12 @@ TEST_F(RenderBundleValidationTest, StatePersistence) { // Render bundle does not persist buffers so the draw is invalid. { - dawn::CommandEncoder commandEncoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); - dawn::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); + wgpu::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); renderBundleEncoder.SetVertexBuffer(0, vertexBuffer); - dawn::RenderBundle renderBundle = renderBundleEncoder.Finish(); + wgpu::RenderBundle renderBundle = renderBundleEncoder.Finish(); pass.ExecuteBundles(1, &renderBundle); pass.SetPipeline(pipeline); @@ -407,13 +407,13 @@ TEST_F(RenderBundleValidationTest, ClearsState) { desc.colorFormatsCount = 1; desc.cColorFormats[0] = renderPass.attachmentFormat; - dawn::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); - dawn::RenderBundle renderBundle = renderBundleEncoder.Finish(); + wgpu::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); + wgpu::RenderBundle renderBundle = renderBundleEncoder.Finish(); // Render bundle clears pipeline so the draw is invalid. { - dawn::CommandEncoder commandEncoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); pass.SetPipeline(pipeline); pass.ExecuteBundles(1, &renderBundle); @@ -428,8 +428,8 @@ TEST_F(RenderBundleValidationTest, ClearsState) { // Render bundle clears bind groups so the draw is invalid. { - dawn::CommandEncoder commandEncoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); pass.SetBindGroup(0, bg0); pass.SetBindGroup(1, bg1); @@ -444,8 +444,8 @@ TEST_F(RenderBundleValidationTest, ClearsState) { // Render bundle clears pipeline and bind groups so the draw is invalid. { - dawn::CommandEncoder commandEncoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); pass.SetPipeline(pipeline); pass.SetBindGroup(0, bg0); @@ -460,8 +460,8 @@ TEST_F(RenderBundleValidationTest, ClearsState) { // Render bundle clears buffers so the draw is invalid. { - dawn::CommandEncoder commandEncoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); pass.SetVertexBuffer(0, vertexBuffer); pass.ExecuteBundles(1, &renderBundle); @@ -476,8 +476,8 @@ TEST_F(RenderBundleValidationTest, ClearsState) { // Test executing 0 bundles does not clear command buffer state. { - dawn::CommandEncoder commandEncoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); pass.SetPipeline(pipeline); pass.SetBindGroup(0, bg0); @@ -499,9 +499,9 @@ TEST_F(RenderBundleValidationTest, MultipleBundles) { desc.colorFormatsCount = 1; desc.cColorFormats[0] = renderPass.attachmentFormat; - dawn::RenderBundle renderBundles[2] = {}; + wgpu::RenderBundle renderBundles[2] = {}; - dawn::RenderBundleEncoder renderBundleEncoder0 = device.CreateRenderBundleEncoder(&desc); + wgpu::RenderBundleEncoder renderBundleEncoder0 = device.CreateRenderBundleEncoder(&desc); renderBundleEncoder0.SetPipeline(pipeline); renderBundleEncoder0.SetBindGroup(0, bg0); renderBundleEncoder0.SetBindGroup(1, bg1); @@ -509,7 +509,7 @@ TEST_F(RenderBundleValidationTest, MultipleBundles) { renderBundleEncoder0.Draw(3, 1, 0, 0); renderBundles[0] = renderBundleEncoder0.Finish(); - dawn::RenderBundleEncoder renderBundleEncoder1 = device.CreateRenderBundleEncoder(&desc); + wgpu::RenderBundleEncoder renderBundleEncoder1 = device.CreateRenderBundleEncoder(&desc); renderBundleEncoder1.SetPipeline(pipeline); renderBundleEncoder1.SetBindGroup(0, bg0); renderBundleEncoder1.SetBindGroup(1, bg1); @@ -517,8 +517,8 @@ TEST_F(RenderBundleValidationTest, MultipleBundles) { renderBundleEncoder1.Draw(3, 1, 0, 0); renderBundles[1] = renderBundleEncoder1.Finish(); - dawn::CommandEncoder commandEncoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); pass.ExecuteBundles(2, renderBundles); pass.EndPass(); commandEncoder.Finish(); @@ -532,16 +532,16 @@ TEST_F(RenderBundleValidationTest, ExecuteMultipleTimes) { desc.colorFormatsCount = 1; desc.cColorFormats[0] = renderPass.attachmentFormat; - dawn::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); + wgpu::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); renderBundleEncoder.SetPipeline(pipeline); renderBundleEncoder.SetBindGroup(0, bg0); renderBundleEncoder.SetBindGroup(1, bg1); renderBundleEncoder.SetVertexBuffer(0, vertexBuffer); renderBundleEncoder.Draw(3, 1, 0, 0); - dawn::RenderBundle renderBundle = renderBundleEncoder.Finish(); + wgpu::RenderBundle renderBundle = renderBundleEncoder.Finish(); - dawn::CommandEncoder commandEncoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); pass.ExecuteBundles(1, &renderBundle); pass.ExecuteBundles(1, &renderBundle); pass.ExecuteBundles(1, &renderBundle); @@ -553,9 +553,9 @@ TEST_F(RenderBundleValidationTest, ExecuteMultipleTimes) { TEST_F(RenderBundleValidationTest, FinishTwice) { utils::ComboRenderBundleEncoderDescriptor desc = {}; desc.colorFormatsCount = 1; - desc.cColorFormats[0] = dawn::TextureFormat::RGBA8Uint; + desc.cColorFormats[0] = wgpu::TextureFormat::RGBA8Uint; - dawn::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); + wgpu::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); renderBundleEncoder.Finish(); ASSERT_DEVICE_ERROR(renderBundleEncoder.Finish()); } @@ -572,14 +572,14 @@ TEST_F(RenderBundleValidationTest, RequiresAtLeastOneTextureFormat) { { utils::ComboRenderBundleEncoderDescriptor desc = {}; desc.colorFormatsCount = 1; - desc.cColorFormats[0] = dawn::TextureFormat::RGBA8Uint; + desc.cColorFormats[0] = wgpu::TextureFormat::RGBA8Uint; device.CreateRenderBundleEncoder(&desc); } // Test success with a depth stencil format. { utils::ComboRenderBundleEncoderDescriptor desc = {}; - desc.depthStencilFormat = dawn::TextureFormat::Depth24PlusStencil8; + desc.depthStencilFormat = wgpu::TextureFormat::Depth24PlusStencil8; device.CreateRenderBundleEncoder(&desc); } } @@ -588,14 +588,14 @@ TEST_F(RenderBundleValidationTest, RequiresAtLeastOneTextureFormat) { TEST_F(RenderBundleValidationTest, ColorFormatUndefined) { utils::ComboRenderBundleEncoderDescriptor desc = {}; desc.colorFormatsCount = 1; - desc.cColorFormats[0] = dawn::TextureFormat::Undefined; + desc.cColorFormats[0] = wgpu::TextureFormat::Undefined; ASSERT_DEVICE_ERROR(device.CreateRenderBundleEncoder(&desc)); } // Test that the render bundle depth stencil format cannot be set to undefined. TEST_F(RenderBundleValidationTest, DepthStencilFormatUndefined) { utils::ComboRenderBundleEncoderDescriptor desc = {}; - desc.depthStencilFormat = dawn::TextureFormat::Undefined; + desc.depthStencilFormat = wgpu::TextureFormat::Undefined; ASSERT_DEVICE_ERROR(device.CreateRenderBundleEncoder(&desc)); } @@ -607,12 +607,12 @@ TEST_F(RenderBundleValidationTest, UsageTracking) { desc.colorFormatsCount = 1; desc.cColorFormats[0] = renderPass.attachmentFormat; - dawn::RenderBundle renderBundle0; - dawn::RenderBundle renderBundle1; + wgpu::RenderBundle renderBundle0; + wgpu::RenderBundle renderBundle1; // First base case is successful. |bg1Vertex| does not reference |vertexBuffer|. { - dawn::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); + wgpu::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); renderBundleEncoder.SetPipeline(pipeline); renderBundleEncoder.SetBindGroup(0, bg0); renderBundleEncoder.SetBindGroup(1, bg1Vertex); @@ -623,7 +623,7 @@ TEST_F(RenderBundleValidationTest, UsageTracking) { // Second base case is successful. |bg1| does not reference |vertexStorageBuffer| { - dawn::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); + wgpu::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); renderBundleEncoder.SetPipeline(pipeline); renderBundleEncoder.SetBindGroup(0, bg0); renderBundleEncoder.SetBindGroup(1, bg1); @@ -635,7 +635,7 @@ TEST_F(RenderBundleValidationTest, UsageTracking) { // Test that a render bundle which sets a buffer as both vertex and storage is invalid. // |bg1Vertex| references |vertexStorageBuffer| { - dawn::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); + wgpu::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&desc); renderBundleEncoder.SetPipeline(pipeline); renderBundleEncoder.SetBindGroup(0, bg0); renderBundleEncoder.SetBindGroup(1, bg1Vertex); @@ -649,8 +649,8 @@ TEST_F(RenderBundleValidationTest, UsageTracking) { // renderBundle0 uses |vertexStorageBuffer| as a storage buffer. // renderBundle1 uses |vertexStorageBuffer| as a vertex buffer. { - dawn::CommandEncoder commandEncoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); pass.ExecuteBundles(1, &renderBundle0); pass.ExecuteBundles(1, &renderBundle1); pass.EndPass(); @@ -661,8 +661,8 @@ TEST_F(RenderBundleValidationTest, UsageTracking) { // The render pass uses |vertexStorageBuffer| as a storage buffer. // renderBundle1 uses |vertexStorageBuffer| as a vertex buffer. { - dawn::CommandEncoder commandEncoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); pass.SetPipeline(pipeline); pass.SetBindGroup(0, bg0); @@ -679,8 +679,8 @@ TEST_F(RenderBundleValidationTest, UsageTracking) { // renderBundle0 uses |vertexStorageBuffer| as a storage buffer. // The render pass uses |vertexStorageBuffer| as a vertex buffer. { - dawn::CommandEncoder commandEncoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); pass.ExecuteBundles(1, &renderBundle0); @@ -699,16 +699,16 @@ TEST_F(RenderBundleValidationTest, UsageTracking) { TEST_F(RenderBundleValidationTest, PipelineColorFormatMismatch) { utils::ComboRenderBundleEncoderDescriptor renderBundleDesc = {}; renderBundleDesc.colorFormatsCount = 3; - renderBundleDesc.cColorFormats[0] = dawn::TextureFormat::RGBA8Unorm; - renderBundleDesc.cColorFormats[1] = dawn::TextureFormat::RG16Float; - renderBundleDesc.cColorFormats[2] = dawn::TextureFormat::R16Sint; + renderBundleDesc.cColorFormats[0] = wgpu::TextureFormat::RGBA8Unorm; + renderBundleDesc.cColorFormats[1] = wgpu::TextureFormat::RG16Float; + renderBundleDesc.cColorFormats[2] = wgpu::TextureFormat::R16Sint; auto SetupRenderPipelineDescForTest = [this](utils::ComboRenderPipelineDescriptor* desc) { InitializeRenderPipelineDescriptor(desc); desc->colorStateCount = 3; - desc->cColorStates[0].format = dawn::TextureFormat::RGBA8Unorm; - desc->cColorStates[1].format = dawn::TextureFormat::RG16Float; - desc->cColorStates[2].format = dawn::TextureFormat::R16Sint; + desc->cColorStates[0].format = wgpu::TextureFormat::RGBA8Unorm; + desc->cColorStates[1].format = wgpu::TextureFormat::RG16Float; + desc->cColorStates[2].format = wgpu::TextureFormat::R16Sint; }; // Test the success case. @@ -716,9 +716,9 @@ TEST_F(RenderBundleValidationTest, PipelineColorFormatMismatch) { utils::ComboRenderPipelineDescriptor desc(device); SetupRenderPipelineDescForTest(&desc); - dawn::RenderBundleEncoder renderBundleEncoder = + wgpu::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&renderBundleDesc); - dawn::RenderPipeline pipeline = device.CreateRenderPipeline(&desc); + wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&desc); renderBundleEncoder.SetPipeline(pipeline); renderBundleEncoder.Finish(); } @@ -727,11 +727,11 @@ TEST_F(RenderBundleValidationTest, PipelineColorFormatMismatch) { { utils::ComboRenderPipelineDescriptor desc(device); SetupRenderPipelineDescForTest(&desc); - desc.cColorStates[1].format = dawn::TextureFormat::RGBA8Unorm; + desc.cColorStates[1].format = wgpu::TextureFormat::RGBA8Unorm; - dawn::RenderBundleEncoder renderBundleEncoder = + wgpu::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&renderBundleDesc); - dawn::RenderPipeline pipeline = device.CreateRenderPipeline(&desc); + wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&desc); renderBundleEncoder.SetPipeline(pipeline); ASSERT_DEVICE_ERROR(renderBundleEncoder.Finish()); } @@ -742,9 +742,9 @@ TEST_F(RenderBundleValidationTest, PipelineColorFormatMismatch) { SetupRenderPipelineDescForTest(&desc); desc.colorStateCount = 2; - dawn::RenderBundleEncoder renderBundleEncoder = + wgpu::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&renderBundleDesc); - dawn::RenderPipeline pipeline = device.CreateRenderPipeline(&desc); + wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&desc); renderBundleEncoder.SetPipeline(pipeline); ASSERT_DEVICE_ERROR(renderBundleEncoder.Finish()); } @@ -754,15 +754,15 @@ TEST_F(RenderBundleValidationTest, PipelineColorFormatMismatch) { TEST_F(RenderBundleValidationTest, PipelineDepthStencilFormatMismatch) { utils::ComboRenderBundleEncoderDescriptor renderBundleDesc = {}; renderBundleDesc.colorFormatsCount = 1; - renderBundleDesc.cColorFormats[0] = dawn::TextureFormat::RGBA8Unorm; - renderBundleDesc.depthStencilFormat = dawn::TextureFormat::Depth24PlusStencil8; + renderBundleDesc.cColorFormats[0] = wgpu::TextureFormat::RGBA8Unorm; + renderBundleDesc.depthStencilFormat = wgpu::TextureFormat::Depth24PlusStencil8; auto SetupRenderPipelineDescForTest = [this](utils::ComboRenderPipelineDescriptor* desc) { InitializeRenderPipelineDescriptor(desc); desc->colorStateCount = 1; - desc->cColorStates[0].format = dawn::TextureFormat::RGBA8Unorm; + desc->cColorStates[0].format = wgpu::TextureFormat::RGBA8Unorm; desc->depthStencilState = &desc->cDepthStencilState; - desc->cDepthStencilState.format = dawn::TextureFormat::Depth24PlusStencil8; + desc->cDepthStencilState.format = wgpu::TextureFormat::Depth24PlusStencil8; }; // Test the success case. @@ -770,9 +770,9 @@ TEST_F(RenderBundleValidationTest, PipelineDepthStencilFormatMismatch) { utils::ComboRenderPipelineDescriptor desc(device); SetupRenderPipelineDescForTest(&desc); - dawn::RenderBundleEncoder renderBundleEncoder = + wgpu::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&renderBundleDesc); - dawn::RenderPipeline pipeline = device.CreateRenderPipeline(&desc); + wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&desc); renderBundleEncoder.SetPipeline(pipeline); renderBundleEncoder.Finish(); } @@ -781,11 +781,11 @@ TEST_F(RenderBundleValidationTest, PipelineDepthStencilFormatMismatch) { { utils::ComboRenderPipelineDescriptor desc(device); SetupRenderPipelineDescForTest(&desc); - desc.cDepthStencilState.format = dawn::TextureFormat::Depth24Plus; + desc.cDepthStencilState.format = wgpu::TextureFormat::Depth24Plus; - dawn::RenderBundleEncoder renderBundleEncoder = + wgpu::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&renderBundleDesc); - dawn::RenderPipeline pipeline = device.CreateRenderPipeline(&desc); + wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&desc); renderBundleEncoder.SetPipeline(pipeline); ASSERT_DEVICE_ERROR(renderBundleEncoder.Finish()); } @@ -796,9 +796,9 @@ TEST_F(RenderBundleValidationTest, PipelineDepthStencilFormatMismatch) { SetupRenderPipelineDescForTest(&desc); desc.depthStencilState = nullptr; - dawn::RenderBundleEncoder renderBundleEncoder = + wgpu::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&renderBundleDesc); - dawn::RenderPipeline pipeline = device.CreateRenderPipeline(&desc); + wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&desc); renderBundleEncoder.SetPipeline(pipeline); ASSERT_DEVICE_ERROR(renderBundleEncoder.Finish()); } @@ -808,20 +808,20 @@ TEST_F(RenderBundleValidationTest, PipelineDepthStencilFormatMismatch) { TEST_F(RenderBundleValidationTest, PipelineSampleCountMismatch) { utils::ComboRenderBundleEncoderDescriptor renderBundleDesc = {}; renderBundleDesc.colorFormatsCount = 1; - renderBundleDesc.cColorFormats[0] = dawn::TextureFormat::RGBA8Unorm; + renderBundleDesc.cColorFormats[0] = wgpu::TextureFormat::RGBA8Unorm; renderBundleDesc.sampleCount = 4; utils::ComboRenderPipelineDescriptor renderPipelineDesc(device); InitializeRenderPipelineDescriptor(&renderPipelineDesc); renderPipelineDesc.colorStateCount = 1; - renderPipelineDesc.cColorStates[0].format = dawn::TextureFormat::RGBA8Unorm; + renderPipelineDesc.cColorStates[0].format = wgpu::TextureFormat::RGBA8Unorm; renderPipelineDesc.sampleCount = 4; // Test the success case. { - dawn::RenderBundleEncoder renderBundleEncoder = + wgpu::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&renderBundleDesc); - dawn::RenderPipeline pipeline = device.CreateRenderPipeline(&renderPipelineDesc); + wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&renderPipelineDesc); renderBundleEncoder.SetPipeline(pipeline); renderBundleEncoder.Finish(); } @@ -830,9 +830,9 @@ TEST_F(RenderBundleValidationTest, PipelineSampleCountMismatch) { { renderPipelineDesc.sampleCount = 1; - dawn::RenderBundleEncoder renderBundleEncoder = + wgpu::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&renderBundleDesc); - dawn::RenderPipeline pipeline = device.CreateRenderPipeline(&renderPipelineDesc); + wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&renderPipelineDesc); renderBundleEncoder.SetPipeline(pipeline); ASSERT_DEVICE_ERROR(renderBundleEncoder.Finish()); } @@ -842,26 +842,26 @@ TEST_F(RenderBundleValidationTest, PipelineSampleCountMismatch) { TEST_F(RenderBundleValidationTest, RenderPassColorFormatMismatch) { utils::ComboRenderBundleEncoderDescriptor renderBundleDesc = {}; renderBundleDesc.colorFormatsCount = 3; - renderBundleDesc.cColorFormats[0] = dawn::TextureFormat::RGBA8Unorm; - renderBundleDesc.cColorFormats[1] = dawn::TextureFormat::RG16Float; - renderBundleDesc.cColorFormats[2] = dawn::TextureFormat::R16Sint; + renderBundleDesc.cColorFormats[0] = wgpu::TextureFormat::RGBA8Unorm; + renderBundleDesc.cColorFormats[1] = wgpu::TextureFormat::RG16Float; + renderBundleDesc.cColorFormats[2] = wgpu::TextureFormat::R16Sint; - dawn::RenderBundleEncoder renderBundleEncoder = + wgpu::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&renderBundleDesc); - dawn::RenderBundle renderBundle = renderBundleEncoder.Finish(); + wgpu::RenderBundle renderBundle = renderBundleEncoder.Finish(); - dawn::TextureDescriptor textureDesc = {}; - textureDesc.usage = dawn::TextureUsage::OutputAttachment; - textureDesc.size = dawn::Extent3D({400, 400, 1}); + wgpu::TextureDescriptor textureDesc = {}; + textureDesc.usage = wgpu::TextureUsage::OutputAttachment; + textureDesc.size = wgpu::Extent3D({400, 400, 1}); - textureDesc.format = dawn::TextureFormat::RGBA8Unorm; - dawn::Texture tex0 = device.CreateTexture(&textureDesc); + textureDesc.format = wgpu::TextureFormat::RGBA8Unorm; + wgpu::Texture tex0 = device.CreateTexture(&textureDesc); - textureDesc.format = dawn::TextureFormat::RG16Float; - dawn::Texture tex1 = device.CreateTexture(&textureDesc); + textureDesc.format = wgpu::TextureFormat::RG16Float; + wgpu::Texture tex1 = device.CreateTexture(&textureDesc); - textureDesc.format = dawn::TextureFormat::R16Sint; - dawn::Texture tex2 = device.CreateTexture(&textureDesc); + textureDesc.format = wgpu::TextureFormat::R16Sint; + wgpu::Texture tex2 = device.CreateTexture(&textureDesc); // Test the success case { @@ -871,8 +871,8 @@ TEST_F(RenderBundleValidationTest, RenderPassColorFormatMismatch) { tex2.CreateView(), }); - dawn::CommandEncoder commandEncoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); pass.ExecuteBundles(1, &renderBundle); pass.EndPass(); commandEncoder.Finish(); @@ -886,8 +886,8 @@ TEST_F(RenderBundleValidationTest, RenderPassColorFormatMismatch) { tex0.CreateView(), }); - dawn::CommandEncoder commandEncoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); pass.ExecuteBundles(1, &renderBundle); pass.EndPass(); ASSERT_DEVICE_ERROR(commandEncoder.Finish()); @@ -900,8 +900,8 @@ TEST_F(RenderBundleValidationTest, RenderPassColorFormatMismatch) { tex1.CreateView(), }); - dawn::CommandEncoder commandEncoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); pass.ExecuteBundles(1, &renderBundle); pass.EndPass(); ASSERT_DEVICE_ERROR(commandEncoder.Finish()); @@ -913,32 +913,32 @@ TEST_F(RenderBundleValidationTest, RenderPassColorFormatMismatch) { TEST_F(RenderBundleValidationTest, RenderPassDepthStencilFormatMismatch) { utils::ComboRenderBundleEncoderDescriptor renderBundleDesc = {}; renderBundleDesc.colorFormatsCount = 1; - renderBundleDesc.cColorFormats[0] = dawn::TextureFormat::RGBA8Unorm; - renderBundleDesc.depthStencilFormat = dawn::TextureFormat::Depth24Plus; + renderBundleDesc.cColorFormats[0] = wgpu::TextureFormat::RGBA8Unorm; + renderBundleDesc.depthStencilFormat = wgpu::TextureFormat::Depth24Plus; - dawn::RenderBundleEncoder renderBundleEncoder = + wgpu::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&renderBundleDesc); - dawn::RenderBundle renderBundle = renderBundleEncoder.Finish(); + wgpu::RenderBundle renderBundle = renderBundleEncoder.Finish(); - dawn::TextureDescriptor textureDesc = {}; - textureDesc.usage = dawn::TextureUsage::OutputAttachment; - textureDesc.size = dawn::Extent3D({400, 400, 1}); + wgpu::TextureDescriptor textureDesc = {}; + textureDesc.usage = wgpu::TextureUsage::OutputAttachment; + textureDesc.size = wgpu::Extent3D({400, 400, 1}); - textureDesc.format = dawn::TextureFormat::RGBA8Unorm; - dawn::Texture tex0 = device.CreateTexture(&textureDesc); + textureDesc.format = wgpu::TextureFormat::RGBA8Unorm; + wgpu::Texture tex0 = device.CreateTexture(&textureDesc); - textureDesc.format = dawn::TextureFormat::Depth24Plus; - dawn::Texture tex1 = device.CreateTexture(&textureDesc); + textureDesc.format = wgpu::TextureFormat::Depth24Plus; + wgpu::Texture tex1 = device.CreateTexture(&textureDesc); - textureDesc.format = dawn::TextureFormat::Depth32Float; - dawn::Texture tex2 = device.CreateTexture(&textureDesc); + textureDesc.format = wgpu::TextureFormat::Depth32Float; + wgpu::Texture tex2 = device.CreateTexture(&textureDesc); // Test the success case { utils::ComboRenderPassDescriptor renderPass({tex0.CreateView()}, tex1.CreateView()); - dawn::CommandEncoder commandEncoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); pass.ExecuteBundles(1, &renderBundle); pass.EndPass(); commandEncoder.Finish(); @@ -948,8 +948,8 @@ TEST_F(RenderBundleValidationTest, RenderPassDepthStencilFormatMismatch) { { utils::ComboRenderPassDescriptor renderPass({tex0.CreateView()}, tex2.CreateView()); - dawn::CommandEncoder commandEncoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); pass.ExecuteBundles(1, &renderBundle); pass.EndPass(); ASSERT_DEVICE_ERROR(commandEncoder.Finish()); @@ -959,8 +959,8 @@ TEST_F(RenderBundleValidationTest, RenderPassDepthStencilFormatMismatch) { { utils::ComboRenderPassDescriptor renderPass({tex0.CreateView()}); - dawn::CommandEncoder commandEncoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); pass.ExecuteBundles(1, &renderBundle); pass.EndPass(); ASSERT_DEVICE_ERROR(commandEncoder.Finish()); @@ -971,28 +971,28 @@ TEST_F(RenderBundleValidationTest, RenderPassDepthStencilFormatMismatch) { TEST_F(RenderBundleValidationTest, RenderPassSampleCountMismatch) { utils::ComboRenderBundleEncoderDescriptor renderBundleDesc = {}; renderBundleDesc.colorFormatsCount = 1; - renderBundleDesc.cColorFormats[0] = dawn::TextureFormat::RGBA8Unorm; + renderBundleDesc.cColorFormats[0] = wgpu::TextureFormat::RGBA8Unorm; - dawn::RenderBundleEncoder renderBundleEncoder = + wgpu::RenderBundleEncoder renderBundleEncoder = device.CreateRenderBundleEncoder(&renderBundleDesc); - dawn::RenderBundle renderBundle = renderBundleEncoder.Finish(); + wgpu::RenderBundle renderBundle = renderBundleEncoder.Finish(); - dawn::TextureDescriptor textureDesc = {}; - textureDesc.usage = dawn::TextureUsage::OutputAttachment; - textureDesc.size = dawn::Extent3D({400, 400, 1}); + wgpu::TextureDescriptor textureDesc = {}; + textureDesc.usage = wgpu::TextureUsage::OutputAttachment; + textureDesc.size = wgpu::Extent3D({400, 400, 1}); - textureDesc.format = dawn::TextureFormat::RGBA8Unorm; - dawn::Texture tex0 = device.CreateTexture(&textureDesc); + textureDesc.format = wgpu::TextureFormat::RGBA8Unorm; + wgpu::Texture tex0 = device.CreateTexture(&textureDesc); textureDesc.sampleCount = 4; - dawn::Texture tex1 = device.CreateTexture(&textureDesc); + wgpu::Texture tex1 = device.CreateTexture(&textureDesc); // Test the success case { utils::ComboRenderPassDescriptor renderPass({tex0.CreateView()}); - dawn::CommandEncoder commandEncoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); pass.ExecuteBundles(1, &renderBundle); pass.EndPass(); commandEncoder.Finish(); @@ -1002,8 +1002,8 @@ TEST_F(RenderBundleValidationTest, RenderPassSampleCountMismatch) { { utils::ComboRenderPassDescriptor renderPass({tex1.CreateView()}); - dawn::CommandEncoder commandEncoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); pass.ExecuteBundles(1, &renderBundle); pass.EndPass(); ASSERT_DEVICE_ERROR(commandEncoder.Finish()); @@ -1017,7 +1017,7 @@ TEST_F(RenderBundleValidationTest, TextureFormats) { { utils::ComboRenderBundleEncoderDescriptor desc = {}; desc.colorFormatsCount = 1; - desc.cColorFormats[0] = dawn::TextureFormat::Depth24PlusStencil8; + desc.cColorFormats[0] = wgpu::TextureFormat::Depth24PlusStencil8; ASSERT_DEVICE_ERROR(device.CreateRenderBundleEncoder(&desc)); } @@ -1025,14 +1025,14 @@ TEST_F(RenderBundleValidationTest, TextureFormats) { { utils::ComboRenderBundleEncoderDescriptor desc = {}; desc.colorFormatsCount = 1; - desc.cColorFormats[0] = dawn::TextureFormat::RGBA8Snorm; + desc.cColorFormats[0] = wgpu::TextureFormat::RGBA8Snorm; ASSERT_DEVICE_ERROR(device.CreateRenderBundleEncoder(&desc)); } // Test that depth/stencil formats are validated as depth/stencil. { utils::ComboRenderBundleEncoderDescriptor desc = {}; - desc.depthStencilFormat = dawn::TextureFormat::RGBA8Unorm; + desc.depthStencilFormat = wgpu::TextureFormat::RGBA8Unorm; ASSERT_DEVICE_ERROR(device.CreateRenderBundleEncoder(&desc)); } diff --git a/src/tests/unittests/validation/RenderPassDescriptorValidationTests.cpp b/src/tests/unittests/validation/RenderPassDescriptorValidationTests.cpp index 6a31293930..94d770bfac 100644 --- a/src/tests/unittests/validation/RenderPassDescriptorValidationTests.cpp +++ b/src/tests/unittests/validation/RenderPassDescriptorValidationTests.cpp @@ -22,34 +22,34 @@ namespace { class RenderPassDescriptorValidationTest : public ValidationTest { public: - void AssertBeginRenderPassSuccess(const dawn::RenderPassDescriptor* descriptor) { - dawn::CommandEncoder commandEncoder = TestBeginRenderPass(descriptor); + void AssertBeginRenderPassSuccess(const wgpu::RenderPassDescriptor* descriptor) { + wgpu::CommandEncoder commandEncoder = TestBeginRenderPass(descriptor); commandEncoder.Finish(); } - void AssertBeginRenderPassError(const dawn::RenderPassDescriptor* descriptor) { - dawn::CommandEncoder commandEncoder = TestBeginRenderPass(descriptor); + void AssertBeginRenderPassError(const wgpu::RenderPassDescriptor* descriptor) { + wgpu::CommandEncoder commandEncoder = TestBeginRenderPass(descriptor); ASSERT_DEVICE_ERROR(commandEncoder.Finish()); } private: - dawn::CommandEncoder TestBeginRenderPass(const dawn::RenderPassDescriptor* descriptor) { - dawn::CommandEncoder commandEncoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder renderPassEncoder = commandEncoder.BeginRenderPass(descriptor); + wgpu::CommandEncoder TestBeginRenderPass(const wgpu::RenderPassDescriptor* descriptor) { + wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder renderPassEncoder = commandEncoder.BeginRenderPass(descriptor); renderPassEncoder.EndPass(); return commandEncoder; } }; -dawn::Texture CreateTexture(dawn::Device& device, - dawn::TextureDimension dimension, - dawn::TextureFormat format, +wgpu::Texture CreateTexture(wgpu::Device& device, + wgpu::TextureDimension dimension, + wgpu::TextureFormat format, uint32_t width, uint32_t height, uint32_t arrayLayerCount, uint32_t mipLevelCount, uint32_t sampleCount = 1, - dawn::TextureUsage usage = dawn::TextureUsage::OutputAttachment) { - dawn::TextureDescriptor descriptor; + wgpu::TextureUsage usage = wgpu::TextureUsage::OutputAttachment) { + wgpu::TextureDescriptor descriptor; descriptor.dimension = dimension; descriptor.size.width = width; descriptor.size.height = height; @@ -63,12 +63,12 @@ dawn::Texture CreateTexture(dawn::Device& device, return device.CreateTexture(&descriptor); } -dawn::TextureView Create2DAttachment(dawn::Device& device, +wgpu::TextureView Create2DAttachment(wgpu::Device& device, uint32_t width, uint32_t height, - dawn::TextureFormat format) { - dawn::Texture texture = CreateTexture( - device, dawn::TextureDimension::e2D, format, width, height, 1, 1); + wgpu::TextureFormat format) { + wgpu::Texture texture = + CreateTexture(device, wgpu::TextureDimension::e2D, format, width, height, 1, 1); return texture.CreateView(); } @@ -82,15 +82,15 @@ TEST_F(RenderPassDescriptorValidationTest, Empty) { TEST_F(RenderPassDescriptorValidationTest, OneAttachment) { // One color attachment { - dawn::TextureView color = Create2DAttachment(device, 1, 1, dawn::TextureFormat::RGBA8Unorm); + wgpu::TextureView color = Create2DAttachment(device, 1, 1, wgpu::TextureFormat::RGBA8Unorm); utils::ComboRenderPassDescriptor renderPass({color}); AssertBeginRenderPassSuccess(&renderPass); } // One depth-stencil attachment { - dawn::TextureView depthStencil = - Create2DAttachment(device, 1, 1, dawn::TextureFormat::Depth24PlusStencil8); + wgpu::TextureView depthStencil = + Create2DAttachment(device, 1, 1, wgpu::TextureFormat::Depth24PlusStencil8); utils::ComboRenderPassDescriptor renderPass({}, depthStencil); AssertBeginRenderPassSuccess(&renderPass); @@ -99,10 +99,10 @@ TEST_F(RenderPassDescriptorValidationTest, OneAttachment) { // Test OOB color attachment indices are handled TEST_F(RenderPassDescriptorValidationTest, ColorAttachmentOutOfBounds) { - dawn::TextureView color0 = Create2DAttachment(device, 1, 1, dawn::TextureFormat::RGBA8Unorm); - dawn::TextureView color1 = Create2DAttachment(device, 1, 1, dawn::TextureFormat::RGBA8Unorm); - dawn::TextureView color2 = Create2DAttachment(device, 1, 1, dawn::TextureFormat::RGBA8Unorm); - dawn::TextureView color3 = Create2DAttachment(device, 1, 1, dawn::TextureFormat::RGBA8Unorm); + wgpu::TextureView color0 = Create2DAttachment(device, 1, 1, wgpu::TextureFormat::RGBA8Unorm); + wgpu::TextureView color1 = Create2DAttachment(device, 1, 1, wgpu::TextureFormat::RGBA8Unorm); + wgpu::TextureView color2 = Create2DAttachment(device, 1, 1, wgpu::TextureFormat::RGBA8Unorm); + wgpu::TextureView color3 = Create2DAttachment(device, 1, 1, wgpu::TextureFormat::RGBA8Unorm); // For setting the color attachment, control case { utils::ComboRenderPassDescriptor renderPass({color0, color1, color2, color3}); @@ -112,12 +112,12 @@ TEST_F(RenderPassDescriptorValidationTest, ColorAttachmentOutOfBounds) { { // We cannot use utils::ComboRenderPassDescriptor here because it only supports at most // kMaxColorAttachments(4) color attachments. - std::array colorAttachments; + std::array colorAttachments; colorAttachments[0].attachment = color0; colorAttachments[0].resolveTarget = nullptr; colorAttachments[0].clearColor = {0.0f, 0.0f, 0.0f, 0.0f}; - colorAttachments[0].loadOp = dawn::LoadOp::Clear; - colorAttachments[0].storeOp = dawn::StoreOp::Store; + colorAttachments[0].loadOp = wgpu::LoadOp::Clear; + colorAttachments[0].storeOp = wgpu::StoreOp::Store; colorAttachments[1] = colorAttachments[0]; colorAttachments[1].attachment = color1; @@ -130,9 +130,9 @@ TEST_F(RenderPassDescriptorValidationTest, ColorAttachmentOutOfBounds) { colorAttachments[4] = colorAttachments[0]; colorAttachments[4].attachment = - Create2DAttachment(device, 1, 1, dawn::TextureFormat::RGBA8Unorm); + Create2DAttachment(device, 1, 1, wgpu::TextureFormat::RGBA8Unorm); - dawn::RenderPassDescriptor renderPass; + wgpu::RenderPassDescriptor renderPass; renderPass.colorAttachmentCount = 5; renderPass.colorAttachments = colorAttachments.data(); renderPass.depthStencilAttachment = nullptr; @@ -142,14 +142,14 @@ TEST_F(RenderPassDescriptorValidationTest, ColorAttachmentOutOfBounds) { // Attachments must have the same size TEST_F(RenderPassDescriptorValidationTest, SizeMustMatch) { - dawn::TextureView color1x1A = Create2DAttachment(device, 1, 1, dawn::TextureFormat::RGBA8Unorm); - dawn::TextureView color1x1B = Create2DAttachment(device, 1, 1, dawn::TextureFormat::RGBA8Unorm); - dawn::TextureView color2x2 = Create2DAttachment(device, 2, 2, dawn::TextureFormat::RGBA8Unorm); + wgpu::TextureView color1x1A = Create2DAttachment(device, 1, 1, wgpu::TextureFormat::RGBA8Unorm); + wgpu::TextureView color1x1B = Create2DAttachment(device, 1, 1, wgpu::TextureFormat::RGBA8Unorm); + wgpu::TextureView color2x2 = Create2DAttachment(device, 2, 2, wgpu::TextureFormat::RGBA8Unorm); - dawn::TextureView depthStencil1x1 = - Create2DAttachment(device, 1, 1, dawn::TextureFormat::Depth24PlusStencil8); - dawn::TextureView depthStencil2x2 = - Create2DAttachment(device, 2, 2, dawn::TextureFormat::Depth24PlusStencil8); + wgpu::TextureView depthStencil1x1 = + Create2DAttachment(device, 1, 1, wgpu::TextureFormat::Depth24PlusStencil8); + wgpu::TextureView depthStencil2x2 = + Create2DAttachment(device, 2, 2, wgpu::TextureFormat::Depth24PlusStencil8); // Control case: all the same size (1x1) { @@ -172,9 +172,9 @@ TEST_F(RenderPassDescriptorValidationTest, SizeMustMatch) { // Attachments formats must match whether they are used for color or depth-stencil TEST_F(RenderPassDescriptorValidationTest, FormatMismatch) { - dawn::TextureView color = Create2DAttachment(device, 1, 1, dawn::TextureFormat::RGBA8Unorm); - dawn::TextureView depthStencil = - Create2DAttachment(device, 1, 1, dawn::TextureFormat::Depth24PlusStencil8); + wgpu::TextureView color = Create2DAttachment(device, 1, 1, wgpu::TextureFormat::RGBA8Unorm); + wgpu::TextureView depthStencil = + Create2DAttachment(device, 1, 1, wgpu::TextureFormat::Depth24PlusStencil8); // Using depth-stencil for color { @@ -194,45 +194,45 @@ TEST_F(RenderPassDescriptorValidationTest, DepthStencilStoreOpMismatch) { constexpr uint32_t kArrayLayers = 1; constexpr uint32_t kLevelCount = 1; constexpr uint32_t kSize = 32; - constexpr dawn::TextureFormat kColorFormat = dawn::TextureFormat::RGBA8Unorm; - constexpr dawn::TextureFormat kDepthStencilFormat = dawn::TextureFormat::Depth24PlusStencil8; + constexpr wgpu::TextureFormat kColorFormat = wgpu::TextureFormat::RGBA8Unorm; + constexpr wgpu::TextureFormat kDepthStencilFormat = wgpu::TextureFormat::Depth24PlusStencil8; - dawn::Texture colorTexture = CreateTexture(device, dawn::TextureDimension::e2D, kColorFormat, + wgpu::Texture colorTexture = CreateTexture(device, wgpu::TextureDimension::e2D, kColorFormat, kSize, kSize, kArrayLayers, kLevelCount); - dawn::Texture depthStencilTexture = - CreateTexture(device, dawn::TextureDimension::e2D, kDepthStencilFormat, kSize, kSize, + wgpu::Texture depthStencilTexture = + CreateTexture(device, wgpu::TextureDimension::e2D, kDepthStencilFormat, kSize, kSize, kArrayLayers, kLevelCount); - dawn::TextureViewDescriptor descriptor; - descriptor.dimension = dawn::TextureViewDimension::e2D; + wgpu::TextureViewDescriptor descriptor; + descriptor.dimension = wgpu::TextureViewDimension::e2D; descriptor.baseArrayLayer = 0; descriptor.arrayLayerCount = kArrayLayers; descriptor.baseMipLevel = 0; descriptor.mipLevelCount = kLevelCount; - dawn::TextureView colorTextureView = colorTexture.CreateView(&descriptor); - dawn::TextureView depthStencilView = depthStencilTexture.CreateView(&descriptor); + wgpu::TextureView colorTextureView = colorTexture.CreateView(&descriptor); + wgpu::TextureView depthStencilView = depthStencilTexture.CreateView(&descriptor); // StoreOps mismatch causing the render pass to error { utils::ComboRenderPassDescriptor renderPass({}, depthStencilView); - renderPass.cDepthStencilAttachmentInfo.stencilStoreOp = dawn::StoreOp::Store; - renderPass.cDepthStencilAttachmentInfo.depthStoreOp = dawn::StoreOp::Clear; + renderPass.cDepthStencilAttachmentInfo.stencilStoreOp = wgpu::StoreOp::Store; + renderPass.cDepthStencilAttachmentInfo.depthStoreOp = wgpu::StoreOp::Clear; AssertBeginRenderPassError(&renderPass); } // StoreOps match so render pass is a success { utils::ComboRenderPassDescriptor renderPass({}, depthStencilView); - renderPass.cDepthStencilAttachmentInfo.stencilStoreOp = dawn::StoreOp::Store; - renderPass.cDepthStencilAttachmentInfo.depthStoreOp = dawn::StoreOp::Store; + renderPass.cDepthStencilAttachmentInfo.stencilStoreOp = wgpu::StoreOp::Store; + renderPass.cDepthStencilAttachmentInfo.depthStoreOp = wgpu::StoreOp::Store; AssertBeginRenderPassSuccess(&renderPass); } // StoreOps match so render pass is a success { utils::ComboRenderPassDescriptor renderPass({}, depthStencilView); - renderPass.cDepthStencilAttachmentInfo.stencilStoreOp = dawn::StoreOp::Clear; - renderPass.cDepthStencilAttachmentInfo.depthStoreOp = dawn::StoreOp::Clear; + renderPass.cDepthStencilAttachmentInfo.stencilStoreOp = wgpu::StoreOp::Clear; + renderPass.cDepthStencilAttachmentInfo.depthStoreOp = wgpu::StoreOp::Clear; AssertBeginRenderPassSuccess(&renderPass); } } @@ -242,19 +242,19 @@ TEST_F(RenderPassDescriptorValidationTest, DepthStencilStoreOpMismatch) { TEST_F(RenderPassDescriptorValidationTest, TextureViewLayerCountForColorAndDepthStencil) { constexpr uint32_t kLevelCount = 1; constexpr uint32_t kSize = 32; - constexpr dawn::TextureFormat kColorFormat = dawn::TextureFormat::RGBA8Unorm; - constexpr dawn::TextureFormat kDepthStencilFormat = dawn::TextureFormat::Depth24PlusStencil8; + constexpr wgpu::TextureFormat kColorFormat = wgpu::TextureFormat::RGBA8Unorm; + constexpr wgpu::TextureFormat kDepthStencilFormat = wgpu::TextureFormat::Depth24PlusStencil8; constexpr uint32_t kArrayLayers = 10; - dawn::Texture colorTexture = CreateTexture( - device, dawn::TextureDimension::e2D, kColorFormat, kSize, kSize, kArrayLayers, kLevelCount); - dawn::Texture depthStencilTexture = CreateTexture( - device, dawn::TextureDimension::e2D, kDepthStencilFormat, kSize, kSize, kArrayLayers, - kLevelCount); + wgpu::Texture colorTexture = CreateTexture(device, wgpu::TextureDimension::e2D, kColorFormat, + kSize, kSize, kArrayLayers, kLevelCount); + wgpu::Texture depthStencilTexture = + CreateTexture(device, wgpu::TextureDimension::e2D, kDepthStencilFormat, kSize, kSize, + kArrayLayers, kLevelCount); - dawn::TextureViewDescriptor baseDescriptor; - baseDescriptor.dimension = dawn::TextureViewDimension::e2DArray; + wgpu::TextureViewDescriptor baseDescriptor; + baseDescriptor.dimension = wgpu::TextureViewDimension::e2DArray; baseDescriptor.baseArrayLayer = 0; baseDescriptor.arrayLayerCount = kArrayLayers; baseDescriptor.baseMipLevel = 0; @@ -262,70 +262,70 @@ TEST_F(RenderPassDescriptorValidationTest, TextureViewLayerCountForColorAndDepth // Using 2D array texture view with arrayLayerCount > 1 is not allowed for color { - dawn::TextureViewDescriptor descriptor = baseDescriptor; + wgpu::TextureViewDescriptor descriptor = baseDescriptor; descriptor.format = kColorFormat; descriptor.arrayLayerCount = 5; - dawn::TextureView colorTextureView = colorTexture.CreateView(&descriptor); + wgpu::TextureView colorTextureView = colorTexture.CreateView(&descriptor); utils::ComboRenderPassDescriptor renderPass({colorTextureView}); AssertBeginRenderPassError(&renderPass); } // Using 2D array texture view with arrayLayerCount > 1 is not allowed for depth stencil { - dawn::TextureViewDescriptor descriptor = baseDescriptor; + wgpu::TextureViewDescriptor descriptor = baseDescriptor; descriptor.format = kDepthStencilFormat; descriptor.arrayLayerCount = 5; - dawn::TextureView depthStencilView = depthStencilTexture.CreateView(&descriptor); + wgpu::TextureView depthStencilView = depthStencilTexture.CreateView(&descriptor); utils::ComboRenderPassDescriptor renderPass({}, depthStencilView); AssertBeginRenderPassError(&renderPass); } // Using 2D array texture view that covers the first layer of the texture is OK for color { - dawn::TextureViewDescriptor descriptor = baseDescriptor; + wgpu::TextureViewDescriptor descriptor = baseDescriptor; descriptor.format = kColorFormat; descriptor.baseArrayLayer = 0; descriptor.arrayLayerCount = 1; - dawn::TextureView colorTextureView = colorTexture.CreateView(&descriptor); + wgpu::TextureView colorTextureView = colorTexture.CreateView(&descriptor); utils::ComboRenderPassDescriptor renderPass({colorTextureView}); AssertBeginRenderPassSuccess(&renderPass); } // Using 2D array texture view that covers the first layer is OK for depth stencil { - dawn::TextureViewDescriptor descriptor = baseDescriptor; + wgpu::TextureViewDescriptor descriptor = baseDescriptor; descriptor.format = kDepthStencilFormat; descriptor.baseArrayLayer = 0; descriptor.arrayLayerCount = 1; - dawn::TextureView depthStencilView = depthStencilTexture.CreateView(&descriptor); + wgpu::TextureView depthStencilView = depthStencilTexture.CreateView(&descriptor); utils::ComboRenderPassDescriptor renderPass({}, depthStencilView); AssertBeginRenderPassSuccess(&renderPass); } // Using 2D array texture view that covers the last layer is OK for color { - dawn::TextureViewDescriptor descriptor = baseDescriptor; + wgpu::TextureViewDescriptor descriptor = baseDescriptor; descriptor.format = kColorFormat; descriptor.baseArrayLayer = kArrayLayers - 1; descriptor.arrayLayerCount = 1; - dawn::TextureView colorTextureView = colorTexture.CreateView(&descriptor); + wgpu::TextureView colorTextureView = colorTexture.CreateView(&descriptor); utils::ComboRenderPassDescriptor renderPass({colorTextureView}); AssertBeginRenderPassSuccess(&renderPass); } // Using 2D array texture view that covers the last layer is OK for depth stencil { - dawn::TextureViewDescriptor descriptor = baseDescriptor; + wgpu::TextureViewDescriptor descriptor = baseDescriptor; descriptor.format = kDepthStencilFormat; descriptor.baseArrayLayer = kArrayLayers - 1; descriptor.arrayLayerCount = 1; - dawn::TextureView depthStencilView = depthStencilTexture.CreateView(&descriptor); + wgpu::TextureView depthStencilView = depthStencilTexture.CreateView(&descriptor); utils::ComboRenderPassDescriptor renderPass({}, depthStencilView); AssertBeginRenderPassSuccess(&renderPass); } @@ -335,19 +335,19 @@ TEST_F(RenderPassDescriptorValidationTest, TextureViewLayerCountForColorAndDepth TEST_F(RenderPassDescriptorValidationTest, TextureViewLevelCountForColorAndDepthStencil) { constexpr uint32_t kArrayLayers = 1; constexpr uint32_t kSize = 32; - constexpr dawn::TextureFormat kColorFormat = dawn::TextureFormat::RGBA8Unorm; - constexpr dawn::TextureFormat kDepthStencilFormat = dawn::TextureFormat::Depth24PlusStencil8; + constexpr wgpu::TextureFormat kColorFormat = wgpu::TextureFormat::RGBA8Unorm; + constexpr wgpu::TextureFormat kDepthStencilFormat = wgpu::TextureFormat::Depth24PlusStencil8; constexpr uint32_t kLevelCount = 4; - dawn::Texture colorTexture = CreateTexture( - device, dawn::TextureDimension::e2D, kColorFormat, kSize, kSize, kArrayLayers, kLevelCount); - dawn::Texture depthStencilTexture = CreateTexture( - device, dawn::TextureDimension::e2D, kDepthStencilFormat, kSize, kSize, kArrayLayers, - kLevelCount); + wgpu::Texture colorTexture = CreateTexture(device, wgpu::TextureDimension::e2D, kColorFormat, + kSize, kSize, kArrayLayers, kLevelCount); + wgpu::Texture depthStencilTexture = + CreateTexture(device, wgpu::TextureDimension::e2D, kDepthStencilFormat, kSize, kSize, + kArrayLayers, kLevelCount); - dawn::TextureViewDescriptor baseDescriptor; - baseDescriptor.dimension = dawn::TextureViewDimension::e2D; + wgpu::TextureViewDescriptor baseDescriptor; + baseDescriptor.dimension = wgpu::TextureViewDimension::e2D; baseDescriptor.baseArrayLayer = 0; baseDescriptor.arrayLayerCount = kArrayLayers; baseDescriptor.baseMipLevel = 0; @@ -355,70 +355,70 @@ TEST_F(RenderPassDescriptorValidationTest, TextureViewLevelCountForColorAndDepth // Using 2D texture view with mipLevelCount > 1 is not allowed for color { - dawn::TextureViewDescriptor descriptor = baseDescriptor; + wgpu::TextureViewDescriptor descriptor = baseDescriptor; descriptor.format = kColorFormat; descriptor.mipLevelCount = 2; - dawn::TextureView colorTextureView = colorTexture.CreateView(&descriptor); + wgpu::TextureView colorTextureView = colorTexture.CreateView(&descriptor); utils::ComboRenderPassDescriptor renderPass({colorTextureView}); AssertBeginRenderPassError(&renderPass); } // Using 2D texture view with mipLevelCount > 1 is not allowed for depth stencil { - dawn::TextureViewDescriptor descriptor = baseDescriptor; + wgpu::TextureViewDescriptor descriptor = baseDescriptor; descriptor.format = kDepthStencilFormat; descriptor.mipLevelCount = 2; - dawn::TextureView depthStencilView = depthStencilTexture.CreateView(&descriptor); + wgpu::TextureView depthStencilView = depthStencilTexture.CreateView(&descriptor); utils::ComboRenderPassDescriptor renderPass({}, depthStencilView); AssertBeginRenderPassError(&renderPass); } // Using 2D texture view that covers the first level of the texture is OK for color { - dawn::TextureViewDescriptor descriptor = baseDescriptor; + wgpu::TextureViewDescriptor descriptor = baseDescriptor; descriptor.format = kColorFormat; descriptor.baseMipLevel = 0; descriptor.mipLevelCount = 1; - dawn::TextureView colorTextureView = colorTexture.CreateView(&descriptor); + wgpu::TextureView colorTextureView = colorTexture.CreateView(&descriptor); utils::ComboRenderPassDescriptor renderPass({colorTextureView}); AssertBeginRenderPassSuccess(&renderPass); } // Using 2D texture view that covers the first level is OK for depth stencil { - dawn::TextureViewDescriptor descriptor = baseDescriptor; + wgpu::TextureViewDescriptor descriptor = baseDescriptor; descriptor.format = kDepthStencilFormat; descriptor.baseMipLevel = 0; descriptor.mipLevelCount = 1; - dawn::TextureView depthStencilView = depthStencilTexture.CreateView(&descriptor); + wgpu::TextureView depthStencilView = depthStencilTexture.CreateView(&descriptor); utils::ComboRenderPassDescriptor renderPass({}, depthStencilView); AssertBeginRenderPassSuccess(&renderPass); } // Using 2D texture view that covers the last level is OK for color { - dawn::TextureViewDescriptor descriptor = baseDescriptor; + wgpu::TextureViewDescriptor descriptor = baseDescriptor; descriptor.format = kColorFormat; descriptor.baseMipLevel = kLevelCount - 1; descriptor.mipLevelCount = 1; - dawn::TextureView colorTextureView = colorTexture.CreateView(&descriptor); + wgpu::TextureView colorTextureView = colorTexture.CreateView(&descriptor); utils::ComboRenderPassDescriptor renderPass({colorTextureView}); AssertBeginRenderPassSuccess(&renderPass); } // Using 2D texture view that covers the last level is OK for depth stencil { - dawn::TextureViewDescriptor descriptor = baseDescriptor; + wgpu::TextureViewDescriptor descriptor = baseDescriptor; descriptor.format = kDepthStencilFormat; descriptor.baseMipLevel = kLevelCount - 1; descriptor.mipLevelCount = 1; - dawn::TextureView depthStencilView = depthStencilTexture.CreateView(&descriptor); + wgpu::TextureView depthStencilView = depthStencilTexture.CreateView(&descriptor); utils::ComboRenderPassDescriptor renderPass({}, depthStencilView); AssertBeginRenderPassSuccess(&renderPass); } @@ -430,16 +430,16 @@ TEST_F(RenderPassDescriptorValidationTest, NonMultisampledColorWithResolveTarget static constexpr uint32_t kLevelCount = 1; static constexpr uint32_t kSize = 32; static constexpr uint32_t kSampleCount = 1; - static constexpr dawn::TextureFormat kColorFormat = dawn::TextureFormat::RGBA8Unorm; + static constexpr wgpu::TextureFormat kColorFormat = wgpu::TextureFormat::RGBA8Unorm; - dawn::Texture colorTexture = CreateTexture( - device, dawn::TextureDimension::e2D, kColorFormat, kSize, kSize, kArrayLayers, - kLevelCount, kSampleCount); - dawn::Texture resolveTargetTexture = CreateTexture( - device, dawn::TextureDimension::e2D, kColorFormat, kSize, kSize, kArrayLayers, - kLevelCount, kSampleCount); - dawn::TextureView colorTextureView = colorTexture.CreateView(); - dawn::TextureView resolveTargetTextureView = resolveTargetTexture.CreateView(); + wgpu::Texture colorTexture = + CreateTexture(device, wgpu::TextureDimension::e2D, kColorFormat, kSize, kSize, kArrayLayers, + kLevelCount, kSampleCount); + wgpu::Texture resolveTargetTexture = + CreateTexture(device, wgpu::TextureDimension::e2D, kColorFormat, kSize, kSize, kArrayLayers, + kLevelCount, kSampleCount); + wgpu::TextureView colorTextureView = colorTexture.CreateView(); + wgpu::TextureView resolveTargetTextureView = resolveTargetTexture.CreateView(); utils::ComboRenderPassDescriptor renderPass({colorTextureView}); renderPass.cColorAttachments[0].resolveTarget = resolveTargetTextureView; @@ -452,11 +452,11 @@ class MultisampledRenderPassDescriptorValidationTest : public RenderPassDescript return utils::ComboRenderPassDescriptor({CreateMultisampledColorTextureView()}); } - dawn::TextureView CreateMultisampledColorTextureView() { + wgpu::TextureView CreateMultisampledColorTextureView() { return CreateColorTextureView(kSampleCount); } - dawn::TextureView CreateNonMultisampledColorTextureView() { + wgpu::TextureView CreateNonMultisampledColorTextureView() { return CreateColorTextureView(1); } @@ -464,13 +464,13 @@ class MultisampledRenderPassDescriptorValidationTest : public RenderPassDescript static constexpr uint32_t kLevelCount = 1; static constexpr uint32_t kSize = 32; static constexpr uint32_t kSampleCount = 4; - static constexpr dawn::TextureFormat kColorFormat = dawn::TextureFormat::RGBA8Unorm; + static constexpr wgpu::TextureFormat kColorFormat = wgpu::TextureFormat::RGBA8Unorm; private: - dawn::TextureView CreateColorTextureView(uint32_t sampleCount) { - dawn::Texture colorTexture = CreateTexture( - device, dawn::TextureDimension::e2D, kColorFormat, kSize, kSize, kArrayLayers, - kLevelCount, sampleCount); + wgpu::TextureView CreateColorTextureView(uint32_t sampleCount) { + wgpu::Texture colorTexture = + CreateTexture(device, wgpu::TextureDimension::e2D, kColorFormat, kSize, kSize, + kArrayLayers, kLevelCount, sampleCount); return colorTexture.CreateView(); } @@ -478,9 +478,9 @@ class MultisampledRenderPassDescriptorValidationTest : public RenderPassDescript // Tests on the use of multisampled textures as color attachments TEST_F(MultisampledRenderPassDescriptorValidationTest, MultisampledColorAttachments) { - dawn::TextureView colorTextureView = CreateNonMultisampledColorTextureView(); - dawn::TextureView resolveTargetTextureView = CreateNonMultisampledColorTextureView(); - dawn::TextureView multisampledColorTextureView = CreateMultisampledColorTextureView(); + wgpu::TextureView colorTextureView = CreateNonMultisampledColorTextureView(); + wgpu::TextureView resolveTargetTextureView = CreateNonMultisampledColorTextureView(); + wgpu::TextureView multisampledColorTextureView = CreateMultisampledColorTextureView(); // It is allowed to use a multisampled color attachment without setting resolve target. { @@ -498,7 +498,7 @@ TEST_F(MultisampledRenderPassDescriptorValidationTest, MultisampledColorAttachme // It is not allowed to use a multisampled resolve target. TEST_F(MultisampledRenderPassDescriptorValidationTest, MultisampledResolveTarget) { - dawn::TextureView multisampledResolveTargetView = CreateMultisampledColorTextureView(); + wgpu::TextureView multisampledResolveTargetView = CreateMultisampledColorTextureView(); utils::ComboRenderPassDescriptor renderPass = CreateMultisampledRenderPass(); renderPass.cColorAttachments[0].resolveTarget = multisampledResolveTargetView; @@ -508,10 +508,9 @@ TEST_F(MultisampledRenderPassDescriptorValidationTest, MultisampledResolveTarget // It is not allowed to use a resolve target with array layer count > 1. TEST_F(MultisampledRenderPassDescriptorValidationTest, ResolveTargetArrayLayerMoreThanOne) { constexpr uint32_t kArrayLayers2 = 2; - dawn::Texture resolveTexture = CreateTexture( - device, dawn::TextureDimension::e2D, kColorFormat, kSize, kSize, kArrayLayers2, - kLevelCount); - dawn::TextureView resolveTextureView = resolveTexture.CreateView(); + wgpu::Texture resolveTexture = CreateTexture(device, wgpu::TextureDimension::e2D, kColorFormat, + kSize, kSize, kArrayLayers2, kLevelCount); + wgpu::TextureView resolveTextureView = resolveTexture.CreateView(); utils::ComboRenderPassDescriptor renderPass = CreateMultisampledRenderPass(); renderPass.cColorAttachments[0].resolveTarget = resolveTextureView; @@ -521,10 +520,9 @@ TEST_F(MultisampledRenderPassDescriptorValidationTest, ResolveTargetArrayLayerMo // It is not allowed to use a resolve target with mipmap level count > 1. TEST_F(MultisampledRenderPassDescriptorValidationTest, ResolveTargetMipmapLevelMoreThanOne) { constexpr uint32_t kLevelCount2 = 2; - dawn::Texture resolveTexture = CreateTexture( - device, dawn::TextureDimension::e2D, kColorFormat, kSize, kSize, kArrayLayers, - kLevelCount2); - dawn::TextureView resolveTextureView = resolveTexture.CreateView(); + wgpu::Texture resolveTexture = CreateTexture(device, wgpu::TextureDimension::e2D, kColorFormat, + kSize, kSize, kArrayLayers, kLevelCount2); + wgpu::TextureView resolveTextureView = resolveTexture.CreateView(); utils::ComboRenderPassDescriptor renderPass = CreateMultisampledRenderPass(); renderPass.cColorAttachments[0].resolveTarget = resolveTextureView; @@ -532,13 +530,13 @@ TEST_F(MultisampledRenderPassDescriptorValidationTest, ResolveTargetMipmapLevelM } // It is not allowed to use a resolve target which is created from a texture whose usage does not -// include dawn::TextureUsage::OutputAttachment. +// include wgpu::TextureUsage::OutputAttachment. TEST_F(MultisampledRenderPassDescriptorValidationTest, ResolveTargetUsageNoOutputAttachment) { - constexpr dawn::TextureUsage kUsage = dawn::TextureUsage::CopyDst | dawn::TextureUsage::CopySrc; - dawn::Texture nonColorUsageResolveTexture = CreateTexture( - device, dawn::TextureDimension::e2D, kColorFormat, kSize, kSize, kArrayLayers, - kLevelCount, 1, kUsage); - dawn::TextureView nonColorUsageResolveTextureView = nonColorUsageResolveTexture.CreateView(); + constexpr wgpu::TextureUsage kUsage = wgpu::TextureUsage::CopyDst | wgpu::TextureUsage::CopySrc; + wgpu::Texture nonColorUsageResolveTexture = + CreateTexture(device, wgpu::TextureDimension::e2D, kColorFormat, kSize, kSize, kArrayLayers, + kLevelCount, 1, kUsage); + wgpu::TextureView nonColorUsageResolveTextureView = nonColorUsageResolveTexture.CreateView(); utils::ComboRenderPassDescriptor renderPass = CreateMultisampledRenderPass(); renderPass.cColorAttachments[0].resolveTarget = nonColorUsageResolveTextureView; @@ -547,16 +545,14 @@ TEST_F(MultisampledRenderPassDescriptorValidationTest, ResolveTargetUsageNoOutpu // It is not allowed to use a resolve target which is in error state. TEST_F(MultisampledRenderPassDescriptorValidationTest, ResolveTargetInErrorState) { - dawn::Texture resolveTexture = CreateTexture( - device, dawn::TextureDimension::e2D, kColorFormat, kSize, kSize, kArrayLayers, - kLevelCount); - dawn::TextureViewDescriptor errorTextureView; - errorTextureView.dimension = dawn::TextureViewDimension::e2D; + wgpu::Texture resolveTexture = CreateTexture(device, wgpu::TextureDimension::e2D, kColorFormat, + kSize, kSize, kArrayLayers, kLevelCount); + wgpu::TextureViewDescriptor errorTextureView; + errorTextureView.dimension = wgpu::TextureViewDimension::e2D; errorTextureView.format = kColorFormat; errorTextureView.baseArrayLayer = kArrayLayers + 1; - ASSERT_DEVICE_ERROR( - dawn::TextureView errorResolveTarget = - resolveTexture.CreateView(&errorTextureView)); + ASSERT_DEVICE_ERROR(wgpu::TextureView errorResolveTarget = + resolveTexture.CreateView(&errorTextureView)); utils::ComboRenderPassDescriptor renderPass = CreateMultisampledRenderPass(); renderPass.cColorAttachments[0].resolveTarget = errorResolveTarget; @@ -565,7 +561,7 @@ TEST_F(MultisampledRenderPassDescriptorValidationTest, ResolveTargetInErrorState // It is allowed to use a multisampled color attachment and a non-multisampled resolve target. TEST_F(MultisampledRenderPassDescriptorValidationTest, MultisampledColorWithResolveTarget) { - dawn::TextureView resolveTargetTextureView = CreateNonMultisampledColorTextureView(); + wgpu::TextureView resolveTargetTextureView = CreateNonMultisampledColorTextureView(); utils::ComboRenderPassDescriptor renderPass = CreateMultisampledRenderPass(); renderPass.cColorAttachments[0].resolveTarget = resolveTargetTextureView; @@ -574,11 +570,10 @@ TEST_F(MultisampledRenderPassDescriptorValidationTest, MultisampledColorWithReso // It is not allowed to use a resolve target in a format different from the color attachment. TEST_F(MultisampledRenderPassDescriptorValidationTest, ResolveTargetDifferentFormat) { - constexpr dawn::TextureFormat kColorFormat2 = dawn::TextureFormat::BGRA8Unorm; - dawn::Texture resolveTexture = CreateTexture( - device, dawn::TextureDimension::e2D, kColorFormat2, kSize, kSize, kArrayLayers, - kLevelCount); - dawn::TextureView resolveTextureView = resolveTexture.CreateView(); + constexpr wgpu::TextureFormat kColorFormat2 = wgpu::TextureFormat::BGRA8Unorm; + wgpu::Texture resolveTexture = CreateTexture(device, wgpu::TextureDimension::e2D, kColorFormat2, + kSize, kSize, kArrayLayers, kLevelCount); + wgpu::TextureView resolveTextureView = resolveTexture.CreateView(); utils::ComboRenderPassDescriptor renderPass = CreateMultisampledRenderPass(); renderPass.cColorAttachments[0].resolveTarget = resolveTextureView; @@ -588,24 +583,22 @@ TEST_F(MultisampledRenderPassDescriptorValidationTest, ResolveTargetDifferentFor // Tests on the size of the resolve target. TEST_F(MultisampledRenderPassDescriptorValidationTest, ColorAttachmentResolveTargetCompatibility) { constexpr uint32_t kSize2 = kSize * 2; - dawn::Texture resolveTexture = CreateTexture( - device, dawn::TextureDimension::e2D, kColorFormat, kSize2, kSize2, kArrayLayers, - kLevelCount + 1); + wgpu::Texture resolveTexture = CreateTexture(device, wgpu::TextureDimension::e2D, kColorFormat, + kSize2, kSize2, kArrayLayers, kLevelCount + 1); - dawn::TextureViewDescriptor textureViewDescriptor; + wgpu::TextureViewDescriptor textureViewDescriptor; textureViewDescriptor.nextInChain = nullptr; - textureViewDescriptor.dimension = dawn::TextureViewDimension::e2D; + textureViewDescriptor.dimension = wgpu::TextureViewDimension::e2D; textureViewDescriptor.format = kColorFormat; textureViewDescriptor.mipLevelCount = 1; textureViewDescriptor.baseArrayLayer = 0; textureViewDescriptor.arrayLayerCount = 1; { - dawn::TextureViewDescriptor firstMipLevelDescriptor = textureViewDescriptor; + wgpu::TextureViewDescriptor firstMipLevelDescriptor = textureViewDescriptor; firstMipLevelDescriptor.baseMipLevel = 0; - dawn::TextureView resolveTextureView = - resolveTexture.CreateView(&firstMipLevelDescriptor); + wgpu::TextureView resolveTextureView = resolveTexture.CreateView(&firstMipLevelDescriptor); utils::ComboRenderPassDescriptor renderPass = CreateMultisampledRenderPass(); renderPass.cColorAttachments[0].resolveTarget = resolveTextureView; @@ -613,11 +606,10 @@ TEST_F(MultisampledRenderPassDescriptorValidationTest, ColorAttachmentResolveTar } { - dawn::TextureViewDescriptor secondMipLevelDescriptor = textureViewDescriptor; + wgpu::TextureViewDescriptor secondMipLevelDescriptor = textureViewDescriptor; secondMipLevelDescriptor.baseMipLevel = 1; - dawn::TextureView resolveTextureView = - resolveTexture.CreateView(&secondMipLevelDescriptor); + wgpu::TextureView resolveTextureView = resolveTexture.CreateView(&secondMipLevelDescriptor); utils::ComboRenderPassDescriptor renderPass = CreateMultisampledRenderPass(); renderPass.cColorAttachments[0].resolveTarget = resolveTextureView; @@ -627,20 +619,20 @@ TEST_F(MultisampledRenderPassDescriptorValidationTest, ColorAttachmentResolveTar // Tests on the sample count of depth stencil attachment. TEST_F(MultisampledRenderPassDescriptorValidationTest, DepthStencilAttachmentSampleCount) { - constexpr dawn::TextureFormat kDepthStencilFormat = dawn::TextureFormat::Depth24PlusStencil8; - dawn::Texture multisampledDepthStencilTexture = CreateTexture( - device, dawn::TextureDimension::e2D, kDepthStencilFormat, kSize, kSize, kArrayLayers, - kLevelCount, kSampleCount); - dawn::TextureView multisampledDepthStencilTextureView = + constexpr wgpu::TextureFormat kDepthStencilFormat = wgpu::TextureFormat::Depth24PlusStencil8; + wgpu::Texture multisampledDepthStencilTexture = + CreateTexture(device, wgpu::TextureDimension::e2D, kDepthStencilFormat, kSize, kSize, + kArrayLayers, kLevelCount, kSampleCount); + wgpu::TextureView multisampledDepthStencilTextureView = multisampledDepthStencilTexture.CreateView(); // It is not allowed to use a depth stencil attachment whose sample count is different from the // one of the color attachment. { - dawn::Texture depthStencilTexture = CreateTexture( - device, dawn::TextureDimension::e2D, kDepthStencilFormat, kSize, kSize, kArrayLayers, - kLevelCount); - dawn::TextureView depthStencilTextureView = depthStencilTexture.CreateView(); + wgpu::Texture depthStencilTexture = + CreateTexture(device, wgpu::TextureDimension::e2D, kDepthStencilFormat, kSize, kSize, + kArrayLayers, kLevelCount); + wgpu::TextureView depthStencilTextureView = depthStencilTexture.CreateView(); utils::ComboRenderPassDescriptor renderPass( {CreateMultisampledColorTextureView()}, depthStencilTextureView); diff --git a/src/tests/unittests/validation/RenderPassValidationTests.cpp b/src/tests/unittests/validation/RenderPassValidationTests.cpp index 573a301f4d..d0ee909b6d 100644 --- a/src/tests/unittests/validation/RenderPassValidationTests.cpp +++ b/src/tests/unittests/validation/RenderPassValidationTests.cpp @@ -25,7 +25,7 @@ class RenderPassValidationTest : public ValidationTest {}; // Test that it is invalid to draw in a render pass with missing bind groups TEST_F(RenderPassValidationTest, MissingBindGroup) { - dawn::ShaderModule vsModule = + wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, utils::SingleShaderStage::Vertex, R"( #version 450 layout (set = 0, binding = 0) uniform vertexUniformBuffer { @@ -36,7 +36,7 @@ void main() { gl_Position = vec4(transform * pos[gl_VertexIndex], 0.f, 1.f); })"); - dawn::ShaderModule fsModule = + wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, utils::SingleShaderStage::Fragment, R"( #version 450 layout (set = 1, binding = 0) uniform fragmentUniformBuffer { @@ -47,38 +47,38 @@ void main() { fragColor = color; })"); - dawn::BindGroupLayout bgls[] = { + wgpu::BindGroupLayout bgls[] = { utils::MakeBindGroupLayout( - device, {{0, dawn::ShaderStage::Vertex, dawn::BindingType::UniformBuffer}}), + device, {{0, wgpu::ShaderStage::Vertex, wgpu::BindingType::UniformBuffer}}), utils::MakeBindGroupLayout( - device, {{0, dawn::ShaderStage::Fragment, dawn::BindingType::UniformBuffer}})}; + device, {{0, wgpu::ShaderStage::Fragment, wgpu::BindingType::UniformBuffer}})}; - dawn::PipelineLayoutDescriptor pipelineLayoutDesc; + wgpu::PipelineLayoutDescriptor pipelineLayoutDesc; pipelineLayoutDesc.bindGroupLayoutCount = 2; pipelineLayoutDesc.bindGroupLayouts = bgls; - dawn::PipelineLayout pipelineLayout = device.CreatePipelineLayout(&pipelineLayoutDesc); + wgpu::PipelineLayout pipelineLayout = device.CreatePipelineLayout(&pipelineLayoutDesc); utils::ComboRenderPipelineDescriptor descriptor(device); descriptor.layout = pipelineLayout; descriptor.vertexStage.module = vsModule; descriptor.cFragmentStage.module = fsModule; - dawn::RenderPipeline pipeline = device.CreateRenderPipeline(&descriptor); + wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&descriptor); float data[4]; - dawn::Buffer buffer = - utils::CreateBufferFromData(device, data, 4 * sizeof(float), dawn::BufferUsage::Uniform); + wgpu::Buffer buffer = + utils::CreateBufferFromData(device, data, 4 * sizeof(float), wgpu::BufferUsage::Uniform); - dawn::BindGroup bg1 = + wgpu::BindGroup bg1 = utils::MakeBindGroup(device, bgls[0], {{0, buffer, 0, 4 * sizeof(float)}}); - dawn::BindGroup bg2 = + wgpu::BindGroup bg2 = utils::MakeBindGroup(device, bgls[1], {{0, buffer, 0, 4 * sizeof(float)}}); DummyRenderPass renderPass(device); { - dawn::CommandEncoder commandEncoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); pass.SetPipeline(pipeline); pass.SetBindGroup(0, bg1); pass.SetBindGroup(1, bg2); @@ -87,16 +87,16 @@ void main() { commandEncoder.Finish(); } { - dawn::CommandEncoder commandEncoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); pass.SetPipeline(pipeline); pass.Draw(3, 0, 0, 0); pass.EndPass(); ASSERT_DEVICE_ERROR(commandEncoder.Finish()); } { - dawn::CommandEncoder commandEncoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); pass.SetPipeline(pipeline); pass.SetBindGroup(1, bg2); pass.Draw(3, 0, 0, 0); @@ -104,8 +104,8 @@ void main() { ASSERT_DEVICE_ERROR(commandEncoder.Finish()); } { - dawn::CommandEncoder commandEncoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); + wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder pass = commandEncoder.BeginRenderPass(&renderPass); pass.SetPipeline(pipeline); pass.SetBindGroup(0, bg1); pass.Draw(3, 0, 0, 0); diff --git a/src/tests/unittests/validation/RenderPipelineValidationTests.cpp b/src/tests/unittests/validation/RenderPipelineValidationTests.cpp index f26a16cca4..08d063900c 100644 --- a/src/tests/unittests/validation/RenderPipelineValidationTests.cpp +++ b/src/tests/unittests/validation/RenderPipelineValidationTests.cpp @@ -39,8 +39,8 @@ class RenderPipelineValidationTest : public ValidationTest { })"); } - dawn::ShaderModule vsModule; - dawn::ShaderModule fsModule; + wgpu::ShaderModule vsModule; + wgpu::ShaderModule fsModule; }; // Test cases where creation should succeed @@ -100,7 +100,7 @@ TEST_F(RenderPipelineValidationTest, NonRenderableFormat) { utils::ComboRenderPipelineDescriptor descriptor(device); descriptor.vertexStage.module = vsModule; descriptor.cFragmentStage.module = fsModule; - descriptor.cColorStates[0].format = dawn::TextureFormat::RGBA8Unorm; + descriptor.cColorStates[0].format = wgpu::TextureFormat::RGBA8Unorm; device.CreateRenderPipeline(&descriptor); } @@ -110,7 +110,7 @@ TEST_F(RenderPipelineValidationTest, NonRenderableFormat) { utils::ComboRenderPipelineDescriptor descriptor(device); descriptor.vertexStage.module = vsModule; descriptor.cFragmentStage.module = fsModule; - descriptor.cColorStates[0].format = dawn::TextureFormat::RG11B10Float; + descriptor.cColorStates[0].format = wgpu::TextureFormat::RG11B10Float; ASSERT_DEVICE_ERROR(device.CreateRenderPipeline(&descriptor)); } @@ -120,9 +120,9 @@ TEST_F(RenderPipelineValidationTest, NonRenderableFormat) { TEST_F(RenderPipelineValidationTest, FragmentOutputFormatCompatibility) { constexpr uint32_t kNumTextureFormatBaseType = 3u; std::array kVecPreFix = {{"", "i", "u"}}; - std::array kColorFormats = { - {dawn::TextureFormat::RGBA8Unorm, dawn::TextureFormat::RGBA8Sint, - dawn::TextureFormat::RGBA8Uint}}; + std::array kColorFormats = { + {wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureFormat::RGBA8Sint, + wgpu::TextureFormat::RGBA8Uint}}; for (size_t i = 0; i < kNumTextureFormatBaseType; ++i) { for (size_t j = 0; j < kNumTextureFormatBaseType; ++j) { @@ -174,56 +174,56 @@ TEST_F(RenderPipelineValidationTest, SampleCount) { // in the render pass. TEST_F(RenderPipelineValidationTest, SampleCountCompatibilityWithRenderPass) { constexpr uint32_t kMultisampledCount = 4; - constexpr dawn::TextureFormat kColorFormat = dawn::TextureFormat::RGBA8Unorm; - constexpr dawn::TextureFormat kDepthStencilFormat = dawn::TextureFormat::Depth24PlusStencil8; + constexpr wgpu::TextureFormat kColorFormat = wgpu::TextureFormat::RGBA8Unorm; + constexpr wgpu::TextureFormat kDepthStencilFormat = wgpu::TextureFormat::Depth24PlusStencil8; - dawn::TextureDescriptor baseTextureDescriptor; + wgpu::TextureDescriptor baseTextureDescriptor; baseTextureDescriptor.size.width = 4; baseTextureDescriptor.size.height = 4; baseTextureDescriptor.size.depth = 1; baseTextureDescriptor.arrayLayerCount = 1; baseTextureDescriptor.mipLevelCount = 1; - baseTextureDescriptor.dimension = dawn::TextureDimension::e2D; - baseTextureDescriptor.usage = dawn::TextureUsage::OutputAttachment; + baseTextureDescriptor.dimension = wgpu::TextureDimension::e2D; + baseTextureDescriptor.usage = wgpu::TextureUsage::OutputAttachment; utils::ComboRenderPipelineDescriptor nonMultisampledPipelineDescriptor(device); nonMultisampledPipelineDescriptor.sampleCount = 1; nonMultisampledPipelineDescriptor.vertexStage.module = vsModule; nonMultisampledPipelineDescriptor.cFragmentStage.module = fsModule; - dawn::RenderPipeline nonMultisampledPipeline = + wgpu::RenderPipeline nonMultisampledPipeline = device.CreateRenderPipeline(&nonMultisampledPipelineDescriptor); nonMultisampledPipelineDescriptor.colorStateCount = 0; nonMultisampledPipelineDescriptor.depthStencilState = &nonMultisampledPipelineDescriptor.cDepthStencilState; - dawn::RenderPipeline nonMultisampledPipelineWithDepthStencilOnly = + wgpu::RenderPipeline nonMultisampledPipelineWithDepthStencilOnly = device.CreateRenderPipeline(&nonMultisampledPipelineDescriptor); utils::ComboRenderPipelineDescriptor multisampledPipelineDescriptor(device); multisampledPipelineDescriptor.sampleCount = kMultisampledCount; multisampledPipelineDescriptor.vertexStage.module = vsModule; multisampledPipelineDescriptor.cFragmentStage.module = fsModule; - dawn::RenderPipeline multisampledPipeline = + wgpu::RenderPipeline multisampledPipeline = device.CreateRenderPipeline(&multisampledPipelineDescriptor); multisampledPipelineDescriptor.colorStateCount = 0; multisampledPipelineDescriptor.depthStencilState = &multisampledPipelineDescriptor.cDepthStencilState; - dawn::RenderPipeline multisampledPipelineWithDepthStencilOnly = + wgpu::RenderPipeline multisampledPipelineWithDepthStencilOnly = device.CreateRenderPipeline(&multisampledPipelineDescriptor); // It is not allowed to use multisampled render pass and non-multisampled render pipeline. { { - dawn::TextureDescriptor textureDescriptor = baseTextureDescriptor; + wgpu::TextureDescriptor textureDescriptor = baseTextureDescriptor; textureDescriptor.format = kColorFormat; textureDescriptor.sampleCount = kMultisampledCount; - dawn::Texture multisampledColorTexture = device.CreateTexture(&textureDescriptor); + wgpu::Texture multisampledColorTexture = device.CreateTexture(&textureDescriptor); utils::ComboRenderPassDescriptor renderPassDescriptor( {multisampledColorTexture.CreateView()}); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder renderPass = encoder.BeginRenderPass(&renderPassDescriptor); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder renderPass = encoder.BeginRenderPass(&renderPassDescriptor); renderPass.SetPipeline(nonMultisampledPipeline); renderPass.EndPass(); @@ -231,16 +231,16 @@ TEST_F(RenderPipelineValidationTest, SampleCountCompatibilityWithRenderPass) { } { - dawn::TextureDescriptor textureDescriptor = baseTextureDescriptor; + wgpu::TextureDescriptor textureDescriptor = baseTextureDescriptor; textureDescriptor.sampleCount = kMultisampledCount; textureDescriptor.format = kDepthStencilFormat; - dawn::Texture multisampledDepthStencilTexture = + wgpu::Texture multisampledDepthStencilTexture = device.CreateTexture(&textureDescriptor); utils::ComboRenderPassDescriptor renderPassDescriptor( {}, multisampledDepthStencilTexture.CreateView()); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder renderPass = encoder.BeginRenderPass(&renderPassDescriptor); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder renderPass = encoder.BeginRenderPass(&renderPassDescriptor); renderPass.SetPipeline(nonMultisampledPipelineWithDepthStencilOnly); renderPass.EndPass(); @@ -251,15 +251,15 @@ TEST_F(RenderPipelineValidationTest, SampleCountCompatibilityWithRenderPass) { // It is allowed to use multisampled render pass and multisampled render pipeline. { { - dawn::TextureDescriptor textureDescriptor = baseTextureDescriptor; + wgpu::TextureDescriptor textureDescriptor = baseTextureDescriptor; textureDescriptor.format = kColorFormat; textureDescriptor.sampleCount = kMultisampledCount; - dawn::Texture multisampledColorTexture = device.CreateTexture(&textureDescriptor); + wgpu::Texture multisampledColorTexture = device.CreateTexture(&textureDescriptor); utils::ComboRenderPassDescriptor renderPassDescriptor( {multisampledColorTexture.CreateView()}); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder renderPass = encoder.BeginRenderPass(&renderPassDescriptor); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder renderPass = encoder.BeginRenderPass(&renderPassDescriptor); renderPass.SetPipeline(multisampledPipeline); renderPass.EndPass(); @@ -267,16 +267,16 @@ TEST_F(RenderPipelineValidationTest, SampleCountCompatibilityWithRenderPass) { } { - dawn::TextureDescriptor textureDescriptor = baseTextureDescriptor; + wgpu::TextureDescriptor textureDescriptor = baseTextureDescriptor; textureDescriptor.sampleCount = kMultisampledCount; textureDescriptor.format = kDepthStencilFormat; - dawn::Texture multisampledDepthStencilTexture = + wgpu::Texture multisampledDepthStencilTexture = device.CreateTexture(&textureDescriptor); utils::ComboRenderPassDescriptor renderPassDescriptor( {}, multisampledDepthStencilTexture.CreateView()); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder renderPass = encoder.BeginRenderPass(&renderPassDescriptor); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder renderPass = encoder.BeginRenderPass(&renderPassDescriptor); renderPass.SetPipeline(multisampledPipelineWithDepthStencilOnly); renderPass.EndPass(); @@ -287,15 +287,15 @@ TEST_F(RenderPipelineValidationTest, SampleCountCompatibilityWithRenderPass) { // It is not allowed to use non-multisampled render pass and multisampled render pipeline. { { - dawn::TextureDescriptor textureDescriptor = baseTextureDescriptor; + wgpu::TextureDescriptor textureDescriptor = baseTextureDescriptor; textureDescriptor.format = kColorFormat; textureDescriptor.sampleCount = 1; - dawn::Texture nonMultisampledColorTexture = device.CreateTexture(&textureDescriptor); + wgpu::Texture nonMultisampledColorTexture = device.CreateTexture(&textureDescriptor); utils::ComboRenderPassDescriptor nonMultisampledRenderPassDescriptor( {nonMultisampledColorTexture.CreateView()}); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder renderPass = + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder renderPass = encoder.BeginRenderPass(&nonMultisampledRenderPassDescriptor); renderPass.SetPipeline(multisampledPipeline); renderPass.EndPass(); @@ -304,16 +304,16 @@ TEST_F(RenderPipelineValidationTest, SampleCountCompatibilityWithRenderPass) { } { - dawn::TextureDescriptor textureDescriptor = baseTextureDescriptor; + wgpu::TextureDescriptor textureDescriptor = baseTextureDescriptor; textureDescriptor.sampleCount = 1; textureDescriptor.format = kDepthStencilFormat; - dawn::Texture multisampledDepthStencilTexture = + wgpu::Texture multisampledDepthStencilTexture = device.CreateTexture(&textureDescriptor); utils::ComboRenderPassDescriptor renderPassDescriptor( {}, multisampledDepthStencilTexture.CreateView()); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); - dawn::RenderPassEncoder renderPass = encoder.BeginRenderPass(&renderPassDescriptor); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::RenderPassEncoder renderPass = encoder.BeginRenderPass(&renderPassDescriptor); renderPass.SetPipeline(multisampledPipelineWithDepthStencilOnly); renderPass.EndPass(); diff --git a/src/tests/unittests/validation/SamplerValidationTests.cpp b/src/tests/unittests/validation/SamplerValidationTests.cpp index ed79f31ec0..e262536500 100644 --- a/src/tests/unittests/validation/SamplerValidationTests.cpp +++ b/src/tests/unittests/validation/SamplerValidationTests.cpp @@ -25,22 +25,22 @@ namespace { // Test NaN and INFINITY values are not allowed TEST_F(SamplerValidationTest, InvalidLOD) { { - dawn::SamplerDescriptor samplerDesc = utils::GetDefaultSamplerDescriptor(); + wgpu::SamplerDescriptor samplerDesc = utils::GetDefaultSamplerDescriptor(); samplerDesc.lodMinClamp = NAN; ASSERT_DEVICE_ERROR(device.CreateSampler(&samplerDesc)); } { - dawn::SamplerDescriptor samplerDesc = utils::GetDefaultSamplerDescriptor(); + wgpu::SamplerDescriptor samplerDesc = utils::GetDefaultSamplerDescriptor(); samplerDesc.lodMaxClamp = NAN; ASSERT_DEVICE_ERROR(device.CreateSampler(&samplerDesc)); } { - dawn::SamplerDescriptor samplerDesc = utils::GetDefaultSamplerDescriptor(); + wgpu::SamplerDescriptor samplerDesc = utils::GetDefaultSamplerDescriptor(); samplerDesc.lodMinClamp = INFINITY; ASSERT_DEVICE_ERROR(device.CreateSampler(&samplerDesc)); } { - dawn::SamplerDescriptor samplerDesc = utils::GetDefaultSamplerDescriptor(); + wgpu::SamplerDescriptor samplerDesc = utils::GetDefaultSamplerDescriptor(); samplerDesc.lodMaxClamp = INFINITY; ASSERT_DEVICE_ERROR(device.CreateSampler(&samplerDesc)); } diff --git a/src/tests/unittests/validation/TextureValidationTests.cpp b/src/tests/unittests/validation/TextureValidationTests.cpp index 7f46602aed..9e2488f333 100644 --- a/src/tests/unittests/validation/TextureValidationTests.cpp +++ b/src/tests/unittests/validation/TextureValidationTests.cpp @@ -22,21 +22,21 @@ namespace { class TextureValidationTest : public ValidationTest { protected: - dawn::TextureDescriptor CreateDefaultTextureDescriptor() { - dawn::TextureDescriptor descriptor; + wgpu::TextureDescriptor CreateDefaultTextureDescriptor() { + wgpu::TextureDescriptor descriptor; descriptor.size.width = kWidth; descriptor.size.height = kHeight; descriptor.size.depth = 1; descriptor.arrayLayerCount = kDefaultArraySize; descriptor.mipLevelCount = kDefaultMipLevels; descriptor.sampleCount = kDefaultSampleCount; - descriptor.dimension = dawn::TextureDimension::e2D; + descriptor.dimension = wgpu::TextureDimension::e2D; descriptor.format = kDefaultTextureFormat; - descriptor.usage = dawn::TextureUsage::OutputAttachment | dawn::TextureUsage::Sampled; + descriptor.usage = wgpu::TextureUsage::OutputAttachment | wgpu::TextureUsage::Sampled; return descriptor; } - dawn::Queue queue = device.CreateQueue(); + wgpu::Queue queue = device.CreateQueue(); private: static constexpr uint32_t kWidth = 32; @@ -45,16 +45,16 @@ class TextureValidationTest : public ValidationTest { static constexpr uint32_t kDefaultMipLevels = 1; static constexpr uint32_t kDefaultSampleCount = 1; - static constexpr dawn::TextureFormat kDefaultTextureFormat = dawn::TextureFormat::RGBA8Unorm; + static constexpr wgpu::TextureFormat kDefaultTextureFormat = wgpu::TextureFormat::RGBA8Unorm; }; // Test the validation of sample count TEST_F(TextureValidationTest, SampleCount) { - dawn::TextureDescriptor defaultDescriptor = CreateDefaultTextureDescriptor(); + wgpu::TextureDescriptor defaultDescriptor = CreateDefaultTextureDescriptor(); // sampleCount == 1 is allowed. { - dawn::TextureDescriptor descriptor = defaultDescriptor; + wgpu::TextureDescriptor descriptor = defaultDescriptor; descriptor.sampleCount = 1; device.CreateTexture(&descriptor); @@ -62,7 +62,7 @@ TEST_F(TextureValidationTest, SampleCount) { // sampleCount == 4 is allowed. { - dawn::TextureDescriptor descriptor = defaultDescriptor; + wgpu::TextureDescriptor descriptor = defaultDescriptor; descriptor.sampleCount = 4; device.CreateTexture(&descriptor); @@ -70,7 +70,7 @@ TEST_F(TextureValidationTest, SampleCount) { // It is an error to create a texture with an invalid sampleCount. { - dawn::TextureDescriptor descriptor = defaultDescriptor; + wgpu::TextureDescriptor descriptor = defaultDescriptor; descriptor.sampleCount = 3; ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor)); @@ -78,7 +78,7 @@ TEST_F(TextureValidationTest, SampleCount) { // It is an error to create a multisampled texture with mipLevelCount > 1. { - dawn::TextureDescriptor descriptor = defaultDescriptor; + wgpu::TextureDescriptor descriptor = defaultDescriptor; descriptor.sampleCount = 4; descriptor.mipLevelCount = 2; @@ -87,7 +87,7 @@ TEST_F(TextureValidationTest, SampleCount) { // Currently we do not support multisampled 2D array textures. { - dawn::TextureDescriptor descriptor = defaultDescriptor; + wgpu::TextureDescriptor descriptor = defaultDescriptor; descriptor.sampleCount = 4; descriptor.arrayLayerCount = 2; @@ -97,11 +97,11 @@ TEST_F(TextureValidationTest, SampleCount) { // Test the validation of the mip level count TEST_F(TextureValidationTest, MipLevelCount) { - dawn::TextureDescriptor defaultDescriptor = CreateDefaultTextureDescriptor(); + wgpu::TextureDescriptor defaultDescriptor = CreateDefaultTextureDescriptor(); // mipLevelCount == 1 is allowed { - dawn::TextureDescriptor descriptor = defaultDescriptor; + wgpu::TextureDescriptor descriptor = defaultDescriptor; descriptor.size.width = 32; descriptor.size.height = 32; descriptor.mipLevelCount = 1; @@ -111,7 +111,7 @@ TEST_F(TextureValidationTest, MipLevelCount) { // mipLevelCount == 0 is an error { - dawn::TextureDescriptor descriptor = defaultDescriptor; + wgpu::TextureDescriptor descriptor = defaultDescriptor; descriptor.size.width = 32; descriptor.size.height = 32; descriptor.mipLevelCount = 0; @@ -121,7 +121,7 @@ TEST_F(TextureValidationTest, MipLevelCount) { // Full mip chains are allowed { - dawn::TextureDescriptor descriptor = defaultDescriptor; + wgpu::TextureDescriptor descriptor = defaultDescriptor; descriptor.size.width = 32; descriptor.size.height = 32; // Mip level sizes: 32, 16, 8, 4, 2, 1 @@ -132,7 +132,7 @@ TEST_F(TextureValidationTest, MipLevelCount) { // Too big mip chains on width are disallowed { - dawn::TextureDescriptor descriptor = defaultDescriptor; + wgpu::TextureDescriptor descriptor = defaultDescriptor; descriptor.size.width = 31; descriptor.size.height = 32; // Mip level width: 31, 15, 7, 3, 1, 1 @@ -143,7 +143,7 @@ TEST_F(TextureValidationTest, MipLevelCount) { // Too big mip chains on height are disallowed { - dawn::TextureDescriptor descriptor = defaultDescriptor; + wgpu::TextureDescriptor descriptor = defaultDescriptor; descriptor.size.width = 32; descriptor.size.height = 31; // Mip level height: 31, 15, 7, 3, 1, 1 @@ -154,7 +154,7 @@ TEST_F(TextureValidationTest, MipLevelCount) { // Undefined shift check if miplevel is bigger than the integer bit width. { - dawn::TextureDescriptor descriptor = defaultDescriptor; + wgpu::TextureDescriptor descriptor = defaultDescriptor; descriptor.size.width = 32; descriptor.size.height = 32; descriptor.mipLevelCount = 100; @@ -164,7 +164,7 @@ TEST_F(TextureValidationTest, MipLevelCount) { // Non square mip map halves the resolution until a 1x1 dimension. { - dawn::TextureDescriptor descriptor = defaultDescriptor; + wgpu::TextureDescriptor descriptor = defaultDescriptor; descriptor.size.width = 32; descriptor.size.height = 8; // Mip maps: 32 * 8, 16 * 4, 8 * 2, 4 * 1, 2 * 1, 1 * 1 @@ -176,15 +176,15 @@ TEST_F(TextureValidationTest, MipLevelCount) { // Test that it is valid to destroy a texture TEST_F(TextureValidationTest, DestroyTexture) { - dawn::TextureDescriptor descriptor = CreateDefaultTextureDescriptor(); - dawn::Texture texture = device.CreateTexture(&descriptor); + wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor(); + wgpu::Texture texture = device.CreateTexture(&descriptor); texture.Destroy(); } // Test that it's valid to destroy a destroyed texture TEST_F(TextureValidationTest, DestroyDestroyedTexture) { - dawn::TextureDescriptor descriptor = CreateDefaultTextureDescriptor(); - dawn::Texture texture = device.CreateTexture(&descriptor); + wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor(); + wgpu::Texture texture = device.CreateTexture(&descriptor); texture.Destroy(); texture.Destroy(); } @@ -192,21 +192,21 @@ TEST_F(TextureValidationTest, DestroyDestroyedTexture) { // Test that it's invalid to submit a destroyed texture in a queue // in the case of destroy, encode, submit TEST_F(TextureValidationTest, DestroyEncodeSubmit) { - dawn::TextureDescriptor descriptor = CreateDefaultTextureDescriptor(); - dawn::Texture texture = device.CreateTexture(&descriptor); - dawn::TextureView textureView = texture.CreateView(); + wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor(); + wgpu::Texture texture = device.CreateTexture(&descriptor); + wgpu::TextureView textureView = texture.CreateView(); utils::ComboRenderPassDescriptor renderPass({textureView}); // Destroy the texture texture.Destroy(); - dawn::CommandEncoder encoder_post_destroy = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder_post_destroy = device.CreateCommandEncoder(); { - dawn::RenderPassEncoder pass = encoder_post_destroy.BeginRenderPass(&renderPass); + wgpu::RenderPassEncoder pass = encoder_post_destroy.BeginRenderPass(&renderPass); pass.EndPass(); } - dawn::CommandBuffer commands = encoder_post_destroy.Finish(); + wgpu::CommandBuffer commands = encoder_post_destroy.Finish(); // Submit should fail due to destroyed texture ASSERT_DEVICE_ERROR(queue.Submit(1, &commands)); @@ -215,18 +215,18 @@ TEST_F(TextureValidationTest, DestroyEncodeSubmit) { // Test that it's invalid to submit a destroyed texture in a queue // in the case of encode, destroy, submit TEST_F(TextureValidationTest, EncodeDestroySubmit) { - dawn::TextureDescriptor descriptor = CreateDefaultTextureDescriptor(); - dawn::Texture texture = device.CreateTexture(&descriptor); - dawn::TextureView textureView = texture.CreateView(); + wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor(); + wgpu::Texture texture = device.CreateTexture(&descriptor); + wgpu::TextureView textureView = texture.CreateView(); utils::ComboRenderPassDescriptor renderPass({textureView}); - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); { - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); pass.EndPass(); } - dawn::CommandBuffer commands = encoder.Finish(); + wgpu::CommandBuffer commands = encoder.Finish(); // Destroy the texture texture.Destroy(); @@ -237,20 +237,22 @@ TEST_F(TextureValidationTest, EncodeDestroySubmit) { // Test it is an error to create an OutputAttachment texture with a non-renderable format. TEST_F(TextureValidationTest, NonRenderableAndOutputAttachment) { - dawn::TextureDescriptor descriptor; + wgpu::TextureDescriptor descriptor; descriptor.size = {1, 1, 1}; - descriptor.usage = dawn::TextureUsage::OutputAttachment; + descriptor.usage = wgpu::TextureUsage::OutputAttachment; // Succeeds because RGBA8Unorm is renderable - descriptor.format = dawn::TextureFormat::RGBA8Unorm; + descriptor.format = wgpu::TextureFormat::RGBA8Unorm; device.CreateTexture(&descriptor); - dawn::TextureFormat nonRenderableFormats[] = { - dawn::TextureFormat::RG11B10Float, dawn::TextureFormat::R8Snorm, - dawn::TextureFormat::RG8Snorm, dawn::TextureFormat::RGBA8Snorm, + wgpu::TextureFormat nonRenderableFormats[] = { + wgpu::TextureFormat::RG11B10Float, + wgpu::TextureFormat::R8Snorm, + wgpu::TextureFormat::RG8Snorm, + wgpu::TextureFormat::RGBA8Snorm, }; - for (dawn::TextureFormat format : nonRenderableFormats) { + for (wgpu::TextureFormat format : nonRenderableFormats) { // Fails because `format` is non-renderable descriptor.format = format; ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor)); @@ -259,8 +261,8 @@ TEST_F(TextureValidationTest, NonRenderableAndOutputAttachment) { // Test it is an error to create a texture with format "Undefined". TEST_F(TextureValidationTest, TextureFormatUndefined) { - dawn::TextureDescriptor descriptor = CreateDefaultTextureDescriptor(); - descriptor.format = dawn::TextureFormat::Undefined; + wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor(); + descriptor.format = wgpu::TextureFormat::Undefined; ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor)); } @@ -273,52 +275,52 @@ class CompressedTextureFormatsValidationTests : public TextureValidationTest { } protected: - dawn::TextureDescriptor CreateDefaultTextureDescriptor() { - dawn::TextureDescriptor descriptor = + wgpu::TextureDescriptor CreateDefaultTextureDescriptor() { + wgpu::TextureDescriptor descriptor = TextureValidationTest::CreateDefaultTextureDescriptor(); descriptor.usage = - dawn::TextureUsage::CopySrc | dawn::TextureUsage::CopyDst | dawn::TextureUsage::Sampled; + wgpu::TextureUsage::CopySrc | wgpu::TextureUsage::CopyDst | wgpu::TextureUsage::Sampled; return descriptor; } - const std::array kBCFormats = { - dawn::TextureFormat::BC1RGBAUnorm, dawn::TextureFormat::BC1RGBAUnormSrgb, - dawn::TextureFormat::BC2RGBAUnorm, dawn::TextureFormat::BC2RGBAUnormSrgb, - dawn::TextureFormat::BC3RGBAUnorm, dawn::TextureFormat::BC3RGBAUnormSrgb, - dawn::TextureFormat::BC4RUnorm, dawn::TextureFormat::BC4RSnorm, - dawn::TextureFormat::BC5RGUnorm, dawn::TextureFormat::BC5RGSnorm, - dawn::TextureFormat::BC6HRGBUfloat, dawn::TextureFormat::BC6HRGBSfloat, - dawn::TextureFormat::BC7RGBAUnorm, dawn::TextureFormat::BC7RGBAUnormSrgb}; + const std::array kBCFormats = { + wgpu::TextureFormat::BC1RGBAUnorm, wgpu::TextureFormat::BC1RGBAUnormSrgb, + wgpu::TextureFormat::BC2RGBAUnorm, wgpu::TextureFormat::BC2RGBAUnormSrgb, + wgpu::TextureFormat::BC3RGBAUnorm, wgpu::TextureFormat::BC3RGBAUnormSrgb, + wgpu::TextureFormat::BC4RUnorm, wgpu::TextureFormat::BC4RSnorm, + wgpu::TextureFormat::BC5RGUnorm, wgpu::TextureFormat::BC5RGSnorm, + wgpu::TextureFormat::BC6HRGBUfloat, wgpu::TextureFormat::BC6HRGBSfloat, + wgpu::TextureFormat::BC7RGBAUnorm, wgpu::TextureFormat::BC7RGBAUnormSrgb}; }; // Test the validation of texture size when creating textures in compressed texture formats. TEST_F(CompressedTextureFormatsValidationTests, TextureSize) { // Test that it is invalid to use a number that is not a multiple of 4 (the compressed block // width and height of all BC formats) as the width or height of textures in BC formats. - for (dawn::TextureFormat format : kBCFormats) { + for (wgpu::TextureFormat format : kBCFormats) { { - dawn::TextureDescriptor descriptor = CreateDefaultTextureDescriptor(); + wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor(); descriptor.format = format; ASSERT_TRUE(descriptor.size.width % 4 == 0 && descriptor.size.height % 4 == 0); device.CreateTexture(&descriptor); } { - dawn::TextureDescriptor descriptor = CreateDefaultTextureDescriptor(); + wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor(); descriptor.format = format; descriptor.size.width = 31; ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor)); } { - dawn::TextureDescriptor descriptor = CreateDefaultTextureDescriptor(); + wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor(); descriptor.format = format; descriptor.size.height = 31; ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor)); } { - dawn::TextureDescriptor descriptor = CreateDefaultTextureDescriptor(); + wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor(); descriptor.format = format; descriptor.size.width = 12; descriptor.size.height = 32; @@ -331,9 +333,9 @@ TEST_F(CompressedTextureFormatsValidationTests, TextureSize) { // is not enabled. TEST_F(CompressedTextureFormatsValidationTests, UseBCFormatWithoutEnablingExtension) { const std::vector kEmptyVector; - dawn::Device deviceWithoutExtension = CreateDeviceFromAdapter(adapter, kEmptyVector); - for (dawn::TextureFormat format : kBCFormats) { - dawn::TextureDescriptor descriptor = CreateDefaultTextureDescriptor(); + wgpu::Device deviceWithoutExtension = CreateDeviceFromAdapter(adapter, kEmptyVector); + for (wgpu::TextureFormat format : kBCFormats) { + wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor(); descriptor.format = format; ASSERT_DEVICE_ERROR(deviceWithoutExtension.CreateTexture(&descriptor)); } @@ -343,25 +345,25 @@ TEST_F(CompressedTextureFormatsValidationTests, UseBCFormatWithoutEnablingExtens TEST_F(CompressedTextureFormatsValidationTests, TextureUsage) { // Test that only CopySrc, CopyDst and Sampled are accepted as the texture usage of the // textures in BC formats. - for (dawn::TextureFormat format : kBCFormats) { + for (wgpu::TextureFormat format : kBCFormats) { { - dawn::TextureDescriptor descriptor = CreateDefaultTextureDescriptor(); + wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor(); descriptor.format = format; - descriptor.usage = dawn::TextureUsage::OutputAttachment; + descriptor.usage = wgpu::TextureUsage::OutputAttachment; ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor)); } { - dawn::TextureDescriptor descriptor = CreateDefaultTextureDescriptor(); + wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor(); descriptor.format = format; - descriptor.usage = dawn::TextureUsage::Storage; + descriptor.usage = wgpu::TextureUsage::Storage; ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor)); } { - dawn::TextureDescriptor descriptor = CreateDefaultTextureDescriptor(); + wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor(); descriptor.format = format; - descriptor.usage = dawn::TextureUsage::Present; + descriptor.usage = wgpu::TextureUsage::Present; ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor)); } } @@ -370,8 +372,8 @@ TEST_F(CompressedTextureFormatsValidationTests, TextureUsage) { // Test the validation of sample count when creating textures in compressed texture formats. TEST_F(CompressedTextureFormatsValidationTests, SampleCount) { // Test that it is invalid to specify SampleCount > 1 when we create a texture in BC formats. - for (dawn::TextureFormat format : kBCFormats) { - dawn::TextureDescriptor descriptor = CreateDefaultTextureDescriptor(); + for (wgpu::TextureFormat format : kBCFormats) { + wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor(); descriptor.format = format; descriptor.sampleCount = 4; ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor)); @@ -381,8 +383,8 @@ TEST_F(CompressedTextureFormatsValidationTests, SampleCount) { // Test the validation of creating 2D array textures in compressed texture formats. TEST_F(CompressedTextureFormatsValidationTests, 2DArrayTexture) { // Test that it is allowed to create a 2D array texture in BC formats. - for (dawn::TextureFormat format : kBCFormats) { - dawn::TextureDescriptor descriptor = CreateDefaultTextureDescriptor(); + for (wgpu::TextureFormat format : kBCFormats) { + wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor(); descriptor.format = format; descriptor.arrayLayerCount = 6; device.CreateTexture(&descriptor); diff --git a/src/tests/unittests/validation/TextureViewValidationTests.cpp b/src/tests/unittests/validation/TextureViewValidationTests.cpp index f68f46cfd3..f607184339 100644 --- a/src/tests/unittests/validation/TextureViewValidationTests.cpp +++ b/src/tests/unittests/validation/TextureViewValidationTests.cpp @@ -23,16 +23,16 @@ constexpr uint32_t kWidth = 32u; constexpr uint32_t kHeight = 32u; constexpr uint32_t kDefaultMipLevels = 6u; -constexpr dawn::TextureFormat kDefaultTextureFormat = dawn::TextureFormat::RGBA8Unorm; +constexpr wgpu::TextureFormat kDefaultTextureFormat = wgpu::TextureFormat::RGBA8Unorm; -dawn::Texture Create2DArrayTexture(dawn::Device& device, +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) { - dawn::TextureDescriptor descriptor; - descriptor.dimension = dawn::TextureDimension::e2D; + wgpu::TextureDescriptor descriptor; + descriptor.dimension = wgpu::TextureDimension::e2D; descriptor.size.width = width; descriptor.size.height = height; descriptor.size.depth = 1; @@ -40,12 +40,12 @@ dawn::Texture Create2DArrayTexture(dawn::Device& device, descriptor.sampleCount = sampleCount; descriptor.format = kDefaultTextureFormat; descriptor.mipLevelCount = mipLevelCount; - descriptor.usage = dawn::TextureUsage::Sampled; + descriptor.usage = wgpu::TextureUsage::Sampled; return device.CreateTexture(&descriptor); } -dawn::TextureViewDescriptor CreateDefaultViewDescriptor(dawn::TextureViewDimension dimension) { - dawn::TextureViewDescriptor descriptor; +wgpu::TextureViewDescriptor CreateDefaultViewDescriptor(wgpu::TextureViewDimension dimension) { + wgpu::TextureViewDescriptor descriptor; descriptor.format = kDefaultTextureFormat; descriptor.dimension = dimension; descriptor.baseMipLevel = 0; @@ -57,36 +57,36 @@ dawn::TextureViewDescriptor CreateDefaultViewDescriptor(dawn::TextureViewDimensi // Test creating texture view on a 2D non-array texture TEST_F(TextureViewValidationTest, CreateTextureViewOnTexture2D) { - dawn::Texture texture = Create2DArrayTexture(device, 1); + wgpu::Texture texture = Create2DArrayTexture(device, 1); - dawn::TextureViewDescriptor base2DTextureViewDescriptor = - CreateDefaultViewDescriptor(dawn::TextureViewDimension::e2D); + wgpu::TextureViewDescriptor base2DTextureViewDescriptor = + CreateDefaultViewDescriptor(wgpu::TextureViewDimension::e2D); // It is OK to create a 2D texture view on a 2D texture. { - dawn::TextureViewDescriptor descriptor = base2DTextureViewDescriptor; + wgpu::TextureViewDescriptor descriptor = base2DTextureViewDescriptor; descriptor.arrayLayerCount = 1; texture.CreateView(&descriptor); } // It is an error to view a layer past the end of the texture. { - dawn::TextureViewDescriptor descriptor = base2DTextureViewDescriptor; + 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. { - dawn::TextureViewDescriptor descriptor = base2DTextureViewDescriptor; - descriptor.dimension = dawn::TextureViewDimension::e2DArray; + wgpu::TextureViewDescriptor descriptor = base2DTextureViewDescriptor; + descriptor.dimension = wgpu::TextureViewDimension::e2DArray; descriptor.arrayLayerCount = 1; texture.CreateView(&descriptor); } // baseMipLevel == k && mipLevelCount == 0 means to use levels k..end. { - dawn::TextureViewDescriptor descriptor = base2DTextureViewDescriptor; + wgpu::TextureViewDescriptor descriptor = base2DTextureViewDescriptor; descriptor.mipLevelCount = 0; descriptor.baseMipLevel = 0; @@ -101,7 +101,7 @@ TEST_F(TextureViewValidationTest, CreateTextureViewOnTexture2D) { // It is an error to make the mip level out of range. { - dawn::TextureViewDescriptor descriptor = base2DTextureViewDescriptor; + wgpu::TextureViewDescriptor descriptor = base2DTextureViewDescriptor; descriptor.baseMipLevel = 0; descriptor.mipLevelCount = kDefaultMipLevels + 1; ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor)); @@ -121,29 +121,29 @@ TEST_F(TextureViewValidationTest, CreateTextureViewOnTexture2D) { TEST_F(TextureViewValidationTest, CreateTextureViewOnTexture2DArray) { constexpr uint32_t kDefaultArrayLayers = 6; - dawn::Texture texture = Create2DArrayTexture(device, kDefaultArrayLayers); + wgpu::Texture texture = Create2DArrayTexture(device, kDefaultArrayLayers); - dawn::TextureViewDescriptor base2DArrayTextureViewDescriptor = - CreateDefaultViewDescriptor(dawn::TextureViewDimension::e2DArray); + wgpu::TextureViewDescriptor base2DArrayTextureViewDescriptor = + CreateDefaultViewDescriptor(wgpu::TextureViewDimension::e2DArray); // It is OK to create a 2D texture view on a 2D array texture. { - dawn::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor; - descriptor.dimension = dawn::TextureViewDimension::e2D; + 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. { - dawn::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor; + wgpu::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor; descriptor.arrayLayerCount = kDefaultArrayLayers; texture.CreateView(&descriptor); } // baseArrayLayer == k && arrayLayerCount == 0 means to use layers k..end. { - dawn::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor; + wgpu::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor; descriptor.arrayLayerCount = 0; descriptor.baseArrayLayer = 0; @@ -158,7 +158,7 @@ TEST_F(TextureViewValidationTest, CreateTextureViewOnTexture2DArray) { // It is an error for the array layer range of the view to exceed that of the texture. { - dawn::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor; + wgpu::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor; descriptor.baseArrayLayer = 0; descriptor.arrayLayerCount = kDefaultArrayLayers + 1; ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor)); @@ -179,35 +179,35 @@ TEST_F(TextureViewValidationTest, CreateTextureViewOnTexture2DArray) { // Variant for a texture with more than 1 array layer. TEST_F(TextureViewValidationTest, TextureViewDescriptorDefaultsArray) { constexpr uint32_t kDefaultArrayLayers = 6; - dawn::Texture texture = Create2DArrayTexture(device, kDefaultArrayLayers); + wgpu::Texture texture = Create2DArrayTexture(device, kDefaultArrayLayers); { texture.CreateView(); } { - dawn::TextureViewDescriptor descriptor; - descriptor.format = dawn::TextureFormat::Undefined; + wgpu::TextureViewDescriptor descriptor; + descriptor.format = wgpu::TextureFormat::Undefined; texture.CreateView(&descriptor); - descriptor.format = dawn::TextureFormat::RGBA8Unorm; + descriptor.format = wgpu::TextureFormat::RGBA8Unorm; texture.CreateView(&descriptor); - descriptor.format = dawn::TextureFormat::R8Unorm; + descriptor.format = wgpu::TextureFormat::R8Unorm; ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor)); } { - dawn::TextureViewDescriptor descriptor; - descriptor.dimension = dawn::TextureViewDimension::Undefined; + wgpu::TextureViewDescriptor descriptor; + descriptor.dimension = wgpu::TextureViewDimension::Undefined; texture.CreateView(&descriptor); - descriptor.dimension = dawn::TextureViewDimension::e2DArray; + descriptor.dimension = wgpu::TextureViewDimension::e2DArray; texture.CreateView(&descriptor); - descriptor.dimension = dawn::TextureViewDimension::e2D; + descriptor.dimension = wgpu::TextureViewDimension::e2D; ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor)); } { - dawn::TextureViewDescriptor descriptor; + wgpu::TextureViewDescriptor descriptor; // Setting array layers to non-0 means the dimensionality will // default to 2D so by itself it causes an error. descriptor.arrayLayerCount = kDefaultArrayLayers; ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor)); - descriptor.dimension = dawn::TextureViewDimension::e2DArray; + descriptor.dimension = wgpu::TextureViewDimension::e2DArray; texture.CreateView(&descriptor); descriptor.mipLevelCount = kDefaultMipLevels; @@ -220,29 +220,29 @@ TEST_F(TextureViewValidationTest, TextureViewDescriptorDefaultsArray) { // Variant for a texture with only 1 array layer. TEST_F(TextureViewValidationTest, TextureViewDescriptorDefaultsNonArray) { constexpr uint32_t kDefaultArrayLayers = 1; - dawn::Texture texture = Create2DArrayTexture(device, kDefaultArrayLayers); + wgpu::Texture texture = Create2DArrayTexture(device, kDefaultArrayLayers); { texture.CreateView(); } { - dawn::TextureViewDescriptor descriptor; - descriptor.format = dawn::TextureFormat::Undefined; + wgpu::TextureViewDescriptor descriptor; + descriptor.format = wgpu::TextureFormat::Undefined; texture.CreateView(&descriptor); - descriptor.format = dawn::TextureFormat::RGBA8Unorm; + descriptor.format = wgpu::TextureFormat::RGBA8Unorm; texture.CreateView(&descriptor); - descriptor.format = dawn::TextureFormat::R8Unorm; + descriptor.format = wgpu::TextureFormat::R8Unorm; ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor)); } { - dawn::TextureViewDescriptor descriptor; - descriptor.dimension = dawn::TextureViewDimension::Undefined; + wgpu::TextureViewDescriptor descriptor; + descriptor.dimension = wgpu::TextureViewDimension::Undefined; texture.CreateView(&descriptor); - descriptor.dimension = dawn::TextureViewDimension::e2D; + descriptor.dimension = wgpu::TextureViewDimension::e2D; texture.CreateView(&descriptor); - descriptor.dimension = dawn::TextureViewDimension::e2DArray; + descriptor.dimension = wgpu::TextureViewDimension::e2DArray; texture.CreateView(&descriptor); } { - dawn::TextureViewDescriptor descriptor; + wgpu::TextureViewDescriptor descriptor; descriptor.arrayLayerCount = 0; texture.CreateView(&descriptor); descriptor.arrayLayerCount = 1; @@ -251,7 +251,7 @@ TEST_F(TextureViewValidationTest, TextureViewDescriptorDefaultsNonArray) { ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor)); } { - dawn::TextureViewDescriptor descriptor; + wgpu::TextureViewDescriptor descriptor; descriptor.mipLevelCount = kDefaultMipLevels; texture.CreateView(&descriptor); descriptor.arrayLayerCount = kDefaultArrayLayers; @@ -263,59 +263,59 @@ TEST_F(TextureViewValidationTest, TextureViewDescriptorDefaultsNonArray) { TEST_F(TextureViewValidationTest, CreateCubeMapTextureView) { constexpr uint32_t kDefaultArrayLayers = 16; - dawn::Texture texture = Create2DArrayTexture(device, kDefaultArrayLayers); + wgpu::Texture texture = Create2DArrayTexture(device, kDefaultArrayLayers); - dawn::TextureViewDescriptor base2DArrayTextureViewDescriptor = - CreateDefaultViewDescriptor(dawn::TextureViewDimension::e2DArray); + wgpu::TextureViewDescriptor base2DArrayTextureViewDescriptor = + CreateDefaultViewDescriptor(wgpu::TextureViewDimension::e2DArray); // It is OK to create a cube map texture view with arrayLayerCount == 6. { - dawn::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor; - descriptor.dimension = dawn::TextureViewDimension::Cube; + 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. { - dawn::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor; - descriptor.dimension = dawn::TextureViewDimension::Cube; + 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. { - dawn::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor; - descriptor.dimension = dawn::TextureViewDimension::CubeArray; + 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. { - dawn::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor; - descriptor.dimension = dawn::TextureViewDimension::CubeArray; + 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. { - dawn::Texture nonSquareTexture = Create2DArrayTexture(device, 18, 32, 16, 5); + wgpu::Texture nonSquareTexture = Create2DArrayTexture(device, 18, 32, 16, 5); - dawn::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor; - descriptor.dimension = dawn::TextureViewDimension::Cube; + 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. { - dawn::Texture nonSquareTexture = Create2DArrayTexture(device, 18, 32, 16, 5); + wgpu::Texture nonSquareTexture = Create2DArrayTexture(device, 18, 32, 16, 5); - dawn::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor; - descriptor.dimension = dawn::TextureViewDimension::CubeArray; + wgpu::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor; + descriptor.dimension = wgpu::TextureViewDimension::CubeArray; descriptor.arrayLayerCount = 12; ASSERT_DEVICE_ERROR(nonSquareTexture.CreateView(&descriptor)); } @@ -324,41 +324,41 @@ TEST_F(TextureViewValidationTest, CreateCubeMapTextureView) { // Test the format compatibility rules when creating a texture view. // TODO(jiawei.shao@intel.com): add more tests when the rules are fully implemented. TEST_F(TextureViewValidationTest, TextureViewFormatCompatibility) { - dawn::Texture texture = Create2DArrayTexture(device, 1); + wgpu::Texture texture = Create2DArrayTexture(device, 1); - dawn::TextureViewDescriptor base2DTextureViewDescriptor = - CreateDefaultViewDescriptor(dawn::TextureViewDimension::e2D); + wgpu::TextureViewDescriptor base2DTextureViewDescriptor = + CreateDefaultViewDescriptor(wgpu::TextureViewDimension::e2D); // It is an error to create a texture view in depth-stencil format on a RGBA texture. { - dawn::TextureViewDescriptor descriptor = base2DTextureViewDescriptor; - descriptor.format = dawn::TextureFormat::Depth24PlusStencil8; + wgpu::TextureViewDescriptor descriptor = base2DTextureViewDescriptor; + descriptor.format = wgpu::TextureFormat::Depth24PlusStencil8; ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor)); } } // Test that it's invalid to create a texture view from a destroyed texture TEST_F(TextureViewValidationTest, DestroyCreateTextureView) { - dawn::Texture texture = Create2DArrayTexture(device, 1); - dawn::TextureViewDescriptor descriptor = - CreateDefaultViewDescriptor(dawn::TextureViewDimension::e2D); + wgpu::Texture texture = Create2DArrayTexture(device, 1); + wgpu::TextureViewDescriptor descriptor = + CreateDefaultViewDescriptor(wgpu::TextureViewDimension::e2D); texture.Destroy(); ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor)); } // Test that only TextureAspect::All is supported TEST_F(TextureViewValidationTest, AspectMustBeAll) { - dawn::TextureDescriptor descriptor = {}; + wgpu::TextureDescriptor descriptor = {}; descriptor.size = {1, 1, 1}; - descriptor.format = dawn::TextureFormat::Depth32Float; - descriptor.usage = dawn::TextureUsage::Sampled | dawn::TextureUsage::OutputAttachment; - dawn::Texture texture = device.CreateTexture(&descriptor); + descriptor.format = wgpu::TextureFormat::Depth32Float; + descriptor.usage = wgpu::TextureUsage::Sampled | wgpu::TextureUsage::OutputAttachment; + wgpu::Texture texture = device.CreateTexture(&descriptor); - dawn::TextureViewDescriptor viewDescriptor = {}; - viewDescriptor.aspect = dawn::TextureAspect::All; + wgpu::TextureViewDescriptor viewDescriptor = {}; + viewDescriptor.aspect = wgpu::TextureAspect::All; texture.CreateView(&viewDescriptor); - viewDescriptor.aspect = dawn::TextureAspect::DepthOnly; + viewDescriptor.aspect = wgpu::TextureAspect::DepthOnly; ASSERT_DEVICE_ERROR(texture.CreateView(&viewDescriptor)); } diff --git a/src/tests/unittests/validation/ToggleValidationTests.cpp b/src/tests/unittests/validation/ToggleValidationTests.cpp index 82b973c71a..950c889814 100644 --- a/src/tests/unittests/validation/ToggleValidationTests.cpp +++ b/src/tests/unittests/validation/ToggleValidationTests.cpp @@ -47,7 +47,7 @@ TEST_F(ToggleValidationTest, OverrideToggleUsage) { dawn_native::DeviceDescriptor descriptor; descriptor.forceEnabledToggles.push_back(kValidToggleName); - DawnDevice deviceWithToggle = adapter.CreateDevice(&descriptor); + WGPUDevice deviceWithToggle = adapter.CreateDevice(&descriptor); std::vector toggleNames = dawn_native::GetTogglesUsed(deviceWithToggle); bool validToggleExists = false; for (const char* toggle : toggleNames) { @@ -64,7 +64,7 @@ TEST_F(ToggleValidationTest, OverrideToggleUsage) { dawn_native::DeviceDescriptor descriptor; descriptor.forceEnabledToggles.push_back(kInvalidToggleName); - DawnDevice deviceWithToggle = adapter.CreateDevice(&descriptor); + WGPUDevice deviceWithToggle = adapter.CreateDevice(&descriptor); std::vector toggleNames = dawn_native::GetTogglesUsed(deviceWithToggle); bool InvalidToggleExists = false; for (const char* toggle : toggleNames) { @@ -81,7 +81,7 @@ TEST_F(ToggleValidationTest, TurnOffVsyncWithToggle) { dawn_native::DeviceDescriptor descriptor; descriptor.forceEnabledToggles.push_back(kValidToggleName); - DawnDevice deviceWithToggle = adapter.CreateDevice(&descriptor); + WGPUDevice deviceWithToggle = adapter.CreateDevice(&descriptor); std::vector toggleNames = dawn_native::GetTogglesUsed(deviceWithToggle); bool validToggleExists = false; for (const char* toggle : toggleNames) { diff --git a/src/tests/unittests/validation/ValidationTest.cpp b/src/tests/unittests/validation/ValidationTest.cpp index d2b82f0e22..957a859c44 100644 --- a/src/tests/unittests/validation/ValidationTest.cpp +++ b/src/tests/unittests/validation/ValidationTest.cpp @@ -15,8 +15,8 @@ #include "tests/unittests/validation/ValidationTest.h" #include "common/Assert.h" -#include "dawn/dawn.h" #include "dawn/dawn_proc.h" +#include "dawn/webgpu.h" #include "dawn_native/NullBackend.h" ValidationTest::ValidationTest() { @@ -43,18 +43,18 @@ ValidationTest::ValidationTest() { device = CreateDeviceFromAdapter(adapter, std::vector()); } -dawn::Device ValidationTest::CreateDeviceFromAdapter( +wgpu::Device ValidationTest::CreateDeviceFromAdapter( dawn_native::Adapter adapterToTest, const std::vector& requiredExtensions) { - dawn::Device deviceToTest; + wgpu::Device deviceToTest; // Always keep the code path to test creating a device without a device descriptor. if (requiredExtensions.empty()) { - deviceToTest = dawn::Device::Acquire(adapterToTest.CreateDevice()); + deviceToTest = wgpu::Device::Acquire(adapterToTest.CreateDevice()); } else { dawn_native::DeviceDescriptor descriptor; descriptor.requiredExtensions = requiredExtensions; - deviceToTest = dawn::Device::Acquire(adapterToTest.CreateDevice(&descriptor)); + deviceToTest = wgpu::Device::Acquire(adapterToTest.CreateDevice(&descriptor)); } deviceToTest.SetUncapturedErrorCallback(ValidationTest::OnDeviceError, this); @@ -64,7 +64,7 @@ dawn::Device ValidationTest::CreateDeviceFromAdapter( ValidationTest::~ValidationTest() { // We need to destroy Dawn objects before setting the procs to null otherwise the dawn*Release // will call a nullptr - device = dawn::Device(); + device = wgpu::Device(); dawnProcSetProcs(nullptr); } @@ -85,8 +85,8 @@ std::string ValidationTest::GetLastDeviceErrorMessage() const { } // static -void ValidationTest::OnDeviceError(DawnErrorType type, const char* message, void* userdata) { - ASSERT(type != DAWN_ERROR_TYPE_NO_ERROR); +void ValidationTest::OnDeviceError(WGPUErrorType type, const char* message, void* userdata) { + ASSERT(type != WGPUErrorType_NoError); auto self = static_cast(userdata); self->mDeviceErrorMessage = message; @@ -95,10 +95,10 @@ void ValidationTest::OnDeviceError(DawnErrorType type, const char* message, void self->mError = true; } -ValidationTest::DummyRenderPass::DummyRenderPass(const dawn::Device& device) - : attachmentFormat(dawn::TextureFormat::RGBA8Unorm), width(400), height(400) { - dawn::TextureDescriptor descriptor; - descriptor.dimension = dawn::TextureDimension::e2D; +ValidationTest::DummyRenderPass::DummyRenderPass(const wgpu::Device& device) + : attachmentFormat(wgpu::TextureFormat::RGBA8Unorm), width(400), height(400) { + wgpu::TextureDescriptor descriptor; + descriptor.dimension = wgpu::TextureDimension::e2D; descriptor.size.width = width; descriptor.size.height = height; descriptor.size.depth = 1; @@ -106,15 +106,15 @@ ValidationTest::DummyRenderPass::DummyRenderPass(const dawn::Device& device) descriptor.sampleCount = 1; descriptor.format = attachmentFormat; descriptor.mipLevelCount = 1; - descriptor.usage = dawn::TextureUsage::OutputAttachment; + descriptor.usage = wgpu::TextureUsage::OutputAttachment; attachment = device.CreateTexture(&descriptor); - dawn::TextureView view = attachment.CreateView(); + wgpu::TextureView view = attachment.CreateView(); mColorAttachment.attachment = view; mColorAttachment.resolveTarget = nullptr; mColorAttachment.clearColor = { 0.0f, 0.0f, 0.0f, 0.0f }; - mColorAttachment.loadOp = dawn::LoadOp::Clear; - mColorAttachment.storeOp = dawn::StoreOp::Store; + mColorAttachment.loadOp = wgpu::LoadOp::Clear; + mColorAttachment.storeOp = wgpu::StoreOp::Store; colorAttachmentCount = 1; colorAttachments = &mColorAttachment; diff --git a/src/tests/unittests/validation/ValidationTest.h b/src/tests/unittests/validation/ValidationTest.h index e4a266da8b..8994784546 100644 --- a/src/tests/unittests/validation/ValidationTest.h +++ b/src/tests/unittests/validation/ValidationTest.h @@ -15,9 +15,9 @@ #ifndef TESTS_UNITTESTS_VALIDATIONTEST_H_ #define TESTS_UNITTESTS_VALIDATIONTEST_H_ -#include "gtest/gtest.h" -#include "dawn/dawncpp.h" +#include "dawn/webgpu_cpp.h" #include "dawn_native/DawnNative.h" +#include "gtest/gtest.h" #define ASSERT_DEVICE_ERROR(statement) \ StartExpectDeviceError(); \ @@ -29,7 +29,7 @@ class ValidationTest : public testing::Test { ValidationTest(); ~ValidationTest(); - dawn::Device CreateDeviceFromAdapter(dawn_native::Adapter adapter, + wgpu::Device CreateDeviceFromAdapter(dawn_native::Adapter adapter, const std::vector& requiredExtensions); void TearDown() override; @@ -40,25 +40,25 @@ class ValidationTest : public testing::Test { // Helper functions to create objects to test validation. - struct DummyRenderPass : public dawn::RenderPassDescriptor { + struct DummyRenderPass : public wgpu::RenderPassDescriptor { public: - DummyRenderPass(const dawn::Device& device); - dawn::Texture attachment; - dawn::TextureFormat attachmentFormat; + DummyRenderPass(const wgpu::Device& device); + wgpu::Texture attachment; + wgpu::TextureFormat attachmentFormat; uint32_t width; uint32_t height; private: - dawn::RenderPassColorAttachmentDescriptor mColorAttachment; + wgpu::RenderPassColorAttachmentDescriptor mColorAttachment; }; protected: - dawn::Device device; + wgpu::Device device; dawn_native::Adapter adapter; std::unique_ptr instance; private: - static void OnDeviceError(DawnErrorType type, const char* message, void* userdata); + static void OnDeviceError(WGPUErrorType type, const char* message, void* userdata); std::string mDeviceErrorMessage; bool mExpectError = false; bool mError = false; diff --git a/src/tests/unittests/validation/VertexBufferValidationTests.cpp b/src/tests/unittests/validation/VertexBufferValidationTests.cpp index 6e0ebbed49..178a4ec335 100644 --- a/src/tests/unittests/validation/VertexBufferValidationTests.cpp +++ b/src/tests/unittests/validation/VertexBufferValidationTests.cpp @@ -32,15 +32,15 @@ class VertexBufferValidationTest : public ValidationTest { })"); } - dawn::Buffer MakeVertexBuffer() { - dawn::BufferDescriptor descriptor; + wgpu::Buffer MakeVertexBuffer() { + wgpu::BufferDescriptor descriptor; descriptor.size = 256; - descriptor.usage = dawn::BufferUsage::Vertex; + descriptor.usage = wgpu::BufferUsage::Vertex; return device.CreateBuffer(&descriptor); } - dawn::ShaderModule MakeVertexShader(unsigned int bufferCount) { + wgpu::ShaderModule MakeVertexShader(unsigned int bufferCount) { std::ostringstream vs; vs << "#version 450\n"; for (unsigned int i = 0; i < bufferCount; ++i) { @@ -63,7 +63,7 @@ class VertexBufferValidationTest : public ValidationTest { vs.str().c_str()); } - dawn::RenderPipeline MakeRenderPipeline(const dawn::ShaderModule& vsModule, + wgpu::RenderPipeline MakeRenderPipeline(const wgpu::ShaderModule& vsModule, unsigned int bufferCount) { utils::ComboRenderPipelineDescriptor descriptor(device); descriptor.vertexStage.module = vsModule; @@ -74,14 +74,14 @@ class VertexBufferValidationTest : public ValidationTest { descriptor.cVertexInput.cBuffers[i].attributes = &descriptor.cVertexInput.cAttributes[i]; descriptor.cVertexInput.cAttributes[i].shaderLocation = i; - descriptor.cVertexInput.cAttributes[i].format = dawn::VertexFormat::Float3; + descriptor.cVertexInput.cAttributes[i].format = wgpu::VertexFormat::Float3; } descriptor.cVertexInput.bufferCount = bufferCount; return device.CreateRenderPipeline(&descriptor); } - dawn::ShaderModule fsModule; + wgpu::ShaderModule fsModule; }; TEST_F(VertexBufferValidationTest, VertexBuffersInheritedBetweenPipelines) { @@ -96,9 +96,9 @@ TEST_F(VertexBufferValidationTest, VertexBuffersInheritedBetweenPipelines) { auto vertexBuffer2 = MakeVertexBuffer(); // Check failure when vertex buffer is not set - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); { - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); pass.SetPipeline(pipeline1); pass.Draw(3, 1, 0, 0); pass.EndPass(); @@ -108,7 +108,7 @@ TEST_F(VertexBufferValidationTest, VertexBuffersInheritedBetweenPipelines) { // Check success when vertex buffer is inherited from previous pipeline encoder = device.CreateCommandEncoder(); { - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); pass.SetPipeline(pipeline2); pass.SetVertexBuffer(0, vertexBuffer1); pass.SetVertexBuffer(1, vertexBuffer2); @@ -132,9 +132,9 @@ TEST_F(VertexBufferValidationTest, VertexBuffersNotInheritedBetweenRendePasses) auto vertexBuffer2 = MakeVertexBuffer(); // Check success when vertex buffer is set for each render pass - dawn::CommandEncoder encoder = device.CreateCommandEncoder(); + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); { - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); pass.SetPipeline(pipeline2); pass.SetVertexBuffer(0, vertexBuffer1); pass.SetVertexBuffer(1, vertexBuffer2); @@ -142,7 +142,7 @@ TEST_F(VertexBufferValidationTest, VertexBuffersNotInheritedBetweenRendePasses) pass.EndPass(); } { - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); pass.SetPipeline(pipeline1); pass.SetVertexBuffer(0, vertexBuffer1); pass.Draw(3, 1, 0, 0); @@ -153,7 +153,7 @@ TEST_F(VertexBufferValidationTest, VertexBuffersNotInheritedBetweenRendePasses) // Check failure because vertex buffer is not inherited in second subpass encoder = device.CreateCommandEncoder(); { - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); pass.SetPipeline(pipeline2); pass.SetVertexBuffer(0, vertexBuffer1); pass.SetVertexBuffer(1, vertexBuffer2); @@ -161,7 +161,7 @@ TEST_F(VertexBufferValidationTest, VertexBuffersNotInheritedBetweenRendePasses) pass.EndPass(); } { - dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); pass.SetPipeline(pipeline1); pass.Draw(3, 1, 0, 0); pass.EndPass(); diff --git a/src/tests/unittests/validation/VertexInputValidationTests.cpp b/src/tests/unittests/validation/VertexInputValidationTests.cpp index 2350a599f3..f3fbb33c95 100644 --- a/src/tests/unittests/validation/VertexInputValidationTests.cpp +++ b/src/tests/unittests/validation/VertexInputValidationTests.cpp @@ -22,9 +22,9 @@ class VertexInputTest : public ValidationTest { void CreatePipeline(bool success, const utils::ComboVertexInputDescriptor& state, std::string vertexSource) { - dawn::ShaderModule vsModule = utils::CreateShaderModule( + wgpu::ShaderModule vsModule = utils::CreateShaderModule( device, utils::SingleShaderStage::Vertex, vertexSource.c_str()); - dawn::ShaderModule fsModule = + wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, utils::SingleShaderStage::Fragment, R"( #version 450 layout(location = 0) out vec4 fragColor; @@ -37,7 +37,7 @@ class VertexInputTest : public ValidationTest { descriptor.vertexStage.module = vsModule; descriptor.cFragmentStage.module = fsModule; descriptor.vertexInput = &state; - descriptor.cColorStates[0].format = dawn::TextureFormat::RGBA8Unorm; + descriptor.cColorStates[0].format = wgpu::TextureFormat::RGBA8Unorm; if (!success) { ASSERT_DEVICE_ERROR(device.CreateRenderPipeline(&descriptor)); @@ -400,7 +400,7 @@ TEST_F(VertexInputTest, SetAttributeOffsetOutOfBounds) { utils::ComboVertexInputDescriptor state; state.bufferCount = 1; state.cBuffers[0].attributeCount = 1; - state.cAttributes[0].offset = kMaxVertexAttributeEnd - sizeof(dawn::VertexFormat::Float); + state.cAttributes[0].offset = kMaxVertexAttributeEnd - sizeof(wgpu::VertexFormat::Float); CreatePipeline(true, state, R"( #version 450 void main() { @@ -462,7 +462,7 @@ TEST_F(VertexInputTest, VertexFormatLargerThanNonZeroStride) { state.bufferCount = 1; state.cBuffers[0].stride = 4; state.cBuffers[0].attributeCount = 1; - state.cAttributes[0].format = dawn::VertexFormat::Float4; + state.cAttributes[0].format = wgpu::VertexFormat::Float4; CreatePipeline(false, state, R"( #version 450 void main() { diff --git a/src/tests/unittests/wire/WireArgumentTests.cpp b/src/tests/unittests/wire/WireArgumentTests.cpp index abb2bb6036..f19c5750f1 100644 --- a/src/tests/unittests/wire/WireArgumentTests.cpp +++ b/src/tests/unittests/wire/WireArgumentTests.cpp @@ -30,14 +30,14 @@ class WireArgumentTests : public WireTest { // Test that the wire is able to send numerical values TEST_F(WireArgumentTests, ValueArgument) { - DawnCommandEncoder encoder = dawnDeviceCreateCommandEncoder(device, nullptr); - DawnComputePassEncoder pass = dawnCommandEncoderBeginComputePass(encoder, nullptr); - dawnComputePassEncoderDispatch(pass, 1, 2, 3); + WGPUCommandEncoder encoder = wgpuDeviceCreateCommandEncoder(device, nullptr); + WGPUComputePassEncoder pass = wgpuCommandEncoderBeginComputePass(encoder, nullptr); + wgpuComputePassEncoderDispatch(pass, 1, 2, 3); - DawnCommandEncoder apiEncoder = api.GetNewCommandEncoder(); + WGPUCommandEncoder apiEncoder = api.GetNewCommandEncoder(); EXPECT_CALL(api, DeviceCreateCommandEncoder(apiDevice, nullptr)).WillOnce(Return(apiEncoder)); - DawnComputePassEncoder apiPass = api.GetNewComputePassEncoder(); + WGPUComputePassEncoder apiPass = api.GetNewComputePassEncoder(); EXPECT_CALL(api, CommandEncoderBeginComputePass(apiEncoder, nullptr)).WillOnce(Return(apiPass)); EXPECT_CALL(api, ComputePassEncoderDispatch(apiPass, 1, 2, 3)).Times(1); @@ -48,36 +48,36 @@ TEST_F(WireArgumentTests, ValueArgument) { // Test that the wire is able to send arrays of numerical values TEST_F(WireArgumentTests, ValueArrayArgument) { // Create a bindgroup. - DawnBindGroupLayoutDescriptor bglDescriptor; + WGPUBindGroupLayoutDescriptor bglDescriptor; bglDescriptor.nextInChain = nullptr; bglDescriptor.bindingCount = 0; bglDescriptor.bindings = nullptr; - DawnBindGroupLayout bgl = dawnDeviceCreateBindGroupLayout(device, &bglDescriptor); - DawnBindGroupLayout apiBgl = api.GetNewBindGroupLayout(); + WGPUBindGroupLayout bgl = wgpuDeviceCreateBindGroupLayout(device, &bglDescriptor); + WGPUBindGroupLayout apiBgl = api.GetNewBindGroupLayout(); EXPECT_CALL(api, DeviceCreateBindGroupLayout(apiDevice, _)).WillOnce(Return(apiBgl)); - DawnBindGroupDescriptor bindGroupDescriptor; + WGPUBindGroupDescriptor bindGroupDescriptor; bindGroupDescriptor.nextInChain = nullptr; bindGroupDescriptor.layout = bgl; bindGroupDescriptor.bindingCount = 0; bindGroupDescriptor.bindings = nullptr; - DawnBindGroup bindGroup = dawnDeviceCreateBindGroup(device, &bindGroupDescriptor); - DawnBindGroup apiBindGroup = api.GetNewBindGroup(); + WGPUBindGroup bindGroup = wgpuDeviceCreateBindGroup(device, &bindGroupDescriptor); + WGPUBindGroup apiBindGroup = api.GetNewBindGroup(); EXPECT_CALL(api, DeviceCreateBindGroup(apiDevice, _)).WillOnce(Return(apiBindGroup)); // Use the bindgroup in SetBindGroup that takes an array of value offsets. - DawnCommandEncoder encoder = dawnDeviceCreateCommandEncoder(device, nullptr); - DawnComputePassEncoder pass = dawnCommandEncoderBeginComputePass(encoder, nullptr); + WGPUCommandEncoder encoder = wgpuDeviceCreateCommandEncoder(device, nullptr); + WGPUComputePassEncoder pass = wgpuCommandEncoderBeginComputePass(encoder, nullptr); std::array testOffsets = {0, 42, 0xDEAD'BEEF'DEAD'BEEFu, 0xFFFF'FFFF'FFFF'FFFFu}; - dawnComputePassEncoderSetBindGroup(pass, 0, bindGroup, testOffsets.size(), testOffsets.data()); + wgpuComputePassEncoderSetBindGroup(pass, 0, bindGroup, testOffsets.size(), testOffsets.data()); - DawnCommandEncoder apiEncoder = api.GetNewCommandEncoder(); + WGPUCommandEncoder apiEncoder = api.GetNewCommandEncoder(); EXPECT_CALL(api, DeviceCreateCommandEncoder(apiDevice, nullptr)).WillOnce(Return(apiEncoder)); - DawnComputePassEncoder apiPass = api.GetNewComputePassEncoder(); + WGPUComputePassEncoder apiPass = api.GetNewComputePassEncoder(); EXPECT_CALL(api, CommandEncoderBeginComputePass(apiEncoder, nullptr)).WillOnce(Return(apiPass)); EXPECT_CALL(api, ComputePassEncoderSetBindGroup( @@ -97,76 +97,76 @@ TEST_F(WireArgumentTests, ValueArrayArgument) { // Test that the wire is able to send C strings TEST_F(WireArgumentTests, CStringArgument) { // Create shader module - DawnShaderModuleDescriptor vertexDescriptor; + WGPUShaderModuleDescriptor vertexDescriptor; vertexDescriptor.nextInChain = nullptr; vertexDescriptor.codeSize = 0; - DawnShaderModule vsModule = dawnDeviceCreateShaderModule(device, &vertexDescriptor); - DawnShaderModule apiVsModule = api.GetNewShaderModule(); + WGPUShaderModule vsModule = wgpuDeviceCreateShaderModule(device, &vertexDescriptor); + WGPUShaderModule apiVsModule = api.GetNewShaderModule(); EXPECT_CALL(api, DeviceCreateShaderModule(apiDevice, _)).WillOnce(Return(apiVsModule)); // Create the color state descriptor - DawnBlendDescriptor blendDescriptor; - blendDescriptor.operation = DAWN_BLEND_OPERATION_ADD; - blendDescriptor.srcFactor = DAWN_BLEND_FACTOR_ONE; - blendDescriptor.dstFactor = DAWN_BLEND_FACTOR_ONE; - DawnColorStateDescriptor colorStateDescriptor; + WGPUBlendDescriptor blendDescriptor; + blendDescriptor.operation = WGPUBlendOperation_Add; + blendDescriptor.srcFactor = WGPUBlendFactor_One; + blendDescriptor.dstFactor = WGPUBlendFactor_One; + WGPUColorStateDescriptor colorStateDescriptor; colorStateDescriptor.nextInChain = nullptr; - colorStateDescriptor.format = DAWN_TEXTURE_FORMAT_RGBA8_UNORM; + colorStateDescriptor.format = WGPUTextureFormat_RGBA8Unorm; colorStateDescriptor.alphaBlend = blendDescriptor; colorStateDescriptor.colorBlend = blendDescriptor; - colorStateDescriptor.writeMask = DAWN_COLOR_WRITE_MASK_ALL; + colorStateDescriptor.writeMask = WGPUColorWriteMask_All; // Create the input state - DawnVertexInputDescriptor vertexInput; + WGPUVertexInputDescriptor vertexInput; vertexInput.nextInChain = nullptr; - vertexInput.indexFormat = DAWN_INDEX_FORMAT_UINT32; + vertexInput.indexFormat = WGPUIndexFormat_Uint32; vertexInput.bufferCount = 0; vertexInput.buffers = nullptr; // Create the rasterization state - DawnRasterizationStateDescriptor rasterizationState; + WGPURasterizationStateDescriptor rasterizationState; rasterizationState.nextInChain = nullptr; - rasterizationState.frontFace = DAWN_FRONT_FACE_CCW; - rasterizationState.cullMode = DAWN_CULL_MODE_NONE; + rasterizationState.frontFace = WGPUFrontFace_CCW; + rasterizationState.cullMode = WGPUCullMode_None; rasterizationState.depthBias = 0; rasterizationState.depthBiasSlopeScale = 0.0; rasterizationState.depthBiasClamp = 0.0; // Create the depth-stencil state - DawnStencilStateFaceDescriptor stencilFace; - stencilFace.compare = DAWN_COMPARE_FUNCTION_ALWAYS; - stencilFace.failOp = DAWN_STENCIL_OPERATION_KEEP; - stencilFace.depthFailOp = DAWN_STENCIL_OPERATION_KEEP; - stencilFace.passOp = DAWN_STENCIL_OPERATION_KEEP; + WGPUStencilStateFaceDescriptor stencilFace; + stencilFace.compare = WGPUCompareFunction_Always; + stencilFace.failOp = WGPUStencilOperation_Keep; + stencilFace.depthFailOp = WGPUStencilOperation_Keep; + stencilFace.passOp = WGPUStencilOperation_Keep; - DawnDepthStencilStateDescriptor depthStencilState; + WGPUDepthStencilStateDescriptor depthStencilState; depthStencilState.nextInChain = nullptr; - depthStencilState.format = DAWN_TEXTURE_FORMAT_DEPTH24_PLUS_STENCIL8; + depthStencilState.format = WGPUTextureFormat_Depth24PlusStencil8; depthStencilState.depthWriteEnabled = false; - depthStencilState.depthCompare = DAWN_COMPARE_FUNCTION_ALWAYS; + depthStencilState.depthCompare = WGPUCompareFunction_Always; depthStencilState.stencilBack = stencilFace; depthStencilState.stencilFront = stencilFace; depthStencilState.stencilReadMask = 0xff; depthStencilState.stencilWriteMask = 0xff; // Create the pipeline layout - DawnPipelineLayoutDescriptor layoutDescriptor; + WGPUPipelineLayoutDescriptor layoutDescriptor; layoutDescriptor.nextInChain = nullptr; layoutDescriptor.bindGroupLayoutCount = 0; layoutDescriptor.bindGroupLayouts = nullptr; - DawnPipelineLayout layout = dawnDeviceCreatePipelineLayout(device, &layoutDescriptor); - DawnPipelineLayout apiLayout = api.GetNewPipelineLayout(); + WGPUPipelineLayout layout = wgpuDeviceCreatePipelineLayout(device, &layoutDescriptor); + WGPUPipelineLayout apiLayout = api.GetNewPipelineLayout(); EXPECT_CALL(api, DeviceCreatePipelineLayout(apiDevice, _)).WillOnce(Return(apiLayout)); // Create pipeline - DawnRenderPipelineDescriptor pipelineDescriptor; + WGPURenderPipelineDescriptor pipelineDescriptor; pipelineDescriptor.nextInChain = nullptr; pipelineDescriptor.vertexStage.nextInChain = nullptr; pipelineDescriptor.vertexStage.module = vsModule; pipelineDescriptor.vertexStage.entryPoint = "main"; - DawnProgrammableStageDescriptor fragmentStage; + WGPUProgrammableStageDescriptor fragmentStage; fragmentStage.nextInChain = nullptr; fragmentStage.module = vsModule; fragmentStage.entryPoint = "main"; @@ -180,16 +180,16 @@ TEST_F(WireArgumentTests, CStringArgument) { pipelineDescriptor.alphaToCoverageEnabled = false; pipelineDescriptor.layout = layout; pipelineDescriptor.vertexInput = &vertexInput; - pipelineDescriptor.primitiveTopology = DAWN_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; + pipelineDescriptor.primitiveTopology = WGPUPrimitiveTopology_TriangleList; pipelineDescriptor.rasterizationState = &rasterizationState; pipelineDescriptor.depthStencilState = &depthStencilState; - dawnDeviceCreateRenderPipeline(device, &pipelineDescriptor); + wgpuDeviceCreateRenderPipeline(device, &pipelineDescriptor); - DawnRenderPipeline apiDummyPipeline = api.GetNewRenderPipeline(); + WGPURenderPipeline apiDummyPipeline = api.GetNewRenderPipeline(); EXPECT_CALL(api, DeviceCreateRenderPipeline( - apiDevice, MatchesLambda([](const DawnRenderPipelineDescriptor* desc) -> bool { + apiDevice, MatchesLambda([](const WGPURenderPipelineDescriptor* desc) -> bool { return desc->vertexStage.entryPoint == std::string("main"); }))) .WillOnce(Return(apiDummyPipeline)); @@ -200,23 +200,23 @@ TEST_F(WireArgumentTests, CStringArgument) { // Test that the wire is able to send objects as value arguments TEST_F(WireArgumentTests, ObjectAsValueArgument) { - DawnCommandEncoder cmdBufEncoder = dawnDeviceCreateCommandEncoder(device, nullptr); - DawnCommandEncoder apiEncoder = api.GetNewCommandEncoder(); + WGPUCommandEncoder cmdBufEncoder = wgpuDeviceCreateCommandEncoder(device, nullptr); + WGPUCommandEncoder apiEncoder = api.GetNewCommandEncoder(); EXPECT_CALL(api, DeviceCreateCommandEncoder(apiDevice, nullptr)).WillOnce(Return(apiEncoder)); - DawnBufferDescriptor descriptor; + WGPUBufferDescriptor descriptor; descriptor.nextInChain = nullptr; descriptor.size = 8; descriptor.usage = - static_cast(DAWN_BUFFER_USAGE_COPY_SRC | DAWN_BUFFER_USAGE_COPY_DST); + static_cast(WGPUBufferUsage_CopySrc | WGPUBufferUsage_CopyDst); - DawnBuffer buffer = dawnDeviceCreateBuffer(device, &descriptor); - DawnBuffer apiBuffer = api.GetNewBuffer(); + WGPUBuffer buffer = wgpuDeviceCreateBuffer(device, &descriptor); + WGPUBuffer apiBuffer = api.GetNewBuffer(); EXPECT_CALL(api, DeviceCreateBuffer(apiDevice, _)) .WillOnce(Return(apiBuffer)) .RetiresOnSaturation(); - dawnCommandEncoderCopyBufferToBuffer(cmdBufEncoder, buffer, 0, buffer, 4, 4); + wgpuCommandEncoderCopyBufferToBuffer(cmdBufEncoder, buffer, 0, buffer, 4, 4); EXPECT_CALL(api, CommandEncoderCopyBufferToBuffer(apiEncoder, apiBuffer, 0, apiBuffer, 4, 4)); FlushClient(); @@ -224,17 +224,17 @@ TEST_F(WireArgumentTests, ObjectAsValueArgument) { // Test that the wire is able to send array of objects TEST_F(WireArgumentTests, ObjectsAsPointerArgument) { - DawnCommandBuffer cmdBufs[2]; - DawnCommandBuffer apiCmdBufs[2]; + WGPUCommandBuffer cmdBufs[2]; + WGPUCommandBuffer apiCmdBufs[2]; // Create two command buffers we need to use a GMock sequence otherwise the order of the // CreateCommandEncoder might be swapped since they are equivalent in term of matchers Sequence s; for (int i = 0; i < 2; ++i) { - DawnCommandEncoder cmdBufEncoder = dawnDeviceCreateCommandEncoder(device, nullptr); - cmdBufs[i] = dawnCommandEncoderFinish(cmdBufEncoder, nullptr); + WGPUCommandEncoder cmdBufEncoder = wgpuDeviceCreateCommandEncoder(device, nullptr); + cmdBufs[i] = wgpuCommandEncoderFinish(cmdBufEncoder, nullptr); - DawnCommandEncoder apiCmdBufEncoder = api.GetNewCommandEncoder(); + WGPUCommandEncoder apiCmdBufEncoder = api.GetNewCommandEncoder(); EXPECT_CALL(api, DeviceCreateCommandEncoder(apiDevice, nullptr)) .InSequence(s) .WillOnce(Return(apiCmdBufEncoder)); @@ -245,15 +245,15 @@ TEST_F(WireArgumentTests, ObjectsAsPointerArgument) { } // Create queue - DawnQueue queue = dawnDeviceCreateQueue(device); - DawnQueue apiQueue = api.GetNewQueue(); + WGPUQueue queue = wgpuDeviceCreateQueue(device); + WGPUQueue apiQueue = api.GetNewQueue(); EXPECT_CALL(api, DeviceCreateQueue(apiDevice)).WillOnce(Return(apiQueue)); // Submit command buffer and check we got a call with both API-side command buffers - dawnQueueSubmit(queue, 2, cmdBufs); + wgpuQueueSubmit(queue, 2, cmdBufs); EXPECT_CALL( - api, QueueSubmit(apiQueue, 2, MatchesLambda([=](const DawnCommandBuffer* cmdBufs) -> bool { + api, QueueSubmit(apiQueue, 2, MatchesLambda([=](const WGPUCommandBuffer* cmdBufs) -> bool { return cmdBufs[0] == apiCmdBufs[0] && cmdBufs[1] == apiCmdBufs[1]; }))); @@ -262,31 +262,31 @@ TEST_F(WireArgumentTests, ObjectsAsPointerArgument) { // Test that the wire is able to send structures that contain pure values (non-objects) TEST_F(WireArgumentTests, StructureOfValuesArgument) { - DawnSamplerDescriptor descriptor; + WGPUSamplerDescriptor descriptor; descriptor.nextInChain = nullptr; - descriptor.magFilter = DAWN_FILTER_MODE_LINEAR; - descriptor.minFilter = DAWN_FILTER_MODE_NEAREST; - descriptor.mipmapFilter = DAWN_FILTER_MODE_LINEAR; - descriptor.addressModeU = DAWN_ADDRESS_MODE_CLAMP_TO_EDGE; - descriptor.addressModeV = DAWN_ADDRESS_MODE_REPEAT; - descriptor.addressModeW = DAWN_ADDRESS_MODE_MIRROR_REPEAT; + descriptor.magFilter = WGPUFilterMode_Linear; + descriptor.minFilter = WGPUFilterMode_Nearest; + descriptor.mipmapFilter = WGPUFilterMode_Linear; + descriptor.addressModeU = WGPUAddressMode_ClampToEdge; + descriptor.addressModeV = WGPUAddressMode_Repeat; + descriptor.addressModeW = WGPUAddressMode_MirrorRepeat; descriptor.lodMinClamp = kLodMin; descriptor.lodMaxClamp = kLodMax; - descriptor.compare = DAWN_COMPARE_FUNCTION_NEVER; + descriptor.compare = WGPUCompareFunction_Never; - dawnDeviceCreateSampler(device, &descriptor); + wgpuDeviceCreateSampler(device, &descriptor); - DawnSampler apiDummySampler = api.GetNewSampler(); + WGPUSampler apiDummySampler = api.GetNewSampler(); EXPECT_CALL(api, DeviceCreateSampler( - apiDevice, MatchesLambda([](const DawnSamplerDescriptor* desc) -> bool { + apiDevice, MatchesLambda([](const WGPUSamplerDescriptor* desc) -> bool { return desc->nextInChain == nullptr && - desc->magFilter == DAWN_FILTER_MODE_LINEAR && - desc->minFilter == DAWN_FILTER_MODE_NEAREST && - desc->mipmapFilter == DAWN_FILTER_MODE_LINEAR && - desc->addressModeU == DAWN_ADDRESS_MODE_CLAMP_TO_EDGE && - desc->addressModeV == DAWN_ADDRESS_MODE_REPEAT && - desc->addressModeW == DAWN_ADDRESS_MODE_MIRROR_REPEAT && - desc->compare == DAWN_COMPARE_FUNCTION_NEVER && + desc->magFilter == WGPUFilterMode_Linear && + desc->minFilter == WGPUFilterMode_Nearest && + desc->mipmapFilter == WGPUFilterMode_Linear && + desc->addressModeU == WGPUAddressMode_ClampToEdge && + desc->addressModeV == WGPUAddressMode_Repeat && + desc->addressModeW == WGPUAddressMode_MirrorRepeat && + desc->compare == WGPUCompareFunction_Never && desc->lodMinClamp == kLodMin && desc->lodMaxClamp == kLodMax; }))) .WillOnce(Return(apiDummySampler)); @@ -296,26 +296,26 @@ TEST_F(WireArgumentTests, StructureOfValuesArgument) { // Test that the wire is able to send structures that contain objects TEST_F(WireArgumentTests, StructureOfObjectArrayArgument) { - DawnBindGroupLayoutDescriptor bglDescriptor; + WGPUBindGroupLayoutDescriptor bglDescriptor; bglDescriptor.nextInChain = nullptr; bglDescriptor.bindingCount = 0; bglDescriptor.bindings = nullptr; - DawnBindGroupLayout bgl = dawnDeviceCreateBindGroupLayout(device, &bglDescriptor); - DawnBindGroupLayout apiBgl = api.GetNewBindGroupLayout(); + WGPUBindGroupLayout bgl = wgpuDeviceCreateBindGroupLayout(device, &bglDescriptor); + WGPUBindGroupLayout apiBgl = api.GetNewBindGroupLayout(); EXPECT_CALL(api, DeviceCreateBindGroupLayout(apiDevice, _)).WillOnce(Return(apiBgl)); - DawnPipelineLayoutDescriptor descriptor; + WGPUPipelineLayoutDescriptor descriptor; descriptor.nextInChain = nullptr; descriptor.bindGroupLayoutCount = 1; descriptor.bindGroupLayouts = &bgl; - dawnDeviceCreatePipelineLayout(device, &descriptor); + wgpuDeviceCreatePipelineLayout(device, &descriptor); - DawnPipelineLayout apiDummyLayout = api.GetNewPipelineLayout(); + WGPUPipelineLayout apiDummyLayout = api.GetNewPipelineLayout(); EXPECT_CALL(api, DeviceCreatePipelineLayout( apiDevice, - MatchesLambda([apiBgl](const DawnPipelineLayoutDescriptor* desc) -> bool { + MatchesLambda([apiBgl](const WGPUPipelineLayoutDescriptor* desc) -> bool { return desc->nextInChain == nullptr && desc->bindGroupLayoutCount == 1 && desc->bindGroupLayouts[0] == apiBgl; @@ -328,25 +328,25 @@ TEST_F(WireArgumentTests, StructureOfObjectArrayArgument) { // Test that the wire is able to send structures that contain objects TEST_F(WireArgumentTests, StructureOfStructureArrayArgument) { static constexpr int NUM_BINDINGS = 3; - DawnBindGroupLayoutBinding bindings[NUM_BINDINGS]{ - {0, DAWN_SHADER_STAGE_VERTEX, DAWN_BINDING_TYPE_SAMPLER, false, false, - DAWN_TEXTURE_VIEW_DIMENSION_2D, DAWN_TEXTURE_COMPONENT_TYPE_FLOAT}, - {1, DAWN_SHADER_STAGE_VERTEX, DAWN_BINDING_TYPE_SAMPLED_TEXTURE, false, false, - DAWN_TEXTURE_VIEW_DIMENSION_2D, DAWN_TEXTURE_COMPONENT_TYPE_FLOAT}, - {2, static_cast(DAWN_SHADER_STAGE_VERTEX | DAWN_SHADER_STAGE_FRAGMENT), - DAWN_BINDING_TYPE_UNIFORM_BUFFER, false, false, DAWN_TEXTURE_VIEW_DIMENSION_2D, - DAWN_TEXTURE_COMPONENT_TYPE_FLOAT}, + WGPUBindGroupLayoutBinding bindings[NUM_BINDINGS]{ + {0, WGPUShaderStage_Vertex, WGPUBindingType_Sampler, false, false, + WGPUTextureViewDimension_2D, WGPUTextureComponentType_Float}, + {1, WGPUShaderStage_Vertex, WGPUBindingType_SampledTexture, false, false, + WGPUTextureViewDimension_2D, WGPUTextureComponentType_Float}, + {2, static_cast(WGPUShaderStage_Vertex | WGPUShaderStage_Fragment), + WGPUBindingType_UniformBuffer, false, false, WGPUTextureViewDimension_2D, + WGPUTextureComponentType_Float}, }; - DawnBindGroupLayoutDescriptor bglDescriptor; + WGPUBindGroupLayoutDescriptor bglDescriptor; bglDescriptor.bindingCount = NUM_BINDINGS; bglDescriptor.bindings = bindings; - dawnDeviceCreateBindGroupLayout(device, &bglDescriptor); - DawnBindGroupLayout apiBgl = api.GetNewBindGroupLayout(); + wgpuDeviceCreateBindGroupLayout(device, &bglDescriptor); + WGPUBindGroupLayout apiBgl = api.GetNewBindGroupLayout(); EXPECT_CALL( api, DeviceCreateBindGroupLayout( - apiDevice, MatchesLambda([bindings](const DawnBindGroupLayoutDescriptor* desc) -> bool { + apiDevice, MatchesLambda([bindings](const WGPUBindGroupLayoutDescriptor* desc) -> bool { for (int i = 0; i < NUM_BINDINGS; ++i) { const auto& a = desc->bindings[i]; const auto& b = bindings[i]; @@ -364,17 +364,17 @@ TEST_F(WireArgumentTests, StructureOfStructureArrayArgument) { // Test passing nullptr instead of objects - array of objects version TEST_F(WireArgumentTests, DISABLED_NullptrInArray) { - DawnBindGroupLayout nullBGL = nullptr; + WGPUBindGroupLayout nullBGL = nullptr; - DawnPipelineLayoutDescriptor descriptor; + WGPUPipelineLayoutDescriptor descriptor; descriptor.nextInChain = nullptr; descriptor.bindGroupLayoutCount = 1; descriptor.bindGroupLayouts = &nullBGL; - dawnDeviceCreatePipelineLayout(device, &descriptor); + wgpuDeviceCreatePipelineLayout(device, &descriptor); EXPECT_CALL(api, DeviceCreatePipelineLayout( - apiDevice, MatchesLambda([](const DawnPipelineLayoutDescriptor* desc) -> bool { + apiDevice, MatchesLambda([](const WGPUPipelineLayoutDescriptor* desc) -> bool { return desc->nextInChain == nullptr && desc->bindGroupLayoutCount == 1 && desc->bindGroupLayouts[0] == nullptr; }))) diff --git a/src/tests/unittests/wire/WireBasicTests.cpp b/src/tests/unittests/wire/WireBasicTests.cpp index 488c05e1b8..e14a5967bf 100644 --- a/src/tests/unittests/wire/WireBasicTests.cpp +++ b/src/tests/unittests/wire/WireBasicTests.cpp @@ -26,9 +26,9 @@ class WireBasicTests : public WireTest { // One call gets forwarded correctly. TEST_F(WireBasicTests, CallForwarded) { - dawnDeviceCreateCommandEncoder(device, nullptr); + wgpuDeviceCreateCommandEncoder(device, nullptr); - DawnCommandEncoder apiCmdBufEncoder = api.GetNewCommandEncoder(); + WGPUCommandEncoder apiCmdBufEncoder = api.GetNewCommandEncoder(); EXPECT_CALL(api, DeviceCreateCommandEncoder(apiDevice, nullptr)) .WillOnce(Return(apiCmdBufEncoder)); @@ -37,14 +37,14 @@ TEST_F(WireBasicTests, CallForwarded) { // Test that calling methods on a new object works as expected. TEST_F(WireBasicTests, CreateThenCall) { - DawnCommandEncoder encoder = dawnDeviceCreateCommandEncoder(device, nullptr); - dawnCommandEncoderFinish(encoder, nullptr); + WGPUCommandEncoder encoder = wgpuDeviceCreateCommandEncoder(device, nullptr); + wgpuCommandEncoderFinish(encoder, nullptr); - DawnCommandEncoder apiCmdBufEncoder = api.GetNewCommandEncoder(); + WGPUCommandEncoder apiCmdBufEncoder = api.GetNewCommandEncoder(); EXPECT_CALL(api, DeviceCreateCommandEncoder(apiDevice, nullptr)) .WillOnce(Return(apiCmdBufEncoder)); - DawnCommandBuffer apiCmdBuf = api.GetNewCommandBuffer(); + WGPUCommandBuffer apiCmdBuf = api.GetNewCommandBuffer(); EXPECT_CALL(api, CommandEncoderFinish(apiCmdBufEncoder, nullptr)).WillOnce(Return(apiCmdBuf)); FlushClient(); @@ -52,12 +52,12 @@ TEST_F(WireBasicTests, CreateThenCall) { // Test that client reference/release do not call the backend API. TEST_F(WireBasicTests, RefCountKeptInClient) { - DawnCommandEncoder encoder = dawnDeviceCreateCommandEncoder(device, nullptr); + WGPUCommandEncoder encoder = wgpuDeviceCreateCommandEncoder(device, nullptr); - dawnCommandEncoderReference(encoder); - dawnCommandEncoderRelease(encoder); + wgpuCommandEncoderReference(encoder); + wgpuCommandEncoderRelease(encoder); - DawnCommandEncoder apiCmdBufEncoder = api.GetNewCommandEncoder(); + WGPUCommandEncoder apiCmdBufEncoder = api.GetNewCommandEncoder(); EXPECT_CALL(api, DeviceCreateCommandEncoder(apiDevice, nullptr)) .WillOnce(Return(apiCmdBufEncoder)); @@ -66,11 +66,11 @@ TEST_F(WireBasicTests, RefCountKeptInClient) { // Test that client reference/release do not call the backend API. TEST_F(WireBasicTests, ReleaseCalledOnRefCount0) { - DawnCommandEncoder encoder = dawnDeviceCreateCommandEncoder(device, nullptr); + WGPUCommandEncoder encoder = wgpuDeviceCreateCommandEncoder(device, nullptr); - dawnCommandEncoderRelease(encoder); + wgpuCommandEncoderRelease(encoder); - DawnCommandEncoder apiCmdBufEncoder = api.GetNewCommandEncoder(); + WGPUCommandEncoder apiCmdBufEncoder = api.GetNewCommandEncoder(); EXPECT_CALL(api, DeviceCreateCommandEncoder(apiDevice, nullptr)) .WillOnce(Return(apiCmdBufEncoder)); diff --git a/src/tests/unittests/wire/WireBufferMappingTests.cpp b/src/tests/unittests/wire/WireBufferMappingTests.cpp index 7319a97d36..69b10629c3 100644 --- a/src/tests/unittests/wire/WireBufferMappingTests.cpp +++ b/src/tests/unittests/wire/WireBufferMappingTests.cpp @@ -23,14 +23,14 @@ namespace { class MockBufferMapReadCallback { public: MOCK_METHOD4(Call, - void(DawnBufferMapAsyncStatus status, + void(WGPUBufferMapAsyncStatus status, const uint32_t* ptr, uint64_t dataLength, void* userdata)); }; std::unique_ptr> mockBufferMapReadCallback; - void ToMockBufferMapReadCallback(DawnBufferMapAsyncStatus status, + void ToMockBufferMapReadCallback(WGPUBufferMapAsyncStatus status, const void* ptr, uint64_t dataLength, void* userdata) { @@ -42,7 +42,7 @@ namespace { class MockBufferMapWriteCallback { public: MOCK_METHOD4(Call, - void(DawnBufferMapAsyncStatus status, + void(WGPUBufferMapAsyncStatus status, uint32_t* ptr, uint64_t dataLength, void* userdata)); @@ -50,7 +50,7 @@ namespace { std::unique_ptr> mockBufferMapWriteCallback; uint32_t* lastMapWritePointer = nullptr; - void ToMockBufferMapWriteCallback(DawnBufferMapAsyncStatus status, + void ToMockBufferMapWriteCallback(WGPUBufferMapAsyncStatus status, void* ptr, uint64_t dataLength, void* userdata) { @@ -62,8 +62,8 @@ namespace { class MockBufferCreateMappedCallback { public: MOCK_METHOD5(Call, - void(DawnBufferMapAsyncStatus status, - DawnBuffer buffer, + void(WGPUBufferMapAsyncStatus status, + WGPUBuffer buffer, uint32_t* ptr, uint64_t dataLength, void* userdata)); @@ -71,12 +71,12 @@ namespace { std::unique_ptr> mockCreateBufferMappedCallback; uint32_t* lastCreateMappedPointer = nullptr; - void ToMockCreateBufferMappedCallback(DawnBufferMapAsyncStatus status, - DawnCreateBufferMappedResult result, + void ToMockCreateBufferMappedCallback(WGPUBufferMapAsyncStatus status, + WGPUCreateBufferMappedResult result, void* userdata) { // Assume the data is uint32_t to make writing matchers easier lastCreateMappedPointer = static_cast(result.data); - // Unpack DawnCreateBufferMappedResult to make writing matchers easier + // Unpack WGPUCreateBufferMappedResult to make writing matchers easier mockCreateBufferMappedCallback->Call(status, result.buffer, lastCreateMappedPointer, result.dataLength, userdata); } @@ -97,13 +97,13 @@ class WireBufferMappingTests : public WireTest { mockCreateBufferMappedCallback = std::make_unique>(); - DawnBufferDescriptor descriptor; + WGPUBufferDescriptor descriptor; descriptor.nextInChain = nullptr; descriptor.label = nullptr; descriptor.size = kBufferSize; apiBuffer = api.GetNewBuffer(); - buffer = dawnDeviceCreateBuffer(device, &descriptor); + buffer = wgpuDeviceCreateBuffer(device, &descriptor); EXPECT_CALL(api, DeviceCreateBuffer(apiDevice, _)) .WillOnce(Return(apiBuffer)) @@ -131,32 +131,32 @@ class WireBufferMappingTests : public WireTest { protected: static constexpr uint64_t kBufferSize = sizeof(uint32_t); // A successfully created buffer - DawnBuffer buffer; - DawnBuffer apiBuffer; + WGPUBuffer buffer; + WGPUBuffer apiBuffer; }; // MapRead-specific tests // Check mapping for reading a succesfully created buffer TEST_F(WireBufferMappingTests, MappingForReadSuccessBuffer) { - dawnBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr); + wgpuBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr); uint32_t bufferContent = 31337; EXPECT_CALL(api, OnBufferMapReadAsyncCallback(apiBuffer, _, _)) .WillOnce(InvokeWithoutArgs([&]() { - api.CallMapReadCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, &bufferContent, + api.CallMapReadCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success, &bufferContent, kBufferSize); })); FlushClient(); - EXPECT_CALL(*mockBufferMapReadCallback, Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, - Pointee(Eq(bufferContent)), kBufferSize, _)) + EXPECT_CALL(*mockBufferMapReadCallback, + Call(WGPUBufferMapAsyncStatus_Success, Pointee(Eq(bufferContent)), kBufferSize, _)) .Times(1); FlushServer(); - dawnBufferUnmap(buffer); + wgpuBufferUnmap(buffer); EXPECT_CALL(api, BufferUnmap(apiBuffer)).Times(1); FlushClient(); @@ -165,16 +165,16 @@ TEST_F(WireBufferMappingTests, MappingForReadSuccessBuffer) { // Check that things work correctly when a validation error happens when mapping the buffer for // reading TEST_F(WireBufferMappingTests, ErrorWhileMappingForRead) { - dawnBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr); + wgpuBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr); EXPECT_CALL(api, OnBufferMapReadAsyncCallback(apiBuffer, _, _)) .WillOnce(InvokeWithoutArgs([&]() { - api.CallMapReadCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, 0); + api.CallMapReadCallback(apiBuffer, WGPUBufferMapAsyncStatus_Error, nullptr, 0); })); FlushClient(); - EXPECT_CALL(*mockBufferMapReadCallback, Call(DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, 0, _)) + EXPECT_CALL(*mockBufferMapReadCallback, Call(WGPUBufferMapAsyncStatus_Error, nullptr, 0, _)) .Times(1); FlushServer(); @@ -183,19 +183,18 @@ TEST_F(WireBufferMappingTests, ErrorWhileMappingForRead) { // Check that the map read callback is called with UNKNOWN when the buffer is destroyed before the // request is finished TEST_F(WireBufferMappingTests, DestroyBeforeReadRequestEnd) { - dawnBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr); + wgpuBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr); // Return success EXPECT_CALL(api, OnBufferMapReadAsyncCallback(apiBuffer, _, _)) .WillOnce(InvokeWithoutArgs([&]() { - api.CallMapReadCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, nullptr, 0); + api.CallMapReadCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success, nullptr, 0); })); // Destroy before the client gets the success, so the callback is called with unknown. - EXPECT_CALL(*mockBufferMapReadCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, nullptr, 0, _)) + EXPECT_CALL(*mockBufferMapReadCallback, Call(WGPUBufferMapAsyncStatus_Unknown, nullptr, 0, _)) .Times(1); - dawnBufferRelease(buffer); + wgpuBufferRelease(buffer); EXPECT_CALL(api, BufferRelease(apiBuffer)); FlushClient(); @@ -205,22 +204,21 @@ TEST_F(WireBufferMappingTests, DestroyBeforeReadRequestEnd) { // Check the map read callback is called with UNKNOWN when the map request would have worked, but // Unmap was called TEST_F(WireBufferMappingTests, UnmapCalledTooEarlyForRead) { - dawnBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr); + wgpuBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr); uint32_t bufferContent = 31337; EXPECT_CALL(api, OnBufferMapReadAsyncCallback(apiBuffer, _, _)) .WillOnce(InvokeWithoutArgs([&]() { - api.CallMapReadCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, &bufferContent, + api.CallMapReadCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success, &bufferContent, kBufferSize); })); FlushClient(); // Oh no! We are calling Unmap too early! - EXPECT_CALL(*mockBufferMapReadCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, nullptr, 0, _)) + EXPECT_CALL(*mockBufferMapReadCallback, Call(WGPUBufferMapAsyncStatus_Unknown, nullptr, 0, _)) .Times(1); - dawnBufferUnmap(buffer); + wgpuBufferUnmap(buffer); // The callback shouldn't get called, even when the request succeeded on the server side FlushServer(); @@ -229,34 +227,34 @@ TEST_F(WireBufferMappingTests, UnmapCalledTooEarlyForRead) { // Check that an error map read callback gets nullptr while a buffer is already mapped TEST_F(WireBufferMappingTests, MappingForReadingErrorWhileAlreadyMappedGetsNullptr) { // Successful map - dawnBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr); + wgpuBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr); uint32_t bufferContent = 31337; EXPECT_CALL(api, OnBufferMapReadAsyncCallback(apiBuffer, _, _)) .WillOnce(InvokeWithoutArgs([&]() { - api.CallMapReadCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, &bufferContent, + api.CallMapReadCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success, &bufferContent, kBufferSize); })) .RetiresOnSaturation(); FlushClient(); - EXPECT_CALL(*mockBufferMapReadCallback, Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, - Pointee(Eq(bufferContent)), kBufferSize, _)) + EXPECT_CALL(*mockBufferMapReadCallback, + Call(WGPUBufferMapAsyncStatus_Success, Pointee(Eq(bufferContent)), kBufferSize, _)) .Times(1); FlushServer(); // Map failure while the buffer is already mapped - dawnBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr); + wgpuBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr); EXPECT_CALL(api, OnBufferMapReadAsyncCallback(apiBuffer, _, _)) .WillOnce(InvokeWithoutArgs([&]() { - api.CallMapReadCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, 0); + api.CallMapReadCallback(apiBuffer, WGPUBufferMapAsyncStatus_Error, nullptr, 0); })); FlushClient(); - EXPECT_CALL(*mockBufferMapReadCallback, Call(DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, 0, _)) + EXPECT_CALL(*mockBufferMapReadCallback, Call(WGPUBufferMapAsyncStatus_Error, nullptr, 0, _)) .Times(1); FlushServer(); @@ -264,20 +262,20 @@ TEST_F(WireBufferMappingTests, MappingForReadingErrorWhileAlreadyMappedGetsNullp // Test that the MapReadCallback isn't fired twice when unmap() is called inside the callback TEST_F(WireBufferMappingTests, UnmapInsideMapReadCallback) { - dawnBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr); + wgpuBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr); uint32_t bufferContent = 31337; EXPECT_CALL(api, OnBufferMapReadAsyncCallback(apiBuffer, _, _)) .WillOnce(InvokeWithoutArgs([&]() { - api.CallMapReadCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, &bufferContent, + api.CallMapReadCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success, &bufferContent, kBufferSize); })); FlushClient(); - EXPECT_CALL(*mockBufferMapReadCallback, Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, - Pointee(Eq(bufferContent)), kBufferSize, _)) - .WillOnce(InvokeWithoutArgs([&]() { dawnBufferUnmap(buffer); })); + EXPECT_CALL(*mockBufferMapReadCallback, + Call(WGPUBufferMapAsyncStatus_Success, Pointee(Eq(bufferContent)), kBufferSize, _)) + .WillOnce(InvokeWithoutArgs([&]() { wgpuBufferUnmap(buffer); })); FlushServer(); @@ -289,20 +287,20 @@ TEST_F(WireBufferMappingTests, UnmapInsideMapReadCallback) { // Test that the MapReadCallback isn't fired twice the buffer external refcount reaches 0 in the // callback TEST_F(WireBufferMappingTests, DestroyInsideMapReadCallback) { - dawnBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr); + wgpuBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr); uint32_t bufferContent = 31337; EXPECT_CALL(api, OnBufferMapReadAsyncCallback(apiBuffer, _, _)) .WillOnce(InvokeWithoutArgs([&]() { - api.CallMapReadCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, &bufferContent, + api.CallMapReadCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success, &bufferContent, kBufferSize); })); FlushClient(); - EXPECT_CALL(*mockBufferMapReadCallback, Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, - Pointee(Eq(bufferContent)), kBufferSize, _)) - .WillOnce(InvokeWithoutArgs([&]() { dawnBufferRelease(buffer); })); + EXPECT_CALL(*mockBufferMapReadCallback, + Call(WGPUBufferMapAsyncStatus_Success, Pointee(Eq(bufferContent)), kBufferSize, _)) + .WillOnce(InvokeWithoutArgs([&]() { wgpuBufferRelease(buffer); })); FlushServer(); @@ -315,7 +313,7 @@ TEST_F(WireBufferMappingTests, DestroyInsideMapReadCallback) { // Check mapping for writing a succesfully created buffer TEST_F(WireBufferMappingTests, MappingForWriteSuccessBuffer) { - dawnBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr); + wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr); uint32_t serverBufferContent = 31337; uint32_t updatedContent = 4242; @@ -323,7 +321,7 @@ TEST_F(WireBufferMappingTests, MappingForWriteSuccessBuffer) { EXPECT_CALL(api, OnBufferMapWriteAsyncCallback(apiBuffer, _, _)) .WillOnce(InvokeWithoutArgs([&]() { - api.CallMapWriteCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, + api.CallMapWriteCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success, &serverBufferContent, kBufferSize); })); @@ -331,7 +329,7 @@ TEST_F(WireBufferMappingTests, MappingForWriteSuccessBuffer) { // The map write callback always gets a buffer full of zeroes. EXPECT_CALL(*mockBufferMapWriteCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, Pointee(Eq(zero)), kBufferSize, _)) + Call(WGPUBufferMapAsyncStatus_Success, Pointee(Eq(zero)), kBufferSize, _)) .Times(1); FlushServer(); @@ -339,7 +337,7 @@ TEST_F(WireBufferMappingTests, MappingForWriteSuccessBuffer) { // Write something to the mapped pointer *lastMapWritePointer = updatedContent; - dawnBufferUnmap(buffer); + wgpuBufferUnmap(buffer); EXPECT_CALL(api, BufferUnmap(apiBuffer)).Times(1); FlushClient(); @@ -351,17 +349,16 @@ TEST_F(WireBufferMappingTests, MappingForWriteSuccessBuffer) { // Check that things work correctly when a validation error happens when mapping the buffer for // writing TEST_F(WireBufferMappingTests, ErrorWhileMappingForWrite) { - dawnBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr); + wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr); EXPECT_CALL(api, OnBufferMapWriteAsyncCallback(apiBuffer, _, _)) .WillOnce(InvokeWithoutArgs([&]() { - api.CallMapWriteCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, 0); + api.CallMapWriteCallback(apiBuffer, WGPUBufferMapAsyncStatus_Error, nullptr, 0); })); FlushClient(); - EXPECT_CALL(*mockBufferMapWriteCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, 0, _)) + EXPECT_CALL(*mockBufferMapWriteCallback, Call(WGPUBufferMapAsyncStatus_Error, nullptr, 0, _)) .Times(1); FlushServer(); @@ -370,19 +367,18 @@ TEST_F(WireBufferMappingTests, ErrorWhileMappingForWrite) { // Check that the map write callback is called with UNKNOWN when the buffer is destroyed before the // request is finished TEST_F(WireBufferMappingTests, DestroyBeforeWriteRequestEnd) { - dawnBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr); + wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr); // Return success EXPECT_CALL(api, OnBufferMapWriteAsyncCallback(apiBuffer, _, _)) .WillOnce(InvokeWithoutArgs([&]() { - api.CallMapWriteCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, nullptr, 0); + api.CallMapWriteCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success, nullptr, 0); })); // Destroy before the client gets the success, so the callback is called with unknown. - EXPECT_CALL(*mockBufferMapWriteCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, nullptr, 0, _)) + EXPECT_CALL(*mockBufferMapWriteCallback, Call(WGPUBufferMapAsyncStatus_Unknown, nullptr, 0, _)) .Times(1); - dawnBufferRelease(buffer); + wgpuBufferRelease(buffer); EXPECT_CALL(api, BufferRelease(apiBuffer)); FlushClient(); @@ -392,22 +388,21 @@ TEST_F(WireBufferMappingTests, DestroyBeforeWriteRequestEnd) { // Check the map read callback is called with UNKNOWN when the map request would have worked, but // Unmap was called TEST_F(WireBufferMappingTests, UnmapCalledTooEarlyForWrite) { - dawnBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr); + wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr); uint32_t bufferContent = 31337; EXPECT_CALL(api, OnBufferMapWriteAsyncCallback(apiBuffer, _, _)) .WillOnce(InvokeWithoutArgs([&]() { - api.CallMapWriteCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, - &bufferContent, kBufferSize); + api.CallMapWriteCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success, &bufferContent, + kBufferSize); })); FlushClient(); // Oh no! We are calling Unmap too early! - EXPECT_CALL(*mockBufferMapWriteCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, nullptr, 0, _)) + EXPECT_CALL(*mockBufferMapWriteCallback, Call(WGPUBufferMapAsyncStatus_Unknown, nullptr, 0, _)) .Times(1); - dawnBufferUnmap(buffer); + wgpuBufferUnmap(buffer); // The callback shouldn't get called, even when the request succeeded on the server side FlushServer(); @@ -416,36 +411,35 @@ TEST_F(WireBufferMappingTests, UnmapCalledTooEarlyForWrite) { // Check that an error map read callback gets nullptr while a buffer is already mapped TEST_F(WireBufferMappingTests, MappingForWritingErrorWhileAlreadyMappedGetsNullptr) { // Successful map - dawnBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr); + wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr); uint32_t bufferContent = 31337; uint32_t zero = 0; EXPECT_CALL(api, OnBufferMapWriteAsyncCallback(apiBuffer, _, _)) .WillOnce(InvokeWithoutArgs([&]() { - api.CallMapWriteCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, - &bufferContent, kBufferSize); + api.CallMapWriteCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success, &bufferContent, + kBufferSize); })) .RetiresOnSaturation(); FlushClient(); EXPECT_CALL(*mockBufferMapWriteCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, Pointee(Eq(zero)), kBufferSize, _)) + Call(WGPUBufferMapAsyncStatus_Success, Pointee(Eq(zero)), kBufferSize, _)) .Times(1); FlushServer(); // Map failure while the buffer is already mapped - dawnBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr); + wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr); EXPECT_CALL(api, OnBufferMapWriteAsyncCallback(apiBuffer, _, _)) .WillOnce(InvokeWithoutArgs([&]() { - api.CallMapWriteCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, 0); + api.CallMapWriteCallback(apiBuffer, WGPUBufferMapAsyncStatus_Error, nullptr, 0); })); FlushClient(); - EXPECT_CALL(*mockBufferMapWriteCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, 0, _)) + EXPECT_CALL(*mockBufferMapWriteCallback, Call(WGPUBufferMapAsyncStatus_Error, nullptr, 0, _)) .Times(1); FlushServer(); @@ -453,21 +447,21 @@ TEST_F(WireBufferMappingTests, MappingForWritingErrorWhileAlreadyMappedGetsNullp // Test that the MapWriteCallback isn't fired twice when unmap() is called inside the callback TEST_F(WireBufferMappingTests, UnmapInsideMapWriteCallback) { - dawnBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr); + wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr); uint32_t bufferContent = 31337; uint32_t zero = 0; EXPECT_CALL(api, OnBufferMapWriteAsyncCallback(apiBuffer, _, _)) .WillOnce(InvokeWithoutArgs([&]() { - api.CallMapWriteCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, - &bufferContent, kBufferSize); + api.CallMapWriteCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success, &bufferContent, + kBufferSize); })); FlushClient(); EXPECT_CALL(*mockBufferMapWriteCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, Pointee(Eq(zero)), kBufferSize, _)) - .WillOnce(InvokeWithoutArgs([&]() { dawnBufferUnmap(buffer); })); + Call(WGPUBufferMapAsyncStatus_Success, Pointee(Eq(zero)), kBufferSize, _)) + .WillOnce(InvokeWithoutArgs([&]() { wgpuBufferUnmap(buffer); })); FlushServer(); @@ -479,21 +473,21 @@ TEST_F(WireBufferMappingTests, UnmapInsideMapWriteCallback) { // Test that the MapWriteCallback isn't fired twice the buffer external refcount reaches 0 in the // callback TEST_F(WireBufferMappingTests, DestroyInsideMapWriteCallback) { - dawnBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr); + wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr); uint32_t bufferContent = 31337; uint32_t zero = 0; EXPECT_CALL(api, OnBufferMapWriteAsyncCallback(apiBuffer, _, _)) .WillOnce(InvokeWithoutArgs([&]() { - api.CallMapWriteCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, - &bufferContent, kBufferSize); + api.CallMapWriteCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success, &bufferContent, + kBufferSize); })); FlushClient(); EXPECT_CALL(*mockBufferMapWriteCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, Pointee(Eq(zero)), kBufferSize, _)) - .WillOnce(InvokeWithoutArgs([&]() { dawnBufferRelease(buffer); })); + Call(WGPUBufferMapAsyncStatus_Success, Pointee(Eq(zero)), kBufferSize, _)) + .WillOnce(InvokeWithoutArgs([&]() { wgpuBufferRelease(buffer); })); FlushServer(); @@ -504,19 +498,19 @@ TEST_F(WireBufferMappingTests, DestroyInsideMapWriteCallback) { // Test successful CreateBufferMapped TEST_F(WireBufferMappingTests, CreateBufferMappedSuccess) { - DawnBufferDescriptor descriptor; + WGPUBufferDescriptor descriptor; descriptor.nextInChain = nullptr; descriptor.label = nullptr; descriptor.size = 4; - DawnBuffer apiBuffer = api.GetNewBuffer(); - DawnCreateBufferMappedResult apiResult; + WGPUBuffer apiBuffer = api.GetNewBuffer(); + WGPUCreateBufferMappedResult apiResult; uint32_t apiBufferData = 1234; apiResult.buffer = apiBuffer; apiResult.data = reinterpret_cast(&apiBufferData); apiResult.dataLength = 4; - DawnCreateBufferMappedResult result = dawnDeviceCreateBufferMapped(device, &descriptor); + WGPUCreateBufferMappedResult result = wgpuDeviceCreateBufferMapped(device, &descriptor); EXPECT_CALL(api, DeviceCreateBufferMapped(apiDevice, _)) .WillOnce(Return(apiResult)) @@ -524,7 +518,7 @@ TEST_F(WireBufferMappingTests, CreateBufferMappedSuccess) { FlushClient(); - dawnBufferUnmap(result.buffer); + wgpuBufferUnmap(result.buffer); EXPECT_CALL(api, BufferUnmap(apiBuffer)).Times(1); FlushClient(); @@ -532,19 +526,19 @@ TEST_F(WireBufferMappingTests, CreateBufferMappedSuccess) { // Test that releasing after CreateBufferMapped does not call Unmap TEST_F(WireBufferMappingTests, ReleaseAfterCreateBufferMapped) { - DawnBufferDescriptor descriptor; + WGPUBufferDescriptor descriptor; descriptor.nextInChain = nullptr; descriptor.label = nullptr; descriptor.size = 4; - DawnBuffer apiBuffer = api.GetNewBuffer(); - DawnCreateBufferMappedResult apiResult; + WGPUBuffer apiBuffer = api.GetNewBuffer(); + WGPUCreateBufferMappedResult apiResult; uint32_t apiBufferData = 1234; apiResult.buffer = apiBuffer; apiResult.data = reinterpret_cast(&apiBufferData); apiResult.dataLength = 4; - DawnCreateBufferMappedResult result = dawnDeviceCreateBufferMapped(device, &descriptor); + WGPUCreateBufferMappedResult result = wgpuDeviceCreateBufferMapped(device, &descriptor); EXPECT_CALL(api, DeviceCreateBufferMapped(apiDevice, _)) .WillOnce(Return(apiResult)) @@ -552,7 +546,7 @@ TEST_F(WireBufferMappingTests, ReleaseAfterCreateBufferMapped) { FlushClient(); - dawnBufferRelease(result.buffer); + wgpuBufferRelease(result.buffer); EXPECT_CALL(api, BufferRelease(apiBuffer)).Times(1); FlushClient(); @@ -560,19 +554,19 @@ TEST_F(WireBufferMappingTests, ReleaseAfterCreateBufferMapped) { // Test that it is valid to map a buffer after CreateBufferMapped and Unmap TEST_F(WireBufferMappingTests, CreateBufferMappedThenMapSuccess) { - DawnBufferDescriptor descriptor; + WGPUBufferDescriptor descriptor; descriptor.nextInChain = nullptr; descriptor.label = nullptr; descriptor.size = 4; - DawnBuffer apiBuffer = api.GetNewBuffer(); - DawnCreateBufferMappedResult apiResult; + WGPUBuffer apiBuffer = api.GetNewBuffer(); + WGPUCreateBufferMappedResult apiResult; uint32_t apiBufferData = 9863; apiResult.buffer = apiBuffer; apiResult.data = reinterpret_cast(&apiBufferData); apiResult.dataLength = 4; - DawnCreateBufferMappedResult result = dawnDeviceCreateBufferMapped(device, &descriptor); + WGPUCreateBufferMappedResult result = wgpuDeviceCreateBufferMapped(device, &descriptor); EXPECT_CALL(api, DeviceCreateBufferMapped(apiDevice, _)) .WillOnce(Return(apiResult)) @@ -580,24 +574,24 @@ TEST_F(WireBufferMappingTests, CreateBufferMappedThenMapSuccess) { FlushClient(); - dawnBufferUnmap(result.buffer); + wgpuBufferUnmap(result.buffer); EXPECT_CALL(api, BufferUnmap(apiBuffer)).Times(1); FlushClient(); - dawnBufferMapWriteAsync(result.buffer, ToMockBufferMapWriteCallback, nullptr); + wgpuBufferMapWriteAsync(result.buffer, ToMockBufferMapWriteCallback, nullptr); uint32_t zero = 0; EXPECT_CALL(api, OnBufferMapWriteAsyncCallback(apiBuffer, _, _)) .WillOnce(InvokeWithoutArgs([&]() { - api.CallMapWriteCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, - &apiBufferData, kBufferSize); + api.CallMapWriteCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success, &apiBufferData, + kBufferSize); })); FlushClient(); EXPECT_CALL(*mockBufferMapWriteCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, Pointee(Eq(zero)), kBufferSize, _)) + Call(WGPUBufferMapAsyncStatus_Success, Pointee(Eq(zero)), kBufferSize, _)) .Times(1); FlushServer(); @@ -605,19 +599,19 @@ TEST_F(WireBufferMappingTests, CreateBufferMappedThenMapSuccess) { // Test that it is invalid to map a buffer after CreateBufferMapped before Unmap TEST_F(WireBufferMappingTests, CreateBufferMappedThenMapFailure) { - DawnBufferDescriptor descriptor; + WGPUBufferDescriptor descriptor; descriptor.nextInChain = nullptr; descriptor.label = nullptr; descriptor.size = 4; - DawnBuffer apiBuffer = api.GetNewBuffer(); - DawnCreateBufferMappedResult apiResult; + WGPUBuffer apiBuffer = api.GetNewBuffer(); + WGPUCreateBufferMappedResult apiResult; uint32_t apiBufferData = 9863; apiResult.buffer = apiBuffer; apiResult.data = reinterpret_cast(&apiBufferData); apiResult.dataLength = 4; - DawnCreateBufferMappedResult result = dawnDeviceCreateBufferMapped(device, &descriptor); + WGPUCreateBufferMappedResult result = wgpuDeviceCreateBufferMapped(device, &descriptor); EXPECT_CALL(api, DeviceCreateBufferMapped(apiDevice, _)) .WillOnce(Return(apiResult)) @@ -625,22 +619,21 @@ TEST_F(WireBufferMappingTests, CreateBufferMappedThenMapFailure) { FlushClient(); - dawnBufferMapWriteAsync(result.buffer, ToMockBufferMapWriteCallback, nullptr); + wgpuBufferMapWriteAsync(result.buffer, ToMockBufferMapWriteCallback, nullptr); EXPECT_CALL(api, OnBufferMapWriteAsyncCallback(apiBuffer, _, _)) .WillOnce(InvokeWithoutArgs([&]() { - api.CallMapWriteCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, 0); + api.CallMapWriteCallback(apiBuffer, WGPUBufferMapAsyncStatus_Error, nullptr, 0); })); FlushClient(); - EXPECT_CALL(*mockBufferMapWriteCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, 0, _)) + EXPECT_CALL(*mockBufferMapWriteCallback, Call(WGPUBufferMapAsyncStatus_Error, nullptr, 0, _)) .Times(1); FlushServer(); - dawnBufferUnmap(result.buffer); + wgpuBufferUnmap(result.buffer); EXPECT_CALL(api, BufferUnmap(apiBuffer)).Times(1); FlushClient(); @@ -648,12 +641,12 @@ TEST_F(WireBufferMappingTests, CreateBufferMappedThenMapFailure) { // Test successful CreateBufferMappedAsync TEST_F(WireBufferMappingTests, CreateBufferMappedAsyncSuccess) { - DawnBufferDescriptor descriptor; + WGPUBufferDescriptor descriptor; descriptor.nextInChain = nullptr; descriptor.label = nullptr; descriptor.size = kBufferSize; - DawnCreateBufferMappedResult apiResult; + WGPUCreateBufferMappedResult apiResult; uint32_t serverBufferContent = 31337; apiResult.buffer = apiBuffer; apiResult.data = reinterpret_cast(&serverBufferContent); @@ -662,7 +655,8 @@ TEST_F(WireBufferMappingTests, CreateBufferMappedAsyncSuccess) { uint32_t updatedContent = 4242; uint32_t zero = 0; - dawnDeviceCreateBufferMappedAsync(device, &descriptor, ToMockCreateBufferMappedCallback, nullptr); + wgpuDeviceCreateBufferMappedAsync(device, &descriptor, ToMockCreateBufferMappedCallback, + nullptr); EXPECT_CALL(api, DeviceCreateBufferMapped(apiDevice, _)) .WillOnce(Return(apiResult)) @@ -670,10 +664,10 @@ TEST_F(WireBufferMappingTests, CreateBufferMappedAsyncSuccess) { FlushClient(); - DawnBuffer buffer; + WGPUBuffer buffer; // The callback always gets a buffer full of zeroes. EXPECT_CALL(*mockCreateBufferMappedCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, _, Pointee(Eq(zero)), kBufferSize, _)) + Call(WGPUBufferMapAsyncStatus_Success, _, Pointee(Eq(zero)), kBufferSize, _)) .WillOnce(::testing::SaveArg<1>(&buffer)); FlushServer(); @@ -681,7 +675,7 @@ TEST_F(WireBufferMappingTests, CreateBufferMappedAsyncSuccess) { // Write something to the mapped pointer *lastCreateMappedPointer = updatedContent; - dawnBufferUnmap(buffer); + wgpuBufferUnmap(buffer); EXPECT_CALL(api, BufferUnmap(apiBuffer)).Times(1); FlushClient(); @@ -692,16 +686,17 @@ TEST_F(WireBufferMappingTests, CreateBufferMappedAsyncSuccess) { // Test CreateBufferMappedAsync with map error TEST_F(WireBufferMappingTests, CreateBufferMappedAsyncMapError) { - DawnBufferDescriptor descriptor; + WGPUBufferDescriptor descriptor; descriptor.nextInChain = nullptr; descriptor.label = nullptr; - DawnCreateBufferMappedResult apiResult; + WGPUCreateBufferMappedResult apiResult; apiResult.buffer = apiBuffer; apiResult.data = nullptr; // error mapping apiResult.dataLength = kBufferSize; - dawnDeviceCreateBufferMappedAsync(device, &descriptor, ToMockCreateBufferMappedCallback, nullptr); + wgpuDeviceCreateBufferMappedAsync(device, &descriptor, ToMockCreateBufferMappedCallback, + nullptr); EXPECT_CALL(api, DeviceCreateBufferMapped(apiDevice, _)) .WillOnce(Return(apiResult)) @@ -709,14 +704,14 @@ TEST_F(WireBufferMappingTests, CreateBufferMappedAsyncMapError) { FlushClient(); - DawnBuffer buffer; + WGPUBuffer buffer; EXPECT_CALL(*mockCreateBufferMappedCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, _, nullptr, 0, _)) + Call(WGPUBufferMapAsyncStatus_Error, _, nullptr, 0, _)) .WillOnce(::testing::SaveArg<1>(&buffer)); FlushServer(); - dawnBufferUnmap(buffer); + wgpuBufferUnmap(buffer); EXPECT_CALL(api, BufferUnmap(apiBuffer)).Times(1); FlushClient(); @@ -725,12 +720,12 @@ TEST_F(WireBufferMappingTests, CreateBufferMappedAsyncMapError) { // Test that the CreateBufferMappedCallback isn't fired twice when unmap() is called inside the // callback TEST_F(WireBufferMappingTests, UnmapInsideCreateBufferMappedAsyncCallback) { - DawnBufferDescriptor descriptor; + WGPUBufferDescriptor descriptor; descriptor.nextInChain = nullptr; descriptor.label = nullptr; descriptor.size = kBufferSize; - DawnCreateBufferMappedResult apiResult; + WGPUCreateBufferMappedResult apiResult; uint32_t serverBufferContent = 31337; apiResult.buffer = apiBuffer; apiResult.data = reinterpret_cast(&serverBufferContent); @@ -738,7 +733,8 @@ TEST_F(WireBufferMappingTests, UnmapInsideCreateBufferMappedAsyncCallback) { uint32_t zero = 0; - dawnDeviceCreateBufferMappedAsync(device, &descriptor, ToMockCreateBufferMappedCallback, nullptr); + wgpuDeviceCreateBufferMappedAsync(device, &descriptor, ToMockCreateBufferMappedCallback, + nullptr); EXPECT_CALL(api, DeviceCreateBufferMapped(apiDevice, _)) .WillOnce(Return(apiResult)) @@ -746,12 +742,12 @@ TEST_F(WireBufferMappingTests, UnmapInsideCreateBufferMappedAsyncCallback) { FlushClient(); - DawnBuffer buffer; + WGPUBuffer buffer; // The callback always gets a buffer full of zeroes. EXPECT_CALL(*mockCreateBufferMappedCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, _, Pointee(Eq(zero)), kBufferSize, _)) + Call(WGPUBufferMapAsyncStatus_Success, _, Pointee(Eq(zero)), kBufferSize, _)) .WillOnce(DoAll(::testing::SaveArg<1>(&buffer), - InvokeWithoutArgs([&]() { dawnBufferUnmap(buffer); }))); + InvokeWithoutArgs([&]() { wgpuBufferUnmap(buffer); }))); FlushServer(); @@ -763,12 +759,12 @@ TEST_F(WireBufferMappingTests, UnmapInsideCreateBufferMappedAsyncCallback) { // Test that the CreateBufferMappedCallback isn't fired twice when the buffer is deleted inside // the callback TEST_F(WireBufferMappingTests, ReleaseInsideCreateBufferMappedAsyncCallback) { - DawnBufferDescriptor descriptor; + WGPUBufferDescriptor descriptor; descriptor.nextInChain = nullptr; descriptor.label = nullptr; descriptor.size = kBufferSize; - DawnCreateBufferMappedResult apiResult; + WGPUCreateBufferMappedResult apiResult; uint32_t serverBufferContent = 31337; apiResult.buffer = apiBuffer; apiResult.data = reinterpret_cast(&serverBufferContent); @@ -776,7 +772,8 @@ TEST_F(WireBufferMappingTests, ReleaseInsideCreateBufferMappedAsyncCallback) { uint32_t zero = 0; - dawnDeviceCreateBufferMappedAsync(device, &descriptor, ToMockCreateBufferMappedCallback, nullptr); + wgpuDeviceCreateBufferMappedAsync(device, &descriptor, ToMockCreateBufferMappedCallback, + nullptr); EXPECT_CALL(api, DeviceCreateBufferMapped(apiDevice, _)) .WillOnce(Return(apiResult)) @@ -784,12 +781,12 @@ TEST_F(WireBufferMappingTests, ReleaseInsideCreateBufferMappedAsyncCallback) { FlushClient(); - DawnBuffer buffer; + WGPUBuffer buffer; // The callback always gets a buffer full of zeroes. EXPECT_CALL(*mockCreateBufferMappedCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, _, Pointee(Eq(zero)), kBufferSize, _)) + Call(WGPUBufferMapAsyncStatus_Success, _, Pointee(Eq(zero)), kBufferSize, _)) .WillOnce(DoAll(::testing::SaveArg<1>(&buffer), - InvokeWithoutArgs([&]() { dawnBufferRelease(buffer); }))); + InvokeWithoutArgs([&]() { wgpuBufferRelease(buffer); }))); FlushServer(); @@ -801,12 +798,12 @@ TEST_F(WireBufferMappingTests, ReleaseInsideCreateBufferMappedAsyncCallback) { // Test that the CreateBufferMappedCallback isn't fired twice when the buffer is destroyed inside // the callback TEST_F(WireBufferMappingTests, DestroyInsideCreateBufferMappedAsyncCallback) { - DawnBufferDescriptor descriptor; + WGPUBufferDescriptor descriptor; descriptor.nextInChain = nullptr; descriptor.label = nullptr; descriptor.size = kBufferSize; - DawnCreateBufferMappedResult apiResult; + WGPUCreateBufferMappedResult apiResult; uint32_t serverBufferContent = 31337; apiResult.buffer = apiBuffer; apiResult.data = reinterpret_cast(&serverBufferContent); @@ -814,7 +811,8 @@ TEST_F(WireBufferMappingTests, DestroyInsideCreateBufferMappedAsyncCallback) { uint32_t zero = 0; - dawnDeviceCreateBufferMappedAsync(device, &descriptor, ToMockCreateBufferMappedCallback, nullptr); + wgpuDeviceCreateBufferMappedAsync(device, &descriptor, ToMockCreateBufferMappedCallback, + nullptr); EXPECT_CALL(api, DeviceCreateBufferMapped(apiDevice, _)) .WillOnce(Return(apiResult)) @@ -822,12 +820,12 @@ TEST_F(WireBufferMappingTests, DestroyInsideCreateBufferMappedAsyncCallback) { FlushClient(); - DawnBuffer buffer; + WGPUBuffer buffer; // The callback always gets a buffer full of zeroes. EXPECT_CALL(*mockCreateBufferMappedCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, _, Pointee(Eq(zero)), kBufferSize, _)) + Call(WGPUBufferMapAsyncStatus_Success, _, Pointee(Eq(zero)), kBufferSize, _)) .WillOnce(DoAll(::testing::SaveArg<1>(&buffer), - InvokeWithoutArgs([&]() { dawnBufferDestroy(buffer); }))); + InvokeWithoutArgs([&]() { wgpuBufferDestroy(buffer); }))); FlushServer(); diff --git a/src/tests/unittests/wire/WireErrorCallbackTests.cpp b/src/tests/unittests/wire/WireErrorCallbackTests.cpp index 55e0912447..18436fce52 100644 --- a/src/tests/unittests/wire/WireErrorCallbackTests.cpp +++ b/src/tests/unittests/wire/WireErrorCallbackTests.cpp @@ -22,21 +22,23 @@ namespace { // Mock classes to add expectations on the wire calling callbacks class MockDeviceErrorCallback { public: - MOCK_METHOD3(Call, void(DawnErrorType type, const char* message, void* userdata)); + MOCK_METHOD3(Call, void(WGPUErrorType type, const char* message, void* userdata)); }; std::unique_ptr> mockDeviceErrorCallback; - void ToMockDeviceErrorCallback(DawnErrorType type, const char* message, void* userdata) { + void ToMockDeviceErrorCallback(WGPUErrorType type, const char* message, void* userdata) { mockDeviceErrorCallback->Call(type, message, userdata); } class MockDevicePopErrorScopeCallback { public: - MOCK_METHOD3(Call, void(DawnErrorType type, const char* message, void* userdata)); + MOCK_METHOD3(Call, void(WGPUErrorType type, const char* message, void* userdata)); }; std::unique_ptr> mockDevicePopErrorScopeCallback; - void ToMockDevicePopErrorScopeCallback(DawnErrorType type, const char* message, void* userdata) { + void ToMockDevicePopErrorScopeCallback(WGPUErrorType type, + const char* message, + void* userdata) { mockDevicePopErrorScopeCallback->Call(type, message, userdata); } @@ -72,38 +74,42 @@ class WireErrorCallbackTests : public WireTest { // Test the return wire for device error callbacks TEST_F(WireErrorCallbackTests, DeviceErrorCallback) { - dawnDeviceSetUncapturedErrorCallback(device, ToMockDeviceErrorCallback, this); + wgpuDeviceSetUncapturedErrorCallback(device, ToMockDeviceErrorCallback, this); // Setting the error callback should stay on the client side and do nothing FlushClient(); // Calling the callback on the server side will result in the callback being called on the // client side - api.CallDeviceErrorCallback(apiDevice, DAWN_ERROR_TYPE_VALIDATION, "Some error message"); + api.CallDeviceErrorCallback(apiDevice, WGPUErrorType_Validation, "Some error message"); - EXPECT_CALL(*mockDeviceErrorCallback, Call(DAWN_ERROR_TYPE_VALIDATION, StrEq("Some error message"), this)).Times(1); + EXPECT_CALL(*mockDeviceErrorCallback, + Call(WGPUErrorType_Validation, StrEq("Some error message"), this)) + .Times(1); FlushServer(); } // Test the return wire for error scopes. TEST_F(WireErrorCallbackTests, PushPopErrorScopeCallback) { - dawnDevicePushErrorScope(device, DAWN_ERROR_FILTER_VALIDATION); - EXPECT_CALL(api, DevicePushErrorScope(apiDevice, DAWN_ERROR_FILTER_VALIDATION)).Times(1); + wgpuDevicePushErrorScope(device, WGPUErrorFilter_Validation); + EXPECT_CALL(api, DevicePushErrorScope(apiDevice, WGPUErrorFilter_Validation)).Times(1); FlushClient(); - dawnDevicePopErrorScope(device, ToMockDevicePopErrorScopeCallback, this); + wgpuDevicePopErrorScope(device, ToMockDevicePopErrorScopeCallback, this); - DawnErrorCallback callback; + WGPUErrorCallback callback; void* userdata; EXPECT_CALL(api, OnDevicePopErrorScopeCallback(apiDevice, _, _)) .WillOnce(DoAll(SaveArg<1>(&callback), SaveArg<2>(&userdata), Return(true))); FlushClient(); - callback(DAWN_ERROR_TYPE_VALIDATION, "Some error message", userdata); - EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(DAWN_ERROR_TYPE_VALIDATION, StrEq("Some error message"), this)).Times(1); + callback(WGPUErrorType_Validation, "Some error message", userdata); + EXPECT_CALL(*mockDevicePopErrorScopeCallback, + Call(WGPUErrorType_Validation, StrEq("Some error message"), this)) + .Times(1); FlushServer(); } @@ -112,17 +118,17 @@ TEST_F(WireErrorCallbackTests, PushPopErrorScopeCallback) { TEST_F(WireErrorCallbackTests, PopErrorScopeCallbackOrdering) { // Two error scopes are popped, and the first one returns first. { - dawnDevicePushErrorScope(device, DAWN_ERROR_FILTER_VALIDATION); - dawnDevicePushErrorScope(device, DAWN_ERROR_FILTER_VALIDATION); - EXPECT_CALL(api, DevicePushErrorScope(apiDevice, DAWN_ERROR_FILTER_VALIDATION)).Times(2); + wgpuDevicePushErrorScope(device, WGPUErrorFilter_Validation); + wgpuDevicePushErrorScope(device, WGPUErrorFilter_Validation); + EXPECT_CALL(api, DevicePushErrorScope(apiDevice, WGPUErrorFilter_Validation)).Times(2); FlushClient(); - dawnDevicePopErrorScope(device, ToMockDevicePopErrorScopeCallback, this); - dawnDevicePopErrorScope(device, ToMockDevicePopErrorScopeCallback, this + 1); + wgpuDevicePopErrorScope(device, ToMockDevicePopErrorScopeCallback, this); + wgpuDevicePopErrorScope(device, ToMockDevicePopErrorScopeCallback, this + 1); - DawnErrorCallback callback1; - DawnErrorCallback callback2; + WGPUErrorCallback callback1; + WGPUErrorCallback callback2; void* userdata1; void* userdata2; EXPECT_CALL(api, OnDevicePopErrorScopeCallback(apiDevice, _, _)) @@ -131,32 +137,32 @@ TEST_F(WireErrorCallbackTests, PopErrorScopeCallbackOrdering) { FlushClient(); - callback1(DAWN_ERROR_TYPE_VALIDATION, "First error message", userdata1); + callback1(WGPUErrorType_Validation, "First error message", userdata1); EXPECT_CALL(*mockDevicePopErrorScopeCallback, - Call(DAWN_ERROR_TYPE_VALIDATION, - StrEq("First error message"), this)).Times(1); + Call(WGPUErrorType_Validation, StrEq("First error message"), this)) + .Times(1); FlushServer(); - callback2(DAWN_ERROR_TYPE_VALIDATION, "Second error message", userdata2); + callback2(WGPUErrorType_Validation, "Second error message", userdata2); EXPECT_CALL(*mockDevicePopErrorScopeCallback, - Call(DAWN_ERROR_TYPE_VALIDATION, - StrEq("Second error message"), this + 1)).Times(1); + Call(WGPUErrorType_Validation, StrEq("Second error message"), this + 1)) + .Times(1); FlushServer(); } // Two error scopes are popped, and the second one returns first. { - dawnDevicePushErrorScope(device, DAWN_ERROR_FILTER_VALIDATION); - dawnDevicePushErrorScope(device, DAWN_ERROR_FILTER_VALIDATION); - EXPECT_CALL(api, DevicePushErrorScope(apiDevice, DAWN_ERROR_FILTER_VALIDATION)).Times(2); + wgpuDevicePushErrorScope(device, WGPUErrorFilter_Validation); + wgpuDevicePushErrorScope(device, WGPUErrorFilter_Validation); + EXPECT_CALL(api, DevicePushErrorScope(apiDevice, WGPUErrorFilter_Validation)).Times(2); FlushClient(); - dawnDevicePopErrorScope(device, ToMockDevicePopErrorScopeCallback, this); - dawnDevicePopErrorScope(device, ToMockDevicePopErrorScopeCallback, this + 1); + wgpuDevicePopErrorScope(device, ToMockDevicePopErrorScopeCallback, this); + wgpuDevicePopErrorScope(device, ToMockDevicePopErrorScopeCallback, this + 1); - DawnErrorCallback callback1; - DawnErrorCallback callback2; + WGPUErrorCallback callback1; + WGPUErrorCallback callback2; void* userdata1; void* userdata2; EXPECT_CALL(api, OnDevicePopErrorScopeCallback(apiDevice, _, _)) @@ -165,61 +171,63 @@ TEST_F(WireErrorCallbackTests, PopErrorScopeCallbackOrdering) { FlushClient(); - callback2(DAWN_ERROR_TYPE_VALIDATION, "Second error message", userdata2); + callback2(WGPUErrorType_Validation, "Second error message", userdata2); EXPECT_CALL(*mockDevicePopErrorScopeCallback, - Call(DAWN_ERROR_TYPE_VALIDATION, - StrEq("Second error message"), this + 1)).Times(1); + Call(WGPUErrorType_Validation, StrEq("Second error message"), this + 1)) + .Times(1); FlushServer(); - callback1(DAWN_ERROR_TYPE_VALIDATION, "First error message", userdata1); + callback1(WGPUErrorType_Validation, "First error message", userdata1); EXPECT_CALL(*mockDevicePopErrorScopeCallback, - Call(DAWN_ERROR_TYPE_VALIDATION, - StrEq("First error message"), this)).Times(1); + Call(WGPUErrorType_Validation, StrEq("First error message"), this)) + .Times(1); FlushServer(); } } // Test the return wire for error scopes in flight when the device is destroyed. TEST_F(WireErrorCallbackTests, PopErrorScopeDeviceDestroyed) { - dawnDevicePushErrorScope(device, DAWN_ERROR_FILTER_VALIDATION); - EXPECT_CALL(api, DevicePushErrorScope(apiDevice, DAWN_ERROR_FILTER_VALIDATION)).Times(1); + wgpuDevicePushErrorScope(device, WGPUErrorFilter_Validation); + EXPECT_CALL(api, DevicePushErrorScope(apiDevice, WGPUErrorFilter_Validation)).Times(1); FlushClient(); - EXPECT_TRUE(dawnDevicePopErrorScope(device, ToMockDevicePopErrorScopeCallback, this)); + EXPECT_TRUE(wgpuDevicePopErrorScope(device, ToMockDevicePopErrorScopeCallback, this)); EXPECT_CALL(api, OnDevicePopErrorScopeCallback(apiDevice, _, _)) .WillOnce(Return(true)); FlushClient(); // Incomplete callback called in Device destructor. - EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(DAWN_ERROR_TYPE_UNKNOWN, ValidStringMessage(), this)).Times(1); + EXPECT_CALL(*mockDevicePopErrorScopeCallback, + Call(WGPUErrorType_Unknown, ValidStringMessage(), this)) + .Times(1); } // Test that PopErrorScope returns false if there are no error scopes. TEST_F(WireErrorCallbackTests, PopErrorScopeEmptyStack) { // Empty stack - { - EXPECT_FALSE(dawnDevicePopErrorScope(device, ToMockDevicePopErrorScopeCallback, this)); - } + { EXPECT_FALSE(wgpuDevicePopErrorScope(device, ToMockDevicePopErrorScopeCallback, this)); } // Pop too many times { - dawnDevicePushErrorScope(device, DAWN_ERROR_FILTER_VALIDATION); - EXPECT_CALL(api, DevicePushErrorScope(apiDevice, DAWN_ERROR_FILTER_VALIDATION)).Times(1); + wgpuDevicePushErrorScope(device, WGPUErrorFilter_Validation); + EXPECT_CALL(api, DevicePushErrorScope(apiDevice, WGPUErrorFilter_Validation)).Times(1); - EXPECT_TRUE(dawnDevicePopErrorScope(device, ToMockDevicePopErrorScopeCallback, this)); - EXPECT_FALSE(dawnDevicePopErrorScope(device, ToMockDevicePopErrorScopeCallback, this + 1)); + EXPECT_TRUE(wgpuDevicePopErrorScope(device, ToMockDevicePopErrorScopeCallback, this)); + EXPECT_FALSE(wgpuDevicePopErrorScope(device, ToMockDevicePopErrorScopeCallback, this + 1)); - DawnErrorCallback callback; + WGPUErrorCallback callback; void* userdata; EXPECT_CALL(api, OnDevicePopErrorScopeCallback(apiDevice, _, _)) .WillOnce(DoAll(SaveArg<1>(&callback), SaveArg<2>(&userdata), Return(true))); FlushClient(); - callback(DAWN_ERROR_TYPE_VALIDATION, "Some error message", userdata); - EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(DAWN_ERROR_TYPE_VALIDATION, StrEq("Some error message"), this)).Times(1); + callback(WGPUErrorType_Validation, "Some error message", userdata); + EXPECT_CALL(*mockDevicePopErrorScopeCallback, + Call(WGPUErrorType_Validation, StrEq("Some error message"), this)) + .Times(1); FlushServer(); } diff --git a/src/tests/unittests/wire/WireFenceTests.cpp b/src/tests/unittests/wire/WireFenceTests.cpp index a91593e0c2..59d2b26039 100644 --- a/src/tests/unittests/wire/WireFenceTests.cpp +++ b/src/tests/unittests/wire/WireFenceTests.cpp @@ -21,11 +21,11 @@ namespace { class MockFenceOnCompletionCallback { public: - MOCK_METHOD2(Call, void(DawnFenceCompletionStatus status, void* userdata)); + MOCK_METHOD2(Call, void(WGPUFenceCompletionStatus status, void* userdata)); }; std::unique_ptr> mockFenceOnCompletionCallback; - void ToMockFenceOnCompletionCallback(DawnFenceCompletionStatus status, void* userdata) { + void ToMockFenceOnCompletionCallback(WGPUFenceCompletionStatus status, void* userdata) { mockFenceOnCompletionCallback->Call(status, userdata); } @@ -44,19 +44,19 @@ class WireFenceTests : public WireTest { std::make_unique>(); { - queue = dawnDeviceCreateQueue(device); + queue = wgpuDeviceCreateQueue(device); apiQueue = api.GetNewQueue(); EXPECT_CALL(api, DeviceCreateQueue(apiDevice)).WillOnce(Return(apiQueue)); FlushClient(); } { - DawnFenceDescriptor descriptor; + WGPUFenceDescriptor descriptor; descriptor.nextInChain = nullptr; descriptor.label = nullptr; descriptor.initialValue = 1; apiFence = api.GetNewFence(); - fence = dawnQueueCreateFence(queue, &descriptor); + fence = wgpuQueueCreateFence(queue, &descriptor); EXPECT_CALL(api, QueueCreateFence(apiQueue, _)).WillOnce(Return(apiFence)); FlushClient(); @@ -77,23 +77,23 @@ class WireFenceTests : public WireTest { protected: void DoQueueSignal(uint64_t signalValue) { - dawnQueueSignal(queue, fence, signalValue); + wgpuQueueSignal(queue, fence, signalValue); EXPECT_CALL(api, QueueSignal(apiQueue, apiFence, signalValue)).Times(1); // This callback is generated to update the completedValue of the fence // on the client EXPECT_CALL(api, OnFenceOnCompletionCallback(apiFence, signalValue, _, _)) .WillOnce(InvokeWithoutArgs([&]() { - api.CallFenceOnCompletionCallback(apiFence, DAWN_FENCE_COMPLETION_STATUS_SUCCESS); + api.CallFenceOnCompletionCallback(apiFence, WGPUFenceCompletionStatus_Success); })); } // A successfully created fence - DawnFence fence; - DawnFence apiFence; + WGPUFence fence; + WGPUFence apiFence; - DawnQueue queue; - DawnQueue apiQueue; + WGPUQueue queue; + WGPUQueue apiQueue; }; // Check that signaling a fence succeeds @@ -107,19 +107,22 @@ TEST_F(WireFenceTests, QueueSignalSuccess) { // Errors should be generated when signaling a value less // than or equal to the current signaled value TEST_F(WireFenceTests, QueueSignalValidationError) { - dawnQueueSignal(queue, fence, 0u); // Error - EXPECT_CALL(api, DeviceInjectError(apiDevice, DAWN_ERROR_TYPE_VALIDATION, ValidStringMessage())).Times(1); + wgpuQueueSignal(queue, fence, 0u); // Error + EXPECT_CALL(api, DeviceInjectError(apiDevice, WGPUErrorType_Validation, ValidStringMessage())) + .Times(1); FlushClient(); - dawnQueueSignal(queue, fence, 1u); // Error - EXPECT_CALL(api, DeviceInjectError(apiDevice, DAWN_ERROR_TYPE_VALIDATION, ValidStringMessage())).Times(1); + wgpuQueueSignal(queue, fence, 1u); // Error + EXPECT_CALL(api, DeviceInjectError(apiDevice, WGPUErrorType_Validation, ValidStringMessage())) + .Times(1); FlushClient(); DoQueueSignal(4u); // Success FlushClient(); - dawnQueueSignal(queue, fence, 3u); // Error - EXPECT_CALL(api, DeviceInjectError(apiDevice, DAWN_ERROR_TYPE_VALIDATION, ValidStringMessage())).Times(1); + wgpuQueueSignal(queue, fence, 3u); // Error + EXPECT_CALL(api, DeviceInjectError(apiDevice, WGPUErrorType_Validation, ValidStringMessage())) + .Times(1); FlushClient(); } @@ -127,16 +130,16 @@ TEST_F(WireFenceTests, QueueSignalValidationError) { TEST_F(WireFenceTests, OnCompletionImmediate) { // Can call on value < (initial) signaled value happens immediately { - EXPECT_CALL(*mockFenceOnCompletionCallback, Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, _)) + EXPECT_CALL(*mockFenceOnCompletionCallback, Call(WGPUFenceCompletionStatus_Success, _)) .Times(1); - dawnFenceOnCompletion(fence, 0, ToMockFenceOnCompletionCallback, nullptr); + wgpuFenceOnCompletion(fence, 0, ToMockFenceOnCompletionCallback, nullptr); } // Can call on value == (initial) signaled value happens immediately { - EXPECT_CALL(*mockFenceOnCompletionCallback, Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, _)) + EXPECT_CALL(*mockFenceOnCompletionCallback, Call(WGPUFenceCompletionStatus_Success, _)) .Times(1); - dawnFenceOnCompletion(fence, 1, ToMockFenceOnCompletionCallback, nullptr); + wgpuFenceOnCompletion(fence, 1, ToMockFenceOnCompletionCallback, nullptr); } } @@ -148,26 +151,22 @@ TEST_F(WireFenceTests, OnCompletionMultiple) { // Add callbacks in a non-monotonic order. They should still be called // in order of increasing fence value. // Add multiple callbacks for the same value. - dawnFenceOnCompletion(fence, 6, ToMockFenceOnCompletionCallback, this + 0); - dawnFenceOnCompletion(fence, 2, ToMockFenceOnCompletionCallback, this + 1); - dawnFenceOnCompletion(fence, 3, ToMockFenceOnCompletionCallback, this + 2); - dawnFenceOnCompletion(fence, 2, ToMockFenceOnCompletionCallback, this + 3); + wgpuFenceOnCompletion(fence, 6, ToMockFenceOnCompletionCallback, this + 0); + wgpuFenceOnCompletion(fence, 2, ToMockFenceOnCompletionCallback, this + 1); + wgpuFenceOnCompletion(fence, 3, ToMockFenceOnCompletionCallback, this + 2); + wgpuFenceOnCompletion(fence, 2, ToMockFenceOnCompletionCallback, this + 3); Sequence s1, s2; - EXPECT_CALL(*mockFenceOnCompletionCallback, - Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, this + 1)) + EXPECT_CALL(*mockFenceOnCompletionCallback, Call(WGPUFenceCompletionStatus_Success, this + 1)) .Times(1) .InSequence(s1); - EXPECT_CALL(*mockFenceOnCompletionCallback, - Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, this + 3)) + EXPECT_CALL(*mockFenceOnCompletionCallback, Call(WGPUFenceCompletionStatus_Success, this + 3)) .Times(1) .InSequence(s2); - EXPECT_CALL(*mockFenceOnCompletionCallback, - Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, this + 2)) + EXPECT_CALL(*mockFenceOnCompletionCallback, Call(WGPUFenceCompletionStatus_Success, this + 2)) .Times(1) .InSequence(s1, s2); - EXPECT_CALL(*mockFenceOnCompletionCallback, - Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, this + 0)) + EXPECT_CALL(*mockFenceOnCompletionCallback, Call(WGPUFenceCompletionStatus_Success, this + 0)) .Times(1) .InSequence(s1, s2); @@ -178,30 +177,31 @@ TEST_F(WireFenceTests, OnCompletionMultiple) { // Without any flushes, it is valid to wait on a value less than or equal to // the last signaled value TEST_F(WireFenceTests, OnCompletionSynchronousValidationSuccess) { - dawnQueueSignal(queue, fence, 4u); - dawnFenceOnCompletion(fence, 2u, ToMockFenceOnCompletionCallback, 0); - dawnFenceOnCompletion(fence, 3u, ToMockFenceOnCompletionCallback, 0); - dawnFenceOnCompletion(fence, 4u, ToMockFenceOnCompletionCallback, 0); + wgpuQueueSignal(queue, fence, 4u); + wgpuFenceOnCompletion(fence, 2u, ToMockFenceOnCompletionCallback, 0); + wgpuFenceOnCompletion(fence, 3u, ToMockFenceOnCompletionCallback, 0); + wgpuFenceOnCompletion(fence, 4u, ToMockFenceOnCompletionCallback, 0); - EXPECT_CALL(*mockFenceOnCompletionCallback, Call(DAWN_FENCE_COMPLETION_STATUS_UNKNOWN, _)) + EXPECT_CALL(*mockFenceOnCompletionCallback, Call(WGPUFenceCompletionStatus_Unknown, _)) .Times(3); } // Errors should be generated when waiting on a value greater // than the last signaled value TEST_F(WireFenceTests, OnCompletionValidationError) { - EXPECT_CALL(*mockFenceOnCompletionCallback, Call(DAWN_FENCE_COMPLETION_STATUS_ERROR, this + 0)) + EXPECT_CALL(*mockFenceOnCompletionCallback, Call(WGPUFenceCompletionStatus_Error, this + 0)) .Times(1); - dawnFenceOnCompletion(fence, 2u, ToMockFenceOnCompletionCallback, this + 0); + wgpuFenceOnCompletion(fence, 2u, ToMockFenceOnCompletionCallback, this + 0); - EXPECT_CALL(api, DeviceInjectError(apiDevice, DAWN_ERROR_TYPE_VALIDATION, ValidStringMessage())).Times(1); + EXPECT_CALL(api, DeviceInjectError(apiDevice, WGPUErrorType_Validation, ValidStringMessage())) + .Times(1); FlushClient(); } // Check that the fence completed value is initialized TEST_F(WireFenceTests, GetCompletedValueInitialization) { - EXPECT_EQ(dawnFenceGetCompletedValue(fence), 1u); + EXPECT_EQ(wgpuFenceGetCompletedValue(fence), 1u); } // Check that the fence completed value updates after signaling the fence @@ -210,55 +210,57 @@ TEST_F(WireFenceTests, GetCompletedValueUpdate) { FlushClient(); FlushServer(); - EXPECT_EQ(dawnFenceGetCompletedValue(fence), 3u); + EXPECT_EQ(wgpuFenceGetCompletedValue(fence), 3u); } // Check that the fence completed value does not update without a flush TEST_F(WireFenceTests, GetCompletedValueNoUpdate) { - dawnQueueSignal(queue, fence, 3u); - EXPECT_EQ(dawnFenceGetCompletedValue(fence), 1u); + wgpuQueueSignal(queue, fence, 3u); + EXPECT_EQ(wgpuFenceGetCompletedValue(fence), 1u); } // Check that the callback is called with UNKNOWN when the fence is destroyed // before the completed value is updated TEST_F(WireFenceTests, DestroyBeforeOnCompletionEnd) { - dawnQueueSignal(queue, fence, 3u); - dawnFenceOnCompletion(fence, 2u, ToMockFenceOnCompletionCallback, nullptr); - EXPECT_CALL(*mockFenceOnCompletionCallback, Call(DAWN_FENCE_COMPLETION_STATUS_UNKNOWN, _)) + wgpuQueueSignal(queue, fence, 3u); + wgpuFenceOnCompletion(fence, 2u, ToMockFenceOnCompletionCallback, nullptr); + EXPECT_CALL(*mockFenceOnCompletionCallback, Call(WGPUFenceCompletionStatus_Unknown, _)) .Times(1); } // Test that signaling a fence on a wrong queue is invalid TEST_F(WireFenceTests, SignalWrongQueue) { - DawnQueue queue2 = dawnDeviceCreateQueue(device); - DawnQueue apiQueue2 = api.GetNewQueue(); + WGPUQueue queue2 = wgpuDeviceCreateQueue(device); + WGPUQueue apiQueue2 = api.GetNewQueue(); EXPECT_CALL(api, DeviceCreateQueue(apiDevice)).WillOnce(Return(apiQueue2)); FlushClient(); - dawnQueueSignal(queue2, fence, 2u); // error - EXPECT_CALL(api, DeviceInjectError(apiDevice, DAWN_ERROR_TYPE_VALIDATION, ValidStringMessage())).Times(1); + wgpuQueueSignal(queue2, fence, 2u); // error + EXPECT_CALL(api, DeviceInjectError(apiDevice, WGPUErrorType_Validation, ValidStringMessage())) + .Times(1); FlushClient(); } // Test that signaling a fence on a wrong queue does not update fence signaled value TEST_F(WireFenceTests, SignalWrongQueueDoesNotUpdateValue) { - DawnQueue queue2 = dawnDeviceCreateQueue(device); - DawnQueue apiQueue2 = api.GetNewQueue(); + WGPUQueue queue2 = wgpuDeviceCreateQueue(device); + WGPUQueue apiQueue2 = api.GetNewQueue(); EXPECT_CALL(api, DeviceCreateQueue(apiDevice)).WillOnce(Return(apiQueue2)); FlushClient(); - dawnQueueSignal(queue2, fence, 2u); // error - EXPECT_CALL(api, DeviceInjectError(apiDevice, DAWN_ERROR_TYPE_VALIDATION, ValidStringMessage())).Times(1); + wgpuQueueSignal(queue2, fence, 2u); // error + EXPECT_CALL(api, DeviceInjectError(apiDevice, WGPUErrorType_Validation, ValidStringMessage())) + .Times(1); FlushClient(); // Fence value should be unchanged. FlushClient(); FlushServer(); - EXPECT_EQ(dawnFenceGetCompletedValue(fence), 1u); + EXPECT_EQ(wgpuFenceGetCompletedValue(fence), 1u); // Signaling with 2 on the correct queue should succeed DoQueueSignal(2u); // success FlushClient(); FlushServer(); - EXPECT_EQ(dawnFenceGetCompletedValue(fence), 2u); + EXPECT_EQ(wgpuFenceGetCompletedValue(fence), 2u); } diff --git a/src/tests/unittests/wire/WireInjectTextureTests.cpp b/src/tests/unittests/wire/WireInjectTextureTests.cpp index d5dea81e27..9e327cf5b1 100644 --- a/src/tests/unittests/wire/WireInjectTextureTests.cpp +++ b/src/tests/unittests/wire/WireInjectTextureTests.cpp @@ -32,12 +32,12 @@ class WireInjectTextureTests : public WireTest { TEST_F(WireInjectTextureTests, CallAfterReserveInject) { ReservedTexture reservation = GetWireClient()->ReserveTexture(device); - DawnTexture apiTexture = api.GetNewTexture(); + WGPUTexture apiTexture = api.GetNewTexture(); EXPECT_CALL(api, TextureReference(apiTexture)); ASSERT_TRUE(GetWireServer()->InjectTexture(apiTexture, reservation.id, reservation.generation)); - dawnTextureCreateView(reservation.texture, nullptr); - DawnTextureView apiDummyView = api.GetNewTextureView(); + wgpuTextureCreateView(reservation.texture, nullptr); + WGPUTextureView apiDummyView = api.GetNewTextureView(); EXPECT_CALL(api, TextureCreateView(apiTexture, nullptr)).WillOnce(Return(apiDummyView)); FlushClient(); } @@ -55,7 +55,7 @@ TEST_F(WireInjectTextureTests, ReserveDifferentIDs) { TEST_F(WireInjectTextureTests, InjectExistingID) { ReservedTexture reservation = GetWireClient()->ReserveTexture(device); - DawnTexture apiTexture = api.GetNewTexture(); + WGPUTexture apiTexture = api.GetNewTexture(); EXPECT_CALL(api, TextureReference(apiTexture)); ASSERT_TRUE(GetWireServer()->InjectTexture(apiTexture, reservation.id, reservation.generation)); @@ -69,12 +69,12 @@ TEST_F(WireInjectTextureTests, InjectedTextureLifetime) { ReservedTexture reservation = GetWireClient()->ReserveTexture(device); // Injecting the texture adds a reference - DawnTexture apiTexture = api.GetNewTexture(); + WGPUTexture apiTexture = api.GetNewTexture(); EXPECT_CALL(api, TextureReference(apiTexture)); ASSERT_TRUE(GetWireServer()->InjectTexture(apiTexture, reservation.id, reservation.generation)); // Releasing the texture removes a single reference. - dawnTextureRelease(reservation.texture); + wgpuTextureRelease(reservation.texture); EXPECT_CALL(api, TextureRelease(apiTexture)); FlushClient(); diff --git a/src/tests/unittests/wire/WireMemoryTransferServiceTests.cpp b/src/tests/unittests/wire/WireMemoryTransferServiceTests.cpp index b0f5f9d4f7..a4f085b6c4 100644 --- a/src/tests/unittests/wire/WireMemoryTransferServiceTests.cpp +++ b/src/tests/unittests/wire/WireMemoryTransferServiceTests.cpp @@ -26,14 +26,14 @@ namespace { class MockBufferMapReadCallback { public: MOCK_METHOD4(Call, - void(DawnBufferMapAsyncStatus status, + void(WGPUBufferMapAsyncStatus status, const uint32_t* ptr, uint64_t dataLength, void* userdata)); }; std::unique_ptr> mockBufferMapReadCallback; - void ToMockBufferMapReadCallback(DawnBufferMapAsyncStatus status, + void ToMockBufferMapReadCallback(WGPUBufferMapAsyncStatus status, const void* ptr, uint64_t dataLength, void* userdata) { @@ -45,14 +45,14 @@ namespace { class MockBufferMapWriteCallback { public: MOCK_METHOD4(Call, - void(DawnBufferMapAsyncStatus status, + void(WGPUBufferMapAsyncStatus status, uint32_t* ptr, uint64_t dataLength, void* userdata)); }; std::unique_ptr> mockBufferMapWriteCallback; - void ToMockBufferMapWriteCallback(DawnBufferMapAsyncStatus status, + void ToMockBufferMapWriteCallback(WGPUBufferMapAsyncStatus status, void* ptr, uint64_t dataLength, void* userdata) { @@ -63,16 +63,16 @@ namespace { class MockBufferCreateMappedCallback { public: MOCK_METHOD5(Call, - void(DawnBufferMapAsyncStatus status, - DawnBuffer buffer, + void(WGPUBufferMapAsyncStatus status, + WGPUBuffer buffer, uint32_t* ptr, uint64_t dataLength, void* userdata)); }; std::unique_ptr> mockCreateBufferMappedCallback; - void ToMockCreateBufferMappedCallback(DawnBufferMapAsyncStatus status, - DawnCreateBufferMappedResult result, + void ToMockCreateBufferMappedCallback(WGPUBufferMapAsyncStatus status, + WGPUCreateBufferMappedResult result, void* userdata) { // Assume the data is uint32_t to make writing matchers easier mockCreateBufferMappedCallback->Call(status, result.buffer, @@ -154,14 +154,14 @@ class WireMemoryTransferServiceTests : public WireTest { using ClientWriteHandle = client::MockMemoryTransferService::MockWriteHandle; using ServerWriteHandle = server::MockMemoryTransferService::MockWriteHandle; - std::pair CreateBuffer() { - DawnBufferDescriptor descriptor; + std::pair CreateBuffer() { + WGPUBufferDescriptor descriptor; descriptor.nextInChain = nullptr; descriptor.label = nullptr; descriptor.size = sizeof(mBufferContent); - DawnBuffer apiBuffer = api.GetNewBuffer(); - DawnBuffer buffer = dawnDeviceCreateBuffer(device, &descriptor); + WGPUBuffer apiBuffer = api.GetNewBuffer(); + WGPUBuffer buffer = wgpuDeviceCreateBuffer(device, &descriptor); EXPECT_CALL(api, DeviceCreateBuffer(apiDevice, _)) .WillOnce(Return(apiBuffer)) @@ -170,20 +170,20 @@ class WireMemoryTransferServiceTests : public WireTest { return std::make_pair(apiBuffer, buffer); } - std::pair CreateBufferMapped() { - DawnBufferDescriptor descriptor; + std::pair CreateBufferMapped() { + WGPUBufferDescriptor descriptor; descriptor.nextInChain = nullptr; descriptor.label = nullptr; descriptor.size = sizeof(mBufferContent); - DawnBuffer apiBuffer = api.GetNewBuffer(); + WGPUBuffer apiBuffer = api.GetNewBuffer(); - DawnCreateBufferMappedResult apiResult; + WGPUCreateBufferMappedResult apiResult; apiResult.buffer = apiBuffer; apiResult.data = reinterpret_cast(&mMappedBufferContent); apiResult.dataLength = sizeof(mMappedBufferContent); - DawnCreateBufferMappedResult result = dawnDeviceCreateBufferMapped(device, &descriptor); + WGPUCreateBufferMappedResult result = wgpuDeviceCreateBufferMapped(device, &descriptor); EXPECT_CALL(api, DeviceCreateBufferMapped(apiDevice, _)) .WillOnce(Return(apiResult)) @@ -192,18 +192,18 @@ class WireMemoryTransferServiceTests : public WireTest { return std::make_pair(apiResult, result); } - DawnCreateBufferMappedResult CreateBufferMappedAsync() { - DawnBufferDescriptor descriptor; + WGPUCreateBufferMappedResult CreateBufferMappedAsync() { + WGPUBufferDescriptor descriptor; descriptor.nextInChain = nullptr; descriptor.label = nullptr; descriptor.size = sizeof(mBufferContent); - dawnDeviceCreateBufferMappedAsync(device, &descriptor, ToMockCreateBufferMappedCallback, + wgpuDeviceCreateBufferMappedAsync(device, &descriptor, ToMockCreateBufferMappedCallback, nullptr); - DawnBuffer apiBuffer = api.GetNewBuffer(); + WGPUBuffer apiBuffer = api.GetNewBuffer(); - DawnCreateBufferMappedResult apiResult; + WGPUCreateBufferMappedResult apiResult; apiResult.buffer = apiBuffer; apiResult.data = reinterpret_cast(&mMappedBufferContent); apiResult.dataLength = sizeof(mMappedBufferContent); @@ -416,8 +416,8 @@ uint32_t WireMemoryTransferServiceTests::mSerializeFlushInfo = 1235; // Test successful MapRead. TEST_F(WireMemoryTransferServiceTests, BufferMapReadSuccess) { - DawnBuffer buffer; - DawnBuffer apiBuffer; + WGPUBuffer buffer; + WGPUBuffer apiBuffer; std::tie(apiBuffer, buffer) = CreateBuffer(); FlushClient(); @@ -425,7 +425,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapReadSuccess) { ClientReadHandle* clientHandle = ExpectReadHandleCreation(); ExpectReadHandleSerialization(clientHandle); - dawnBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr); + wgpuBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr); // The server should deserialize the MapRead handle from the client and then serialize // an initialization message. @@ -435,7 +435,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapReadSuccess) { // Mock a successful callback EXPECT_CALL(api, OnBufferMapReadAsyncCallback(apiBuffer, _, _)) .WillOnce(InvokeWithoutArgs([&]() { - api.CallMapReadCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, &mBufferContent, + api.CallMapReadCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success, &mBufferContent, sizeof(mBufferContent)); })); @@ -443,8 +443,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapReadSuccess) { // The client receives a successful callback. EXPECT_CALL(*mockBufferMapReadCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, &mBufferContent, - sizeof(mBufferContent), _)) + Call(WGPUBufferMapAsyncStatus_Success, &mBufferContent, sizeof(mBufferContent), _)) .Times(1); // The client should receive the handle initialization message from the server. @@ -454,7 +453,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapReadSuccess) { // The handle is destroyed once the buffer is unmapped. EXPECT_CALL(clientMemoryTransferService, OnReadHandleDestroy(clientHandle)).Times(1); - dawnBufferUnmap(buffer); + wgpuBufferUnmap(buffer); EXPECT_CALL(serverMemoryTransferService, OnReadHandleDestroy(serverHandle)).Times(1); EXPECT_CALL(api, BufferUnmap(apiBuffer)).Times(1); @@ -464,8 +463,8 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapReadSuccess) { // Test unsuccessful MapRead. TEST_F(WireMemoryTransferServiceTests, BufferMapReadError) { - DawnBuffer buffer; - DawnBuffer apiBuffer; + WGPUBuffer buffer; + WGPUBuffer apiBuffer; std::tie(apiBuffer, buffer) = CreateBuffer(); FlushClient(); @@ -473,7 +472,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapReadError) { ClientReadHandle* clientHandle = ExpectReadHandleCreation(); ExpectReadHandleSerialization(clientHandle); - dawnBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr); + wgpuBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr); // The server should deserialize the ReadHandle from the client. ServerReadHandle* serverHandle = ExpectServerReadHandleDeserialize(); @@ -481,7 +480,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapReadError) { // Mock a failed callback. EXPECT_CALL(api, OnBufferMapReadAsyncCallback(apiBuffer, _, _)) .WillOnce(InvokeWithoutArgs([&]() { - api.CallMapReadCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, 0); + api.CallMapReadCallback(apiBuffer, WGPUBufferMapAsyncStatus_Error, nullptr, 0); })); // Since the mapping failed, the handle is immediately destroyed. @@ -490,7 +489,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapReadError) { FlushClient(); // The client receives an error callback. - EXPECT_CALL(*mockBufferMapReadCallback, Call(DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, 0, _)) + EXPECT_CALL(*mockBufferMapReadCallback, Call(WGPUBufferMapAsyncStatus_Error, nullptr, 0, _)) .Times(1); // The client receives the map failure and destroys the handle. @@ -498,7 +497,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapReadError) { FlushServer(); - dawnBufferUnmap(buffer); + wgpuBufferUnmap(buffer); EXPECT_CALL(api, BufferUnmap(apiBuffer)).Times(1); @@ -507,8 +506,8 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapReadError) { // Test MapRead ReadHandle creation failure. TEST_F(WireMemoryTransferServiceTests, BufferMapReadHandleCreationFailure) { - DawnBuffer buffer; - DawnBuffer apiBuffer; + WGPUBuffer buffer; + WGPUBuffer apiBuffer; std::tie(apiBuffer, buffer) = CreateBuffer(); FlushClient(); @@ -518,16 +517,16 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapReadHandleCreationFailure) { // Failed creation of a ReadHandle is a fatal failure and the client synchronously receives a // DEVICE_LOST callback. EXPECT_CALL(*mockBufferMapReadCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_DEVICE_LOST, nullptr, 0, _)) + Call(WGPUBufferMapAsyncStatus_DeviceLost, nullptr, 0, _)) .Times(1); - dawnBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr); + wgpuBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr); } // Test MapRead DeserializeReadHandle failure. TEST_F(WireMemoryTransferServiceTests, BufferMapReadDeserializeReadHandleFailure) { - DawnBuffer buffer; - DawnBuffer apiBuffer; + WGPUBuffer buffer; + WGPUBuffer apiBuffer; std::tie(apiBuffer, buffer) = CreateBuffer(); FlushClient(); @@ -535,7 +534,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapReadDeserializeReadHandleFailure ClientReadHandle* clientHandle = ExpectReadHandleCreation(); ExpectReadHandleSerialization(clientHandle); - dawnBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr); + wgpuBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr); // Mock a Deserialization failure. MockServerReadHandleDeserializeFailure(); @@ -544,8 +543,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapReadDeserializeReadHandleFailure // The server received a fatal failure and the client callback was never returned. // It is called when the wire is destructed. - EXPECT_CALL(*mockBufferMapReadCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, nullptr, 0, _)) + EXPECT_CALL(*mockBufferMapReadCallback, Call(WGPUBufferMapAsyncStatus_Unknown, nullptr, 0, _)) .Times(1); EXPECT_CALL(clientMemoryTransferService, OnReadHandleDestroy(clientHandle)).Times(1); @@ -553,8 +551,8 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapReadDeserializeReadHandleFailure // Test MapRead DeserializeInitialData failure. TEST_F(WireMemoryTransferServiceTests, BufferMapReadDeserializeInitialDataFailure) { - DawnBuffer buffer; - DawnBuffer apiBuffer; + WGPUBuffer buffer; + WGPUBuffer apiBuffer; std::tie(apiBuffer, buffer) = CreateBuffer(); FlushClient(); @@ -562,7 +560,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapReadDeserializeInitialDataFailur ClientReadHandle* clientHandle = ExpectReadHandleCreation(); ExpectReadHandleSerialization(clientHandle); - dawnBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr); + wgpuBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr); // The server should deserialize the MapRead handle from the client and then serialize // an initialization message. @@ -572,7 +570,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapReadDeserializeInitialDataFailur // Mock a successful callback EXPECT_CALL(api, OnBufferMapReadAsyncCallback(apiBuffer, _, _)) .WillOnce(InvokeWithoutArgs([&]() { - api.CallMapReadCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, &mBufferContent, + api.CallMapReadCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success, &mBufferContent, sizeof(mBufferContent)); })); @@ -585,7 +583,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapReadDeserializeInitialDataFailur // Failed deserialization is a fatal failure and the client synchronously receives a // DEVICE_LOST callback. EXPECT_CALL(*mockBufferMapReadCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_DEVICE_LOST, nullptr, 0, _)) + Call(WGPUBufferMapAsyncStatus_DeviceLost, nullptr, 0, _)) .Times(1); // The handle will be destroyed since deserializing failed. @@ -598,15 +596,15 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapReadDeserializeInitialDataFailur // Test successful MapWrite. TEST_F(WireMemoryTransferServiceTests, BufferMapWriteSuccess) { - DawnBuffer buffer; - DawnBuffer apiBuffer; + WGPUBuffer buffer; + WGPUBuffer apiBuffer; std::tie(apiBuffer, buffer) = CreateBuffer(); FlushClient(); ClientWriteHandle* clientHandle = ExpectWriteHandleCreation(); ExpectWriteHandleSerialization(clientHandle); - dawnBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr); + wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr); // The server should then deserialize the WriteHandle from the client. ServerWriteHandle* serverHandle = ExpectServerWriteHandleDeserialization(); @@ -614,7 +612,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapWriteSuccess) { // Mock a successful callback. EXPECT_CALL(api, OnBufferMapWriteAsyncCallback(apiBuffer, _, _)) .WillOnce(InvokeWithoutArgs([&]() { - api.CallMapWriteCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, + api.CallMapWriteCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success, &mMappedBufferContent, sizeof(mMappedBufferContent)); })); @@ -622,7 +620,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapWriteSuccess) { // The client receives a successful callback. EXPECT_CALL(*mockBufferMapWriteCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, &mMappedBufferContent, + Call(WGPUBufferMapAsyncStatus_Success, &mMappedBufferContent, sizeof(mMappedBufferContent), _)) .Times(1); @@ -638,7 +636,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapWriteSuccess) { ExpectClientWriteHandleSerializeFlush(clientHandle); EXPECT_CALL(clientMemoryTransferService, OnWriteHandleDestroy(clientHandle)).Times(1); - dawnBufferUnmap(buffer); + wgpuBufferUnmap(buffer); // The server deserializes the Flush message. ExpectServerWriteHandleDeserializeFlush(serverHandle, mUpdatedBufferContent); @@ -652,8 +650,8 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapWriteSuccess) { // Test unsuccessful MapWrite. TEST_F(WireMemoryTransferServiceTests, BufferMapWriteError) { - DawnBuffer buffer; - DawnBuffer apiBuffer; + WGPUBuffer buffer; + WGPUBuffer apiBuffer; std::tie(apiBuffer, buffer) = CreateBuffer(); FlushClient(); @@ -661,7 +659,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapWriteError) { ClientWriteHandle* clientHandle = ExpectWriteHandleCreation(); ExpectWriteHandleSerialization(clientHandle); - dawnBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr); + wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr); // The server should then deserialize the WriteHandle from the client. ServerWriteHandle* serverHandle = ExpectServerWriteHandleDeserialization(); @@ -669,7 +667,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapWriteError) { // Mock an error callback. EXPECT_CALL(api, OnBufferMapWriteAsyncCallback(apiBuffer, _, _)) .WillOnce(InvokeWithoutArgs([&]() { - api.CallMapWriteCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, 0); + api.CallMapWriteCallback(apiBuffer, WGPUBufferMapAsyncStatus_Error, nullptr, 0); })); // Since the mapping fails, the handle is immediately destroyed because it won't be written. @@ -678,8 +676,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapWriteError) { FlushClient(); // The client receives an error callback. - EXPECT_CALL(*mockBufferMapWriteCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, 0, _)) + EXPECT_CALL(*mockBufferMapWriteCallback, Call(WGPUBufferMapAsyncStatus_Error, nullptr, 0, _)) .Times(1); // Client receives the map failure and destroys the handle. @@ -687,7 +684,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapWriteError) { FlushServer(); - dawnBufferUnmap(buffer); + wgpuBufferUnmap(buffer); EXPECT_CALL(api, BufferUnmap(apiBuffer)).Times(1); @@ -696,8 +693,8 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapWriteError) { // Test MapRead WriteHandle creation failure. TEST_F(WireMemoryTransferServiceTests, BufferMapWriteHandleCreationFailure) { - DawnBuffer buffer; - DawnBuffer apiBuffer; + WGPUBuffer buffer; + WGPUBuffer apiBuffer; std::tie(apiBuffer, buffer) = CreateBuffer(); FlushClient(); @@ -707,16 +704,16 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapWriteHandleCreationFailure) { // Failed creation of a WriteHandle is a fatal failure and the client synchronously receives a // DEVICE_LOST callback. EXPECT_CALL(*mockBufferMapWriteCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_DEVICE_LOST, nullptr, 0, _)) + Call(WGPUBufferMapAsyncStatus_DeviceLost, nullptr, 0, _)) .Times(1); - dawnBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr); + wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr); } // Test MapWrite DeserializeWriteHandle failure. TEST_F(WireMemoryTransferServiceTests, BufferMapWriteDeserializeWriteHandleFailure) { - DawnBuffer buffer; - DawnBuffer apiBuffer; + WGPUBuffer buffer; + WGPUBuffer apiBuffer; std::tie(apiBuffer, buffer) = CreateBuffer(); FlushClient(); @@ -724,7 +721,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapWriteDeserializeWriteHandleFailu ClientWriteHandle* clientHandle = ExpectWriteHandleCreation(); ExpectWriteHandleSerialization(clientHandle); - dawnBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr); + wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr); // Mock a deserialization failure. MockServerWriteHandleDeserializeFailure(); @@ -733,8 +730,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapWriteDeserializeWriteHandleFailu // The server hit a fatal failure and never returned the callback. The client callback is // called when the wire is destructed. - EXPECT_CALL(*mockBufferMapWriteCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, nullptr, 0, _)) + EXPECT_CALL(*mockBufferMapWriteCallback, Call(WGPUBufferMapAsyncStatus_Unknown, nullptr, 0, _)) .Times(1); EXPECT_CALL(clientMemoryTransferService, OnWriteHandleDestroy(clientHandle)).Times(1); @@ -742,15 +738,15 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapWriteDeserializeWriteHandleFailu // Test MapWrite handle Open failure. TEST_F(WireMemoryTransferServiceTests, BufferMapWriteHandleOpenFailure) { - DawnBuffer buffer; - DawnBuffer apiBuffer; + WGPUBuffer buffer; + WGPUBuffer apiBuffer; std::tie(apiBuffer, buffer) = CreateBuffer(); FlushClient(); ClientWriteHandle* clientHandle = ExpectWriteHandleCreation(); ExpectWriteHandleSerialization(clientHandle); - dawnBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr); + wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr); // The server should then deserialize the WriteHandle from the client. ServerWriteHandle* serverHandle = ExpectServerWriteHandleDeserialization(); @@ -758,7 +754,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapWriteHandleOpenFailure) { // Mock a successful callback. EXPECT_CALL(api, OnBufferMapWriteAsyncCallback(apiBuffer, _, _)) .WillOnce(InvokeWithoutArgs([&]() { - api.CallMapWriteCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, + api.CallMapWriteCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success, &mMappedBufferContent, sizeof(mMappedBufferContent)); })); @@ -770,7 +766,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapWriteHandleOpenFailure) { // Failing to open a handle is a fatal failure and the client receives a DEVICE_LOST callback. EXPECT_CALL(*mockBufferMapWriteCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_DEVICE_LOST, nullptr, 0, _)) + Call(WGPUBufferMapAsyncStatus_DeviceLost, nullptr, 0, _)) .Times(1); // Since opening the handle fails, it gets destroyed immediately. @@ -783,15 +779,15 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapWriteHandleOpenFailure) { // Test MapWrite DeserializeFlush failure. TEST_F(WireMemoryTransferServiceTests, BufferMapWriteDeserializeFlushFailure) { - DawnBuffer buffer; - DawnBuffer apiBuffer; + WGPUBuffer buffer; + WGPUBuffer apiBuffer; std::tie(apiBuffer, buffer) = CreateBuffer(); FlushClient(); ClientWriteHandle* clientHandle = ExpectWriteHandleCreation(); ExpectWriteHandleSerialization(clientHandle); - dawnBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr); + wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr); // The server should then deserialize the WriteHandle from the client. ServerWriteHandle* serverHandle = ExpectServerWriteHandleDeserialization(); @@ -799,7 +795,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapWriteDeserializeFlushFailure) { // Mock a successful callback. EXPECT_CALL(api, OnBufferMapWriteAsyncCallback(apiBuffer, _, _)) .WillOnce(InvokeWithoutArgs([&]() { - api.CallMapWriteCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, + api.CallMapWriteCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success, &mMappedBufferContent, sizeof(mMappedBufferContent)); })); @@ -807,7 +803,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapWriteDeserializeFlushFailure) { // The client receives a success callback. EXPECT_CALL(*mockBufferMapWriteCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, &mMappedBufferContent, + Call(WGPUBufferMapAsyncStatus_Success, &mMappedBufferContent, sizeof(mMappedBufferContent), _)) .Times(1); @@ -823,7 +819,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapWriteDeserializeFlushFailure) { ExpectClientWriteHandleSerializeFlush(clientHandle); EXPECT_CALL(clientMemoryTransferService, OnWriteHandleDestroy(clientHandle)).Times(1); - dawnBufferUnmap(buffer); + wgpuBufferUnmap(buffer); // The server deserializes the Flush message. Mock a deserialization failure. MockServerWriteHandleDeserializeFlushFailure(serverHandle); @@ -839,7 +835,7 @@ TEST_F(WireMemoryTransferServiceTests, CreateBufferMappedAsyncSuccess) { ClientWriteHandle* clientHandle = ExpectWriteHandleCreation(); ExpectWriteHandleSerialization(clientHandle); - DawnCreateBufferMappedResult apiResult = CreateBufferMappedAsync(); + WGPUCreateBufferMappedResult apiResult = CreateBufferMappedAsync(); // The server should then deserialize the WriteHandle from the client. ServerWriteHandle* serverHandle = ExpectServerWriteHandleDeserialization(); @@ -847,9 +843,9 @@ TEST_F(WireMemoryTransferServiceTests, CreateBufferMappedAsyncSuccess) { FlushClient(); // The client receives a success callback. Save the buffer argument so we can call Unmap. - DawnBuffer buffer; + WGPUBuffer buffer; EXPECT_CALL(*mockCreateBufferMappedCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, _, &mMappedBufferContent, + Call(WGPUBufferMapAsyncStatus_Success, _, &mMappedBufferContent, sizeof(mMappedBufferContent), _)) .WillOnce(SaveArg<1>(&buffer)); @@ -866,7 +862,7 @@ TEST_F(WireMemoryTransferServiceTests, CreateBufferMappedAsyncSuccess) { ExpectClientWriteHandleSerializeFlush(clientHandle); EXPECT_CALL(clientMemoryTransferService, OnWriteHandleDestroy(clientHandle)).Times(1); - dawnBufferUnmap(buffer); + wgpuBufferUnmap(buffer); // The server deserializes the Flush message. ExpectServerWriteHandleDeserializeFlush(serverHandle, mUpdatedBufferContent); @@ -883,7 +879,7 @@ TEST_F(WireMemoryTransferServiceTests, CreateBufferMappedAsyncWriteHandleCreatio // Mock a WriteHandle creation failure MockWriteHandleCreationFailure(); - DawnBufferDescriptor descriptor; + WGPUBufferDescriptor descriptor; descriptor.nextInChain = nullptr; descriptor.label = nullptr; descriptor.size = sizeof(mBufferContent); @@ -891,10 +887,11 @@ TEST_F(WireMemoryTransferServiceTests, CreateBufferMappedAsyncWriteHandleCreatio // Failed creation of a WriteHandle is a fatal failure. The client synchronously receives // a DEVICE_LOST callback. EXPECT_CALL(*mockCreateBufferMappedCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_DEVICE_LOST, _, nullptr, 0, _)) + Call(WGPUBufferMapAsyncStatus_DeviceLost, _, nullptr, 0, _)) .Times(1); - dawnDeviceCreateBufferMappedAsync(device, &descriptor, ToMockCreateBufferMappedCallback, nullptr); + wgpuDeviceCreateBufferMappedAsync(device, &descriptor, ToMockCreateBufferMappedCallback, + nullptr); } // Test CreateBufferMappedAsync DeserializeWriteHandle failure. @@ -903,7 +900,7 @@ TEST_F(WireMemoryTransferServiceTests, CreateBufferMappedAsyncDeserializeWriteHa ClientWriteHandle* clientHandle = ExpectWriteHandleCreation(); ExpectWriteHandleSerialization(clientHandle); - DawnCreateBufferMappedResult apiResult = CreateBufferMappedAsync(); + WGPUCreateBufferMappedResult apiResult = CreateBufferMappedAsync(); DAWN_UNUSED(apiResult); // The server should then deserialize the WriteHandle from the client. @@ -915,7 +912,7 @@ TEST_F(WireMemoryTransferServiceTests, CreateBufferMappedAsyncDeserializeWriteHa // The server hit a fatal failure and never returned the callback. It is called when the // wire is destructed. EXPECT_CALL(*mockCreateBufferMappedCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, _, nullptr, 0, _)) + Call(WGPUBufferMapAsyncStatus_Unknown, _, nullptr, 0, _)) .Times(1); EXPECT_CALL(clientMemoryTransferService, OnWriteHandleDestroy(clientHandle)).Times(1); @@ -927,7 +924,7 @@ TEST_F(WireMemoryTransferServiceTests, CreateBufferMappedAsyncHandleOpenFailure) ClientWriteHandle* clientHandle = ExpectWriteHandleCreation(); ExpectWriteHandleSerialization(clientHandle); - DawnCreateBufferMappedResult apiResult = CreateBufferMappedAsync(); + WGPUCreateBufferMappedResult apiResult = CreateBufferMappedAsync(); DAWN_UNUSED(apiResult); // The server should then deserialize the WriteHandle from the client. @@ -940,7 +937,7 @@ TEST_F(WireMemoryTransferServiceTests, CreateBufferMappedAsyncHandleOpenFailure) // Failing to open a handle is a fatal failure. The client receives a DEVICE_LOST callback. EXPECT_CALL(*mockCreateBufferMappedCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_DEVICE_LOST, _, nullptr, 0, _)) + Call(WGPUBufferMapAsyncStatus_DeviceLost, _, nullptr, 0, _)) .Times(1); // Since opening the handle fails, it is destroyed immediately. @@ -957,7 +954,7 @@ TEST_F(WireMemoryTransferServiceTests, CreateBufferMappedAsyncDeserializeFlushFa ClientWriteHandle* clientHandle = ExpectWriteHandleCreation(); ExpectWriteHandleSerialization(clientHandle); - DawnCreateBufferMappedResult apiResult = CreateBufferMappedAsync(); + WGPUCreateBufferMappedResult apiResult = CreateBufferMappedAsync(); DAWN_UNUSED(apiResult); // The server should then deserialize the WriteHandle from the client. @@ -966,9 +963,9 @@ TEST_F(WireMemoryTransferServiceTests, CreateBufferMappedAsyncDeserializeFlushFa FlushClient(); // The client receives a success callback. Save the buffer argument so we can call Unmap. - DawnBuffer buffer; + WGPUBuffer buffer; EXPECT_CALL(*mockCreateBufferMappedCallback, - Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, _, &mMappedBufferContent, + Call(WGPUBufferMapAsyncStatus_Success, _, &mMappedBufferContent, sizeof(mMappedBufferContent), _)) .WillOnce(SaveArg<1>(&buffer)); @@ -985,7 +982,7 @@ TEST_F(WireMemoryTransferServiceTests, CreateBufferMappedAsyncDeserializeFlushFa ExpectClientWriteHandleSerializeFlush(clientHandle); EXPECT_CALL(clientMemoryTransferService, OnWriteHandleDestroy(clientHandle)).Times(1); - dawnBufferUnmap(buffer); + wgpuBufferUnmap(buffer); // The server deserializes the Flush message. // Mock a deserialization failure. @@ -1009,8 +1006,8 @@ TEST_F(WireMemoryTransferServiceTests, CreateBufferMappedSuccess) { // The server should then deserialize the WriteHandle from the client. ServerWriteHandle* serverHandle = ExpectServerWriteHandleDeserialization(); - DawnCreateBufferMappedResult result; - DawnCreateBufferMappedResult apiResult; + WGPUCreateBufferMappedResult result; + WGPUCreateBufferMappedResult apiResult; std::tie(apiResult, result) = CreateBufferMapped(); FlushClient(); @@ -1021,7 +1018,7 @@ TEST_F(WireMemoryTransferServiceTests, CreateBufferMappedSuccess) { ExpectClientWriteHandleSerializeFlush(clientHandle); EXPECT_CALL(clientMemoryTransferService, OnWriteHandleDestroy(clientHandle)).Times(1); - dawnBufferUnmap(result.buffer); + wgpuBufferUnmap(result.buffer); // The server deserializes the Flush message. ExpectServerWriteHandleDeserializeFlush(serverHandle, mUpdatedBufferContent); @@ -1038,12 +1035,12 @@ TEST_F(WireMemoryTransferServiceTests, CreateBufferMappedWriteHandleCreationFail // Mock a WriteHandle creation failure MockWriteHandleCreationFailure(); - DawnBufferDescriptor descriptor; + WGPUBufferDescriptor descriptor; descriptor.nextInChain = nullptr; descriptor.label = nullptr; descriptor.size = sizeof(mBufferContent); - DawnCreateBufferMappedResult result = dawnDeviceCreateBufferMapped(device, &descriptor); + WGPUCreateBufferMappedResult result = wgpuDeviceCreateBufferMapped(device, &descriptor); // TODO(enga): Check that the client generated a context lost. EXPECT_EQ(result.data, nullptr); @@ -1063,8 +1060,8 @@ TEST_F(WireMemoryTransferServiceTests, CreateBufferMappedDeserializeWriteHandleF // The server should then deserialize the WriteHandle from the client. MockServerWriteHandleDeserializeFailure(); - DawnCreateBufferMappedResult result; - DawnCreateBufferMappedResult apiResult; + WGPUCreateBufferMappedResult result; + WGPUCreateBufferMappedResult apiResult; std::tie(apiResult, result) = CreateBufferMapped(); FlushClient(false); @@ -1084,12 +1081,12 @@ TEST_F(WireMemoryTransferServiceTests, CreateBufferMappedHandleOpenFailure) { // Note: The handle is not serialized because sychronously opening it failed. EXPECT_CALL(clientMemoryTransferService, OnWriteHandleDestroy(clientHandle)).Times(1); - DawnBufferDescriptor descriptor; + WGPUBufferDescriptor descriptor; descriptor.nextInChain = nullptr; descriptor.label = nullptr; descriptor.size = sizeof(mBufferContent); - DawnCreateBufferMappedResult result = dawnDeviceCreateBufferMapped(device, &descriptor); + WGPUCreateBufferMappedResult result = wgpuDeviceCreateBufferMapped(device, &descriptor); // TODO(enga): Check that the client generated a context lost. EXPECT_EQ(result.data, nullptr); @@ -1109,8 +1106,8 @@ TEST_F(WireMemoryTransferServiceTests, CreateBufferMappedDeserializeFlushFailure // The server should then deserialize the WriteHandle from the client. ServerWriteHandle* serverHandle = ExpectServerWriteHandleDeserialization(); - DawnCreateBufferMappedResult result; - DawnCreateBufferMappedResult apiResult; + WGPUCreateBufferMappedResult result; + WGPUCreateBufferMappedResult apiResult; std::tie(apiResult, result) = CreateBufferMapped(); FlushClient(); @@ -1121,7 +1118,7 @@ TEST_F(WireMemoryTransferServiceTests, CreateBufferMappedDeserializeFlushFailure ExpectClientWriteHandleSerializeFlush(clientHandle); EXPECT_CALL(clientMemoryTransferService, OnWriteHandleDestroy(clientHandle)).Times(1); - dawnBufferUnmap(result.buffer); + wgpuBufferUnmap(result.buffer); // The server deserializes the Flush message. Mock a deserialization failure. MockServerWriteHandleDeserializeFlushFailure(serverHandle); diff --git a/src/tests/unittests/wire/WireOptionalTests.cpp b/src/tests/unittests/wire/WireOptionalTests.cpp index 9a38fd58cc..382985fe25 100644 --- a/src/tests/unittests/wire/WireOptionalTests.cpp +++ b/src/tests/unittests/wire/WireOptionalTests.cpp @@ -26,35 +26,35 @@ class WireOptionalTests : public WireTest { // Test passing nullptr instead of objects - object as value version TEST_F(WireOptionalTests, OptionalObjectValue) { - DawnBindGroupLayoutDescriptor bglDesc; + WGPUBindGroupLayoutDescriptor bglDesc; bglDesc.nextInChain = nullptr; bglDesc.label = nullptr; bglDesc.bindingCount = 0; - DawnBindGroupLayout bgl = dawnDeviceCreateBindGroupLayout(device, &bglDesc); + WGPUBindGroupLayout bgl = wgpuDeviceCreateBindGroupLayout(device, &bglDesc); - DawnBindGroupLayout apiBindGroupLayout = api.GetNewBindGroupLayout(); + WGPUBindGroupLayout apiBindGroupLayout = api.GetNewBindGroupLayout(); EXPECT_CALL(api, DeviceCreateBindGroupLayout(apiDevice, _)) .WillOnce(Return(apiBindGroupLayout)); // The `sampler`, `textureView` and `buffer` members of a binding are optional. - DawnBindGroupBinding binding; + WGPUBindGroupBinding binding; binding.binding = 0; binding.sampler = nullptr; binding.textureView = nullptr; binding.buffer = nullptr; - DawnBindGroupDescriptor bgDesc; + WGPUBindGroupDescriptor bgDesc; bgDesc.nextInChain = nullptr; bgDesc.label = nullptr; bgDesc.layout = bgl; bgDesc.bindingCount = 1; bgDesc.bindings = &binding; - dawnDeviceCreateBindGroup(device, &bgDesc); + wgpuDeviceCreateBindGroup(device, &bgDesc); - DawnBindGroup apiDummyBindGroup = api.GetNewBindGroup(); + WGPUBindGroup apiDummyBindGroup = api.GetNewBindGroup(); EXPECT_CALL(api, DeviceCreateBindGroup( - apiDevice, MatchesLambda([](const DawnBindGroupDescriptor* desc) -> bool { + apiDevice, MatchesLambda([](const WGPUBindGroupDescriptor* desc) -> bool { return desc->nextInChain == nullptr && desc->bindingCount == 1 && desc->bindings[0].binding == 0 && desc->bindings[0].sampler == nullptr && @@ -69,71 +69,71 @@ TEST_F(WireOptionalTests, OptionalObjectValue) { // Test that the wire is able to send optional pointers to structures TEST_F(WireOptionalTests, OptionalStructPointer) { // Create shader module - DawnShaderModuleDescriptor vertexDescriptor; + WGPUShaderModuleDescriptor vertexDescriptor; vertexDescriptor.nextInChain = nullptr; vertexDescriptor.label = nullptr; vertexDescriptor.codeSize = 0; - DawnShaderModule vsModule = dawnDeviceCreateShaderModule(device, &vertexDescriptor); - DawnShaderModule apiVsModule = api.GetNewShaderModule(); + WGPUShaderModule vsModule = wgpuDeviceCreateShaderModule(device, &vertexDescriptor); + WGPUShaderModule apiVsModule = api.GetNewShaderModule(); EXPECT_CALL(api, DeviceCreateShaderModule(apiDevice, _)).WillOnce(Return(apiVsModule)); // Create the color state descriptor - DawnBlendDescriptor blendDescriptor; - blendDescriptor.operation = DAWN_BLEND_OPERATION_ADD; - blendDescriptor.srcFactor = DAWN_BLEND_FACTOR_ONE; - blendDescriptor.dstFactor = DAWN_BLEND_FACTOR_ONE; - DawnColorStateDescriptor colorStateDescriptor; + WGPUBlendDescriptor blendDescriptor; + blendDescriptor.operation = WGPUBlendOperation_Add; + blendDescriptor.srcFactor = WGPUBlendFactor_One; + blendDescriptor.dstFactor = WGPUBlendFactor_One; + WGPUColorStateDescriptor colorStateDescriptor; colorStateDescriptor.nextInChain = nullptr; - colorStateDescriptor.format = DAWN_TEXTURE_FORMAT_RGBA8_UNORM; + colorStateDescriptor.format = WGPUTextureFormat_RGBA8Unorm; colorStateDescriptor.alphaBlend = blendDescriptor; colorStateDescriptor.colorBlend = blendDescriptor; - colorStateDescriptor.writeMask = DAWN_COLOR_WRITE_MASK_ALL; + colorStateDescriptor.writeMask = WGPUColorWriteMask_All; // Create the input state - DawnVertexInputDescriptor vertexInput; + WGPUVertexInputDescriptor vertexInput; vertexInput.nextInChain = nullptr; - vertexInput.indexFormat = DAWN_INDEX_FORMAT_UINT32; + vertexInput.indexFormat = WGPUIndexFormat_Uint32; vertexInput.bufferCount = 0; vertexInput.buffers = nullptr; // Create the rasterization state - DawnRasterizationStateDescriptor rasterizationState; + WGPURasterizationStateDescriptor rasterizationState; rasterizationState.nextInChain = nullptr; - rasterizationState.frontFace = DAWN_FRONT_FACE_CCW; - rasterizationState.cullMode = DAWN_CULL_MODE_NONE; + rasterizationState.frontFace = WGPUFrontFace_CCW; + rasterizationState.cullMode = WGPUCullMode_None; rasterizationState.depthBias = 0; rasterizationState.depthBiasSlopeScale = 0.0; rasterizationState.depthBiasClamp = 0.0; // Create the depth-stencil state - DawnStencilStateFaceDescriptor stencilFace; - stencilFace.compare = DAWN_COMPARE_FUNCTION_ALWAYS; - stencilFace.failOp = DAWN_STENCIL_OPERATION_KEEP; - stencilFace.depthFailOp = DAWN_STENCIL_OPERATION_KEEP; - stencilFace.passOp = DAWN_STENCIL_OPERATION_KEEP; + WGPUStencilStateFaceDescriptor stencilFace; + stencilFace.compare = WGPUCompareFunction_Always; + stencilFace.failOp = WGPUStencilOperation_Keep; + stencilFace.depthFailOp = WGPUStencilOperation_Keep; + stencilFace.passOp = WGPUStencilOperation_Keep; - DawnDepthStencilStateDescriptor depthStencilState; + WGPUDepthStencilStateDescriptor depthStencilState; depthStencilState.nextInChain = nullptr; - depthStencilState.format = DAWN_TEXTURE_FORMAT_DEPTH24_PLUS_STENCIL8; + depthStencilState.format = WGPUTextureFormat_Depth24PlusStencil8; depthStencilState.depthWriteEnabled = false; - depthStencilState.depthCompare = DAWN_COMPARE_FUNCTION_ALWAYS; + depthStencilState.depthCompare = WGPUCompareFunction_Always; depthStencilState.stencilBack = stencilFace; depthStencilState.stencilFront = stencilFace; depthStencilState.stencilReadMask = 0xff; depthStencilState.stencilWriteMask = 0xff; // Create the pipeline layout - DawnPipelineLayoutDescriptor layoutDescriptor; + WGPUPipelineLayoutDescriptor layoutDescriptor; layoutDescriptor.nextInChain = nullptr; layoutDescriptor.label = nullptr; layoutDescriptor.bindGroupLayoutCount = 0; layoutDescriptor.bindGroupLayouts = nullptr; - DawnPipelineLayout layout = dawnDeviceCreatePipelineLayout(device, &layoutDescriptor); - DawnPipelineLayout apiLayout = api.GetNewPipelineLayout(); + WGPUPipelineLayout layout = wgpuDeviceCreatePipelineLayout(device, &layoutDescriptor); + WGPUPipelineLayout apiLayout = api.GetNewPipelineLayout(); EXPECT_CALL(api, DeviceCreatePipelineLayout(apiDevice, _)).WillOnce(Return(apiLayout)); // Create pipeline - DawnRenderPipelineDescriptor pipelineDescriptor; + WGPURenderPipelineDescriptor pipelineDescriptor; pipelineDescriptor.nextInChain = nullptr; pipelineDescriptor.label = nullptr; @@ -141,7 +141,7 @@ TEST_F(WireOptionalTests, OptionalStructPointer) { pipelineDescriptor.vertexStage.module = vsModule; pipelineDescriptor.vertexStage.entryPoint = "main"; - DawnProgrammableStageDescriptor fragmentStage; + WGPUProgrammableStageDescriptor fragmentStage; fragmentStage.nextInChain = nullptr; fragmentStage.module = vsModule; fragmentStage.entryPoint = "main"; @@ -155,36 +155,33 @@ TEST_F(WireOptionalTests, OptionalStructPointer) { pipelineDescriptor.alphaToCoverageEnabled = false; pipelineDescriptor.layout = layout; pipelineDescriptor.vertexInput = &vertexInput; - pipelineDescriptor.primitiveTopology = DAWN_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; + pipelineDescriptor.primitiveTopology = WGPUPrimitiveTopology_TriangleList; pipelineDescriptor.rasterizationState = &rasterizationState; // First case: depthStencilState is not null. pipelineDescriptor.depthStencilState = &depthStencilState; - dawnDeviceCreateRenderPipeline(device, &pipelineDescriptor); + wgpuDeviceCreateRenderPipeline(device, &pipelineDescriptor); - DawnRenderPipeline apiDummyPipeline = api.GetNewRenderPipeline(); + WGPURenderPipeline apiDummyPipeline = api.GetNewRenderPipeline(); EXPECT_CALL( api, DeviceCreateRenderPipeline( - apiDevice, MatchesLambda([](const DawnRenderPipelineDescriptor* desc) -> bool { + apiDevice, MatchesLambda([](const WGPURenderPipelineDescriptor* desc) -> bool { return desc->depthStencilState != nullptr && desc->depthStencilState->nextInChain == nullptr && desc->depthStencilState->depthWriteEnabled == false && - desc->depthStencilState->depthCompare == DAWN_COMPARE_FUNCTION_ALWAYS && - desc->depthStencilState->stencilBack.compare == - DAWN_COMPARE_FUNCTION_ALWAYS && - desc->depthStencilState->stencilBack.failOp == DAWN_STENCIL_OPERATION_KEEP && + desc->depthStencilState->depthCompare == WGPUCompareFunction_Always && + desc->depthStencilState->stencilBack.compare == WGPUCompareFunction_Always && + desc->depthStencilState->stencilBack.failOp == WGPUStencilOperation_Keep && desc->depthStencilState->stencilBack.depthFailOp == - DAWN_STENCIL_OPERATION_KEEP && - desc->depthStencilState->stencilBack.passOp == DAWN_STENCIL_OPERATION_KEEP && + WGPUStencilOperation_Keep && + desc->depthStencilState->stencilBack.passOp == WGPUStencilOperation_Keep && desc->depthStencilState->stencilFront.compare == - DAWN_COMPARE_FUNCTION_ALWAYS && - desc->depthStencilState->stencilFront.failOp == - DAWN_STENCIL_OPERATION_KEEP && + WGPUCompareFunction_Always && + desc->depthStencilState->stencilFront.failOp == WGPUStencilOperation_Keep && desc->depthStencilState->stencilFront.depthFailOp == - DAWN_STENCIL_OPERATION_KEEP && - desc->depthStencilState->stencilFront.passOp == - DAWN_STENCIL_OPERATION_KEEP && + WGPUStencilOperation_Keep && + desc->depthStencilState->stencilFront.passOp == WGPUStencilOperation_Keep && desc->depthStencilState->stencilReadMask == 0xff && desc->depthStencilState->stencilWriteMask == 0xff; }))) @@ -194,10 +191,10 @@ TEST_F(WireOptionalTests, OptionalStructPointer) { // Second case: depthStencilState is null. pipelineDescriptor.depthStencilState = nullptr; - dawnDeviceCreateRenderPipeline(device, &pipelineDescriptor); + wgpuDeviceCreateRenderPipeline(device, &pipelineDescriptor); EXPECT_CALL(api, DeviceCreateRenderPipeline( - apiDevice, MatchesLambda([](const DawnRenderPipelineDescriptor* desc) -> bool { + apiDevice, MatchesLambda([](const WGPURenderPipelineDescriptor* desc) -> bool { return desc->depthStencilState == nullptr; }))) .WillOnce(Return(apiDummyPipeline)); diff --git a/src/tests/unittests/wire/WireTest.cpp b/src/tests/unittests/wire/WireTest.cpp index 2c74df795c..d48c08573e 100644 --- a/src/tests/unittests/wire/WireTest.cpp +++ b/src/tests/unittests/wire/WireTest.cpp @@ -38,7 +38,7 @@ server::MemoryTransferService* WireTest::GetServerMemoryTransferService() { void WireTest::SetUp() { DawnProcTable mockProcs; - DawnDevice mockDevice; + WGPUDevice mockDevice; api.GetProcTableAndDevice(&mockProcs, &mockDevice); // This SetCallback call cannot be ignored because it is done as soon as we start the server diff --git a/src/tests/unittests/wire/WireTest.h b/src/tests/unittests/wire/WireTest.h index 1beb36fca9..7a6c234a29 100644 --- a/src/tests/unittests/wire/WireTest.h +++ b/src/tests/unittests/wire/WireTest.h @@ -12,8 +12,8 @@ // See the License for the specific language governing permissions and // limitations under the License. +#include "dawn/mock_webgpu.h" #include "gtest/gtest.h" -#include "dawn/mock_dawn.h" #include @@ -122,8 +122,8 @@ class WireTest : public testing::Test { void FlushServer(bool success = true); testing::StrictMock api; - DawnDevice apiDevice; - DawnDevice device; + WGPUDevice apiDevice; + WGPUDevice device; dawn_wire::WireServer* GetWireServer(); dawn_wire::WireClient* GetWireClient();