Queue: Add functionality needed by new USART stream driver

Previously there was no way to remove multiple units at a time
from the queue, and the queue was wasting an entry to disambiguate
full from empty.  There was also no way to get the free entry
count from the queue, only the ability to query if it was above
a required amount.  The queue was also storing its constant
compile time configuration as well as its dynamic state in the
same structure.  This wasted RAM on configuration information
that doesn't change.

This refactor fixes these issues, making the queue suitable for
use in the new USART stream driver.

Signed-off-by: Anton Staaf <robotboy@chromium.org>

BRANCH=None
BUG=None
TEST=make buildall -j

Change-Id: I284cee52d8189928dbc4c499f87ab34e14019e5a
Reviewed-on: https://chromium-review.googlesource.com/210533
Reviewed-by: Vic Yang <victoryang@chromium.org>
Reviewed-by: Randall Spangler <rspangler@chromium.org>
Commit-Queue: Anton Staaf <robotboy@chromium.org>
Tested-by: Anton Staaf <robotboy@chromium.org>

1 files changed, 81 insertions, 79 deletions

diff --git a/test/queue.c b/test/queue.c
index c7b4518e02..d5d499377b 100644
--- a/test/queue.c
+++ b/test/queue.c
@@ -12,142 +12,143 @@
 #include "timer.h"
 #include "util.h"
 
-static char buffer6[6];  /* Max 5 items in queue */
-static struct queue test_queue6 = {
-	.buf_bytes  = sizeof(buffer6),
-	.unit_bytes = sizeof(char),
-	.buf        = buffer6,
-};
-
-static char buffer5[5];  /* Max 2 items (2 byte for each) in queue */
-static struct queue test_queue5 = {
-	.buf_bytes  = sizeof(buffer5),
-	.unit_bytes = 2,
-	.buf        = buffer5,
-};
-
-#define LOOP_DEQUE(q, d, n) \
-	do { \
-		int i; \
-		for (i = 0; i < n; ++i) \
-			TEST_ASSERT(queue_remove_unit(&q, d + i)); \
-	} while (0)
-
-static int test_queue6_empty(void)
+QUEUE_CONFIG(test_queue8, 8, char)
+QUEUE_CONFIG(test_queue2, 2, int16_t)
+
+static int test_queue8_empty(void)
 {
 	char dummy = 1;
 
-	queue_reset(&test_queue6);
-	TEST_ASSERT(queue_is_empty(&test_queue6));
-	TEST_ASSERT(!queue_remove_unit(&test_queue6, &dummy));
-	queue_add_units(&test_queue6, &dummy, 1);
-	TEST_ASSERT(!queue_is_empty(&test_queue6));
+	queue_init(&test_queue8);
+	TEST_ASSERT(queue_is_empty(&test_queue8));
+	TEST_ASSERT(!queue_remove_units(&test_queue8, &dummy, 1));
+	TEST_ASSERT(queue_add_units(&test_queue8, &dummy, 1) == 1);
+	TEST_ASSERT(!queue_is_empty(&test_queue8));
 
 	return EC_SUCCESS;
 }
 
-static int test_queue6_reset(void)
+static int test_queue8_init(void)
 {
 	char dummy = 1;
 
-	queue_reset(&test_queue6);
-	queue_add_units(&test_queue6, &dummy, 1);
-	queue_reset(&test_queue6);
-	TEST_ASSERT(queue_is_empty(&test_queue6));
+	queue_init(&test_queue8);
+	TEST_ASSERT(queue_add_units(&test_queue8, &dummy, 1) == 1);
+	queue_init(&test_queue8);
+	TEST_ASSERT(queue_is_empty(&test_queue8));
 
 	return EC_SUCCESS;
 }
 
-static int test_queue6_fifo(void)
+static int test_queue8_fifo(void)
 {
 	char buf1[3] = {1, 2, 3};
 	char buf2[3];
 
-	queue_reset(&test_queue6);
+	queue_init(&test_queue8);
 
-	queue_add_units(&test_queue6, buf1 + 0, 1);
-	queue_add_units(&test_queue6, buf1 + 1, 1);
-	queue_add_units(&test_queue6, buf1 + 2, 1);
+	TEST_ASSERT(queue_add_units(&test_queue8, buf1 + 0, 1) == 1);
+	TEST_ASSERT(queue_add_units(&test_queue8, buf1 + 1, 1) == 1);
+	TEST_ASSERT(queue_add_units(&test_queue8, buf1 + 2, 1) == 1);
 
-	LOOP_DEQUE(test_queue6, buf2, 3);
+	TEST_ASSERT(queue_remove_units(&test_queue8, buf2, 3) == 3);
 	TEST_ASSERT_ARRAY_EQ(buf1, buf2, 3);
 
 	return EC_SUCCESS;
 }
 
-static int test_queue6_multiple_units_add(void)
+static int test_queue8_multiple_units_add(void)
 {
 	char buf1[5] = {1, 2, 3, 4, 5};
 	char buf2[5];
 
-	queue_reset(&test_queue6);
-	TEST_ASSERT(queue_has_space(&test_queue6, 5));
-	queue_add_units(&test_queue6, buf1, 5);
-	LOOP_DEQUE(test_queue6, buf2, 5);
+	queue_init(&test_queue8);
+	TEST_ASSERT(queue_space(&test_queue8) >= 5);
+	TEST_ASSERT(queue_add_units(&test_queue8, buf1, 5) == 5);
+	TEST_ASSERT(queue_remove_units(&test_queue8, buf2, 5) == 5);
 	TEST_ASSERT_ARRAY_EQ(buf1, buf2, 5);
 
 	return EC_SUCCESS;
 }
 
-static int test_queue6_removal(void)
+static int test_queue8_removal(void)
 {
 	char buf1[5] = {1, 2, 3, 4, 5};
 	char buf2[5];
 
-	queue_reset(&test_queue6);
-	queue_add_units(&test_queue6, buf1, 5);
+	queue_init(&test_queue8);
+	TEST_ASSERT(queue_add_units(&test_queue8, buf1, 5) == 5);
 	/* 1, 2, 3, 4, 5 */
-	LOOP_DEQUE(test_queue6, buf2, 3);
+	TEST_ASSERT(queue_remove_units(&test_queue8, buf2, 3) == 3);
 	TEST_ASSERT_ARRAY_EQ(buf1, buf2, 3);
 	/* 4, 5 */
-	queue_add_units(&test_queue6, buf1, 2);
+	TEST_ASSERT(queue_add_units(&test_queue8, buf1, 2) == 2);
 	/* 4, 5, 1, 2 */
-	TEST_ASSERT(queue_has_space(&test_queue6, 1));
-	TEST_ASSERT(!queue_has_space(&test_queue6, 2));
-	LOOP_DEQUE(test_queue6, buf2, 1);
+	TEST_ASSERT(queue_space(&test_queue8) == 4);
+	TEST_ASSERT(queue_remove_units(&test_queue8, buf2, 1) == 1);
 	TEST_ASSERT(buf2[0] == 4);
 	/* 5, 1, 2 */
-	queue_add_units(&test_queue6, buf1 + 2, 2);
+	TEST_ASSERT(queue_add_units(&test_queue8, buf1 + 2, 2) == 2);
 	/* 5, 1, 2, 3, 4 */
-	TEST_ASSERT(!queue_has_space(&test_queue6, 1));
-	LOOP_DEQUE(test_queue6, buf2, 1);
+	TEST_ASSERT(queue_space(&test_queue8) == 3);
+	TEST_ASSERT(queue_add_units(&test_queue8, buf1 + 2, 3) == 3);
+	/* 5, 1, 2, 3, 4, 3, 4, 5 */
+	TEST_ASSERT(queue_space(&test_queue8) == 0);
+	TEST_ASSERT(queue_remove_units(&test_queue8, buf2, 1) == 1);
 	TEST_ASSERT(buf2[0] == 5);
-	LOOP_DEQUE(test_queue6, buf2, 4);
+	TEST_ASSERT(queue_remove_units(&test_queue8, buf2, 4) == 4);
 	TEST_ASSERT_ARRAY_EQ(buf1, buf2, 4);
-	TEST_ASSERT(queue_is_empty(&test_queue6));
+	TEST_ASSERT(queue_remove_units(&test_queue8, buf2, 3) == 3);
+	TEST_ASSERT_ARRAY_EQ(buf1 + 2, buf2, 3);
+	TEST_ASSERT(queue_is_empty(&test_queue8));
 	/* Empty */
-	queue_add_units(&test_queue6, buf1, 5);
-	LOOP_DEQUE(test_queue6, buf2, 5);
+	TEST_ASSERT(queue_add_units(&test_queue8, buf1, 5) == 5);
+	TEST_ASSERT(queue_remove_units(&test_queue8, buf2, 5) == 5);
 	TEST_ASSERT_ARRAY_EQ(buf1, buf2, 5);
 
 	return EC_SUCCESS;
 }
 
-static int test_queue5_odd_even(void)
+static int test_queue8_peek(void)
+{
+	char buf1[5] = {1, 2, 3, 4, 5};
+	char buf2[5];
+
+	queue_init(&test_queue8);
+	TEST_ASSERT(queue_add_units(&test_queue8, buf1, 5) == 5);
+	/* 1, 2, 3, 4, 5 */
+	TEST_ASSERT(queue_count(&test_queue8) == 5);
+	TEST_ASSERT(queue_space(&test_queue8) == 3);
+	TEST_ASSERT(queue_peek_units(&test_queue8, buf2, 2, 3) == 3);
+	TEST_ASSERT_ARRAY_EQ(buf1 + 2, buf2, 3);
+	TEST_ASSERT(queue_count(&test_queue8) == 5);
+	TEST_ASSERT(queue_space(&test_queue8) == 3);
+
+	return EC_SUCCESS;
+}
+
+static int test_queue2_odd_even(void)
 {
 	uint16_t buf1[3] = {1, 2, 3};
 	uint16_t buf2[3];
 
-	queue_reset(&test_queue5);
-	queue_add_units(&test_queue5, buf1, 1);
+	queue_init(&test_queue2);
+	TEST_ASSERT(queue_add_units(&test_queue2, buf1, 1) == 1);
 	/* 1 */
-	TEST_ASSERT(!queue_has_space(&test_queue5, 2));
-	TEST_ASSERT(queue_has_space(&test_queue5, 1));
-	queue_add_units(&test_queue5, buf1 + 1, 1);
+	TEST_ASSERT(queue_space(&test_queue2) == 1);
+	TEST_ASSERT(queue_add_units(&test_queue2, buf1 + 1, 1) == 1);
 	/* 1, 2 */
-	TEST_ASSERT(!queue_has_space(&test_queue5, 1));
-	LOOP_DEQUE(test_queue5, buf2, 2);
+	TEST_ASSERT(queue_space(&test_queue2) == 0);
+	TEST_ASSERT(queue_remove_units(&test_queue2, buf2, 2) == 2);
 	TEST_ASSERT_ARRAY_EQ(buf1, buf2, 2);
-	TEST_ASSERT(queue_is_empty(&test_queue5));
+	TEST_ASSERT(queue_is_empty(&test_queue2));
 	/* Empty */
-	TEST_ASSERT(!queue_has_space(&test_queue5, 3));
-	TEST_ASSERT(queue_has_space(&test_queue5, 2));
-	TEST_ASSERT(queue_has_space(&test_queue5, 1));
-	queue_add_units(&test_queue5, buf1 + 2, 1);
+	TEST_ASSERT(queue_space(&test_queue2) == 2);
+	TEST_ASSERT(queue_add_units(&test_queue2, buf1 + 2, 1) == 1);
 	/* 3 */
-	LOOP_DEQUE(test_queue5, buf2, 1);
+	TEST_ASSERT(queue_remove_units(&test_queue2, buf2, 1) == 1);
 	TEST_ASSERT(buf2[0] == 3);
-	TEST_ASSERT(queue_is_empty(&test_queue5));
+	TEST_ASSERT(queue_is_empty(&test_queue2));
 
 	return EC_SUCCESS;
 }
@@ -156,12 +157,13 @@ void run_test(void)
 {
 	test_reset();
 
-	RUN_TEST(test_queue6_empty);
-	RUN_TEST(test_queue6_reset);
-	RUN_TEST(test_queue6_fifo);
-	RUN_TEST(test_queue6_multiple_units_add);
-	RUN_TEST(test_queue6_removal);
-	RUN_TEST(test_queue5_odd_even);
+	RUN_TEST(test_queue8_empty);
+	RUN_TEST(test_queue8_init);
+	RUN_TEST(test_queue8_fifo);
+	RUN_TEST(test_queue8_multiple_units_add);
+	RUN_TEST(test_queue8_removal);
+	RUN_TEST(test_queue8_peek);
+	RUN_TEST(test_queue2_odd_even);
 
 	test_print_result();
 }