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

Capitalize C types dawn -> Dawn

Browse Source 
This is to match Chromium style.

Change-Id: Ic97cc03e2291c653ade9662ba3d5e629872b10ad
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/5482
Reviewed-by: Kai Ninomiya <kainino@chromium.org>
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
Commit-Queue: Austin Eng <enga@chromium.org>
This commit is contained in:
Austin Eng
2019-03-11 16:52:42 +00:00
committed by Commit Bot service account
parent 97ffc1a8aa
commit 45f9730855
87 changed files with 596 additions and 596 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
src/tests/DawnTest.cpp
View File

@@ -262,8 +262,8 @@ void DawnTest::SetUp() {
}
mPCIInfo = backendAdapter.GetPCIInfo();
dawnDevice backendDevice = backendAdapter.CreateDevice();
dawnProcTable backendProcs = dawn_native::GetProcs();
DawnDevice backendDevice = backendAdapter.CreateDevice();
DawnProcTable backendProcs = dawn_native::GetProcs();
// Get the test window and create the device using it (esp. for OpenGL)
GLFWwindow* testWindow = gTestEnv->GetWindowForBackend(GetParam());
@@ -272,8 +272,8 @@ void DawnTest::SetUp() {
DAWN_ASSERT(mBinding != nullptr);
// Choose whether to use the backend procs and devices directly, or set up the wire.
dawnDevice cDevice = nullptr;
dawnProcTable procs;
DawnDevice cDevice = nullptr;
DawnProcTable procs;
if (gTestEnv->UseWire()) {
mC2sBuf = std::make_unique<utils::TerribleCommandBuffer>();
@@ -283,8 +283,8 @@ void DawnTest::SetUp() {
mC2sBuf->SetHandler(mWireServer.get());
mWireClient.reset(new dawn_wire::WireClient(mC2sBuf.get()));
dawnDevice clientDevice = mWireClient->GetDevice();
dawnProcTable clientProcs = mWireClient->GetProcs();
DawnDevice clientDevice = mWireClient->GetDevice();
DawnProcTable clientProcs = mWireClient->GetProcs();
mS2cBuf->SetHandler(mWireClient.get());
procs = clientProcs;
@@ -310,7 +310,7 @@ void DawnTest::SetUp() {
dawn::TextureUsageBit::OutputAttachment, 400, 400);
device.SetErrorCallback(OnDeviceError,
static_cast<dawnCallbackUserdata>(reinterpret_cast<uintptr_t>(this)));
static_cast<DawnCallbackUserdata>(reinterpret_cast<uintptr_t>(this)));
}
void DawnTest::TearDown() {
@@ -334,7 +334,7 @@ bool DawnTest::EndExpectDeviceError() {
}
// static
void DawnTest::OnDeviceError(const char* message, dawnCallbackUserdata userdata) {
void DawnTest::OnDeviceError(const char* message, DawnCallbackUserdata userdata) {
DawnTest* self = reinterpret_cast<DawnTest*>(static_cast<uintptr_t>(userdata));
ASSERT_TRUE(self->mExpectError) << "Got unexpected device error: " << message;
@@ -481,10 +481,10 @@ void DawnTest::MapSlotsSynchronously() {
}
// static
void DawnTest::SlotMapReadCallback(dawnBufferMapAsyncStatus status,
void DawnTest::SlotMapReadCallback(DawnBufferMapAsyncStatus status,
const void* data,
uint32_t,
dawnCallbackUserdata userdata_) {
DawnCallbackUserdata userdata_) {
DAWN_ASSERT(status == DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS);
auto userdata = reinterpret_cast<MapReadUserdata*>(static_cast<uintptr_t>(userdata_));

6
src/tests/DawnTest.h
View File

@@ -171,7 +171,7 @@ class DawnTest : public ::testing::TestWithParam<dawn_native::BackendType> {
void FlushWire();
// Tracking for validation errors
static void OnDeviceError(const char* message, dawnCallbackUserdata userdata);
static void OnDeviceError(const char* message, DawnCallbackUserdata userdata);
bool mExpectError = false;
bool mError = false;
@@ -185,10 +185,10 @@ class DawnTest : public ::testing::TestWithParam<dawn_native::BackendType> {
// Maps all the buffers and fill ReadbackSlot::mappedData
void MapSlotsSynchronously();
static void SlotMapReadCallback(dawnBufferMapAsyncStatus status,
static void SlotMapReadCallback(DawnBufferMapAsyncStatus status,
const void* data,
uint32_t dataLength,
dawnCallbackUserdata userdata);
DawnCallbackUserdata userdata);
size_t mNumPendingMapOperations = 0;
// Reserve space where the data for an expectation can be copied

8
src/tests/end2end/BufferTests.cpp
View File

@@ -18,10 +18,10 @@
class BufferMapReadTests : public DawnTest {
protected:
static void MapReadCallback(dawnBufferMapAsyncStatus status,
static void MapReadCallback(DawnBufferMapAsyncStatus status,
const void* data,
uint32_t,
dawnCallbackUserdata userdata) {
DawnCallbackUserdata userdata) {
ASSERT_EQ(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, status);
ASSERT_NE(nullptr, data);
@@ -85,10 +85,10 @@ DAWN_INSTANTIATE_TEST(BufferMapReadTests, D3D12Backend, MetalBackend, OpenGLBack
class BufferMapWriteTests : public DawnTest {
protected:
static void MapWriteCallback(dawnBufferMapAsyncStatus status,
static void MapWriteCallback(DawnBufferMapAsyncStatus status,
void* data,
uint32_t,
dawnCallbackUserdata userdata) {
DawnCallbackUserdata userdata) {
ASSERT_EQ(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, status);
ASSERT_NE(nullptr, data);

36
src/tests/end2end/FenceTests.cpp
View File

@@ -20,12 +20,12 @@
class MockFenceOnCompletionCallback {
public:
MOCK_METHOD2(Call, void(dawnFenceCompletionStatus status, dawnCallbackUserdata userdata));
MOCK_METHOD2(Call, void(DawnFenceCompletionStatus status, DawnCallbackUserdata userdata));
};
static std::unique_ptr<MockFenceOnCompletionCallback> mockFenceOnCompletionCallback;
static void ToMockFenceOnCompletionCallback(dawnFenceCompletionStatus status,
dawnCallbackUserdata userdata) {
static void ToMockFenceOnCompletionCallback(DawnFenceCompletionStatus status,
DawnCallbackUserdata userdata) {
mockFenceOnCompletionCallback->Call(status, userdata);
}
class FenceTests : public DawnTest {
@@ -33,10 +33,10 @@ class FenceTests : public DawnTest {
struct CallbackInfo {
FenceTests* test;
uint64_t value;
dawnFenceCompletionStatus status;
DawnFenceCompletionStatus status;
int32_t callIndex = -1; // If this is -1, the callback was not called
void Update(dawnFenceCompletionStatus status) {
void Update(DawnFenceCompletionStatus status) {
this->callIndex = test->mCallIndex++;
this->status = status;
}
@@ -89,10 +89,10 @@ TEST_P(FenceTests, OnCompletionOrdering) {
queue.Signal(fence, 4);
dawnCallbackUserdata userdata0 = 1282;
dawnCallbackUserdata userdata1 = 4382;
dawnCallbackUserdata userdata2 = 1211;
dawnCallbackUserdata userdata3 = 1882;
DawnCallbackUserdata userdata0 = 1282;
DawnCallbackUserdata userdata1 = 4382;
DawnCallbackUserdata userdata2 = 1211;
DawnCallbackUserdata userdata3 = 1882;
{
testing::InSequence s;
@@ -131,7 +131,7 @@ TEST_P(FenceTests, MultipleSignalOnCompletion) {
queue.Signal(fence, 2);
queue.Signal(fence, 4);
dawnCallbackUserdata userdata = 1234;
DawnCallbackUserdata userdata = 1234;
EXPECT_CALL(*mockFenceOnCompletionCallback,
Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, userdata))
.Times(1);
@@ -148,10 +148,10 @@ TEST_P(FenceTests, OnCompletionMultipleCallbacks) {
queue.Signal(fence, 4);
dawnCallbackUserdata userdata0 = 2341;
dawnCallbackUserdata userdata1 = 4598;
dawnCallbackUserdata userdata2 = 5690;
dawnCallbackUserdata userdata3 = 2783;
DawnCallbackUserdata userdata0 = 2341;
DawnCallbackUserdata userdata1 = 4598;
DawnCallbackUserdata userdata2 = 5690;
DawnCallbackUserdata userdata3 = 2783;
EXPECT_CALL(*mockFenceOnCompletionCallback,
Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, userdata0))
@@ -192,10 +192,10 @@ TEST_P(FenceTests, DISABLED_DestroyBeforeOnCompletionEnd) {
queue.Signal(testFence, 4);
dawnCallbackUserdata userdata0 = 1341;
dawnCallbackUserdata userdata1 = 1598;
dawnCallbackUserdata userdata2 = 1690;
dawnCallbackUserdata userdata3 = 1783;
DawnCallbackUserdata userdata0 = 1341;
DawnCallbackUserdata userdata1 = 1598;
DawnCallbackUserdata userdata2 = 1690;
DawnCallbackUserdata userdata3 = 1783;
EXPECT_CALL(*mockFenceOnCompletionCallback,
Call(DAWN_FENCE_COMPLETION_STATUS_UNKNOWN, userdata0))

4
src/tests/end2end/IOSurfaceWrappingTests.cpp
View File

@@ -96,8 +96,8 @@ namespace {
dawn::Texture WrapIOSurface(const dawn::TextureDescriptor* descriptor,
IOSurfaceRef ioSurface,
uint32_t plane) {
dawnTexture texture = dawn_native::metal::WrapIOSurface(
device.Get(), reinterpret_cast<const dawnTextureDescriptor*>(descriptor), ioSurface,
DawnTexture texture = dawn_native::metal::WrapIOSurface(
device.Get(), reinterpret_cast<const DawnTextureDescriptor*>(descriptor), ioSurface,
plane);
return dawn::Texture::Acquire(texture);
}

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

@@ -23,17 +23,17 @@ using namespace testing;
class MockBufferMapReadCallback {
public:
MOCK_METHOD4(Call,
void(dawnBufferMapAsyncStatus status,
void(DawnBufferMapAsyncStatus status,
const uint32_t* ptr,
uint32_t dataLength,
dawnCallbackUserdata userdata));
DawnCallbackUserdata userdata));
};
static std::unique_ptr<MockBufferMapReadCallback> mockBufferMapReadCallback;
static void ToMockBufferMapReadCallback(dawnBufferMapAsyncStatus status,
static void ToMockBufferMapReadCallback(DawnBufferMapAsyncStatus status,
const void* ptr,
uint32_t dataLength,
dawnCallbackUserdata userdata) {
DawnCallbackUserdata userdata) {
// Assume the data is uint32_t to make writing matchers easier
mockBufferMapReadCallback->Call(status, reinterpret_cast<const uint32_t*>(ptr), dataLength,
userdata);
@@ -42,17 +42,17 @@ static void ToMockBufferMapReadCallback(dawnBufferMapAsyncStatus status,
class MockBufferMapWriteCallback {
public:
MOCK_METHOD4(Call,
void(dawnBufferMapAsyncStatus status,
void(DawnBufferMapAsyncStatus status,
uint32_t* ptr,
uint32_t dataLength,
dawnCallbackUserdata userdata));
DawnCallbackUserdata userdata));
};
static std::unique_ptr<MockBufferMapWriteCallback> mockBufferMapWriteCallback;
static void ToMockBufferMapWriteCallback(dawnBufferMapAsyncStatus status,
static void ToMockBufferMapWriteCallback(DawnBufferMapAsyncStatus status,
void* ptr,
uint32_t dataLength,
dawnCallbackUserdata userdata) {
DawnCallbackUserdata userdata) {
// Assume the data is uint32_t to make writing matchers easier
mockBufferMapWriteCallback->Call(status, reinterpret_cast<uint32_t*>(ptr), dataLength,
userdata);

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

@@ -20,30 +20,30 @@ using namespace testing;
class MockFenceOnCompletionCallback {
public:
MOCK_METHOD2(Call, void(dawnFenceCompletionStatus status, dawnCallbackUserdata userdata));
MOCK_METHOD2(Call, void(DawnFenceCompletionStatus status, DawnCallbackUserdata userdata));
};
struct FenceOnCompletionExpectation {
dawn::Fence fence;
uint64_t value;
dawnFenceCompletionStatus status;
DawnFenceCompletionStatus status;
};
static std::unique_ptr<MockFenceOnCompletionCallback> mockFenceOnCompletionCallback;
static void ToMockFenceOnCompletionCallback(dawnFenceCompletionStatus status,
dawnCallbackUserdata userdata) {
static void ToMockFenceOnCompletionCallback(DawnFenceCompletionStatus status,
DawnCallbackUserdata userdata) {
mockFenceOnCompletionCallback->Call(status, userdata);
}
class FenceValidationTest : public ValidationTest {
protected:
void TestOnCompletion(dawn::Fence fence, uint64_t value, dawnFenceCompletionStatus status) {
void TestOnCompletion(dawn::Fence fence, uint64_t value, DawnFenceCompletionStatus status) {
FenceOnCompletionExpectation* expectation = new FenceOnCompletionExpectation;
expectation->fence = fence;
expectation->value = value;
expectation->status = status;
dawnCallbackUserdata userdata =
static_cast<dawnCallbackUserdata>(reinterpret_cast<uintptr_t>(expectation));
DawnCallbackUserdata userdata =
static_cast<DawnCallbackUserdata>(reinterpret_cast<uintptr_t>(expectation));
EXPECT_CALL(*mockFenceOnCompletionCallback, Call(status, userdata)).Times(1);
fence.OnCompletion(value, ToMockFenceOnCompletionCallback, userdata);
@@ -135,7 +135,7 @@ TEST_F(FenceValidationTest, GetCompletedValueInsideCallback) {
queue.Signal(fence, 3);
fence.OnCompletion(2u, ToMockFenceOnCompletionCallback, 0);
EXPECT_CALL(*mockFenceOnCompletionCallback, Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, 0))
.WillOnce(Invoke([&](dawnFenceCompletionStatus status, dawnCallbackUserdata userdata) {
.WillOnce(Invoke([&](DawnFenceCompletionStatus status, DawnCallbackUserdata userdata) {
EXPECT_EQ(fence.GetCompletedValue(), 3u);
}));

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

@@ -21,10 +21,10 @@ namespace {
class QueueSubmitValidationTest : public ValidationTest {
};
static void StoreTrueMapWriteCallback(dawnBufferMapAsyncStatus status,
static void StoreTrueMapWriteCallback(DawnBufferMapAsyncStatus status,
void*,
uint32_t,
dawnCallbackUserdata userdata) {
DawnCallbackUserdata userdata) {
bool* userdataPtr = reinterpret_cast<bool*>(static_cast<intptr_t>(userdata));
*userdataPtr = true;
}
@@ -56,7 +56,7 @@ TEST_F(QueueSubmitValidationTest, SubmitWithMappedBuffer) {
// Map the buffer, submitting when the buffer is mapped should fail
bool mapWriteFinished = false;
dawnCallbackUserdata userdata = static_cast<dawnCallbackUserdata>(reinterpret_cast<intptr_t>(&mapWriteFinished));
DawnCallbackUserdata userdata = static_cast<DawnCallbackUserdata>(reinterpret_cast<intptr_t>(&mapWriteFinished));
buffer.MapWriteAsync(StoreTrueMapWriteCallback, userdata);
queue.Submit(0, nullptr);
ASSERT_TRUE(mapWriteFinished);

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

@@ -39,10 +39,10 @@ ValidationTest::ValidationTest() {
ASSERT(foundNullAdapter);
device = dawn::Device::Acquire(nullAdapter.CreateDevice());
dawnProcTable procs = dawn_native::GetProcs();
DawnProcTable procs = dawn_native::GetProcs();
dawnSetProcs(&procs);
device.SetErrorCallback(ValidationTest::OnDeviceError, static_cast<dawnCallbackUserdata>(reinterpret_cast<uintptr_t>(this)));
device.SetErrorCallback(ValidationTest::OnDeviceError, static_cast<DawnCallbackUserdata>(reinterpret_cast<uintptr_t>(this)));
}
ValidationTest::~ValidationTest() {
@@ -85,7 +85,7 @@ std::string ValidationTest::GetLastDeviceErrorMessage() const {
}
// static
void ValidationTest::OnDeviceError(const char* message, dawnCallbackUserdata userdata) {
void ValidationTest::OnDeviceError(const char* message, DawnCallbackUserdata userdata) {
auto self = reinterpret_cast<ValidationTest*>(static_cast<uintptr_t>(userdata));
self->mDeviceErrorMessage = message;
@@ -102,7 +102,7 @@ void ValidationTest::OnDeviceError(const char* message, dawnCallbackUserdata use
}
// static
void ValidationTest::OnBuilderErrorStatus(dawnBuilderErrorStatus status, const char* message, dawn::CallbackUserdata userdata1, dawn::CallbackUserdata userdata2) {
void ValidationTest::OnBuilderErrorStatus(DawnBuilderErrorStatus status, const char* message, dawn::CallbackUserdata userdata1, dawn::CallbackUserdata userdata2) {
auto* self = reinterpret_cast<ValidationTest*>(static_cast<uintptr_t>(userdata1));
size_t index = static_cast<size_t>(userdata2);

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

@@ -74,7 +74,7 @@ class ValidationTest : public testing::Test {
private:
std::unique_ptr<dawn_native::Instance> mInstance;
static void OnDeviceError(const char* message, dawnCallbackUserdata userdata);
static void OnDeviceError(const char* message, DawnCallbackUserdata userdata);
std::string mDeviceErrorMessage;
bool mExpectError = false;
bool mError = false;
@@ -85,14 +85,14 @@ class ValidationTest : public testing::Test {
bool gotStatus = false;
std::string statusMessage;
dawnBuilderErrorStatus status;
DawnBuilderErrorStatus status;
};
std::vector<BuilderStatusExpectations> mExpectations;
template<typename Builder>
Builder AddExpectation(Builder& builder, std::string debugName, bool expectSuccess);
static void OnBuilderErrorStatus(dawnBuilderErrorStatus status, const char* message, dawn::CallbackUserdata userdata1, dawn::CallbackUserdata userdata2);
static void OnBuilderErrorStatus(DawnBuilderErrorStatus status, const char* message, dawn::CallbackUserdata userdata1, dawn::CallbackUserdata userdata2);
};
// Template implementation details

110
src/tests/unittests/wire/WireArgumentTests.cpp
View File

@@ -28,14 +28,14 @@ class WireArgumentTests : public WireTest {
// Test that the wire is able to send numerical values
TEST_F(WireArgumentTests, ValueArgument) {
dawnCommandEncoder encoder = dawnDeviceCreateCommandEncoder(device);
dawnComputePassEncoder pass = dawnCommandEncoderBeginComputePass(encoder);
DawnCommandEncoder encoder = dawnDeviceCreateCommandEncoder(device);
DawnComputePassEncoder pass = dawnCommandEncoderBeginComputePass(encoder);
dawnComputePassEncoderDispatch(pass, 1, 2, 3);
dawnCommandEncoder apiEncoder = api.GetNewCommandEncoder();
DawnCommandEncoder apiEncoder = api.GetNewCommandEncoder();
EXPECT_CALL(api, DeviceCreateCommandEncoder(apiDevice)).WillOnce(Return(apiEncoder));
dawnComputePassEncoder apiPass = api.GetNewComputePassEncoder();
DawnComputePassEncoder apiPass = api.GetNewComputePassEncoder();
EXPECT_CALL(api, CommandEncoderBeginComputePass(apiEncoder)).WillOnce(Return(apiPass));
EXPECT_CALL(api, ComputePassEncoderDispatch(apiPass, 1, 2, 3)).Times(1);
@@ -58,15 +58,15 @@ bool CheckPushConstantValues(const uint32_t* values) {
}
TEST_F(WireArgumentTests, ValueArrayArgument) {
dawnCommandEncoder encoder = dawnDeviceCreateCommandEncoder(device);
dawnComputePassEncoder pass = dawnCommandEncoderBeginComputePass(encoder);
DawnCommandEncoder encoder = dawnDeviceCreateCommandEncoder(device);
DawnComputePassEncoder pass = dawnCommandEncoderBeginComputePass(encoder);
dawnComputePassEncoderSetPushConstants(pass, DAWN_SHADER_STAGE_BIT_VERTEX, 0, 4,
testPushConstantValues);
dawnCommandEncoder apiEncoder = api.GetNewCommandEncoder();
DawnCommandEncoder apiEncoder = api.GetNewCommandEncoder();
EXPECT_CALL(api, DeviceCreateCommandEncoder(apiDevice)).WillOnce(Return(apiEncoder));
dawnComputePassEncoder apiPass = api.GetNewComputePassEncoder();
DawnComputePassEncoder apiPass = api.GetNewComputePassEncoder();
EXPECT_CALL(api, CommandEncoderBeginComputePass(apiEncoder)).WillOnce(Return(apiPass));
EXPECT_CALL(api,
@@ -81,19 +81,19 @@ TEST_F(WireArgumentTests, ValueArrayArgument) {
// Test that the wire is able to send C strings
TEST_F(WireArgumentTests, CStringArgument) {
// Create shader module
dawnShaderModuleDescriptor vertexDescriptor;
DawnShaderModuleDescriptor vertexDescriptor;
vertexDescriptor.nextInChain = nullptr;
vertexDescriptor.codeSize = 0;
dawnShaderModule vsModule = dawnDeviceCreateShaderModule(device, &vertexDescriptor);
dawnShaderModule apiVsModule = api.GetNewShaderModule();
DawnShaderModule vsModule = dawnDeviceCreateShaderModule(device, &vertexDescriptor);
DawnShaderModule apiVsModule = api.GetNewShaderModule();
EXPECT_CALL(api, DeviceCreateShaderModule(apiDevice, _)).WillOnce(Return(apiVsModule));
// Create the color state descriptor
dawnBlendDescriptor blendDescriptor;
DawnBlendDescriptor blendDescriptor;
blendDescriptor.operation = DAWN_BLEND_OPERATION_ADD;
blendDescriptor.srcFactor = DAWN_BLEND_FACTOR_ONE;
blendDescriptor.dstFactor = DAWN_BLEND_FACTOR_ONE;
dawnColorStateDescriptor colorStateDescriptor;
DawnColorStateDescriptor colorStateDescriptor;
colorStateDescriptor.nextInChain = nullptr;
colorStateDescriptor.format = DAWN_TEXTURE_FORMAT_R8_G8_B8_A8_UNORM;
colorStateDescriptor.alphaBlend = blendDescriptor;
@@ -101,24 +101,24 @@ TEST_F(WireArgumentTests, CStringArgument) {
colorStateDescriptor.colorWriteMask = DAWN_COLOR_WRITE_MASK_ALL;
// Create the input state
dawnInputStateBuilder inputStateBuilder = dawnDeviceCreateInputStateBuilder(device);
dawnInputStateBuilder apiInputStateBuilder = api.GetNewInputStateBuilder();
DawnInputStateBuilder inputStateBuilder = dawnDeviceCreateInputStateBuilder(device);
DawnInputStateBuilder apiInputStateBuilder = api.GetNewInputStateBuilder();
EXPECT_CALL(api, DeviceCreateInputStateBuilder(apiDevice))
.WillOnce(Return(apiInputStateBuilder));
dawnInputState inputState = dawnInputStateBuilderGetResult(inputStateBuilder);
dawnInputState apiInputState = api.GetNewInputState();
DawnInputState inputState = dawnInputStateBuilderGetResult(inputStateBuilder);
DawnInputState apiInputState = api.GetNewInputState();
EXPECT_CALL(api, InputStateBuilderGetResult(apiInputStateBuilder))
.WillOnce(Return(apiInputState));
// Create the depth-stencil state
dawnStencilStateFaceDescriptor stencilFace;
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;
dawnDepthStencilStateDescriptor depthStencilState;
DawnDepthStencilStateDescriptor depthStencilState;
depthStencilState.nextInChain = nullptr;
depthStencilState.format = DAWN_TEXTURE_FORMAT_D32_FLOAT_S8_UINT;
depthStencilState.depthWriteEnabled = false;
@@ -129,32 +129,32 @@ TEST_F(WireArgumentTests, CStringArgument) {
depthStencilState.stencilWriteMask = 0xff;
// Create the pipeline layout
dawnPipelineLayoutDescriptor layoutDescriptor;
DawnPipelineLayoutDescriptor layoutDescriptor;
layoutDescriptor.nextInChain = nullptr;
layoutDescriptor.bindGroupLayoutCount = 0;
layoutDescriptor.bindGroupLayouts = nullptr;
dawnPipelineLayout layout = dawnDeviceCreatePipelineLayout(device, &layoutDescriptor);
dawnPipelineLayout apiLayout = api.GetNewPipelineLayout();
DawnPipelineLayout layout = dawnDeviceCreatePipelineLayout(device, &layoutDescriptor);
DawnPipelineLayout apiLayout = api.GetNewPipelineLayout();
EXPECT_CALL(api, DeviceCreatePipelineLayout(apiDevice, _)).WillOnce(Return(apiLayout));
// Create pipeline
dawnRenderPipelineDescriptor pipelineDescriptor;
DawnRenderPipelineDescriptor pipelineDescriptor;
pipelineDescriptor.nextInChain = nullptr;
dawnPipelineStageDescriptor vertexStage;
DawnPipelineStageDescriptor vertexStage;
vertexStage.nextInChain = nullptr;
vertexStage.module = vsModule;
vertexStage.entryPoint = "main";
pipelineDescriptor.vertexStage = &vertexStage;
dawnPipelineStageDescriptor fragmentStage;
DawnPipelineStageDescriptor fragmentStage;
fragmentStage.nextInChain = nullptr;
fragmentStage.module = vsModule;
fragmentStage.entryPoint = "main";
pipelineDescriptor.fragmentStage = &fragmentStage;
pipelineDescriptor.colorStateCount = 1;
dawnColorStateDescriptor* colorStatesPtr[] = {&colorStateDescriptor};
DawnColorStateDescriptor* colorStatesPtr[] = {&colorStateDescriptor};
pipelineDescriptor.colorStates = colorStatesPtr;
pipelineDescriptor.sampleCount = 1;
@@ -167,7 +167,7 @@ TEST_F(WireArgumentTests, CStringArgument) {
dawnDeviceCreateRenderPipeline(device, &pipelineDescriptor);
EXPECT_CALL(api,
DeviceCreateRenderPipeline(
apiDevice, MatchesLambda([](const dawnRenderPipelineDescriptor* desc) -> bool {
apiDevice, MatchesLambda([](const DawnRenderPipelineDescriptor* desc) -> bool {
return desc->vertexStage->entryPoint == std::string("main");
})))
.WillOnce(Return(nullptr));
@@ -182,18 +182,18 @@ TEST_F(WireArgumentTests, CStringArgument) {
// Test that the wire is able to send objects as value arguments
TEST_F(WireArgumentTests, ObjectAsValueArgument) {
dawnCommandEncoder cmdBufEncoder = dawnDeviceCreateCommandEncoder(device);
dawnCommandEncoder apiEncoder = api.GetNewCommandEncoder();
DawnCommandEncoder cmdBufEncoder = dawnDeviceCreateCommandEncoder(device);
DawnCommandEncoder apiEncoder = api.GetNewCommandEncoder();
EXPECT_CALL(api, DeviceCreateCommandEncoder(apiDevice)).WillOnce(Return(apiEncoder));
dawnBufferDescriptor descriptor;
DawnBufferDescriptor descriptor;
descriptor.nextInChain = nullptr;
descriptor.size = 8;
descriptor.usage = static_cast<dawnBufferUsageBit>(DAWN_BUFFER_USAGE_BIT_TRANSFER_SRC |
descriptor.usage = static_cast<DawnBufferUsageBit>(DAWN_BUFFER_USAGE_BIT_TRANSFER_SRC |
DAWN_BUFFER_USAGE_BIT_TRANSFER_DST);
dawnBuffer buffer = dawnDeviceCreateBuffer(device, &descriptor);
dawnBuffer apiBuffer = api.GetNewBuffer();
DawnBuffer buffer = dawnDeviceCreateBuffer(device, &descriptor);
DawnBuffer apiBuffer = api.GetNewBuffer();
EXPECT_CALL(api, DeviceCreateBuffer(apiDevice, _))
.WillOnce(Return(apiBuffer))
.RetiresOnSaturation();
@@ -209,17 +209,17 @@ TEST_F(WireArgumentTests, ObjectAsValueArgument) {
// Test that the wire is able to send array of objects
TEST_F(WireArgumentTests, ObjectsAsPointerArgument) {
dawnCommandBuffer cmdBufs[2];
dawnCommandBuffer apiCmdBufs[2];
DawnCommandBuffer cmdBufs[2];
DawnCommandBuffer 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);
DawnCommandEncoder cmdBufEncoder = dawnDeviceCreateCommandEncoder(device);
cmdBufs[i] = dawnCommandEncoderFinish(cmdBufEncoder);
dawnCommandEncoder apiCmdBufEncoder = api.GetNewCommandEncoder();
DawnCommandEncoder apiCmdBufEncoder = api.GetNewCommandEncoder();
EXPECT_CALL(api, DeviceCreateCommandEncoder(apiDevice))
.InSequence(s)
.WillOnce(Return(apiCmdBufEncoder));
@@ -232,15 +232,15 @@ TEST_F(WireArgumentTests, ObjectsAsPointerArgument) {
}
// Create queue
dawnQueue queue = dawnDeviceCreateQueue(device);
dawnQueue apiQueue = api.GetNewQueue();
DawnQueue queue = dawnDeviceCreateQueue(device);
DawnQueue 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);
EXPECT_CALL(
api, QueueSubmit(apiQueue, 2, MatchesLambda([=](const dawnCommandBuffer* cmdBufs) -> bool {
api, QueueSubmit(apiQueue, 2, MatchesLambda([=](const DawnCommandBuffer* cmdBufs) -> bool {
return cmdBufs[0] == apiCmdBufs[0] && cmdBufs[1] == apiCmdBufs[1];
})));
@@ -250,7 +250,7 @@ TEST_F(WireArgumentTests, ObjectsAsPointerArgument) {
// Test that the wire is able to send structures that contain pure values (non-objects)
TEST_F(WireArgumentTests, StructureOfValuesArgument) {
dawnSamplerDescriptor descriptor;
DawnSamplerDescriptor descriptor;
descriptor.nextInChain = nullptr;
descriptor.magFilter = DAWN_FILTER_MODE_LINEAR;
descriptor.minFilter = DAWN_FILTER_MODE_NEAREST;
@@ -265,7 +265,7 @@ TEST_F(WireArgumentTests, StructureOfValuesArgument) {
dawnDeviceCreateSampler(device, &descriptor);
EXPECT_CALL(api, DeviceCreateSampler(
apiDevice, MatchesLambda([](const dawnSamplerDescriptor* desc) -> bool {
apiDevice, MatchesLambda([](const DawnSamplerDescriptor* desc) -> bool {
return desc->nextInChain == nullptr &&
desc->magFilter == DAWN_FILTER_MODE_LINEAR &&
desc->minFilter == DAWN_FILTER_MODE_NEAREST &&
@@ -284,15 +284,15 @@ TEST_F(WireArgumentTests, StructureOfValuesArgument) {
// Test that the wire is able to send structures that contain objects
TEST_F(WireArgumentTests, StructureOfObjectArrayArgument) {
dawnBindGroupLayoutDescriptor bglDescriptor;
DawnBindGroupLayoutDescriptor bglDescriptor;
bglDescriptor.bindingCount = 0;
bglDescriptor.bindings = nullptr;
dawnBindGroupLayout bgl = dawnDeviceCreateBindGroupLayout(device, &bglDescriptor);
dawnBindGroupLayout apiBgl = api.GetNewBindGroupLayout();
DawnBindGroupLayout bgl = dawnDeviceCreateBindGroupLayout(device, &bglDescriptor);
DawnBindGroupLayout apiBgl = api.GetNewBindGroupLayout();
EXPECT_CALL(api, DeviceCreateBindGroupLayout(apiDevice, _)).WillOnce(Return(apiBgl));
dawnPipelineLayoutDescriptor descriptor;
DawnPipelineLayoutDescriptor descriptor;
descriptor.nextInChain = nullptr;
descriptor.bindGroupLayoutCount = 1;
descriptor.bindGroupLayouts = &bgl;
@@ -300,7 +300,7 @@ TEST_F(WireArgumentTests, StructureOfObjectArrayArgument) {
dawnDeviceCreatePipelineLayout(device, &descriptor);
EXPECT_CALL(api, DeviceCreatePipelineLayout(
apiDevice,
MatchesLambda([apiBgl](const dawnPipelineLayoutDescriptor* desc) -> bool {
MatchesLambda([apiBgl](const DawnPipelineLayoutDescriptor* desc) -> bool {
return desc->nextInChain == nullptr &&
desc->bindGroupLayoutCount == 1 &&
desc->bindGroupLayouts[0] == apiBgl;
@@ -314,24 +314,24 @@ TEST_F(WireArgumentTests, StructureOfObjectArrayArgument) {
// Test that the wire is able to send structures that contain objects
TEST_F(WireArgumentTests, StructureOfStructureArrayArgument) {
static constexpr int NUM_BINDINGS = 3;
dawnBindGroupLayoutBinding bindings[NUM_BINDINGS]{
DawnBindGroupLayoutBinding bindings[NUM_BINDINGS]{
{0, DAWN_SHADER_STAGE_BIT_VERTEX, DAWN_BINDING_TYPE_SAMPLER},
{1, DAWN_SHADER_STAGE_BIT_VERTEX, DAWN_BINDING_TYPE_SAMPLED_TEXTURE},
{2,
static_cast<dawnShaderStageBit>(DAWN_SHADER_STAGE_BIT_VERTEX |
static_cast<DawnShaderStageBit>(DAWN_SHADER_STAGE_BIT_VERTEX |
DAWN_SHADER_STAGE_BIT_FRAGMENT),
DAWN_BINDING_TYPE_UNIFORM_BUFFER},
};
dawnBindGroupLayoutDescriptor bglDescriptor;
DawnBindGroupLayoutDescriptor bglDescriptor;
bglDescriptor.bindingCount = NUM_BINDINGS;
bglDescriptor.bindings = bindings;
dawnDeviceCreateBindGroupLayout(device, &bglDescriptor);
dawnBindGroupLayout apiBgl = api.GetNewBindGroupLayout();
DawnBindGroupLayout apiBgl = api.GetNewBindGroupLayout();
EXPECT_CALL(
api,
DeviceCreateBindGroupLayout(
apiDevice, MatchesLambda([bindings](const dawnBindGroupLayoutDescriptor* desc) -> bool {
apiDevice, MatchesLambda([bindings](const DawnBindGroupLayoutDescriptor* desc) -> bool {
for (int i = 0; i < NUM_BINDINGS; ++i) {
const auto& a = desc->bindings[i];
const auto& b = bindings[i];
@@ -350,9 +350,9 @@ TEST_F(WireArgumentTests, StructureOfStructureArrayArgument) {
// Test passing nullptr instead of objects - array of objects version
TEST_F(WireArgumentTests, DISABLED_NullptrInArray) {
dawnBindGroupLayout nullBGL = nullptr;
DawnBindGroupLayout nullBGL = nullptr;
dawnPipelineLayoutDescriptor descriptor;
DawnPipelineLayoutDescriptor descriptor;
descriptor.nextInChain = nullptr;
descriptor.bindGroupLayoutCount = 1;
descriptor.bindGroupLayouts = &nullBGL;
@@ -360,7 +360,7 @@ TEST_F(WireArgumentTests, DISABLED_NullptrInArray) {
dawnDeviceCreatePipelineLayout(device, &descriptor);
EXPECT_CALL(api,
DeviceCreatePipelineLayout(
apiDevice, MatchesLambda([](const dawnPipelineLayoutDescriptor* desc) -> bool {
apiDevice, MatchesLambda([](const DawnPipelineLayoutDescriptor* desc) -> bool {
return desc->nextInChain == nullptr && desc->bindGroupLayoutCount == 1 &&
desc->bindGroupLayouts[0] == nullptr;
})))

16
src/tests/unittests/wire/WireBasicTests.cpp
View File

@@ -28,7 +28,7 @@ class WireBasicTests : public WireTest {
TEST_F(WireBasicTests, CallForwarded) {
dawnDeviceCreateCommandEncoder(device);
dawnCommandEncoder apiCmdBufEncoder = api.GetNewCommandEncoder();
DawnCommandEncoder apiCmdBufEncoder = api.GetNewCommandEncoder();
EXPECT_CALL(api, DeviceCreateCommandEncoder(apiDevice))
.WillOnce(Return(apiCmdBufEncoder));
@@ -38,14 +38,14 @@ TEST_F(WireBasicTests, CallForwarded) {
// Test that calling methods on a new object works as expected.
TEST_F(WireBasicTests, CreateThenCall) {
dawnCommandEncoder encoder = dawnDeviceCreateCommandEncoder(device);
DawnCommandEncoder encoder = dawnDeviceCreateCommandEncoder(device);
dawnCommandEncoderFinish(encoder);
dawnCommandEncoder apiCmdBufEncoder = api.GetNewCommandEncoder();
DawnCommandEncoder apiCmdBufEncoder = api.GetNewCommandEncoder();
EXPECT_CALL(api, DeviceCreateCommandEncoder(apiDevice))
.WillOnce(Return(apiCmdBufEncoder));
dawnCommandBuffer apiCmdBuf = api.GetNewCommandBuffer();
DawnCommandBuffer apiCmdBuf = api.GetNewCommandBuffer();
EXPECT_CALL(api, CommandEncoderFinish(apiCmdBufEncoder)).WillOnce(Return(apiCmdBuf));
EXPECT_CALL(api, CommandEncoderRelease(apiCmdBufEncoder));
@@ -55,12 +55,12 @@ TEST_F(WireBasicTests, CreateThenCall) {
// Test that client reference/release do not call the backend API.
TEST_F(WireBasicTests, RefCountKeptInClient) {
dawnCommandEncoder encoder = dawnDeviceCreateCommandEncoder(device);
DawnCommandEncoder encoder = dawnDeviceCreateCommandEncoder(device);
dawnCommandEncoderReference(encoder);
dawnCommandEncoderRelease(encoder);
dawnCommandEncoder apiCmdBufEncoder = api.GetNewCommandEncoder();
DawnCommandEncoder apiCmdBufEncoder = api.GetNewCommandEncoder();
EXPECT_CALL(api, DeviceCreateCommandEncoder(apiDevice))
.WillOnce(Return(apiCmdBufEncoder));
EXPECT_CALL(api, CommandEncoderRelease(apiCmdBufEncoder));
@@ -70,11 +70,11 @@ TEST_F(WireBasicTests, RefCountKeptInClient) {
// Test that client reference/release do not call the backend API.
TEST_F(WireBasicTests, ReleaseCalledOnRefCount0) {
dawnCommandEncoder encoder = dawnDeviceCreateCommandEncoder(device);
DawnCommandEncoder encoder = dawnDeviceCreateCommandEncoder(device);
dawnCommandEncoderRelease(encoder);
dawnCommandEncoder apiCmdBufEncoder = api.GetNewCommandEncoder();
DawnCommandEncoder apiCmdBufEncoder = api.GetNewCommandEncoder();
EXPECT_CALL(api, DeviceCreateCommandEncoder(apiDevice))
.WillOnce(Return(apiCmdBufEncoder));

58
src/tests/unittests/wire/WireBufferMappingTests.cpp
View File

@@ -23,17 +23,17 @@ namespace {
class MockBufferMapReadCallback {
public:
MOCK_METHOD4(Call,
void(dawnBufferMapAsyncStatus status,
void(DawnBufferMapAsyncStatus status,
const uint32_t* ptr,
uint32_t dataLength,
dawnCallbackUserdata userdata));
DawnCallbackUserdata userdata));
};
std::unique_ptr<MockBufferMapReadCallback> mockBufferMapReadCallback;
void ToMockBufferMapReadCallback(dawnBufferMapAsyncStatus status,
void ToMockBufferMapReadCallback(DawnBufferMapAsyncStatus status,
const void* ptr,
uint32_t dataLength,
dawnCallbackUserdata userdata) {
DawnCallbackUserdata userdata) {
// Assume the data is uint32_t to make writing matchers easier
mockBufferMapReadCallback->Call(status, static_cast<const uint32_t*>(ptr), dataLength,
userdata);
@@ -42,18 +42,18 @@ namespace {
class MockBufferMapWriteCallback {
public:
MOCK_METHOD4(Call,
void(dawnBufferMapAsyncStatus status,
void(DawnBufferMapAsyncStatus status,
uint32_t* ptr,
uint32_t dataLength,
dawnCallbackUserdata userdata));
DawnCallbackUserdata userdata));
};
std::unique_ptr<MockBufferMapWriteCallback> mockBufferMapWriteCallback;
uint32_t* lastMapWritePointer = nullptr;
void ToMockBufferMapWriteCallback(dawnBufferMapAsyncStatus status,
void ToMockBufferMapWriteCallback(DawnBufferMapAsyncStatus status,
void* ptr,
uint32_t dataLength,
dawnCallbackUserdata userdata) {
DawnCallbackUserdata userdata) {
// Assume the data is uint32_t to make writing matchers easier
lastMapWritePointer = static_cast<uint32_t*>(ptr);
mockBufferMapWriteCallback->Call(status, lastMapWritePointer, dataLength, userdata);
@@ -74,7 +74,7 @@ class WireBufferMappingTests : public WireTest {
mockBufferMapWriteCallback = std::make_unique<MockBufferMapWriteCallback>();
{
dawnBufferDescriptor descriptor;
DawnBufferDescriptor descriptor;
descriptor.nextInChain = nullptr;
apiBuffer = api.GetNewBuffer();
@@ -87,7 +87,7 @@ class WireBufferMappingTests : public WireTest {
FlushClient();
}
{
dawnBufferDescriptor descriptor;
DawnBufferDescriptor descriptor;
descriptor.nextInChain = nullptr;
errorBuffer = dawnDeviceCreateBuffer(device, &descriptor);
@@ -109,18 +109,18 @@ class WireBufferMappingTests : public WireTest {
protected:
// A successfully created buffer
dawnBuffer buffer;
dawnBuffer apiBuffer;
DawnBuffer buffer;
DawnBuffer apiBuffer;
// An buffer that wasn't created on the server side
dawnBuffer errorBuffer;
DawnBuffer errorBuffer;
};
// MapRead-specific tests
// Check mapping for reading a succesfully created buffer
TEST_F(WireBufferMappingTests, MappingForReadSuccessBuffer) {
dawnCallbackUserdata userdata = 8653;
DawnCallbackUserdata userdata = 8653;
dawnBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, userdata);
uint32_t bufferContent = 31337;
@@ -148,7 +148,7 @@ TEST_F(WireBufferMappingTests, MappingForReadSuccessBuffer) {
// Check that things work correctly when a validation error happens when mapping the buffer for
// reading
TEST_F(WireBufferMappingTests, ErrorWhileMappingForRead) {
dawnCallbackUserdata userdata = 8654;
DawnCallbackUserdata userdata = 8654;
dawnBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, userdata);
EXPECT_CALL(api, OnBufferMapReadAsyncCallback(apiBuffer, _, _))
@@ -167,7 +167,7 @@ TEST_F(WireBufferMappingTests, ErrorWhileMappingForRead) {
// Check mapping for reading a buffer that didn't get created on the server side
TEST_F(WireBufferMappingTests, MappingForReadErrorBuffer) {
dawnCallbackUserdata userdata = 8655;
DawnCallbackUserdata userdata = 8655;
dawnBufferMapReadAsync(errorBuffer, ToMockBufferMapReadCallback, userdata);
FlushClient();
@@ -186,7 +186,7 @@ TEST_F(WireBufferMappingTests, MappingForReadErrorBuffer) {
// Check that the map read callback is called with UNKNOWN when the buffer is destroyed before the
// request is finished
TEST_F(WireBufferMappingTests, DestroyBeforeReadRequestEnd) {
dawnCallbackUserdata userdata = 8656;
DawnCallbackUserdata userdata = 8656;
dawnBufferMapReadAsync(errorBuffer, ToMockBufferMapReadCallback, userdata);
EXPECT_CALL(*mockBufferMapReadCallback,
@@ -199,7 +199,7 @@ TEST_F(WireBufferMappingTests, DestroyBeforeReadRequestEnd) {
// Check the map read callback is called with UNKNOWN when the map request would have worked, but
// Unmap was called
TEST_F(WireBufferMappingTests, UnmapCalledTooEarlyForRead) {
dawnCallbackUserdata userdata = 8657;
DawnCallbackUserdata userdata = 8657;
dawnBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, userdata);
uint32_t bufferContent = 31337;
@@ -224,7 +224,7 @@ TEST_F(WireBufferMappingTests, UnmapCalledTooEarlyForRead) {
// Check that an error map read callback gets nullptr while a buffer is already mapped
TEST_F(WireBufferMappingTests, MappingForReadingErrorWhileAlreadyMappedGetsNullptr) {
// Successful map
dawnCallbackUserdata userdata = 34098;
DawnCallbackUserdata userdata = 34098;
dawnBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, userdata);
uint32_t bufferContent = 31337;
@@ -263,7 +263,7 @@ TEST_F(WireBufferMappingTests, MappingForReadingErrorWhileAlreadyMappedGetsNullp
// Test that the MapReadCallback isn't fired twice when unmap() is called inside the callback
TEST_F(WireBufferMappingTests, UnmapInsideMapReadCallback) {
dawnCallbackUserdata userdata = 2039;
DawnCallbackUserdata userdata = 2039;
dawnBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, userdata);
uint32_t bufferContent = 31337;
@@ -290,7 +290,7 @@ TEST_F(WireBufferMappingTests, UnmapInsideMapReadCallback) {
// Test that the MapReadCallback isn't fired twice the buffer external refcount reaches 0 in the
// callback
TEST_F(WireBufferMappingTests, DestroyInsideMapReadCallback) {
dawnCallbackUserdata userdata = 2039;
DawnCallbackUserdata userdata = 2039;
dawnBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, userdata);
uint32_t bufferContent = 31337;
@@ -316,7 +316,7 @@ TEST_F(WireBufferMappingTests, DestroyInsideMapReadCallback) {
// Check mapping for writing a succesfully created buffer
TEST_F(WireBufferMappingTests, MappingForWriteSuccessBuffer) {
dawnCallbackUserdata userdata = 8653;
DawnCallbackUserdata userdata = 8653;
dawnBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, userdata);
uint32_t serverBufferContent = 31337;
@@ -353,7 +353,7 @@ TEST_F(WireBufferMappingTests, MappingForWriteSuccessBuffer) {
// Check that things work correctly when a validation error happens when mapping the buffer for
// writing
TEST_F(WireBufferMappingTests, ErrorWhileMappingForWrite) {
dawnCallbackUserdata userdata = 8654;
DawnCallbackUserdata userdata = 8654;
dawnBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, userdata);
EXPECT_CALL(api, OnBufferMapWriteAsyncCallback(apiBuffer, _, _))
@@ -372,7 +372,7 @@ TEST_F(WireBufferMappingTests, ErrorWhileMappingForWrite) {
// Check mapping for writing a buffer that didn't get created on the server side
TEST_F(WireBufferMappingTests, MappingForWriteErrorBuffer) {
dawnCallbackUserdata userdata = 8655;
DawnCallbackUserdata userdata = 8655;
dawnBufferMapWriteAsync(errorBuffer, ToMockBufferMapWriteCallback, userdata);
FlushClient();
@@ -391,7 +391,7 @@ TEST_F(WireBufferMappingTests, MappingForWriteErrorBuffer) {
// Check that the map write callback is called with UNKNOWN when the buffer is destroyed before the
// request is finished
TEST_F(WireBufferMappingTests, DestroyBeforeWriteRequestEnd) {
dawnCallbackUserdata userdata = 8656;
DawnCallbackUserdata userdata = 8656;
dawnBufferMapWriteAsync(errorBuffer, ToMockBufferMapWriteCallback, userdata);
EXPECT_CALL(*mockBufferMapWriteCallback,
@@ -404,7 +404,7 @@ TEST_F(WireBufferMappingTests, DestroyBeforeWriteRequestEnd) {
// Check the map read callback is called with UNKNOWN when the map request would have worked, but
// Unmap was called
TEST_F(WireBufferMappingTests, UnmapCalledTooEarlyForWrite) {
dawnCallbackUserdata userdata = 8657;
DawnCallbackUserdata userdata = 8657;
dawnBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, userdata);
uint32_t bufferContent = 31337;
@@ -429,7 +429,7 @@ TEST_F(WireBufferMappingTests, UnmapCalledTooEarlyForWrite) {
// Check that an error map read callback gets nullptr while a buffer is already mapped
TEST_F(WireBufferMappingTests, MappingForWritingErrorWhileAlreadyMappedGetsNullptr) {
// Successful map
dawnCallbackUserdata userdata = 34098;
DawnCallbackUserdata userdata = 34098;
dawnBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, userdata);
uint32_t bufferContent = 31337;
@@ -468,7 +468,7 @@ TEST_F(WireBufferMappingTests, MappingForWritingErrorWhileAlreadyMappedGetsNullp
// Test that the MapWriteCallback isn't fired twice when unmap() is called inside the callback
TEST_F(WireBufferMappingTests, UnmapInsideMapWriteCallback) {
dawnCallbackUserdata userdata = 2039;
DawnCallbackUserdata userdata = 2039;
dawnBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, userdata);
uint32_t bufferContent = 31337;
@@ -495,7 +495,7 @@ TEST_F(WireBufferMappingTests, UnmapInsideMapWriteCallback) {
// Test that the MapWriteCallback isn't fired twice the buffer external refcount reaches 0 in the
// callback
TEST_F(WireBufferMappingTests, DestroyInsideMapWriteCallback) {
dawnCallbackUserdata userdata = 2039;
DawnCallbackUserdata userdata = 2039;
dawnBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, userdata);
uint32_t bufferContent = 31337;

54
src/tests/unittests/wire/WireCallbackTests.cpp
View File

@@ -22,28 +22,28 @@ namespace {
// Mock classes to add expectations on the wire calling callbacks
class MockDeviceErrorCallback {
public:
MOCK_METHOD2(Call, void(const char* message, dawnCallbackUserdata userdata));
MOCK_METHOD2(Call, void(const char* message, DawnCallbackUserdata userdata));
};
std::unique_ptr<MockDeviceErrorCallback> mockDeviceErrorCallback;
void ToMockDeviceErrorCallback(const char* message, dawnCallbackUserdata userdata) {
void ToMockDeviceErrorCallback(const char* message, DawnCallbackUserdata userdata) {
mockDeviceErrorCallback->Call(message, userdata);
}
class MockBuilderErrorCallback {
public:
MOCK_METHOD4(Call,
void(dawnBuilderErrorStatus status,
void(DawnBuilderErrorStatus status,
const char* message,
dawnCallbackUserdata userdata1,
dawnCallbackUserdata userdata2));
DawnCallbackUserdata userdata1,
DawnCallbackUserdata userdata2));
};
std::unique_ptr<MockBuilderErrorCallback> mockBuilderErrorCallback;
void ToMockBuilderErrorCallback(dawnBuilderErrorStatus status,
void ToMockBuilderErrorCallback(DawnBuilderErrorStatus status,
const char* message,
dawnCallbackUserdata userdata1,
dawnCallbackUserdata userdata2) {
DawnCallbackUserdata userdata1,
DawnCallbackUserdata userdata2) {
mockBuilderErrorCallback->Call(status, message, userdata1, userdata2);
}
@@ -73,17 +73,17 @@ class WireCallbackTests : public WireTest {
// Test that we get a success builder error status when no error happens
TEST_F(WireCallbackTests, SuccessCallbackOnBuilderSuccess) {
dawnBufferBuilder bufferBuilder = dawnDeviceCreateBufferBuilderForTesting(device);
DawnBufferBuilder bufferBuilder = dawnDeviceCreateBufferBuilderForTesting(device);
dawnBufferBuilderSetErrorCallback(bufferBuilder, ToMockBuilderErrorCallback, 1, 2);
dawnBufferBuilderGetResult(bufferBuilder);
dawnBufferBuilder apiBufferBuilder = api.GetNewBufferBuilder();
DawnBufferBuilder apiBufferBuilder = api.GetNewBufferBuilder();
EXPECT_CALL(api, DeviceCreateBufferBuilderForTesting(apiDevice))
.WillOnce(Return(apiBufferBuilder));
dawnBuffer apiBuffer = api.GetNewBuffer();
DawnBuffer apiBuffer = api.GetNewBuffer();
EXPECT_CALL(api, BufferBuilderGetResult(apiBufferBuilder))
.WillOnce(InvokeWithoutArgs([&]() -> dawnBuffer {
.WillOnce(InvokeWithoutArgs([&]() -> DawnBuffer {
api.CallBuilderErrorCallback(apiBufferBuilder, DAWN_BUILDER_ERROR_STATUS_SUCCESS,
"I like cheese");
return apiBuffer;
@@ -103,7 +103,7 @@ TEST_F(WireCallbackTests, SuccessCallbackOnBuilderSuccess) {
TEST_F(WireCallbackTests, UnknownBuilderErrorStatusCallback) {
// The builder is destroyed before the object is built
{
dawnBufferBuilder bufferBuilder = dawnDeviceCreateBufferBuilderForTesting(device);
DawnBufferBuilder bufferBuilder = dawnDeviceCreateBufferBuilderForTesting(device);
dawnBufferBuilderSetErrorCallback(bufferBuilder, ToMockBuilderErrorCallback, 1, 2);
EXPECT_CALL(*mockBuilderErrorCallback, Call(DAWN_BUILDER_ERROR_STATUS_UNKNOWN, _, 1, 2))
@@ -114,7 +114,7 @@ TEST_F(WireCallbackTests, UnknownBuilderErrorStatusCallback) {
// If the builder has been consumed, it doesn't fire the callback with unknown
{
dawnBufferBuilder bufferBuilder = dawnDeviceCreateBufferBuilderForTesting(device);
DawnBufferBuilder bufferBuilder = dawnDeviceCreateBufferBuilderForTesting(device);
dawnBufferBuilderSetErrorCallback(bufferBuilder, ToMockBuilderErrorCallback, 3, 4);
dawnBufferBuilderGetResult(bufferBuilder);
@@ -127,9 +127,9 @@ TEST_F(WireCallbackTests, UnknownBuilderErrorStatusCallback) {
// If the builder has been consumed, and the object is destroyed before the result comes from
// the server, then the callback is fired with unknown
{
dawnBufferBuilder bufferBuilder = dawnDeviceCreateBufferBuilderForTesting(device);
DawnBufferBuilder bufferBuilder = dawnDeviceCreateBufferBuilderForTesting(device);
dawnBufferBuilderSetErrorCallback(bufferBuilder, ToMockBuilderErrorCallback, 5, 6);
dawnBuffer buffer = dawnBufferBuilderGetResult(bufferBuilder);
DawnBuffer buffer = dawnBufferBuilderGetResult(bufferBuilder);
EXPECT_CALL(*mockBuilderErrorCallback, Call(DAWN_BUILDER_ERROR_STATUS_UNKNOWN, _, 5, 6))
.Times(1);
@@ -142,16 +142,16 @@ TEST_F(WireCallbackTests, UnknownBuilderErrorStatusCallback) {
TEST_F(WireCallbackTests, SuccessCallbackNotForwardedToDevice) {
dawnDeviceSetErrorCallback(device, ToMockDeviceErrorCallback, 0);
dawnBufferBuilder bufferBuilder = dawnDeviceCreateBufferBuilderForTesting(device);
DawnBufferBuilder bufferBuilder = dawnDeviceCreateBufferBuilderForTesting(device);
dawnBufferBuilderGetResult(bufferBuilder);
dawnBufferBuilder apiBufferBuilder = api.GetNewBufferBuilder();
DawnBufferBuilder apiBufferBuilder = api.GetNewBufferBuilder();
EXPECT_CALL(api, DeviceCreateBufferBuilderForTesting(apiDevice))
.WillOnce(Return(apiBufferBuilder));
dawnBuffer apiBuffer = api.GetNewBuffer();
DawnBuffer apiBuffer = api.GetNewBuffer();
EXPECT_CALL(api, BufferBuilderGetResult(apiBufferBuilder))
.WillOnce(InvokeWithoutArgs([&]() -> dawnBuffer {
.WillOnce(InvokeWithoutArgs([&]() -> DawnBuffer {
api.CallBuilderErrorCallback(apiBufferBuilder, DAWN_BUILDER_ERROR_STATUS_SUCCESS,
"I like cheese");
return apiBuffer;
@@ -168,15 +168,15 @@ TEST_F(WireCallbackTests, ErrorCallbackForwardedToDevice) {
uint64_t userdata = 30495;
dawnDeviceSetErrorCallback(device, ToMockDeviceErrorCallback, userdata);
dawnBufferBuilder bufferBuilder = dawnDeviceCreateBufferBuilderForTesting(device);
DawnBufferBuilder bufferBuilder = dawnDeviceCreateBufferBuilderForTesting(device);
dawnBufferBuilderGetResult(bufferBuilder);
dawnBufferBuilder apiBufferBuilder = api.GetNewBufferBuilder();
DawnBufferBuilder apiBufferBuilder = api.GetNewBufferBuilder();
EXPECT_CALL(api, DeviceCreateBufferBuilderForTesting(apiDevice))
.WillOnce(Return(apiBufferBuilder));
EXPECT_CALL(api, BufferBuilderGetResult(apiBufferBuilder))
.WillOnce(InvokeWithoutArgs([&]() -> dawnBuffer {
.WillOnce(InvokeWithoutArgs([&]() -> DawnBuffer {
api.CallBuilderErrorCallback(apiBufferBuilder, DAWN_BUILDER_ERROR_STATUS_ERROR,
"Error :(");
return nullptr;
@@ -213,9 +213,9 @@ TEST_F(WireCallbackTests, BuilderErrorCallback) {
uint64_t userdata2 = 982734239028;
// Create the buffer builder, the callback is set immediately on the server side
dawnBufferBuilder bufferBuilder = dawnDeviceCreateBufferBuilderForTesting(device);
DawnBufferBuilder bufferBuilder = dawnDeviceCreateBufferBuilderForTesting(device);
dawnBufferBuilder apiBufferBuilder = api.GetNewBufferBuilder();
DawnBufferBuilder apiBufferBuilder = api.GetNewBufferBuilder();
EXPECT_CALL(api, DeviceCreateBufferBuilderForTesting(apiDevice))
.WillOnce(Return(apiBufferBuilder));
@@ -231,9 +231,9 @@ TEST_F(WireCallbackTests, BuilderErrorCallback) {
// Create an object so that it is a valid case to call the error callback
dawnBufferBuilderGetResult(bufferBuilder);
dawnBuffer apiBuffer = api.GetNewBuffer();
DawnBuffer apiBuffer = api.GetNewBuffer();
EXPECT_CALL(api, BufferBuilderGetResult(apiBufferBuilder))
.WillOnce(InvokeWithoutArgs([&]() -> dawnBuffer {
.WillOnce(InvokeWithoutArgs([&]() -> DawnBuffer {
api.CallBuilderErrorCallback(apiBufferBuilder, DAWN_BUILDER_ERROR_STATUS_SUCCESS,
"Success!");
return apiBuffer;

54
src/tests/unittests/wire/WireFenceTests.cpp
View File

@@ -22,22 +22,22 @@ namespace {
// Mock classes to add expectations on the wire calling callbacks
class MockDeviceErrorCallback {
public:
MOCK_METHOD2(Call, void(const char* message, dawnCallbackUserdata userdata));
MOCK_METHOD2(Call, void(const char* message, DawnCallbackUserdata userdata));
};
std::unique_ptr<MockDeviceErrorCallback> mockDeviceErrorCallback;
void ToMockDeviceErrorCallback(const char* message, dawnCallbackUserdata userdata) {
void ToMockDeviceErrorCallback(const char* message, DawnCallbackUserdata userdata) {
mockDeviceErrorCallback->Call(message, userdata);
}
class MockFenceOnCompletionCallback {
public:
MOCK_METHOD2(Call, void(dawnFenceCompletionStatus status, dawnCallbackUserdata userdata));
MOCK_METHOD2(Call, void(DawnFenceCompletionStatus status, DawnCallbackUserdata userdata));
};
std::unique_ptr<MockFenceOnCompletionCallback> mockFenceOnCompletionCallback;
void ToMockFenceOnCompletionCallback(dawnFenceCompletionStatus status,
dawnCallbackUserdata userdata) {
void ToMockFenceOnCompletionCallback(DawnFenceCompletionStatus status,
DawnCallbackUserdata userdata) {
mockFenceOnCompletionCallback->Call(status, userdata);
}
@@ -63,7 +63,7 @@ class WireFenceTests : public WireTest {
FlushClient();
}
{
dawnFenceDescriptor descriptor;
DawnFenceDescriptor descriptor;
descriptor.initialValue = 1;
descriptor.nextInChain = nullptr;
@@ -98,11 +98,11 @@ class WireFenceTests : public WireTest {
}
// A successfully created fence
dawnFence fence;
dawnFence apiFence;
DawnFence fence;
DawnFence apiFence;
dawnQueue queue;
dawnQueue apiQueue;
DawnQueue queue;
DawnQueue apiQueue;
};
// Check that signaling a fence succeeds
@@ -116,7 +116,7 @@ TEST_F(WireFenceTests, QueueSignalSuccess) {
// Without any flushes, it is valid to signal a value greater than the current
// signaled value
TEST_F(WireFenceTests, QueueSignalSynchronousValidationSuccess) {
dawnCallbackUserdata userdata = 9157;
DawnCallbackUserdata userdata = 9157;
dawnDeviceSetErrorCallback(device, ToMockDeviceErrorCallback, userdata);
EXPECT_CALL(*mockDeviceErrorCallback, Call(_, userdata)).Times(0);
@@ -128,7 +128,7 @@ TEST_F(WireFenceTests, QueueSignalSynchronousValidationSuccess) {
// Without any flushes, errors should be generated when signaling a value less
// than or equal to the current signaled value
TEST_F(WireFenceTests, QueueSignalSynchronousValidationError) {
dawnCallbackUserdata userdata = 3157;
DawnCallbackUserdata userdata = 3157;
dawnDeviceSetErrorCallback(device, ToMockDeviceErrorCallback, userdata);
EXPECT_CALL(*mockDeviceErrorCallback, Call(_, userdata)).Times(1);
@@ -152,7 +152,7 @@ TEST_F(WireFenceTests, QueueSignalSynchronousValidationError) {
TEST_F(WireFenceTests, OnCompletionImmediate) {
// Can call on value < (initial) signaled value happens immediately
{
dawnCallbackUserdata userdata = 9847;
DawnCallbackUserdata userdata = 9847;
EXPECT_CALL(*mockFenceOnCompletionCallback,
Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, userdata))
.Times(1);
@@ -161,7 +161,7 @@ TEST_F(WireFenceTests, OnCompletionImmediate) {
// Can call on value == (initial) signaled value happens immediately
{
dawnCallbackUserdata userdata = 4347;
DawnCallbackUserdata userdata = 4347;
EXPECT_CALL(*mockFenceOnCompletionCallback,
Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, userdata))
.Times(1);
@@ -174,10 +174,10 @@ TEST_F(WireFenceTests, OnCompletionMultiple) {
DoQueueSignal(3u);
DoQueueSignal(6u);
dawnCallbackUserdata userdata0 = 2134;
dawnCallbackUserdata userdata1 = 7134;
dawnCallbackUserdata userdata2 = 3144;
dawnCallbackUserdata userdata3 = 1130;
DawnCallbackUserdata userdata0 = 2134;
DawnCallbackUserdata userdata1 = 7134;
DawnCallbackUserdata userdata2 = 3144;
DawnCallbackUserdata userdata3 = 1130;
// Add callbacks in a non-monotonic order. They should still be called
// in order of increasing fence value.
@@ -221,8 +221,8 @@ TEST_F(WireFenceTests, OnCompletionSynchronousValidationSuccess) {
// Without any flushes, errors should be generated when waiting on a value greater
// than the last signaled value
TEST_F(WireFenceTests, OnCompletionSynchronousValidationError) {
dawnCallbackUserdata userdata1 = 3817;
dawnCallbackUserdata userdata2 = 3857;
DawnCallbackUserdata userdata1 = 3817;
DawnCallbackUserdata userdata2 = 3857;
dawnDeviceSetErrorCallback(device, ToMockDeviceErrorCallback, userdata2);
EXPECT_CALL(*mockFenceOnCompletionCallback, Call(DAWN_FENCE_COMPLETION_STATUS_ERROR, userdata1))
@@ -255,7 +255,7 @@ TEST_F(WireFenceTests, GetCompletedValueNoUpdate) {
// Check that the callback is called with UNKNOWN when the fence is destroyed
// before the completed value is updated
TEST_F(WireFenceTests, DestroyBeforeOnCompletionEnd) {
dawnCallbackUserdata userdata = 8616;
DawnCallbackUserdata userdata = 8616;
dawnQueueSignal(queue, fence, 3u);
dawnFenceOnCompletion(fence, 2u, ToMockFenceOnCompletionCallback, userdata);
EXPECT_CALL(*mockFenceOnCompletionCallback,
@@ -267,13 +267,13 @@ TEST_F(WireFenceTests, DestroyBeforeOnCompletionEnd) {
// Test that signaling a fence on a wrong queue is invalid
TEST_F(WireFenceTests, SignalWrongQueue) {
dawnQueue queue2 = dawnDeviceCreateQueue(device);
dawnQueue apiQueue2 = api.GetNewQueue();
DawnQueue queue2 = dawnDeviceCreateQueue(device);
DawnQueue apiQueue2 = api.GetNewQueue();
EXPECT_CALL(api, DeviceCreateQueue(apiDevice)).WillOnce(Return(apiQueue2));
EXPECT_CALL(api, QueueRelease(apiQueue2));
FlushClient();
dawnCallbackUserdata userdata = 1520;
DawnCallbackUserdata userdata = 1520;
dawnDeviceSetErrorCallback(device, ToMockDeviceErrorCallback, userdata);
EXPECT_CALL(*mockDeviceErrorCallback, Call(_, userdata)).Times(1);
@@ -282,13 +282,13 @@ TEST_F(WireFenceTests, SignalWrongQueue) {
// 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();
DawnQueue queue2 = dawnDeviceCreateQueue(device);
DawnQueue apiQueue2 = api.GetNewQueue();
EXPECT_CALL(api, DeviceCreateQueue(apiDevice)).WillOnce(Return(apiQueue2));
EXPECT_CALL(api, QueueRelease(apiQueue2));
FlushClient();
dawnCallbackUserdata userdata = 1024;
DawnCallbackUserdata userdata = 1024;
dawnDeviceSetErrorCallback(device, ToMockDeviceErrorCallback, userdata);
EXPECT_CALL(*mockDeviceErrorCallback, Call(_, userdata)).Times(1);

52
src/tests/unittests/wire/WireOptionalTests.cpp
View File

@@ -26,23 +26,23 @@ class WireOptionalTests : public WireTest {
// Test passing nullptr instead of objects - object as value version
TEST_F(WireOptionalTests, OptionalObjectValue) {
dawnBindGroupLayoutDescriptor bglDesc;
DawnBindGroupLayoutDescriptor bglDesc;
bglDesc.nextInChain = nullptr;
bglDesc.bindingCount = 0;
dawnBindGroupLayout bgl = dawnDeviceCreateBindGroupLayout(device, &bglDesc);
DawnBindGroupLayout bgl = dawnDeviceCreateBindGroupLayout(device, &bglDesc);
dawnBindGroupLayout apiBindGroupLayout = api.GetNewBindGroupLayout();
DawnBindGroupLayout apiBindGroupLayout = api.GetNewBindGroupLayout();
EXPECT_CALL(api, DeviceCreateBindGroupLayout(apiDevice, _))
.WillOnce(Return(apiBindGroupLayout));
// The `sampler`, `textureView` and `buffer` members of a binding are optional.
dawnBindGroupBinding binding;
DawnBindGroupBinding binding;
binding.binding = 0;
binding.sampler = nullptr;
binding.textureView = nullptr;
binding.buffer = nullptr;
dawnBindGroupDescriptor bgDesc;
DawnBindGroupDescriptor bgDesc;
bgDesc.nextInChain = nullptr;
bgDesc.layout = bgl;
bgDesc.bindingCount = 1;
@@ -50,7 +50,7 @@ TEST_F(WireOptionalTests, OptionalObjectValue) {
dawnDeviceCreateBindGroup(device, &bgDesc);
EXPECT_CALL(api, DeviceCreateBindGroup(
apiDevice, MatchesLambda([](const dawnBindGroupDescriptor* desc) -> bool {
apiDevice, MatchesLambda([](const DawnBindGroupDescriptor* desc) -> bool {
return desc->nextInChain == nullptr && desc->bindingCount == 1 &&
desc->bindings[0].binding == 0 &&
desc->bindings[0].sampler == nullptr &&
@@ -66,19 +66,19 @@ TEST_F(WireOptionalTests, OptionalObjectValue) {
// Test that the wire is able to send optional pointers to structures
TEST_F(WireOptionalTests, OptionalStructPointer) {
// Create shader module
dawnShaderModuleDescriptor vertexDescriptor;
DawnShaderModuleDescriptor vertexDescriptor;
vertexDescriptor.nextInChain = nullptr;
vertexDescriptor.codeSize = 0;
dawnShaderModule vsModule = dawnDeviceCreateShaderModule(device, &vertexDescriptor);
dawnShaderModule apiVsModule = api.GetNewShaderModule();
DawnShaderModule vsModule = dawnDeviceCreateShaderModule(device, &vertexDescriptor);
DawnShaderModule apiVsModule = api.GetNewShaderModule();
EXPECT_CALL(api, DeviceCreateShaderModule(apiDevice, _)).WillOnce(Return(apiVsModule));
// Create the color state descriptor
dawnBlendDescriptor blendDescriptor;
DawnBlendDescriptor blendDescriptor;
blendDescriptor.operation = DAWN_BLEND_OPERATION_ADD;
blendDescriptor.srcFactor = DAWN_BLEND_FACTOR_ONE;
blendDescriptor.dstFactor = DAWN_BLEND_FACTOR_ONE;
dawnColorStateDescriptor colorStateDescriptor;
DawnColorStateDescriptor colorStateDescriptor;
colorStateDescriptor.nextInChain = nullptr;
colorStateDescriptor.format = DAWN_TEXTURE_FORMAT_R8_G8_B8_A8_UNORM;
colorStateDescriptor.alphaBlend = blendDescriptor;
@@ -86,24 +86,24 @@ TEST_F(WireOptionalTests, OptionalStructPointer) {
colorStateDescriptor.colorWriteMask = DAWN_COLOR_WRITE_MASK_ALL;
// Create the input state
dawnInputStateBuilder inputStateBuilder = dawnDeviceCreateInputStateBuilder(device);
dawnInputStateBuilder apiInputStateBuilder = api.GetNewInputStateBuilder();
DawnInputStateBuilder inputStateBuilder = dawnDeviceCreateInputStateBuilder(device);
DawnInputStateBuilder apiInputStateBuilder = api.GetNewInputStateBuilder();
EXPECT_CALL(api, DeviceCreateInputStateBuilder(apiDevice))
.WillOnce(Return(apiInputStateBuilder));
dawnInputState inputState = dawnInputStateBuilderGetResult(inputStateBuilder);
dawnInputState apiInputState = api.GetNewInputState();
DawnInputState inputState = dawnInputStateBuilderGetResult(inputStateBuilder);
DawnInputState apiInputState = api.GetNewInputState();
EXPECT_CALL(api, InputStateBuilderGetResult(apiInputStateBuilder))
.WillOnce(Return(apiInputState));
// Create the depth-stencil state
dawnStencilStateFaceDescriptor stencilFace;
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;
dawnDepthStencilStateDescriptor depthStencilState;
DawnDepthStencilStateDescriptor depthStencilState;
depthStencilState.nextInChain = nullptr;
depthStencilState.format = DAWN_TEXTURE_FORMAT_D32_FLOAT_S8_UINT;
depthStencilState.depthWriteEnabled = false;
@@ -114,32 +114,32 @@ TEST_F(WireOptionalTests, OptionalStructPointer) {
depthStencilState.stencilWriteMask = 0xff;
// Create the pipeline layout
dawnPipelineLayoutDescriptor layoutDescriptor;
DawnPipelineLayoutDescriptor layoutDescriptor;
layoutDescriptor.nextInChain = nullptr;
layoutDescriptor.bindGroupLayoutCount = 0;
layoutDescriptor.bindGroupLayouts = nullptr;
dawnPipelineLayout layout = dawnDeviceCreatePipelineLayout(device, &layoutDescriptor);
dawnPipelineLayout apiLayout = api.GetNewPipelineLayout();
DawnPipelineLayout layout = dawnDeviceCreatePipelineLayout(device, &layoutDescriptor);
DawnPipelineLayout apiLayout = api.GetNewPipelineLayout();
EXPECT_CALL(api, DeviceCreatePipelineLayout(apiDevice, _)).WillOnce(Return(apiLayout));
// Create pipeline
dawnRenderPipelineDescriptor pipelineDescriptor;
DawnRenderPipelineDescriptor pipelineDescriptor;
pipelineDescriptor.nextInChain = nullptr;
dawnPipelineStageDescriptor vertexStage;
DawnPipelineStageDescriptor vertexStage;
vertexStage.nextInChain = nullptr;
vertexStage.module = vsModule;
vertexStage.entryPoint = "main";
pipelineDescriptor.vertexStage = &vertexStage;
dawnPipelineStageDescriptor fragmentStage;
DawnPipelineStageDescriptor fragmentStage;
fragmentStage.nextInChain = nullptr;
fragmentStage.module = vsModule;
fragmentStage.entryPoint = "main";
pipelineDescriptor.fragmentStage = &fragmentStage;
pipelineDescriptor.colorStateCount = 1;
dawnColorStateDescriptor* colorStatesPtr[] = {&colorStateDescriptor};
DawnColorStateDescriptor* colorStatesPtr[] = {&colorStateDescriptor};
pipelineDescriptor.colorStates = colorStatesPtr;
pipelineDescriptor.sampleCount = 1;
@@ -154,7 +154,7 @@ TEST_F(WireOptionalTests, OptionalStructPointer) {
EXPECT_CALL(
api,
DeviceCreateRenderPipeline(
apiDevice, MatchesLambda([](const dawnRenderPipelineDescriptor* desc) -> bool {
apiDevice, MatchesLambda([](const DawnRenderPipelineDescriptor* desc) -> bool {
return desc->depthStencilState != nullptr &&
desc->depthStencilState->nextInChain == nullptr &&
desc->depthStencilState->depthWriteEnabled == false &&
@@ -185,7 +185,7 @@ TEST_F(WireOptionalTests, OptionalStructPointer) {
dawnDeviceCreateRenderPipeline(device, &pipelineDescriptor);
EXPECT_CALL(api,
DeviceCreateRenderPipeline(
apiDevice, MatchesLambda([](const dawnRenderPipelineDescriptor* desc) -> bool {
apiDevice, MatchesLambda([](const DawnRenderPipelineDescriptor* desc) -> bool {
return desc->depthStencilState == nullptr;
})))
.WillOnce(Return(nullptr));

6
src/tests/unittests/wire/WireTest.cpp
View File

@@ -28,8 +28,8 @@ WireTest::~WireTest() {
}
void WireTest::SetUp() {
dawnProcTable mockProcs;
dawnDevice mockDevice;
DawnProcTable mockProcs;
DawnDevice mockDevice;
api.GetProcTableAndDevice(&mockProcs, &mockDevice);
// This SetCallback call cannot be ignored because it is done as soon as we start the server
@@ -49,7 +49,7 @@ void WireTest::SetUp() {
mS2cBuf->SetHandler(mWireClient.get());
device = mWireClient->GetDevice();
dawnProcTable clientProcs = mWireClient->GetProcs();
DawnProcTable clientProcs = mWireClient->GetProcs();
dawnSetProcs(&clientProcs);
apiDevice = mockDevice;

4
src/tests/unittests/wire/WireTest.h
View File

@@ -86,8 +86,8 @@ class WireTest : public testing::Test {
void FlushServer();
MockProcTable api;
dawnDevice apiDevice;
dawnDevice device;
DawnDevice apiDevice;
DawnDevice device;
private:
bool mIgnoreSetCallbackCalls = false;