Skip to content

Commit d1aaf2e

Browse files
MichalMrozekMichalMrozek
committed
Refactor naming in drm memory manager tests.
Change-Id: I9dedc5397150869874e15f379d75e7135c11a7b5
1 parent 4600314 commit d1aaf2e

File tree

1 file changed

+67
-67
lines changed

1 file changed

+67
-67
lines changed

‎unit_tests/os_interface/linux/drm_memory_manager_tests.cpp‎

Lines changed: 67 additions & 67 deletions
Original file line numberDiff line numberDiff line change
@@ -179,31 +179,31 @@ TEST_F(DrmMemoryManagerWithExplicitExpectationsTest, givenDefaultDrmMemoryManger
179179
}
180180

181181
TEST_F(DrmMemoryManagerWithExplicitExpectationsTest, givenforcePinAllowedWhenMemoryManagerIsCreatedThenPinBbIsCreated) {
182-
auto mm = new (std::nothrow) TestedDrmMemoryManager(this->mock, true, false);
183-
EXPECT_NE(nullptr, mm->getPinBB());
184-
delete mm;
182+
auto memoryManager = new (std::nothrow) TestedDrmMemoryManager(this->mock, true, false);
183+
EXPECT_NE(nullptr, memoryManager->getPinBB());
184+
delete memoryManager;
185185
}
186186

187187
TEST_F(DrmMemoryManagerTest, pinBBisCreated) {
188188
mock->ioctl_expected.gemUserptr = 1;
189189
mock->ioctl_expected.gemClose = 1;
190190

191-
auto mm = new (std::nothrow) TestedDrmMemoryManager(this->mock, true, false);
192-
EXPECT_NE(nullptr, mm->getPinBB());
193-
delete mm;
191+
auto memoryManager = new (std::nothrow) TestedDrmMemoryManager(this->mock, true, false);
192+
EXPECT_NE(nullptr, memoryManager->getPinBB());
193+
delete memoryManager;
194194
}
195195

196196
TEST_F(DrmMemoryManagerTest, givenNotAllowedForcePinWhenMemoryManagerIsCreatedThenPinBBIsNotCreated) {
197-
std::unique_ptr<TestedDrmMemoryManager> mm(new (std::nothrow) TestedDrmMemoryManager(this->mock, false, false));
198-
EXPECT_EQ(nullptr, mm->getPinBB());
197+
std::unique_ptr<TestedDrmMemoryManager> memoryManager(new (std::nothrow) TestedDrmMemoryManager(this->mock, false, false));
198+
EXPECT_EQ(nullptr, memoryManager->getPinBB());
199199
}
200200

201201
TEST_F(DrmMemoryManagerTest, pinBBnotCreatedWhenIoctlFailed) {
202202
mock->ioctl_expected.gemUserptr = 1;
203203
mock->ioctl_res = -1;
204-
auto mm = new (std::nothrow) TestedDrmMemoryManager(this->mock, true, false);
205-
EXPECT_EQ(nullptr, mm->getPinBB());
206-
delete mm;
204+
auto memoryManager = new (std::nothrow) TestedDrmMemoryManager(this->mock, true, false);
205+
EXPECT_EQ(nullptr, memoryManager->getPinBB());
206+
delete memoryManager;
207207
}
208208

209209
TEST_F(DrmMemoryManagerTest, pinAfterAllocateWhenAskedAndAllowedAndBigAllocation) {
@@ -212,67 +212,67 @@ TEST_F(DrmMemoryManagerTest, pinAfterAllocateWhenAskedAndAllowedAndBigAllocation
212212
mock->ioctl_expected.gemWait = 1;
213213
mock->ioctl_expected.gemClose = 2;
214214

215-
auto mm = new (std::nothrow) TestedDrmMemoryManager(this->mock, true, false);
216-
ASSERT_NE(nullptr, mm->getPinBB());
215+
auto memoryManager = new (std::nothrow) TestedDrmMemoryManager(this->mock, true, false);
216+
ASSERT_NE(nullptr, memoryManager->getPinBB());
217217

218-
auto alloc = mm->allocateGraphicsMemory(10 * 1014 * 1024, 1024, true, false);
218+
auto alloc = memoryManager->allocateGraphicsMemory(10 * 1014 * 1024, 1024, true, false);
219219
ASSERT_NE(nullptr, alloc);
220220
EXPECT_NE(nullptr, alloc->getBO());
221221

222-
mm->freeGraphicsMemory(alloc);
222+
memoryManager->freeGraphicsMemory(alloc);
223223

224-
delete mm;
224+
delete memoryManager;
225225
}
226226

227227
TEST_F(DrmMemoryManagerTest, doNotPinAfterAllocateWhenAskedAndAllowedButSmallAllocation) {
228228
mock->ioctl_expected.gemUserptr = 2;
229229
mock->ioctl_expected.gemWait = 1;
230230
mock->ioctl_expected.gemClose = 2;
231231

232-
auto mm = new (std::nothrow) TestedDrmMemoryManager(this->mock, true, false);
233-
ASSERT_NE(nullptr, mm->getPinBB());
232+
auto memoryManager = new (std::nothrow) TestedDrmMemoryManager(this->mock, true, false);
233+
ASSERT_NE(nullptr, memoryManager->getPinBB());
234234

235235
// one page is too small for early pinning
236-
auto alloc = mm->allocateGraphicsMemory(4 * 1024, 1024, true, false);
236+
auto alloc = memoryManager->allocateGraphicsMemory(4 * 1024, 1024, true, false);
237237
ASSERT_NE(nullptr, alloc);
238238
EXPECT_NE(nullptr, alloc->getBO());
239239

240-
mm->freeGraphicsMemory(alloc);
240+
memoryManager->freeGraphicsMemory(alloc);
241241

242-
delete mm;
242+
delete memoryManager;
243243
}
244244

245245
TEST_F(DrmMemoryManagerTest, doNotPinAfterAllocateWhenNotAskedButAllowed) {
246246
mock->ioctl_expected.gemUserptr = 2;
247247
mock->ioctl_expected.gemClose = 2;
248248
mock->ioctl_expected.gemWait = 1;
249249

250-
auto mm = new (std::nothrow) TestedDrmMemoryManager(this->mock, true, false);
251-
ASSERT_NE(nullptr, mm->getPinBB());
250+
auto memoryManager = new (std::nothrow) TestedDrmMemoryManager(this->mock, true, false);
251+
ASSERT_NE(nullptr, memoryManager->getPinBB());
252252

253-
auto alloc = mm->allocateGraphicsMemory(1024, 1024, false, false);
253+
auto alloc = memoryManager->allocateGraphicsMemory(1024, 1024, false, false);
254254
ASSERT_NE(nullptr, alloc);
255255
EXPECT_NE(nullptr, alloc->getBO());
256256

257-
mm->freeGraphicsMemory(alloc);
257+
memoryManager->freeGraphicsMemory(alloc);
258258

259-
delete mm;
259+
delete memoryManager;
260260
}
261261

262262
TEST_F(DrmMemoryManagerTest, doNotPinAfterAllocateWhenAskedButNotAllowed) {
263263
mock->ioctl_expected.gemUserptr = 1;
264264
mock->ioctl_expected.gemWait = 1;
265265
mock->ioctl_expected.gemClose = 1;
266266

267-
auto mm = new (std::nothrow) TestedDrmMemoryManager(this->mock, false, false);
267+
auto memoryManager = new (std::nothrow) TestedDrmMemoryManager(this->mock, false, false);
268268

269-
auto alloc = mm->allocateGraphicsMemory(1024, 1024, true, false);
269+
auto alloc = memoryManager->allocateGraphicsMemory(1024, 1024, true, false);
270270
ASSERT_NE(nullptr, alloc);
271271
EXPECT_NE(nullptr, alloc->getBO());
272272

273-
mm->freeGraphicsMemory(alloc);
273+
memoryManager->freeGraphicsMemory(alloc);
274274

275-
delete mm;
275+
delete memoryManager;
276276
}
277277

278278
// ---- HostPtr
@@ -282,18 +282,18 @@ TEST_F(DrmMemoryManagerTest, pinAfterAllocateWhenAskedAndAllowedAndBigAllocation
282282
mock->ioctl_expected.execbuffer2 = 1;
283283
mock->ioctl_expected.gemWait = 1;
284284

285-
auto mm = new (std::nothrow) TestedDrmMemoryManager(this->mock, true, false);
286-
ASSERT_NE(nullptr, mm->getPinBB());
285+
auto memoryManager = new (std::nothrow) TestedDrmMemoryManager(this->mock, true, false);
286+
ASSERT_NE(nullptr, memoryManager->getPinBB());
287287

288288
size_t size = 10 * 1024 * 1024;
289289
void *ptr = ::alignedMalloc(size, 4096);
290-
auto alloc = mm->allocateGraphicsMemory(size, ptr, true);
290+
auto alloc = memoryManager->allocateGraphicsMemory(size, ptr, true);
291291
ASSERT_NE(nullptr, alloc);
292292
EXPECT_NE(nullptr, alloc->getBO());
293293

294-
mm->freeGraphicsMemory(alloc);
294+
memoryManager->freeGraphicsMemory(alloc);
295295

296-
delete mm;
296+
delete memoryManager;
297297
::alignedFree(ptr);
298298
}
299299

@@ -302,19 +302,19 @@ TEST_F(DrmMemoryManagerTest, givenSmallAllocationHostPtrAllocationWhenForcePinIs
302302
mock->ioctl_expected.gemWait = 1;
303303
mock->ioctl_expected.gemClose = 2;
304304

305-
auto mm = new (std::nothrow) TestedDrmMemoryManager(this->mock, true, false);
306-
ASSERT_NE(nullptr, mm->getPinBB());
305+
auto memoryManager = new (std::nothrow) TestedDrmMemoryManager(this->mock, true, false);
306+
ASSERT_NE(nullptr, memoryManager->getPinBB());
307307

308308
// one page is too small for early pinning
309309
size_t size = 4 * 1024;
310310
void *ptr = ::alignedMalloc(size, 4096);
311-
auto alloc = mm->allocateGraphicsMemory(size, ptr, true);
311+
auto alloc = memoryManager->allocateGraphicsMemory(size, ptr, true);
312312
ASSERT_NE(nullptr, alloc);
313313
EXPECT_NE(nullptr, alloc->getBO());
314314

315-
mm->freeGraphicsMemory(alloc);
315+
memoryManager->freeGraphicsMemory(alloc);
316316

317-
delete mm;
317+
delete memoryManager;
318318
::alignedFree(ptr);
319319
}
320320

@@ -323,18 +323,18 @@ TEST_F(DrmMemoryManagerTest, doNotPinAfterAllocateWhenNotAskedButAllowedHostPtr)
323323
mock->ioctl_expected.gemWait = 1;
324324
mock->ioctl_expected.gemClose = 2;
325325

326-
auto mm = new (std::nothrow) TestedDrmMemoryManager(this->mock, true, false);
327-
ASSERT_NE(nullptr, mm->getPinBB());
326+
auto memoryManager = new (std::nothrow) TestedDrmMemoryManager(this->mock, true, false);
327+
ASSERT_NE(nullptr, memoryManager->getPinBB());
328328

329329
size_t size = 4 * 1024;
330330
void *ptr = ::alignedMalloc(size, 4096);
331-
auto alloc = mm->allocateGraphicsMemory(size, ptr, false);
331+
auto alloc = memoryManager->allocateGraphicsMemory(size, ptr, false);
332332
ASSERT_NE(nullptr, alloc);
333333
EXPECT_NE(nullptr, alloc->getBO());
334334

335-
mm->freeGraphicsMemory(alloc);
335+
memoryManager->freeGraphicsMemory(alloc);
336336

337-
delete mm;
337+
delete memoryManager;
338338
::alignedFree(ptr);
339339
}
340340

@@ -343,17 +343,17 @@ TEST_F(DrmMemoryManagerTest, doNotPinAfterAllocateWhenAskedButNotAllowedHostPtr)
343343
mock->ioctl_expected.gemWait = 1;
344344
mock->ioctl_expected.gemClose = 1;
345345

346-
auto mm = new (std::nothrow) TestedDrmMemoryManager(this->mock, false, false);
346+
auto memoryManager = new (std::nothrow) TestedDrmMemoryManager(this->mock, false, false);
347347

348348
size_t size = 4 * 1024;
349349
void *ptr = ::alignedMalloc(size, 4096);
350-
auto alloc = mm->allocateGraphicsMemory(size, ptr, true);
350+
auto alloc = memoryManager->allocateGraphicsMemory(size, ptr, true);
351351
ASSERT_NE(nullptr, alloc);
352352
EXPECT_NE(nullptr, alloc->getBO());
353353

354-
mm->freeGraphicsMemory(alloc);
354+
memoryManager->freeGraphicsMemory(alloc);
355355

356-
delete mm;
356+
delete memoryManager;
357357
::alignedFree(ptr);
358358
}
359359

@@ -2472,16 +2472,16 @@ TEST_F(DrmMemoryManagerWithExplicitExpectationsTest, givenValidateHostPtrMemoryE
24722472
mock->ioctl_expected.gemWait = 1;
24732473
mock->ioctl_expected.gemClose = 2;
24742474

2475-
std::unique_ptr<TestedDrmMemoryManager> mm(new (std::nothrow) TestedDrmMemoryManager(this->mock, true, true));
2476-
ASSERT_NE(nullptr, mm->getPinBB());
2475+
std::unique_ptr<TestedDrmMemoryManager> memoryManager(new (std::nothrow) TestedDrmMemoryManager(this->mock, true, true));
2476+
ASSERT_NE(nullptr, memoryManager->getPinBB());
24772477

24782478
size_t size = 10 * 1024 * 1024;
24792479
void *ptr = ::alignedMalloc(size, 4096);
2480-
auto alloc = mm->allocateGraphicsMemory(size, ptr, false);
2480+
auto alloc = memoryManager->allocateGraphicsMemory(size, ptr, false);
24812481
ASSERT_NE(nullptr, alloc);
24822482
EXPECT_NE(nullptr, alloc->getBO());
24832483

2484-
mm->freeGraphicsMemory(alloc);
2484+
memoryManager->freeGraphicsMemory(alloc);
24852485
::alignedFree(ptr);
24862486
}
24872487

@@ -2505,17 +2505,17 @@ TEST_F(DrmMemoryManagerTest, givenForcePinAndHostMemoryValidationEnabledWhenSmal
25052505
mock->ioctl_expected.gemWait = 1; // in freeGraphicsAllocation
25062506
mock->ioctl_expected.gemClose = 2; // 1 pinBB, 1 small allocation
25072507

2508-
std::unique_ptr<TestedDrmMemoryManager> mm(new (std::nothrow) TestedDrmMemoryManager(this->mock, true, true));
2509-
ASSERT_NE(nullptr, mm->getPinBB());
2508+
std::unique_ptr<TestedDrmMemoryManager> memoryManager(new (std::nothrow) TestedDrmMemoryManager(this->mock, true, true));
2509+
ASSERT_NE(nullptr, memoryManager->getPinBB());
25102510

25112511
// one page is too small for early pinning but pinning is used for host memory validation
25122512
size_t size = 4 * 1024;
25132513
void *ptr = ::alignedMalloc(size, 4096);
2514-
auto alloc = mm->allocateGraphicsMemory(size, ptr, false);
2514+
auto alloc = memoryManager->allocateGraphicsMemory(size, ptr, false);
25152515
ASSERT_NE(nullptr, alloc);
25162516
EXPECT_NE(nullptr, alloc->getBO());
25172517

2518-
mm->freeGraphicsMemory(alloc);
2518+
memoryManager->freeGraphicsMemory(alloc);
25192519
::alignedFree(ptr);
25202520
}
25212521

@@ -2524,17 +2524,17 @@ TEST_F(DrmMemoryManagerTest, givenForcePinAllowedAndNoPinBBInMemoryManagerWhenAl
25242524
mock->ioctl_expected.gemWait = 1;
25252525
mock->ioctl_expected.gemClose = 1;
25262526
mock->ioctl_res = -1;
2527-
std::unique_ptr<TestedDrmMemoryManager> mm(new (std::nothrow) TestedDrmMemoryManager(this->mock, true, false));
2528-
EXPECT_EQ(nullptr, mm->getPinBB());
2527+
std::unique_ptr<TestedDrmMemoryManager> memoryManager(new (std::nothrow) TestedDrmMemoryManager(this->mock, true, false));
2528+
EXPECT_EQ(nullptr, memoryManager->getPinBB());
25292529
mock->ioctl_res = 0;
25302530

2531-
auto allocation = mm->allocateGraphicsMemory(4096, 4096, true, false);
2531+
auto allocation = memoryManager->allocateGraphicsMemory(4096, 4096, true, false);
25322532
EXPECT_NE(nullptr, allocation);
2533-
mm->freeGraphicsMemory(allocation);
2533+
memoryManager->freeGraphicsMemory(allocation);
25342534
}
25352535

25362536
TEST_F(DrmMemoryManagerWithExplicitExpectationsTest, givenForcePinNotAllowedAndHostMemoryValidationEnabledWhenAllocationIsCreatedThenBufferObjectIsPinnedOnlyOnce) {
2537-
std::unique_ptr<TestedDrmMemoryManager> mm(new TestedDrmMemoryManager(this->mock, false, true));
2537+
std::unique_ptr<TestedDrmMemoryManager> memoryManager(new TestedDrmMemoryManager(this->mock, false, true));
25382538
mock->reset();
25392539
mock->ioctl_expected.gemUserptr = 1;
25402540
mock->ioctl_expected.execbuffer2 = 1;
@@ -2543,30 +2543,30 @@ TEST_F(DrmMemoryManagerWithExplicitExpectationsTest, givenForcePinNotAllowedAndH
25432543

25442544
size_t size = 1024;
25452545
void *ptr = ::alignedMalloc(size, 4096);
2546-
auto alloc = mm->allocateGraphicsMemory(size, ptr, true);
2546+
auto alloc = memoryManager->allocateGraphicsMemory(size, ptr, true);
25472547
ASSERT_NE(nullptr, alloc);
25482548
EXPECT_NE(nullptr, alloc->getBO());
25492549

2550-
mm->freeGraphicsMemory(alloc);
2550+
memoryManager->freeGraphicsMemory(alloc);
25512551
mock->testIoctls();
25522552

25532553
::alignedFree(ptr);
25542554
}
25552555

25562556
TEST_F(DrmMemoryManagerWithExplicitExpectationsTest, givenForcePinNotAllowedAndHostMemoryValidationDisabledWhenAllocationIsCreatedThenBufferObjectIsNotPinned) {
2557-
std::unique_ptr<TestedDrmMemoryManager> mm(new TestedDrmMemoryManager(this->mock, false, false));
2557+
std::unique_ptr<TestedDrmMemoryManager> memoryManager(new TestedDrmMemoryManager(this->mock, false, false));
25582558
mock->reset();
25592559
mock->ioctl_expected.gemUserptr = 1;
25602560
mock->ioctl_expected.gemClose = 1;
25612561
mock->ioctl_expected.gemWait = 1;
25622562

25632563
size_t size = 10 * 1024 * 1024; // bigger than threshold
25642564
void *ptr = ::alignedMalloc(size, 4096);
2565-
auto alloc = mm->allocateGraphicsMemory(size, ptr, true);
2565+
auto alloc = memoryManager->allocateGraphicsMemory(size, ptr, true);
25662566
ASSERT_NE(nullptr, alloc);
25672567
EXPECT_NE(nullptr, alloc->getBO());
25682568

2569-
mm->freeGraphicsMemory(alloc);
2569+
memoryManager->freeGraphicsMemory(alloc);
25702570
mock->testIoctls();
25712571

25722572
::alignedFree(ptr);

0 commit comments

Comments
 (0)