• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1  // Copyright 2019 The Dawn Authors
2  //
3  // Licensed under the Apache License, Version 2.0 (the "License");
4  // you may not use this file except in compliance with the License.
5  // You may obtain a copy of the License at
6  //
7  //     http://www.apache.org/licenses/LICENSE-2.0
8  //
9  // Unless required by applicable law or agreed to in writing, software
10  // distributed under the License is distributed on an "AS IS" BASIS,
11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  // See the License for the specific language governing permissions and
13  // limitations under the License.
14  
15  #include "tests/unittests/wire/WireTest.h"
16  
17  #include "dawn/dawn_proc.h"
18  #include "dawn_wire/WireClient.h"
19  #include "dawn_wire/WireServer.h"
20  #include "utils/TerribleCommandBuffer.h"
21  
22  using namespace testing;
23  using namespace dawn_wire;
24  
WireTest()25  WireTest::WireTest() {
26  }
27  
~WireTest()28  WireTest::~WireTest() {
29  }
30  
GetClientMemoryTransferService()31  client::MemoryTransferService* WireTest::GetClientMemoryTransferService() {
32      return nullptr;
33  }
34  
GetServerMemoryTransferService()35  server::MemoryTransferService* WireTest::GetServerMemoryTransferService() {
36      return nullptr;
37  }
38  
SetUp()39  void WireTest::SetUp() {
40      DawnProcTable mockProcs;
41      WGPUDevice mockDevice;
42      api.GetProcTableAndDevice(&mockProcs, &mockDevice);
43  
44      // This SetCallback call cannot be ignored because it is done as soon as we start the server
45      EXPECT_CALL(api, OnDeviceSetUncapturedErrorCallback(_, _, _)).Times(Exactly(1));
46      EXPECT_CALL(api, OnDeviceSetLoggingCallback(_, _, _)).Times(Exactly(1));
47      EXPECT_CALL(api, OnDeviceSetDeviceLostCallback(_, _, _)).Times(Exactly(1));
48      SetupIgnoredCallExpectations();
49  
50      mS2cBuf = std::make_unique<utils::TerribleCommandBuffer>();
51      mC2sBuf = std::make_unique<utils::TerribleCommandBuffer>(mWireServer.get());
52  
53      WireServerDescriptor serverDesc = {};
54      serverDesc.procs = &mockProcs;
55      serverDesc.serializer = mS2cBuf.get();
56      serverDesc.memoryTransferService = GetServerMemoryTransferService();
57  
58      mWireServer.reset(new WireServer(serverDesc));
59      mC2sBuf->SetHandler(mWireServer.get());
60  
61      WireClientDescriptor clientDesc = {};
62      clientDesc.serializer = mC2sBuf.get();
63      clientDesc.memoryTransferService = GetClientMemoryTransferService();
64  
65      mWireClient.reset(new WireClient(clientDesc));
66      mS2cBuf->SetHandler(mWireClient.get());
67  
68      dawnProcSetProcs(&dawn_wire::client::GetProcs());
69  
70      auto deviceReservation = mWireClient->ReserveDevice();
71      EXPECT_CALL(api, DeviceReference(mockDevice));
72      mWireServer->InjectDevice(mockDevice, deviceReservation.id, deviceReservation.generation);
73  
74      device = deviceReservation.device;
75      apiDevice = mockDevice;
76  
77      // The GetQueue is done on WireClient startup so we expect it now.
78      queue = wgpuDeviceGetQueue(device);
79      apiQueue = api.GetNewQueue();
80      EXPECT_CALL(api, DeviceGetQueue(apiDevice)).WillOnce(Return(apiQueue));
81      FlushClient();
82  }
83  
TearDown()84  void WireTest::TearDown() {
85      dawnProcSetProcs(nullptr);
86  
87      // Derived classes should call the base TearDown() first. The client must
88      // be reset before any mocks are deleted.
89      // Incomplete client callbacks will be called on deletion, so the mocks
90      // cannot be null.
91      api.IgnoreAllReleaseCalls();
92      mWireClient = nullptr;
93  
94      if (mWireServer && apiDevice) {
95          // These are called on server destruction to clear the callbacks. They must not be
96          // called after the server is destroyed.
97          EXPECT_CALL(api, OnDeviceSetUncapturedErrorCallback(apiDevice, nullptr, nullptr))
98              .Times(Exactly(1));
99          EXPECT_CALL(api, OnDeviceSetLoggingCallback(apiDevice, nullptr, nullptr)).Times(Exactly(1));
100          EXPECT_CALL(api, OnDeviceSetDeviceLostCallback(apiDevice, nullptr, nullptr))
101              .Times(Exactly(1));
102      }
103      mWireServer = nullptr;
104  }
105  
106  // This should be called if |apiDevice| is no longer exists on the wire.
107  // This signals that expectations in |TearDowb| shouldn't be added.
DefaultApiDeviceWasReleased()108  void WireTest::DefaultApiDeviceWasReleased() {
109      apiDevice = nullptr;
110  }
111  
FlushClient(bool success)112  void WireTest::FlushClient(bool success) {
113      ASSERT_EQ(mC2sBuf->Flush(), success);
114  
115      Mock::VerifyAndClearExpectations(&api);
116      SetupIgnoredCallExpectations();
117  }
118  
FlushServer(bool success)119  void WireTest::FlushServer(bool success) {
120      ASSERT_EQ(mS2cBuf->Flush(), success);
121  }
122  
GetWireServer()123  dawn_wire::WireServer* WireTest::GetWireServer() {
124      return mWireServer.get();
125  }
126  
GetWireClient()127  dawn_wire::WireClient* WireTest::GetWireClient() {
128      return mWireClient.get();
129  }
130  
DeleteServer()131  void WireTest::DeleteServer() {
132      EXPECT_CALL(api, QueueRelease(apiQueue)).Times(1);
133      EXPECT_CALL(api, DeviceRelease(apiDevice)).Times(1);
134  
135      if (mWireServer) {
136          // These are called on server destruction to clear the callbacks. They must not be
137          // called after the server is destroyed.
138          EXPECT_CALL(api, OnDeviceSetUncapturedErrorCallback(apiDevice, nullptr, nullptr))
139              .Times(Exactly(1));
140          EXPECT_CALL(api, OnDeviceSetLoggingCallback(apiDevice, nullptr, nullptr)).Times(Exactly(1));
141          EXPECT_CALL(api, OnDeviceSetDeviceLostCallback(apiDevice, nullptr, nullptr))
142              .Times(Exactly(1));
143      }
144      mWireServer = nullptr;
145  }
146  
DeleteClient()147  void WireTest::DeleteClient() {
148      mWireClient = nullptr;
149  }
150  
SetupIgnoredCallExpectations()151  void WireTest::SetupIgnoredCallExpectations() {
152      EXPECT_CALL(api, DeviceTick(_)).Times(AnyNumber());
153  }
154