Get QueueTimelineTests back
MapAsync -> OnSubmittedWorkDone and OnSubmittedWorkDone ->
OnSubmittedWorkDone are still supposed to be guaranteed.
Bug: dawn:404
Bug: dawn:1705
Change-Id: Ia42b090bb260dce77d5429a0bc55c47a533bcaf6
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/135661
Kokoro: Kokoro <noreply+kokoro@google.com>
Reviewed-by: Austin Eng <enga@chromium.org>
Commit-Queue: Jie A Chen <jie.a.chen@intel.com>
diff --git a/src/dawn/tests/BUILD.gn b/src/dawn/tests/BUILD.gn
index 01888d5..4760567 100644
--- a/src/dawn/tests/BUILD.gn
+++ b/src/dawn/tests/BUILD.gn
@@ -543,6 +543,7 @@
"end2end/PrimitiveTopologyTests.cpp",
"end2end/QueryTests.cpp",
"end2end/QueueTests.cpp",
+ "end2end/QueueTimelineTests.cpp",
"end2end/ReadOnlyDepthStencilAttachmentTests.cpp",
"end2end/RenderAttachmentTests.cpp",
"end2end/RenderBundleTests.cpp",
diff --git a/src/dawn/tests/end2end/QueueTimelineTests.cpp b/src/dawn/tests/end2end/QueueTimelineTests.cpp
new file mode 100644
index 0000000..6c14dc0
--- /dev/null
+++ b/src/dawn/tests/end2end/QueueTimelineTests.cpp
@@ -0,0 +1,107 @@
+// Copyright 2020 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 <memory>
+
+#include "dawn/tests/DawnTest.h"
+#include "gmock/gmock.h"
+
+using testing::InSequence;
+
+class MockMapCallback {
+ public:
+ MOCK_METHOD(void, Call, (WGPUBufferMapAsyncStatus status, void* userdata));
+};
+
+static std::unique_ptr<MockMapCallback> mockMapCallback;
+static void ToMockMapCallback(WGPUBufferMapAsyncStatus status, void* userdata) {
+ EXPECT_EQ(status, WGPUBufferMapAsyncStatus_Success);
+ mockMapCallback->Call(status, userdata);
+}
+
+class MockQueueWorkDoneCallback {
+ public:
+ MOCK_METHOD(void, Call, (WGPUQueueWorkDoneStatus status, void* userdata));
+};
+
+static std::unique_ptr<MockQueueWorkDoneCallback> mockQueueWorkDoneCallback;
+static void ToMockQueueWorkDone(WGPUQueueWorkDoneStatus status, void* userdata) {
+ mockQueueWorkDoneCallback->Call(status, userdata);
+}
+
+static std::unique_ptr<MockQueueWorkDoneCallback> mockQueueWorkDoneCallback1;
+static void ToMockQueueWorkDone1(WGPUQueueWorkDoneStatus status, void* userdata) {
+ mockQueueWorkDoneCallback1->Call(status, userdata);
+}
+
+class QueueTimelineTests : public DawnTest {
+ protected:
+ void SetUp() override {
+ DawnTest::SetUp();
+
+ mockMapCallback = std::make_unique<MockMapCallback>();
+ mockQueueWorkDoneCallback = std::make_unique<MockQueueWorkDoneCallback>();
+ mockQueueWorkDoneCallback1 = std::make_unique<MockQueueWorkDoneCallback>();
+
+ wgpu::BufferDescriptor descriptor;
+ descriptor.size = 4;
+ descriptor.usage = wgpu::BufferUsage::MapRead;
+ mMapReadBuffer = device.CreateBuffer(&descriptor);
+ }
+
+ void TearDown() override {
+ mockMapCallback = nullptr;
+ mockQueueWorkDoneCallback = nullptr;
+ mockQueueWorkDoneCallback1 = nullptr;
+ DawnTest::TearDown();
+ }
+
+ wgpu::Buffer mMapReadBuffer;
+};
+
+// Test that mMapReadBuffer.MapAsync callback happens before queue.OnWorkDone callback
+// when queue.OnSubmittedWorkDone is called after mMapReadBuffer.MapAsync. The callback order should
+// happen in the order the functions are called.
+TEST_P(QueueTimelineTests, MapRead_OnWorkDone) {
+ InSequence sequence;
+ EXPECT_CALL(*mockMapCallback, Call(WGPUBufferMapAsyncStatus_Success, this)).Times(1);
+ EXPECT_CALL(*mockQueueWorkDoneCallback, Call(WGPUQueueWorkDoneStatus_Success, this)).Times(1);
+
+ mMapReadBuffer.MapAsync(wgpu::MapMode::Read, 0, wgpu::kWholeMapSize, ToMockMapCallback, this);
+
+ queue.OnSubmittedWorkDone(0u, ToMockQueueWorkDone, this);
+
+ WaitForAllOperations();
+ mMapReadBuffer.Unmap();
+}
+
+// Test that the OnSubmittedWorkDone callbacks should happen in the order the functions are called.
+TEST_P(QueueTimelineTests, OnWorkDone_OnWorkDone) {
+ InSequence sequence;
+ EXPECT_CALL(*mockQueueWorkDoneCallback, Call(WGPUQueueWorkDoneStatus_Success, this)).Times(1);
+ EXPECT_CALL(*mockQueueWorkDoneCallback1, Call(WGPUQueueWorkDoneStatus_Success, this)).Times(1);
+
+ queue.OnSubmittedWorkDone(0u, ToMockQueueWorkDone, this);
+ queue.OnSubmittedWorkDone(0u, ToMockQueueWorkDone1, this);
+
+ WaitForAllOperations();
+}
+
+DAWN_INSTANTIATE_TEST(QueueTimelineTests,
+ D3D11Backend(),
+ D3D12Backend(),
+ MetalBackend(),
+ OpenGLBackend(),
+ OpenGLESBackend(),
+ VulkanBackend());
