bufferpool2.0 tests: add read/write verification

Bug: 112203066
Bug: 113798958
Change-Id: I3969903c7263654bf1fecf012cf9185acd60ef58

media/bufferpool/2.0/tests/allocator.cpp

@@ -15,6 +15,7 @@
  */
 
 #include <cutils/ashmem.h>
+#include <sys/mman.h>
 #include "allocator.h"
 
 union Params {
@@ -42,6 +43,8 @@ struct HandleAshmem : public native_handle_t {
         | size_t(uint64_t(unsigned(mInts.mSizeHi)) << 32);
   }
 
+  static bool isValid(const native_handle_t * const o);
+
 protected:
   struct {
     int mAshmem;
@@ -69,6 +72,14 @@ const native_handle_t HandleAshmem::cHeader = {
   {}
 };
 
+bool HandleAshmem::isValid(const native_handle_t * const o) {
+  if (!o || memcmp(o, &cHeader, sizeof(cHeader))) {
+    return false;
+  }
+  const HandleAshmem *other = static_cast<const HandleAshmem*>(o);
+  return other->mInts.mMagic == kMagic;
+}
+
 class AllocationAshmem {
 private:
   AllocationAshmem(int ashmemFd, size_t capacity, bool res)
@@ -150,6 +161,46 @@ bool TestBufferPoolAllocator::compatible(const std::vector<uint8_t> &newParams,
   return false;
 }
 
+bool TestBufferPoolAllocator::Fill(const native_handle_t *handle, const unsigned char val) {
+  if (!HandleAshmem::isValid(handle)) {
+    return false;
+  }
+  const HandleAshmem *o = static_cast<const HandleAshmem*>(handle);
+  unsigned char *ptr = (unsigned char *)mmap(
+      NULL, o->size(), PROT_READ|PROT_WRITE, MAP_SHARED, o->ashmemFd(), 0);
+
+  if (ptr != MAP_FAILED) {
+    for (size_t i = 0; i < o->size(); ++i) {
+      ptr[i] = val;
+    }
+    munmap(ptr, o->size());
+    return true;
+  }
+  return false;
+}
+
+bool TestBufferPoolAllocator::Verify(const native_handle_t *handle, const unsigned char val) {
+  if (!HandleAshmem::isValid(handle)) {
+    return false;
+  }
+  const HandleAshmem *o = static_cast<const HandleAshmem*>(handle);
+  unsigned char *ptr = (unsigned char *)mmap(
+      NULL, o->size(), PROT_READ, MAP_SHARED, o->ashmemFd(), 0);
+
+  if (ptr != MAP_FAILED) {
+    bool res = true;
+    for (size_t i = 0; i < o->size(); ++i) {
+      if (ptr[i] != val) {
+        res = false;
+        break;
+      }
+    }
+    munmap(ptr, o->size());
+    return res;
+  }
+  return false;
+}
+
 void getTestAllocatorParams(std::vector<uint8_t> *params) {
   constexpr static int kAllocationSize = 1024 * 10;
   Params ashmemParams(kAllocationSize);

media/bufferpool/2.0/tests/allocator.h

@@ -39,6 +39,10 @@ class TestBufferPoolAllocator : public BufferPoolAllocator {
   bool compatible(const std::vector<uint8_t> &newParams,
                   const std::vector<uint8_t> &oldParams) override;
 
+  static bool Fill(const native_handle_t *handle, const unsigned char val);
+
+  static bool Verify(const native_handle_t *handle, const unsigned char val);
+
 };
 
 // retrieve buffer allocator paramters

media/bufferpool/2.0/tests/multi.cpp

@@ -161,9 +161,11 @@ class BufferpoolMultiTest : public ::testing::Test {
           message.data.bufferId, message.data.timestampUs, &rhandle, &rbuffer);
       mManager->close(message.data.connectionId);
       if (status != ResultStatus::OK) {
-        message.data.command = PipeCommand::RECEIVE_ERROR;
-        sendMessage(mResultPipeFds, message);
-        return;
+        if (!TestBufferPoolAllocator::Verify(rhandle, 0x77)) {
+          message.data.command = PipeCommand::RECEIVE_ERROR;
+          sendMessage(mResultPipeFds, message);
+          return;
+        }
       }
     }
     message.data.command = PipeCommand::RECEIVE_OK;
@@ -195,6 +197,8 @@ TEST_F(BufferpoolMultiTest, TransferBuffer) {
     status = mManager->allocate(mConnectionId, vecParams, &shandle, &sbuffer);
     ASSERT_TRUE(status == ResultStatus::OK);
 
+    ASSERT_TRUE(TestBufferPoolAllocator::Fill(shandle, 0x77));
+
     status = mManager->postSend(receiverId, sbuffer, &transactionId, &postUs);
     ASSERT_TRUE(status == ResultStatus::OK);
 

media/bufferpool/2.0/tests/single.cpp

@@ -147,11 +147,13 @@ TEST_F(BufferpoolSingleTest, TransferBuffer) {
 
   status = mManager->allocate(mConnectionId, vecParams, &allocHandle, &sbuffer);
   ASSERT_TRUE(status == ResultStatus::OK);
+  ASSERT_TRUE(TestBufferPoolAllocator::Fill(allocHandle, 0x77));
   status = mManager->postSend(mReceiverId, sbuffer, &transactionId, &postUs);
   ASSERT_TRUE(status == ResultStatus::OK);
   status = mManager->receive(mReceiverId, transactionId, sbuffer->mId, postUs,
                              &recvHandle, &rbuffer);
   EXPECT_TRUE(status == ResultStatus::OK);
+  ASSERT_TRUE(TestBufferPoolAllocator::Verify(recvHandle, 0x77));
 }
 
 }  // anonymous namespace