src/tests/unittests/wire/WireArgumentTests.cpp - dawn - Git at Google


            
            // Copyright 2019 The Dawn Authors

            
            //

            
            // Licensed under the Apache License, Version 2.0 (the "License");

            
            // you may not use this file except in compliance with the License.

            
            // You may obtain a copy of the License at

            
            //

            
            //     http://www.apache.org/licenses/LICENSE-2.0

            
            //

            
            // Unless required by applicable law or agreed to in writing, software

            
            // distributed under the License is distributed on an "AS IS" BASIS,

            
            // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

            
            // See the License for the specific language governing permissions and

            
            // limitations under the License.


            #include "tests/unittests/wire/WireTest.h"


            #include "common/Constants.h"


            #include <array>


            using namespace testing;

            
            using namespace dawn_wire;


            class WireArgumentTests : public WireTest {

            
              public:

            
                WireArgumentTests() {

            
                }

            
                ~WireArgumentTests() override = default;

            
            };


            // Test that the wire is able to send numerical values

            
            TEST_F(WireArgumentTests, ValueArgument) {

            
                WGPUCommandEncoder encoder = wgpuDeviceCreateCommandEncoder(device, nullptr);

            
                WGPUComputePassEncoder pass = wgpuCommandEncoderBeginComputePass(encoder, nullptr);

            
                wgpuComputePassEncoderDispatch(pass, 1, 2, 3);


                WGPUCommandEncoder apiEncoder = api.GetNewCommandEncoder();

            
                EXPECT_CALL(api, DeviceCreateCommandEncoder(apiDevice, nullptr)).WillOnce(Return(apiEncoder));


                WGPUComputePassEncoder apiPass = api.GetNewComputePassEncoder();

            
                EXPECT_CALL(api, CommandEncoderBeginComputePass(apiEncoder, nullptr)).WillOnce(Return(apiPass));


                EXPECT_CALL(api, ComputePassEncoderDispatch(apiPass, 1, 2, 3)).Times(1);


                FlushClient();

            
            }


            // Test that the wire is able to send arrays of numerical values

            
            TEST_F(WireArgumentTests, ValueArrayArgument) {

            
                // Create a bindgroup.

            
                WGPUBindGroupLayoutDescriptor bglDescriptor = {};

            
                bglDescriptor.entryCount = 0;

            
                bglDescriptor.entries = nullptr;


                WGPUBindGroupLayout bgl = wgpuDeviceCreateBindGroupLayout(device, &bglDescriptor);

            
                WGPUBindGroupLayout apiBgl = api.GetNewBindGroupLayout();

            
                EXPECT_CALL(api, DeviceCreateBindGroupLayout(apiDevice, _)).WillOnce(Return(apiBgl));


                WGPUBindGroupDescriptor bindGroupDescriptor = {};

            
                bindGroupDescriptor.layout = bgl;

            
                bindGroupDescriptor.entryCount = 0;

            
                bindGroupDescriptor.entries = nullptr;


                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.

            
                WGPUCommandEncoder encoder = wgpuDeviceCreateCommandEncoder(device, nullptr);

            
                WGPUComputePassEncoder pass = wgpuCommandEncoderBeginComputePass(encoder, nullptr);


                std::array<uint32_t, 4> testOffsets = {0, 42, 0xDEAD'BEEFu, 0xFFFF'FFFFu};

            
                wgpuComputePassEncoderSetBindGroup(pass, 0, bindGroup, testOffsets.size(), testOffsets.data());


                WGPUCommandEncoder apiEncoder = api.GetNewCommandEncoder();

            
                EXPECT_CALL(api, DeviceCreateCommandEncoder(apiDevice, nullptr)).WillOnce(Return(apiEncoder));


                WGPUComputePassEncoder apiPass = api.GetNewComputePassEncoder();

            
                EXPECT_CALL(api, CommandEncoderBeginComputePass(apiEncoder, nullptr)).WillOnce(Return(apiPass));


                EXPECT_CALL(api, ComputePassEncoderSetBindGroup(

            
                                     apiPass, 0, apiBindGroup, testOffsets.size(),

            
                                     MatchesLambda([testOffsets](const uint32_t* offsets) -> bool {

            
                                         for (size_t i = 0; i < testOffsets.size(); i++) {

            
                                             if (offsets[i] != testOffsets[i]) {

            
                                                 return false;

            
                                             }

            
                                         }

            
                                         return true;

            
                                     })));


                FlushClient();

            
            }


            // Test that the wire is able to send C strings

            
            TEST_F(WireArgumentTests, CStringArgument) {

            
                // Create shader module

            
                WGPUShaderModuleDescriptor vertexDescriptor = {};

            
                WGPUShaderModule vsModule = wgpuDeviceCreateShaderModule(device, &vertexDescriptor);

            
                WGPUShaderModule apiVsModule = api.GetNewShaderModule();

            
                EXPECT_CALL(api, DeviceCreateShaderModule(apiDevice, _)).WillOnce(Return(apiVsModule));


                // Create the color state descriptor

            
                WGPUBlendComponent blendComponent = {};

            
                blendComponent.operation = WGPUBlendOperation_Add;

            
                blendComponent.srcFactor = WGPUBlendFactor_One;

            
                blendComponent.dstFactor = WGPUBlendFactor_One;

            
                WGPUBlendState blendState = {};

            
                blendState.alpha = blendComponent;

            
                blendState.color = blendComponent;

            
                WGPUColorTargetState colorTargetState = {};

            
                colorTargetState.format = WGPUTextureFormat_RGBA8Unorm;

            
                colorTargetState.blend = &blendState;

            
                colorTargetState.writeMask = WGPUColorWriteMask_All;


                // Create the depth-stencil state

            
                WGPUStencilFaceState stencilFace = {};

            
                stencilFace.compare = WGPUCompareFunction_Always;

            
                stencilFace.failOp = WGPUStencilOperation_Keep;

            
                stencilFace.depthFailOp = WGPUStencilOperation_Keep;

            
                stencilFace.passOp = WGPUStencilOperation_Keep;


                WGPUDepthStencilState depthStencilState = {};

            
                depthStencilState.format = WGPUTextureFormat_Depth24PlusStencil8;

            
                depthStencilState.depthWriteEnabled = false;

            
                depthStencilState.depthCompare = WGPUCompareFunction_Always;

            
                depthStencilState.stencilBack = stencilFace;

            
                depthStencilState.stencilFront = stencilFace;

            
                depthStencilState.stencilReadMask = 0xff;

            
                depthStencilState.stencilWriteMask = 0xff;

            
                depthStencilState.depthBias = 0;

            
                depthStencilState.depthBiasSlopeScale = 0.0;

            
                depthStencilState.depthBiasClamp = 0.0;


                // Create the pipeline layout

            
                WGPUPipelineLayoutDescriptor layoutDescriptor = {};

            
                layoutDescriptor.bindGroupLayoutCount = 0;

            
                layoutDescriptor.bindGroupLayouts = nullptr;

            
                WGPUPipelineLayout layout = wgpuDeviceCreatePipelineLayout(device, &layoutDescriptor);

            
                WGPUPipelineLayout apiLayout = api.GetNewPipelineLayout();

            
                EXPECT_CALL(api, DeviceCreatePipelineLayout(apiDevice, _)).WillOnce(Return(apiLayout));


                // Create pipeline

            
                WGPURenderPipelineDescriptor pipelineDescriptor = {};


                pipelineDescriptor.vertex.module = vsModule;

            
                pipelineDescriptor.vertex.entryPoint = "main";

            
                pipelineDescriptor.vertex.bufferCount = 0;

            
                pipelineDescriptor.vertex.buffers = nullptr;


                WGPUFragmentState fragment = {};

            
                fragment.module = vsModule;

            
                fragment.entryPoint = "main";

            
                fragment.targetCount = 1;

            
                fragment.targets = &colorTargetState;

            
                pipelineDescriptor.fragment = &fragment;


                pipelineDescriptor.multisample.count = 1;

            
                pipelineDescriptor.multisample.mask = 0xFFFFFFFF;

            
                pipelineDescriptor.multisample.alphaToCoverageEnabled = false;

            
                pipelineDescriptor.layout = layout;

            
                pipelineDescriptor.primitive.topology = WGPUPrimitiveTopology_TriangleList;

            
                pipelineDescriptor.primitive.frontFace = WGPUFrontFace_CCW;

            
                pipelineDescriptor.primitive.cullMode = WGPUCullMode_None;

            
                pipelineDescriptor.depthStencil = &depthStencilState;


                wgpuDeviceCreateRenderPipeline(device, &pipelineDescriptor);


                WGPURenderPipeline apiDummyPipeline = api.GetNewRenderPipeline();

            
                EXPECT_CALL(api,

            
                            DeviceCreateRenderPipeline(

            
                                apiDevice, MatchesLambda([](const WGPURenderPipelineDescriptor* desc) -> bool {

            
                                    return desc->vertex.entryPoint == std::string("main");

            
                                })))

            
                    .WillOnce(Return(apiDummyPipeline));


                FlushClient();

            
            }


            // Test that the wire is able to send objects as value arguments

            
            TEST_F(WireArgumentTests, ObjectAsValueArgument) {

            
                WGPUCommandEncoder cmdBufEncoder = wgpuDeviceCreateCommandEncoder(device, nullptr);

            
                WGPUCommandEncoder apiEncoder = api.GetNewCommandEncoder();

            
                EXPECT_CALL(api, DeviceCreateCommandEncoder(apiDevice, nullptr)).WillOnce(Return(apiEncoder));


                WGPUBufferDescriptor descriptor = {};

            
                descriptor.size = 8;

            
                descriptor.usage =

            
                    static_cast<WGPUBufferUsage>(WGPUBufferUsage_CopySrc | WGPUBufferUsage_CopyDst);


                WGPUBuffer buffer = wgpuDeviceCreateBuffer(device, &descriptor);

            
                WGPUBuffer apiBuffer = api.GetNewBuffer();

            
                EXPECT_CALL(api, DeviceCreateBuffer(apiDevice, _))

            
                    .WillOnce(Return(apiBuffer))

            
                    .RetiresOnSaturation();


                wgpuCommandEncoderCopyBufferToBuffer(cmdBufEncoder, buffer, 0, buffer, 4, 4);

            
                EXPECT_CALL(api, CommandEncoderCopyBufferToBuffer(apiEncoder, apiBuffer, 0, apiBuffer, 4, 4));


                FlushClient();

            
            }


            // Test that the wire is able to send array of objects

            
            TEST_F(WireArgumentTests, ObjectsAsPointerArgument) {

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

            
                    WGPUCommandEncoder cmdBufEncoder = wgpuDeviceCreateCommandEncoder(device, nullptr);

            
                    cmdBufs[i] = wgpuCommandEncoderFinish(cmdBufEncoder, nullptr);


                    WGPUCommandEncoder apiCmdBufEncoder = api.GetNewCommandEncoder();

            
                    EXPECT_CALL(api, DeviceCreateCommandEncoder(apiDevice, nullptr))

            
                        .InSequence(s)

            
                        .WillOnce(Return(apiCmdBufEncoder));


                    apiCmdBufs[i] = api.GetNewCommandBuffer();

            
                    EXPECT_CALL(api, CommandEncoderFinish(apiCmdBufEncoder, nullptr))

            
                        .WillOnce(Return(apiCmdBufs[i]));

            
                }


                // Submit command buffer and check we got a call with both API-side command buffers

            
                wgpuQueueSubmit(queue, 2, cmdBufs);


                EXPECT_CALL(

            
                    api, QueueSubmit(apiQueue, 2, MatchesLambda([=](const WGPUCommandBuffer* cmdBufs) -> bool {

            
                                         return cmdBufs[0] == apiCmdBufs[0] && cmdBufs[1] == apiCmdBufs[1];

            
                                     })));


                FlushClient();

            
            }


            // Test that the wire is able to send structures that contain pure values (non-objects)

            
            TEST_F(WireArgumentTests, StructureOfValuesArgument) {

            
                WGPUSamplerDescriptor descriptor = {};

            
                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 = WGPUCompareFunction_Never;


                wgpuDeviceCreateSampler(device, &descriptor);


                WGPUSampler apiDummySampler = api.GetNewSampler();

            
                EXPECT_CALL(api, DeviceCreateSampler(

            
                                     apiDevice, MatchesLambda([](const WGPUSamplerDescriptor* desc) -> bool {

            
                                         return desc->nextInChain == nullptr &&

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


                FlushClient();

            
            }


            // Test that the wire is able to send structures that contain objects

            
            TEST_F(WireArgumentTests, StructureOfObjectArrayArgument) {

            
                WGPUBindGroupLayoutDescriptor bglDescriptor = {};

            
                bglDescriptor.entryCount = 0;

            
                bglDescriptor.entries = nullptr;


                WGPUBindGroupLayout bgl = wgpuDeviceCreateBindGroupLayout(device, &bglDescriptor);

            
                WGPUBindGroupLayout apiBgl = api.GetNewBindGroupLayout();

            
                EXPECT_CALL(api, DeviceCreateBindGroupLayout(apiDevice, _)).WillOnce(Return(apiBgl));


                WGPUPipelineLayoutDescriptor descriptor = {};

            
                descriptor.bindGroupLayoutCount = 1;

            
                descriptor.bindGroupLayouts = &bgl;


                wgpuDeviceCreatePipelineLayout(device, &descriptor);


                WGPUPipelineLayout apiDummyLayout = api.GetNewPipelineLayout();

            
                EXPECT_CALL(api, DeviceCreatePipelineLayout(

            
                                     apiDevice,

            
                                     MatchesLambda([apiBgl](const WGPUPipelineLayoutDescriptor* desc) -> bool {

            
                                         return desc->nextInChain == nullptr &&

            
                                                desc->bindGroupLayoutCount == 1 &&

            
                                                desc->bindGroupLayouts[0] == apiBgl;

            
                                     })))

            
                    .WillOnce(Return(apiDummyLayout));


                FlushClient();

            
            }


            // Test that the wire is able to send structures that contain objects

            
            TEST_F(WireArgumentTests, StructureOfStructureArrayArgument) {

            
                static constexpr int NUM_BINDINGS = 3;

            
                WGPUBindGroupLayoutEntry entries[NUM_BINDINGS]{

            
                    {nullptr,

            
                     0,

            
                     WGPUShaderStage_Vertex,

            
                     {},

            
                     {nullptr, WGPUSamplerBindingType_Filtering},

            
                     {},

            
                     {}},

            
                    {nullptr,

            
                     1,

            
                     WGPUShaderStage_Vertex,

            
                     {},

            
                     {},

            
                     {nullptr, WGPUTextureSampleType_Float, WGPUTextureViewDimension_2D, false},

            
                     {}},

            
                    {nullptr,

            
                     2,

            
                     static_cast<WGPUShaderStage>(WGPUShaderStage_Vertex | WGPUShaderStage_Fragment),

            
                     {nullptr, WGPUBufferBindingType_Uniform, false, 0},

            
                     {},

            
                     {},

            
                     {}},

            
                };

            
                WGPUBindGroupLayoutDescriptor bglDescriptor = {};

            
                bglDescriptor.entryCount = NUM_BINDINGS;

            
                bglDescriptor.entries = entries;


                wgpuDeviceCreateBindGroupLayout(device, &bglDescriptor);

            
                WGPUBindGroupLayout apiBgl = api.GetNewBindGroupLayout();

            
                EXPECT_CALL(

            
                    api,

            
                    DeviceCreateBindGroupLayout(

            
                        apiDevice, MatchesLambda([entries](const WGPUBindGroupLayoutDescriptor* desc) -> bool {

            
                            for (int i = 0; i < NUM_BINDINGS; ++i) {

            
                                const auto& a = desc->entries[i];

            
                                const auto& b = entries[i];

            
                                if (a.binding != b.binding || a.visibility != b.visibility ||

            
                                    a.buffer.type != b.buffer.type || a.sampler.type != b.sampler.type ||

            
                                    a.texture.sampleType != b.texture.sampleType) {

            
                                    return false;

            
                                }

            
                            }

            
                            return desc->nextInChain == nullptr && desc->entryCount == 3;

            
                        })))

            
                    .WillOnce(Return(apiBgl));


                FlushClient();

            
            }


            // Test passing nullptr instead of objects - array of objects version

            
            TEST_F(WireArgumentTests, DISABLED_NullptrInArray) {

            
                WGPUBindGroupLayout nullBGL = nullptr;


                WGPUPipelineLayoutDescriptor descriptor = {};

            
                descriptor.bindGroupLayoutCount = 1;

            
                descriptor.bindGroupLayouts = &nullBGL;


                wgpuDeviceCreatePipelineLayout(device, &descriptor);

            
                EXPECT_CALL(api,

            
                            DeviceCreatePipelineLayout(

            
                                apiDevice, MatchesLambda([](const WGPUPipelineLayoutDescriptor* desc) -> bool {

            
                                    return desc->nextInChain == nullptr && desc->bindGroupLayoutCount == 1 &&

            
                                           desc->bindGroupLayouts[0] == nullptr;

            
                                })))

            
                    .WillOnce(Return(nullptr));


                FlushClient();

            
            }
	// Copyright 2019 The Dawn Authors
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	#include "tests/unittests/wire/WireTest.h"

	#include "common/Constants.h"

	#include <array>

	using namespace testing;
	using namespace dawn_wire;

	class WireArgumentTests : public WireTest {
	public:
	WireArgumentTests() {
	}
	~WireArgumentTests() override = default;
	};

	// Test that the wire is able to send numerical values
	TEST_F(WireArgumentTests, ValueArgument) {
	WGPUCommandEncoder encoder = wgpuDeviceCreateCommandEncoder(device, nullptr);
	WGPUComputePassEncoder pass = wgpuCommandEncoderBeginComputePass(encoder, nullptr);
	wgpuComputePassEncoderDispatch(pass, 1, 2, 3);

	WGPUCommandEncoder apiEncoder = api.GetNewCommandEncoder();
	EXPECT_CALL(api, DeviceCreateCommandEncoder(apiDevice, nullptr)).WillOnce(Return(apiEncoder));

	WGPUComputePassEncoder apiPass = api.GetNewComputePassEncoder();
	EXPECT_CALL(api, CommandEncoderBeginComputePass(apiEncoder, nullptr)).WillOnce(Return(apiPass));

	EXPECT_CALL(api, ComputePassEncoderDispatch(apiPass, 1, 2, 3)).Times(1);

	FlushClient();
	}

	// Test that the wire is able to send arrays of numerical values
	TEST_F(WireArgumentTests, ValueArrayArgument) {
	// Create a bindgroup.
	WGPUBindGroupLayoutDescriptor bglDescriptor = {};
	bglDescriptor.entryCount = 0;
	bglDescriptor.entries = nullptr;

	WGPUBindGroupLayout bgl = wgpuDeviceCreateBindGroupLayout(device, &bglDescriptor);
	WGPUBindGroupLayout apiBgl = api.GetNewBindGroupLayout();
	EXPECT_CALL(api, DeviceCreateBindGroupLayout(apiDevice, _)).WillOnce(Return(apiBgl));

	WGPUBindGroupDescriptor bindGroupDescriptor = {};
	bindGroupDescriptor.layout = bgl;
	bindGroupDescriptor.entryCount = 0;
	bindGroupDescriptor.entries = nullptr;

	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.
	WGPUCommandEncoder encoder = wgpuDeviceCreateCommandEncoder(device, nullptr);
	WGPUComputePassEncoder pass = wgpuCommandEncoderBeginComputePass(encoder, nullptr);

	std::array<uint32_t, 4> testOffsets = {0, 42, 0xDEAD'BEEFu, 0xFFFF'FFFFu};
	wgpuComputePassEncoderSetBindGroup(pass, 0, bindGroup, testOffsets.size(), testOffsets.data());

	WGPUCommandEncoder apiEncoder = api.GetNewCommandEncoder();
	EXPECT_CALL(api, DeviceCreateCommandEncoder(apiDevice, nullptr)).WillOnce(Return(apiEncoder));

	WGPUComputePassEncoder apiPass = api.GetNewComputePassEncoder();
	EXPECT_CALL(api, CommandEncoderBeginComputePass(apiEncoder, nullptr)).WillOnce(Return(apiPass));

	EXPECT_CALL(api, ComputePassEncoderSetBindGroup(
	apiPass, 0, apiBindGroup, testOffsets.size(),
	MatchesLambda([testOffsets](const uint32_t* offsets) -> bool {
	for (size_t i = 0; i < testOffsets.size(); i++) {
	if (offsets[i] != testOffsets[i]) {
	return false;
	}
	}
	return true;
	})));

	FlushClient();
	}

	// Test that the wire is able to send C strings
	TEST_F(WireArgumentTests, CStringArgument) {
	// Create shader module
	WGPUShaderModuleDescriptor vertexDescriptor = {};
	WGPUShaderModule vsModule = wgpuDeviceCreateShaderModule(device, &vertexDescriptor);
	WGPUShaderModule apiVsModule = api.GetNewShaderModule();
	EXPECT_CALL(api, DeviceCreateShaderModule(apiDevice, _)).WillOnce(Return(apiVsModule));

	// Create the color state descriptor
	WGPUBlendComponent blendComponent = {};
	blendComponent.operation = WGPUBlendOperation_Add;
	blendComponent.srcFactor = WGPUBlendFactor_One;
	blendComponent.dstFactor = WGPUBlendFactor_One;
	WGPUBlendState blendState = {};
	blendState.alpha = blendComponent;
	blendState.color = blendComponent;
	WGPUColorTargetState colorTargetState = {};
	colorTargetState.format = WGPUTextureFormat_RGBA8Unorm;
	colorTargetState.blend = &blendState;
	colorTargetState.writeMask = WGPUColorWriteMask_All;

	// Create the depth-stencil state
	WGPUStencilFaceState stencilFace = {};
	stencilFace.compare = WGPUCompareFunction_Always;
	stencilFace.failOp = WGPUStencilOperation_Keep;
	stencilFace.depthFailOp = WGPUStencilOperation_Keep;
	stencilFace.passOp = WGPUStencilOperation_Keep;

	WGPUDepthStencilState depthStencilState = {};
	depthStencilState.format = WGPUTextureFormat_Depth24PlusStencil8;
	depthStencilState.depthWriteEnabled = false;
	depthStencilState.depthCompare = WGPUCompareFunction_Always;
	depthStencilState.stencilBack = stencilFace;
	depthStencilState.stencilFront = stencilFace;
	depthStencilState.stencilReadMask = 0xff;
	depthStencilState.stencilWriteMask = 0xff;
	depthStencilState.depthBias = 0;
	depthStencilState.depthBiasSlopeScale = 0.0;
	depthStencilState.depthBiasClamp = 0.0;

	// Create the pipeline layout
	WGPUPipelineLayoutDescriptor layoutDescriptor = {};
	layoutDescriptor.bindGroupLayoutCount = 0;
	layoutDescriptor.bindGroupLayouts = nullptr;
	WGPUPipelineLayout layout = wgpuDeviceCreatePipelineLayout(device, &layoutDescriptor);
	WGPUPipelineLayout apiLayout = api.GetNewPipelineLayout();
	EXPECT_CALL(api, DeviceCreatePipelineLayout(apiDevice, _)).WillOnce(Return(apiLayout));

	// Create pipeline
	WGPURenderPipelineDescriptor pipelineDescriptor = {};

	pipelineDescriptor.vertex.module = vsModule;
	pipelineDescriptor.vertex.entryPoint = "main";
	pipelineDescriptor.vertex.bufferCount = 0;
	pipelineDescriptor.vertex.buffers = nullptr;

	WGPUFragmentState fragment = {};
	fragment.module = vsModule;
	fragment.entryPoint = "main";
	fragment.targetCount = 1;
	fragment.targets = &colorTargetState;
	pipelineDescriptor.fragment = &fragment;

	pipelineDescriptor.multisample.count = 1;
	pipelineDescriptor.multisample.mask = 0xFFFFFFFF;
	pipelineDescriptor.multisample.alphaToCoverageEnabled = false;
	pipelineDescriptor.layout = layout;
	pipelineDescriptor.primitive.topology = WGPUPrimitiveTopology_TriangleList;
	pipelineDescriptor.primitive.frontFace = WGPUFrontFace_CCW;
	pipelineDescriptor.primitive.cullMode = WGPUCullMode_None;
	pipelineDescriptor.depthStencil = &depthStencilState;

	wgpuDeviceCreateRenderPipeline(device, &pipelineDescriptor);

	WGPURenderPipeline apiDummyPipeline = api.GetNewRenderPipeline();
	EXPECT_CALL(api,
	DeviceCreateRenderPipeline(
	apiDevice, MatchesLambda([](const WGPURenderPipelineDescriptor* desc) -> bool {
	return desc->vertex.entryPoint == std::string("main");
	})))
	.WillOnce(Return(apiDummyPipeline));

	FlushClient();
	}

	// Test that the wire is able to send objects as value arguments
	TEST_F(WireArgumentTests, ObjectAsValueArgument) {
	WGPUCommandEncoder cmdBufEncoder = wgpuDeviceCreateCommandEncoder(device, nullptr);
	WGPUCommandEncoder apiEncoder = api.GetNewCommandEncoder();
	EXPECT_CALL(api, DeviceCreateCommandEncoder(apiDevice, nullptr)).WillOnce(Return(apiEncoder));

	WGPUBufferDescriptor descriptor = {};
	descriptor.size = 8;
	descriptor.usage =
	static_cast<WGPUBufferUsage>(WGPUBufferUsage_CopySrc \| WGPUBufferUsage_CopyDst);

	WGPUBuffer buffer = wgpuDeviceCreateBuffer(device, &descriptor);
	WGPUBuffer apiBuffer = api.GetNewBuffer();
	EXPECT_CALL(api, DeviceCreateBuffer(apiDevice, _))
	.WillOnce(Return(apiBuffer))
	.RetiresOnSaturation();

	wgpuCommandEncoderCopyBufferToBuffer(cmdBufEncoder, buffer, 0, buffer, 4, 4);
	EXPECT_CALL(api, CommandEncoderCopyBufferToBuffer(apiEncoder, apiBuffer, 0, apiBuffer, 4, 4));

	FlushClient();
	}

	// Test that the wire is able to send array of objects
	TEST_F(WireArgumentTests, ObjectsAsPointerArgument) {
	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) {
	WGPUCommandEncoder cmdBufEncoder = wgpuDeviceCreateCommandEncoder(device, nullptr);
	cmdBufs[i] = wgpuCommandEncoderFinish(cmdBufEncoder, nullptr);

	WGPUCommandEncoder apiCmdBufEncoder = api.GetNewCommandEncoder();
	EXPECT_CALL(api, DeviceCreateCommandEncoder(apiDevice, nullptr))
	.InSequence(s)
	.WillOnce(Return(apiCmdBufEncoder));

	apiCmdBufs[i] = api.GetNewCommandBuffer();
	EXPECT_CALL(api, CommandEncoderFinish(apiCmdBufEncoder, nullptr))
	.WillOnce(Return(apiCmdBufs[i]));
	}

	// Submit command buffer and check we got a call with both API-side command buffers
	wgpuQueueSubmit(queue, 2, cmdBufs);

	EXPECT_CALL(
	api, QueueSubmit(apiQueue, 2, MatchesLambda([=](const WGPUCommandBuffer* cmdBufs) -> bool {
	return cmdBufs[0] == apiCmdBufs[0] && cmdBufs[1] == apiCmdBufs[1];
	})));

	FlushClient();
	}

	// Test that the wire is able to send structures that contain pure values (non-objects)
	TEST_F(WireArgumentTests, StructureOfValuesArgument) {
	WGPUSamplerDescriptor descriptor = {};
	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 = WGPUCompareFunction_Never;

	wgpuDeviceCreateSampler(device, &descriptor);

	WGPUSampler apiDummySampler = api.GetNewSampler();
	EXPECT_CALL(api, DeviceCreateSampler(
	apiDevice, MatchesLambda([](const WGPUSamplerDescriptor* desc) -> bool {
	return desc->nextInChain == nullptr &&
	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));

	FlushClient();
	}

	// Test that the wire is able to send structures that contain objects
	TEST_F(WireArgumentTests, StructureOfObjectArrayArgument) {
	WGPUBindGroupLayoutDescriptor bglDescriptor = {};
	bglDescriptor.entryCount = 0;
	bglDescriptor.entries = nullptr;

	WGPUBindGroupLayout bgl = wgpuDeviceCreateBindGroupLayout(device, &bglDescriptor);
	WGPUBindGroupLayout apiBgl = api.GetNewBindGroupLayout();
	EXPECT_CALL(api, DeviceCreateBindGroupLayout(apiDevice, _)).WillOnce(Return(apiBgl));

	WGPUPipelineLayoutDescriptor descriptor = {};
	descriptor.bindGroupLayoutCount = 1;
	descriptor.bindGroupLayouts = &bgl;

	wgpuDeviceCreatePipelineLayout(device, &descriptor);

	WGPUPipelineLayout apiDummyLayout = api.GetNewPipelineLayout();
	EXPECT_CALL(api, DeviceCreatePipelineLayout(
	apiDevice,
	MatchesLambda([apiBgl](const WGPUPipelineLayoutDescriptor* desc) -> bool {
	return desc->nextInChain == nullptr &&
	desc->bindGroupLayoutCount == 1 &&
	desc->bindGroupLayouts[0] == apiBgl;
	})))
	.WillOnce(Return(apiDummyLayout));

	FlushClient();
	}

	// Test that the wire is able to send structures that contain objects
	TEST_F(WireArgumentTests, StructureOfStructureArrayArgument) {
	static constexpr int NUM_BINDINGS = 3;
	WGPUBindGroupLayoutEntry entries[NUM_BINDINGS]{
	{nullptr,
	0,
	WGPUShaderStage_Vertex,
	{},
	{nullptr, WGPUSamplerBindingType_Filtering},
	{},
	{}},
	{nullptr,
	1,
	WGPUShaderStage_Vertex,
	{},
	{},
	{nullptr, WGPUTextureSampleType_Float, WGPUTextureViewDimension_2D, false},
	{}},
	{nullptr,
	2,
	static_cast<WGPUShaderStage>(WGPUShaderStage_Vertex \| WGPUShaderStage_Fragment),
	{nullptr, WGPUBufferBindingType_Uniform, false, 0},
	{},
	{},
	{}},
	};
	WGPUBindGroupLayoutDescriptor bglDescriptor = {};
	bglDescriptor.entryCount = NUM_BINDINGS;
	bglDescriptor.entries = entries;

	wgpuDeviceCreateBindGroupLayout(device, &bglDescriptor);
	WGPUBindGroupLayout apiBgl = api.GetNewBindGroupLayout();
	EXPECT_CALL(
	api,
	DeviceCreateBindGroupLayout(
	apiDevice, MatchesLambda([entries](const WGPUBindGroupLayoutDescriptor* desc) -> bool {
	for (int i = 0; i < NUM_BINDINGS; ++i) {
	const auto& a = desc->entries[i];
	const auto& b = entries[i];
	if (a.binding != b.binding \|\| a.visibility != b.visibility \|\|
	a.buffer.type != b.buffer.type \|\| a.sampler.type != b.sampler.type \|\|
	a.texture.sampleType != b.texture.sampleType) {
	return false;
	}
	}
	return desc->nextInChain == nullptr && desc->entryCount == 3;
	})))
	.WillOnce(Return(apiBgl));

	FlushClient();
	}

	// Test passing nullptr instead of objects - array of objects version
	TEST_F(WireArgumentTests, DISABLED_NullptrInArray) {
	WGPUBindGroupLayout nullBGL = nullptr;

	WGPUPipelineLayoutDescriptor descriptor = {};
	descriptor.bindGroupLayoutCount = 1;
	descriptor.bindGroupLayouts = &nullBGL;

	wgpuDeviceCreatePipelineLayout(device, &descriptor);
	EXPECT_CALL(api,
	DeviceCreatePipelineLayout(
	apiDevice, MatchesLambda([](const WGPUPipelineLayoutDescriptor* desc) -> bool {
	return desc->nextInChain == nullptr && desc->bindGroupLayoutCount == 1 &&
	desc->bindGroupLayouts[0] == nullptr;
	})))
	.WillOnce(Return(nullptr));

	FlushClient();
	}