From 8a7086296c145494ca35f93cd9c4f45a1c646689 Mon Sep 17 00:00:00 2001 From: Hridya Valsaraju Date: Mon, 6 Mar 2017 14:10:42 -0800 Subject: [PATCH] Move FMQ tests to hardware/interfaces Test: FMQ unit tests pass Bug: 32284445 Change-Id: I1daf563560d12fc7a4433ae98876331c37509980 --- tests/Android.bp | 1 + tests/msgq/1.0/default/Android.bp | 19 ++++ tests/msgq/1.0/default/TestMsgQ.cpp | 135 ++++++++++++++++++++++++++++ tests/msgq/1.0/default/TestMsgQ.h | 77 ++++++++++++++++ 4 files changed, 232 insertions(+) create mode 100644 tests/msgq/1.0/default/Android.bp create mode 100644 tests/msgq/1.0/default/TestMsgQ.cpp create mode 100644 tests/msgq/1.0/default/TestMsgQ.h diff --git a/tests/Android.bp b/tests/Android.bp index 41043d9e95..9bb4bf5c2b 100644 --- a/tests/Android.bp +++ b/tests/Android.bp @@ -15,6 +15,7 @@ subdirs = [ "memory/1.0", "memory/1.0/default", "msgq/1.0", + "msgq/1.0/default", "pointer/1.0", "pointer/1.0/default", "pointer/1.0/default/lib", diff --git a/tests/msgq/1.0/default/Android.bp b/tests/msgq/1.0/default/Android.bp new file mode 100644 index 0000000000..b53fcd38df --- /dev/null +++ b/tests/msgq/1.0/default/Android.bp @@ -0,0 +1,19 @@ +cc_library_shared { + name: "android.hardware.tests.msgq@1.0-impl", + relative_install_path: "hw", + proprietary: true, + srcs: [ + "TestMsgQ.cpp", + ], + shared_libs: [ + "libbase", + "libcutils", + "libfmq", + "libhidlbase", + "libhidltransport", + "liblog", + "libutils", + "android.hardware.tests.msgq@1.0", + "android.hidl.base@1.0", + ], +} diff --git a/tests/msgq/1.0/default/TestMsgQ.cpp b/tests/msgq/1.0/default/TestMsgQ.cpp new file mode 100644 index 0000000000..7cc4f5b76c --- /dev/null +++ b/tests/msgq/1.0/default/TestMsgQ.cpp @@ -0,0 +1,135 @@ +#include "TestMsgQ.h" + +namespace android { +namespace hardware { +namespace tests { +namespace msgq { +namespace V1_0 { +namespace implementation { + +// Methods from ::android::hardware::tests::msgq::V1_0::ITestMsgQ follow. +Return TestMsgQ::configureFmqSyncReadWrite(configureFmqSyncReadWrite_cb _hidl_cb) { + static constexpr size_t kNumElementsInQueue = 1024; + mFmqSynchronized.reset(new (std::nothrow) MessageQueueSync( + kNumElementsInQueue, true /* configureEventFlagWord */)); + if ((mFmqSynchronized == nullptr) || (mFmqSynchronized->isValid() == false)) { + _hidl_cb(false /* ret */, MessageQueueSync::Descriptor()); + } else { + /* + * Initialize the EventFlag word with bit FMQ_NOT_FULL. + */ + auto evFlagWordPtr = mFmqSynchronized->getEventFlagWord(); + if (evFlagWordPtr != nullptr) { + std::atomic_init(evFlagWordPtr, + static_cast(ITestMsgQ::EventFlagBits::FMQ_NOT_FULL)); + } + _hidl_cb(true /* ret */, *mFmqSynchronized->getDesc()); + } + return Void(); +} + +Return TestMsgQ::getFmqUnsyncWrite(bool configureFmq, getFmqUnsyncWrite_cb _hidl_cb) { + if (configureFmq) { + static constexpr size_t kNumElementsInQueue = 1024; + mFmqUnsynchronized.reset(new (std::nothrow) MessageQueueUnsync(kNumElementsInQueue)); + } + if ((mFmqUnsynchronized == nullptr) || + (mFmqUnsynchronized->isValid() == false)) { + _hidl_cb(false /* ret */, MessageQueueUnsync::Descriptor()); + } else { + _hidl_cb(true /* ret */, *mFmqUnsynchronized->getDesc()); + } + return Void(); +} + +Return TestMsgQ::requestWriteFmqSync(int32_t count) { + std::vector data(count); + for (int i = 0; i < count; i++) { + data[i] = i; + } + bool result = mFmqSynchronized->write(&data[0], count); + return result; +} + +Return TestMsgQ::requestReadFmqSync(int32_t count) { + std::vector data(count); + bool result = mFmqSynchronized->read(&data[0], count) + && verifyData(&data[0], count); + return result; +} + +Return TestMsgQ::requestWriteFmqUnsync(int32_t count) { + std::vector data(count); + for (int i = 0; i < count; i++) { + data[i] = i; + } + bool result = mFmqUnsynchronized->write(&data[0], count); + return result; +} + +Return TestMsgQ::requestReadFmqUnsync(int32_t count) { + std::vector data(count); + bool result = + mFmqUnsynchronized->read(&data[0], count) && verifyData(&data[0], count); + return result; +} + +Return TestMsgQ::requestBlockingRead(int32_t count) { + std::vector data(count); + bool result = mFmqSynchronized->readBlocking( + &data[0], + count, + static_cast(ITestMsgQ::EventFlagBits::FMQ_NOT_FULL), + static_cast(ITestMsgQ::EventFlagBits::FMQ_NOT_EMPTY), + 5000000000 /* timeOutNanos */); + + if (result == false) { + ALOGE("Blocking read fails"); + } + return Void(); +} + +Return TestMsgQ::requestBlockingReadDefaultEventFlagBits(int32_t count) { + std::vector data(count); + bool result = mFmqSynchronized->readBlocking( + &data[0], + count); + + if (result == false) { + ALOGE("Blocking read fails"); + } + + return Void(); +} + +Return TestMsgQ::requestBlockingReadRepeat(int32_t count, int32_t numIter) { + std::vector data(count); + for (int i = 0; i < numIter; i++) { + bool result = mFmqSynchronized->readBlocking( + &data[0], + count, + static_cast(ITestMsgQ::EventFlagBits::FMQ_NOT_FULL), + static_cast(ITestMsgQ::EventFlagBits::FMQ_NOT_EMPTY), + 5000000000 /* timeOutNanos */); + + if (result == false) { + ALOGE("Blocking read fails"); + break; + } + } + return Void(); +} + + +// Methods from ::android::hidl::base::V1_0::IBase follow. + +ITestMsgQ* HIDL_FETCH_ITestMsgQ(const char* /* name */) { + return new TestMsgQ(); +} + +} // namespace implementation +} // namespace V1_0 +} // namespace msgq +} // namespace tests +} // namespace hardware +} // namespace android diff --git a/tests/msgq/1.0/default/TestMsgQ.h b/tests/msgq/1.0/default/TestMsgQ.h new file mode 100644 index 0000000000..760d931391 --- /dev/null +++ b/tests/msgq/1.0/default/TestMsgQ.h @@ -0,0 +1,77 @@ +#ifndef ANDROID_HARDWARE_TESTS_MSGQ_V1_0_TESTMSGQ_H +#define ANDROID_HARDWARE_TESTS_MSGQ_V1_0_TESTMSGQ_H + +#include +#include +#include +#include +#include + +namespace android { +namespace hardware { +namespace tests { +namespace msgq { +namespace V1_0 { +namespace implementation { + +using ::android::hardware::tests::msgq::V1_0::ITestMsgQ; +using ::android::hidl::base::V1_0::DebugInfo; +using ::android::hidl::base::V1_0::IBase; +using ::android::hardware::hidl_array; +using ::android::hardware::hidl_memory; +using ::android::hardware::hidl_string; +using ::android::hardware::hidl_vec; +using ::android::hardware::Return; +using ::android::hardware::Void; +using ::android::sp; + +using android::hardware::kSynchronizedReadWrite; +using android::hardware::kUnsynchronizedWrite; +using android::hardware::MQDescriptorSync; +using android::hardware::MQDescriptorUnsync; + +using android::hardware::MessageQueue; + +struct TestMsgQ : public ITestMsgQ { + typedef MessageQueue MessageQueueSync; + typedef MessageQueue MessageQueueUnsync; + + TestMsgQ() : mFmqSynchronized(nullptr), mFmqUnsynchronized(nullptr) {} + + // Methods from ::android::hardware::tests::msgq::V1_0::ITestMsgQ follow. + Return configureFmqSyncReadWrite(configureFmqSyncReadWrite_cb _hidl_cb) override; + Return getFmqUnsyncWrite(bool configureFmq, getFmqUnsyncWrite_cb _hidl_cb) override; + Return requestWriteFmqSync(int32_t count) override; + Return requestReadFmqSync(int32_t count) override; + Return requestWriteFmqUnsync(int32_t count) override; + Return requestReadFmqUnsync(int32_t count) override; + Return requestBlockingRead(int32_t count) override; + Return requestBlockingReadDefaultEventFlagBits(int32_t count) override; + Return requestBlockingReadRepeat(int32_t count, int32_t numIter) override; + + // Methods from ::android::hidl::base::V1_0::IBase follow. +private: + std::unique_ptr mFmqSynchronized; + std::unique_ptr mFmqUnsynchronized; + + /* + * Utility function to verify data read from the fast message queue. + */ + bool verifyData(uint16_t* data, int count) { + for (int i = 0; i < count; i++) { + if (data[i] != i) return false; + } + return true; + } +}; + +extern "C" ITestMsgQ* HIDL_FETCH_ITestMsgQ(const char* name); + +} // namespace implementation +} // namespace V1_0 +} // namespace msgq +} // namespace tests +} // namespace hardware +} // namespace android + +#endif // ANDROID_HARDWARE_TESTS_MSGQ_V1_0_TESTMSGQ_H