/*
|
* Copyright (C) 2016 The Android Open Source Project
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*/
|
|
#include <asm-generic/mman.h>
|
#include <gtest/gtest.h>
|
#include <atomic>
|
#include <cstdlib>
|
#include <sstream>
|
#include <thread>
|
#include <fmq/MessageQueue.h>
|
#include <fmq/EventFlag.h>
|
|
enum EventFlagBits : uint32_t {
|
kFmqNotEmpty = 1 << 0,
|
kFmqNotFull = 1 << 1,
|
};
|
|
typedef android::hardware::MessageQueue<uint8_t, android::hardware::kSynchronizedReadWrite>
|
MessageQueueSync;
|
typedef android::hardware::MessageQueue<uint8_t, android::hardware::kUnsynchronizedWrite>
|
MessageQueueUnsync;
|
|
class SynchronizedReadWrites : public ::testing::Test {
|
protected:
|
virtual void TearDown() {
|
delete mQueue;
|
}
|
|
virtual void SetUp() {
|
static constexpr size_t kNumElementsInQueue = 2048;
|
mQueue = new (std::nothrow) MessageQueueSync(kNumElementsInQueue);
|
ASSERT_NE(nullptr, mQueue);
|
ASSERT_TRUE(mQueue->isValid());
|
mNumMessagesMax = mQueue->getQuantumCount();
|
ASSERT_EQ(kNumElementsInQueue, mNumMessagesMax);
|
}
|
|
MessageQueueSync* mQueue = nullptr;
|
size_t mNumMessagesMax = 0;
|
};
|
|
class UnsynchronizedWrite : public ::testing::Test {
|
protected:
|
virtual void TearDown() {
|
delete mQueue;
|
}
|
|
virtual void SetUp() {
|
static constexpr size_t kNumElementsInQueue = 2048;
|
mQueue = new (std::nothrow) MessageQueueUnsync(kNumElementsInQueue);
|
ASSERT_NE(nullptr, mQueue);
|
ASSERT_TRUE(mQueue->isValid());
|
mNumMessagesMax = mQueue->getQuantumCount();
|
ASSERT_EQ(kNumElementsInQueue, mNumMessagesMax);
|
}
|
|
MessageQueueUnsync* mQueue = nullptr;
|
size_t mNumMessagesMax = 0;
|
};
|
|
class BlockingReadWrites : public ::testing::Test {
|
protected:
|
virtual void TearDown() {
|
delete mQueue;
|
}
|
virtual void SetUp() {
|
static constexpr size_t kNumElementsInQueue = 2048;
|
mQueue = new (std::nothrow) MessageQueueSync(kNumElementsInQueue);
|
ASSERT_NE(nullptr, mQueue);
|
ASSERT_TRUE(mQueue->isValid());
|
mNumMessagesMax = mQueue->getQuantumCount();
|
ASSERT_EQ(kNumElementsInQueue, mNumMessagesMax);
|
/*
|
* Initialize the EventFlag word to indicate Queue is not full.
|
*/
|
std::atomic_init(&mFw, static_cast<uint32_t>(kFmqNotFull));
|
}
|
|
MessageQueueSync* mQueue;
|
std::atomic<uint32_t> mFw;
|
size_t mNumMessagesMax = 0;
|
};
|
|
class QueueSizeOdd : public ::testing::Test {
|
protected:
|
virtual void TearDown() {
|
delete mQueue;
|
}
|
virtual void SetUp() {
|
static constexpr size_t kNumElementsInQueue = 2049;
|
mQueue = new (std::nothrow) MessageQueueSync(kNumElementsInQueue,
|
true /* configureEventFlagWord */);
|
ASSERT_NE(nullptr, mQueue);
|
ASSERT_TRUE(mQueue->isValid());
|
mNumMessagesMax = mQueue->getQuantumCount();
|
ASSERT_EQ(kNumElementsInQueue, mNumMessagesMax);
|
auto evFlagWordPtr = mQueue->getEventFlagWord();
|
ASSERT_NE(nullptr, evFlagWordPtr);
|
/*
|
* Initialize the EventFlag word to indicate Queue is not full.
|
*/
|
std::atomic_init(evFlagWordPtr, static_cast<uint32_t>(kFmqNotFull));
|
}
|
|
MessageQueueSync* mQueue;
|
size_t mNumMessagesMax = 0;
|
};
|
|
class BadQueueConfig: public ::testing::Test {
|
};
|
|
/*
|
* Utility function to initialize data to be written to the FMQ
|
*/
|
inline void initData(uint8_t* data, size_t count) {
|
for (size_t i = 0; i < count; i++) {
|
data[i] = i & 0xFF;
|
}
|
}
|
|
/*
|
* This thread will attempt to read and block. When wait returns
|
* it checks if the kFmqNotEmpty bit is actually set.
|
* If the read is succesful, it signals Wake to kFmqNotFull.
|
*/
|
void ReaderThreadBlocking(
|
android::hardware::MessageQueue<uint8_t,
|
android::hardware::kSynchronizedReadWrite>* fmq,
|
std::atomic<uint32_t>* fwAddr) {
|
const size_t dataLen = 64;
|
uint8_t data[dataLen];
|
android::hardware::EventFlag* efGroup = nullptr;
|
android::status_t status = android::hardware::EventFlag::createEventFlag(fwAddr, &efGroup);
|
ASSERT_EQ(android::NO_ERROR, status);
|
ASSERT_NE(nullptr, efGroup);
|
|
while (true) {
|
uint32_t efState = 0;
|
android::status_t ret = efGroup->wait(kFmqNotEmpty,
|
&efState,
|
5000000000 /* timeoutNanoSeconds */);
|
/*
|
* Wait should not time out here after 5s
|
*/
|
ASSERT_NE(android::TIMED_OUT, ret);
|
|
if ((efState & kFmqNotEmpty) && fmq->read(data, dataLen)) {
|
efGroup->wake(kFmqNotFull);
|
break;
|
}
|
}
|
|
status = android::hardware::EventFlag::deleteEventFlag(&efGroup);
|
ASSERT_EQ(android::NO_ERROR, status);
|
}
|
|
/*
|
* This thread will attempt to read and block using the readBlocking() API and
|
* passes in a pointer to an EventFlag object.
|
*/
|
void ReaderThreadBlocking2(
|
android::hardware::MessageQueue<uint8_t,
|
android::hardware::kSynchronizedReadWrite>* fmq,
|
std::atomic<uint32_t>* fwAddr) {
|
const size_t dataLen = 64;
|
uint8_t data[dataLen];
|
android::hardware::EventFlag* efGroup = nullptr;
|
android::status_t status = android::hardware::EventFlag::createEventFlag(fwAddr, &efGroup);
|
ASSERT_EQ(android::NO_ERROR, status);
|
ASSERT_NE(nullptr, efGroup);
|
bool ret = fmq->readBlocking(data,
|
dataLen,
|
static_cast<uint32_t>(kFmqNotFull),
|
static_cast<uint32_t>(kFmqNotEmpty),
|
5000000000 /* timeOutNanos */,
|
efGroup);
|
ASSERT_TRUE(ret);
|
status = android::hardware::EventFlag::deleteEventFlag(&efGroup);
|
ASSERT_EQ(android::NO_ERROR, status);
|
}
|
|
|
TEST_F(BadQueueConfig, QueueSizeTooLarge) {
|
typedef android::hardware::MessageQueue<uint16_t, android::hardware::kSynchronizedReadWrite>
|
MessageQueueSync16;
|
size_t numElementsInQueue = SIZE_MAX / sizeof(uint16_t) + 1;
|
MessageQueueSync16 * fmq = new (std::nothrow) MessageQueueSync16(numElementsInQueue);
|
ASSERT_NE(nullptr, fmq);
|
/*
|
* Should fail due to size being too large to fit into size_t.
|
*/
|
ASSERT_FALSE(fmq->isValid());
|
}
|
|
/*
|
* Test that basic blocking works. This test uses the non-blocking read()/write()
|
* APIs.
|
*/
|
TEST_F(BlockingReadWrites, SmallInputTest1) {
|
const size_t dataLen = 64;
|
uint8_t data[dataLen] = {0};
|
|
android::hardware::EventFlag* efGroup = nullptr;
|
android::status_t status = android::hardware::EventFlag::createEventFlag(&mFw, &efGroup);
|
|
ASSERT_EQ(android::NO_ERROR, status);
|
ASSERT_NE(nullptr, efGroup);
|
|
/*
|
* Start a thread that will try to read and block on kFmqNotEmpty.
|
*/
|
std::thread Reader(ReaderThreadBlocking, mQueue, &mFw);
|
struct timespec waitTime = {0, 100 * 1000000};
|
ASSERT_EQ(0, nanosleep(&waitTime, NULL));
|
|
/*
|
* After waiting for some time write into the FMQ
|
* and call Wake on kFmqNotEmpty.
|
*/
|
ASSERT_TRUE(mQueue->write(data, dataLen));
|
status = efGroup->wake(kFmqNotEmpty);
|
ASSERT_EQ(android::NO_ERROR, status);
|
|
ASSERT_EQ(0, nanosleep(&waitTime, NULL));
|
Reader.join();
|
|
status = android::hardware::EventFlag::deleteEventFlag(&efGroup);
|
ASSERT_EQ(android::NO_ERROR, status);
|
}
|
|
/*
|
* Test that basic blocking works. This test uses the
|
* writeBlocking()/readBlocking() APIs.
|
*/
|
TEST_F(BlockingReadWrites, SmallInputTest2) {
|
const size_t dataLen = 64;
|
uint8_t data[dataLen] = {0};
|
|
android::hardware::EventFlag* efGroup = nullptr;
|
android::status_t status = android::hardware::EventFlag::createEventFlag(&mFw, &efGroup);
|
|
ASSERT_EQ(android::NO_ERROR, status);
|
ASSERT_NE(nullptr, efGroup);
|
|
/*
|
* Start a thread that will try to read and block on kFmqNotEmpty. It will
|
* call wake() on kFmqNotFull when the read is successful.
|
*/
|
std::thread Reader(ReaderThreadBlocking2, mQueue, &mFw);
|
bool ret = mQueue->writeBlocking(data,
|
dataLen,
|
static_cast<uint32_t>(kFmqNotFull),
|
static_cast<uint32_t>(kFmqNotEmpty),
|
5000000000 /* timeOutNanos */,
|
efGroup);
|
ASSERT_TRUE(ret);
|
Reader.join();
|
|
status = android::hardware::EventFlag::deleteEventFlag(&efGroup);
|
ASSERT_EQ(android::NO_ERROR, status);
|
}
|
|
/*
|
* Test that basic blocking times out as intended.
|
*/
|
TEST_F(BlockingReadWrites, BlockingTimeOutTest) {
|
android::hardware::EventFlag* efGroup = nullptr;
|
android::status_t status = android::hardware::EventFlag::createEventFlag(&mFw, &efGroup);
|
|
ASSERT_EQ(android::NO_ERROR, status);
|
ASSERT_NE(nullptr, efGroup);
|
|
/* Block on an EventFlag bit that no one will wake and time out in 1s */
|
uint32_t efState = 0;
|
android::status_t ret = efGroup->wait(kFmqNotEmpty,
|
&efState,
|
1000000000 /* timeoutNanoSeconds */);
|
/*
|
* Wait should time out in a second.
|
*/
|
EXPECT_EQ(android::TIMED_OUT, ret);
|
|
status = android::hardware::EventFlag::deleteEventFlag(&efGroup);
|
ASSERT_EQ(android::NO_ERROR, status);
|
}
|
|
/*
|
* Test that odd queue sizes do not cause unaligned error
|
* on access to EventFlag object.
|
*/
|
TEST_F(QueueSizeOdd, EventFlagTest) {
|
const size_t dataLen = 64;
|
uint8_t data[dataLen] = {0};
|
|
bool ret = mQueue->writeBlocking(data,
|
dataLen,
|
static_cast<uint32_t>(kFmqNotFull),
|
static_cast<uint32_t>(kFmqNotEmpty),
|
5000000000 /* timeOutNanos */);
|
ASSERT_TRUE(ret);
|
}
|
|
/*
|
* Verify that a few bytes of data can be successfully written and read.
|
*/
|
TEST_F(SynchronizedReadWrites, SmallInputTest1) {
|
const size_t dataLen = 16;
|
ASSERT_LE(dataLen, mNumMessagesMax);
|
uint8_t data[dataLen];
|
|
initData(data, dataLen);
|
|
ASSERT_TRUE(mQueue->write(data, dataLen));
|
uint8_t readData[dataLen] = {};
|
ASSERT_TRUE(mQueue->read(readData, dataLen));
|
ASSERT_EQ(0, memcmp(data, readData, dataLen));
|
}
|
|
/*
|
* Verify that a few bytes of data can be successfully written and read using
|
* beginRead/beginWrite/CommitRead/CommitWrite
|
*/
|
TEST_F(SynchronizedReadWrites, SmallInputTest2) {
|
const size_t dataLen = 16;
|
ASSERT_LE(dataLen, mNumMessagesMax);
|
uint8_t data[dataLen];
|
|
initData(data, dataLen);
|
|
MessageQueueSync::MemTransaction tx;
|
ASSERT_TRUE(mQueue->beginWrite(dataLen, &tx));
|
|
ASSERT_TRUE(tx.copyTo(data, 0 /* startIdx */, dataLen));
|
|
ASSERT_TRUE(mQueue->commitWrite(dataLen));
|
|
uint8_t readData[dataLen] = {};
|
|
ASSERT_TRUE(mQueue->beginRead(dataLen, &tx));
|
|
ASSERT_TRUE(tx.copyFrom(readData, 0 /* startIdx */, dataLen));
|
|
ASSERT_TRUE(mQueue->commitRead(dataLen));
|
|
ASSERT_EQ(0, memcmp(data, readData, dataLen));
|
}
|
|
/*
|
* Verify that a few bytes of data can be successfully written and read using
|
* beginRead/beginWrite/CommitRead/CommitWrite as well as getSlot().
|
*/
|
TEST_F(SynchronizedReadWrites, SmallInputTest3) {
|
const size_t dataLen = 16;
|
ASSERT_LE(dataLen, mNumMessagesMax);
|
uint8_t data[dataLen];
|
|
initData(data, dataLen);
|
MessageQueueSync::MemTransaction tx;
|
ASSERT_TRUE(mQueue->beginWrite(dataLen, &tx));
|
|
auto first = tx.getFirstRegion();
|
auto second = tx.getSecondRegion();
|
|
ASSERT_EQ(first.getLength() + second.getLength(), dataLen);
|
for (size_t i = 0; i < dataLen; i++) {
|
uint8_t* ptr = tx.getSlot(i);
|
*ptr = data[i];
|
}
|
|
ASSERT_TRUE(mQueue->commitWrite(dataLen));
|
|
uint8_t readData[dataLen] = {};
|
|
ASSERT_TRUE(mQueue->beginRead(dataLen, &tx));
|
|
first = tx.getFirstRegion();
|
second = tx.getSecondRegion();
|
|
ASSERT_EQ(first.getLength() + second.getLength(), dataLen);
|
|
for (size_t i = 0; i < dataLen; i++) {
|
uint8_t* ptr = tx.getSlot(i);
|
readData[i] = *ptr;
|
}
|
|
ASSERT_TRUE(mQueue->commitRead(dataLen));
|
|
ASSERT_EQ(0, memcmp(data, readData, dataLen));
|
}
|
|
/*
|
* Verify that read() returns false when trying to read from an empty queue.
|
*/
|
TEST_F(SynchronizedReadWrites, ReadWhenEmpty1) {
|
ASSERT_EQ(0UL, mQueue->availableToRead());
|
const size_t dataLen = 2;
|
ASSERT_LE(dataLen, mNumMessagesMax);
|
uint8_t readData[dataLen];
|
ASSERT_FALSE(mQueue->read(readData, dataLen));
|
}
|
|
/*
|
* Verify that beginRead() returns a MemTransaction object with null pointers when trying
|
* to read from an empty queue.
|
*/
|
TEST_F(SynchronizedReadWrites, ReadWhenEmpty2) {
|
ASSERT_EQ(0UL, mQueue->availableToRead());
|
const size_t dataLen = 2;
|
ASSERT_LE(dataLen, mNumMessagesMax);
|
|
MessageQueueSync::MemTransaction tx;
|
ASSERT_FALSE(mQueue->beginRead(dataLen, &tx));
|
|
auto first = tx.getFirstRegion();
|
auto second = tx.getSecondRegion();
|
|
ASSERT_EQ(nullptr, first.getAddress());
|
ASSERT_EQ(nullptr, second.getAddress());
|
}
|
|
/*
|
* Write the queue until full. Verify that another write is unsuccessful.
|
* Verify that availableToWrite() returns 0 as expected.
|
*/
|
TEST_F(SynchronizedReadWrites, WriteWhenFull1) {
|
ASSERT_EQ(0UL, mQueue->availableToRead());
|
std::vector<uint8_t> data(mNumMessagesMax);
|
|
initData(&data[0], mNumMessagesMax);
|
ASSERT_TRUE(mQueue->write(&data[0], mNumMessagesMax));
|
ASSERT_EQ(0UL, mQueue->availableToWrite());
|
ASSERT_FALSE(mQueue->write(&data[0], 1));
|
|
std::vector<uint8_t> readData(mNumMessagesMax);
|
ASSERT_TRUE(mQueue->read(&readData[0], mNumMessagesMax));
|
ASSERT_EQ(data, readData);
|
}
|
|
/*
|
* Write the queue until full. Verify that beginWrite() returns
|
* a MemTransaction object with null base pointers.
|
*/
|
TEST_F(SynchronizedReadWrites, WriteWhenFull2) {
|
ASSERT_EQ(0UL, mQueue->availableToRead());
|
std::vector<uint8_t> data(mNumMessagesMax);
|
|
initData(&data[0], mNumMessagesMax);
|
ASSERT_TRUE(mQueue->write(&data[0], mNumMessagesMax));
|
ASSERT_EQ(0UL, mQueue->availableToWrite());
|
|
MessageQueueSync::MemTransaction tx;
|
ASSERT_FALSE(mQueue->beginWrite(1, &tx));
|
|
auto first = tx.getFirstRegion();
|
auto second = tx.getSecondRegion();
|
|
ASSERT_EQ(nullptr, first.getAddress());
|
ASSERT_EQ(nullptr, second.getAddress());
|
}
|
|
/*
|
* Write a chunk of data equal to the queue size.
|
* Verify that the write is successful and the subsequent read
|
* returns the expected data.
|
*/
|
TEST_F(SynchronizedReadWrites, LargeInputTest1) {
|
std::vector<uint8_t> data(mNumMessagesMax);
|
initData(&data[0], mNumMessagesMax);
|
ASSERT_TRUE(mQueue->write(&data[0], mNumMessagesMax));
|
std::vector<uint8_t> readData(mNumMessagesMax);
|
ASSERT_TRUE(mQueue->read(&readData[0], mNumMessagesMax));
|
ASSERT_EQ(data, readData);
|
}
|
|
/*
|
* Attempt to write a chunk of data larger than the queue size.
|
* Verify that it fails. Verify that a subsequent read fails and
|
* the queue is still empty.
|
*/
|
TEST_F(SynchronizedReadWrites, LargeInputTest2) {
|
ASSERT_EQ(0UL, mQueue->availableToRead());
|
const size_t dataLen = 4096;
|
ASSERT_GT(dataLen, mNumMessagesMax);
|
std::vector<uint8_t> data(dataLen);
|
|
initData(&data[0], dataLen);
|
ASSERT_FALSE(mQueue->write(&data[0], dataLen));
|
std::vector<uint8_t> readData(mNumMessagesMax);
|
ASSERT_FALSE(mQueue->read(&readData[0], mNumMessagesMax));
|
ASSERT_NE(data, readData);
|
ASSERT_EQ(0UL, mQueue->availableToRead());
|
}
|
|
/*
|
* After the queue is full, try to write more data. Verify that
|
* the attempt returns false. Verify that the attempt did not
|
* affect the pre-existing data in the queue.
|
*/
|
TEST_F(SynchronizedReadWrites, LargeInputTest3) {
|
std::vector<uint8_t> data(mNumMessagesMax);
|
initData(&data[0], mNumMessagesMax);
|
ASSERT_TRUE(mQueue->write(&data[0], mNumMessagesMax));
|
ASSERT_FALSE(mQueue->write(&data[0], 1));
|
std::vector<uint8_t> readData(mNumMessagesMax);
|
ASSERT_TRUE(mQueue->read(&readData[0], mNumMessagesMax));
|
ASSERT_EQ(data, readData);
|
}
|
|
/*
|
* Verify that beginWrite() returns a MemTransaction with
|
* null base pointers when attempting to write data larger
|
* than the queue size.
|
*/
|
TEST_F(SynchronizedReadWrites, LargeInputTest4) {
|
ASSERT_EQ(0UL, mQueue->availableToRead());
|
const size_t dataLen = 4096;
|
ASSERT_GT(dataLen, mNumMessagesMax);
|
|
MessageQueueSync::MemTransaction tx;
|
ASSERT_FALSE(mQueue->beginWrite(dataLen, &tx));
|
|
auto first = tx.getFirstRegion();
|
auto second = tx.getSecondRegion();
|
|
ASSERT_EQ(nullptr, first.getAddress());
|
ASSERT_EQ(nullptr, second.getAddress());
|
}
|
|
/*
|
* Verify that multiple reads one after the other return expected data.
|
*/
|
TEST_F(SynchronizedReadWrites, MultipleRead) {
|
const size_t chunkSize = 100;
|
const size_t chunkNum = 5;
|
const size_t dataLen = chunkSize * chunkNum;
|
ASSERT_LE(dataLen, mNumMessagesMax);
|
uint8_t data[dataLen];
|
|
initData(data, dataLen);
|
ASSERT_TRUE(mQueue->write(data, dataLen));
|
uint8_t readData[dataLen] = {};
|
for (size_t i = 0; i < chunkNum; i++) {
|
ASSERT_TRUE(mQueue->read(readData + i * chunkSize, chunkSize));
|
}
|
ASSERT_EQ(0, memcmp(readData, data, dataLen));
|
}
|
|
/*
|
* Verify that multiple writes one after the other happens correctly.
|
*/
|
TEST_F(SynchronizedReadWrites, MultipleWrite) {
|
const int chunkSize = 100;
|
const int chunkNum = 5;
|
const size_t dataLen = chunkSize * chunkNum;
|
ASSERT_LE(dataLen, mNumMessagesMax);
|
uint8_t data[dataLen];
|
|
initData(data, dataLen);
|
for (unsigned int i = 0; i < chunkNum; i++) {
|
ASSERT_TRUE(mQueue->write(data + i * chunkSize, chunkSize));
|
}
|
uint8_t readData[dataLen] = {};
|
ASSERT_TRUE(mQueue->read(readData, dataLen));
|
ASSERT_EQ(0, memcmp(readData, data, dataLen));
|
}
|
|
/*
|
* Write enough messages into the FMQ to fill half of it
|
* and read back the same.
|
* Write mNumMessagesMax messages into the queue. This will cause a
|
* wrap around. Read and verify the data.
|
*/
|
TEST_F(SynchronizedReadWrites, ReadWriteWrapAround1) {
|
size_t numMessages = mNumMessagesMax - 1;
|
std::vector<uint8_t> data(mNumMessagesMax);
|
std::vector<uint8_t> readData(mNumMessagesMax);
|
initData(&data[0], mNumMessagesMax);
|
ASSERT_TRUE(mQueue->write(&data[0], numMessages));
|
ASSERT_TRUE(mQueue->read(&readData[0], numMessages));
|
ASSERT_TRUE(mQueue->write(&data[0], mNumMessagesMax));
|
ASSERT_TRUE(mQueue->read(&readData[0], mNumMessagesMax));
|
ASSERT_EQ(data, readData);
|
}
|
|
/*
|
* Use beginRead/CommitRead/beginWrite/commitWrite APIs
|
* to test wrap arounds are handled correctly.
|
* Write enough messages into the FMQ to fill half of it
|
* and read back the same.
|
* Write mNumMessagesMax messages into the queue. This will cause a
|
* wrap around. Read and verify the data.
|
*/
|
TEST_F(SynchronizedReadWrites, ReadWriteWrapAround2) {
|
size_t dataLen = mNumMessagesMax - 1;
|
std::vector<uint8_t> data(mNumMessagesMax);
|
std::vector<uint8_t> readData(mNumMessagesMax);
|
initData(&data[0], mNumMessagesMax);
|
ASSERT_TRUE(mQueue->write(&data[0], dataLen));
|
ASSERT_TRUE(mQueue->read(&readData[0], dataLen));
|
|
/*
|
* The next write and read will have to deal with with wrap arounds.
|
*/
|
MessageQueueSync::MemTransaction tx;
|
ASSERT_TRUE(mQueue->beginWrite(mNumMessagesMax, &tx));
|
|
auto first = tx.getFirstRegion();
|
auto second = tx.getSecondRegion();
|
|
ASSERT_EQ(first.getLength() + second.getLength(), mNumMessagesMax);
|
|
ASSERT_TRUE(tx.copyTo(&data[0], 0 /* startIdx */, mNumMessagesMax));
|
|
ASSERT_TRUE(mQueue->commitWrite(mNumMessagesMax));
|
|
ASSERT_TRUE(mQueue->beginRead(mNumMessagesMax, &tx));
|
|
first = tx.getFirstRegion();
|
second = tx.getSecondRegion();
|
|
ASSERT_EQ(first.getLength() + second.getLength(), mNumMessagesMax);
|
|
ASSERT_TRUE(tx.copyFrom(&readData[0], 0 /* startIdx */, mNumMessagesMax));
|
ASSERT_TRUE(mQueue->commitRead(mNumMessagesMax));
|
|
ASSERT_EQ(data, readData);
|
}
|
|
/*
|
* Verify that a few bytes of data can be successfully written and read.
|
*/
|
TEST_F(UnsynchronizedWrite, SmallInputTest1) {
|
const size_t dataLen = 16;
|
ASSERT_LE(dataLen, mNumMessagesMax);
|
uint8_t data[dataLen];
|
|
initData(data, dataLen);
|
ASSERT_TRUE(mQueue->write(data, dataLen));
|
uint8_t readData[dataLen] = {};
|
ASSERT_TRUE(mQueue->read(readData, dataLen));
|
ASSERT_EQ(0, memcmp(data, readData, dataLen));
|
}
|
|
/*
|
* Verify that read() returns false when trying to read from an empty queue.
|
*/
|
TEST_F(UnsynchronizedWrite, ReadWhenEmpty) {
|
ASSERT_EQ(0UL, mQueue->availableToRead());
|
const size_t dataLen = 2;
|
ASSERT_TRUE(dataLen < mNumMessagesMax);
|
uint8_t readData[dataLen];
|
ASSERT_FALSE(mQueue->read(readData, dataLen));
|
}
|
|
/*
|
* Write the queue when full. Verify that a subsequent writes is succesful.
|
* Verify that availableToWrite() returns 0 as expected.
|
*/
|
TEST_F(UnsynchronizedWrite, WriteWhenFull1) {
|
ASSERT_EQ(0UL, mQueue->availableToRead());
|
std::vector<uint8_t> data(mNumMessagesMax);
|
|
initData(&data[0], mNumMessagesMax);
|
ASSERT_TRUE(mQueue->write(&data[0], mNumMessagesMax));
|
ASSERT_EQ(0UL, mQueue->availableToWrite());
|
ASSERT_TRUE(mQueue->write(&data[0], 1));
|
|
std::vector<uint8_t> readData(mNumMessagesMax);
|
ASSERT_FALSE(mQueue->read(&readData[0], mNumMessagesMax));
|
}
|
|
/*
|
* Write the queue when full. Verify that a subsequent writes
|
* using beginRead()/commitRead() is succesful.
|
* Verify that the next read fails as expected for unsynchronized flavor.
|
*/
|
TEST_F(UnsynchronizedWrite, WriteWhenFull2) {
|
ASSERT_EQ(0UL, mQueue->availableToRead());
|
std::vector<uint8_t> data(mNumMessagesMax);
|
ASSERT_TRUE(mQueue->write(&data[0], mNumMessagesMax));
|
|
MessageQueueUnsync::MemTransaction tx;
|
ASSERT_TRUE(mQueue->beginWrite(1, &tx));
|
|
ASSERT_EQ(tx.getFirstRegion().getLength(), 1U);
|
|
ASSERT_TRUE(tx.copyTo(&data[0], 0 /* startIdx */));
|
|
ASSERT_TRUE(mQueue->commitWrite(1));
|
|
std::vector<uint8_t> readData(mNumMessagesMax);
|
ASSERT_FALSE(mQueue->read(&readData[0], mNumMessagesMax));
|
}
|
|
/*
|
* Write a chunk of data equal to the queue size.
|
* Verify that the write is successful and the subsequent read
|
* returns the expected data.
|
*/
|
TEST_F(UnsynchronizedWrite, LargeInputTest1) {
|
std::vector<uint8_t> data(mNumMessagesMax);
|
initData(&data[0], mNumMessagesMax);
|
ASSERT_TRUE(mQueue->write(&data[0], mNumMessagesMax));
|
std::vector<uint8_t> readData(mNumMessagesMax);
|
ASSERT_TRUE(mQueue->read(&readData[0], mNumMessagesMax));
|
ASSERT_EQ(data, readData);
|
}
|
|
/*
|
* Attempt to write a chunk of data larger than the queue size.
|
* Verify that it fails. Verify that a subsequent read fails and
|
* the queue is still empty.
|
*/
|
TEST_F(UnsynchronizedWrite, LargeInputTest2) {
|
ASSERT_EQ(0UL, mQueue->availableToRead());
|
const size_t dataLen = 4096;
|
ASSERT_GT(dataLen, mNumMessagesMax);
|
std::vector<uint8_t> data(dataLen);
|
initData(&data[0], dataLen);
|
ASSERT_FALSE(mQueue->write(&data[0], dataLen));
|
std::vector<uint8_t> readData(mNumMessagesMax);
|
ASSERT_FALSE(mQueue->read(&readData[0], mNumMessagesMax));
|
ASSERT_NE(data, readData);
|
ASSERT_EQ(0UL, mQueue->availableToRead());
|
}
|
|
/*
|
* After the queue is full, try to write more data. Verify that
|
* the attempt is succesful. Verify that the read fails
|
* as expected.
|
*/
|
TEST_F(UnsynchronizedWrite, LargeInputTest3) {
|
std::vector<uint8_t> data(mNumMessagesMax);
|
initData(&data[0], mNumMessagesMax);
|
ASSERT_TRUE(mQueue->write(&data[0], mNumMessagesMax));
|
ASSERT_TRUE(mQueue->write(&data[0], 1));
|
std::vector<uint8_t> readData(mNumMessagesMax);
|
ASSERT_FALSE(mQueue->read(&readData[0], mNumMessagesMax));
|
}
|
|
/*
|
* Verify that multiple reads one after the other return expected data.
|
*/
|
TEST_F(UnsynchronizedWrite, MultipleRead) {
|
const size_t chunkSize = 100;
|
const size_t chunkNum = 5;
|
const size_t dataLen = chunkSize * chunkNum;
|
ASSERT_LE(dataLen, mNumMessagesMax);
|
uint8_t data[dataLen];
|
initData(data, dataLen);
|
ASSERT_TRUE(mQueue->write(data, dataLen));
|
uint8_t readData[dataLen] = {};
|
for (size_t i = 0; i < chunkNum; i++) {
|
ASSERT_TRUE(mQueue->read(readData + i * chunkSize, chunkSize));
|
}
|
ASSERT_EQ(0, memcmp(readData, data, dataLen));
|
}
|
|
/*
|
* Verify that multiple writes one after the other happens correctly.
|
*/
|
TEST_F(UnsynchronizedWrite, MultipleWrite) {
|
const size_t chunkSize = 100;
|
const size_t chunkNum = 5;
|
const size_t dataLen = chunkSize * chunkNum;
|
ASSERT_LE(dataLen, mNumMessagesMax);
|
uint8_t data[dataLen];
|
|
initData(data, dataLen);
|
for (size_t i = 0; i < chunkNum; i++) {
|
ASSERT_TRUE(mQueue->write(data + i * chunkSize, chunkSize));
|
}
|
|
uint8_t readData[dataLen] = {};
|
ASSERT_TRUE(mQueue->read(readData, dataLen));
|
ASSERT_EQ(0, memcmp(readData, data, dataLen));
|
}
|
|
/*
|
* Write enough messages into the FMQ to fill half of it
|
* and read back the same.
|
* Write mNumMessagesMax messages into the queue. This will cause a
|
* wrap around. Read and verify the data.
|
*/
|
TEST_F(UnsynchronizedWrite, ReadWriteWrapAround) {
|
size_t numMessages = mNumMessagesMax - 1;
|
std::vector<uint8_t> data(mNumMessagesMax);
|
std::vector<uint8_t> readData(mNumMessagesMax);
|
|
initData(&data[0], mNumMessagesMax);
|
ASSERT_TRUE(mQueue->write(&data[0], numMessages));
|
ASSERT_TRUE(mQueue->read(&readData[0], numMessages));
|
ASSERT_TRUE(mQueue->write(&data[0], mNumMessagesMax));
|
ASSERT_TRUE(mQueue->read(&readData[0], mNumMessagesMax));
|
ASSERT_EQ(data, readData);
|
}
|
