commit 982dc2bfa46c04c016402b1a050675b2a8ecd950
author Hridya Valsaraju <hridya@google.com> Tue Dec 19 18:35:20 2017 +0000
committer android-build-merger <android-build-merger@google.com> Tue Dec 19 18:35:20 2017 +0000
tree 7ae79bd7688f3ce3c9976ab4235dbee6a7ab3cdf
parent d7937c1cbee063b418104464dc24a9216e350cf9
parent fd704122b08a9b6662c87dab2b445dd0d5fc02f7

Modify blocking test cases to not proceed without waiting for service
am: fd704122b0

Change-Id: Ie8a79d72f82ec9a8fd887209fe11c166e8c9df1e

tests/msgq_test_client.cpp

diff --git a/tests/msgq_test_client.cpp b/tests/msgq_test_client.cpp
index 4416c54..50664f7 100644
--- a/tests/msgq_test_client.cpp
+++ b/tests/msgq_test_client.cpp
@@ -244,6 +244,11 @@
                                      static_cast<uint32_t>(ITestMsgQ::EventFlagBits::FMQ_NOT_EMPTY),
                                      5000000000 /* timeOutNanos */);
     ASSERT_TRUE(ret);
+    ret = mQueue->writeBlocking(data, mNumMessagesMax,
+                                static_cast<uint32_t>(ITestMsgQ::EventFlagBits::FMQ_NOT_FULL),
+                                static_cast<uint32_t>(ITestMsgQ::EventFlagBits::FMQ_NOT_EMPTY),
+                                5000000000 /* timeOutNanos */);
+    ASSERT_TRUE(ret);
 }
 
 /*
@@ -286,6 +291,7 @@
 TEST_F(SynchronizedReadWriteClient, BlockingReadWriteRepeat1) {
     const size_t dataLen = 64;
     uint16_t data[dataLen] = {0};
+    bool ret = false;
 
     /*
      * Request service to perform a blocking read. This call is oneway and will
@@ -295,14 +301,19 @@
     mService->requestBlockingReadRepeat(dataLen, writeCount);
 
     for (size_t i = 0; i < writeCount; i++) {
-        bool ret = mQueue->writeBlocking(
-                data,
-                dataLen,
-                static_cast<uint32_t>(ITestMsgQ::EventFlagBits::FMQ_NOT_FULL),
-                static_cast<uint32_t>(ITestMsgQ::EventFlagBits::FMQ_NOT_EMPTY),
-                5000000000 /* timeOutNanos */);
+        ret = mQueue->writeBlocking(data, dataLen,
+                                    static_cast<uint32_t>(ITestMsgQ::EventFlagBits::FMQ_NOT_FULL),
+                                    static_cast<uint32_t>(ITestMsgQ::EventFlagBits::FMQ_NOT_EMPTY),
+                                    5000000000 /* timeOutNanos */);
         ASSERT_TRUE(ret);
     }
+
+    ret = mQueue->writeBlocking(data, mNumMessagesMax,
+                                static_cast<uint32_t>(ITestMsgQ::EventFlagBits::FMQ_NOT_FULL),
+                                static_cast<uint32_t>(ITestMsgQ::EventFlagBits::FMQ_NOT_EMPTY),
+                                5000000000 /* timeOutNanos */);
+
+    ASSERT_TRUE(ret);
 }
 
 /*
@@ -314,6 +325,7 @@
 TEST_F(SynchronizedReadWriteClient, BlockingReadWriteRepeat2) {
     const size_t dataLen = 64;
     uint16_t data[dataLen] = {0};
+    bool ret = false;
 
     /*
      * Request service to perform a blocking read. This call is oneway and will
@@ -323,14 +335,18 @@
     mService->requestBlockingReadRepeat(dataLen*2, writeCount/2);
 
     for (size_t i = 0; i < writeCount; i++) {
-        bool ret = mQueue->writeBlocking(
-                data,
-                dataLen,
-                static_cast<uint32_t>(ITestMsgQ::EventFlagBits::FMQ_NOT_FULL),
-                static_cast<uint32_t>(ITestMsgQ::EventFlagBits::FMQ_NOT_EMPTY),
-                5000000000 /* timeOutNanos */);
+        ret = mQueue->writeBlocking(data, dataLen,
+                                    static_cast<uint32_t>(ITestMsgQ::EventFlagBits::FMQ_NOT_FULL),
+                                    static_cast<uint32_t>(ITestMsgQ::EventFlagBits::FMQ_NOT_EMPTY),
+                                    5000000000 /* timeOutNanos */);
         ASSERT_TRUE(ret);
     }
+
+    ret = mQueue->writeBlocking(data, mNumMessagesMax,
+                                static_cast<uint32_t>(ITestMsgQ::EventFlagBits::FMQ_NOT_FULL),
+                                static_cast<uint32_t>(ITestMsgQ::EventFlagBits::FMQ_NOT_EMPTY),
+                                5000000000 /* timeOutNanos */);
+    ASSERT_TRUE(ret);
 }
 
 /*
@@ -341,6 +357,7 @@
 TEST_F(SynchronizedReadWriteClient, BlockingReadWriteRepeat3) {
     const size_t dataLen = 64;
     uint16_t data[dataLen] = {0};
+    bool ret = false;
 
     /*
      * Request service to perform a blocking read. This call is oneway and will
@@ -350,14 +367,17 @@
     mService->requestBlockingReadRepeat(dataLen/2, writeCount*2);
 
     for (size_t i = 0; i < writeCount; i++) {
-        bool ret = mQueue->writeBlocking(
-                data,
-                dataLen,
-                static_cast<uint32_t>(ITestMsgQ::EventFlagBits::FMQ_NOT_FULL),
-                static_cast<uint32_t>(ITestMsgQ::EventFlagBits::FMQ_NOT_EMPTY),
-                5000000000 /* timeOutNanos */);
+        ret = mQueue->writeBlocking(data, dataLen,
+                                    static_cast<uint32_t>(ITestMsgQ::EventFlagBits::FMQ_NOT_FULL),
+                                    static_cast<uint32_t>(ITestMsgQ::EventFlagBits::FMQ_NOT_EMPTY),
+                                    5000000000 /* timeOutNanos */);
         ASSERT_TRUE(ret);
     }
+    ret = mQueue->writeBlocking(data, mNumMessagesMax,
+                                static_cast<uint32_t>(ITestMsgQ::EventFlagBits::FMQ_NOT_FULL),
+                                static_cast<uint32_t>(ITestMsgQ::EventFlagBits::FMQ_NOT_EMPTY),
+                                5000000000 /* timeOutNanos */);
+    ASSERT_TRUE(ret);
 }
 
 /*