Skip to content

Commit 1d48e97

Browse files
fzwolinskiCompute-Runtime-Automation
fzwolinski
authored and
Compute-Runtime-Automation
committed
Remove GMock from MockAubCsr, GmockAubFileStream, AsyncEventsHandlerTests...
GMock Removed from: - MockAubCsr - GmockAubFileStream - AsyncEventsHandlerTests - AsyncEventsHandlerTests::MyEvent - MockGmmPageTableMngr - GmockWddm Additionally: - GmockAubFileStream body moved to MockAubFileStream class - Deleted unused GmockAubFileStream class - Deleted NiceMocks from AsyncEventsHandlerTests - Renamed GmockWddm to MockWddm Related-To: NEO-4914 Signed-off-by: Fabian Zwolinski <[email protected]>
1 parent f8c1fe5 commit 1d48e97

16 files changed

+320
-279
lines changed

‎opencl/test/unit_test/command_stream/command_stream_receiver_flush_task_2_tests.cpp‎

Lines changed: 22 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
/*
2-
* Copyright (C) 2018-2021 Intel Corporation
2+
* Copyright (C) 2018-2022 Intel Corporation
33
*
44
* SPDX-License-Identifier: MIT
55
*
@@ -1390,9 +1390,6 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenCommandStreamReceiverWhenFlus
13901390
MockGmmPageTableMngr *pageTableManager2 = new MockGmmPageTableMngr();
13911391
csr2->pageTableManager.reset(pageTableManager2);
13921392

1393-
EXPECT_CALL(*pageTableManager, initContextAuxTableRegister(csr, ::testing::_)).Times(1);
1394-
EXPECT_CALL(*pageTableManager, initContextAuxTableRegister(csr2, ::testing::_)).Times(0);
1395-
13961393
auto memoryManager = pDevice->getMemoryManager();
13971394
auto graphicsAllocation = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{pDevice->getRootDeviceIndex(), MemoryConstants::pageSize});
13981395
IndirectHeap cs(graphicsAllocation);
@@ -1409,12 +1406,18 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenCommandStreamReceiverWhenFlus
14091406

14101407
csr->flushTask(cs, 0u, cs, cs, cs, 0u, dispatchFlags, *pDevice);
14111408

1412-
EXPECT_CALL(*pageTableManager2, initContextAuxTableRegister(csr2, ::testing::_)).Times(1);
1409+
EXPECT_EQ(1u, pageTableManager->initContextAuxTableRegisterCalled);
1410+
EXPECT_EQ(1u, pageTableManager->initContextAuxTableRegisterParamsPassed.size());
1411+
EXPECT_EQ(csr, pageTableManager->initContextAuxTableRegisterParamsPassed[0].initialBBHandle);
1412+
14131413
pDevice->resetCommandStreamReceiver(csr2);
14141414
csr2->flushTask(cs, 0u, cs, cs, cs, 0u, dispatchFlags, *pDevice);
14151415
EXPECT_TRUE(csr2->pageTableManagerInitialized);
14161416

14171417
memoryManager->freeGraphicsMemory(graphicsAllocation);
1418+
1419+
EXPECT_EQ(1u, pageTableManager2->initContextAuxTableRegisterCalled);
1420+
EXPECT_EQ(csr2, pageTableManager2->initContextAuxTableRegisterParamsPassed[0].initialBBHandle);
14181421
}
14191422

14201423
HWTEST_F(CommandStreamReceiverFlushTaskTests, givenPageTableManagerPointerWhenCallBlitBufferThenPageTableManagerInitializedForProperCsr) {
@@ -1427,9 +1430,6 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenPageTableManagerPointerWhenCa
14271430
MockGmmPageTableMngr *pageTableManager2 = new MockGmmPageTableMngr();
14281431
bcsCsr2->pageTableManager.reset(pageTableManager2);
14291432

1430-
EXPECT_CALL(*pageTableManager, initContextAuxTableRegister(bcsCsr, ::testing::_)).Times(1);
1431-
EXPECT_CALL(*pageTableManager2, initContextAuxTableRegister(bcsCsr2, ::testing::_)).Times(0);
1432-
14331433
auto memoryManager = pDevice->getMemoryManager();
14341434
auto graphicsAllocation = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{pDevice->getRootDeviceIndex(), MemoryConstants::pageSize});
14351435

@@ -1455,13 +1455,18 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenPageTableManagerPointerWhenCa
14551455
EXPECT_TRUE(bcsCsr->pageTableManagerInitialized);
14561456
EXPECT_FALSE(bcsCsr2->pageTableManagerInitialized);
14571457

1458-
EXPECT_CALL(*pageTableManager2, initContextAuxTableRegister(bcsCsr2, ::testing::_)).Times(1);
1458+
EXPECT_EQ(1u, pageTableManager->initContextAuxTableRegisterCalled);
1459+
EXPECT_EQ(bcsCsr, pageTableManager->initContextAuxTableRegisterParamsPassed[0].initialBBHandle);
1460+
14591461
pDevice->resetCommandStreamReceiver(bcsCsr2);
14601462
bcsCsr2->blitBuffer(container, true, false, *pDevice);
14611463

14621464
EXPECT_TRUE(bcsCsr2->pageTableManagerInitialized);
14631465

14641466
memoryManager->freeGraphicsMemory(graphicsAllocation);
1467+
1468+
EXPECT_EQ(1u, pageTableManager2->initContextAuxTableRegisterCalled);
1469+
EXPECT_EQ(bcsCsr2, pageTableManager2->initContextAuxTableRegisterParamsPassed[0].initialBBHandle);
14651470
}
14661471

14671472
HWTEST_F(CommandStreamReceiverFlushTaskTests, givenPageTableManagerPointerWhenCallBlitBufferAndPageTableManagerInitializedThenNotInitializeAgain) {
@@ -1471,8 +1476,6 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenPageTableManagerPointerWhenCa
14711476
MockGmmPageTableMngr *pageTableManager = new MockGmmPageTableMngr();
14721477
bcsCsr->pageTableManager.reset(pageTableManager);
14731478

1474-
EXPECT_CALL(*pageTableManager, initContextAuxTableRegister(bcsCsr, ::testing::_)).Times(1);
1475-
14761479
auto memoryManager = pDevice->getMemoryManager();
14771480
auto graphicsAllocation = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{pDevice->getRootDeviceIndex(), MemoryConstants::pageSize});
14781481

@@ -1496,10 +1499,13 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenPageTableManagerPointerWhenCa
14961499

14971500
EXPECT_TRUE(bcsCsr->pageTableManagerInitialized);
14981501

1499-
EXPECT_CALL(*pageTableManager, initContextAuxTableRegister(bcsCsr, ::testing::_)).Times(0);
15001502
bcsCsr->blitBuffer(container, true, false, *pDevice);
15011503

15021504
memoryManager->freeGraphicsMemory(graphicsAllocation);
1505+
1506+
EXPECT_EQ(1u, pageTableManager->initContextAuxTableRegisterCalled);
1507+
EXPECT_EQ(1u, pageTableManager->initContextAuxTableRegisterParamsPassed.size());
1508+
EXPECT_EQ(bcsCsr, pageTableManager->initContextAuxTableRegisterParamsPassed[0].initialBBHandle);
15031509
}
15041510

15051511
HWTEST_F(CommandStreamReceiverFlushTaskTests, givenNullPageTableManagerWhenCallBlitBufferThenPageTableManagerIsNotInitialized) {
@@ -1553,7 +1559,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenCommandStreamReceiverWhenInit
15531559
MockGmmPageTableMngr *pageTableManager = new MockGmmPageTableMngr();
15541560
csr->pageTableManager.reset(pageTableManager);
15551561

1556-
EXPECT_CALL(*pageTableManager, initContextAuxTableRegister(csr, ::testing::_)).Times(2).WillRepeatedly(::testing::Return(GMM_ERROR));
1562+
pageTableManager->initContextAuxTableRegisterResult = GMM_ERROR;
15571563

15581564
auto memoryManager = pDevice->getMemoryManager();
15591565
auto graphicsAllocation = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{pDevice->getRootDeviceIndex(), MemoryConstants::pageSize});
@@ -1571,6 +1577,9 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenCommandStreamReceiverWhenInit
15711577

15721578
EXPECT_FALSE(csr->pageTableManagerInitialized);
15731579
memoryManager->freeGraphicsMemory(graphicsAllocation);
1580+
EXPECT_EQ(2u, pageTableManager->initContextAuxTableRegisterCalled);
1581+
EXPECT_EQ(csr, pageTableManager->initContextAuxTableRegisterParamsPassed[0].initialBBHandle);
1582+
EXPECT_EQ(csr, pageTableManager->initContextAuxTableRegisterParamsPassed[1].initialBBHandle);
15741583
}
15751584

15761585
HWTEST_F(CommandStreamReceiverFlushTaskTests, WhenCsrIsMarkedWithNewResourceThenCallBatchedSubmission) {

‎opencl/test/unit_test/event/async_events_handler_tests.cpp‎

Lines changed: 26 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -1,12 +1,13 @@
11
/*
2-
* Copyright (C) 2018-2021 Intel Corporation
2+
* Copyright (C) 2018-2022 Intel Corporation
33
*
44
* SPDX-License-Identifier: MIT
55
*
66
*/
77

88
#include "shared/source/helpers/timestamp_packet.h"
99
#include "shared/test/common/helpers/debug_manager_state_restore.h"
10+
#include "shared/test/common/test_macros/mock_method_macros.h"
1011
#include "shared/test/common/test_macros/test.h"
1112
#include "shared/test/unit_test/utilities/base_object_utils.h"
1213

@@ -17,8 +18,6 @@
1718
#include "opencl/test/unit_test/mocks/mock_command_queue.h"
1819
#include "opencl/test/unit_test/mocks/mock_context.h"
1920

20-
#include "gmock/gmock.h"
21-
2221
using namespace NEO;
2322
using namespace ::testing;
2423

@@ -27,7 +26,9 @@ class AsyncEventsHandlerTests : public ::testing::Test {
2726
class MyEvent : public Event {
2827
public:
2928
MyEvent(Context *ctx, CommandQueue *cmdQueue, cl_command_type cmdType, uint32_t taskLevel, uint32_t taskCount)
30-
: Event(ctx, cmdQueue, cmdType, taskLevel, taskCount) {}
29+
: Event(ctx, cmdQueue, cmdType, taskLevel, taskCount) {
30+
handler.reset(new MockHandler());
31+
}
3132
int getExecutionStatus() {
3233
//return execution status without updating
3334
return executionStatus.load();
@@ -37,7 +38,15 @@ class AsyncEventsHandlerTests : public ::testing::Test {
3738
this->updateTaskCount(taskCount, 0);
3839
}
3940

40-
MOCK_METHOD2(wait, bool(bool blocking, bool quickKmdSleep));
41+
bool wait(bool blocking, bool quickKmdSleep) override {
42+
waitCalled++;
43+
handler->allowAsyncProcess.store(false);
44+
return waitResult;
45+
}
46+
47+
uint32_t waitCalled = 0u;
48+
bool waitResult = true;
49+
std::unique_ptr<MockHandler> handler;
4150
};
4251

4352
static void CL_CALLBACK callbackFcn(cl_event e, cl_int status, void *data) {
@@ -48,26 +57,26 @@ class AsyncEventsHandlerTests : public ::testing::Test {
4857
dbgRestore.reset(new DebugManagerStateRestore());
4958
DebugManager.flags.EnableAsyncEventsHandler.set(false);
5059
handler.reset(new MockHandler());
51-
context = make_releaseable<NiceMock<MockContext>>();
60+
context = make_releaseable<MockContext>();
5261

5362
commandQueue = make_releaseable<MockCommandQueue>(context.get(), context->getDevice(0), nullptr, false);
5463

5564
*(commandQueue->getGpgpuCommandStreamReceiver().getTagAddress()) = 0;
5665

57-
event1 = make_releaseable<NiceMock<MyEvent>>(context.get(), commandQueue.get(), CL_COMMAND_BARRIER, CompletionStamp::notReady, CompletionStamp::notReady);
58-
event2 = make_releaseable<NiceMock<MyEvent>>(context.get(), commandQueue.get(), CL_COMMAND_BARRIER, CompletionStamp::notReady, CompletionStamp::notReady);
59-
event3 = make_releaseable<NiceMock<MyEvent>>(context.get(), commandQueue.get(), CL_COMMAND_BARRIER, CompletionStamp::notReady, CompletionStamp::notReady);
66+
event1 = make_releaseable<MyEvent>(context.get(), commandQueue.get(), CL_COMMAND_BARRIER, CompletionStamp::notReady, CompletionStamp::notReady);
67+
event2 = make_releaseable<MyEvent>(context.get(), commandQueue.get(), CL_COMMAND_BARRIER, CompletionStamp::notReady, CompletionStamp::notReady);
68+
event3 = make_releaseable<MyEvent>(context.get(), commandQueue.get(), CL_COMMAND_BARRIER, CompletionStamp::notReady, CompletionStamp::notReady);
6069
}
6170

6271
std::unique_ptr<DebugManagerStateRestore> dbgRestore;
6372
std::unique_ptr<MockHandler> handler;
6473
int counter = 0;
6574

66-
ReleaseableObjectPtr<NiceMock<MockContext>> context;
75+
ReleaseableObjectPtr<MockContext> context;
6776
ReleaseableObjectPtr<MockCommandQueue> commandQueue;
68-
ReleaseableObjectPtr<NiceMock<MyEvent>> event1;
69-
ReleaseableObjectPtr<NiceMock<MyEvent>> event2;
70-
ReleaseableObjectPtr<NiceMock<MyEvent>> event3;
77+
ReleaseableObjectPtr<MyEvent> event1;
78+
ReleaseableObjectPtr<MyEvent> event2;
79+
ReleaseableObjectPtr<MyEvent> event3;
7180
};
7281

7382
TEST_F(AsyncEventsHandlerTests, givenEventsWhenListIsProcessedThenUpdateExecutionStatus) {
@@ -340,20 +349,13 @@ TEST_F(AsyncEventsHandlerTests, givenEventWithoutCallbacksWhenProcessedThenDontR
340349
TEST_F(AsyncEventsHandlerTests, givenSleepCandidateWhenProcessedThenCallWaitWithQuickKmdSleepRequest) {
341350
event1->setTaskStamp(0, 1);
342351
event1->addCallback(&this->callbackFcn, CL_COMPLETE, &counter);
343-
handler->registerEvent(event1.get());
344-
handler->allowAsyncProcess.store(true);
352+
event1->handler->registerEvent(event1.get());
353+
event1->handler->allowAsyncProcess.store(true);
345354

346-
// break infinite loop after first iteartion
347-
auto unsetAsyncFlag = [&](bool blocking, bool quickKmdSleep) {
348-
handler->allowAsyncProcess.store(false);
349-
return true;
350-
};
351-
352-
EXPECT_CALL(*event1, wait(true, true)).Times(1).WillOnce(Invoke(unsetAsyncFlag));
353-
354-
MockHandler::asyncProcess(handler.get());
355+
MockHandler::asyncProcess(event1->handler.get());
355356

356357
event1->setStatus(CL_COMPLETE);
358+
EXPECT_EQ(1u, event1->waitCalled);
357359
}
358360

359361
TEST_F(AsyncEventsHandlerTests, WhenReturningThenAsyncProcessWillCallProcessList) {

‎opencl/test/unit_test/memory_manager/memory_manager_tests.cpp‎

Lines changed: 11 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -2864,8 +2864,8 @@ HWTEST_F(PageTableManagerTest, givenPageTableManagerWhenMapAuxGpuVaThenForAllEng
28642864
memoryManager->createAndRegisterOsContext(csr2.get(), EngineDescriptorHelper::getDefaultDescriptor(regularEngines[1],
28652865
PreemptionHelper::getDefaultPreemptionMode(hwInfo)));
28662866

2867-
auto mockMngr = new NiceMock<MockGmmPageTableMngr>();
2868-
auto mockMngr2 = new NiceMock<MockGmmPageTableMngr>();
2867+
auto mockMngr = new MockGmmPageTableMngr();
2868+
auto mockMngr2 = new MockGmmPageTableMngr();
28692869

28702870
memoryManager->getRegisteredEngines()[0].commandStreamReceiver->pageTableManager.reset(mockMngr);
28712871
memoryManager->getRegisteredEngines()[1].commandStreamReceiver->pageTableManager.reset(mockMngr2);
@@ -2874,22 +2874,21 @@ HWTEST_F(PageTableManagerTest, givenPageTableManagerWhenMapAuxGpuVaThenForAllEng
28742874
MockGmm gmm(executionEnvironment->rootDeviceEnvironments[allocation.getRootDeviceIndex()]->getGmmClientContext());
28752875
gmm.isCompressionEnabled = true;
28762876
allocation.setDefaultGmm(&gmm);
2877-
GMM_DDI_UPDATEAUXTABLE givenDdiUpdateAuxTable = {};
2878-
GMM_DDI_UPDATEAUXTABLE givenDdiUpdateAuxTable2 = {};
28792877
GMM_DDI_UPDATEAUXTABLE expectedDdiUpdateAuxTable = {};
28802878
expectedDdiUpdateAuxTable.BaseGpuVA = allocation.getGpuAddress();
28812879
expectedDdiUpdateAuxTable.BaseResInfo = allocation.getDefaultGmm()->gmmResourceInfo->peekGmmResourceInfo();
28822880
expectedDdiUpdateAuxTable.DoNotWait = true;
28832881
expectedDdiUpdateAuxTable.Map = true;
28842882

2885-
EXPECT_CALL(*mockMngr, updateAuxTable(_)).Times(1).WillOnce(Invoke([&](const GMM_DDI_UPDATEAUXTABLE *arg) {givenDdiUpdateAuxTable = *arg; return GMM_SUCCESS; }));
2886-
EXPECT_CALL(*mockMngr2, updateAuxTable(_)).Times(1).WillOnce(Invoke([&](const GMM_DDI_UPDATEAUXTABLE *arg2) {givenDdiUpdateAuxTable2 = *arg2; return GMM_SUCCESS; }));
2887-
28882883
bool result = memoryManager->mapAuxGpuVA(&allocation);
28892884
EXPECT_TRUE(result);
28902885

2891-
EXPECT_TRUE(memcmp(&expectedDdiUpdateAuxTable, &givenDdiUpdateAuxTable, sizeof(GMM_DDI_UPDATEAUXTABLE)) == 0);
2892-
EXPECT_TRUE(memcmp(&expectedDdiUpdateAuxTable, &givenDdiUpdateAuxTable2, sizeof(GMM_DDI_UPDATEAUXTABLE)) == 0);
2886+
EXPECT_EQ(1u, mockMngr->updateAuxTableCalled);
2887+
EXPECT_TRUE(memcmp(&expectedDdiUpdateAuxTable, &mockMngr->updateAuxTableParamsPassed[0].ddiUpdateAuxTable, sizeof(GMM_DDI_UPDATEAUXTABLE)) == 0);
2888+
2889+
EXPECT_EQ(1u, mockMngr2->updateAuxTableCalled);
2890+
2891+
EXPECT_TRUE(memcmp(&expectedDdiUpdateAuxTable, &mockMngr2->updateAuxTableParamsPassed[0].ddiUpdateAuxTable, sizeof(GMM_DDI_UPDATEAUXTABLE)) == 0);
28932892
}
28942893
HWTEST_F(PageTableManagerTest, givenPageTableManagerWhenUpdateAuxTableGmmErrorThenMapAuxGpuVaReturnFalse) {
28952894
ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
@@ -2910,7 +2909,8 @@ HWTEST_F(PageTableManagerTest, givenPageTableManagerWhenUpdateAuxTableGmmErrorTh
29102909
memoryManager->createAndRegisterOsContext(csr.get(), EngineDescriptorHelper::getDefaultDescriptor(regularEngines[0],
29112910
PreemptionHelper::getDefaultPreemptionMode(hwInfo)));
29122911

2913-
auto mockMngr = new NiceMock<MockGmmPageTableMngr>();
2912+
auto mockMngr = new MockGmmPageTableMngr();
2913+
mockMngr->updateAuxTableResult = GMM_ERROR;
29142914

29152915
memoryManager->getRegisteredEngines()[0].commandStreamReceiver->pageTableManager.reset(mockMngr);
29162916

@@ -2919,10 +2919,9 @@ HWTEST_F(PageTableManagerTest, givenPageTableManagerWhenUpdateAuxTableGmmErrorTh
29192919
gmm.isCompressionEnabled = true;
29202920
allocation.setDefaultGmm(&gmm);
29212921

2922-
EXPECT_CALL(*mockMngr, updateAuxTable(_)).Times(1).WillOnce(Invoke([&](const GMM_DDI_UPDATEAUXTABLE *arg) { return GMM_ERROR; }));
2923-
29242922
bool result = memoryManager->mapAuxGpuVA(&allocation);
29252923
EXPECT_FALSE(result);
2924+
EXPECT_EQ(1u, mockMngr->updateAuxTableCalled);
29262925
}
29272926

29282927
HWTEST_F(PageTableManagerTest, givenNullPageTableManagerWhenMapAuxGpuVaThenNoThrow) {

‎opencl/test/unit_test/os_interface/linux/drm_command_stream_tests_1.cpp‎

Lines changed: 11 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
/*
2-
* Copyright (C) 2018-2021 Intel Corporation
2+
* Copyright (C) 2018-2022 Intel Corporation
33
*
44
* SPDX-License-Identifier: MIT
55
*
@@ -960,29 +960,27 @@ HWTEST_TEMPLATED_F(DrmCommandStreamTest, givenPageTableManagerAndMapTrueWhenUpda
960960
csr->pageTableManager.reset(mockMngr);
961961
executionEnvironment.rootDeviceEnvironments[0]->initGmm();
962962
auto gmm = std::make_unique<MockGmm>(executionEnvironment.rootDeviceEnvironments[0]->getGmmClientContext());
963-
GMM_DDI_UPDATEAUXTABLE ddiUpdateAuxTable = {};
964-
EXPECT_CALL(*mockMngr, updateAuxTable(::testing::_)).Times(1).WillOnce(::testing::Invoke([&](const GMM_DDI_UPDATEAUXTABLE *arg) {ddiUpdateAuxTable = *arg; return GMM_SUCCESS; }));
965963
auto result = csr->pageTableManager->updateAuxTable(0, gmm.get(), true);
966-
EXPECT_EQ(ddiUpdateAuxTable.BaseGpuVA, 0ull);
967-
EXPECT_EQ(ddiUpdateAuxTable.BaseResInfo, gmm->gmmResourceInfo->peekHandle());
968-
EXPECT_EQ(ddiUpdateAuxTable.DoNotWait, true);
969-
EXPECT_EQ(ddiUpdateAuxTable.Map, 1u);
964+
EXPECT_EQ(0ull, mockMngr->updateAuxTableParamsPassed[0].ddiUpdateAuxTable.BaseGpuVA);
965+
EXPECT_EQ(gmm->gmmResourceInfo->peekHandle(), mockMngr->updateAuxTableParamsPassed[0].ddiUpdateAuxTable.BaseResInfo);
966+
EXPECT_EQ(true, mockMngr->updateAuxTableParamsPassed[0].ddiUpdateAuxTable.DoNotWait);
967+
EXPECT_EQ(1u, mockMngr->updateAuxTableParamsPassed[0].ddiUpdateAuxTable.Map);
970968

971969
EXPECT_TRUE(result);
970+
EXPECT_EQ(1u, mockMngr->updateAuxTableCalled);
972971
}
973972

974973
HWTEST_TEMPLATED_F(DrmCommandStreamTest, givenPageTableManagerAndMapFalseWhenUpdateAuxTableIsCalledThenItReturnsTrue) {
975974
auto mockMngr = new MockGmmPageTableMngr();
976975
csr->pageTableManager.reset(mockMngr);
977976
executionEnvironment.rootDeviceEnvironments[0]->initGmm();
978977
auto gmm = std::make_unique<MockGmm>(executionEnvironment.rootDeviceEnvironments[0]->getGmmClientContext());
979-
GMM_DDI_UPDATEAUXTABLE ddiUpdateAuxTable = {};
980-
EXPECT_CALL(*mockMngr, updateAuxTable(::testing::_)).Times(1).WillOnce(::testing::Invoke([&](const GMM_DDI_UPDATEAUXTABLE *arg) {ddiUpdateAuxTable = *arg; return GMM_SUCCESS; }));
981978
auto result = csr->pageTableManager->updateAuxTable(0, gmm.get(), false);
982-
EXPECT_EQ(ddiUpdateAuxTable.BaseGpuVA, 0ull);
983-
EXPECT_EQ(ddiUpdateAuxTable.BaseResInfo, gmm->gmmResourceInfo->peekHandle());
984-
EXPECT_EQ(ddiUpdateAuxTable.DoNotWait, true);
985-
EXPECT_EQ(ddiUpdateAuxTable.Map, 0u);
979+
EXPECT_EQ(0ull, mockMngr->updateAuxTableParamsPassed[0].ddiUpdateAuxTable.BaseGpuVA);
980+
EXPECT_EQ(gmm->gmmResourceInfo->peekHandle(), mockMngr->updateAuxTableParamsPassed[0].ddiUpdateAuxTable.BaseResInfo);
981+
EXPECT_EQ(true, mockMngr->updateAuxTableParamsPassed[0].ddiUpdateAuxTable.DoNotWait);
982+
EXPECT_EQ(0u, mockMngr->updateAuxTableParamsPassed[0].ddiUpdateAuxTable.Map);
986983

987984
EXPECT_TRUE(result);
985+
EXPECT_EQ(1u, mockMngr->updateAuxTableCalled);
988986
}

0 commit comments

Comments
 (0)