encounter/dawn-cmake
1
0
Fork 0
mirror of https://github.com/encounter/dawn-cmake.git synced 2025-12-18 09:25:25 +00:00
Code Issues Packages Projects Releases Wiki Activity

Make unittests and fuzzers use webgpu.h

Browse Source 
BUG=dawn:22

Change-Id: Iff5465ad7a9456f9c6b2ee380af748b3afc129b7
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/12741
Commit-Queue: Kai Ninomiya <kainino@chromium.org>
Reviewed-by: Austin Eng <enga@chromium.org>
Reviewed-by: Kai Ninomiya <kainino@chromium.org>
This commit is contained in:
Corentin Wallez
2019-10-28 22:15:47 +00:00
committed by Commit Bot service account
parent cab352c2f6
commit 45b51f5df7
40 changed files with 2200 additions and 2200 deletions
Download Patch File Download Diff File Expand all files Collapse all files

428
src/tests/unittests/validation/BindGroupValidationTests.cpp
View File

@@ -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<dawn::FilterMode>(0xFFFFFFFF);
wgpu::SamplerDescriptor samplerDesc = utils::GetDefaultSamplerDescriptor();
samplerDesc.minFilter = static_cast<wgpu::FilterMode>(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<dawn::BufferUsage>(0xFFFFFFFF);
bufferDesc.usage = static_cast<wgpu::BufferUsage>(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<dawn::BindGroupLayoutBinding> maxUniformDB;
std::vector<dawn::BindGroupLayoutBinding> maxStorageDB;
wgpu::BindGroupLayout bgl[2];
std::vector<wgpu::BindGroupLayoutBinding> maxUniformDB;
std::vector<wgpu::BindGroupLayoutBinding> 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<std::vector<dawn::BindGroupLayout>, dawn::RenderPipeline> SetUpLayoutsAndPipeline(
std::vector<std::vector<dawn::BindingType>> layouts) {
std::vector<dawn::BindGroupLayout> bindGroupLayouts(layouts.size());
std::tuple<std::vector<wgpu::BindGroupLayout>, wgpu::RenderPipeline> SetUpLayoutsAndPipeline(
std::vector<std::vector<wgpu::BindingType>> layouts) {
std::vector<wgpu::BindGroupLayout> 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<dawn::BindGroupLayoutBinding> bindings(layout.size());
std::vector<wgpu::BindGroupLayoutBinding> 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<uint32_t>(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<uint32_t>(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<dawn::BindGroupLayout> bindGroupLayouts;
dawn::RenderPipeline pipeline;
std::vector<wgpu::BindGroupLayout> 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<dawn::BindGroupLayout> bindGroupLayoutsA;
dawn::RenderPipeline pipelineA;
std::vector<wgpu::BindGroupLayout> 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<dawn::BindGroupLayout> bindGroupLayoutsB;
dawn::RenderPipeline pipelineB;
std::vector<wgpu::BindGroupLayout> 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);

312
src/tests/unittests/validation/BufferValidationTests.cpp
View File

@@ -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> 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> 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);

122
src/tests/unittests/validation/CommandBufferValidationTests.cpp
View File

@@ -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(&copyBufferDesc);
copyBufferDesc.usage = wgpu::BufferUsage::CopySrc | wgpu::BufferUsage::CopyDst;
wgpu::Buffer copyBuffer = device.CreateBuffer(&copyBufferDesc);
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(&copyBufferDesc);
copyBufferDesc.usage = wgpu::BufferUsage::CopySrc | wgpu::BufferUsage::CopyDst;
wgpu::Buffer copyBuffer = device.CreateBuffer(&copyBufferDesc);
// 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());

18
src/tests/unittests/validation/ComputeIndirectValidationTests.cpp
View File

@@ -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<uint32_t> bufferList,
uint64_t indirectOffset) {
dawn::Buffer indirectBuffer =
utils::CreateBufferFromData<uint32_t>(device, dawn::BufferUsage::Indirect, bufferList);
wgpu::Buffer indirectBuffer =
utils::CreateBufferFromData<uint32_t>(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

76
src/tests/unittests/validation/ComputePassValidationTests.cpp
View File

@@ -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);

580
src/tests/unittests/validation/CopyCommandsValidationTests.cpp
View File

File diff suppressed because it is too large Load Diff

46
src/tests/unittests/validation/DebugMarkerValidationTests.cpp
View File

@@ -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();

22
src/tests/unittests/validation/DrawIndirectValidationTests.cpp
View File

@@ -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<uint32_t> bufferList,
uint64_t indirectOffset,
bool indexed) {
dawn::Buffer indirectBuffer =
utils::CreateBufferFromData<uint32_t>(device, dawn::BufferUsage::Indirect, bufferList);
wgpu::Buffer indirectBuffer =
utils::CreateBufferFromData<uint32_t>(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

112
src/tests/unittests/validation/DynamicStateCommandValidationTests.cpp
View File

@@ -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();
}

86
src/tests/unittests/validation/ErrorScopeValidationTests.cpp
View File

@@ -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> 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::BufferUsage>(DAWN_BUFFER_USAGE_FORCE32);
wgpu::BufferDescriptor desc = {};
desc.usage = static_cast<wgpu::BufferUsage>(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::BufferUsage>(DAWN_BUFFER_USAGE_FORCE32);
wgpu::BufferDescriptor desc = {};
desc.usage = static_cast<wgpu::BufferUsage>(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::BufferUsage>(DAWN_BUFFER_USAGE_FORCE32);
wgpu::BufferDescriptor desc = {};
desc.usage = static_cast<wgpu::BufferUsage>(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::BufferUsage>(DAWN_BUFFER_USAGE_FORCE32);
wgpu::BufferDescriptor desc = {};
desc.usage = static_cast<wgpu::BufferUsage>(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;
}

70
src/tests/unittests/validation/FenceValidationTests.cpp
View File

@@ -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> 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));

18
src/tests/unittests/validation/QueueSubmitValidationTests.cpp
View File

@@ -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);

384
src/tests/unittests/validation/RenderBundleValidationTests.cpp
View File

@@ -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));
}

318
src/tests/unittests/validation/RenderPassDescriptorValidationTests.cpp
View File

@@ -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<dawn::RenderPassColorAttachmentDescriptor, 5> colorAttachments;
std::array<wgpu::RenderPassColorAttachmentDescriptor, 5> 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);

40
src/tests/unittests/validation/RenderPassValidationTests.cpp
View File

@@ -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);

80
src/tests/unittests/validation/RenderPipelineValidationTests.cpp
View File

@@ -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<const char*, kNumTextureFormatBaseType> kVecPreFix = {{"", "i", "u"}};
std::array<dawn::TextureFormat, kNumTextureFormatBaseType> kColorFormats = {
{dawn::TextureFormat::RGBA8Unorm, dawn::TextureFormat::RGBA8Sint,
dawn::TextureFormat::RGBA8Uint}};
std::array<wgpu::TextureFormat, kNumTextureFormatBaseType> 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();

8
src/tests/unittests/validation/SamplerValidationTests.cpp
View File

@@ -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));
}

152
src/tests/unittests/validation/TextureValidationTests.cpp
View File

@@ -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<dawn::TextureFormat, 14> 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<wgpu::TextureFormat, 14> 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<const char*> 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);

156
src/tests/unittests/validation/TextureViewValidationTests.cpp
View File

@@ -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));
}

6
src/tests/unittests/validation/ToggleValidationTests.cpp
View File

@@ -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<const char*> 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<const char*> 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<const char*> toggleNames = dawn_native::GetTogglesUsed(deviceWithToggle);
bool validToggleExists = false;
for (const char* toggle : toggleNames) {

32
src/tests/unittests/validation/ValidationTest.cpp
View File

@@ -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<const char*>());
}
dawn::Device ValidationTest::CreateDeviceFromAdapter(
wgpu::Device ValidationTest::CreateDeviceFromAdapter(
dawn_native::Adapter adapterToTest,
const std::vector<const char*>& 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<ValidationTest*>(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;

20
src/tests/unittests/validation/ValidationTest.h
View File

@@ -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<const char*>& 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<dawn_native::Instance> 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;

30
src/tests/unittests/validation/VertexBufferValidationTests.cpp
View File

@@ -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();

10
src/tests/unittests/validation/VertexInputValidationTests.cpp
View File

@@ -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() {