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

Remove Bit from TextureUsageBit and BufferUsageBit

Browse Source 
This is to match the naming convention of WebGPU's WebIDL and webgpu.h

BUG=dawn:22

Change-Id: Ia91c5a018403e6a72eb0311b5f1a072d102282a2
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/10461
Commit-Queue: Corentin Wallez <cwallez@chromium.org>
Reviewed-by: Austin Eng <enga@chromium.org>
This commit is contained in:
Corentin Wallez
2019-08-27 08:21:39 +00:00
committed by Commit Bot service account
parent e25a3aede0
commit 9e9e29f7a6
110 changed files with 762 additions and 780 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -25,13 +25,13 @@ class BindGroupValidationTest : public ValidationTest {
{
dawn::BufferDescriptor descriptor;
descriptor.size = 1024;
descriptor.usage = dawn::BufferUsageBit::Uniform;
descriptor.usage = dawn::BufferUsage::Uniform;
mUBO = device.CreateBuffer(&descriptor);
}
{
dawn::BufferDescriptor descriptor;
descriptor.size = 1024;
descriptor.usage = dawn::BufferUsageBit::Storage;
descriptor.usage = dawn::BufferUsage::Storage;
mSSBO = device.CreateBuffer(&descriptor);
}
{
@@ -46,7 +46,7 @@ class BindGroupValidationTest : public ValidationTest {
descriptor.sampleCount = 1;
descriptor.format = dawn::TextureFormat::RGBA8Unorm;
descriptor.mipLevelCount = 1;
descriptor.usage = dawn::TextureUsageBit::Sampled;
descriptor.usage = dawn::TextureUsage::Sampled;
mSampledTexture = device.CreateTexture(&descriptor);
mSampledTextureView = mSampledTexture.CreateDefaultView();
}
@@ -272,7 +272,7 @@ TEST_F(BindGroupValidationTest, BufferBindingType) {
{
dawn::BufferDescriptor bufferDesc;
bufferDesc.size = 1024;
bufferDesc.usage = static_cast<dawn::BufferUsageBit>(0xFFFFFFFF);
bufferDesc.usage = static_cast<dawn::BufferUsage>(0xFFFFFFFF);
dawn::Buffer errorBuffer;
ASSERT_DEVICE_ERROR(errorBuffer = device.CreateBuffer(&bufferDesc));
@@ -300,7 +300,7 @@ TEST_F(BindGroupValidationTest, TextureUsage) {
descriptor.sampleCount = 1;
descriptor.format = dawn::TextureFormat::RGBA8Unorm;
descriptor.mipLevelCount = 1;
descriptor.usage = dawn::TextureUsageBit::OutputAttachment;
descriptor.usage = dawn::TextureUsage::OutputAttachment;
dawn::Texture outputTexture = device.CreateTexture(&descriptor);
dawn::TextureView outputTextureView = outputTexture.CreateDefaultView();
ASSERT_DEVICE_ERROR(utils::MakeBindGroup(device, layout, {{0, outputTextureView}}));
@@ -323,7 +323,7 @@ TEST_F(BindGroupValidationTest, TextureComponentType) {
descriptor.sampleCount = 1;
descriptor.format = dawn::TextureFormat::RGBA8Uint;
descriptor.mipLevelCount = 1;
descriptor.usage = dawn::TextureUsageBit::Sampled;
descriptor.usage = dawn::TextureUsage::Sampled;
dawn::Texture uintTexture = device.CreateTexture(&descriptor);
dawn::TextureView uintTextureView = uintTexture.CreateDefaultView();
@@ -382,7 +382,7 @@ TEST_F(BindGroupValidationTest, BufferBindingOOB) {
dawn::BufferDescriptor descriptor;
descriptor.size = 1024;
descriptor.usage = dawn::BufferUsageBit::Uniform;
descriptor.usage = dawn::BufferUsage::Uniform;
dawn::Buffer buffer = device.CreateBuffer(&descriptor);
// Success case, touching the start of the buffer works
@@ -602,7 +602,7 @@ class SetBindGroupValidationTest : public ValidationTest {
dawn::BindingType::StorageBuffer, true}});
}
dawn::Buffer CreateBuffer(uint64_t bufferSize, dawn::BufferUsageBit usage) {
dawn::Buffer CreateBuffer(uint64_t bufferSize, dawn::BufferUsage usage) {
dawn::BufferDescriptor bufferDescriptor;
bufferDescriptor.size = bufferSize;
bufferDescriptor.usage = usage;
@@ -717,8 +717,8 @@ 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::BufferUsageBit::Uniform);
dawn::Buffer storageBuffer = CreateBuffer(kBufferSize, dawn::BufferUsageBit::Storage);
dawn::Buffer uniformBuffer = CreateBuffer(kBufferSize, dawn::BufferUsage::Uniform);
dawn::Buffer storageBuffer = CreateBuffer(kBufferSize, dawn::BufferUsage::Storage);
dawn::BindGroup bindGroup = utils::MakeBindGroup(
device, mBindGroupLayout,
{{0, uniformBuffer, 0, kBindingSize}, {1, storageBuffer, 0, kBindingSize}});
@@ -733,8 +733,8 @@ 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::BufferUsageBit::Uniform);
dawn::Buffer storageBuffer = CreateBuffer(kBufferSize, dawn::BufferUsageBit::Storage);
dawn::Buffer uniformBuffer = CreateBuffer(kBufferSize, dawn::BufferUsage::Uniform);
dawn::Buffer storageBuffer = CreateBuffer(kBufferSize, dawn::BufferUsage::Storage);
dawn::BindGroup bindGroup = utils::MakeBindGroup(
device, mBindGroupLayout,
{{0, uniformBuffer, 0, kBindingSize}, {1, storageBuffer, 0, kBindingSize}});
@@ -750,8 +750,8 @@ 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::BufferUsageBit::Uniform);
dawn::Buffer storageBuffer = CreateBuffer(kBufferSize, dawn::BufferUsageBit::Storage);
dawn::Buffer uniformBuffer = CreateBuffer(kBufferSize, dawn::BufferUsage::Uniform);
dawn::Buffer storageBuffer = CreateBuffer(kBufferSize, dawn::BufferUsage::Storage);
dawn::BindGroup bindGroup = utils::MakeBindGroup(
device, mBindGroupLayout,
{{0, uniformBuffer, 0, kBindingSize}, {1, storageBuffer, 0, kBindingSize}});
@@ -767,8 +767,8 @@ 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::BufferUsageBit::Uniform);
dawn::Buffer storageBuffer = CreateBuffer(kBufferSize, dawn::BufferUsageBit::Storage);
dawn::Buffer uniformBuffer = CreateBuffer(kBufferSize, dawn::BufferUsage::Uniform);
dawn::Buffer storageBuffer = CreateBuffer(kBufferSize, dawn::BufferUsage::Storage);
dawn::BindGroup bindGroup = utils::MakeBindGroup(
device, mBindGroupLayout,
{{0, uniformBuffer, 0, kBindingSize}, {1, storageBuffer, 0, kBindingSize}});
@@ -784,8 +784,8 @@ 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::BufferUsageBit::Uniform);
dawn::Buffer storageBuffer = CreateBuffer(kBufferSize, dawn::BufferUsageBit::Storage);
dawn::Buffer uniformBuffer = CreateBuffer(kBufferSize, dawn::BufferUsage::Uniform);
dawn::Buffer storageBuffer = CreateBuffer(kBufferSize, dawn::BufferUsage::Storage);
dawn::BindGroup bindGroup = utils::MakeBindGroup(
device, mBindGroupLayout,
{{0, uniformBuffer, 0, kBindingSize}, {1, storageBuffer, 0, kBindingSize}});
@@ -801,8 +801,8 @@ 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::BufferUsageBit::Uniform);
dawn::Buffer storageBuffer = CreateBuffer(kBufferSize, dawn::BufferUsageBit::Storage);
dawn::Buffer uniformBuffer = CreateBuffer(kBufferSize, dawn::BufferUsage::Uniform);
dawn::Buffer storageBuffer = CreateBuffer(kBufferSize, dawn::BufferUsage::Storage);
dawn::BindGroup bindGroup = utils::MakeBindGroup(
device, mBindGroupLayout,
{{0, uniformBuffer, 0, kBindingSize}, {1, storageBuffer, 0, kBindingSize}});
@@ -818,8 +818,8 @@ 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::BufferUsageBit::Uniform);
dawn::Buffer storageBuffer = CreateBuffer(kBufferSize, dawn::BufferUsageBit::Storage);
dawn::Buffer uniformBuffer = CreateBuffer(kBufferSize, dawn::BufferUsage::Uniform);
dawn::Buffer storageBuffer = CreateBuffer(kBufferSize, dawn::BufferUsage::Storage);
dawn::BindGroup bindGroup = utils::MakeBindGroup(
device, mBindGroupLayout,
{{0, uniformBuffer, 0, kBindingSize}, {1, storageBuffer, 0, kBindingSize}});

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

@@ -63,27 +63,26 @@ class BufferValidationTest : public ValidationTest {
dawn::Buffer CreateMapReadBuffer(uint64_t size) {
dawn::BufferDescriptor descriptor;
descriptor.size = size;
descriptor.usage = dawn::BufferUsageBit::MapRead;
descriptor.usage = dawn::BufferUsage::MapRead;
return device.CreateBuffer(&descriptor);
}
dawn::Buffer CreateMapWriteBuffer(uint64_t size) {
dawn::BufferDescriptor descriptor;
descriptor.size = size;
descriptor.usage = dawn::BufferUsageBit::MapWrite;
descriptor.usage = dawn::BufferUsage::MapWrite;
return device.CreateBuffer(&descriptor);
}
dawn::Buffer CreateSetSubDataBuffer(uint64_t size) {
dawn::BufferDescriptor descriptor;
descriptor.size = size;
descriptor.usage = dawn::BufferUsageBit::CopyDst;
descriptor.usage = dawn::BufferUsage::CopyDst;
return device.CreateBuffer(&descriptor);
}
dawn::CreateBufferMappedResult CreateBufferMapped(uint64_t size,
dawn::BufferUsageBit usage) {
dawn::CreateBufferMappedResult CreateBufferMapped(uint64_t size, dawn::BufferUsage usage) {
dawn::BufferDescriptor descriptor;
descriptor.size = size;
descriptor.usage = usage;
@@ -117,7 +116,7 @@ TEST_F(BufferValidationTest, CreationSuccess) {
{
dawn::BufferDescriptor descriptor;
descriptor.size = 4;
descriptor.usage = dawn::BufferUsageBit::Uniform;
descriptor.usage = dawn::BufferUsage::Uniform;
device.CreateBuffer(&descriptor);
}
@@ -129,7 +128,7 @@ TEST_F(BufferValidationTest, CreationMapUsageRestrictions) {
{
dawn::BufferDescriptor descriptor;
descriptor.size = 4;
descriptor.usage = dawn::BufferUsageBit::MapRead | dawn::BufferUsageBit::CopyDst;
descriptor.usage = dawn::BufferUsage::MapRead | dawn::BufferUsage::CopyDst;
device.CreateBuffer(&descriptor);
}
@@ -138,7 +137,7 @@ TEST_F(BufferValidationTest, CreationMapUsageRestrictions) {
{
dawn::BufferDescriptor descriptor;
descriptor.size = 4;
descriptor.usage = dawn::BufferUsageBit::MapRead | dawn::BufferUsageBit::Uniform;
descriptor.usage = dawn::BufferUsage::MapRead | dawn::BufferUsage::Uniform;
ASSERT_DEVICE_ERROR(device.CreateBuffer(&descriptor));
}
@@ -147,7 +146,7 @@ TEST_F(BufferValidationTest, CreationMapUsageRestrictions) {
{
dawn::BufferDescriptor descriptor;
descriptor.size = 4;
descriptor.usage = dawn::BufferUsageBit::MapWrite | dawn::BufferUsageBit::CopySrc;
descriptor.usage = dawn::BufferUsage::MapWrite | dawn::BufferUsage::CopySrc;
device.CreateBuffer(&descriptor);
}
@@ -156,7 +155,7 @@ TEST_F(BufferValidationTest, CreationMapUsageRestrictions) {
{
dawn::BufferDescriptor descriptor;
descriptor.size = 4;
descriptor.usage = dawn::BufferUsageBit::MapWrite | dawn::BufferUsageBit::Uniform;
descriptor.usage = dawn::BufferUsage::MapWrite | dawn::BufferUsage::Uniform;
ASSERT_DEVICE_ERROR(device.CreateBuffer(&descriptor));
}
@@ -192,7 +191,7 @@ TEST_F(BufferValidationTest, MapWriteSuccess) {
// Test the success case for CreateBufferMapped
TEST_F(BufferValidationTest, CreateBufferMappedSuccess) {
dawn::CreateBufferMappedResult result = CreateBufferMapped(4, dawn::BufferUsageBit::MapWrite);
dawn::CreateBufferMappedResult result = CreateBufferMapped(4, dawn::BufferUsage::MapWrite);
ASSERT_NE(result.data, nullptr);
ASSERT_EQ(result.dataLength, 4u);
result.buffer.Unmap();
@@ -200,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::BufferUsageBit::CopySrc);
dawn::CreateBufferMappedResult result = CreateBufferMapped(4, dawn::BufferUsage::CopySrc);
ASSERT_NE(result.data, nullptr);
ASSERT_EQ(result.dataLength, 4u);
result.buffer.Unmap();
@@ -210,7 +209,7 @@ TEST_F(BufferValidationTest, NonMappableCreateBufferMappedSuccess) {
TEST_F(BufferValidationTest, MapReadWrongUsage) {
dawn::BufferDescriptor descriptor;
descriptor.size = 4;
descriptor.usage = dawn::BufferUsageBit::CopyDst;
descriptor.usage = dawn::BufferUsage::CopyDst;
dawn::Buffer buf = device.CreateBuffer(&descriptor);
@@ -225,7 +224,7 @@ TEST_F(BufferValidationTest, MapReadWrongUsage) {
TEST_F(BufferValidationTest, MapWriteWrongUsage) {
dawn::BufferDescriptor descriptor;
descriptor.size = 4;
descriptor.usage = dawn::BufferUsageBit::CopySrc;
descriptor.usage = dawn::BufferUsage::CopySrc;
dawn::Buffer buf = device.CreateBuffer(&descriptor);
@@ -467,7 +466,7 @@ TEST_F(BufferValidationTest, SetSubDataOutOfBoundsOverflow) {
TEST_F(BufferValidationTest, SetSubDataWrongUsage) {
dawn::BufferDescriptor descriptor;
descriptor.size = 4;
descriptor.usage = dawn::BufferUsageBit::Vertex;
descriptor.usage = dawn::BufferUsage::Vertex;
dawn::Buffer buf = device.CreateBuffer(&descriptor);
@@ -479,7 +478,7 @@ TEST_F(BufferValidationTest, SetSubDataWrongUsage) {
TEST_F(BufferValidationTest, SetSubDataWithUnalignedSize) {
dawn::BufferDescriptor descriptor;
descriptor.size = 4;
descriptor.usage = dawn::BufferUsageBit::CopySrc | dawn::BufferUsageBit::CopyDst;
descriptor.usage = dawn::BufferUsage::CopySrc | dawn::BufferUsage::CopyDst;
dawn::Buffer buf = device.CreateBuffer(&descriptor);
@@ -491,7 +490,7 @@ TEST_F(BufferValidationTest, SetSubDataWithUnalignedSize) {
TEST_F(BufferValidationTest, SetSubDataWithUnalignedOffset) {
dawn::BufferDescriptor descriptor;
descriptor.size = 4000;
descriptor.usage = dawn::BufferUsageBit::CopySrc | dawn::BufferUsageBit::CopyDst;
descriptor.usage = dawn::BufferUsage::CopySrc | dawn::BufferUsage::CopyDst;
dawn::Buffer buf = device.CreateBuffer(&descriptor);
@@ -612,12 +611,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::BufferUsageBit::MapRead).buffer;
dawn::Buffer buf = CreateBufferMapped(4, dawn::BufferUsage::MapRead).buffer;
ASSERT_DEVICE_ERROR(buf.MapReadAsync(ToMockBufferMapReadCallback, nullptr));
queue.Submit(0, nullptr);
}
{
dawn::Buffer buf = CreateBufferMapped(4, dawn::BufferUsageBit::MapWrite).buffer;
dawn::Buffer buf = CreateBufferMapped(4, dawn::BufferUsage::MapWrite).buffer;
ASSERT_DEVICE_ERROR(buf.MapWriteAsync(ToMockBufferMapWriteCallback, nullptr));
queue.Submit(0, nullptr);
}
@@ -645,11 +644,11 @@ TEST_F(BufferValidationTest, SetSubDataMappedBuffer) {
TEST_F(BufferValidationTest, SubmitBufferWithMapUsage) {
dawn::BufferDescriptor descriptorA;
descriptorA.size = 4;
descriptorA.usage = dawn::BufferUsageBit::CopySrc | dawn::BufferUsageBit::MapWrite;
descriptorA.usage = dawn::BufferUsage::CopySrc | dawn::BufferUsage::MapWrite;
dawn::BufferDescriptor descriptorB;
descriptorB.size = 4;
descriptorB.usage = dawn::BufferUsageBit::CopyDst | dawn::BufferUsageBit::MapRead;
descriptorB.usage = dawn::BufferUsage::CopyDst | dawn::BufferUsage::MapRead;
dawn::Buffer bufA = device.CreateBuffer(&descriptorA);
dawn::Buffer bufB = device.CreateBuffer(&descriptorB);
@@ -664,11 +663,11 @@ TEST_F(BufferValidationTest, SubmitBufferWithMapUsage) {
TEST_F(BufferValidationTest, SubmitMappedBuffer) {
dawn::BufferDescriptor descriptorA;
descriptorA.size = 4;
descriptorA.usage = dawn::BufferUsageBit::CopySrc | dawn::BufferUsageBit::MapWrite;
descriptorA.usage = dawn::BufferUsage::CopySrc | dawn::BufferUsage::MapWrite;
dawn::BufferDescriptor descriptorB;
descriptorB.size = 4;
descriptorB.usage = dawn::BufferUsageBit::CopyDst | dawn::BufferUsageBit::MapRead;
descriptorB.usage = dawn::BufferUsage::CopyDst | dawn::BufferUsage::MapRead;
{
dawn::Buffer bufA = device.CreateBuffer(&descriptorA);
dawn::Buffer bufB = device.CreateBuffer(&descriptorB);
@@ -719,11 +718,11 @@ TEST_F(BufferValidationTest, SubmitMappedBuffer) {
TEST_F(BufferValidationTest, SubmitDestroyedBuffer) {
dawn::BufferDescriptor descriptorA;
descriptorA.size = 4;
descriptorA.usage = dawn::BufferUsageBit::CopySrc;
descriptorA.usage = dawn::BufferUsage::CopySrc;
dawn::BufferDescriptor descriptorB;
descriptorB.size = 4;
descriptorB.usage = dawn::BufferUsageBit::CopyDst;
descriptorB.usage = dawn::BufferUsage::CopyDst;
dawn::Buffer bufA = device.CreateBuffer(&descriptorA);
dawn::Buffer bufB = device.CreateBuffer(&descriptorB);

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

@@ -152,7 +152,7 @@ TEST_F(CommandBufferValidationTest, CallsAfterASuccessfulFinish) {
// A buffer that can be used in CopyBufferToBuffer
dawn::BufferDescriptor copyBufferDesc;
copyBufferDesc.size = 16;
copyBufferDesc.usage = dawn::BufferUsageBit::CopySrc | dawn::BufferUsageBit::CopyDst;
copyBufferDesc.usage = dawn::BufferUsage::CopySrc | dawn::BufferUsage::CopyDst;
dawn::Buffer copyBuffer = device.CreateBuffer(&copyBufferDesc);
dawn::CommandEncoder encoder = device.CreateCommandEncoder();
@@ -166,13 +166,13 @@ TEST_F(CommandBufferValidationTest, CallsAfterAFailedFinish) {
// A buffer that can be used in CopyBufferToBuffer
dawn::BufferDescriptor copyBufferDesc;
copyBufferDesc.size = 16;
copyBufferDesc.usage = dawn::BufferUsageBit::CopySrc | dawn::BufferUsageBit::CopyDst;
copyBufferDesc.usage = dawn::BufferUsage::CopySrc | dawn::BufferUsage::CopyDst;
dawn::Buffer copyBuffer = device.CreateBuffer(&copyBufferDesc);
// A buffer that can't be used in CopyBufferToBuffer
dawn::BufferDescriptor bufferDesc;
bufferDesc.size = 16;
bufferDesc.usage = dawn::BufferUsageBit::Uniform;
bufferDesc.usage = dawn::BufferUsage::Uniform;
dawn::Buffer buffer = device.CreateBuffer(&bufferDesc);
dawn::CommandEncoder encoder = device.CreateCommandEncoder();
@@ -186,7 +186,7 @@ TEST_F(CommandBufferValidationTest, CallsAfterAFailedFinish) {
TEST_F(CommandBufferValidationTest, BufferWithMultipleReadUsage) {
// Create a buffer used as both vertex and index buffer.
dawn::BufferDescriptor bufferDescriptor;
bufferDescriptor.usage = dawn::BufferUsageBit::Vertex | dawn::BufferUsageBit::Index;
bufferDescriptor.usage = dawn::BufferUsage::Vertex | dawn::BufferUsage::Index;
bufferDescriptor.size = 4;
dawn::Buffer buffer = device.CreateBuffer(&bufferDescriptor);
@@ -205,7 +205,7 @@ TEST_F(CommandBufferValidationTest, BufferWithMultipleReadUsage) {
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::BufferUsageBit::Storage | dawn::BufferUsageBit::Index;
bufferDescriptor.usage = dawn::BufferUsage::Storage | dawn::BufferUsage::Index;
bufferDescriptor.size = 4;
dawn::Buffer buffer = device.CreateBuffer(&bufferDescriptor);
@@ -229,7 +229,7 @@ TEST_F(CommandBufferValidationTest, BufferWithReadAndWriteUsage) {
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::TextureUsageBit::Sampled | dawn::TextureUsageBit::OutputAttachment;
textureDescriptor.usage = dawn::TextureUsage::Sampled | dawn::TextureUsage::OutputAttachment;
textureDescriptor.format = dawn::TextureFormat::RGBA8Unorm;
textureDescriptor.dimension = dawn::TextureDimension::e2D;
textureDescriptor.size = {1, 1, 1};

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

@@ -54,8 +54,8 @@ 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::BufferUsageBit::Indirect, bufferList);
dawn::Buffer indirectBuffer =
utils::CreateBufferFromData<uint32_t>(device, dawn::BufferUsage::Indirect, bufferList);
dawn::CommandEncoder encoder = device.CreateCommandEncoder();
dawn::ComputePassEncoder pass = encoder.BeginComputePass();

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

@@ -20,7 +20,7 @@
class CopyCommandTest : public ValidationTest {
protected:
dawn::Buffer CreateBuffer(uint64_t size, dawn::BufferUsageBit usage) {
dawn::Buffer CreateBuffer(uint64_t size, dawn::BufferUsage usage) {
dawn::BufferDescriptor descriptor;
descriptor.size = size;
descriptor.usage = usage;
@@ -33,7 +33,7 @@ class CopyCommandTest : public ValidationTest {
uint32_t mipLevelCount,
uint32_t arrayLayerCount,
dawn::TextureFormat format,
dawn::TextureUsageBit usage,
dawn::TextureUsage usage,
uint32_t sampleCount = 1) {
dawn::TextureDescriptor descriptor;
descriptor.dimension = dawn::TextureDimension::e2D;
@@ -150,8 +150,8 @@ class CopyCommandTest_B2B : public CopyCommandTest {};
// Test a successfull B2B copy
TEST_F(CopyCommandTest_B2B, Success) {
dawn::Buffer source = CreateBuffer(16, dawn::BufferUsageBit::CopySrc);
dawn::Buffer destination = CreateBuffer(16, dawn::BufferUsageBit::CopyDst);
dawn::Buffer source = CreateBuffer(16, dawn::BufferUsage::CopySrc);
dawn::Buffer destination = CreateBuffer(16, dawn::BufferUsage::CopyDst);
// Copy different copies, including some that touch the OOB condition
{
@@ -174,8 +174,8 @@ TEST_F(CopyCommandTest_B2B, Success) {
// Test B2B copies with OOB
TEST_F(CopyCommandTest_B2B, OutOfBounds) {
dawn::Buffer source = CreateBuffer(16, dawn::BufferUsageBit::CopySrc);
dawn::Buffer destination = CreateBuffer(16, dawn::BufferUsageBit::CopyDst);
dawn::Buffer source = CreateBuffer(16, dawn::BufferUsage::CopySrc);
dawn::Buffer destination = CreateBuffer(16, dawn::BufferUsage::CopyDst);
// OOB on the source
{
@@ -194,9 +194,9 @@ TEST_F(CopyCommandTest_B2B, OutOfBounds) {
// Test B2B copies with incorrect buffer usage
TEST_F(CopyCommandTest_B2B, BadUsage) {
dawn::Buffer source = CreateBuffer(16, dawn::BufferUsageBit::CopySrc);
dawn::Buffer destination = CreateBuffer(16, dawn::BufferUsageBit::CopyDst);
dawn::Buffer vertex = CreateBuffer(16, dawn::BufferUsageBit::Vertex);
dawn::Buffer source = CreateBuffer(16, dawn::BufferUsage::CopySrc);
dawn::Buffer destination = CreateBuffer(16, dawn::BufferUsage::CopyDst);
dawn::Buffer vertex = CreateBuffer(16, dawn::BufferUsage::Vertex);
// Source with incorrect usage
{
@@ -215,8 +215,8 @@ TEST_F(CopyCommandTest_B2B, BadUsage) {
// Test B2B copies with unaligned data size
TEST_F(CopyCommandTest_B2B, UnalignedSize) {
dawn::Buffer source = CreateBuffer(16, dawn::BufferUsageBit::CopySrc);
dawn::Buffer destination = CreateBuffer(16, dawn::BufferUsageBit::CopyDst);
dawn::Buffer source = CreateBuffer(16, dawn::BufferUsage::CopySrc);
dawn::Buffer destination = CreateBuffer(16, dawn::BufferUsage::CopyDst);
dawn::CommandEncoder encoder = device.CreateCommandEncoder();
encoder.CopyBufferToBuffer(source, 8, destination, 0, sizeof(uint8_t));
@@ -225,8 +225,8 @@ TEST_F(CopyCommandTest_B2B, UnalignedSize) {
// Test B2B copies with unaligned offset
TEST_F(CopyCommandTest_B2B, UnalignedOffset) {
dawn::Buffer source = CreateBuffer(16, dawn::BufferUsageBit::CopySrc);
dawn::Buffer destination = CreateBuffer(16, dawn::BufferUsageBit::CopyDst);
dawn::Buffer source = CreateBuffer(16, dawn::BufferUsage::CopySrc);
dawn::Buffer destination = CreateBuffer(16, dawn::BufferUsage::CopyDst);
// Unaligned source offset
{
@@ -247,11 +247,11 @@ TEST_F(CopyCommandTest_B2B, UnalignedOffset) {
TEST_F(CopyCommandTest_B2B, BuffersInErrorState) {
dawn::BufferDescriptor errorBufferDescriptor;
errorBufferDescriptor.size = 4;
errorBufferDescriptor.usage = dawn::BufferUsageBit::MapRead | dawn::BufferUsageBit::CopySrc;
errorBufferDescriptor.usage = dawn::BufferUsage::MapRead | dawn::BufferUsage::CopySrc;
ASSERT_DEVICE_ERROR(dawn::Buffer errorBuffer = device.CreateBuffer(&errorBufferDescriptor));
constexpr uint64_t bufferSize = 4;
dawn::Buffer validBuffer = CreateBuffer(bufferSize, dawn::BufferUsageBit::CopySrc);
dawn::Buffer validBuffer = CreateBuffer(bufferSize, dawn::BufferUsage::CopySrc);
{
dawn::CommandEncoder encoder = device.CreateCommandEncoder();
@@ -271,9 +271,9 @@ class CopyCommandTest_B2T : public CopyCommandTest {};
// Test a successfull B2T copy
TEST_F(CopyCommandTest_B2T, Success) {
uint64_t bufferSize = BufferSizeForTextureCopy(4, 4, 1);
dawn::Buffer source = CreateBuffer(bufferSize, dawn::BufferUsageBit::CopySrc);
dawn::Texture destination = Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm,
dawn::TextureUsageBit::CopyDst);
dawn::Buffer source = CreateBuffer(bufferSize, dawn::BufferUsage::CopySrc);
dawn::Texture destination =
Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopyDst);
// Different copies, including some that touch the OOB condition
{
@@ -324,9 +324,9 @@ TEST_F(CopyCommandTest_B2T, Success) {
// Test OOB conditions on the buffer
TEST_F(CopyCommandTest_B2T, OutOfBoundsOnBuffer) {
uint64_t bufferSize = BufferSizeForTextureCopy(4, 4, 1);
dawn::Buffer source = CreateBuffer(bufferSize, dawn::BufferUsageBit::CopySrc);
dawn::Texture destination = Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm,
dawn::TextureUsageBit::CopyDst);
dawn::Buffer source = CreateBuffer(bufferSize, dawn::BufferUsage::CopySrc);
dawn::Texture destination =
Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopyDst);
// OOB on the buffer because we copy too many pixels
TestB2TCopy(utils::Expectation::Failure, source, 0, 256, 0, destination, 0, 0, {0, 0, 0},
@@ -346,7 +346,7 @@ TEST_F(CopyCommandTest_B2T, OutOfBoundsOnBuffer) {
{
uint32_t sourceBufferSize = BufferSizeForTextureCopy(7, 3, 1);
ASSERT_TRUE(256 * 3 > sourceBufferSize) << "row pitch * height should overflow buffer";
dawn::Buffer sourceBuffer = CreateBuffer(sourceBufferSize, dawn::BufferUsageBit::CopySrc);
dawn::Buffer sourceBuffer = CreateBuffer(sourceBufferSize, dawn::BufferUsage::CopySrc);
TestB2TCopy(utils::Expectation::Success, source, 0, 256, 0, destination, 0, 0, {0, 0, 0},
{7, 3, 1});
@@ -356,9 +356,9 @@ TEST_F(CopyCommandTest_B2T, OutOfBoundsOnBuffer) {
// Test OOB conditions on the texture
TEST_F(CopyCommandTest_B2T, OutOfBoundsOnTexture) {
uint64_t bufferSize = BufferSizeForTextureCopy(4, 4, 1);
dawn::Buffer source = CreateBuffer(bufferSize, dawn::BufferUsageBit::CopySrc);
dawn::Texture destination = Create2DTexture(16, 16, 5, 2, dawn::TextureFormat::RGBA8Unorm,
dawn::TextureUsageBit::CopyDst);
dawn::Buffer source = CreateBuffer(bufferSize, dawn::BufferUsage::CopySrc);
dawn::Texture destination =
Create2DTexture(16, 16, 5, 2, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopyDst);
// OOB on the texture because x + width overflows
TestB2TCopy(utils::Expectation::Failure, source, 0, 256, 0, destination, 0, 0, {13, 12, 0},
@@ -383,9 +383,9 @@ TEST_F(CopyCommandTest_B2T, OutOfBoundsOnTexture) {
// Test that we force Z=0 and Depth=1 on copies to 2D textures
TEST_F(CopyCommandTest_B2T, ZDepthConstraintFor2DTextures) {
dawn::Buffer source = CreateBuffer(16 * 4, dawn::BufferUsageBit::CopySrc);
dawn::Texture destination = Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm,
dawn::TextureUsageBit::CopyDst);
dawn::Buffer source = CreateBuffer(16 * 4, dawn::BufferUsage::CopySrc);
dawn::Texture destination =
Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopyDst);
// Z=1 on an empty copy still errors
TestB2TCopy(utils::Expectation::Failure, source, 0, 0, 0, destination, 0, 0, {0, 0, 1},
@@ -398,12 +398,12 @@ TEST_F(CopyCommandTest_B2T, ZDepthConstraintFor2DTextures) {
// Test B2T copies with incorrect buffer usage
TEST_F(CopyCommandTest_B2T, IncorrectUsage) {
dawn::Buffer source = CreateBuffer(16 * 4, dawn::BufferUsageBit::CopySrc);
dawn::Buffer vertex = CreateBuffer(16 * 4, dawn::BufferUsageBit::Vertex);
dawn::Texture destination = Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm,
dawn::TextureUsageBit::CopyDst);
dawn::Texture sampled = Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm,
dawn::TextureUsageBit::Sampled);
dawn::Buffer source = CreateBuffer(16 * 4, dawn::BufferUsage::CopySrc);
dawn::Buffer vertex = CreateBuffer(16 * 4, dawn::BufferUsage::Vertex);
dawn::Texture destination =
Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopyDst);
dawn::Texture sampled =
Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::Sampled);
// Incorrect source usage
TestB2TCopy(utils::Expectation::Failure, vertex, 0, 256, 0, destination, 0, 0, {0, 0, 0},
@@ -416,9 +416,9 @@ TEST_F(CopyCommandTest_B2T, IncorrectUsage) {
TEST_F(CopyCommandTest_B2T, IncorrectRowPitch) {
uint64_t bufferSize = BufferSizeForTextureCopy(128, 16, 1);
dawn::Buffer source = CreateBuffer(bufferSize, dawn::BufferUsageBit::CopySrc);
dawn::Buffer source = CreateBuffer(bufferSize, dawn::BufferUsage::CopySrc);
dawn::Texture destination = Create2DTexture(128, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm,
dawn::TextureUsageBit::CopyDst);
dawn::TextureUsage::CopyDst);
// Default row pitch is not 256-byte aligned
TestB2TCopy(utils::Expectation::Failure, source, 0, 0, 0, destination, 0, 0, {0, 0, 0},
@@ -435,9 +435,9 @@ TEST_F(CopyCommandTest_B2T, IncorrectRowPitch) {
TEST_F(CopyCommandTest_B2T, ImageHeightConstraint) {
uint64_t bufferSize = BufferSizeForTextureCopy(5, 5, 1);
dawn::Buffer source = CreateBuffer(bufferSize, dawn::BufferUsageBit::CopySrc);
dawn::Texture destination = Create2DTexture(16, 16, 1, 1, dawn::TextureFormat::RGBA8Unorm,
dawn::TextureUsageBit::CopyDst);
dawn::Buffer source = CreateBuffer(bufferSize, dawn::BufferUsage::CopySrc);
dawn::Texture destination =
Create2DTexture(16, 16, 1, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopyDst);
// Image height is zero (Valid)
TestB2TCopy(utils::Expectation::Success, source, 0, 256, 0, destination, 0, 0, {0, 0, 0},
@@ -459,9 +459,9 @@ TEST_F(CopyCommandTest_B2T, ImageHeightConstraint) {
// Test B2T copies with incorrect buffer offset usage
TEST_F(CopyCommandTest_B2T, IncorrectBufferOffset) {
uint64_t bufferSize = BufferSizeForTextureCopy(4, 4, 1);
dawn::Buffer source = CreateBuffer(bufferSize, dawn::BufferUsageBit::CopySrc);
dawn::Texture destination = Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm,
dawn::TextureUsageBit::CopyDst);
dawn::Buffer source = CreateBuffer(bufferSize, dawn::BufferUsage::CopySrc);
dawn::Texture destination =
Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopyDst);
// Correct usage
TestB2TCopy(utils::Expectation::Success, source, bufferSize - 4, 256, 0, destination, 0, 0,
@@ -481,9 +481,9 @@ TEST_F(CopyCommandTest_B2T, IncorrectBufferOffset) {
// Test multisampled textures cannot be used in B2T copies.
TEST_F(CopyCommandTest_B2T, CopyToMultisampledTexture) {
uint64_t bufferSize = BufferSizeForTextureCopy(16, 16, 1);
dawn::Buffer source = CreateBuffer(bufferSize, dawn::BufferUsageBit::CopySrc);
dawn::Buffer source = CreateBuffer(bufferSize, dawn::BufferUsage::CopySrc);
dawn::Texture destination = Create2DTexture(2, 2, 1, 1, dawn::TextureFormat::RGBA8Unorm,
dawn::TextureUsageBit::CopyDst, 4);
dawn::TextureUsage::CopyDst, 4);
TestB2TCopy(utils::Expectation::Failure, source, 0, 256, 0, destination, 0, 0, {0, 0, 0},
{2, 2, 1});
@@ -493,7 +493,7 @@ TEST_F(CopyCommandTest_B2T, CopyToMultisampledTexture) {
TEST_F(CopyCommandTest_B2T, BufferOrTextureInErrorState) {
dawn::BufferDescriptor errorBufferDescriptor;
errorBufferDescriptor.size = 4;
errorBufferDescriptor.usage = dawn::BufferUsageBit::MapRead | dawn::BufferUsageBit::CopySrc;
errorBufferDescriptor.usage = dawn::BufferUsage::MapRead | dawn::BufferUsage::CopySrc;
ASSERT_DEVICE_ERROR(dawn::Buffer errorBuffer = device.CreateBuffer(&errorBufferDescriptor));
dawn::TextureDescriptor errorTextureDescriptor;
@@ -508,7 +508,7 @@ TEST_F(CopyCommandTest_B2T, BufferOrTextureInErrorState) {
{
dawn::Texture destination = Create2DTexture(16, 16, 1, 1, dawn::TextureFormat::RGBA8Unorm,
dawn::TextureUsageBit::CopyDst);
dawn::TextureUsage::CopyDst);
dawn::TextureCopyView textureCopyView =
utils::CreateTextureCopyView(destination, 0, 0, {1, 1, 1});
@@ -519,7 +519,7 @@ TEST_F(CopyCommandTest_B2T, BufferOrTextureInErrorState) {
{
uint64_t bufferSize = BufferSizeForTextureCopy(4, 4, 1);
dawn::Buffer source = CreateBuffer(bufferSize, dawn::BufferUsageBit::CopySrc);
dawn::Buffer source = CreateBuffer(bufferSize, dawn::BufferUsage::CopySrc);
dawn::BufferCopyView bufferCopyView = utils::CreateBufferCopyView(source, 0, 0, 0);
@@ -544,9 +544,9 @@ TEST_F(CopyCommandTest_B2T, TextureCopyBufferSizeLastRowComputation) {
constexpr uint32_t kInvalidBufferSize = kRowPitch * (kHeight - 1) + kWidth;
for (dawn::TextureFormat format : kFormats) {
dawn::Buffer source = CreateBuffer(kInvalidBufferSize, dawn::BufferUsageBit::CopySrc);
dawn::Buffer source = CreateBuffer(kInvalidBufferSize, dawn::BufferUsage::CopySrc);
dawn::Texture destination =
Create2DTexture(kWidth, kHeight, 1, 1, format, dawn::TextureUsageBit::CopyDst);
Create2DTexture(kWidth, kHeight, 1, 1, format, dawn::TextureUsage::CopyDst);
TestB2TCopy(utils::Expectation::Failure, source, 0, kRowPitch, 0, destination, 0, 0,
{0, 0, 0}, {kWidth, kHeight, 1});
}
@@ -556,20 +556,19 @@ TEST_F(CopyCommandTest_B2T, TextureCopyBufferSizeLastRowComputation) {
for (dawn::TextureFormat format : kFormats) {
uint32_t validBufferSize = BufferSizeForTextureCopy(kWidth, kHeight, 1, format);
dawn::Texture destination =
Create2DTexture(kWidth, kHeight, 1, 1, format, dawn::TextureUsageBit::CopyDst);
Create2DTexture(kWidth, kHeight, 1, 1, format, dawn::TextureUsage::CopyDst);
// Verify the return value of BufferSizeForTextureCopy() is exactly the minimum valid
// buffer size in this test.
{
uint32_t invalidBuffferSize = validBufferSize - 1;
dawn::Buffer source =
CreateBuffer(invalidBuffferSize, dawn::BufferUsageBit::CopySrc);
dawn::Buffer source = CreateBuffer(invalidBuffferSize, dawn::BufferUsage::CopySrc);
TestB2TCopy(utils::Expectation::Failure, source, 0, kRowPitch, 0, destination, 0, 0,
{0, 0, 0}, {kWidth, kHeight, 1});
}
{
dawn::Buffer source = CreateBuffer(validBufferSize, dawn::BufferUsageBit::CopySrc);
dawn::Buffer source = CreateBuffer(validBufferSize, dawn::BufferUsage::CopySrc);
TestB2TCopy(utils::Expectation::Success, source, 0, kRowPitch, 0, destination, 0, 0,
{0, 0, 0}, {kWidth, kHeight, 1});
}
@@ -580,10 +579,10 @@ TEST_F(CopyCommandTest_B2T, TextureCopyBufferSizeLastRowComputation) {
// Test copy from buffer to mip map of non square texture
TEST_F(CopyCommandTest_B2T, CopyToMipmapOfNonSquareTexture) {
uint64_t bufferSize = BufferSizeForTextureCopy(4, 2, 1);
dawn::Buffer source = CreateBuffer(bufferSize, dawn::BufferUsageBit::CopySrc);
dawn::Buffer source = CreateBuffer(bufferSize, dawn::BufferUsage::CopySrc);
uint32_t maxMipmapLevel = 3;
dawn::Texture destination = Create2DTexture(
4, 2, maxMipmapLevel, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsageBit::CopyDst);
4, 2, maxMipmapLevel, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopyDst);
// Copy to top level mip map
TestB2TCopy(utils::Expectation::Success, source, 0, 256, 0, destination, maxMipmapLevel - 1, 0,
@@ -607,9 +606,9 @@ class CopyCommandTest_T2B : public CopyCommandTest {};
// Test a successfull T2B copy
TEST_F(CopyCommandTest_T2B, Success) {
uint64_t bufferSize = BufferSizeForTextureCopy(4, 4, 1);
dawn::Texture source = Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm,
dawn::TextureUsageBit::CopySrc);
dawn::Buffer destination = CreateBuffer(bufferSize, dawn::BufferUsageBit::CopyDst);
dawn::Texture source =
Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopySrc);
dawn::Buffer destination = CreateBuffer(bufferSize, dawn::BufferUsage::CopyDst);
// Different copies, including some that touch the OOB condition
{
@@ -660,9 +659,9 @@ TEST_F(CopyCommandTest_T2B, Success) {
// Test OOB conditions on the texture
TEST_F(CopyCommandTest_T2B, OutOfBoundsOnTexture) {
uint64_t bufferSize = BufferSizeForTextureCopy(4, 4, 1);
dawn::Texture source = Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm,
dawn::TextureUsageBit::CopySrc);
dawn::Buffer destination = CreateBuffer(bufferSize, dawn::BufferUsageBit::CopyDst);
dawn::Texture source =
Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopySrc);
dawn::Buffer destination = CreateBuffer(bufferSize, dawn::BufferUsage::CopyDst);
// OOB on the texture because x + width overflows
TestT2BCopy(utils::Expectation::Failure, source, 0, 0, {13, 12, 0}, destination, 0, 256, 0,
@@ -684,9 +683,9 @@ TEST_F(CopyCommandTest_T2B, OutOfBoundsOnTexture) {
// Test OOB conditions on the buffer
TEST_F(CopyCommandTest_T2B, OutOfBoundsOnBuffer) {
uint64_t bufferSize = BufferSizeForTextureCopy(4, 4, 1);
dawn::Texture source = Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm,
dawn::TextureUsageBit::CopySrc);
dawn::Buffer destination = CreateBuffer(bufferSize, dawn::BufferUsageBit::CopyDst);
dawn::Texture source =
Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopySrc);
dawn::Buffer destination = CreateBuffer(bufferSize, dawn::BufferUsage::CopyDst);
// OOB on the buffer because we copy too many pixels
TestT2BCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, destination, 0, 256, 0,
@@ -707,7 +706,7 @@ TEST_F(CopyCommandTest_T2B, OutOfBoundsOnBuffer) {
uint32_t destinationBufferSize = BufferSizeForTextureCopy(7, 3, 1);
ASSERT_TRUE(256 * 3 > destinationBufferSize) << "row pitch * height should overflow buffer";
dawn::Buffer destinationBuffer =
CreateBuffer(destinationBufferSize, dawn::BufferUsageBit::CopyDst);
CreateBuffer(destinationBufferSize, dawn::BufferUsage::CopyDst);
TestT2BCopy(utils::Expectation::Success, source, 0, 0, {0, 0, 0}, destinationBuffer, 0, 256,
0, {7, 3, 1});
}
@@ -716,9 +715,9 @@ TEST_F(CopyCommandTest_T2B, OutOfBoundsOnBuffer) {
// Test that we force Z=0 and Depth=1 on copies from to 2D textures
TEST_F(CopyCommandTest_T2B, ZDepthConstraintFor2DTextures) {
uint64_t bufferSize = BufferSizeForTextureCopy(4, 4, 1);
dawn::Texture source = Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm,
dawn::TextureUsageBit::CopySrc);
dawn::Buffer destination = CreateBuffer(bufferSize, dawn::BufferUsageBit::CopyDst);
dawn::Texture source =
Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopySrc);
dawn::Buffer destination = CreateBuffer(bufferSize, dawn::BufferUsage::CopyDst);
// Z=1 on an empty copy still errors
TestT2BCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 1}, destination, 0, 0, 0,
@@ -732,12 +731,12 @@ TEST_F(CopyCommandTest_T2B, ZDepthConstraintFor2DTextures) {
// Test T2B copies with incorrect buffer usage
TEST_F(CopyCommandTest_T2B, IncorrectUsage) {
uint64_t bufferSize = BufferSizeForTextureCopy(4, 4, 1);
dawn::Texture source = Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm,
dawn::TextureUsageBit::CopySrc);
dawn::Texture sampled = Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm,
dawn::TextureUsageBit::Sampled);
dawn::Buffer destination = CreateBuffer(bufferSize, dawn::BufferUsageBit::CopyDst);
dawn::Buffer vertex = CreateBuffer(bufferSize, dawn::BufferUsageBit::Vertex);
dawn::Texture source =
Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopySrc);
dawn::Texture sampled =
Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::Sampled);
dawn::Buffer destination = CreateBuffer(bufferSize, dawn::BufferUsage::CopyDst);
dawn::Buffer vertex = CreateBuffer(bufferSize, dawn::BufferUsage::Vertex);
// Incorrect source usage
TestT2BCopy(utils::Expectation::Failure, sampled, 0, 0, {0, 0, 0}, destination, 0, 256, 0,
@@ -750,8 +749,8 @@ TEST_F(CopyCommandTest_T2B, IncorrectUsage) {
TEST_F(CopyCommandTest_T2B, IncorrectRowPitch) {
uint64_t bufferSize = BufferSizeForTextureCopy(128, 16, 1);
dawn::Texture source = Create2DTexture(128, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm,
dawn::TextureUsageBit::CopyDst);
dawn::Buffer destination = CreateBuffer(bufferSize, dawn::BufferUsageBit::CopySrc);
dawn::TextureUsage::CopyDst);
dawn::Buffer destination = CreateBuffer(bufferSize, dawn::BufferUsage::CopySrc);
// Default row pitch is not 256-byte aligned
TestT2BCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, destination, 0, 256, 0,
@@ -768,9 +767,9 @@ TEST_F(CopyCommandTest_T2B, IncorrectRowPitch) {
TEST_F(CopyCommandTest_T2B, ImageHeightConstraint) {
uint64_t bufferSize = BufferSizeForTextureCopy(5, 5, 1);
dawn::Texture source = Create2DTexture(16, 16, 1, 1, dawn::TextureFormat::RGBA8Unorm,
dawn::TextureUsageBit::CopySrc);
dawn::Buffer destination = CreateBuffer(bufferSize, dawn::BufferUsageBit::CopyDst);
dawn::Texture source =
Create2DTexture(16, 16, 1, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopySrc);
dawn::Buffer destination = CreateBuffer(bufferSize, dawn::BufferUsage::CopyDst);
// Image height is zero (Valid)
TestT2BCopy(utils::Expectation::Success, source, 0, 0, {0, 0, 0}, destination, 0, 256, 0,
@@ -793,8 +792,8 @@ TEST_F(CopyCommandTest_T2B, ImageHeightConstraint) {
TEST_F(CopyCommandTest_T2B, IncorrectBufferOffset) {
uint64_t bufferSize = BufferSizeForTextureCopy(128, 16, 1);
dawn::Texture source = Create2DTexture(128, 16, 5, 1, dawn::TextureFormat::RGBA8Unorm,
dawn::TextureUsageBit::CopySrc);
dawn::Buffer destination = CreateBuffer(bufferSize, dawn::BufferUsageBit::CopyDst);
dawn::TextureUsage::CopySrc);
dawn::Buffer destination = CreateBuffer(bufferSize, dawn::BufferUsage::CopyDst);
// Correct usage
TestT2BCopy(utils::Expectation::Success, source, 0, 0, {0, 0, 0}, destination, bufferSize - 4,
@@ -812,9 +811,9 @@ TEST_F(CopyCommandTest_T2B, IncorrectBufferOffset) {
// Test multisampled textures cannot be used in T2B copies.
TEST_F(CopyCommandTest_T2B, CopyFromMultisampledTexture) {
dawn::Texture source = Create2DTexture(2, 2, 1, 1, dawn::TextureFormat::RGBA8Unorm,
dawn::TextureUsageBit::CopySrc, 4);
dawn::TextureUsage::CopySrc, 4);
uint64_t bufferSize = BufferSizeForTextureCopy(16, 16, 1);
dawn::Buffer destination = CreateBuffer(bufferSize, dawn::BufferUsageBit::CopyDst);
dawn::Buffer destination = CreateBuffer(bufferSize, dawn::BufferUsage::CopyDst);
TestT2BCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, destination, 0, 256, 0,
{2, 2, 1});
@@ -824,7 +823,7 @@ TEST_F(CopyCommandTest_T2B, CopyFromMultisampledTexture) {
TEST_F(CopyCommandTest_T2B, BufferOrTextureInErrorState) {
dawn::BufferDescriptor errorBufferDescriptor;
errorBufferDescriptor.size = 4;
errorBufferDescriptor.usage = dawn::BufferUsageBit::MapRead | dawn::BufferUsageBit::CopySrc;
errorBufferDescriptor.usage = dawn::BufferUsage::MapRead | dawn::BufferUsage::CopySrc;
ASSERT_DEVICE_ERROR(dawn::Buffer errorBuffer = device.CreateBuffer(&errorBufferDescriptor));
dawn::TextureDescriptor errorTextureDescriptor;
@@ -839,7 +838,7 @@ TEST_F(CopyCommandTest_T2B, BufferOrTextureInErrorState) {
{
uint64_t bufferSize = BufferSizeForTextureCopy(4, 4, 1);
dawn::Buffer source = CreateBuffer(bufferSize, dawn::BufferUsageBit::CopySrc);
dawn::Buffer source = CreateBuffer(bufferSize, dawn::BufferUsage::CopySrc);
dawn::BufferCopyView bufferCopyView = utils::CreateBufferCopyView(source, 0, 0, 0);
@@ -850,7 +849,7 @@ TEST_F(CopyCommandTest_T2B, BufferOrTextureInErrorState) {
{
dawn::Texture destination = Create2DTexture(16, 16, 1, 1, dawn::TextureFormat::RGBA8Unorm,
dawn::TextureUsageBit::CopyDst);
dawn::TextureUsage::CopyDst);
dawn::TextureCopyView textureCopyView =
utils::CreateTextureCopyView(destination, 0, 0, {1, 1, 1});
@@ -876,10 +875,9 @@ TEST_F(CopyCommandTest_T2B, TextureCopyBufferSizeLastRowComputation) {
for (dawn::TextureFormat format : kFormats) {
dawn::Texture source =
Create2DTexture(kWidth, kHeight, 1, 1, format, dawn::TextureUsageBit::CopyDst);
Create2DTexture(kWidth, kHeight, 1, 1, format, dawn::TextureUsage::CopyDst);
dawn::Buffer destination =
CreateBuffer(kInvalidBufferSize, dawn::BufferUsageBit::CopySrc);
dawn::Buffer destination = CreateBuffer(kInvalidBufferSize, dawn::BufferUsage::CopySrc);
TestT2BCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, destination, 0,
kRowPitch, 0, {kWidth, kHeight, 1});
}
@@ -889,21 +887,21 @@ TEST_F(CopyCommandTest_T2B, TextureCopyBufferSizeLastRowComputation) {
for (dawn::TextureFormat format : kFormats) {
uint32_t validBufferSize = BufferSizeForTextureCopy(kWidth, kHeight, 1, format);
dawn::Texture source =
Create2DTexture(kWidth, kHeight, 1, 1, format, dawn::TextureUsageBit::CopySrc);
Create2DTexture(kWidth, kHeight, 1, 1, format, dawn::TextureUsage::CopySrc);
// Verify the return value of BufferSizeForTextureCopy() is exactly the minimum valid
// buffer size in this test.
{
uint32_t invalidBufferSize = validBufferSize - 1;
dawn::Buffer destination =
CreateBuffer(invalidBufferSize, dawn::BufferUsageBit::CopyDst);
CreateBuffer(invalidBufferSize, dawn::BufferUsage::CopyDst);
TestT2BCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, destination, 0,
kRowPitch, 0, {kWidth, kHeight, 1});
}
{
dawn::Buffer destination =
CreateBuffer(validBufferSize, dawn::BufferUsageBit::CopyDst);
CreateBuffer(validBufferSize, dawn::BufferUsage::CopyDst);
TestT2BCopy(utils::Expectation::Success, source, 0, 0, {0, 0, 0}, destination, 0,
kRowPitch, 0, {kWidth, kHeight, 1});
}
@@ -915,9 +913,9 @@ TEST_F(CopyCommandTest_T2B, TextureCopyBufferSizeLastRowComputation) {
TEST_F(CopyCommandTest_T2B, CopyFromMipmapOfNonSquareTexture) {
uint32_t maxMipmapLevel = 3;
dawn::Texture source = Create2DTexture(4, 2, maxMipmapLevel, 1, dawn::TextureFormat::RGBA8Unorm,
dawn::TextureUsageBit::CopySrc);
dawn::TextureUsage::CopySrc);
uint64_t bufferSize = BufferSizeForTextureCopy(4, 2, 1);
dawn::Buffer destination = CreateBuffer(bufferSize, dawn::BufferUsageBit::CopyDst);
dawn::Buffer destination = CreateBuffer(bufferSize, dawn::BufferUsage::CopyDst);
// Copy from top level mip map
TestT2BCopy(utils::Expectation::Success, source, maxMipmapLevel - 1, 0, {0, 0, 0}, destination,
@@ -939,10 +937,10 @@ TEST_F(CopyCommandTest_T2B, CopyFromMipmapOfNonSquareTexture) {
class CopyCommandTest_T2T : public CopyCommandTest {};
TEST_F(CopyCommandTest_T2T, Success) {
dawn::Texture source = Create2DTexture(16, 16, 5, 2, dawn::TextureFormat::RGBA8Unorm,
dawn::TextureUsageBit::CopySrc);
dawn::Texture destination = Create2DTexture(16, 16, 5, 2, dawn::TextureFormat::RGBA8Unorm,
dawn::TextureUsageBit::CopyDst);
dawn::Texture source =
Create2DTexture(16, 16, 5, 2, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopySrc);
dawn::Texture destination =
Create2DTexture(16, 16, 5, 2, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopyDst);
// Different copies, including some that touch the OOB condition
{
@@ -992,10 +990,10 @@ TEST_F(CopyCommandTest_T2T, Success) {
}
TEST_F(CopyCommandTest_T2T, IncorrectUsage) {
dawn::Texture source = Create2DTexture(16, 16, 5, 2, dawn::TextureFormat::RGBA8Unorm,
dawn::TextureUsageBit::CopySrc);
dawn::Texture destination = Create2DTexture(16, 16, 5, 2, dawn::TextureFormat::RGBA8Unorm,
dawn::TextureUsageBit::CopyDst);
dawn::Texture source =
Create2DTexture(16, 16, 5, 2, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopySrc);
dawn::Texture destination =
Create2DTexture(16, 16, 5, 2, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopyDst);
// Incorrect source usage causes failure
TestT2TCopy(utils::Expectation::Failure, destination, 0, 0, {0, 0, 0}, destination, 0, 0,
@@ -1007,10 +1005,10 @@ TEST_F(CopyCommandTest_T2T, IncorrectUsage) {
}
TEST_F(CopyCommandTest_T2T, OutOfBounds) {
dawn::Texture source = Create2DTexture(16, 16, 5, 2, dawn::TextureFormat::RGBA8Unorm,
dawn::TextureUsageBit::CopySrc);
dawn::Texture destination = Create2DTexture(16, 16, 5, 2, dawn::TextureFormat::RGBA8Unorm,
dawn::TextureUsageBit::CopyDst);
dawn::Texture source =
Create2DTexture(16, 16, 5, 2, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopySrc);
dawn::Texture destination =
Create2DTexture(16, 16, 5, 2, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopyDst);
// OOB on source
{
@@ -1060,10 +1058,10 @@ TEST_F(CopyCommandTest_T2T, OutOfBounds) {
}
TEST_F(CopyCommandTest_T2T, 2DTextureDepthConstraints) {
dawn::Texture source = Create2DTexture(16, 16, 5, 2, dawn::TextureFormat::RGBA8Unorm,
dawn::TextureUsageBit::CopySrc);
dawn::Texture destination = Create2DTexture(16, 16, 5, 2, dawn::TextureFormat::RGBA8Unorm,
dawn::TextureUsageBit::CopyDst);
dawn::Texture source =
Create2DTexture(16, 16, 5, 2, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopySrc);
dawn::Texture destination =
Create2DTexture(16, 16, 5, 2, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopyDst);
// Empty copy on source with z > 0 fails
TestT2TCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 1}, destination, 0, 0, {0, 0, 0},
@@ -1080,9 +1078,9 @@ TEST_F(CopyCommandTest_T2T, 2DTextureDepthConstraints) {
TEST_F(CopyCommandTest_T2T, 2DTextureDepthStencil) {
dawn::Texture source = Create2DTexture(16, 16, 1, 1, dawn::TextureFormat::Depth24PlusStencil8,
dawn::TextureUsageBit::CopySrc);
dawn::TextureUsage::CopySrc);
dawn::Texture destination = Create2DTexture(
16, 16, 1, 1, dawn::TextureFormat::Depth24PlusStencil8, dawn::TextureUsageBit::CopyDst);
16, 16, 1, 1, dawn::TextureFormat::Depth24PlusStencil8, dawn::TextureUsage::CopyDst);
// Success when entire depth stencil subresource is copied
TestT2TCopy(utils::Expectation::Success, source, 0, 0, {0, 0, 0}, destination, 0, 0, {0, 0, 0},
@@ -1094,10 +1092,10 @@ TEST_F(CopyCommandTest_T2T, 2DTextureDepthStencil) {
}
TEST_F(CopyCommandTest_T2T, FormatsMismatch) {
dawn::Texture source = Create2DTexture(16, 16, 5, 2, dawn::TextureFormat::RGBA8Uint,
dawn::TextureUsageBit::CopySrc);
dawn::Texture destination = Create2DTexture(16, 16, 5, 2, dawn::TextureFormat::RGBA8Unorm,
dawn::TextureUsageBit::CopyDst);
dawn::Texture source =
Create2DTexture(16, 16, 5, 2, dawn::TextureFormat::RGBA8Uint, dawn::TextureUsage::CopySrc);
dawn::Texture destination =
Create2DTexture(16, 16, 5, 2, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopyDst);
// Failure when formats don't match
TestT2TCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, destination, 0, 0, {0, 0, 0},
@@ -1106,11 +1104,11 @@ TEST_F(CopyCommandTest_T2T, FormatsMismatch) {
TEST_F(CopyCommandTest_T2T, MultisampledCopies) {
dawn::Texture sourceMultiSampled1x = Create2DTexture(
16, 16, 1, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsageBit::CopySrc, 1);
16, 16, 1, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopySrc, 1);
dawn::Texture sourceMultiSampled4x = Create2DTexture(
16, 16, 1, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsageBit::CopySrc, 4);
16, 16, 1, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopySrc, 4);
dawn::Texture destinationMultiSampled4x = Create2DTexture(
16, 16, 1, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsageBit::CopyDst, 4);
16, 16, 1, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopyDst, 4);
// Success when entire multisampled subresource is copied
{
@@ -1134,9 +1132,9 @@ TEST_F(CopyCommandTest_T2T, MultisampledCopies) {
TEST_F(CopyCommandTest_T2T, CopyToMipmapOfNonSquareTexture) {
uint32_t maxMipmapLevel = 3;
dawn::Texture source = Create2DTexture(4, 2, maxMipmapLevel, 1, dawn::TextureFormat::RGBA8Unorm,
dawn::TextureUsageBit::CopySrc);
dawn::TextureUsage::CopySrc);
dawn::Texture destination = Create2DTexture(
4, 2, maxMipmapLevel, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsageBit::CopyDst);
4, 2, maxMipmapLevel, 1, dawn::TextureFormat::RGBA8Unorm, dawn::TextureUsage::CopyDst);
// Copy to top level mip map
TestT2TCopy(utils::Expectation::Success, source, maxMipmapLevel - 1, 0, {0, 0, 0}, destination,
maxMipmapLevel - 1, 0, {0, 0, 0}, {1, 1, 1});
@@ -1165,9 +1163,8 @@ class CopyCommandTest_CompressedTextureFormats : public CopyCommandTest {
uint32_t mipmapLevels = 1,
uint32_t width = kWidth,
uint32_t height = kHeight) {
constexpr dawn::TextureUsageBit kUsage = dawn::TextureUsageBit::CopyDst |
dawn::TextureUsageBit::CopySrc |
dawn::TextureUsageBit::Sampled;
constexpr dawn::TextureUsage kUsage =
dawn::TextureUsage::CopyDst | dawn::TextureUsage::CopySrc | dawn::TextureUsage::Sampled;
constexpr uint32_t kArrayLayers = 1;
return CopyCommandTest::Create2DTexture(width, height, mipmapLevels, kArrayLayers, format,
kUsage, 1);
@@ -1246,7 +1243,7 @@ class CopyCommandTest_CompressedTextureFormats : public CopyCommandTest {
// in buffer-to-texture or texture-to-buffer copies with compressed texture formats.
TEST_F(CopyCommandTest_CompressedTextureFormats, BufferOffset) {
dawn::Buffer buffer =
CreateBuffer(512, dawn::BufferUsageBit::CopySrc | dawn::BufferUsageBit::CopyDst);
CreateBuffer(512, dawn::BufferUsage::CopySrc | dawn::BufferUsage::CopyDst);
for (dawn::TextureFormat bcFormat : kBCFormats) {
dawn::Texture texture = Create2DTexture(bcFormat);
@@ -1274,7 +1271,7 @@ TEST_F(CopyCommandTest_CompressedTextureFormats, BufferOffset) {
// the multiple of compressed texture block width in bytes.
TEST_F(CopyCommandTest_CompressedTextureFormats, RowPitch) {
dawn::Buffer buffer =
CreateBuffer(1024, dawn::BufferUsageBit::CopySrc | dawn::BufferUsageBit::CopyDst);
CreateBuffer(1024, dawn::BufferUsage::CopySrc | dawn::BufferUsage::CopyDst);
{
constexpr uint32_t kTestWidth = 160;
@@ -1343,7 +1340,7 @@ TEST_F(CopyCommandTest_CompressedTextureFormats, RowPitch) {
// buffer-to-texture or texture-to-buffer copies with compressed texture formats.
TEST_F(CopyCommandTest_CompressedTextureFormats, ImageHeight) {
dawn::Buffer buffer =
CreateBuffer(512, dawn::BufferUsageBit::CopySrc | dawn::BufferUsageBit::CopyDst);
CreateBuffer(512, dawn::BufferUsage::CopySrc | dawn::BufferUsage::CopyDst);
for (dawn::TextureFormat bcFormat : kBCFormats) {
dawn::Texture texture = Create2DTexture(bcFormat);
@@ -1369,7 +1366,7 @@ TEST_F(CopyCommandTest_CompressedTextureFormats, ImageHeight) {
// texture-to-buffer or texture-to-texture copies with compressed texture formats.
TEST_F(CopyCommandTest_CompressedTextureFormats, ImageOffset) {
dawn::Buffer buffer =
CreateBuffer(512, dawn::BufferUsageBit::CopySrc | dawn::BufferUsageBit::CopyDst);
CreateBuffer(512, dawn::BufferUsage::CopySrc | dawn::BufferUsage::CopyDst);
for (dawn::TextureFormat bcFormat : kBCFormats) {
dawn::Texture texture = Create2DTexture(bcFormat);
@@ -1412,7 +1409,7 @@ TEST_F(CopyCommandTest_CompressedTextureFormats, ImageOffset) {
// texture-to-buffer or texture-to-texture copies with compressed texture formats.
TEST_F(CopyCommandTest_CompressedTextureFormats, ImageExtent) {
dawn::Buffer buffer =
CreateBuffer(512, dawn::BufferUsageBit::CopySrc | dawn::BufferUsageBit::CopyDst);
CreateBuffer(512, dawn::BufferUsage::CopySrc | dawn::BufferUsage::CopyDst);
constexpr uint32_t kMipmapLevels = 3;
constexpr uint32_t kTestWidth = 60;

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

@@ -73,8 +73,8 @@ class DrawIndirectValidationTest : public ValidationTest {
std::initializer_list<uint32_t> bufferList,
uint64_t indirectOffset,
bool indexed) {
dawn::Buffer indirectBuffer = utils::CreateBufferFromData<uint32_t>(
device, dawn::BufferUsageBit::Indirect, bufferList);
dawn::Buffer indirectBuffer =
utils::CreateBufferFromData<uint32_t>(device, dawn::BufferUsage::Indirect, bufferList);
DummyRenderPass renderPass(device);
dawn::CommandEncoder encoder = device.CreateCommandEncoder();
@@ -82,8 +82,8 @@ class DrawIndirectValidationTest : public ValidationTest {
pass.SetPipeline(pipeline);
if (indexed) {
uint32_t zeros[100] = {};
dawn::Buffer indexBuffer = utils::CreateBufferFromData(device, zeros, sizeof(zeros),
dawn::BufferUsageBit::Index);
dawn::Buffer indexBuffer =
utils::CreateBufferFromData(device, zeros, sizeof(zeros), dawn::BufferUsage::Index);
pass.SetIndexBuffer(indexBuffer, 0);
pass.DrawIndexedIndirect(indirectBuffer, indirectOffset);
} else {

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

@@ -32,12 +32,12 @@ static void StoreTrueMapWriteCallback(DawnBufferMapAsyncStatus status,
TEST_F(QueueSubmitValidationTest, SubmitWithMappedBuffer) {
// Create a map-write buffer.
dawn::BufferDescriptor descriptor;
descriptor.usage = dawn::BufferUsageBit::MapWrite | dawn::BufferUsageBit::CopySrc;
descriptor.usage = dawn::BufferUsage::MapWrite | dawn::BufferUsage::CopySrc;
descriptor.size = 4;
dawn::Buffer buffer = device.CreateBuffer(&descriptor);
// Create a fake copy destination buffer
descriptor.usage = dawn::BufferUsageBit::CopyDst;
descriptor.usage = dawn::BufferUsage::CopyDst;
dawn::Buffer targetBuffer = device.CreateBuffer(&descriptor);
// Create a command buffer that reads from the mappable buffer.

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

@@ -69,21 +69,21 @@ namespace {
float data[4];
dawn::Buffer buffer = utils::CreateBufferFromData(device, data, 4 * sizeof(float),
dawn::BufferUsageBit::Uniform);
dawn::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::BufferUsageBit::Vertex);
dawn::BufferUsage::Vertex);
// Dummy storage buffer.
dawn::Buffer storageBuffer = utils::CreateBufferFromData(
device, kVertices, sizeof(kVertices), dawn::BufferUsageBit::Storage);
device, kVertices, sizeof(kVertices), dawn::BufferUsage::Storage);
// Vertex buffer with storage usage for testing read+write error usage.
vertexStorageBuffer = utils::CreateBufferFromData(
device, kVertices, sizeof(kVertices),
dawn::BufferUsageBit::Vertex | dawn::BufferUsageBit::Storage);
vertexStorageBuffer =
utils::CreateBufferFromData(device, kVertices, sizeof(kVertices),
dawn::BufferUsage::Vertex | dawn::BufferUsage::Storage);
bg0 = utils::MakeBindGroup(device, bgls[0], {{0, buffer, 0, 4 * sizeof(float)}});
bg1 = utils::MakeBindGroup(
@@ -843,7 +843,7 @@ TEST_F(RenderBundleValidationTest, RenderPassColorFormatMismatch) {
dawn::RenderBundle renderBundle = renderBundleEncoder.Finish();
dawn::TextureDescriptor textureDesc = {};
textureDesc.usage = dawn::TextureUsageBit::OutputAttachment;
textureDesc.usage = dawn::TextureUsage::OutputAttachment;
textureDesc.size = dawn::Extent3D({400, 400, 1});
textureDesc.format = dawn::TextureFormat::RGBA8Unorm;
@@ -914,7 +914,7 @@ TEST_F(RenderBundleValidationTest, RenderPassDepthStencilFormatMismatch) {
dawn::RenderBundle renderBundle = renderBundleEncoder.Finish();
dawn::TextureDescriptor textureDesc = {};
textureDesc.usage = dawn::TextureUsageBit::OutputAttachment;
textureDesc.usage = dawn::TextureUsage::OutputAttachment;
textureDesc.size = dawn::Extent3D({400, 400, 1});
textureDesc.format = dawn::TextureFormat::RGBA8Unorm;
@@ -973,7 +973,7 @@ TEST_F(RenderBundleValidationTest, RenderPassSampleCountMismatch) {
dawn::RenderBundle renderBundle = renderBundleEncoder.Finish();
dawn::TextureDescriptor textureDesc = {};
textureDesc.usage = dawn::TextureUsageBit::OutputAttachment;
textureDesc.usage = dawn::TextureUsage::OutputAttachment;
textureDesc.size = dawn::Extent3D({400, 400, 1});
textureDesc.format = dawn::TextureFormat::RGBA8Unorm;

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

@@ -48,7 +48,7 @@ dawn::Texture CreateTexture(dawn::Device& device,
uint32_t arrayLayerCount,
uint32_t mipLevelCount,
uint32_t sampleCount = 1,
dawn::TextureUsageBit usage = dawn::TextureUsageBit::OutputAttachment) {
dawn::TextureUsage usage = dawn::TextureUsage::OutputAttachment) {
dawn::TextureDescriptor descriptor;
descriptor.dimension = dimension;
descriptor.size.width = width;
@@ -488,10 +488,9 @@ 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::TextureUsageBit::OutputAttachment.
// include dawn::TextureUsage::OutputAttachment.
TEST_F(MultisampledRenderPassDescriptorValidationTest, ResolveTargetUsageNoOutputAttachment) {
constexpr dawn::TextureUsageBit kUsage =
dawn::TextureUsageBit::CopyDst | dawn::TextureUsageBit::CopySrc;
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);

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

@@ -66,8 +66,8 @@ void main() {
dawn::RenderPipeline pipeline = device.CreateRenderPipeline(&descriptor);
float data[4];
dawn::Buffer buffer = utils::CreateBufferFromData(device, data, 4 * sizeof(float),
dawn::BufferUsageBit::Uniform);
dawn::Buffer buffer =
utils::CreateBufferFromData(device, data, 4 * sizeof(float), dawn::BufferUsage::Uniform);
dawn::BindGroup bg1 =
utils::MakeBindGroup(device, bgls[0], {{0, buffer, 0, 4 * sizeof(float)}});

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

@@ -130,7 +130,7 @@ TEST_F(RenderPipelineValidationTest, SampleCountCompatibilityWithRenderPass) {
baseTextureDescriptor.arrayLayerCount = 1;
baseTextureDescriptor.mipLevelCount = 1;
baseTextureDescriptor.dimension = dawn::TextureDimension::e2D;
baseTextureDescriptor.usage = dawn::TextureUsageBit::OutputAttachment;
baseTextureDescriptor.usage = dawn::TextureUsage::OutputAttachment;
utils::ComboRenderPipelineDescriptor nonMultisampledPipelineDescriptor(device);
nonMultisampledPipelineDescriptor.sampleCount = 1;

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

@@ -32,7 +32,7 @@ class TextureValidationTest : public ValidationTest {
descriptor.sampleCount = kDefaultSampleCount;
descriptor.dimension = dawn::TextureDimension::e2D;
descriptor.format = kDefaultTextureFormat;
descriptor.usage = dawn::TextureUsageBit::OutputAttachment | dawn::TextureUsageBit::Sampled;
descriptor.usage = dawn::TextureUsage::OutputAttachment | dawn::TextureUsage::Sampled;
return descriptor;
}
@@ -239,7 +239,7 @@ TEST_F(TextureValidationTest, EncodeDestroySubmit) {
TEST_F(TextureValidationTest, NonRenderableAndOutputAttachment) {
dawn::TextureDescriptor descriptor;
descriptor.size = {1, 1, 1};
descriptor.usage = dawn::TextureUsageBit::OutputAttachment;
descriptor.usage = dawn::TextureUsage::OutputAttachment;
// Succeeds because RGBA8Unorm is renderable
descriptor.format = dawn::TextureFormat::RGBA8Unorm;
@@ -276,8 +276,8 @@ class CompressedTextureFormatsValidationTests : public TextureValidationTest {
dawn::TextureDescriptor CreateDefaultTextureDescriptor() {
dawn::TextureDescriptor descriptor =
TextureValidationTest::CreateDefaultTextureDescriptor();
descriptor.usage = dawn::TextureUsageBit::CopySrc | dawn::TextureUsageBit::CopyDst |
dawn::TextureUsageBit::Sampled;
descriptor.usage =
dawn::TextureUsage::CopySrc | dawn::TextureUsage::CopyDst | dawn::TextureUsage::Sampled;
return descriptor;
}
@@ -347,21 +347,21 @@ TEST_F(CompressedTextureFormatsValidationTests, TextureUsage) {
{
dawn::TextureDescriptor descriptor = CreateDefaultTextureDescriptor();
descriptor.format = format;
descriptor.usage = dawn::TextureUsageBit::OutputAttachment;
descriptor.usage = dawn::TextureUsage::OutputAttachment;
ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor));
}
{
dawn::TextureDescriptor descriptor = CreateDefaultTextureDescriptor();
descriptor.format = format;
descriptor.usage = dawn::TextureUsageBit::Storage;
descriptor.usage = dawn::TextureUsage::Storage;
ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor));
}
{
dawn::TextureDescriptor descriptor = CreateDefaultTextureDescriptor();
descriptor.format = format;
descriptor.usage = dawn::TextureUsageBit::Present;
descriptor.usage = dawn::TextureUsage::Present;
ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor));
}
}

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

@@ -40,7 +40,7 @@ dawn::Texture Create2DArrayTexture(dawn::Device& device,
descriptor.sampleCount = sampleCount;
descriptor.format = kDefaultTextureFormat;
descriptor.mipLevelCount = mipLevelCount;
descriptor.usage = dawn::TextureUsageBit::Sampled;
descriptor.usage = dawn::TextureUsage::Sampled;
return device.CreateTexture(&descriptor);
}

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

@@ -104,7 +104,7 @@ ValidationTest::DummyRenderPass::DummyRenderPass(const dawn::Device& device)
descriptor.sampleCount = 1;
descriptor.format = attachmentFormat;
descriptor.mipLevelCount = 1;
descriptor.usage = dawn::TextureUsageBit::OutputAttachment;
descriptor.usage = dawn::TextureUsage::OutputAttachment;
attachment = device.CreateTexture(&descriptor);
dawn::TextureView view = attachment.CreateDefaultView();

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

@@ -38,7 +38,7 @@ class VertexBufferValidationTest : public ValidationTest {
for (auto& buffer : buffers) {
dawn::BufferDescriptor descriptor;
descriptor.size = 256;
descriptor.usage = dawn::BufferUsageBit::Vertex;
descriptor.usage = dawn::BufferUsage::Vertex;
buffer = device.CreateBuffer(&descriptor);
}