Make unittests and fuzzers use webgpu.h
BUG=dawn:22
Change-Id: Iff5465ad7a9456f9c6b2ee380af748b3afc129b7
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/12741
Commit-Queue: Kai Ninomiya <kainino@chromium.org>
Reviewed-by: Austin Eng <enga@chromium.org>
Reviewed-by: Kai Ninomiya <kainino@chromium.org>
diff --git a/src/tests/unittests/wire/WireArgumentTests.cpp b/src/tests/unittests/wire/WireArgumentTests.cpp
index abb2bb60..f19c575 100644
--- a/src/tests/unittests/wire/WireArgumentTests.cpp
+++ b/src/tests/unittests/wire/WireArgumentTests.cpp
@@ -30,14 +30,14 @@
// Test that the wire is able to send numerical values
TEST_F(WireArgumentTests, ValueArgument) {
- DawnCommandEncoder encoder = dawnDeviceCreateCommandEncoder(device, nullptr);
- DawnComputePassEncoder pass = dawnCommandEncoderBeginComputePass(encoder, nullptr);
- dawnComputePassEncoderDispatch(pass, 1, 2, 3);
+ WGPUCommandEncoder encoder = wgpuDeviceCreateCommandEncoder(device, nullptr);
+ WGPUComputePassEncoder pass = wgpuCommandEncoderBeginComputePass(encoder, nullptr);
+ wgpuComputePassEncoderDispatch(pass, 1, 2, 3);
- DawnCommandEncoder apiEncoder = api.GetNewCommandEncoder();
+ WGPUCommandEncoder apiEncoder = api.GetNewCommandEncoder();
EXPECT_CALL(api, DeviceCreateCommandEncoder(apiDevice, nullptr)).WillOnce(Return(apiEncoder));
- DawnComputePassEncoder apiPass = api.GetNewComputePassEncoder();
+ WGPUComputePassEncoder apiPass = api.GetNewComputePassEncoder();
EXPECT_CALL(api, CommandEncoderBeginComputePass(apiEncoder, nullptr)).WillOnce(Return(apiPass));
EXPECT_CALL(api, ComputePassEncoderDispatch(apiPass, 1, 2, 3)).Times(1);
@@ -48,36 +48,36 @@
// Test that the wire is able to send arrays of numerical values
TEST_F(WireArgumentTests, ValueArrayArgument) {
// Create a bindgroup.
- DawnBindGroupLayoutDescriptor bglDescriptor;
+ WGPUBindGroupLayoutDescriptor bglDescriptor;
bglDescriptor.nextInChain = nullptr;
bglDescriptor.bindingCount = 0;
bglDescriptor.bindings = nullptr;
- DawnBindGroupLayout bgl = dawnDeviceCreateBindGroupLayout(device, &bglDescriptor);
- DawnBindGroupLayout apiBgl = api.GetNewBindGroupLayout();
+ WGPUBindGroupLayout bgl = wgpuDeviceCreateBindGroupLayout(device, &bglDescriptor);
+ WGPUBindGroupLayout apiBgl = api.GetNewBindGroupLayout();
EXPECT_CALL(api, DeviceCreateBindGroupLayout(apiDevice, _)).WillOnce(Return(apiBgl));
- DawnBindGroupDescriptor bindGroupDescriptor;
+ WGPUBindGroupDescriptor bindGroupDescriptor;
bindGroupDescriptor.nextInChain = nullptr;
bindGroupDescriptor.layout = bgl;
bindGroupDescriptor.bindingCount = 0;
bindGroupDescriptor.bindings = nullptr;
- DawnBindGroup bindGroup = dawnDeviceCreateBindGroup(device, &bindGroupDescriptor);
- DawnBindGroup apiBindGroup = api.GetNewBindGroup();
+ WGPUBindGroup bindGroup = wgpuDeviceCreateBindGroup(device, &bindGroupDescriptor);
+ WGPUBindGroup apiBindGroup = api.GetNewBindGroup();
EXPECT_CALL(api, DeviceCreateBindGroup(apiDevice, _)).WillOnce(Return(apiBindGroup));
// Use the bindgroup in SetBindGroup that takes an array of value offsets.
- DawnCommandEncoder encoder = dawnDeviceCreateCommandEncoder(device, nullptr);
- DawnComputePassEncoder pass = dawnCommandEncoderBeginComputePass(encoder, nullptr);
+ WGPUCommandEncoder encoder = wgpuDeviceCreateCommandEncoder(device, nullptr);
+ WGPUComputePassEncoder pass = wgpuCommandEncoderBeginComputePass(encoder, nullptr);
std::array<uint64_t, 4> testOffsets = {0, 42, 0xDEAD'BEEF'DEAD'BEEFu, 0xFFFF'FFFF'FFFF'FFFFu};
- dawnComputePassEncoderSetBindGroup(pass, 0, bindGroup, testOffsets.size(), testOffsets.data());
+ wgpuComputePassEncoderSetBindGroup(pass, 0, bindGroup, testOffsets.size(), testOffsets.data());
- DawnCommandEncoder apiEncoder = api.GetNewCommandEncoder();
+ WGPUCommandEncoder apiEncoder = api.GetNewCommandEncoder();
EXPECT_CALL(api, DeviceCreateCommandEncoder(apiDevice, nullptr)).WillOnce(Return(apiEncoder));
- DawnComputePassEncoder apiPass = api.GetNewComputePassEncoder();
+ WGPUComputePassEncoder apiPass = api.GetNewComputePassEncoder();
EXPECT_CALL(api, CommandEncoderBeginComputePass(apiEncoder, nullptr)).WillOnce(Return(apiPass));
EXPECT_CALL(api, ComputePassEncoderSetBindGroup(
@@ -97,76 +97,76 @@
// Test that the wire is able to send C strings
TEST_F(WireArgumentTests, CStringArgument) {
// Create shader module
- DawnShaderModuleDescriptor vertexDescriptor;
+ WGPUShaderModuleDescriptor vertexDescriptor;
vertexDescriptor.nextInChain = nullptr;
vertexDescriptor.codeSize = 0;
- DawnShaderModule vsModule = dawnDeviceCreateShaderModule(device, &vertexDescriptor);
- DawnShaderModule apiVsModule = api.GetNewShaderModule();
+ WGPUShaderModule vsModule = wgpuDeviceCreateShaderModule(device, &vertexDescriptor);
+ WGPUShaderModule apiVsModule = api.GetNewShaderModule();
EXPECT_CALL(api, DeviceCreateShaderModule(apiDevice, _)).WillOnce(Return(apiVsModule));
// Create the color state descriptor
- DawnBlendDescriptor blendDescriptor;
- blendDescriptor.operation = DAWN_BLEND_OPERATION_ADD;
- blendDescriptor.srcFactor = DAWN_BLEND_FACTOR_ONE;
- blendDescriptor.dstFactor = DAWN_BLEND_FACTOR_ONE;
- DawnColorStateDescriptor colorStateDescriptor;
+ WGPUBlendDescriptor blendDescriptor;
+ blendDescriptor.operation = WGPUBlendOperation_Add;
+ blendDescriptor.srcFactor = WGPUBlendFactor_One;
+ blendDescriptor.dstFactor = WGPUBlendFactor_One;
+ WGPUColorStateDescriptor colorStateDescriptor;
colorStateDescriptor.nextInChain = nullptr;
- colorStateDescriptor.format = DAWN_TEXTURE_FORMAT_RGBA8_UNORM;
+ colorStateDescriptor.format = WGPUTextureFormat_RGBA8Unorm;
colorStateDescriptor.alphaBlend = blendDescriptor;
colorStateDescriptor.colorBlend = blendDescriptor;
- colorStateDescriptor.writeMask = DAWN_COLOR_WRITE_MASK_ALL;
+ colorStateDescriptor.writeMask = WGPUColorWriteMask_All;
// Create the input state
- DawnVertexInputDescriptor vertexInput;
+ WGPUVertexInputDescriptor vertexInput;
vertexInput.nextInChain = nullptr;
- vertexInput.indexFormat = DAWN_INDEX_FORMAT_UINT32;
+ vertexInput.indexFormat = WGPUIndexFormat_Uint32;
vertexInput.bufferCount = 0;
vertexInput.buffers = nullptr;
// Create the rasterization state
- DawnRasterizationStateDescriptor rasterizationState;
+ WGPURasterizationStateDescriptor rasterizationState;
rasterizationState.nextInChain = nullptr;
- rasterizationState.frontFace = DAWN_FRONT_FACE_CCW;
- rasterizationState.cullMode = DAWN_CULL_MODE_NONE;
+ rasterizationState.frontFace = WGPUFrontFace_CCW;
+ rasterizationState.cullMode = WGPUCullMode_None;
rasterizationState.depthBias = 0;
rasterizationState.depthBiasSlopeScale = 0.0;
rasterizationState.depthBiasClamp = 0.0;
// Create the depth-stencil state
- DawnStencilStateFaceDescriptor stencilFace;
- stencilFace.compare = DAWN_COMPARE_FUNCTION_ALWAYS;
- stencilFace.failOp = DAWN_STENCIL_OPERATION_KEEP;
- stencilFace.depthFailOp = DAWN_STENCIL_OPERATION_KEEP;
- stencilFace.passOp = DAWN_STENCIL_OPERATION_KEEP;
+ WGPUStencilStateFaceDescriptor stencilFace;
+ stencilFace.compare = WGPUCompareFunction_Always;
+ stencilFace.failOp = WGPUStencilOperation_Keep;
+ stencilFace.depthFailOp = WGPUStencilOperation_Keep;
+ stencilFace.passOp = WGPUStencilOperation_Keep;
- DawnDepthStencilStateDescriptor depthStencilState;
+ WGPUDepthStencilStateDescriptor depthStencilState;
depthStencilState.nextInChain = nullptr;
- depthStencilState.format = DAWN_TEXTURE_FORMAT_DEPTH24_PLUS_STENCIL8;
+ depthStencilState.format = WGPUTextureFormat_Depth24PlusStencil8;
depthStencilState.depthWriteEnabled = false;
- depthStencilState.depthCompare = DAWN_COMPARE_FUNCTION_ALWAYS;
+ depthStencilState.depthCompare = WGPUCompareFunction_Always;
depthStencilState.stencilBack = stencilFace;
depthStencilState.stencilFront = stencilFace;
depthStencilState.stencilReadMask = 0xff;
depthStencilState.stencilWriteMask = 0xff;
// Create the pipeline layout
- DawnPipelineLayoutDescriptor layoutDescriptor;
+ WGPUPipelineLayoutDescriptor layoutDescriptor;
layoutDescriptor.nextInChain = nullptr;
layoutDescriptor.bindGroupLayoutCount = 0;
layoutDescriptor.bindGroupLayouts = nullptr;
- DawnPipelineLayout layout = dawnDeviceCreatePipelineLayout(device, &layoutDescriptor);
- DawnPipelineLayout apiLayout = api.GetNewPipelineLayout();
+ WGPUPipelineLayout layout = wgpuDeviceCreatePipelineLayout(device, &layoutDescriptor);
+ WGPUPipelineLayout apiLayout = api.GetNewPipelineLayout();
EXPECT_CALL(api, DeviceCreatePipelineLayout(apiDevice, _)).WillOnce(Return(apiLayout));
// Create pipeline
- DawnRenderPipelineDescriptor pipelineDescriptor;
+ WGPURenderPipelineDescriptor pipelineDescriptor;
pipelineDescriptor.nextInChain = nullptr;
pipelineDescriptor.vertexStage.nextInChain = nullptr;
pipelineDescriptor.vertexStage.module = vsModule;
pipelineDescriptor.vertexStage.entryPoint = "main";
- DawnProgrammableStageDescriptor fragmentStage;
+ WGPUProgrammableStageDescriptor fragmentStage;
fragmentStage.nextInChain = nullptr;
fragmentStage.module = vsModule;
fragmentStage.entryPoint = "main";
@@ -180,16 +180,16 @@
pipelineDescriptor.alphaToCoverageEnabled = false;
pipelineDescriptor.layout = layout;
pipelineDescriptor.vertexInput = &vertexInput;
- pipelineDescriptor.primitiveTopology = DAWN_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
+ pipelineDescriptor.primitiveTopology = WGPUPrimitiveTopology_TriangleList;
pipelineDescriptor.rasterizationState = &rasterizationState;
pipelineDescriptor.depthStencilState = &depthStencilState;
- dawnDeviceCreateRenderPipeline(device, &pipelineDescriptor);
+ wgpuDeviceCreateRenderPipeline(device, &pipelineDescriptor);
- DawnRenderPipeline apiDummyPipeline = api.GetNewRenderPipeline();
+ WGPURenderPipeline apiDummyPipeline = api.GetNewRenderPipeline();
EXPECT_CALL(api,
DeviceCreateRenderPipeline(
- apiDevice, MatchesLambda([](const DawnRenderPipelineDescriptor* desc) -> bool {
+ apiDevice, MatchesLambda([](const WGPURenderPipelineDescriptor* desc) -> bool {
return desc->vertexStage.entryPoint == std::string("main");
})))
.WillOnce(Return(apiDummyPipeline));
@@ -200,23 +200,23 @@
// Test that the wire is able to send objects as value arguments
TEST_F(WireArgumentTests, ObjectAsValueArgument) {
- DawnCommandEncoder cmdBufEncoder = dawnDeviceCreateCommandEncoder(device, nullptr);
- DawnCommandEncoder apiEncoder = api.GetNewCommandEncoder();
+ WGPUCommandEncoder cmdBufEncoder = wgpuDeviceCreateCommandEncoder(device, nullptr);
+ WGPUCommandEncoder apiEncoder = api.GetNewCommandEncoder();
EXPECT_CALL(api, DeviceCreateCommandEncoder(apiDevice, nullptr)).WillOnce(Return(apiEncoder));
- DawnBufferDescriptor descriptor;
+ WGPUBufferDescriptor descriptor;
descriptor.nextInChain = nullptr;
descriptor.size = 8;
descriptor.usage =
- static_cast<DawnBufferUsage>(DAWN_BUFFER_USAGE_COPY_SRC | DAWN_BUFFER_USAGE_COPY_DST);
+ static_cast<WGPUBufferUsage>(WGPUBufferUsage_CopySrc | WGPUBufferUsage_CopyDst);
- DawnBuffer buffer = dawnDeviceCreateBuffer(device, &descriptor);
- DawnBuffer apiBuffer = api.GetNewBuffer();
+ WGPUBuffer buffer = wgpuDeviceCreateBuffer(device, &descriptor);
+ WGPUBuffer apiBuffer = api.GetNewBuffer();
EXPECT_CALL(api, DeviceCreateBuffer(apiDevice, _))
.WillOnce(Return(apiBuffer))
.RetiresOnSaturation();
- dawnCommandEncoderCopyBufferToBuffer(cmdBufEncoder, buffer, 0, buffer, 4, 4);
+ wgpuCommandEncoderCopyBufferToBuffer(cmdBufEncoder, buffer, 0, buffer, 4, 4);
EXPECT_CALL(api, CommandEncoderCopyBufferToBuffer(apiEncoder, apiBuffer, 0, apiBuffer, 4, 4));
FlushClient();
@@ -224,17 +224,17 @@
// Test that the wire is able to send array of objects
TEST_F(WireArgumentTests, ObjectsAsPointerArgument) {
- DawnCommandBuffer cmdBufs[2];
- DawnCommandBuffer apiCmdBufs[2];
+ WGPUCommandBuffer cmdBufs[2];
+ WGPUCommandBuffer apiCmdBufs[2];
// Create two command buffers we need to use a GMock sequence otherwise the order of the
// CreateCommandEncoder might be swapped since they are equivalent in term of matchers
Sequence s;
for (int i = 0; i < 2; ++i) {
- DawnCommandEncoder cmdBufEncoder = dawnDeviceCreateCommandEncoder(device, nullptr);
- cmdBufs[i] = dawnCommandEncoderFinish(cmdBufEncoder, nullptr);
+ WGPUCommandEncoder cmdBufEncoder = wgpuDeviceCreateCommandEncoder(device, nullptr);
+ cmdBufs[i] = wgpuCommandEncoderFinish(cmdBufEncoder, nullptr);
- DawnCommandEncoder apiCmdBufEncoder = api.GetNewCommandEncoder();
+ WGPUCommandEncoder apiCmdBufEncoder = api.GetNewCommandEncoder();
EXPECT_CALL(api, DeviceCreateCommandEncoder(apiDevice, nullptr))
.InSequence(s)
.WillOnce(Return(apiCmdBufEncoder));
@@ -245,15 +245,15 @@
}
// Create queue
- DawnQueue queue = dawnDeviceCreateQueue(device);
- DawnQueue apiQueue = api.GetNewQueue();
+ WGPUQueue queue = wgpuDeviceCreateQueue(device);
+ WGPUQueue apiQueue = api.GetNewQueue();
EXPECT_CALL(api, DeviceCreateQueue(apiDevice)).WillOnce(Return(apiQueue));
// Submit command buffer and check we got a call with both API-side command buffers
- dawnQueueSubmit(queue, 2, cmdBufs);
+ wgpuQueueSubmit(queue, 2, cmdBufs);
EXPECT_CALL(
- api, QueueSubmit(apiQueue, 2, MatchesLambda([=](const DawnCommandBuffer* cmdBufs) -> bool {
+ api, QueueSubmit(apiQueue, 2, MatchesLambda([=](const WGPUCommandBuffer* cmdBufs) -> bool {
return cmdBufs[0] == apiCmdBufs[0] && cmdBufs[1] == apiCmdBufs[1];
})));
@@ -262,31 +262,31 @@
// Test that the wire is able to send structures that contain pure values (non-objects)
TEST_F(WireArgumentTests, StructureOfValuesArgument) {
- DawnSamplerDescriptor descriptor;
+ WGPUSamplerDescriptor descriptor;
descriptor.nextInChain = nullptr;
- descriptor.magFilter = DAWN_FILTER_MODE_LINEAR;
- descriptor.minFilter = DAWN_FILTER_MODE_NEAREST;
- descriptor.mipmapFilter = DAWN_FILTER_MODE_LINEAR;
- descriptor.addressModeU = DAWN_ADDRESS_MODE_CLAMP_TO_EDGE;
- descriptor.addressModeV = DAWN_ADDRESS_MODE_REPEAT;
- descriptor.addressModeW = DAWN_ADDRESS_MODE_MIRROR_REPEAT;
+ descriptor.magFilter = WGPUFilterMode_Linear;
+ descriptor.minFilter = WGPUFilterMode_Nearest;
+ descriptor.mipmapFilter = WGPUFilterMode_Linear;
+ descriptor.addressModeU = WGPUAddressMode_ClampToEdge;
+ descriptor.addressModeV = WGPUAddressMode_Repeat;
+ descriptor.addressModeW = WGPUAddressMode_MirrorRepeat;
descriptor.lodMinClamp = kLodMin;
descriptor.lodMaxClamp = kLodMax;
- descriptor.compare = DAWN_COMPARE_FUNCTION_NEVER;
+ descriptor.compare = WGPUCompareFunction_Never;
- dawnDeviceCreateSampler(device, &descriptor);
+ wgpuDeviceCreateSampler(device, &descriptor);
- DawnSampler apiDummySampler = api.GetNewSampler();
+ WGPUSampler apiDummySampler = api.GetNewSampler();
EXPECT_CALL(api, DeviceCreateSampler(
- apiDevice, MatchesLambda([](const DawnSamplerDescriptor* desc) -> bool {
+ apiDevice, MatchesLambda([](const WGPUSamplerDescriptor* desc) -> bool {
return desc->nextInChain == nullptr &&
- desc->magFilter == DAWN_FILTER_MODE_LINEAR &&
- desc->minFilter == DAWN_FILTER_MODE_NEAREST &&
- desc->mipmapFilter == DAWN_FILTER_MODE_LINEAR &&
- desc->addressModeU == DAWN_ADDRESS_MODE_CLAMP_TO_EDGE &&
- desc->addressModeV == DAWN_ADDRESS_MODE_REPEAT &&
- desc->addressModeW == DAWN_ADDRESS_MODE_MIRROR_REPEAT &&
- desc->compare == DAWN_COMPARE_FUNCTION_NEVER &&
+ desc->magFilter == WGPUFilterMode_Linear &&
+ desc->minFilter == WGPUFilterMode_Nearest &&
+ desc->mipmapFilter == WGPUFilterMode_Linear &&
+ desc->addressModeU == WGPUAddressMode_ClampToEdge &&
+ desc->addressModeV == WGPUAddressMode_Repeat &&
+ desc->addressModeW == WGPUAddressMode_MirrorRepeat &&
+ desc->compare == WGPUCompareFunction_Never &&
desc->lodMinClamp == kLodMin && desc->lodMaxClamp == kLodMax;
})))
.WillOnce(Return(apiDummySampler));
@@ -296,26 +296,26 @@
// Test that the wire is able to send structures that contain objects
TEST_F(WireArgumentTests, StructureOfObjectArrayArgument) {
- DawnBindGroupLayoutDescriptor bglDescriptor;
+ WGPUBindGroupLayoutDescriptor bglDescriptor;
bglDescriptor.nextInChain = nullptr;
bglDescriptor.bindingCount = 0;
bglDescriptor.bindings = nullptr;
- DawnBindGroupLayout bgl = dawnDeviceCreateBindGroupLayout(device, &bglDescriptor);
- DawnBindGroupLayout apiBgl = api.GetNewBindGroupLayout();
+ WGPUBindGroupLayout bgl = wgpuDeviceCreateBindGroupLayout(device, &bglDescriptor);
+ WGPUBindGroupLayout apiBgl = api.GetNewBindGroupLayout();
EXPECT_CALL(api, DeviceCreateBindGroupLayout(apiDevice, _)).WillOnce(Return(apiBgl));
- DawnPipelineLayoutDescriptor descriptor;
+ WGPUPipelineLayoutDescriptor descriptor;
descriptor.nextInChain = nullptr;
descriptor.bindGroupLayoutCount = 1;
descriptor.bindGroupLayouts = &bgl;
- dawnDeviceCreatePipelineLayout(device, &descriptor);
+ wgpuDeviceCreatePipelineLayout(device, &descriptor);
- DawnPipelineLayout apiDummyLayout = api.GetNewPipelineLayout();
+ WGPUPipelineLayout apiDummyLayout = api.GetNewPipelineLayout();
EXPECT_CALL(api, DeviceCreatePipelineLayout(
apiDevice,
- MatchesLambda([apiBgl](const DawnPipelineLayoutDescriptor* desc) -> bool {
+ MatchesLambda([apiBgl](const WGPUPipelineLayoutDescriptor* desc) -> bool {
return desc->nextInChain == nullptr &&
desc->bindGroupLayoutCount == 1 &&
desc->bindGroupLayouts[0] == apiBgl;
@@ -328,25 +328,25 @@
// Test that the wire is able to send structures that contain objects
TEST_F(WireArgumentTests, StructureOfStructureArrayArgument) {
static constexpr int NUM_BINDINGS = 3;
- DawnBindGroupLayoutBinding bindings[NUM_BINDINGS]{
- {0, DAWN_SHADER_STAGE_VERTEX, DAWN_BINDING_TYPE_SAMPLER, false, false,
- DAWN_TEXTURE_VIEW_DIMENSION_2D, DAWN_TEXTURE_COMPONENT_TYPE_FLOAT},
- {1, DAWN_SHADER_STAGE_VERTEX, DAWN_BINDING_TYPE_SAMPLED_TEXTURE, false, false,
- DAWN_TEXTURE_VIEW_DIMENSION_2D, DAWN_TEXTURE_COMPONENT_TYPE_FLOAT},
- {2, static_cast<DawnShaderStage>(DAWN_SHADER_STAGE_VERTEX | DAWN_SHADER_STAGE_FRAGMENT),
- DAWN_BINDING_TYPE_UNIFORM_BUFFER, false, false, DAWN_TEXTURE_VIEW_DIMENSION_2D,
- DAWN_TEXTURE_COMPONENT_TYPE_FLOAT},
+ WGPUBindGroupLayoutBinding bindings[NUM_BINDINGS]{
+ {0, WGPUShaderStage_Vertex, WGPUBindingType_Sampler, false, false,
+ WGPUTextureViewDimension_2D, WGPUTextureComponentType_Float},
+ {1, WGPUShaderStage_Vertex, WGPUBindingType_SampledTexture, false, false,
+ WGPUTextureViewDimension_2D, WGPUTextureComponentType_Float},
+ {2, static_cast<WGPUShaderStage>(WGPUShaderStage_Vertex | WGPUShaderStage_Fragment),
+ WGPUBindingType_UniformBuffer, false, false, WGPUTextureViewDimension_2D,
+ WGPUTextureComponentType_Float},
};
- DawnBindGroupLayoutDescriptor bglDescriptor;
+ WGPUBindGroupLayoutDescriptor bglDescriptor;
bglDescriptor.bindingCount = NUM_BINDINGS;
bglDescriptor.bindings = bindings;
- dawnDeviceCreateBindGroupLayout(device, &bglDescriptor);
- DawnBindGroupLayout apiBgl = api.GetNewBindGroupLayout();
+ wgpuDeviceCreateBindGroupLayout(device, &bglDescriptor);
+ WGPUBindGroupLayout apiBgl = api.GetNewBindGroupLayout();
EXPECT_CALL(
api,
DeviceCreateBindGroupLayout(
- apiDevice, MatchesLambda([bindings](const DawnBindGroupLayoutDescriptor* desc) -> bool {
+ apiDevice, MatchesLambda([bindings](const WGPUBindGroupLayoutDescriptor* desc) -> bool {
for (int i = 0; i < NUM_BINDINGS; ++i) {
const auto& a = desc->bindings[i];
const auto& b = bindings[i];
@@ -364,17 +364,17 @@
// Test passing nullptr instead of objects - array of objects version
TEST_F(WireArgumentTests, DISABLED_NullptrInArray) {
- DawnBindGroupLayout nullBGL = nullptr;
+ WGPUBindGroupLayout nullBGL = nullptr;
- DawnPipelineLayoutDescriptor descriptor;
+ WGPUPipelineLayoutDescriptor descriptor;
descriptor.nextInChain = nullptr;
descriptor.bindGroupLayoutCount = 1;
descriptor.bindGroupLayouts = &nullBGL;
- dawnDeviceCreatePipelineLayout(device, &descriptor);
+ wgpuDeviceCreatePipelineLayout(device, &descriptor);
EXPECT_CALL(api,
DeviceCreatePipelineLayout(
- apiDevice, MatchesLambda([](const DawnPipelineLayoutDescriptor* desc) -> bool {
+ apiDevice, MatchesLambda([](const WGPUPipelineLayoutDescriptor* desc) -> bool {
return desc->nextInChain == nullptr && desc->bindGroupLayoutCount == 1 &&
desc->bindGroupLayouts[0] == nullptr;
})))
diff --git a/src/tests/unittests/wire/WireBasicTests.cpp b/src/tests/unittests/wire/WireBasicTests.cpp
index 488c05e..e14a596 100644
--- a/src/tests/unittests/wire/WireBasicTests.cpp
+++ b/src/tests/unittests/wire/WireBasicTests.cpp
@@ -26,9 +26,9 @@
// One call gets forwarded correctly.
TEST_F(WireBasicTests, CallForwarded) {
- dawnDeviceCreateCommandEncoder(device, nullptr);
+ wgpuDeviceCreateCommandEncoder(device, nullptr);
- DawnCommandEncoder apiCmdBufEncoder = api.GetNewCommandEncoder();
+ WGPUCommandEncoder apiCmdBufEncoder = api.GetNewCommandEncoder();
EXPECT_CALL(api, DeviceCreateCommandEncoder(apiDevice, nullptr))
.WillOnce(Return(apiCmdBufEncoder));
@@ -37,14 +37,14 @@
// Test that calling methods on a new object works as expected.
TEST_F(WireBasicTests, CreateThenCall) {
- DawnCommandEncoder encoder = dawnDeviceCreateCommandEncoder(device, nullptr);
- dawnCommandEncoderFinish(encoder, nullptr);
+ WGPUCommandEncoder encoder = wgpuDeviceCreateCommandEncoder(device, nullptr);
+ wgpuCommandEncoderFinish(encoder, nullptr);
- DawnCommandEncoder apiCmdBufEncoder = api.GetNewCommandEncoder();
+ WGPUCommandEncoder apiCmdBufEncoder = api.GetNewCommandEncoder();
EXPECT_CALL(api, DeviceCreateCommandEncoder(apiDevice, nullptr))
.WillOnce(Return(apiCmdBufEncoder));
- DawnCommandBuffer apiCmdBuf = api.GetNewCommandBuffer();
+ WGPUCommandBuffer apiCmdBuf = api.GetNewCommandBuffer();
EXPECT_CALL(api, CommandEncoderFinish(apiCmdBufEncoder, nullptr)).WillOnce(Return(apiCmdBuf));
FlushClient();
@@ -52,12 +52,12 @@
// Test that client reference/release do not call the backend API.
TEST_F(WireBasicTests, RefCountKeptInClient) {
- DawnCommandEncoder encoder = dawnDeviceCreateCommandEncoder(device, nullptr);
+ WGPUCommandEncoder encoder = wgpuDeviceCreateCommandEncoder(device, nullptr);
- dawnCommandEncoderReference(encoder);
- dawnCommandEncoderRelease(encoder);
+ wgpuCommandEncoderReference(encoder);
+ wgpuCommandEncoderRelease(encoder);
- DawnCommandEncoder apiCmdBufEncoder = api.GetNewCommandEncoder();
+ WGPUCommandEncoder apiCmdBufEncoder = api.GetNewCommandEncoder();
EXPECT_CALL(api, DeviceCreateCommandEncoder(apiDevice, nullptr))
.WillOnce(Return(apiCmdBufEncoder));
@@ -66,11 +66,11 @@
// Test that client reference/release do not call the backend API.
TEST_F(WireBasicTests, ReleaseCalledOnRefCount0) {
- DawnCommandEncoder encoder = dawnDeviceCreateCommandEncoder(device, nullptr);
+ WGPUCommandEncoder encoder = wgpuDeviceCreateCommandEncoder(device, nullptr);
- dawnCommandEncoderRelease(encoder);
+ wgpuCommandEncoderRelease(encoder);
- DawnCommandEncoder apiCmdBufEncoder = api.GetNewCommandEncoder();
+ WGPUCommandEncoder apiCmdBufEncoder = api.GetNewCommandEncoder();
EXPECT_CALL(api, DeviceCreateCommandEncoder(apiDevice, nullptr))
.WillOnce(Return(apiCmdBufEncoder));
diff --git a/src/tests/unittests/wire/WireBufferMappingTests.cpp b/src/tests/unittests/wire/WireBufferMappingTests.cpp
index 7319a97..69b1062 100644
--- a/src/tests/unittests/wire/WireBufferMappingTests.cpp
+++ b/src/tests/unittests/wire/WireBufferMappingTests.cpp
@@ -23,14 +23,14 @@
class MockBufferMapReadCallback {
public:
MOCK_METHOD4(Call,
- void(DawnBufferMapAsyncStatus status,
+ void(WGPUBufferMapAsyncStatus status,
const uint32_t* ptr,
uint64_t dataLength,
void* userdata));
};
std::unique_ptr<StrictMock<MockBufferMapReadCallback>> mockBufferMapReadCallback;
- void ToMockBufferMapReadCallback(DawnBufferMapAsyncStatus status,
+ void ToMockBufferMapReadCallback(WGPUBufferMapAsyncStatus status,
const void* ptr,
uint64_t dataLength,
void* userdata) {
@@ -42,7 +42,7 @@
class MockBufferMapWriteCallback {
public:
MOCK_METHOD4(Call,
- void(DawnBufferMapAsyncStatus status,
+ void(WGPUBufferMapAsyncStatus status,
uint32_t* ptr,
uint64_t dataLength,
void* userdata));
@@ -50,7 +50,7 @@
std::unique_ptr<StrictMock<MockBufferMapWriteCallback>> mockBufferMapWriteCallback;
uint32_t* lastMapWritePointer = nullptr;
- void ToMockBufferMapWriteCallback(DawnBufferMapAsyncStatus status,
+ void ToMockBufferMapWriteCallback(WGPUBufferMapAsyncStatus status,
void* ptr,
uint64_t dataLength,
void* userdata) {
@@ -62,8 +62,8 @@
class MockBufferCreateMappedCallback {
public:
MOCK_METHOD5(Call,
- void(DawnBufferMapAsyncStatus status,
- DawnBuffer buffer,
+ void(WGPUBufferMapAsyncStatus status,
+ WGPUBuffer buffer,
uint32_t* ptr,
uint64_t dataLength,
void* userdata));
@@ -71,12 +71,12 @@
std::unique_ptr<StrictMock<MockBufferCreateMappedCallback>> mockCreateBufferMappedCallback;
uint32_t* lastCreateMappedPointer = nullptr;
- void ToMockCreateBufferMappedCallback(DawnBufferMapAsyncStatus status,
- DawnCreateBufferMappedResult result,
+ void ToMockCreateBufferMappedCallback(WGPUBufferMapAsyncStatus status,
+ WGPUCreateBufferMappedResult result,
void* userdata) {
// Assume the data is uint32_t to make writing matchers easier
lastCreateMappedPointer = static_cast<uint32_t*>(result.data);
- // Unpack DawnCreateBufferMappedResult to make writing matchers easier
+ // Unpack WGPUCreateBufferMappedResult to make writing matchers easier
mockCreateBufferMappedCallback->Call(status, result.buffer, lastCreateMappedPointer,
result.dataLength, userdata);
}
@@ -97,13 +97,13 @@
mockCreateBufferMappedCallback =
std::make_unique<StrictMock<MockBufferCreateMappedCallback>>();
- DawnBufferDescriptor descriptor;
+ WGPUBufferDescriptor descriptor;
descriptor.nextInChain = nullptr;
descriptor.label = nullptr;
descriptor.size = kBufferSize;
apiBuffer = api.GetNewBuffer();
- buffer = dawnDeviceCreateBuffer(device, &descriptor);
+ buffer = wgpuDeviceCreateBuffer(device, &descriptor);
EXPECT_CALL(api, DeviceCreateBuffer(apiDevice, _))
.WillOnce(Return(apiBuffer))
@@ -131,32 +131,32 @@
protected:
static constexpr uint64_t kBufferSize = sizeof(uint32_t);
// A successfully created buffer
- DawnBuffer buffer;
- DawnBuffer apiBuffer;
+ WGPUBuffer buffer;
+ WGPUBuffer apiBuffer;
};
// MapRead-specific tests
// Check mapping for reading a succesfully created buffer
TEST_F(WireBufferMappingTests, MappingForReadSuccessBuffer) {
- dawnBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr);
+ wgpuBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr);
uint32_t bufferContent = 31337;
EXPECT_CALL(api, OnBufferMapReadAsyncCallback(apiBuffer, _, _))
.WillOnce(InvokeWithoutArgs([&]() {
- api.CallMapReadCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, &bufferContent,
+ api.CallMapReadCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success, &bufferContent,
kBufferSize);
}));
FlushClient();
- EXPECT_CALL(*mockBufferMapReadCallback, Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS,
- Pointee(Eq(bufferContent)), kBufferSize, _))
+ EXPECT_CALL(*mockBufferMapReadCallback,
+ Call(WGPUBufferMapAsyncStatus_Success, Pointee(Eq(bufferContent)), kBufferSize, _))
.Times(1);
FlushServer();
- dawnBufferUnmap(buffer);
+ wgpuBufferUnmap(buffer);
EXPECT_CALL(api, BufferUnmap(apiBuffer)).Times(1);
FlushClient();
@@ -165,16 +165,16 @@
// Check that things work correctly when a validation error happens when mapping the buffer for
// reading
TEST_F(WireBufferMappingTests, ErrorWhileMappingForRead) {
- dawnBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr);
+ wgpuBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr);
EXPECT_CALL(api, OnBufferMapReadAsyncCallback(apiBuffer, _, _))
.WillOnce(InvokeWithoutArgs([&]() {
- api.CallMapReadCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, 0);
+ api.CallMapReadCallback(apiBuffer, WGPUBufferMapAsyncStatus_Error, nullptr, 0);
}));
FlushClient();
- EXPECT_CALL(*mockBufferMapReadCallback, Call(DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, 0, _))
+ EXPECT_CALL(*mockBufferMapReadCallback, Call(WGPUBufferMapAsyncStatus_Error, nullptr, 0, _))
.Times(1);
FlushServer();
@@ -183,19 +183,18 @@
// Check that the map read callback is called with UNKNOWN when the buffer is destroyed before the
// request is finished
TEST_F(WireBufferMappingTests, DestroyBeforeReadRequestEnd) {
- dawnBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr);
+ wgpuBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr);
// Return success
EXPECT_CALL(api, OnBufferMapReadAsyncCallback(apiBuffer, _, _))
.WillOnce(InvokeWithoutArgs([&]() {
- api.CallMapReadCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, nullptr, 0);
+ api.CallMapReadCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success, nullptr, 0);
}));
// Destroy before the client gets the success, so the callback is called with unknown.
- EXPECT_CALL(*mockBufferMapReadCallback,
- Call(DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, nullptr, 0, _))
+ EXPECT_CALL(*mockBufferMapReadCallback, Call(WGPUBufferMapAsyncStatus_Unknown, nullptr, 0, _))
.Times(1);
- dawnBufferRelease(buffer);
+ wgpuBufferRelease(buffer);
EXPECT_CALL(api, BufferRelease(apiBuffer));
FlushClient();
@@ -205,22 +204,21 @@
// Check the map read callback is called with UNKNOWN when the map request would have worked, but
// Unmap was called
TEST_F(WireBufferMappingTests, UnmapCalledTooEarlyForRead) {
- dawnBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr);
+ wgpuBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr);
uint32_t bufferContent = 31337;
EXPECT_CALL(api, OnBufferMapReadAsyncCallback(apiBuffer, _, _))
.WillOnce(InvokeWithoutArgs([&]() {
- api.CallMapReadCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, &bufferContent,
+ api.CallMapReadCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success, &bufferContent,
kBufferSize);
}));
FlushClient();
// Oh no! We are calling Unmap too early!
- EXPECT_CALL(*mockBufferMapReadCallback,
- Call(DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, nullptr, 0, _))
+ EXPECT_CALL(*mockBufferMapReadCallback, Call(WGPUBufferMapAsyncStatus_Unknown, nullptr, 0, _))
.Times(1);
- dawnBufferUnmap(buffer);
+ wgpuBufferUnmap(buffer);
// The callback shouldn't get called, even when the request succeeded on the server side
FlushServer();
@@ -229,34 +227,34 @@
// Check that an error map read callback gets nullptr while a buffer is already mapped
TEST_F(WireBufferMappingTests, MappingForReadingErrorWhileAlreadyMappedGetsNullptr) {
// Successful map
- dawnBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr);
+ wgpuBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr);
uint32_t bufferContent = 31337;
EXPECT_CALL(api, OnBufferMapReadAsyncCallback(apiBuffer, _, _))
.WillOnce(InvokeWithoutArgs([&]() {
- api.CallMapReadCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, &bufferContent,
+ api.CallMapReadCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success, &bufferContent,
kBufferSize);
}))
.RetiresOnSaturation();
FlushClient();
- EXPECT_CALL(*mockBufferMapReadCallback, Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS,
- Pointee(Eq(bufferContent)), kBufferSize, _))
+ EXPECT_CALL(*mockBufferMapReadCallback,
+ Call(WGPUBufferMapAsyncStatus_Success, Pointee(Eq(bufferContent)), kBufferSize, _))
.Times(1);
FlushServer();
// Map failure while the buffer is already mapped
- dawnBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr);
+ wgpuBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr);
EXPECT_CALL(api, OnBufferMapReadAsyncCallback(apiBuffer, _, _))
.WillOnce(InvokeWithoutArgs([&]() {
- api.CallMapReadCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, 0);
+ api.CallMapReadCallback(apiBuffer, WGPUBufferMapAsyncStatus_Error, nullptr, 0);
}));
FlushClient();
- EXPECT_CALL(*mockBufferMapReadCallback, Call(DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, 0, _))
+ EXPECT_CALL(*mockBufferMapReadCallback, Call(WGPUBufferMapAsyncStatus_Error, nullptr, 0, _))
.Times(1);
FlushServer();
@@ -264,20 +262,20 @@
// Test that the MapReadCallback isn't fired twice when unmap() is called inside the callback
TEST_F(WireBufferMappingTests, UnmapInsideMapReadCallback) {
- dawnBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr);
+ wgpuBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr);
uint32_t bufferContent = 31337;
EXPECT_CALL(api, OnBufferMapReadAsyncCallback(apiBuffer, _, _))
.WillOnce(InvokeWithoutArgs([&]() {
- api.CallMapReadCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, &bufferContent,
+ api.CallMapReadCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success, &bufferContent,
kBufferSize);
}));
FlushClient();
- EXPECT_CALL(*mockBufferMapReadCallback, Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS,
- Pointee(Eq(bufferContent)), kBufferSize, _))
- .WillOnce(InvokeWithoutArgs([&]() { dawnBufferUnmap(buffer); }));
+ EXPECT_CALL(*mockBufferMapReadCallback,
+ Call(WGPUBufferMapAsyncStatus_Success, Pointee(Eq(bufferContent)), kBufferSize, _))
+ .WillOnce(InvokeWithoutArgs([&]() { wgpuBufferUnmap(buffer); }));
FlushServer();
@@ -289,20 +287,20 @@
// Test that the MapReadCallback isn't fired twice the buffer external refcount reaches 0 in the
// callback
TEST_F(WireBufferMappingTests, DestroyInsideMapReadCallback) {
- dawnBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr);
+ wgpuBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr);
uint32_t bufferContent = 31337;
EXPECT_CALL(api, OnBufferMapReadAsyncCallback(apiBuffer, _, _))
.WillOnce(InvokeWithoutArgs([&]() {
- api.CallMapReadCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, &bufferContent,
+ api.CallMapReadCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success, &bufferContent,
kBufferSize);
}));
FlushClient();
- EXPECT_CALL(*mockBufferMapReadCallback, Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS,
- Pointee(Eq(bufferContent)), kBufferSize, _))
- .WillOnce(InvokeWithoutArgs([&]() { dawnBufferRelease(buffer); }));
+ EXPECT_CALL(*mockBufferMapReadCallback,
+ Call(WGPUBufferMapAsyncStatus_Success, Pointee(Eq(bufferContent)), kBufferSize, _))
+ .WillOnce(InvokeWithoutArgs([&]() { wgpuBufferRelease(buffer); }));
FlushServer();
@@ -315,7 +313,7 @@
// Check mapping for writing a succesfully created buffer
TEST_F(WireBufferMappingTests, MappingForWriteSuccessBuffer) {
- dawnBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
+ wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
uint32_t serverBufferContent = 31337;
uint32_t updatedContent = 4242;
@@ -323,7 +321,7 @@
EXPECT_CALL(api, OnBufferMapWriteAsyncCallback(apiBuffer, _, _))
.WillOnce(InvokeWithoutArgs([&]() {
- api.CallMapWriteCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS,
+ api.CallMapWriteCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success,
&serverBufferContent, kBufferSize);
}));
@@ -331,7 +329,7 @@
// The map write callback always gets a buffer full of zeroes.
EXPECT_CALL(*mockBufferMapWriteCallback,
- Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, Pointee(Eq(zero)), kBufferSize, _))
+ Call(WGPUBufferMapAsyncStatus_Success, Pointee(Eq(zero)), kBufferSize, _))
.Times(1);
FlushServer();
@@ -339,7 +337,7 @@
// Write something to the mapped pointer
*lastMapWritePointer = updatedContent;
- dawnBufferUnmap(buffer);
+ wgpuBufferUnmap(buffer);
EXPECT_CALL(api, BufferUnmap(apiBuffer)).Times(1);
FlushClient();
@@ -351,17 +349,16 @@
// Check that things work correctly when a validation error happens when mapping the buffer for
// writing
TEST_F(WireBufferMappingTests, ErrorWhileMappingForWrite) {
- dawnBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
+ wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
EXPECT_CALL(api, OnBufferMapWriteAsyncCallback(apiBuffer, _, _))
.WillOnce(InvokeWithoutArgs([&]() {
- api.CallMapWriteCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, 0);
+ api.CallMapWriteCallback(apiBuffer, WGPUBufferMapAsyncStatus_Error, nullptr, 0);
}));
FlushClient();
- EXPECT_CALL(*mockBufferMapWriteCallback,
- Call(DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, 0, _))
+ EXPECT_CALL(*mockBufferMapWriteCallback, Call(WGPUBufferMapAsyncStatus_Error, nullptr, 0, _))
.Times(1);
FlushServer();
@@ -370,19 +367,18 @@
// Check that the map write callback is called with UNKNOWN when the buffer is destroyed before the
// request is finished
TEST_F(WireBufferMappingTests, DestroyBeforeWriteRequestEnd) {
- dawnBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
+ wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
// Return success
EXPECT_CALL(api, OnBufferMapWriteAsyncCallback(apiBuffer, _, _))
.WillOnce(InvokeWithoutArgs([&]() {
- api.CallMapWriteCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, nullptr, 0);
+ api.CallMapWriteCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success, nullptr, 0);
}));
// Destroy before the client gets the success, so the callback is called with unknown.
- EXPECT_CALL(*mockBufferMapWriteCallback,
- Call(DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, nullptr, 0, _))
+ EXPECT_CALL(*mockBufferMapWriteCallback, Call(WGPUBufferMapAsyncStatus_Unknown, nullptr, 0, _))
.Times(1);
- dawnBufferRelease(buffer);
+ wgpuBufferRelease(buffer);
EXPECT_CALL(api, BufferRelease(apiBuffer));
FlushClient();
@@ -392,22 +388,21 @@
// Check the map read callback is called with UNKNOWN when the map request would have worked, but
// Unmap was called
TEST_F(WireBufferMappingTests, UnmapCalledTooEarlyForWrite) {
- dawnBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
+ wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
uint32_t bufferContent = 31337;
EXPECT_CALL(api, OnBufferMapWriteAsyncCallback(apiBuffer, _, _))
.WillOnce(InvokeWithoutArgs([&]() {
- api.CallMapWriteCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS,
- &bufferContent, kBufferSize);
+ api.CallMapWriteCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success, &bufferContent,
+ kBufferSize);
}));
FlushClient();
// Oh no! We are calling Unmap too early!
- EXPECT_CALL(*mockBufferMapWriteCallback,
- Call(DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, nullptr, 0, _))
+ EXPECT_CALL(*mockBufferMapWriteCallback, Call(WGPUBufferMapAsyncStatus_Unknown, nullptr, 0, _))
.Times(1);
- dawnBufferUnmap(buffer);
+ wgpuBufferUnmap(buffer);
// The callback shouldn't get called, even when the request succeeded on the server side
FlushServer();
@@ -416,36 +411,35 @@
// Check that an error map read callback gets nullptr while a buffer is already mapped
TEST_F(WireBufferMappingTests, MappingForWritingErrorWhileAlreadyMappedGetsNullptr) {
// Successful map
- dawnBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
+ wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
uint32_t bufferContent = 31337;
uint32_t zero = 0;
EXPECT_CALL(api, OnBufferMapWriteAsyncCallback(apiBuffer, _, _))
.WillOnce(InvokeWithoutArgs([&]() {
- api.CallMapWriteCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS,
- &bufferContent, kBufferSize);
+ api.CallMapWriteCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success, &bufferContent,
+ kBufferSize);
}))
.RetiresOnSaturation();
FlushClient();
EXPECT_CALL(*mockBufferMapWriteCallback,
- Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, Pointee(Eq(zero)), kBufferSize, _))
+ Call(WGPUBufferMapAsyncStatus_Success, Pointee(Eq(zero)), kBufferSize, _))
.Times(1);
FlushServer();
// Map failure while the buffer is already mapped
- dawnBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
+ wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
EXPECT_CALL(api, OnBufferMapWriteAsyncCallback(apiBuffer, _, _))
.WillOnce(InvokeWithoutArgs([&]() {
- api.CallMapWriteCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, 0);
+ api.CallMapWriteCallback(apiBuffer, WGPUBufferMapAsyncStatus_Error, nullptr, 0);
}));
FlushClient();
- EXPECT_CALL(*mockBufferMapWriteCallback,
- Call(DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, 0, _))
+ EXPECT_CALL(*mockBufferMapWriteCallback, Call(WGPUBufferMapAsyncStatus_Error, nullptr, 0, _))
.Times(1);
FlushServer();
@@ -453,21 +447,21 @@
// Test that the MapWriteCallback isn't fired twice when unmap() is called inside the callback
TEST_F(WireBufferMappingTests, UnmapInsideMapWriteCallback) {
- dawnBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
+ wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
uint32_t bufferContent = 31337;
uint32_t zero = 0;
EXPECT_CALL(api, OnBufferMapWriteAsyncCallback(apiBuffer, _, _))
.WillOnce(InvokeWithoutArgs([&]() {
- api.CallMapWriteCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS,
- &bufferContent, kBufferSize);
+ api.CallMapWriteCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success, &bufferContent,
+ kBufferSize);
}));
FlushClient();
EXPECT_CALL(*mockBufferMapWriteCallback,
- Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, Pointee(Eq(zero)), kBufferSize, _))
- .WillOnce(InvokeWithoutArgs([&]() { dawnBufferUnmap(buffer); }));
+ Call(WGPUBufferMapAsyncStatus_Success, Pointee(Eq(zero)), kBufferSize, _))
+ .WillOnce(InvokeWithoutArgs([&]() { wgpuBufferUnmap(buffer); }));
FlushServer();
@@ -479,21 +473,21 @@
// Test that the MapWriteCallback isn't fired twice the buffer external refcount reaches 0 in the
// callback
TEST_F(WireBufferMappingTests, DestroyInsideMapWriteCallback) {
- dawnBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
+ wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
uint32_t bufferContent = 31337;
uint32_t zero = 0;
EXPECT_CALL(api, OnBufferMapWriteAsyncCallback(apiBuffer, _, _))
.WillOnce(InvokeWithoutArgs([&]() {
- api.CallMapWriteCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS,
- &bufferContent, kBufferSize);
+ api.CallMapWriteCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success, &bufferContent,
+ kBufferSize);
}));
FlushClient();
EXPECT_CALL(*mockBufferMapWriteCallback,
- Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, Pointee(Eq(zero)), kBufferSize, _))
- .WillOnce(InvokeWithoutArgs([&]() { dawnBufferRelease(buffer); }));
+ Call(WGPUBufferMapAsyncStatus_Success, Pointee(Eq(zero)), kBufferSize, _))
+ .WillOnce(InvokeWithoutArgs([&]() { wgpuBufferRelease(buffer); }));
FlushServer();
@@ -504,19 +498,19 @@
// Test successful CreateBufferMapped
TEST_F(WireBufferMappingTests, CreateBufferMappedSuccess) {
- DawnBufferDescriptor descriptor;
+ WGPUBufferDescriptor descriptor;
descriptor.nextInChain = nullptr;
descriptor.label = nullptr;
descriptor.size = 4;
- DawnBuffer apiBuffer = api.GetNewBuffer();
- DawnCreateBufferMappedResult apiResult;
+ WGPUBuffer apiBuffer = api.GetNewBuffer();
+ WGPUCreateBufferMappedResult apiResult;
uint32_t apiBufferData = 1234;
apiResult.buffer = apiBuffer;
apiResult.data = reinterpret_cast<uint8_t*>(&apiBufferData);
apiResult.dataLength = 4;
- DawnCreateBufferMappedResult result = dawnDeviceCreateBufferMapped(device, &descriptor);
+ WGPUCreateBufferMappedResult result = wgpuDeviceCreateBufferMapped(device, &descriptor);
EXPECT_CALL(api, DeviceCreateBufferMapped(apiDevice, _))
.WillOnce(Return(apiResult))
@@ -524,7 +518,7 @@
FlushClient();
- dawnBufferUnmap(result.buffer);
+ wgpuBufferUnmap(result.buffer);
EXPECT_CALL(api, BufferUnmap(apiBuffer)).Times(1);
FlushClient();
@@ -532,19 +526,19 @@
// Test that releasing after CreateBufferMapped does not call Unmap
TEST_F(WireBufferMappingTests, ReleaseAfterCreateBufferMapped) {
- DawnBufferDescriptor descriptor;
+ WGPUBufferDescriptor descriptor;
descriptor.nextInChain = nullptr;
descriptor.label = nullptr;
descriptor.size = 4;
- DawnBuffer apiBuffer = api.GetNewBuffer();
- DawnCreateBufferMappedResult apiResult;
+ WGPUBuffer apiBuffer = api.GetNewBuffer();
+ WGPUCreateBufferMappedResult apiResult;
uint32_t apiBufferData = 1234;
apiResult.buffer = apiBuffer;
apiResult.data = reinterpret_cast<uint8_t*>(&apiBufferData);
apiResult.dataLength = 4;
- DawnCreateBufferMappedResult result = dawnDeviceCreateBufferMapped(device, &descriptor);
+ WGPUCreateBufferMappedResult result = wgpuDeviceCreateBufferMapped(device, &descriptor);
EXPECT_CALL(api, DeviceCreateBufferMapped(apiDevice, _))
.WillOnce(Return(apiResult))
@@ -552,7 +546,7 @@
FlushClient();
- dawnBufferRelease(result.buffer);
+ wgpuBufferRelease(result.buffer);
EXPECT_CALL(api, BufferRelease(apiBuffer)).Times(1);
FlushClient();
@@ -560,19 +554,19 @@
// Test that it is valid to map a buffer after CreateBufferMapped and Unmap
TEST_F(WireBufferMappingTests, CreateBufferMappedThenMapSuccess) {
- DawnBufferDescriptor descriptor;
+ WGPUBufferDescriptor descriptor;
descriptor.nextInChain = nullptr;
descriptor.label = nullptr;
descriptor.size = 4;
- DawnBuffer apiBuffer = api.GetNewBuffer();
- DawnCreateBufferMappedResult apiResult;
+ WGPUBuffer apiBuffer = api.GetNewBuffer();
+ WGPUCreateBufferMappedResult apiResult;
uint32_t apiBufferData = 9863;
apiResult.buffer = apiBuffer;
apiResult.data = reinterpret_cast<uint8_t*>(&apiBufferData);
apiResult.dataLength = 4;
- DawnCreateBufferMappedResult result = dawnDeviceCreateBufferMapped(device, &descriptor);
+ WGPUCreateBufferMappedResult result = wgpuDeviceCreateBufferMapped(device, &descriptor);
EXPECT_CALL(api, DeviceCreateBufferMapped(apiDevice, _))
.WillOnce(Return(apiResult))
@@ -580,24 +574,24 @@
FlushClient();
- dawnBufferUnmap(result.buffer);
+ wgpuBufferUnmap(result.buffer);
EXPECT_CALL(api, BufferUnmap(apiBuffer)).Times(1);
FlushClient();
- dawnBufferMapWriteAsync(result.buffer, ToMockBufferMapWriteCallback, nullptr);
+ wgpuBufferMapWriteAsync(result.buffer, ToMockBufferMapWriteCallback, nullptr);
uint32_t zero = 0;
EXPECT_CALL(api, OnBufferMapWriteAsyncCallback(apiBuffer, _, _))
.WillOnce(InvokeWithoutArgs([&]() {
- api.CallMapWriteCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS,
- &apiBufferData, kBufferSize);
+ api.CallMapWriteCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success, &apiBufferData,
+ kBufferSize);
}));
FlushClient();
EXPECT_CALL(*mockBufferMapWriteCallback,
- Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, Pointee(Eq(zero)), kBufferSize, _))
+ Call(WGPUBufferMapAsyncStatus_Success, Pointee(Eq(zero)), kBufferSize, _))
.Times(1);
FlushServer();
@@ -605,19 +599,19 @@
// Test that it is invalid to map a buffer after CreateBufferMapped before Unmap
TEST_F(WireBufferMappingTests, CreateBufferMappedThenMapFailure) {
- DawnBufferDescriptor descriptor;
+ WGPUBufferDescriptor descriptor;
descriptor.nextInChain = nullptr;
descriptor.label = nullptr;
descriptor.size = 4;
- DawnBuffer apiBuffer = api.GetNewBuffer();
- DawnCreateBufferMappedResult apiResult;
+ WGPUBuffer apiBuffer = api.GetNewBuffer();
+ WGPUCreateBufferMappedResult apiResult;
uint32_t apiBufferData = 9863;
apiResult.buffer = apiBuffer;
apiResult.data = reinterpret_cast<uint8_t*>(&apiBufferData);
apiResult.dataLength = 4;
- DawnCreateBufferMappedResult result = dawnDeviceCreateBufferMapped(device, &descriptor);
+ WGPUCreateBufferMappedResult result = wgpuDeviceCreateBufferMapped(device, &descriptor);
EXPECT_CALL(api, DeviceCreateBufferMapped(apiDevice, _))
.WillOnce(Return(apiResult))
@@ -625,22 +619,21 @@
FlushClient();
- dawnBufferMapWriteAsync(result.buffer, ToMockBufferMapWriteCallback, nullptr);
+ wgpuBufferMapWriteAsync(result.buffer, ToMockBufferMapWriteCallback, nullptr);
EXPECT_CALL(api, OnBufferMapWriteAsyncCallback(apiBuffer, _, _))
.WillOnce(InvokeWithoutArgs([&]() {
- api.CallMapWriteCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, 0);
+ api.CallMapWriteCallback(apiBuffer, WGPUBufferMapAsyncStatus_Error, nullptr, 0);
}));
FlushClient();
- EXPECT_CALL(*mockBufferMapWriteCallback,
- Call(DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, 0, _))
+ EXPECT_CALL(*mockBufferMapWriteCallback, Call(WGPUBufferMapAsyncStatus_Error, nullptr, 0, _))
.Times(1);
FlushServer();
- dawnBufferUnmap(result.buffer);
+ wgpuBufferUnmap(result.buffer);
EXPECT_CALL(api, BufferUnmap(apiBuffer)).Times(1);
FlushClient();
@@ -648,12 +641,12 @@
// Test successful CreateBufferMappedAsync
TEST_F(WireBufferMappingTests, CreateBufferMappedAsyncSuccess) {
- DawnBufferDescriptor descriptor;
+ WGPUBufferDescriptor descriptor;
descriptor.nextInChain = nullptr;
descriptor.label = nullptr;
descriptor.size = kBufferSize;
- DawnCreateBufferMappedResult apiResult;
+ WGPUCreateBufferMappedResult apiResult;
uint32_t serverBufferContent = 31337;
apiResult.buffer = apiBuffer;
apiResult.data = reinterpret_cast<uint8_t*>(&serverBufferContent);
@@ -662,7 +655,8 @@
uint32_t updatedContent = 4242;
uint32_t zero = 0;
- dawnDeviceCreateBufferMappedAsync(device, &descriptor, ToMockCreateBufferMappedCallback, nullptr);
+ wgpuDeviceCreateBufferMappedAsync(device, &descriptor, ToMockCreateBufferMappedCallback,
+ nullptr);
EXPECT_CALL(api, DeviceCreateBufferMapped(apiDevice, _))
.WillOnce(Return(apiResult))
@@ -670,10 +664,10 @@
FlushClient();
- DawnBuffer buffer;
+ WGPUBuffer buffer;
// The callback always gets a buffer full of zeroes.
EXPECT_CALL(*mockCreateBufferMappedCallback,
- Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, _, Pointee(Eq(zero)), kBufferSize, _))
+ Call(WGPUBufferMapAsyncStatus_Success, _, Pointee(Eq(zero)), kBufferSize, _))
.WillOnce(::testing::SaveArg<1>(&buffer));
FlushServer();
@@ -681,7 +675,7 @@
// Write something to the mapped pointer
*lastCreateMappedPointer = updatedContent;
- dawnBufferUnmap(buffer);
+ wgpuBufferUnmap(buffer);
EXPECT_CALL(api, BufferUnmap(apiBuffer)).Times(1);
FlushClient();
@@ -692,16 +686,17 @@
// Test CreateBufferMappedAsync with map error
TEST_F(WireBufferMappingTests, CreateBufferMappedAsyncMapError) {
- DawnBufferDescriptor descriptor;
+ WGPUBufferDescriptor descriptor;
descriptor.nextInChain = nullptr;
descriptor.label = nullptr;
- DawnCreateBufferMappedResult apiResult;
+ WGPUCreateBufferMappedResult apiResult;
apiResult.buffer = apiBuffer;
apiResult.data = nullptr; // error mapping
apiResult.dataLength = kBufferSize;
- dawnDeviceCreateBufferMappedAsync(device, &descriptor, ToMockCreateBufferMappedCallback, nullptr);
+ wgpuDeviceCreateBufferMappedAsync(device, &descriptor, ToMockCreateBufferMappedCallback,
+ nullptr);
EXPECT_CALL(api, DeviceCreateBufferMapped(apiDevice, _))
.WillOnce(Return(apiResult))
@@ -709,14 +704,14 @@
FlushClient();
- DawnBuffer buffer;
+ WGPUBuffer buffer;
EXPECT_CALL(*mockCreateBufferMappedCallback,
- Call(DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, _, nullptr, 0, _))
+ Call(WGPUBufferMapAsyncStatus_Error, _, nullptr, 0, _))
.WillOnce(::testing::SaveArg<1>(&buffer));
FlushServer();
- dawnBufferUnmap(buffer);
+ wgpuBufferUnmap(buffer);
EXPECT_CALL(api, BufferUnmap(apiBuffer)).Times(1);
FlushClient();
@@ -725,12 +720,12 @@
// Test that the CreateBufferMappedCallback isn't fired twice when unmap() is called inside the
// callback
TEST_F(WireBufferMappingTests, UnmapInsideCreateBufferMappedAsyncCallback) {
- DawnBufferDescriptor descriptor;
+ WGPUBufferDescriptor descriptor;
descriptor.nextInChain = nullptr;
descriptor.label = nullptr;
descriptor.size = kBufferSize;
- DawnCreateBufferMappedResult apiResult;
+ WGPUCreateBufferMappedResult apiResult;
uint32_t serverBufferContent = 31337;
apiResult.buffer = apiBuffer;
apiResult.data = reinterpret_cast<uint8_t*>(&serverBufferContent);
@@ -738,7 +733,8 @@
uint32_t zero = 0;
- dawnDeviceCreateBufferMappedAsync(device, &descriptor, ToMockCreateBufferMappedCallback, nullptr);
+ wgpuDeviceCreateBufferMappedAsync(device, &descriptor, ToMockCreateBufferMappedCallback,
+ nullptr);
EXPECT_CALL(api, DeviceCreateBufferMapped(apiDevice, _))
.WillOnce(Return(apiResult))
@@ -746,12 +742,12 @@
FlushClient();
- DawnBuffer buffer;
+ WGPUBuffer buffer;
// The callback always gets a buffer full of zeroes.
EXPECT_CALL(*mockCreateBufferMappedCallback,
- Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, _, Pointee(Eq(zero)), kBufferSize, _))
+ Call(WGPUBufferMapAsyncStatus_Success, _, Pointee(Eq(zero)), kBufferSize, _))
.WillOnce(DoAll(::testing::SaveArg<1>(&buffer),
- InvokeWithoutArgs([&]() { dawnBufferUnmap(buffer); })));
+ InvokeWithoutArgs([&]() { wgpuBufferUnmap(buffer); })));
FlushServer();
@@ -763,12 +759,12 @@
// Test that the CreateBufferMappedCallback isn't fired twice when the buffer is deleted inside
// the callback
TEST_F(WireBufferMappingTests, ReleaseInsideCreateBufferMappedAsyncCallback) {
- DawnBufferDescriptor descriptor;
+ WGPUBufferDescriptor descriptor;
descriptor.nextInChain = nullptr;
descriptor.label = nullptr;
descriptor.size = kBufferSize;
- DawnCreateBufferMappedResult apiResult;
+ WGPUCreateBufferMappedResult apiResult;
uint32_t serverBufferContent = 31337;
apiResult.buffer = apiBuffer;
apiResult.data = reinterpret_cast<uint8_t*>(&serverBufferContent);
@@ -776,7 +772,8 @@
uint32_t zero = 0;
- dawnDeviceCreateBufferMappedAsync(device, &descriptor, ToMockCreateBufferMappedCallback, nullptr);
+ wgpuDeviceCreateBufferMappedAsync(device, &descriptor, ToMockCreateBufferMappedCallback,
+ nullptr);
EXPECT_CALL(api, DeviceCreateBufferMapped(apiDevice, _))
.WillOnce(Return(apiResult))
@@ -784,12 +781,12 @@
FlushClient();
- DawnBuffer buffer;
+ WGPUBuffer buffer;
// The callback always gets a buffer full of zeroes.
EXPECT_CALL(*mockCreateBufferMappedCallback,
- Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, _, Pointee(Eq(zero)), kBufferSize, _))
+ Call(WGPUBufferMapAsyncStatus_Success, _, Pointee(Eq(zero)), kBufferSize, _))
.WillOnce(DoAll(::testing::SaveArg<1>(&buffer),
- InvokeWithoutArgs([&]() { dawnBufferRelease(buffer); })));
+ InvokeWithoutArgs([&]() { wgpuBufferRelease(buffer); })));
FlushServer();
@@ -801,12 +798,12 @@
// Test that the CreateBufferMappedCallback isn't fired twice when the buffer is destroyed inside
// the callback
TEST_F(WireBufferMappingTests, DestroyInsideCreateBufferMappedAsyncCallback) {
- DawnBufferDescriptor descriptor;
+ WGPUBufferDescriptor descriptor;
descriptor.nextInChain = nullptr;
descriptor.label = nullptr;
descriptor.size = kBufferSize;
- DawnCreateBufferMappedResult apiResult;
+ WGPUCreateBufferMappedResult apiResult;
uint32_t serverBufferContent = 31337;
apiResult.buffer = apiBuffer;
apiResult.data = reinterpret_cast<uint8_t*>(&serverBufferContent);
@@ -814,7 +811,8 @@
uint32_t zero = 0;
- dawnDeviceCreateBufferMappedAsync(device, &descriptor, ToMockCreateBufferMappedCallback, nullptr);
+ wgpuDeviceCreateBufferMappedAsync(device, &descriptor, ToMockCreateBufferMappedCallback,
+ nullptr);
EXPECT_CALL(api, DeviceCreateBufferMapped(apiDevice, _))
.WillOnce(Return(apiResult))
@@ -822,12 +820,12 @@
FlushClient();
- DawnBuffer buffer;
+ WGPUBuffer buffer;
// The callback always gets a buffer full of zeroes.
EXPECT_CALL(*mockCreateBufferMappedCallback,
- Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, _, Pointee(Eq(zero)), kBufferSize, _))
+ Call(WGPUBufferMapAsyncStatus_Success, _, Pointee(Eq(zero)), kBufferSize, _))
.WillOnce(DoAll(::testing::SaveArg<1>(&buffer),
- InvokeWithoutArgs([&]() { dawnBufferDestroy(buffer); })));
+ InvokeWithoutArgs([&]() { wgpuBufferDestroy(buffer); })));
FlushServer();
diff --git a/src/tests/unittests/wire/WireErrorCallbackTests.cpp b/src/tests/unittests/wire/WireErrorCallbackTests.cpp
index 55e0912..18436fc 100644
--- a/src/tests/unittests/wire/WireErrorCallbackTests.cpp
+++ b/src/tests/unittests/wire/WireErrorCallbackTests.cpp
@@ -22,21 +22,23 @@
// Mock classes to add expectations on the wire calling callbacks
class MockDeviceErrorCallback {
public:
- MOCK_METHOD3(Call, void(DawnErrorType type, const char* message, void* userdata));
+ MOCK_METHOD3(Call, void(WGPUErrorType type, const char* message, void* userdata));
};
std::unique_ptr<StrictMock<MockDeviceErrorCallback>> mockDeviceErrorCallback;
- void ToMockDeviceErrorCallback(DawnErrorType type, const char* message, void* userdata) {
+ void ToMockDeviceErrorCallback(WGPUErrorType type, const char* message, void* userdata) {
mockDeviceErrorCallback->Call(type, message, userdata);
}
class MockDevicePopErrorScopeCallback {
public:
- MOCK_METHOD3(Call, void(DawnErrorType type, const char* message, void* userdata));
+ MOCK_METHOD3(Call, void(WGPUErrorType type, const char* message, void* userdata));
};
std::unique_ptr<StrictMock<MockDevicePopErrorScopeCallback>> mockDevicePopErrorScopeCallback;
- void ToMockDevicePopErrorScopeCallback(DawnErrorType type, const char* message, void* userdata) {
+ void ToMockDevicePopErrorScopeCallback(WGPUErrorType type,
+ const char* message,
+ void* userdata) {
mockDevicePopErrorScopeCallback->Call(type, message, userdata);
}
@@ -72,38 +74,42 @@
// Test the return wire for device error callbacks
TEST_F(WireErrorCallbackTests, DeviceErrorCallback) {
- dawnDeviceSetUncapturedErrorCallback(device, ToMockDeviceErrorCallback, this);
+ wgpuDeviceSetUncapturedErrorCallback(device, ToMockDeviceErrorCallback, this);
// Setting the error callback should stay on the client side and do nothing
FlushClient();
// Calling the callback on the server side will result in the callback being called on the
// client side
- api.CallDeviceErrorCallback(apiDevice, DAWN_ERROR_TYPE_VALIDATION, "Some error message");
+ api.CallDeviceErrorCallback(apiDevice, WGPUErrorType_Validation, "Some error message");
- EXPECT_CALL(*mockDeviceErrorCallback, Call(DAWN_ERROR_TYPE_VALIDATION, StrEq("Some error message"), this)).Times(1);
+ EXPECT_CALL(*mockDeviceErrorCallback,
+ Call(WGPUErrorType_Validation, StrEq("Some error message"), this))
+ .Times(1);
FlushServer();
}
// Test the return wire for error scopes.
TEST_F(WireErrorCallbackTests, PushPopErrorScopeCallback) {
- dawnDevicePushErrorScope(device, DAWN_ERROR_FILTER_VALIDATION);
- EXPECT_CALL(api, DevicePushErrorScope(apiDevice, DAWN_ERROR_FILTER_VALIDATION)).Times(1);
+ wgpuDevicePushErrorScope(device, WGPUErrorFilter_Validation);
+ EXPECT_CALL(api, DevicePushErrorScope(apiDevice, WGPUErrorFilter_Validation)).Times(1);
FlushClient();
- dawnDevicePopErrorScope(device, ToMockDevicePopErrorScopeCallback, this);
+ wgpuDevicePopErrorScope(device, ToMockDevicePopErrorScopeCallback, this);
- DawnErrorCallback callback;
+ WGPUErrorCallback callback;
void* userdata;
EXPECT_CALL(api, OnDevicePopErrorScopeCallback(apiDevice, _, _))
.WillOnce(DoAll(SaveArg<1>(&callback), SaveArg<2>(&userdata), Return(true)));
FlushClient();
- callback(DAWN_ERROR_TYPE_VALIDATION, "Some error message", userdata);
- EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(DAWN_ERROR_TYPE_VALIDATION, StrEq("Some error message"), this)).Times(1);
+ callback(WGPUErrorType_Validation, "Some error message", userdata);
+ EXPECT_CALL(*mockDevicePopErrorScopeCallback,
+ Call(WGPUErrorType_Validation, StrEq("Some error message"), this))
+ .Times(1);
FlushServer();
}
@@ -112,17 +118,17 @@
TEST_F(WireErrorCallbackTests, PopErrorScopeCallbackOrdering) {
// Two error scopes are popped, and the first one returns first.
{
- dawnDevicePushErrorScope(device, DAWN_ERROR_FILTER_VALIDATION);
- dawnDevicePushErrorScope(device, DAWN_ERROR_FILTER_VALIDATION);
- EXPECT_CALL(api, DevicePushErrorScope(apiDevice, DAWN_ERROR_FILTER_VALIDATION)).Times(2);
+ wgpuDevicePushErrorScope(device, WGPUErrorFilter_Validation);
+ wgpuDevicePushErrorScope(device, WGPUErrorFilter_Validation);
+ EXPECT_CALL(api, DevicePushErrorScope(apiDevice, WGPUErrorFilter_Validation)).Times(2);
FlushClient();
- dawnDevicePopErrorScope(device, ToMockDevicePopErrorScopeCallback, this);
- dawnDevicePopErrorScope(device, ToMockDevicePopErrorScopeCallback, this + 1);
+ wgpuDevicePopErrorScope(device, ToMockDevicePopErrorScopeCallback, this);
+ wgpuDevicePopErrorScope(device, ToMockDevicePopErrorScopeCallback, this + 1);
- DawnErrorCallback callback1;
- DawnErrorCallback callback2;
+ WGPUErrorCallback callback1;
+ WGPUErrorCallback callback2;
void* userdata1;
void* userdata2;
EXPECT_CALL(api, OnDevicePopErrorScopeCallback(apiDevice, _, _))
@@ -131,32 +137,32 @@
FlushClient();
- callback1(DAWN_ERROR_TYPE_VALIDATION, "First error message", userdata1);
+ callback1(WGPUErrorType_Validation, "First error message", userdata1);
EXPECT_CALL(*mockDevicePopErrorScopeCallback,
- Call(DAWN_ERROR_TYPE_VALIDATION,
- StrEq("First error message"), this)).Times(1);
+ Call(WGPUErrorType_Validation, StrEq("First error message"), this))
+ .Times(1);
FlushServer();
- callback2(DAWN_ERROR_TYPE_VALIDATION, "Second error message", userdata2);
+ callback2(WGPUErrorType_Validation, "Second error message", userdata2);
EXPECT_CALL(*mockDevicePopErrorScopeCallback,
- Call(DAWN_ERROR_TYPE_VALIDATION,
- StrEq("Second error message"), this + 1)).Times(1);
+ Call(WGPUErrorType_Validation, StrEq("Second error message"), this + 1))
+ .Times(1);
FlushServer();
}
// Two error scopes are popped, and the second one returns first.
{
- dawnDevicePushErrorScope(device, DAWN_ERROR_FILTER_VALIDATION);
- dawnDevicePushErrorScope(device, DAWN_ERROR_FILTER_VALIDATION);
- EXPECT_CALL(api, DevicePushErrorScope(apiDevice, DAWN_ERROR_FILTER_VALIDATION)).Times(2);
+ wgpuDevicePushErrorScope(device, WGPUErrorFilter_Validation);
+ wgpuDevicePushErrorScope(device, WGPUErrorFilter_Validation);
+ EXPECT_CALL(api, DevicePushErrorScope(apiDevice, WGPUErrorFilter_Validation)).Times(2);
FlushClient();
- dawnDevicePopErrorScope(device, ToMockDevicePopErrorScopeCallback, this);
- dawnDevicePopErrorScope(device, ToMockDevicePopErrorScopeCallback, this + 1);
+ wgpuDevicePopErrorScope(device, ToMockDevicePopErrorScopeCallback, this);
+ wgpuDevicePopErrorScope(device, ToMockDevicePopErrorScopeCallback, this + 1);
- DawnErrorCallback callback1;
- DawnErrorCallback callback2;
+ WGPUErrorCallback callback1;
+ WGPUErrorCallback callback2;
void* userdata1;
void* userdata2;
EXPECT_CALL(api, OnDevicePopErrorScopeCallback(apiDevice, _, _))
@@ -165,61 +171,63 @@
FlushClient();
- callback2(DAWN_ERROR_TYPE_VALIDATION, "Second error message", userdata2);
+ callback2(WGPUErrorType_Validation, "Second error message", userdata2);
EXPECT_CALL(*mockDevicePopErrorScopeCallback,
- Call(DAWN_ERROR_TYPE_VALIDATION,
- StrEq("Second error message"), this + 1)).Times(1);
+ Call(WGPUErrorType_Validation, StrEq("Second error message"), this + 1))
+ .Times(1);
FlushServer();
- callback1(DAWN_ERROR_TYPE_VALIDATION, "First error message", userdata1);
+ callback1(WGPUErrorType_Validation, "First error message", userdata1);
EXPECT_CALL(*mockDevicePopErrorScopeCallback,
- Call(DAWN_ERROR_TYPE_VALIDATION,
- StrEq("First error message"), this)).Times(1);
+ Call(WGPUErrorType_Validation, StrEq("First error message"), this))
+ .Times(1);
FlushServer();
}
}
// Test the return wire for error scopes in flight when the device is destroyed.
TEST_F(WireErrorCallbackTests, PopErrorScopeDeviceDestroyed) {
- dawnDevicePushErrorScope(device, DAWN_ERROR_FILTER_VALIDATION);
- EXPECT_CALL(api, DevicePushErrorScope(apiDevice, DAWN_ERROR_FILTER_VALIDATION)).Times(1);
+ wgpuDevicePushErrorScope(device, WGPUErrorFilter_Validation);
+ EXPECT_CALL(api, DevicePushErrorScope(apiDevice, WGPUErrorFilter_Validation)).Times(1);
FlushClient();
- EXPECT_TRUE(dawnDevicePopErrorScope(device, ToMockDevicePopErrorScopeCallback, this));
+ EXPECT_TRUE(wgpuDevicePopErrorScope(device, ToMockDevicePopErrorScopeCallback, this));
EXPECT_CALL(api, OnDevicePopErrorScopeCallback(apiDevice, _, _))
.WillOnce(Return(true));
FlushClient();
// Incomplete callback called in Device destructor.
- EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(DAWN_ERROR_TYPE_UNKNOWN, ValidStringMessage(), this)).Times(1);
+ EXPECT_CALL(*mockDevicePopErrorScopeCallback,
+ Call(WGPUErrorType_Unknown, ValidStringMessage(), this))
+ .Times(1);
}
// Test that PopErrorScope returns false if there are no error scopes.
TEST_F(WireErrorCallbackTests, PopErrorScopeEmptyStack) {
// Empty stack
- {
- EXPECT_FALSE(dawnDevicePopErrorScope(device, ToMockDevicePopErrorScopeCallback, this));
- }
+ { EXPECT_FALSE(wgpuDevicePopErrorScope(device, ToMockDevicePopErrorScopeCallback, this)); }
// Pop too many times
{
- dawnDevicePushErrorScope(device, DAWN_ERROR_FILTER_VALIDATION);
- EXPECT_CALL(api, DevicePushErrorScope(apiDevice, DAWN_ERROR_FILTER_VALIDATION)).Times(1);
+ wgpuDevicePushErrorScope(device, WGPUErrorFilter_Validation);
+ EXPECT_CALL(api, DevicePushErrorScope(apiDevice, WGPUErrorFilter_Validation)).Times(1);
- EXPECT_TRUE(dawnDevicePopErrorScope(device, ToMockDevicePopErrorScopeCallback, this));
- EXPECT_FALSE(dawnDevicePopErrorScope(device, ToMockDevicePopErrorScopeCallback, this + 1));
+ EXPECT_TRUE(wgpuDevicePopErrorScope(device, ToMockDevicePopErrorScopeCallback, this));
+ EXPECT_FALSE(wgpuDevicePopErrorScope(device, ToMockDevicePopErrorScopeCallback, this + 1));
- DawnErrorCallback callback;
+ WGPUErrorCallback callback;
void* userdata;
EXPECT_CALL(api, OnDevicePopErrorScopeCallback(apiDevice, _, _))
.WillOnce(DoAll(SaveArg<1>(&callback), SaveArg<2>(&userdata), Return(true)));
FlushClient();
- callback(DAWN_ERROR_TYPE_VALIDATION, "Some error message", userdata);
- EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(DAWN_ERROR_TYPE_VALIDATION, StrEq("Some error message"), this)).Times(1);
+ callback(WGPUErrorType_Validation, "Some error message", userdata);
+ EXPECT_CALL(*mockDevicePopErrorScopeCallback,
+ Call(WGPUErrorType_Validation, StrEq("Some error message"), this))
+ .Times(1);
FlushServer();
}
diff --git a/src/tests/unittests/wire/WireFenceTests.cpp b/src/tests/unittests/wire/WireFenceTests.cpp
index a91593e..59d2b26 100644
--- a/src/tests/unittests/wire/WireFenceTests.cpp
+++ b/src/tests/unittests/wire/WireFenceTests.cpp
@@ -21,11 +21,11 @@
class MockFenceOnCompletionCallback {
public:
- MOCK_METHOD2(Call, void(DawnFenceCompletionStatus status, void* userdata));
+ MOCK_METHOD2(Call, void(WGPUFenceCompletionStatus status, void* userdata));
};
std::unique_ptr<StrictMock<MockFenceOnCompletionCallback>> mockFenceOnCompletionCallback;
- void ToMockFenceOnCompletionCallback(DawnFenceCompletionStatus status, void* userdata) {
+ void ToMockFenceOnCompletionCallback(WGPUFenceCompletionStatus status, void* userdata) {
mockFenceOnCompletionCallback->Call(status, userdata);
}
@@ -44,19 +44,19 @@
std::make_unique<StrictMock<MockFenceOnCompletionCallback>>();
{
- queue = dawnDeviceCreateQueue(device);
+ queue = wgpuDeviceCreateQueue(device);
apiQueue = api.GetNewQueue();
EXPECT_CALL(api, DeviceCreateQueue(apiDevice)).WillOnce(Return(apiQueue));
FlushClient();
}
{
- DawnFenceDescriptor descriptor;
+ WGPUFenceDescriptor descriptor;
descriptor.nextInChain = nullptr;
descriptor.label = nullptr;
descriptor.initialValue = 1;
apiFence = api.GetNewFence();
- fence = dawnQueueCreateFence(queue, &descriptor);
+ fence = wgpuQueueCreateFence(queue, &descriptor);
EXPECT_CALL(api, QueueCreateFence(apiQueue, _)).WillOnce(Return(apiFence));
FlushClient();
@@ -77,23 +77,23 @@
protected:
void DoQueueSignal(uint64_t signalValue) {
- dawnQueueSignal(queue, fence, signalValue);
+ wgpuQueueSignal(queue, fence, signalValue);
EXPECT_CALL(api, QueueSignal(apiQueue, apiFence, signalValue)).Times(1);
// This callback is generated to update the completedValue of the fence
// on the client
EXPECT_CALL(api, OnFenceOnCompletionCallback(apiFence, signalValue, _, _))
.WillOnce(InvokeWithoutArgs([&]() {
- api.CallFenceOnCompletionCallback(apiFence, DAWN_FENCE_COMPLETION_STATUS_SUCCESS);
+ api.CallFenceOnCompletionCallback(apiFence, WGPUFenceCompletionStatus_Success);
}));
}
// A successfully created fence
- DawnFence fence;
- DawnFence apiFence;
+ WGPUFence fence;
+ WGPUFence apiFence;
- DawnQueue queue;
- DawnQueue apiQueue;
+ WGPUQueue queue;
+ WGPUQueue apiQueue;
};
// Check that signaling a fence succeeds
@@ -107,19 +107,22 @@
// Errors should be generated when signaling a value less
// than or equal to the current signaled value
TEST_F(WireFenceTests, QueueSignalValidationError) {
- dawnQueueSignal(queue, fence, 0u); // Error
- EXPECT_CALL(api, DeviceInjectError(apiDevice, DAWN_ERROR_TYPE_VALIDATION, ValidStringMessage())).Times(1);
+ wgpuQueueSignal(queue, fence, 0u); // Error
+ EXPECT_CALL(api, DeviceInjectError(apiDevice, WGPUErrorType_Validation, ValidStringMessage()))
+ .Times(1);
FlushClient();
- dawnQueueSignal(queue, fence, 1u); // Error
- EXPECT_CALL(api, DeviceInjectError(apiDevice, DAWN_ERROR_TYPE_VALIDATION, ValidStringMessage())).Times(1);
+ wgpuQueueSignal(queue, fence, 1u); // Error
+ EXPECT_CALL(api, DeviceInjectError(apiDevice, WGPUErrorType_Validation, ValidStringMessage()))
+ .Times(1);
FlushClient();
DoQueueSignal(4u); // Success
FlushClient();
- dawnQueueSignal(queue, fence, 3u); // Error
- EXPECT_CALL(api, DeviceInjectError(apiDevice, DAWN_ERROR_TYPE_VALIDATION, ValidStringMessage())).Times(1);
+ wgpuQueueSignal(queue, fence, 3u); // Error
+ EXPECT_CALL(api, DeviceInjectError(apiDevice, WGPUErrorType_Validation, ValidStringMessage()))
+ .Times(1);
FlushClient();
}
@@ -127,16 +130,16 @@
TEST_F(WireFenceTests, OnCompletionImmediate) {
// Can call on value < (initial) signaled value happens immediately
{
- EXPECT_CALL(*mockFenceOnCompletionCallback, Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, _))
+ EXPECT_CALL(*mockFenceOnCompletionCallback, Call(WGPUFenceCompletionStatus_Success, _))
.Times(1);
- dawnFenceOnCompletion(fence, 0, ToMockFenceOnCompletionCallback, nullptr);
+ wgpuFenceOnCompletion(fence, 0, ToMockFenceOnCompletionCallback, nullptr);
}
// Can call on value == (initial) signaled value happens immediately
{
- EXPECT_CALL(*mockFenceOnCompletionCallback, Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, _))
+ EXPECT_CALL(*mockFenceOnCompletionCallback, Call(WGPUFenceCompletionStatus_Success, _))
.Times(1);
- dawnFenceOnCompletion(fence, 1, ToMockFenceOnCompletionCallback, nullptr);
+ wgpuFenceOnCompletion(fence, 1, ToMockFenceOnCompletionCallback, nullptr);
}
}
@@ -148,26 +151,22 @@
// Add callbacks in a non-monotonic order. They should still be called
// in order of increasing fence value.
// Add multiple callbacks for the same value.
- dawnFenceOnCompletion(fence, 6, ToMockFenceOnCompletionCallback, this + 0);
- dawnFenceOnCompletion(fence, 2, ToMockFenceOnCompletionCallback, this + 1);
- dawnFenceOnCompletion(fence, 3, ToMockFenceOnCompletionCallback, this + 2);
- dawnFenceOnCompletion(fence, 2, ToMockFenceOnCompletionCallback, this + 3);
+ wgpuFenceOnCompletion(fence, 6, ToMockFenceOnCompletionCallback, this + 0);
+ wgpuFenceOnCompletion(fence, 2, ToMockFenceOnCompletionCallback, this + 1);
+ wgpuFenceOnCompletion(fence, 3, ToMockFenceOnCompletionCallback, this + 2);
+ wgpuFenceOnCompletion(fence, 2, ToMockFenceOnCompletionCallback, this + 3);
Sequence s1, s2;
- EXPECT_CALL(*mockFenceOnCompletionCallback,
- Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, this + 1))
+ EXPECT_CALL(*mockFenceOnCompletionCallback, Call(WGPUFenceCompletionStatus_Success, this + 1))
.Times(1)
.InSequence(s1);
- EXPECT_CALL(*mockFenceOnCompletionCallback,
- Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, this + 3))
+ EXPECT_CALL(*mockFenceOnCompletionCallback, Call(WGPUFenceCompletionStatus_Success, this + 3))
.Times(1)
.InSequence(s2);
- EXPECT_CALL(*mockFenceOnCompletionCallback,
- Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, this + 2))
+ EXPECT_CALL(*mockFenceOnCompletionCallback, Call(WGPUFenceCompletionStatus_Success, this + 2))
.Times(1)
.InSequence(s1, s2);
- EXPECT_CALL(*mockFenceOnCompletionCallback,
- Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, this + 0))
+ EXPECT_CALL(*mockFenceOnCompletionCallback, Call(WGPUFenceCompletionStatus_Success, this + 0))
.Times(1)
.InSequence(s1, s2);
@@ -178,30 +177,31 @@
// Without any flushes, it is valid to wait on a value less than or equal to
// the last signaled value
TEST_F(WireFenceTests, OnCompletionSynchronousValidationSuccess) {
- dawnQueueSignal(queue, fence, 4u);
- dawnFenceOnCompletion(fence, 2u, ToMockFenceOnCompletionCallback, 0);
- dawnFenceOnCompletion(fence, 3u, ToMockFenceOnCompletionCallback, 0);
- dawnFenceOnCompletion(fence, 4u, ToMockFenceOnCompletionCallback, 0);
+ wgpuQueueSignal(queue, fence, 4u);
+ wgpuFenceOnCompletion(fence, 2u, ToMockFenceOnCompletionCallback, 0);
+ wgpuFenceOnCompletion(fence, 3u, ToMockFenceOnCompletionCallback, 0);
+ wgpuFenceOnCompletion(fence, 4u, ToMockFenceOnCompletionCallback, 0);
- EXPECT_CALL(*mockFenceOnCompletionCallback, Call(DAWN_FENCE_COMPLETION_STATUS_UNKNOWN, _))
+ EXPECT_CALL(*mockFenceOnCompletionCallback, Call(WGPUFenceCompletionStatus_Unknown, _))
.Times(3);
}
// Errors should be generated when waiting on a value greater
// than the last signaled value
TEST_F(WireFenceTests, OnCompletionValidationError) {
- EXPECT_CALL(*mockFenceOnCompletionCallback, Call(DAWN_FENCE_COMPLETION_STATUS_ERROR, this + 0))
+ EXPECT_CALL(*mockFenceOnCompletionCallback, Call(WGPUFenceCompletionStatus_Error, this + 0))
.Times(1);
- dawnFenceOnCompletion(fence, 2u, ToMockFenceOnCompletionCallback, this + 0);
+ wgpuFenceOnCompletion(fence, 2u, ToMockFenceOnCompletionCallback, this + 0);
- EXPECT_CALL(api, DeviceInjectError(apiDevice, DAWN_ERROR_TYPE_VALIDATION, ValidStringMessage())).Times(1);
+ EXPECT_CALL(api, DeviceInjectError(apiDevice, WGPUErrorType_Validation, ValidStringMessage()))
+ .Times(1);
FlushClient();
}
// Check that the fence completed value is initialized
TEST_F(WireFenceTests, GetCompletedValueInitialization) {
- EXPECT_EQ(dawnFenceGetCompletedValue(fence), 1u);
+ EXPECT_EQ(wgpuFenceGetCompletedValue(fence), 1u);
}
// Check that the fence completed value updates after signaling the fence
@@ -210,55 +210,57 @@
FlushClient();
FlushServer();
- EXPECT_EQ(dawnFenceGetCompletedValue(fence), 3u);
+ EXPECT_EQ(wgpuFenceGetCompletedValue(fence), 3u);
}
// Check that the fence completed value does not update without a flush
TEST_F(WireFenceTests, GetCompletedValueNoUpdate) {
- dawnQueueSignal(queue, fence, 3u);
- EXPECT_EQ(dawnFenceGetCompletedValue(fence), 1u);
+ wgpuQueueSignal(queue, fence, 3u);
+ EXPECT_EQ(wgpuFenceGetCompletedValue(fence), 1u);
}
// Check that the callback is called with UNKNOWN when the fence is destroyed
// before the completed value is updated
TEST_F(WireFenceTests, DestroyBeforeOnCompletionEnd) {
- dawnQueueSignal(queue, fence, 3u);
- dawnFenceOnCompletion(fence, 2u, ToMockFenceOnCompletionCallback, nullptr);
- EXPECT_CALL(*mockFenceOnCompletionCallback, Call(DAWN_FENCE_COMPLETION_STATUS_UNKNOWN, _))
+ wgpuQueueSignal(queue, fence, 3u);
+ wgpuFenceOnCompletion(fence, 2u, ToMockFenceOnCompletionCallback, nullptr);
+ EXPECT_CALL(*mockFenceOnCompletionCallback, Call(WGPUFenceCompletionStatus_Unknown, _))
.Times(1);
}
// Test that signaling a fence on a wrong queue is invalid
TEST_F(WireFenceTests, SignalWrongQueue) {
- DawnQueue queue2 = dawnDeviceCreateQueue(device);
- DawnQueue apiQueue2 = api.GetNewQueue();
+ WGPUQueue queue2 = wgpuDeviceCreateQueue(device);
+ WGPUQueue apiQueue2 = api.GetNewQueue();
EXPECT_CALL(api, DeviceCreateQueue(apiDevice)).WillOnce(Return(apiQueue2));
FlushClient();
- dawnQueueSignal(queue2, fence, 2u); // error
- EXPECT_CALL(api, DeviceInjectError(apiDevice, DAWN_ERROR_TYPE_VALIDATION, ValidStringMessage())).Times(1);
+ wgpuQueueSignal(queue2, fence, 2u); // error
+ EXPECT_CALL(api, DeviceInjectError(apiDevice, WGPUErrorType_Validation, ValidStringMessage()))
+ .Times(1);
FlushClient();
}
// Test that signaling a fence on a wrong queue does not update fence signaled value
TEST_F(WireFenceTests, SignalWrongQueueDoesNotUpdateValue) {
- DawnQueue queue2 = dawnDeviceCreateQueue(device);
- DawnQueue apiQueue2 = api.GetNewQueue();
+ WGPUQueue queue2 = wgpuDeviceCreateQueue(device);
+ WGPUQueue apiQueue2 = api.GetNewQueue();
EXPECT_CALL(api, DeviceCreateQueue(apiDevice)).WillOnce(Return(apiQueue2));
FlushClient();
- dawnQueueSignal(queue2, fence, 2u); // error
- EXPECT_CALL(api, DeviceInjectError(apiDevice, DAWN_ERROR_TYPE_VALIDATION, ValidStringMessage())).Times(1);
+ wgpuQueueSignal(queue2, fence, 2u); // error
+ EXPECT_CALL(api, DeviceInjectError(apiDevice, WGPUErrorType_Validation, ValidStringMessage()))
+ .Times(1);
FlushClient();
// Fence value should be unchanged.
FlushClient();
FlushServer();
- EXPECT_EQ(dawnFenceGetCompletedValue(fence), 1u);
+ EXPECT_EQ(wgpuFenceGetCompletedValue(fence), 1u);
// Signaling with 2 on the correct queue should succeed
DoQueueSignal(2u); // success
FlushClient();
FlushServer();
- EXPECT_EQ(dawnFenceGetCompletedValue(fence), 2u);
+ EXPECT_EQ(wgpuFenceGetCompletedValue(fence), 2u);
}
diff --git a/src/tests/unittests/wire/WireInjectTextureTests.cpp b/src/tests/unittests/wire/WireInjectTextureTests.cpp
index d5dea81..9e327cf 100644
--- a/src/tests/unittests/wire/WireInjectTextureTests.cpp
+++ b/src/tests/unittests/wire/WireInjectTextureTests.cpp
@@ -32,12 +32,12 @@
TEST_F(WireInjectTextureTests, CallAfterReserveInject) {
ReservedTexture reservation = GetWireClient()->ReserveTexture(device);
- DawnTexture apiTexture = api.GetNewTexture();
+ WGPUTexture apiTexture = api.GetNewTexture();
EXPECT_CALL(api, TextureReference(apiTexture));
ASSERT_TRUE(GetWireServer()->InjectTexture(apiTexture, reservation.id, reservation.generation));
- dawnTextureCreateView(reservation.texture, nullptr);
- DawnTextureView apiDummyView = api.GetNewTextureView();
+ wgpuTextureCreateView(reservation.texture, nullptr);
+ WGPUTextureView apiDummyView = api.GetNewTextureView();
EXPECT_CALL(api, TextureCreateView(apiTexture, nullptr)).WillOnce(Return(apiDummyView));
FlushClient();
}
@@ -55,7 +55,7 @@
TEST_F(WireInjectTextureTests, InjectExistingID) {
ReservedTexture reservation = GetWireClient()->ReserveTexture(device);
- DawnTexture apiTexture = api.GetNewTexture();
+ WGPUTexture apiTexture = api.GetNewTexture();
EXPECT_CALL(api, TextureReference(apiTexture));
ASSERT_TRUE(GetWireServer()->InjectTexture(apiTexture, reservation.id, reservation.generation));
@@ -69,12 +69,12 @@
ReservedTexture reservation = GetWireClient()->ReserveTexture(device);
// Injecting the texture adds a reference
- DawnTexture apiTexture = api.GetNewTexture();
+ WGPUTexture apiTexture = api.GetNewTexture();
EXPECT_CALL(api, TextureReference(apiTexture));
ASSERT_TRUE(GetWireServer()->InjectTexture(apiTexture, reservation.id, reservation.generation));
// Releasing the texture removes a single reference.
- dawnTextureRelease(reservation.texture);
+ wgpuTextureRelease(reservation.texture);
EXPECT_CALL(api, TextureRelease(apiTexture));
FlushClient();
diff --git a/src/tests/unittests/wire/WireMemoryTransferServiceTests.cpp b/src/tests/unittests/wire/WireMemoryTransferServiceTests.cpp
index b0f5f9d..a4f085b 100644
--- a/src/tests/unittests/wire/WireMemoryTransferServiceTests.cpp
+++ b/src/tests/unittests/wire/WireMemoryTransferServiceTests.cpp
@@ -26,14 +26,14 @@
class MockBufferMapReadCallback {
public:
MOCK_METHOD4(Call,
- void(DawnBufferMapAsyncStatus status,
+ void(WGPUBufferMapAsyncStatus status,
const uint32_t* ptr,
uint64_t dataLength,
void* userdata));
};
std::unique_ptr<StrictMock<MockBufferMapReadCallback>> mockBufferMapReadCallback;
- void ToMockBufferMapReadCallback(DawnBufferMapAsyncStatus status,
+ void ToMockBufferMapReadCallback(WGPUBufferMapAsyncStatus status,
const void* ptr,
uint64_t dataLength,
void* userdata) {
@@ -45,14 +45,14 @@
class MockBufferMapWriteCallback {
public:
MOCK_METHOD4(Call,
- void(DawnBufferMapAsyncStatus status,
+ void(WGPUBufferMapAsyncStatus status,
uint32_t* ptr,
uint64_t dataLength,
void* userdata));
};
std::unique_ptr<StrictMock<MockBufferMapWriteCallback>> mockBufferMapWriteCallback;
- void ToMockBufferMapWriteCallback(DawnBufferMapAsyncStatus status,
+ void ToMockBufferMapWriteCallback(WGPUBufferMapAsyncStatus status,
void* ptr,
uint64_t dataLength,
void* userdata) {
@@ -63,16 +63,16 @@
class MockBufferCreateMappedCallback {
public:
MOCK_METHOD5(Call,
- void(DawnBufferMapAsyncStatus status,
- DawnBuffer buffer,
+ void(WGPUBufferMapAsyncStatus status,
+ WGPUBuffer buffer,
uint32_t* ptr,
uint64_t dataLength,
void* userdata));
};
std::unique_ptr<StrictMock<MockBufferCreateMappedCallback>> mockCreateBufferMappedCallback;
- void ToMockCreateBufferMappedCallback(DawnBufferMapAsyncStatus status,
- DawnCreateBufferMappedResult result,
+ void ToMockCreateBufferMappedCallback(WGPUBufferMapAsyncStatus status,
+ WGPUCreateBufferMappedResult result,
void* userdata) {
// Assume the data is uint32_t to make writing matchers easier
mockCreateBufferMappedCallback->Call(status, result.buffer,
@@ -154,14 +154,14 @@
using ClientWriteHandle = client::MockMemoryTransferService::MockWriteHandle;
using ServerWriteHandle = server::MockMemoryTransferService::MockWriteHandle;
- std::pair<DawnBuffer, DawnBuffer> CreateBuffer() {
- DawnBufferDescriptor descriptor;
+ std::pair<WGPUBuffer, WGPUBuffer> CreateBuffer() {
+ WGPUBufferDescriptor descriptor;
descriptor.nextInChain = nullptr;
descriptor.label = nullptr;
descriptor.size = sizeof(mBufferContent);
- DawnBuffer apiBuffer = api.GetNewBuffer();
- DawnBuffer buffer = dawnDeviceCreateBuffer(device, &descriptor);
+ WGPUBuffer apiBuffer = api.GetNewBuffer();
+ WGPUBuffer buffer = wgpuDeviceCreateBuffer(device, &descriptor);
EXPECT_CALL(api, DeviceCreateBuffer(apiDevice, _))
.WillOnce(Return(apiBuffer))
@@ -170,20 +170,20 @@
return std::make_pair(apiBuffer, buffer);
}
- std::pair<DawnCreateBufferMappedResult, DawnCreateBufferMappedResult> CreateBufferMapped() {
- DawnBufferDescriptor descriptor;
+ std::pair<WGPUCreateBufferMappedResult, WGPUCreateBufferMappedResult> CreateBufferMapped() {
+ WGPUBufferDescriptor descriptor;
descriptor.nextInChain = nullptr;
descriptor.label = nullptr;
descriptor.size = sizeof(mBufferContent);
- DawnBuffer apiBuffer = api.GetNewBuffer();
+ WGPUBuffer apiBuffer = api.GetNewBuffer();
- DawnCreateBufferMappedResult apiResult;
+ WGPUCreateBufferMappedResult apiResult;
apiResult.buffer = apiBuffer;
apiResult.data = reinterpret_cast<uint8_t*>(&mMappedBufferContent);
apiResult.dataLength = sizeof(mMappedBufferContent);
- DawnCreateBufferMappedResult result = dawnDeviceCreateBufferMapped(device, &descriptor);
+ WGPUCreateBufferMappedResult result = wgpuDeviceCreateBufferMapped(device, &descriptor);
EXPECT_CALL(api, DeviceCreateBufferMapped(apiDevice, _))
.WillOnce(Return(apiResult))
@@ -192,18 +192,18 @@
return std::make_pair(apiResult, result);
}
- DawnCreateBufferMappedResult CreateBufferMappedAsync() {
- DawnBufferDescriptor descriptor;
+ WGPUCreateBufferMappedResult CreateBufferMappedAsync() {
+ WGPUBufferDescriptor descriptor;
descriptor.nextInChain = nullptr;
descriptor.label = nullptr;
descriptor.size = sizeof(mBufferContent);
- dawnDeviceCreateBufferMappedAsync(device, &descriptor, ToMockCreateBufferMappedCallback,
+ wgpuDeviceCreateBufferMappedAsync(device, &descriptor, ToMockCreateBufferMappedCallback,
nullptr);
- DawnBuffer apiBuffer = api.GetNewBuffer();
+ WGPUBuffer apiBuffer = api.GetNewBuffer();
- DawnCreateBufferMappedResult apiResult;
+ WGPUCreateBufferMappedResult apiResult;
apiResult.buffer = apiBuffer;
apiResult.data = reinterpret_cast<uint8_t*>(&mMappedBufferContent);
apiResult.dataLength = sizeof(mMappedBufferContent);
@@ -416,8 +416,8 @@
// Test successful MapRead.
TEST_F(WireMemoryTransferServiceTests, BufferMapReadSuccess) {
- DawnBuffer buffer;
- DawnBuffer apiBuffer;
+ WGPUBuffer buffer;
+ WGPUBuffer apiBuffer;
std::tie(apiBuffer, buffer) = CreateBuffer();
FlushClient();
@@ -425,7 +425,7 @@
ClientReadHandle* clientHandle = ExpectReadHandleCreation();
ExpectReadHandleSerialization(clientHandle);
- dawnBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr);
+ wgpuBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr);
// The server should deserialize the MapRead handle from the client and then serialize
// an initialization message.
@@ -435,7 +435,7 @@
// Mock a successful callback
EXPECT_CALL(api, OnBufferMapReadAsyncCallback(apiBuffer, _, _))
.WillOnce(InvokeWithoutArgs([&]() {
- api.CallMapReadCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, &mBufferContent,
+ api.CallMapReadCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success, &mBufferContent,
sizeof(mBufferContent));
}));
@@ -443,8 +443,7 @@
// The client receives a successful callback.
EXPECT_CALL(*mockBufferMapReadCallback,
- Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, &mBufferContent,
- sizeof(mBufferContent), _))
+ Call(WGPUBufferMapAsyncStatus_Success, &mBufferContent, sizeof(mBufferContent), _))
.Times(1);
// The client should receive the handle initialization message from the server.
@@ -454,7 +453,7 @@
// The handle is destroyed once the buffer is unmapped.
EXPECT_CALL(clientMemoryTransferService, OnReadHandleDestroy(clientHandle)).Times(1);
- dawnBufferUnmap(buffer);
+ wgpuBufferUnmap(buffer);
EXPECT_CALL(serverMemoryTransferService, OnReadHandleDestroy(serverHandle)).Times(1);
EXPECT_CALL(api, BufferUnmap(apiBuffer)).Times(1);
@@ -464,8 +463,8 @@
// Test unsuccessful MapRead.
TEST_F(WireMemoryTransferServiceTests, BufferMapReadError) {
- DawnBuffer buffer;
- DawnBuffer apiBuffer;
+ WGPUBuffer buffer;
+ WGPUBuffer apiBuffer;
std::tie(apiBuffer, buffer) = CreateBuffer();
FlushClient();
@@ -473,7 +472,7 @@
ClientReadHandle* clientHandle = ExpectReadHandleCreation();
ExpectReadHandleSerialization(clientHandle);
- dawnBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr);
+ wgpuBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr);
// The server should deserialize the ReadHandle from the client.
ServerReadHandle* serverHandle = ExpectServerReadHandleDeserialize();
@@ -481,7 +480,7 @@
// Mock a failed callback.
EXPECT_CALL(api, OnBufferMapReadAsyncCallback(apiBuffer, _, _))
.WillOnce(InvokeWithoutArgs([&]() {
- api.CallMapReadCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, 0);
+ api.CallMapReadCallback(apiBuffer, WGPUBufferMapAsyncStatus_Error, nullptr, 0);
}));
// Since the mapping failed, the handle is immediately destroyed.
@@ -490,7 +489,7 @@
FlushClient();
// The client receives an error callback.
- EXPECT_CALL(*mockBufferMapReadCallback, Call(DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, 0, _))
+ EXPECT_CALL(*mockBufferMapReadCallback, Call(WGPUBufferMapAsyncStatus_Error, nullptr, 0, _))
.Times(1);
// The client receives the map failure and destroys the handle.
@@ -498,7 +497,7 @@
FlushServer();
- dawnBufferUnmap(buffer);
+ wgpuBufferUnmap(buffer);
EXPECT_CALL(api, BufferUnmap(apiBuffer)).Times(1);
@@ -507,8 +506,8 @@
// Test MapRead ReadHandle creation failure.
TEST_F(WireMemoryTransferServiceTests, BufferMapReadHandleCreationFailure) {
- DawnBuffer buffer;
- DawnBuffer apiBuffer;
+ WGPUBuffer buffer;
+ WGPUBuffer apiBuffer;
std::tie(apiBuffer, buffer) = CreateBuffer();
FlushClient();
@@ -518,16 +517,16 @@
// Failed creation of a ReadHandle is a fatal failure and the client synchronously receives a
// DEVICE_LOST callback.
EXPECT_CALL(*mockBufferMapReadCallback,
- Call(DAWN_BUFFER_MAP_ASYNC_STATUS_DEVICE_LOST, nullptr, 0, _))
+ Call(WGPUBufferMapAsyncStatus_DeviceLost, nullptr, 0, _))
.Times(1);
- dawnBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr);
+ wgpuBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr);
}
// Test MapRead DeserializeReadHandle failure.
TEST_F(WireMemoryTransferServiceTests, BufferMapReadDeserializeReadHandleFailure) {
- DawnBuffer buffer;
- DawnBuffer apiBuffer;
+ WGPUBuffer buffer;
+ WGPUBuffer apiBuffer;
std::tie(apiBuffer, buffer) = CreateBuffer();
FlushClient();
@@ -535,7 +534,7 @@
ClientReadHandle* clientHandle = ExpectReadHandleCreation();
ExpectReadHandleSerialization(clientHandle);
- dawnBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr);
+ wgpuBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr);
// Mock a Deserialization failure.
MockServerReadHandleDeserializeFailure();
@@ -544,8 +543,7 @@
// The server received a fatal failure and the client callback was never returned.
// It is called when the wire is destructed.
- EXPECT_CALL(*mockBufferMapReadCallback,
- Call(DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, nullptr, 0, _))
+ EXPECT_CALL(*mockBufferMapReadCallback, Call(WGPUBufferMapAsyncStatus_Unknown, nullptr, 0, _))
.Times(1);
EXPECT_CALL(clientMemoryTransferService, OnReadHandleDestroy(clientHandle)).Times(1);
@@ -553,8 +551,8 @@
// Test MapRead DeserializeInitialData failure.
TEST_F(WireMemoryTransferServiceTests, BufferMapReadDeserializeInitialDataFailure) {
- DawnBuffer buffer;
- DawnBuffer apiBuffer;
+ WGPUBuffer buffer;
+ WGPUBuffer apiBuffer;
std::tie(apiBuffer, buffer) = CreateBuffer();
FlushClient();
@@ -562,7 +560,7 @@
ClientReadHandle* clientHandle = ExpectReadHandleCreation();
ExpectReadHandleSerialization(clientHandle);
- dawnBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr);
+ wgpuBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr);
// The server should deserialize the MapRead handle from the client and then serialize
// an initialization message.
@@ -572,7 +570,7 @@
// Mock a successful callback
EXPECT_CALL(api, OnBufferMapReadAsyncCallback(apiBuffer, _, _))
.WillOnce(InvokeWithoutArgs([&]() {
- api.CallMapReadCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, &mBufferContent,
+ api.CallMapReadCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success, &mBufferContent,
sizeof(mBufferContent));
}));
@@ -585,7 +583,7 @@
// Failed deserialization is a fatal failure and the client synchronously receives a
// DEVICE_LOST callback.
EXPECT_CALL(*mockBufferMapReadCallback,
- Call(DAWN_BUFFER_MAP_ASYNC_STATUS_DEVICE_LOST, nullptr, 0, _))
+ Call(WGPUBufferMapAsyncStatus_DeviceLost, nullptr, 0, _))
.Times(1);
// The handle will be destroyed since deserializing failed.
@@ -598,15 +596,15 @@
// Test successful MapWrite.
TEST_F(WireMemoryTransferServiceTests, BufferMapWriteSuccess) {
- DawnBuffer buffer;
- DawnBuffer apiBuffer;
+ WGPUBuffer buffer;
+ WGPUBuffer apiBuffer;
std::tie(apiBuffer, buffer) = CreateBuffer();
FlushClient();
ClientWriteHandle* clientHandle = ExpectWriteHandleCreation();
ExpectWriteHandleSerialization(clientHandle);
- dawnBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
+ wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
// The server should then deserialize the WriteHandle from the client.
ServerWriteHandle* serverHandle = ExpectServerWriteHandleDeserialization();
@@ -614,7 +612,7 @@
// Mock a successful callback.
EXPECT_CALL(api, OnBufferMapWriteAsyncCallback(apiBuffer, _, _))
.WillOnce(InvokeWithoutArgs([&]() {
- api.CallMapWriteCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS,
+ api.CallMapWriteCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success,
&mMappedBufferContent, sizeof(mMappedBufferContent));
}));
@@ -622,7 +620,7 @@
// The client receives a successful callback.
EXPECT_CALL(*mockBufferMapWriteCallback,
- Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, &mMappedBufferContent,
+ Call(WGPUBufferMapAsyncStatus_Success, &mMappedBufferContent,
sizeof(mMappedBufferContent), _))
.Times(1);
@@ -638,7 +636,7 @@
ExpectClientWriteHandleSerializeFlush(clientHandle);
EXPECT_CALL(clientMemoryTransferService, OnWriteHandleDestroy(clientHandle)).Times(1);
- dawnBufferUnmap(buffer);
+ wgpuBufferUnmap(buffer);
// The server deserializes the Flush message.
ExpectServerWriteHandleDeserializeFlush(serverHandle, mUpdatedBufferContent);
@@ -652,8 +650,8 @@
// Test unsuccessful MapWrite.
TEST_F(WireMemoryTransferServiceTests, BufferMapWriteError) {
- DawnBuffer buffer;
- DawnBuffer apiBuffer;
+ WGPUBuffer buffer;
+ WGPUBuffer apiBuffer;
std::tie(apiBuffer, buffer) = CreateBuffer();
FlushClient();
@@ -661,7 +659,7 @@
ClientWriteHandle* clientHandle = ExpectWriteHandleCreation();
ExpectWriteHandleSerialization(clientHandle);
- dawnBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
+ wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
// The server should then deserialize the WriteHandle from the client.
ServerWriteHandle* serverHandle = ExpectServerWriteHandleDeserialization();
@@ -669,7 +667,7 @@
// Mock an error callback.
EXPECT_CALL(api, OnBufferMapWriteAsyncCallback(apiBuffer, _, _))
.WillOnce(InvokeWithoutArgs([&]() {
- api.CallMapWriteCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, 0);
+ api.CallMapWriteCallback(apiBuffer, WGPUBufferMapAsyncStatus_Error, nullptr, 0);
}));
// Since the mapping fails, the handle is immediately destroyed because it won't be written.
@@ -678,8 +676,7 @@
FlushClient();
// The client receives an error callback.
- EXPECT_CALL(*mockBufferMapWriteCallback,
- Call(DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, 0, _))
+ EXPECT_CALL(*mockBufferMapWriteCallback, Call(WGPUBufferMapAsyncStatus_Error, nullptr, 0, _))
.Times(1);
// Client receives the map failure and destroys the handle.
@@ -687,7 +684,7 @@
FlushServer();
- dawnBufferUnmap(buffer);
+ wgpuBufferUnmap(buffer);
EXPECT_CALL(api, BufferUnmap(apiBuffer)).Times(1);
@@ -696,8 +693,8 @@
// Test MapRead WriteHandle creation failure.
TEST_F(WireMemoryTransferServiceTests, BufferMapWriteHandleCreationFailure) {
- DawnBuffer buffer;
- DawnBuffer apiBuffer;
+ WGPUBuffer buffer;
+ WGPUBuffer apiBuffer;
std::tie(apiBuffer, buffer) = CreateBuffer();
FlushClient();
@@ -707,16 +704,16 @@
// Failed creation of a WriteHandle is a fatal failure and the client synchronously receives a
// DEVICE_LOST callback.
EXPECT_CALL(*mockBufferMapWriteCallback,
- Call(DAWN_BUFFER_MAP_ASYNC_STATUS_DEVICE_LOST, nullptr, 0, _))
+ Call(WGPUBufferMapAsyncStatus_DeviceLost, nullptr, 0, _))
.Times(1);
- dawnBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
+ wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
}
// Test MapWrite DeserializeWriteHandle failure.
TEST_F(WireMemoryTransferServiceTests, BufferMapWriteDeserializeWriteHandleFailure) {
- DawnBuffer buffer;
- DawnBuffer apiBuffer;
+ WGPUBuffer buffer;
+ WGPUBuffer apiBuffer;
std::tie(apiBuffer, buffer) = CreateBuffer();
FlushClient();
@@ -724,7 +721,7 @@
ClientWriteHandle* clientHandle = ExpectWriteHandleCreation();
ExpectWriteHandleSerialization(clientHandle);
- dawnBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
+ wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
// Mock a deserialization failure.
MockServerWriteHandleDeserializeFailure();
@@ -733,8 +730,7 @@
// The server hit a fatal failure and never returned the callback. The client callback is
// called when the wire is destructed.
- EXPECT_CALL(*mockBufferMapWriteCallback,
- Call(DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, nullptr, 0, _))
+ EXPECT_CALL(*mockBufferMapWriteCallback, Call(WGPUBufferMapAsyncStatus_Unknown, nullptr, 0, _))
.Times(1);
EXPECT_CALL(clientMemoryTransferService, OnWriteHandleDestroy(clientHandle)).Times(1);
@@ -742,15 +738,15 @@
// Test MapWrite handle Open failure.
TEST_F(WireMemoryTransferServiceTests, BufferMapWriteHandleOpenFailure) {
- DawnBuffer buffer;
- DawnBuffer apiBuffer;
+ WGPUBuffer buffer;
+ WGPUBuffer apiBuffer;
std::tie(apiBuffer, buffer) = CreateBuffer();
FlushClient();
ClientWriteHandle* clientHandle = ExpectWriteHandleCreation();
ExpectWriteHandleSerialization(clientHandle);
- dawnBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
+ wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
// The server should then deserialize the WriteHandle from the client.
ServerWriteHandle* serverHandle = ExpectServerWriteHandleDeserialization();
@@ -758,7 +754,7 @@
// Mock a successful callback.
EXPECT_CALL(api, OnBufferMapWriteAsyncCallback(apiBuffer, _, _))
.WillOnce(InvokeWithoutArgs([&]() {
- api.CallMapWriteCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS,
+ api.CallMapWriteCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success,
&mMappedBufferContent, sizeof(mMappedBufferContent));
}));
@@ -770,7 +766,7 @@
// Failing to open a handle is a fatal failure and the client receives a DEVICE_LOST callback.
EXPECT_CALL(*mockBufferMapWriteCallback,
- Call(DAWN_BUFFER_MAP_ASYNC_STATUS_DEVICE_LOST, nullptr, 0, _))
+ Call(WGPUBufferMapAsyncStatus_DeviceLost, nullptr, 0, _))
.Times(1);
// Since opening the handle fails, it gets destroyed immediately.
@@ -783,15 +779,15 @@
// Test MapWrite DeserializeFlush failure.
TEST_F(WireMemoryTransferServiceTests, BufferMapWriteDeserializeFlushFailure) {
- DawnBuffer buffer;
- DawnBuffer apiBuffer;
+ WGPUBuffer buffer;
+ WGPUBuffer apiBuffer;
std::tie(apiBuffer, buffer) = CreateBuffer();
FlushClient();
ClientWriteHandle* clientHandle = ExpectWriteHandleCreation();
ExpectWriteHandleSerialization(clientHandle);
- dawnBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
+ wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
// The server should then deserialize the WriteHandle from the client.
ServerWriteHandle* serverHandle = ExpectServerWriteHandleDeserialization();
@@ -799,7 +795,7 @@
// Mock a successful callback.
EXPECT_CALL(api, OnBufferMapWriteAsyncCallback(apiBuffer, _, _))
.WillOnce(InvokeWithoutArgs([&]() {
- api.CallMapWriteCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS,
+ api.CallMapWriteCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success,
&mMappedBufferContent, sizeof(mMappedBufferContent));
}));
@@ -807,7 +803,7 @@
// The client receives a success callback.
EXPECT_CALL(*mockBufferMapWriteCallback,
- Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, &mMappedBufferContent,
+ Call(WGPUBufferMapAsyncStatus_Success, &mMappedBufferContent,
sizeof(mMappedBufferContent), _))
.Times(1);
@@ -823,7 +819,7 @@
ExpectClientWriteHandleSerializeFlush(clientHandle);
EXPECT_CALL(clientMemoryTransferService, OnWriteHandleDestroy(clientHandle)).Times(1);
- dawnBufferUnmap(buffer);
+ wgpuBufferUnmap(buffer);
// The server deserializes the Flush message. Mock a deserialization failure.
MockServerWriteHandleDeserializeFlushFailure(serverHandle);
@@ -839,7 +835,7 @@
ClientWriteHandle* clientHandle = ExpectWriteHandleCreation();
ExpectWriteHandleSerialization(clientHandle);
- DawnCreateBufferMappedResult apiResult = CreateBufferMappedAsync();
+ WGPUCreateBufferMappedResult apiResult = CreateBufferMappedAsync();
// The server should then deserialize the WriteHandle from the client.
ServerWriteHandle* serverHandle = ExpectServerWriteHandleDeserialization();
@@ -847,9 +843,9 @@
FlushClient();
// The client receives a success callback. Save the buffer argument so we can call Unmap.
- DawnBuffer buffer;
+ WGPUBuffer buffer;
EXPECT_CALL(*mockCreateBufferMappedCallback,
- Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, _, &mMappedBufferContent,
+ Call(WGPUBufferMapAsyncStatus_Success, _, &mMappedBufferContent,
sizeof(mMappedBufferContent), _))
.WillOnce(SaveArg<1>(&buffer));
@@ -866,7 +862,7 @@
ExpectClientWriteHandleSerializeFlush(clientHandle);
EXPECT_CALL(clientMemoryTransferService, OnWriteHandleDestroy(clientHandle)).Times(1);
- dawnBufferUnmap(buffer);
+ wgpuBufferUnmap(buffer);
// The server deserializes the Flush message.
ExpectServerWriteHandleDeserializeFlush(serverHandle, mUpdatedBufferContent);
@@ -883,7 +879,7 @@
// Mock a WriteHandle creation failure
MockWriteHandleCreationFailure();
- DawnBufferDescriptor descriptor;
+ WGPUBufferDescriptor descriptor;
descriptor.nextInChain = nullptr;
descriptor.label = nullptr;
descriptor.size = sizeof(mBufferContent);
@@ -891,10 +887,11 @@
// Failed creation of a WriteHandle is a fatal failure. The client synchronously receives
// a DEVICE_LOST callback.
EXPECT_CALL(*mockCreateBufferMappedCallback,
- Call(DAWN_BUFFER_MAP_ASYNC_STATUS_DEVICE_LOST, _, nullptr, 0, _))
+ Call(WGPUBufferMapAsyncStatus_DeviceLost, _, nullptr, 0, _))
.Times(1);
- dawnDeviceCreateBufferMappedAsync(device, &descriptor, ToMockCreateBufferMappedCallback, nullptr);
+ wgpuDeviceCreateBufferMappedAsync(device, &descriptor, ToMockCreateBufferMappedCallback,
+ nullptr);
}
// Test CreateBufferMappedAsync DeserializeWriteHandle failure.
@@ -903,7 +900,7 @@
ClientWriteHandle* clientHandle = ExpectWriteHandleCreation();
ExpectWriteHandleSerialization(clientHandle);
- DawnCreateBufferMappedResult apiResult = CreateBufferMappedAsync();
+ WGPUCreateBufferMappedResult apiResult = CreateBufferMappedAsync();
DAWN_UNUSED(apiResult);
// The server should then deserialize the WriteHandle from the client.
@@ -915,7 +912,7 @@
// The server hit a fatal failure and never returned the callback. It is called when the
// wire is destructed.
EXPECT_CALL(*mockCreateBufferMappedCallback,
- Call(DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, _, nullptr, 0, _))
+ Call(WGPUBufferMapAsyncStatus_Unknown, _, nullptr, 0, _))
.Times(1);
EXPECT_CALL(clientMemoryTransferService, OnWriteHandleDestroy(clientHandle)).Times(1);
@@ -927,7 +924,7 @@
ClientWriteHandle* clientHandle = ExpectWriteHandleCreation();
ExpectWriteHandleSerialization(clientHandle);
- DawnCreateBufferMappedResult apiResult = CreateBufferMappedAsync();
+ WGPUCreateBufferMappedResult apiResult = CreateBufferMappedAsync();
DAWN_UNUSED(apiResult);
// The server should then deserialize the WriteHandle from the client.
@@ -940,7 +937,7 @@
// Failing to open a handle is a fatal failure. The client receives a DEVICE_LOST callback.
EXPECT_CALL(*mockCreateBufferMappedCallback,
- Call(DAWN_BUFFER_MAP_ASYNC_STATUS_DEVICE_LOST, _, nullptr, 0, _))
+ Call(WGPUBufferMapAsyncStatus_DeviceLost, _, nullptr, 0, _))
.Times(1);
// Since opening the handle fails, it is destroyed immediately.
@@ -957,7 +954,7 @@
ClientWriteHandle* clientHandle = ExpectWriteHandleCreation();
ExpectWriteHandleSerialization(clientHandle);
- DawnCreateBufferMappedResult apiResult = CreateBufferMappedAsync();
+ WGPUCreateBufferMappedResult apiResult = CreateBufferMappedAsync();
DAWN_UNUSED(apiResult);
// The server should then deserialize the WriteHandle from the client.
@@ -966,9 +963,9 @@
FlushClient();
// The client receives a success callback. Save the buffer argument so we can call Unmap.
- DawnBuffer buffer;
+ WGPUBuffer buffer;
EXPECT_CALL(*mockCreateBufferMappedCallback,
- Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, _, &mMappedBufferContent,
+ Call(WGPUBufferMapAsyncStatus_Success, _, &mMappedBufferContent,
sizeof(mMappedBufferContent), _))
.WillOnce(SaveArg<1>(&buffer));
@@ -985,7 +982,7 @@
ExpectClientWriteHandleSerializeFlush(clientHandle);
EXPECT_CALL(clientMemoryTransferService, OnWriteHandleDestroy(clientHandle)).Times(1);
- dawnBufferUnmap(buffer);
+ wgpuBufferUnmap(buffer);
// The server deserializes the Flush message.
// Mock a deserialization failure.
@@ -1009,8 +1006,8 @@
// The server should then deserialize the WriteHandle from the client.
ServerWriteHandle* serverHandle = ExpectServerWriteHandleDeserialization();
- DawnCreateBufferMappedResult result;
- DawnCreateBufferMappedResult apiResult;
+ WGPUCreateBufferMappedResult result;
+ WGPUCreateBufferMappedResult apiResult;
std::tie(apiResult, result) = CreateBufferMapped();
FlushClient();
@@ -1021,7 +1018,7 @@
ExpectClientWriteHandleSerializeFlush(clientHandle);
EXPECT_CALL(clientMemoryTransferService, OnWriteHandleDestroy(clientHandle)).Times(1);
- dawnBufferUnmap(result.buffer);
+ wgpuBufferUnmap(result.buffer);
// The server deserializes the Flush message.
ExpectServerWriteHandleDeserializeFlush(serverHandle, mUpdatedBufferContent);
@@ -1038,12 +1035,12 @@
// Mock a WriteHandle creation failure
MockWriteHandleCreationFailure();
- DawnBufferDescriptor descriptor;
+ WGPUBufferDescriptor descriptor;
descriptor.nextInChain = nullptr;
descriptor.label = nullptr;
descriptor.size = sizeof(mBufferContent);
- DawnCreateBufferMappedResult result = dawnDeviceCreateBufferMapped(device, &descriptor);
+ WGPUCreateBufferMappedResult result = wgpuDeviceCreateBufferMapped(device, &descriptor);
// TODO(enga): Check that the client generated a context lost.
EXPECT_EQ(result.data, nullptr);
@@ -1063,8 +1060,8 @@
// The server should then deserialize the WriteHandle from the client.
MockServerWriteHandleDeserializeFailure();
- DawnCreateBufferMappedResult result;
- DawnCreateBufferMappedResult apiResult;
+ WGPUCreateBufferMappedResult result;
+ WGPUCreateBufferMappedResult apiResult;
std::tie(apiResult, result) = CreateBufferMapped();
FlushClient(false);
@@ -1084,12 +1081,12 @@
// Note: The handle is not serialized because sychronously opening it failed.
EXPECT_CALL(clientMemoryTransferService, OnWriteHandleDestroy(clientHandle)).Times(1);
- DawnBufferDescriptor descriptor;
+ WGPUBufferDescriptor descriptor;
descriptor.nextInChain = nullptr;
descriptor.label = nullptr;
descriptor.size = sizeof(mBufferContent);
- DawnCreateBufferMappedResult result = dawnDeviceCreateBufferMapped(device, &descriptor);
+ WGPUCreateBufferMappedResult result = wgpuDeviceCreateBufferMapped(device, &descriptor);
// TODO(enga): Check that the client generated a context lost.
EXPECT_EQ(result.data, nullptr);
@@ -1109,8 +1106,8 @@
// The server should then deserialize the WriteHandle from the client.
ServerWriteHandle* serverHandle = ExpectServerWriteHandleDeserialization();
- DawnCreateBufferMappedResult result;
- DawnCreateBufferMappedResult apiResult;
+ WGPUCreateBufferMappedResult result;
+ WGPUCreateBufferMappedResult apiResult;
std::tie(apiResult, result) = CreateBufferMapped();
FlushClient();
@@ -1121,7 +1118,7 @@
ExpectClientWriteHandleSerializeFlush(clientHandle);
EXPECT_CALL(clientMemoryTransferService, OnWriteHandleDestroy(clientHandle)).Times(1);
- dawnBufferUnmap(result.buffer);
+ wgpuBufferUnmap(result.buffer);
// The server deserializes the Flush message. Mock a deserialization failure.
MockServerWriteHandleDeserializeFlushFailure(serverHandle);
diff --git a/src/tests/unittests/wire/WireOptionalTests.cpp b/src/tests/unittests/wire/WireOptionalTests.cpp
index 9a38fd5..382985f 100644
--- a/src/tests/unittests/wire/WireOptionalTests.cpp
+++ b/src/tests/unittests/wire/WireOptionalTests.cpp
@@ -26,35 +26,35 @@
// Test passing nullptr instead of objects - object as value version
TEST_F(WireOptionalTests, OptionalObjectValue) {
- DawnBindGroupLayoutDescriptor bglDesc;
+ WGPUBindGroupLayoutDescriptor bglDesc;
bglDesc.nextInChain = nullptr;
bglDesc.label = nullptr;
bglDesc.bindingCount = 0;
- DawnBindGroupLayout bgl = dawnDeviceCreateBindGroupLayout(device, &bglDesc);
+ WGPUBindGroupLayout bgl = wgpuDeviceCreateBindGroupLayout(device, &bglDesc);
- DawnBindGroupLayout apiBindGroupLayout = api.GetNewBindGroupLayout();
+ WGPUBindGroupLayout apiBindGroupLayout = api.GetNewBindGroupLayout();
EXPECT_CALL(api, DeviceCreateBindGroupLayout(apiDevice, _))
.WillOnce(Return(apiBindGroupLayout));
// The `sampler`, `textureView` and `buffer` members of a binding are optional.
- DawnBindGroupBinding binding;
+ WGPUBindGroupBinding binding;
binding.binding = 0;
binding.sampler = nullptr;
binding.textureView = nullptr;
binding.buffer = nullptr;
- DawnBindGroupDescriptor bgDesc;
+ WGPUBindGroupDescriptor bgDesc;
bgDesc.nextInChain = nullptr;
bgDesc.label = nullptr;
bgDesc.layout = bgl;
bgDesc.bindingCount = 1;
bgDesc.bindings = &binding;
- dawnDeviceCreateBindGroup(device, &bgDesc);
+ wgpuDeviceCreateBindGroup(device, &bgDesc);
- DawnBindGroup apiDummyBindGroup = api.GetNewBindGroup();
+ WGPUBindGroup apiDummyBindGroup = api.GetNewBindGroup();
EXPECT_CALL(api, DeviceCreateBindGroup(
- apiDevice, MatchesLambda([](const DawnBindGroupDescriptor* desc) -> bool {
+ apiDevice, MatchesLambda([](const WGPUBindGroupDescriptor* desc) -> bool {
return desc->nextInChain == nullptr && desc->bindingCount == 1 &&
desc->bindings[0].binding == 0 &&
desc->bindings[0].sampler == nullptr &&
@@ -69,71 +69,71 @@
// Test that the wire is able to send optional pointers to structures
TEST_F(WireOptionalTests, OptionalStructPointer) {
// Create shader module
- DawnShaderModuleDescriptor vertexDescriptor;
+ WGPUShaderModuleDescriptor vertexDescriptor;
vertexDescriptor.nextInChain = nullptr;
vertexDescriptor.label = nullptr;
vertexDescriptor.codeSize = 0;
- DawnShaderModule vsModule = dawnDeviceCreateShaderModule(device, &vertexDescriptor);
- DawnShaderModule apiVsModule = api.GetNewShaderModule();
+ WGPUShaderModule vsModule = wgpuDeviceCreateShaderModule(device, &vertexDescriptor);
+ WGPUShaderModule apiVsModule = api.GetNewShaderModule();
EXPECT_CALL(api, DeviceCreateShaderModule(apiDevice, _)).WillOnce(Return(apiVsModule));
// Create the color state descriptor
- DawnBlendDescriptor blendDescriptor;
- blendDescriptor.operation = DAWN_BLEND_OPERATION_ADD;
- blendDescriptor.srcFactor = DAWN_BLEND_FACTOR_ONE;
- blendDescriptor.dstFactor = DAWN_BLEND_FACTOR_ONE;
- DawnColorStateDescriptor colorStateDescriptor;
+ WGPUBlendDescriptor blendDescriptor;
+ blendDescriptor.operation = WGPUBlendOperation_Add;
+ blendDescriptor.srcFactor = WGPUBlendFactor_One;
+ blendDescriptor.dstFactor = WGPUBlendFactor_One;
+ WGPUColorStateDescriptor colorStateDescriptor;
colorStateDescriptor.nextInChain = nullptr;
- colorStateDescriptor.format = DAWN_TEXTURE_FORMAT_RGBA8_UNORM;
+ colorStateDescriptor.format = WGPUTextureFormat_RGBA8Unorm;
colorStateDescriptor.alphaBlend = blendDescriptor;
colorStateDescriptor.colorBlend = blendDescriptor;
- colorStateDescriptor.writeMask = DAWN_COLOR_WRITE_MASK_ALL;
+ colorStateDescriptor.writeMask = WGPUColorWriteMask_All;
// Create the input state
- DawnVertexInputDescriptor vertexInput;
+ WGPUVertexInputDescriptor vertexInput;
vertexInput.nextInChain = nullptr;
- vertexInput.indexFormat = DAWN_INDEX_FORMAT_UINT32;
+ vertexInput.indexFormat = WGPUIndexFormat_Uint32;
vertexInput.bufferCount = 0;
vertexInput.buffers = nullptr;
// Create the rasterization state
- DawnRasterizationStateDescriptor rasterizationState;
+ WGPURasterizationStateDescriptor rasterizationState;
rasterizationState.nextInChain = nullptr;
- rasterizationState.frontFace = DAWN_FRONT_FACE_CCW;
- rasterizationState.cullMode = DAWN_CULL_MODE_NONE;
+ rasterizationState.frontFace = WGPUFrontFace_CCW;
+ rasterizationState.cullMode = WGPUCullMode_None;
rasterizationState.depthBias = 0;
rasterizationState.depthBiasSlopeScale = 0.0;
rasterizationState.depthBiasClamp = 0.0;
// Create the depth-stencil state
- DawnStencilStateFaceDescriptor stencilFace;
- stencilFace.compare = DAWN_COMPARE_FUNCTION_ALWAYS;
- stencilFace.failOp = DAWN_STENCIL_OPERATION_KEEP;
- stencilFace.depthFailOp = DAWN_STENCIL_OPERATION_KEEP;
- stencilFace.passOp = DAWN_STENCIL_OPERATION_KEEP;
+ WGPUStencilStateFaceDescriptor stencilFace;
+ stencilFace.compare = WGPUCompareFunction_Always;
+ stencilFace.failOp = WGPUStencilOperation_Keep;
+ stencilFace.depthFailOp = WGPUStencilOperation_Keep;
+ stencilFace.passOp = WGPUStencilOperation_Keep;
- DawnDepthStencilStateDescriptor depthStencilState;
+ WGPUDepthStencilStateDescriptor depthStencilState;
depthStencilState.nextInChain = nullptr;
- depthStencilState.format = DAWN_TEXTURE_FORMAT_DEPTH24_PLUS_STENCIL8;
+ depthStencilState.format = WGPUTextureFormat_Depth24PlusStencil8;
depthStencilState.depthWriteEnabled = false;
- depthStencilState.depthCompare = DAWN_COMPARE_FUNCTION_ALWAYS;
+ depthStencilState.depthCompare = WGPUCompareFunction_Always;
depthStencilState.stencilBack = stencilFace;
depthStencilState.stencilFront = stencilFace;
depthStencilState.stencilReadMask = 0xff;
depthStencilState.stencilWriteMask = 0xff;
// Create the pipeline layout
- DawnPipelineLayoutDescriptor layoutDescriptor;
+ WGPUPipelineLayoutDescriptor layoutDescriptor;
layoutDescriptor.nextInChain = nullptr;
layoutDescriptor.label = nullptr;
layoutDescriptor.bindGroupLayoutCount = 0;
layoutDescriptor.bindGroupLayouts = nullptr;
- DawnPipelineLayout layout = dawnDeviceCreatePipelineLayout(device, &layoutDescriptor);
- DawnPipelineLayout apiLayout = api.GetNewPipelineLayout();
+ WGPUPipelineLayout layout = wgpuDeviceCreatePipelineLayout(device, &layoutDescriptor);
+ WGPUPipelineLayout apiLayout = api.GetNewPipelineLayout();
EXPECT_CALL(api, DeviceCreatePipelineLayout(apiDevice, _)).WillOnce(Return(apiLayout));
// Create pipeline
- DawnRenderPipelineDescriptor pipelineDescriptor;
+ WGPURenderPipelineDescriptor pipelineDescriptor;
pipelineDescriptor.nextInChain = nullptr;
pipelineDescriptor.label = nullptr;
@@ -141,7 +141,7 @@
pipelineDescriptor.vertexStage.module = vsModule;
pipelineDescriptor.vertexStage.entryPoint = "main";
- DawnProgrammableStageDescriptor fragmentStage;
+ WGPUProgrammableStageDescriptor fragmentStage;
fragmentStage.nextInChain = nullptr;
fragmentStage.module = vsModule;
fragmentStage.entryPoint = "main";
@@ -155,36 +155,33 @@
pipelineDescriptor.alphaToCoverageEnabled = false;
pipelineDescriptor.layout = layout;
pipelineDescriptor.vertexInput = &vertexInput;
- pipelineDescriptor.primitiveTopology = DAWN_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
+ pipelineDescriptor.primitiveTopology = WGPUPrimitiveTopology_TriangleList;
pipelineDescriptor.rasterizationState = &rasterizationState;
// First case: depthStencilState is not null.
pipelineDescriptor.depthStencilState = &depthStencilState;
- dawnDeviceCreateRenderPipeline(device, &pipelineDescriptor);
+ wgpuDeviceCreateRenderPipeline(device, &pipelineDescriptor);
- DawnRenderPipeline apiDummyPipeline = api.GetNewRenderPipeline();
+ WGPURenderPipeline apiDummyPipeline = api.GetNewRenderPipeline();
EXPECT_CALL(
api,
DeviceCreateRenderPipeline(
- apiDevice, MatchesLambda([](const DawnRenderPipelineDescriptor* desc) -> bool {
+ apiDevice, MatchesLambda([](const WGPURenderPipelineDescriptor* desc) -> bool {
return desc->depthStencilState != nullptr &&
desc->depthStencilState->nextInChain == nullptr &&
desc->depthStencilState->depthWriteEnabled == false &&
- desc->depthStencilState->depthCompare == DAWN_COMPARE_FUNCTION_ALWAYS &&
- desc->depthStencilState->stencilBack.compare ==
- DAWN_COMPARE_FUNCTION_ALWAYS &&
- desc->depthStencilState->stencilBack.failOp == DAWN_STENCIL_OPERATION_KEEP &&
+ desc->depthStencilState->depthCompare == WGPUCompareFunction_Always &&
+ desc->depthStencilState->stencilBack.compare == WGPUCompareFunction_Always &&
+ desc->depthStencilState->stencilBack.failOp == WGPUStencilOperation_Keep &&
desc->depthStencilState->stencilBack.depthFailOp ==
- DAWN_STENCIL_OPERATION_KEEP &&
- desc->depthStencilState->stencilBack.passOp == DAWN_STENCIL_OPERATION_KEEP &&
+ WGPUStencilOperation_Keep &&
+ desc->depthStencilState->stencilBack.passOp == WGPUStencilOperation_Keep &&
desc->depthStencilState->stencilFront.compare ==
- DAWN_COMPARE_FUNCTION_ALWAYS &&
- desc->depthStencilState->stencilFront.failOp ==
- DAWN_STENCIL_OPERATION_KEEP &&
+ WGPUCompareFunction_Always &&
+ desc->depthStencilState->stencilFront.failOp == WGPUStencilOperation_Keep &&
desc->depthStencilState->stencilFront.depthFailOp ==
- DAWN_STENCIL_OPERATION_KEEP &&
- desc->depthStencilState->stencilFront.passOp ==
- DAWN_STENCIL_OPERATION_KEEP &&
+ WGPUStencilOperation_Keep &&
+ desc->depthStencilState->stencilFront.passOp == WGPUStencilOperation_Keep &&
desc->depthStencilState->stencilReadMask == 0xff &&
desc->depthStencilState->stencilWriteMask == 0xff;
})))
@@ -194,10 +191,10 @@
// Second case: depthStencilState is null.
pipelineDescriptor.depthStencilState = nullptr;
- dawnDeviceCreateRenderPipeline(device, &pipelineDescriptor);
+ wgpuDeviceCreateRenderPipeline(device, &pipelineDescriptor);
EXPECT_CALL(api,
DeviceCreateRenderPipeline(
- apiDevice, MatchesLambda([](const DawnRenderPipelineDescriptor* desc) -> bool {
+ apiDevice, MatchesLambda([](const WGPURenderPipelineDescriptor* desc) -> bool {
return desc->depthStencilState == nullptr;
})))
.WillOnce(Return(apiDummyPipeline));
diff --git a/src/tests/unittests/wire/WireTest.cpp b/src/tests/unittests/wire/WireTest.cpp
index 2c74df7..d48c085 100644
--- a/src/tests/unittests/wire/WireTest.cpp
+++ b/src/tests/unittests/wire/WireTest.cpp
@@ -38,7 +38,7 @@
void WireTest::SetUp() {
DawnProcTable mockProcs;
- DawnDevice mockDevice;
+ WGPUDevice mockDevice;
api.GetProcTableAndDevice(&mockProcs, &mockDevice);
// This SetCallback call cannot be ignored because it is done as soon as we start the server
diff --git a/src/tests/unittests/wire/WireTest.h b/src/tests/unittests/wire/WireTest.h
index 1beb36f..7a6c234 100644
--- a/src/tests/unittests/wire/WireTest.h
+++ b/src/tests/unittests/wire/WireTest.h
@@ -12,8 +12,8 @@
// See the License for the specific language governing permissions and
// limitations under the License.
+#include "dawn/mock_webgpu.h"
#include "gtest/gtest.h"
-#include "dawn/mock_dawn.h"
#include <memory>
@@ -122,8 +122,8 @@
void FlushServer(bool success = true);
testing::StrictMock<MockProcTable> api;
- DawnDevice apiDevice;
- DawnDevice device;
+ WGPUDevice apiDevice;
+ WGPUDevice device;
dawn_wire::WireServer* GetWireServer();
dawn_wire::WireClient* GetWireClient();
