Home | History | Annotate | Download | only in tests 
      1 /*
      2  * Copyright (C) 2010 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #include <gtest/gtest.h>
     18 
     19 #include <errno.h>
     20 #include <unistd.h>
     21 #include <fcntl.h>
     22 #include <sys/mman.h>
     23 
     24 #include "pmemalloc.h"
     25 
     26 class DepsStub : public PmemUserspaceAllocator::Deps, public PmemKernelAllocator::Deps {
     27 
     28  public:
     29 
     30     virtual size_t getPmemTotalSize(int fd, size_t* size) {
     31         return 0;
     32     }
     33 
     34     virtual int connectPmem(int fd, int master_fd) {
     35         return 0;
     36     }
     37 
     38     virtual int mapPmem(int fd, int offset, size_t size) {
     39         return 0;
     40     }
     41 
     42     virtual int unmapPmem(int fd, int offset, size_t size) {
     43         return 0;
     44     }
     45 
     46     virtual int getErrno() {
     47         return 0;
     48     }
     49 
     50     virtual void* mmap(void* start, size_t length, int prot, int flags, int fd,
     51             off_t offset) {
     52         return 0;
     53     }
     54 
     55     virtual int munmap(void* start, size_t length) {
     56         return 0;
     57     }
     58 
     59     virtual int open(const char* pathname, int flags, int mode) {
     60         return 0;
     61     }
     62 
     63     virtual int close(int fd) {
     64         return 0;
     65     }
     66 };
     67 
     68 /******************************************************************************/
     69 
     70 class AllocatorStub : public PmemUserspaceAllocator::Deps::Allocator {
     71     virtual ssize_t setSize(size_t size) {
     72         return 0;
     73     }
     74 
     75     virtual size_t  size() const {
     76         return 0;
     77     }
     78 
     79     virtual ssize_t allocate(size_t size, uint32_t flags = 0) {
     80         return 0;
     81     }
     82 
     83     virtual ssize_t deallocate(size_t offset) {
     84         return 0;
     85     }
     86 };
     87 
     88 /******************************************************************************/
     89 
     90 static const char* fakePmemDev = "/foo/bar";
     91 
     92 /******************************************************************************/
     93 
     94 struct Deps_InitPmemAreaLockedWithSuccessfulCompletion : public DepsStub {
     95 
     96     virtual int open(const char* pathname, int flags, int mode) {
     97         EXPECT_EQ(fakePmemDev, pathname);
     98         EXPECT_EQ(O_RDWR, flags);
     99         EXPECT_EQ(0, mode);
    100         return 1234;
    101     }
    102 
    103     virtual size_t getPmemTotalSize(int fd, size_t* size) {
    104         EXPECT_EQ(1234, fd);
    105         *size = 16 << 20;
    106         return 0;
    107     }
    108 
    109     virtual void* mmap(void* start, size_t length, int prot, int flags, int fd,
    110             off_t offset) {
    111         EXPECT_EQ(1234, fd);
    112         return (void*)0x87654321;
    113     }
    114 
    115 };
    116 
    117 struct Allocator_InitPmemAreaLockedWithSuccessfulCompletion : public AllocatorStub {
    118 
    119     virtual ssize_t setSize(size_t size) {
    120         EXPECT_EQ(size_t(16 << 20), size);
    121         return 0;
    122     }
    123 };
    124 
    125 TEST(test_pmem_userspace_allocator, testInitPmemAreaLockedWithSuccessfulCompletion) {
    126     Deps_InitPmemAreaLockedWithSuccessfulCompletion depsMock;
    127     Allocator_InitPmemAreaLockedWithSuccessfulCompletion allocMock;
    128     PmemUserspaceAllocator pma(depsMock, allocMock, fakePmemDev);
    129 
    130     int result = pma.init_pmem_area_locked();
    131     ASSERT_EQ(0, result);
    132 }
    133 
    134 /******************************************************************************/
    135 
    136 struct Deps_InitPmemAreaLockedWithEnomemOnMmap : public DepsStub {
    137 
    138     virtual int open(const char* pathname, int flags, int mode) {
    139         EXPECT_EQ(fakePmemDev, pathname);
    140         EXPECT_EQ(O_RDWR, flags);
    141         EXPECT_EQ(0, mode);
    142         return 1234;
    143     }
    144 
    145     virtual size_t getPmemTotalSize(int fd, size_t* size) {
    146         EXPECT_EQ(1234, fd);
    147         *size = 16 << 20;
    148         return 0;
    149     }
    150 
    151     virtual int getErrno() {
    152         return ENOMEM;
    153     }
    154 
    155     virtual void* mmap(void* start, size_t length, int prot, int flags, int fd,
    156             off_t offset) {
    157         return (void*)MAP_FAILED;
    158     }
    159 
    160 };
    161 
    162 struct Allocator_InitPmemAreaLockedWithEnomemOnMmap : public AllocatorStub {
    163 
    164     virtual ssize_t setSize(size_t size) {
    165         EXPECT_EQ(size_t(16 << 20), size);
    166         return 0;
    167     }
    168 };
    169 
    170 TEST(test_pmem_userspace_allocator, testInitPmemAreaLockedWthEnomemOnMmap) {
    171     Deps_InitPmemAreaLockedWithEnomemOnMmap depsMock;
    172     Allocator_InitPmemAreaLockedWithEnomemOnMmap allocMock;
    173     PmemUserspaceAllocator pma(depsMock, allocMock, fakePmemDev);
    174 
    175     int result = pma.init_pmem_area_locked();
    176     ASSERT_EQ(-ENOMEM, result);
    177 }
    178 
    179 /******************************************************************************/
    180 
    181 struct Deps_InitPmemAreaLockedWithEaccesOnGetPmemTotalSize : public DepsStub {
    182 
    183     virtual int open(const char* pathname, int flags, int mode) {
    184         EXPECT_EQ(fakePmemDev, pathname);
    185         EXPECT_EQ(O_RDWR, flags);
    186         EXPECT_EQ(0, mode);
    187         return 1234;
    188     }
    189 
    190     virtual size_t getPmemTotalSize(int fd, size_t* size) {
    191         EXPECT_EQ(1234, fd);
    192         return -EACCES;
    193     }
    194 };
    195 
    196 TEST(test_pmem_userspace_allocator, testInitPmemAreaLockedWthEaccesOnGetPmemTotalSize) {
    197     Deps_InitPmemAreaLockedWithEaccesOnGetPmemTotalSize depsMock;
    198     AllocatorStub allocStub;
    199     PmemUserspaceAllocator pma(depsMock, allocStub, fakePmemDev);
    200 
    201     int result = pma.init_pmem_area_locked();
    202     ASSERT_EQ(-EACCES, result);
    203 }
    204 
    205 /******************************************************************************/
    206 
    207 struct Deps_InitPmemAreaLockedWithEaccesOnOpen : public DepsStub {
    208 
    209     virtual int getErrno() {
    210         return EACCES;
    211     }
    212 
    213     virtual int open(const char* pathname, int flags, int mode) {
    214         EXPECT_EQ(fakePmemDev, pathname);
    215         EXPECT_EQ(O_RDWR, flags);
    216         EXPECT_EQ(0, mode);
    217         return -1;
    218     }
    219 };
    220 
    221 TEST(test_pmem_userspace_allocator, testInitPmemAreaLockedWithEaccesOnOpenMaster) {
    222     Deps_InitPmemAreaLockedWithEaccesOnOpen depsMock;
    223     AllocatorStub allocStub;
    224     PmemUserspaceAllocator pma(depsMock, allocStub, fakePmemDev);
    225 
    226     int result = pma.init_pmem_area_locked();
    227     ASSERT_EQ(-EACCES, result);
    228 }
    229 
    230 /******************************************************************************/
    231 
    232 typedef Deps_InitPmemAreaLockedWithSuccessfulCompletion Deps_InitPmemAreaWithSuccessfulInitialCompletion;
    233 
    234 TEST(test_pmem_userspace_allocator, testInitPmemAreaWithSuccessfulInitialCompletion) {
    235     Deps_InitPmemAreaWithSuccessfulInitialCompletion depsMock;
    236     AllocatorStub allocStub;
    237     PmemUserspaceAllocator pma(depsMock, allocStub, fakePmemDev);
    238 
    239     int result = pma.init_pmem_area();
    240     ASSERT_EQ(0, result);
    241 }
    242 
    243 /******************************************************************************/
    244 
    245 typedef Deps_InitPmemAreaLockedWithEaccesOnOpen Deps_InitPmemAreaWithEaccesOnInitLocked;
    246 
    247 TEST(test_pmem_userspace_allocator, testInitPmemAreaWithEaccesOnInitLocked) {
    248     Deps_InitPmemAreaWithEaccesOnInitLocked depsMock;
    249     AllocatorStub allocStub;
    250     PmemUserspaceAllocator pma(depsMock, allocStub, fakePmemDev);
    251 
    252     int result = pma.init_pmem_area();
    253     ASSERT_EQ(-EACCES, result);
    254 }
    255 
    256 /******************************************************************************/
    257 
    258 TEST(test_pmem_userspace_allocator, testInitPmemAreaAfterSuccessfulInitialCompletion) {
    259     DepsStub depsStub;
    260     AllocatorStub allocStub;
    261     PmemUserspaceAllocator pma(depsStub, allocStub, fakePmemDev);
    262 
    263     pma.set_master_values(1234, 0); // Indicate that the pma has been successfully init'd
    264 
    265     int result = pma.init_pmem_area();
    266     ASSERT_EQ(0, result);
    267     //XXX JMG: Add this back in maybe? ASSERT_EQ(1234, pmi.master); // Make sure the master fd wasn't changed
    268 }
    269 
    270 /******************************************************************************/
    271 
    272 TEST(test_pmem_userspace_allocator, testInitPmemAreaAfterFailedInit) {
    273     DepsStub depsStub;
    274     AllocatorStub allocStub;
    275     PmemUserspaceAllocator pma(depsStub, allocStub, fakePmemDev);
    276 
    277     pma.set_master_values(-EACCES, 0); // Indicate that the pma has failed init
    278 
    279     int result = pma.init_pmem_area();
    280     ASSERT_EQ(-EACCES, result);
    281 }
    282 
    283 /******************************************************************************/
    284 
    285 struct Deps_InitPmemAreaLockedWithSuccessfulCompletionWithNoFlags : public DepsStub {
    286 
    287     virtual int open(const char* pathname, int flags, int mode) {
    288         EXPECT_EQ(fakePmemDev, pathname);
    289         EXPECT_EQ(O_RDWR, flags & O_RDWR);
    290         EXPECT_EQ(0, mode);
    291         return 5678;
    292     }
    293 
    294     virtual int connectPmem(int fd, int master_fd) {
    295         EXPECT_EQ(5678, fd);
    296         EXPECT_EQ(1234, master_fd);
    297         return 0;
    298     }
    299 
    300     virtual int mapPmem(int fd, int offset, size_t size) {
    301         EXPECT_EQ(5678, fd);
    302         EXPECT_EQ(0x300, offset);
    303         EXPECT_EQ(size_t(0x100), size);
    304         return 0;
    305     }
    306 };
    307 
    308 
    309 struct Allocator_AllocPmemBufferWithSuccessfulCompletionWithNoFlags : public AllocatorStub {
    310 
    311     virtual ssize_t allocate(size_t size, uint32_t flags = 0) {
    312         EXPECT_EQ(size_t(0x100), size);
    313         EXPECT_EQ(uint32_t(0x0), flags);
    314         return 0x300;
    315     }
    316 };
    317 
    318 TEST(test_pmem_userspace_allocator, testAllocPmemBufferWithSuccessfulCompletionWithNoFlags) {
    319     Deps_InitPmemAreaLockedWithSuccessfulCompletionWithNoFlags depsMock;
    320     Allocator_AllocPmemBufferWithSuccessfulCompletionWithNoFlags allocMock;
    321     PmemUserspaceAllocator pma(depsMock, allocMock, fakePmemDev);
    322 
    323     uint8_t buf[0x300 + 0x100]; // Create a buffer to get memzero'd
    324     pma.set_master_values(1234, buf); // Indicate that the pma has been successfully init'd
    325 
    326     void* base = 0;
    327     int offset = -9182, fd = -9182;
    328     int size = 0x100;
    329     int flags = 0;
    330     int result = pma.alloc_pmem_buffer(size, flags, &base, &offset, &fd);
    331     ASSERT_EQ(0, result);
    332     ASSERT_EQ(0x300, offset);
    333     ASSERT_EQ(5678, fd);
    334     for (int i = 0x300; i < 0x400; ++i) {
    335         ASSERT_EQ(uint8_t(0), buf[i]);
    336     }
    337 }
    338 
    339 /******************************************************************************/
    340 
    341 typedef Deps_InitPmemAreaLockedWithSuccessfulCompletionWithNoFlags Deps_InitPmemAreaLockedWithSuccessfulCompletionWithAllFlags;
    342 
    343 typedef Allocator_AllocPmemBufferWithSuccessfulCompletionWithNoFlags Allocator_AllocPmemBufferWithSuccessfulCompletionWithAllFlags;
    344 
    345 TEST(test_pmem_userspace_allocator, testAllocPmemBufferWithSuccessfulCompletionWithAllFlags) {
    346     Deps_InitPmemAreaLockedWithSuccessfulCompletionWithAllFlags depsMock;
    347     Allocator_AllocPmemBufferWithSuccessfulCompletionWithAllFlags allocMock;
    348     PmemUserspaceAllocator pma(depsMock, allocMock, fakePmemDev);
    349 
    350     uint8_t buf[0x300 + 0x100]; // Create a buffer to get memzero'd
    351     pma.set_master_values(1234, buf); // Indicate that the pma has been successfully init'd
    352 
    353     void* base = 0;
    354     int offset = -9182, fd = -9182;
    355     int size = 0x100;
    356     int flags = ~0;
    357     int result = pma.alloc_pmem_buffer(size, flags, &base, &offset, &fd);
    358     ASSERT_EQ(0, result);
    359     ASSERT_EQ(0x300, offset);
    360     ASSERT_EQ(5678, fd);
    361     for (int i = 0x300; i < 0x400; ++i) {
    362         ASSERT_EQ(0, buf[i]);
    363     }
    364 }
    365 
    366 /******************************************************************************/
    367 
    368 struct Deps_InitPmemAreaLockedWithEnodevOnOpen : public Deps_InitPmemAreaLockedWithSuccessfulCompletionWithNoFlags {
    369 
    370     virtual int getErrno() {
    371         return ENODEV;
    372     }
    373 
    374     virtual int open(const char* pathname, int flags, int mode) {
    375         EXPECT_EQ(fakePmemDev, pathname);
    376         EXPECT_EQ(O_RDWR, flags & O_RDWR);
    377         EXPECT_EQ(0, mode);
    378         return -1;
    379     }
    380 };
    381 
    382 typedef Allocator_AllocPmemBufferWithSuccessfulCompletionWithNoFlags Allocator_AllocPmemBufferWithEnodevOnOpen;
    383 
    384 TEST(test_pmem_userspace_allocator, testAllocPmemBufferWithSuccessfulCompletionWithEnodevOnOpen) {
    385     Deps_InitPmemAreaLockedWithEnodevOnOpen depsMock;
    386     Allocator_AllocPmemBufferWithEnodevOnOpen allocMock;
    387     PmemUserspaceAllocator pma(depsMock, allocMock, fakePmemDev);
    388 
    389     uint8_t buf[0x300 + 0x100]; // Create a buffer to get memzero'd
    390     pma.set_master_values(1234, buf); // Indicate that the pma has been successfully init'd
    391 
    392     void* base = 0;
    393     int offset = -9182, fd = -9182;
    394     int size = 0x100;
    395     int flags = ~0;
    396     int result = pma.alloc_pmem_buffer(size, flags, &base, &offset, &fd);
    397     ASSERT_EQ(-ENODEV, result);
    398 }
    399 
    400 /******************************************************************************/
    401 
    402 struct Deps_InitPmemAreaLockedWithEnomemOnConnectPmem : public Deps_InitPmemAreaLockedWithSuccessfulCompletionWithNoFlags {
    403 
    404     virtual int getErrno() {
    405         return ENOMEM;
    406     }
    407 
    408     virtual int connectPmem(int fd, int master_fd) {
    409         EXPECT_EQ(5678, fd);
    410         EXPECT_EQ(1234, master_fd);
    411         return -1;
    412     }
    413 };
    414 
    415 typedef Allocator_AllocPmemBufferWithSuccessfulCompletionWithNoFlags Allocator_AllocPmemBufferWithEnomemOnConnectPmem;
    416 
    417 TEST(test_pmem_userspace_allocator, testAllocPmemBufferWithSuccessfulCompletionWithEnomemOnConnectPmem) {
    418     Deps_InitPmemAreaLockedWithEnomemOnConnectPmem depsMock;
    419     Allocator_AllocPmemBufferWithEnomemOnConnectPmem allocMock;
    420     PmemUserspaceAllocator pma(depsMock, allocMock, fakePmemDev);
    421 
    422     uint8_t buf[0x300 + 0x100]; // Create a buffer to get memzero'd
    423     pma.set_master_values(1234, buf); // Indicate that the pma has been successfully init'd
    424 
    425     void* base = 0;
    426     int offset = -9182, fd = -9182;
    427     int size = 0x100;
    428     int flags = ~0;
    429     int result = pma.alloc_pmem_buffer(size, flags, &base, &offset, &fd);
    430     ASSERT_EQ(-ENOMEM, result);
    431 }
    432 
    433 /******************************************************************************/
    434 
    435 struct Deps_InitPmemAreaLockedWithEnomemOnMapPmem : public Deps_InitPmemAreaLockedWithSuccessfulCompletionWithNoFlags {
    436 
    437     virtual int getErrno() {
    438         return ENOMEM;
    439     }
    440 
    441     virtual int mapPmem(int fd, int offset, size_t size) {
    442         EXPECT_EQ(5678, fd);
    443         EXPECT_EQ(0x300, offset);
    444         EXPECT_EQ(size_t(0x100), size);
    445         return -1;
    446     }
    447 };
    448 
    449 typedef Allocator_AllocPmemBufferWithSuccessfulCompletionWithNoFlags Allocator_AllocPmemBufferWithEnomemOnMapPmem;
    450 
    451 TEST(test_pmem_userspace_allocator, testAllocPmemBufferWithEnomemOnMapPmem) {
    452     Deps_InitPmemAreaLockedWithEnomemOnMapPmem depsMock;
    453     Allocator_AllocPmemBufferWithEnomemOnMapPmem allocMock;
    454     PmemUserspaceAllocator pma(depsMock, allocMock, fakePmemDev);
    455 
    456     uint8_t buf[0x300 + 0x100]; // Create a buffer to get memzero'd
    457     pma.set_master_values(1234, buf); // Indicate that the pma has been successfully init'd
    458 
    459     void* base = 0;
    460     int offset = -9182, fd = -9182;
    461     int size = 0x100;
    462     int flags = ~0;
    463     int result = pma.alloc_pmem_buffer(size, flags, &base, &offset, &fd);
    464     ASSERT_EQ(-ENOMEM, result);
    465 }
    466 
    467 /******************************************************************************/
    468 
    469 struct Deps_KernelAllocPmemBufferWithSuccessfulCompletionWithNoFlags : public DepsStub {
    470 
    471     void* mmapResult;
    472 
    473     Deps_KernelAllocPmemBufferWithSuccessfulCompletionWithNoFlags(void* mmapResult) :
    474             mmapResult(mmapResult) {}
    475 
    476     virtual int open(const char* pathname, int flags, int mode) {
    477         EXPECT_EQ(fakePmemDev, pathname);
    478         EXPECT_EQ(O_RDWR, flags & O_RDWR);
    479         EXPECT_EQ(0, mode);
    480         return 5678;
    481     }
    482 
    483     virtual void* mmap(void* start, size_t length, int prot, int flags, int fd,
    484             off_t offset) {
    485         EXPECT_EQ(5678, fd);
    486         return mmapResult;
    487     }
    488 };
    489 
    490 TEST(test_pmem_kernel_allocator, testAllocPmemBufferWithSuccessfulCompletionWithNoFlags) {
    491     uint8_t buf[0x100]; // Create a buffer to get memzero'd
    492     Deps_KernelAllocPmemBufferWithSuccessfulCompletionWithNoFlags depsMock(buf);
    493     PmemKernelAllocator pma(depsMock, fakePmemDev);
    494 
    495     void* base = 0;
    496     int offset = -9182, fd = -9182;
    497     int size = 0x100;
    498     int flags = 0;
    499     int result = pma.alloc_pmem_buffer(size, flags, &base, &offset, &fd);
    500     ASSERT_EQ(0, result);
    501     ASSERT_EQ(buf, base);
    502     ASSERT_EQ(0, offset);
    503     ASSERT_EQ(5678, fd);
    504     for (int i = 0; i < 0x100; ++i) {
    505         ASSERT_EQ(0, buf[i]);
    506     }
    507 }
    508 
    509 /******************************************************************************/
    510 
    511 typedef Deps_KernelAllocPmemBufferWithSuccessfulCompletionWithNoFlags Deps_KernelAllocPmemBufferWithSuccessfulCompletionWithAllFlags;
    512 
    513 TEST(test_pmem_kernel_allocator, testAllocPmemBufferWithSuccessfulCompletionWithAllFlags) {
    514     uint8_t buf[0x100]; // Create a buffer to get memzero'd
    515     Deps_KernelAllocPmemBufferWithSuccessfulCompletionWithAllFlags depsMock(buf);
    516     PmemKernelAllocator pma(depsMock, fakePmemDev);
    517 
    518     void* base = 0;
    519     int offset = -9182, fd = -9182;
    520     int size = 0x100;
    521     int flags = ~0;
    522     int result = pma.alloc_pmem_buffer(size, flags, &base, &offset, &fd);
    523     ASSERT_EQ(0, result);
    524     ASSERT_EQ(buf, base);
    525     ASSERT_EQ(0, offset);
    526     ASSERT_EQ(5678, fd);
    527     for (int i = 0; i < 0x100; ++i) {
    528         ASSERT_EQ(0, buf[i]);
    529     }
    530 }
    531 
    532 /******************************************************************************/
    533 
    534 struct Deps_KernelAllocPmemBufferWithEpermOnOpen : public DepsStub {
    535 
    536     virtual int getErrno() {
    537         return EPERM;
    538     }
    539 
    540     virtual int open(const char* pathname, int flags, int mode) {
    541         EXPECT_EQ(fakePmemDev, pathname);
    542         EXPECT_EQ(O_RDWR, flags & O_RDWR);
    543         EXPECT_EQ(0, mode);
    544         return -1;
    545     }
    546 };
    547 
    548 
    549 TEST(test_pmem_kernel_allocator, testAllocPmemBufferWithEpermOnOpen) {
    550     Deps_KernelAllocPmemBufferWithEpermOnOpen depsMock;
    551     PmemKernelAllocator pma(depsMock, fakePmemDev);
    552 
    553     void* base = 0;
    554     int offset = -9182, fd = -9182;
    555     int size = 0x100;
    556     int flags = ~0;
    557     int result = pma.alloc_pmem_buffer(size, flags, &base, &offset, &fd);
    558     ASSERT_EQ(-EPERM, result);
    559     ASSERT_EQ(0, base);
    560     ASSERT_EQ(0, offset);
    561     ASSERT_EQ(-1, fd);
    562 }
    563 
    564 /******************************************************************************/
    565 
    566 struct Deps_KernelAllocPmemBufferWithEnomemOnMmap : DepsStub {
    567 
    568     virtual int open(const char* pathname, int flags, int mode) {
    569         EXPECT_EQ(fakePmemDev, pathname);
    570         EXPECT_EQ(O_RDWR, flags & O_RDWR);
    571         EXPECT_EQ(0, mode);
    572         return 5678;
    573     }
    574 
    575     virtual void* mmap(void* start, size_t length, int prot, int flags, int fd,
    576             off_t offset) {
    577         return (void*)MAP_FAILED;
    578     }
    579 
    580     virtual int getErrno() {
    581         return ENOMEM;
    582     }
    583 };
    584 
    585 
    586 TEST(test_pmem_kernel_allocator, testAllocPmemBufferWithEnomemOnMmap) {
    587     Deps_KernelAllocPmemBufferWithEnomemOnMmap depsMock;
    588     PmemKernelAllocator pma(depsMock, fakePmemDev);
    589 
    590     void* base = 0;
    591     int offset = -9182, fd = -9182;
    592     int size = 0x100;
    593     int flags = ~0;
    594     int result = pma.alloc_pmem_buffer(size, flags, &base, &offset, &fd);
    595     ASSERT_EQ(-ENOMEM, result);
    596     ASSERT_EQ(0, base);
    597     ASSERT_EQ(0, offset);
    598     ASSERT_EQ(-1, fd);
    599 }
    600 
    601 /******************************************************************************/
    602