added more tests and debugging statements
In the process of trying to test one if statement in the queue code, I
realized that it should never have been triggered, so I changed the code
to assert that it's not true instead.
diff --git a/aos/linux_code/ipc_lib/queue.cc b/aos/linux_code/ipc_lib/queue.cc
index b19ef2c..e02df30 100644
--- a/aos/linux_code/ipc_lib/queue.cc
+++ b/aos/linux_code/ipc_lib/queue.cc
@@ -22,6 +22,7 @@
const bool kWriteDebug = false;
const bool kRefDebug = false;
const bool kFetchDebug = false;
+const bool kReadIndexDebug = false;
// The number of extra messages the pool associated with each queue will be able
// to hold (for readers who are slow about freeing them or who leak one when
@@ -425,23 +426,39 @@
int my_start;
const int unread_messages = messages_ - *index;
+ assert(unread_messages > 0);
int current_messages = data_end_ - data_start_;
- if (current_messages < 0) current_messages += data_length_ - 1;
+ if (current_messages < 0) current_messages += data_length_;
+ if (kReadIndexDebug) {
+ printf("queue: %p start=%d end=%d current=%d\n",
+ this, data_start_, data_end_, current_messages);
+ }
+ assert(current_messages > 0);
// If we're behind the available messages.
if (unread_messages > current_messages) {
// Catch index up to the last available message.
*index = messages_ - current_messages;
// And that's the one we're going to read.
my_start = data_start_;
+ if (kReadIndexDebug) {
+ printf("queue: %p jumping ahead to message %d (have %d) (at %d)\n",
+ this, *index, messages_, data_start_);
+ }
} else {
// Just start reading at the first available message that we haven't yet
// read.
my_start = data_end_ - unread_messages;
- if (my_start < 0) {
- my_start += data_length_;
+ if (kReadIndexDebug) {
+ printf("queue: %p original read from %d\n", this, my_start);
+ }
+ if (data_start_ < data_end_) {
+ assert(my_start >= data_start_);
+ } else {
+ if (my_start < 0) my_start += data_length_;
}
}
+ // TODO(brians): Test kPeek and kFromEnd.
if (options & kPeek) {
msg = ReadPeek(options, my_start);
} else {
@@ -462,13 +479,10 @@
if (kReadDebug) {
printf("queue: %p reading from d1: %d\n", this, my_start);
}
-#if 0
- // TODO(brians): Do this check right? (make sure full queue works etc)
// This assert checks that we're either within both endpoints (duh) or
- // outside of both of them (if the queue is wrapped around).
+ // not between them (if the queue is wrapped around).
assert((my_start >= data_start_ && my_start < data_end_) ||
- (my_start > data_end_ && my_start <= data_start_));
-#endif
+ ((my_start >= data_start_) == (my_start > data_end_)));
msg = data_[my_start];
++(*index);
}
diff --git a/aos/linux_code/ipc_lib/queue.h b/aos/linux_code/ipc_lib/queue.h
index 4d00cde..937cb07 100644
--- a/aos/linux_code/ipc_lib/queue.h
+++ b/aos/linux_code/ipc_lib/queue.h
@@ -56,6 +56,8 @@
// The non-conflicting ones can be combined with bitwise-or.
// Causes the returned message to be left in the queue.
+ // NOTE: When used with ReadMessageIndex, this means the index will not be
+ // updated.
// For reading only.
static const int kPeek = 0x0001;
// Reads the last message in the queue instead of just the next one.
@@ -94,7 +96,7 @@
// same message twice with the same index argument. However, it may not
// return some messages that pass through the queue.
// *index should start as 0. index does not have to be in shared memory, but
- // it can be
+ // it can be.
const void *ReadMessageIndex(int options, int *index);
// Retrieves ("allocates") a message that can then be written to the queue.
diff --git a/aos/linux_code/ipc_lib/raw_queue_test.cc b/aos/linux_code/ipc_lib/raw_queue_test.cc
index 2ba1df0..2172fc1 100644
--- a/aos/linux_code/ipc_lib/raw_queue_test.cc
+++ b/aos/linux_code/ipc_lib/raw_queue_test.cc
@@ -300,7 +300,7 @@
void PushMessage(RawQueue *queue, uint16_t data) {
TestMessage *message = static_cast<TestMessage *>(queue->GetMessage());
message->data = data;
- ASSERT_TRUE(queue->WriteMessage(message, RawQueue::kNonBlock));
+ ASSERT_TRUE(queue->WriteMessage(message, RawQueue::kOverride));
}
private:
@@ -468,7 +468,35 @@
EXPECT_EQ(message2, queue->GetMessage());
}
-TEST_F(RawQueueTest, ReadIndexLittleBehind) {
+TEST_F(RawQueueTest, ReadIndexNotFull) {
+ RawQueue *const queue = RawQueue::Fetch("Queue", sizeof(TestMessage), 1, 2);
+ const TestMessage *message;
+
+ PushMessage(queue, 971);
+
+ int index = 0;
+ message = static_cast<const TestMessage *>(
+ queue->ReadMessageIndex(RawQueue::kNonBlock, &index));
+ ASSERT_NE(nullptr, message);
+ EXPECT_EQ(971, message->data);
+ EXPECT_EQ(1, index);
+
+ PushMessage(queue, 1768);
+ message = static_cast<const TestMessage *>(
+ queue->ReadMessageIndex(RawQueue::kNonBlock, &index));
+ ASSERT_NE(nullptr, message);
+ EXPECT_EQ(1768, message->data);
+ EXPECT_EQ(2, index);
+
+ PushMessage(queue, 254);
+ message = static_cast<const TestMessage *>(
+ queue->ReadMessageIndex(RawQueue::kNonBlock, &index));
+ ASSERT_NE(nullptr, message);
+ EXPECT_EQ(254, message->data);
+ EXPECT_EQ(3, index);
+}
+
+TEST_F(RawQueueTest, ReadIndexNotBehind) {
RawQueue *const queue = RawQueue::Fetch("Queue", sizeof(TestMessage), 1, 2);
const TestMessage *message;
@@ -480,6 +508,24 @@
queue->ReadMessageIndex(RawQueue::kNonBlock, &index));
ASSERT_NE(nullptr, message);
EXPECT_EQ(971, message->data);
+ EXPECT_EQ(1, index);
+}
+
+TEST_F(RawQueueTest, ReadIndexLittleBehindNotFull) {
+ RawQueue *const queue = RawQueue::Fetch("Queue", sizeof(TestMessage), 1, 2);
+ const TestMessage *message;
+
+ PushMessage(queue, 971);
+ PushMessage(queue, 1768);
+ ASSERT_NE(nullptr, queue->ReadMessage(RawQueue::kNonBlock));
+
+ int index = 0;
+
+ message = static_cast<const TestMessage *>(
+ queue->ReadMessageIndex(RawQueue::kNonBlock, &index));
+ ASSERT_NE(nullptr, message);
+ EXPECT_EQ(1768, message->data);
+ EXPECT_EQ(2, index);
}
TEST_F(RawQueueTest, ReadIndexMoreBehind) {
@@ -505,6 +551,25 @@
EXPECT_EQ(3, index);
}
+TEST_F(RawQueueTest, ReadIndexMoreBehindNotFull) {
+ RawQueue *const queue = RawQueue::Fetch("Queue", sizeof(TestMessage), 1, 2);
+ const TestMessage *message;
+
+ PushMessage(queue, 971);
+ PushMessage(queue, 1768);
+ ASSERT_NE(nullptr, queue->ReadMessage(RawQueue::kNonBlock));
+ PushMessage(queue, 254);
+ ASSERT_NE(nullptr, queue->ReadMessage(RawQueue::kNonBlock));
+
+ int index = 0;
+
+ message = static_cast<const TestMessage *>(
+ queue->ReadMessageIndex(RawQueue::kNonBlock, &index));
+ ASSERT_NE(nullptr, message);
+ EXPECT_EQ(254, message->data);
+ EXPECT_EQ(3, index);
+}
+
TEST_F(RawQueueTest, ReadIndexLotBehind) {
RawQueue *const queue = RawQueue::Fetch("Queue", sizeof(TestMessage), 1, 2);
const TestMessage *message;
@@ -530,5 +595,76 @@
EXPECT_EQ(4, index);
}
+TEST_F(RawQueueTest, ReadIndexLotBehindNotFull) {
+ RawQueue *const queue = RawQueue::Fetch("Queue", sizeof(TestMessage), 1, 2);
+ const TestMessage *message;
+
+ PushMessage(queue, 971);
+ PushMessage(queue, 1768);
+ ASSERT_NE(nullptr, queue->ReadMessage(RawQueue::kNonBlock));
+ PushMessage(queue, 254);
+ ASSERT_NE(nullptr, queue->ReadMessage(RawQueue::kNonBlock));
+ PushMessage(queue, 973);
+ ASSERT_NE(nullptr, queue->ReadMessage(RawQueue::kNonBlock));
+
+ int index = 0;
+
+ message = static_cast<const TestMessage *>(
+ queue->ReadMessageIndex(RawQueue::kNonBlock, &index));
+ ASSERT_NE(nullptr, message);
+ EXPECT_EQ(973, message->data);
+ EXPECT_EQ(4, index);
+}
+
+TEST_F(RawQueueTest, ReadIndexEvenMoreBehind) {
+ RawQueue *const queue = RawQueue::Fetch("Queue", sizeof(TestMessage), 1, 2);
+ const TestMessage *message;
+
+ PushMessage(queue, 971);
+ PushMessage(queue, 1768);
+ ASSERT_NE(nullptr, queue->ReadMessage(RawQueue::kNonBlock));
+ PushMessage(queue, 254);
+ ASSERT_NE(nullptr, queue->ReadMessage(RawQueue::kNonBlock));
+ PushMessage(queue, 973);
+ ASSERT_NE(nullptr, queue->ReadMessage(RawQueue::kNonBlock));
+ PushMessage(queue, 1114);
+
+ int index = 0;
+
+ message = static_cast<const TestMessage *>(
+ queue->ReadMessageIndex(RawQueue::kNonBlock, &index));
+ ASSERT_NE(nullptr, message);
+ EXPECT_EQ(973, message->data);
+ EXPECT_EQ(4, index);
+ message = static_cast<const TestMessage *>(
+ queue->ReadMessageIndex(RawQueue::kNonBlock, &index));
+ ASSERT_NE(nullptr, message);
+ EXPECT_EQ(1114, message->data);
+ EXPECT_EQ(5, index);
+}
+
+TEST_F(RawQueueTest, ReadIndexEvenMoreBehindNotFull) {
+ RawQueue *const queue = RawQueue::Fetch("Queue", sizeof(TestMessage), 1, 2);
+ const TestMessage *message;
+
+ PushMessage(queue, 971);
+ PushMessage(queue, 1768);
+ ASSERT_NE(nullptr, queue->ReadMessage(RawQueue::kNonBlock));
+ PushMessage(queue, 254);
+ ASSERT_NE(nullptr, queue->ReadMessage(RawQueue::kNonBlock));
+ PushMessage(queue, 973);
+ ASSERT_NE(nullptr, queue->ReadMessage(RawQueue::kNonBlock));
+ PushMessage(queue, 1114);
+ ASSERT_NE(nullptr, queue->ReadMessage(RawQueue::kNonBlock));
+
+ int index = 0;
+
+ message = static_cast<const TestMessage *>(
+ queue->ReadMessageIndex(RawQueue::kNonBlock, &index));
+ ASSERT_NE(nullptr, message);
+ EXPECT_EQ(1114, message->data);
+ EXPECT_EQ(5, index);
+}
+
} // namespace testing
} // namespace aos