Denislam Valeev / Mbed OS Nucleo_rtos_basic

1

mbed-os/TESTS/mbedmicro-rtos-mbed/CircularBuffer/main.cpp@0:e056ac8fecf8, 2018-03-13 (annotated)

Committer:
valeyev
Date:
Tue Mar 13 07:17:50 2018 +0000
Revision:
0:e056ac8fecf8
looking for...

Who changed what in which revision?

UserRevisionLine numberNew contents of line
valeyev 0:e056ac8fecf8 1 /* mbed Microcontroller Library
valeyev 0:e056ac8fecf8 2 * Copyright (c) 2017 ARM Limited
valeyev 0:e056ac8fecf8 3 *
valeyev 0:e056ac8fecf8 4 * Licensed under the Apache License, Version 2.0 (the "License");
valeyev 0:e056ac8fecf8 5 * you may not use this file except in compliance with the License.
valeyev 0:e056ac8fecf8 6 * You may obtain a copy of the License at
valeyev 0:e056ac8fecf8 7 *
valeyev 0:e056ac8fecf8 8 * http://www.apache.org/licenses/LICENSE-2.0
valeyev 0:e056ac8fecf8 9 *
valeyev 0:e056ac8fecf8 10 * Unless required by applicable law or agreed to in writing, software
valeyev 0:e056ac8fecf8 11 * distributed under the License is distributed on an "AS IS" BASIS,
valeyev 0:e056ac8fecf8 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
valeyev 0:e056ac8fecf8 13 * See the License for the specific language governing permissions and
valeyev 0:e056ac8fecf8 14 * limitations under the License.
valeyev 0:e056ac8fecf8 15 */
valeyev 0:e056ac8fecf8 16
valeyev 0:e056ac8fecf8 17 #include "utest/utest.h"
valeyev 0:e056ac8fecf8 18 #include "unity/unity.h"
valeyev 0:e056ac8fecf8 19 #include "greentea-client/test_env.h"
valeyev 0:e056ac8fecf8 20
valeyev 0:e056ac8fecf8 21 #include "mbed.h"
valeyev 0:e056ac8fecf8 22
valeyev 0:e056ac8fecf8 23 using namespace utest::v1;
valeyev 0:e056ac8fecf8 24
valeyev 0:e056ac8fecf8 25 /* Structure for complex type. */
valeyev 0:e056ac8fecf8 26 typedef struct
valeyev 0:e056ac8fecf8 27 {
valeyev 0:e056ac8fecf8 28 int a;
valeyev 0:e056ac8fecf8 29 char b;
valeyev 0:e056ac8fecf8 30 int c;
valeyev 0:e056ac8fecf8 31 } COMPLEX_TYPE;
valeyev 0:e056ac8fecf8 32
valeyev 0:e056ac8fecf8 33 /* Function to check if complex type object holds specified values.*/
valeyev 0:e056ac8fecf8 34 bool comp_is_equal(COMPLEX_TYPE *object, int a, char b, int c)
valeyev 0:e056ac8fecf8 35 {
valeyev 0:e056ac8fecf8 36 if (object->a == a && object->b == b && object->c == c) {
valeyev 0:e056ac8fecf8 37 return true;
valeyev 0:e056ac8fecf8 38 }
valeyev 0:e056ac8fecf8 39
valeyev 0:e056ac8fecf8 40 return false;
valeyev 0:e056ac8fecf8 41 }
valeyev 0:e056ac8fecf8 42
valeyev 0:e056ac8fecf8 43 /* Function to set complex type object fields.*/
valeyev 0:e056ac8fecf8 44 void comp_set(COMPLEX_TYPE *object, int a, char b, int c)
valeyev 0:e056ac8fecf8 45 {
valeyev 0:e056ac8fecf8 46 object->a = a;
valeyev 0:e056ac8fecf8 47 object->b = b;
valeyev 0:e056ac8fecf8 48 object->c = c;
valeyev 0:e056ac8fecf8 49 }
valeyev 0:e056ac8fecf8 50
valeyev 0:e056ac8fecf8 51 /* Test circular buffer - input does not exceed capacity.
valeyev 0:e056ac8fecf8 52 *
valeyev 0:e056ac8fecf8 53 * Given is a circular buffer with the capacity equal to N (BufferSize).
valeyev 0:e056ac8fecf8 54 * When circular buffer is filled with N elements.
valeyev 0:e056ac8fecf8 55 * Then all elements are read from the circular buffer in the FIFO order.
valeyev 0:e056ac8fecf8 56 *
valeyev 0:e056ac8fecf8 57 */
valeyev 0:e056ac8fecf8 58 template<typename T, uint32_t BufferSize, typename CounterType>
valeyev 0:e056ac8fecf8 59 void test_input_does_not_exceed_capacity_push_max_pop_max()
valeyev 0:e056ac8fecf8 60 {
valeyev 0:e056ac8fecf8 61 CircularBuffer<T, BufferSize, CounterType> cb;
valeyev 0:e056ac8fecf8 62 T data = 0;
valeyev 0:e056ac8fecf8 63
valeyev 0:e056ac8fecf8 64 for (uint32_t i = 0; i < BufferSize; i++) {
valeyev 0:e056ac8fecf8 65 data = (0xAA + i);
valeyev 0:e056ac8fecf8 66 cb.push(data);
valeyev 0:e056ac8fecf8 67 TEST_ASSERT_EQUAL(i + 1, cb.size());
valeyev 0:e056ac8fecf8 68 }
valeyev 0:e056ac8fecf8 69
valeyev 0:e056ac8fecf8 70 for (uint32_t i = 0; i < BufferSize; i++) {
valeyev 0:e056ac8fecf8 71 TEST_ASSERT_TRUE(cb.pop(data));
valeyev 0:e056ac8fecf8 72 TEST_ASSERT_EQUAL(0xAA + i, data);
valeyev 0:e056ac8fecf8 73 TEST_ASSERT_EQUAL(BufferSize - i - 1, cb.size());
valeyev 0:e056ac8fecf8 74 }
valeyev 0:e056ac8fecf8 75 }
valeyev 0:e056ac8fecf8 76
valeyev 0:e056ac8fecf8 77 /* Test circular buffer - input does not exceed capacity.
valeyev 0:e056ac8fecf8 78 *
valeyev 0:e056ac8fecf8 79 * Given is a circular buffer with the capacity equal to N (BufferSize).
valeyev 0:e056ac8fecf8 80 * When circular buffer is filled as follows: (2 * N - 2) times 2 elements are pushed and 1 element is popped.
valeyev 0:e056ac8fecf8 81 * Then all elements are read from the circular buffer in the FIFO order.
valeyev 0:e056ac8fecf8 82 *
valeyev 0:e056ac8fecf8 83 */
valeyev 0:e056ac8fecf8 84 template<typename T, uint32_t BufferSize, typename CounterType>
valeyev 0:e056ac8fecf8 85 void test_input_does_not_exceed_capacity_push_2_pop_1()
valeyev 0:e056ac8fecf8 86 {
valeyev 0:e056ac8fecf8 87 CircularBuffer<T, BufferSize, CounterType> cb;
valeyev 0:e056ac8fecf8 88 static const int num_of_elem_push = (2 * BufferSize - 2);
valeyev 0:e056ac8fecf8 89 T push_buffer = 0;
valeyev 0:e056ac8fecf8 90 T pop_buffer = 0;
valeyev 0:e056ac8fecf8 91
valeyev 0:e056ac8fecf8 92 /* Push 2 elements and pop one element in each cycle. */
valeyev 0:e056ac8fecf8 93 for (uint32_t i = 0; i < num_of_elem_push; i += 2) {
valeyev 0:e056ac8fecf8 94 push_buffer = (0xAA + i);
valeyev 0:e056ac8fecf8 95 cb.push(push_buffer);
valeyev 0:e056ac8fecf8 96 push_buffer++;
valeyev 0:e056ac8fecf8 97 cb.push(push_buffer);
valeyev 0:e056ac8fecf8 98 TEST_ASSERT_EQUAL(i / 2 + 2, cb.size());
valeyev 0:e056ac8fecf8 99
valeyev 0:e056ac8fecf8 100 TEST_ASSERT_TRUE(cb.pop(pop_buffer));
valeyev 0:e056ac8fecf8 101 TEST_ASSERT_EQUAL(0xAA + i / 2, pop_buffer);
valeyev 0:e056ac8fecf8 102 TEST_ASSERT_EQUAL(i / 2 + 1, cb.size());
valeyev 0:e056ac8fecf8 103 }
valeyev 0:e056ac8fecf8 104
valeyev 0:e056ac8fecf8 105 /* Pop the rest. */
valeyev 0:e056ac8fecf8 106 for (uint32_t i = 0; i < (num_of_elem_push / 2); i++) {
valeyev 0:e056ac8fecf8 107 TEST_ASSERT_TRUE(cb.pop(pop_buffer));
valeyev 0:e056ac8fecf8 108 TEST_ASSERT_EQUAL(0xAA + num_of_elem_push / 2 + i, pop_buffer);
valeyev 0:e056ac8fecf8 109 TEST_ASSERT_EQUAL(num_of_elem_push / 2 - 1 - i, cb.size());
valeyev 0:e056ac8fecf8 110
valeyev 0:e056ac8fecf8 111 }
valeyev 0:e056ac8fecf8 112 }
valeyev 0:e056ac8fecf8 113
valeyev 0:e056ac8fecf8 114 /* Test circular buffer - input exceeds capacity.
valeyev 0:e056ac8fecf8 115 *
valeyev 0:e056ac8fecf8 116 * Given is a circular buffer with the capacity equal to N (BufferSize).
valeyev 0:e056ac8fecf8 117 * When circular buffer is filled with N + 1 elements.
valeyev 0:e056ac8fecf8 118 * Then first pushed element is lost (overwritten by the last element) and
valeyev 0:e056ac8fecf8 119 * elements are read from the circular buffer in the FIFO order.
valeyev 0:e056ac8fecf8 120 *
valeyev 0:e056ac8fecf8 121 */
valeyev 0:e056ac8fecf8 122 template<typename T, uint32_t BufferSize, typename CounterType>
valeyev 0:e056ac8fecf8 123 void test_input_exceeds_capacity_push_max_plus_1_pop_max()
valeyev 0:e056ac8fecf8 124 {
valeyev 0:e056ac8fecf8 125 CircularBuffer<T, BufferSize, CounterType> cb;
valeyev 0:e056ac8fecf8 126 static const int num_of_elem_push = (BufferSize + 1);
valeyev 0:e056ac8fecf8 127 T data = 0;
valeyev 0:e056ac8fecf8 128
valeyev 0:e056ac8fecf8 129 for (uint32_t i = 0; i < num_of_elem_push; i++) {
valeyev 0:e056ac8fecf8 130 data = (0xAA + i);
valeyev 0:e056ac8fecf8 131 cb.push(data);
valeyev 0:e056ac8fecf8 132 if (i < BufferSize) {
valeyev 0:e056ac8fecf8 133 TEST_ASSERT_EQUAL(i + 1, cb.size());
valeyev 0:e056ac8fecf8 134 } else {
valeyev 0:e056ac8fecf8 135 TEST_ASSERT_EQUAL(BufferSize, cb.size());
valeyev 0:e056ac8fecf8 136 }
valeyev 0:e056ac8fecf8 137
valeyev 0:e056ac8fecf8 138 }
valeyev 0:e056ac8fecf8 139
valeyev 0:e056ac8fecf8 140 for (uint32_t i = 0; i < (BufferSize - 1); i++) {
valeyev 0:e056ac8fecf8 141 TEST_ASSERT_TRUE(cb.pop(data));
valeyev 0:e056ac8fecf8 142 TEST_ASSERT_EQUAL(0xAA + i + 1, data);
valeyev 0:e056ac8fecf8 143 TEST_ASSERT_EQUAL(BufferSize - 1 - i, cb.size());
valeyev 0:e056ac8fecf8 144 }
valeyev 0:e056ac8fecf8 145
valeyev 0:e056ac8fecf8 146 /* First element should be overwritten. */
valeyev 0:e056ac8fecf8 147 TEST_ASSERT_TRUE(cb.pop(data));
valeyev 0:e056ac8fecf8 148 TEST_ASSERT_EQUAL((0xAA + num_of_elem_push - 1), data);
valeyev 0:e056ac8fecf8 149 TEST_ASSERT_EQUAL(0, cb.size());
valeyev 0:e056ac8fecf8 150 }
valeyev 0:e056ac8fecf8 151
valeyev 0:e056ac8fecf8 152 /* Test circular buffer - input exceeds capacity.
valeyev 0:e056ac8fecf8 153 *
valeyev 0:e056ac8fecf8 154 * Given is a circular buffer with the capacity equal to N (BufferSize).
valeyev 0:e056ac8fecf8 155 * When circular buffer is filled as follows: (2 * N) times 2 elements are pushed and 1 element is popped.
valeyev 0:e056ac8fecf8 156 * Then first pushed element is lost (overwritten by the last element) and
valeyev 0:e056ac8fecf8 157 * elements are read from the circular buffer in the FIFO order.
valeyev 0:e056ac8fecf8 158 *
valeyev 0:e056ac8fecf8 159 */
valeyev 0:e056ac8fecf8 160 template<typename T, uint32_t BufferSize, typename CounterType>
valeyev 0:e056ac8fecf8 161 void test_input_exceeds_capacity_push_2_pop_1()
valeyev 0:e056ac8fecf8 162 {
valeyev 0:e056ac8fecf8 163 CircularBuffer<T, BufferSize, CounterType> cb;
valeyev 0:e056ac8fecf8 164 static const int num_of_elem_push = (2 * BufferSize);
valeyev 0:e056ac8fecf8 165 T push_buffer = 0;
valeyev 0:e056ac8fecf8 166 T pop_buffer = 0;
valeyev 0:e056ac8fecf8 167
valeyev 0:e056ac8fecf8 168 /* Push 2 elements and pop one element in each cycle. */
valeyev 0:e056ac8fecf8 169 for (uint32_t i = 0; i < num_of_elem_push; i += 2) {
valeyev 0:e056ac8fecf8 170 push_buffer = (0xAA + i);
valeyev 0:e056ac8fecf8 171 cb.push(push_buffer);
valeyev 0:e056ac8fecf8 172 push_buffer++;
valeyev 0:e056ac8fecf8 173 cb.push(push_buffer);
valeyev 0:e056ac8fecf8 174 if ((i / 2 + 1) < BufferSize) {
valeyev 0:e056ac8fecf8 175 TEST_ASSERT_EQUAL(i / 2 + 2, cb.size());
valeyev 0:e056ac8fecf8 176 } else {
valeyev 0:e056ac8fecf8 177 TEST_ASSERT_EQUAL(BufferSize, cb.size());
valeyev 0:e056ac8fecf8 178 }
valeyev 0:e056ac8fecf8 179
valeyev 0:e056ac8fecf8 180 TEST_ASSERT_TRUE(cb.pop(pop_buffer));
valeyev 0:e056ac8fecf8 181 if ((i / 2 + 1) < BufferSize) {
valeyev 0:e056ac8fecf8 182 TEST_ASSERT_EQUAL(i / 2 + 1, cb.size());
valeyev 0:e056ac8fecf8 183 } else {
valeyev 0:e056ac8fecf8 184 TEST_ASSERT_EQUAL(BufferSize - 1, cb.size());
valeyev 0:e056ac8fecf8 185 }
valeyev 0:e056ac8fecf8 186
valeyev 0:e056ac8fecf8 187 /* First element has been overwritten. */
valeyev 0:e056ac8fecf8 188 if (i == (num_of_elem_push - 2)) {
valeyev 0:e056ac8fecf8 189 TEST_ASSERT_EQUAL(0xAA + i / 2 + 1, pop_buffer);
valeyev 0:e056ac8fecf8 190 } else {
valeyev 0:e056ac8fecf8 191 TEST_ASSERT_EQUAL(0xAA + i / 2, pop_buffer);
valeyev 0:e056ac8fecf8 192 }
valeyev 0:e056ac8fecf8 193 }
valeyev 0:e056ac8fecf8 194
valeyev 0:e056ac8fecf8 195 /* Pop the rest - one element has been overwritten. */
valeyev 0:e056ac8fecf8 196 for (uint32_t i = 0; i < (num_of_elem_push / 2 - 1); i++) {
valeyev 0:e056ac8fecf8 197 TEST_ASSERT_TRUE(cb.pop(pop_buffer));
valeyev 0:e056ac8fecf8 198 TEST_ASSERT_EQUAL(0xAA + num_of_elem_push / 2 + i + 1, pop_buffer);
valeyev 0:e056ac8fecf8 199 }
valeyev 0:e056ac8fecf8 200 }
valeyev 0:e056ac8fecf8 201
valeyev 0:e056ac8fecf8 202 /* Test circular buffer - input exceeds capacity (complex type).
valeyev 0:e056ac8fecf8 203 *
valeyev 0:e056ac8fecf8 204 * Given is a circular buffer with the capacity equal to N (BufferSize).
valeyev 0:e056ac8fecf8 205 * When circular buffer is filled as follows: (2 * N) times 2 elements are pushed and 1 element is popped.
valeyev 0:e056ac8fecf8 206 * Then first pushed element is lost (overwritten by the last element) and
valeyev 0:e056ac8fecf8 207 * elements are read from the circular buffer in the FIFO order.
valeyev 0:e056ac8fecf8 208 *
valeyev 0:e056ac8fecf8 209 */
valeyev 0:e056ac8fecf8 210 template<uint32_t BufferSize, typename CounterType>
valeyev 0:e056ac8fecf8 211 void test_input_exceeds_capacity_push_2_pop_1_complex_type()
valeyev 0:e056ac8fecf8 212 {
valeyev 0:e056ac8fecf8 213 CircularBuffer<COMPLEX_TYPE, BufferSize, CounterType> cb;
valeyev 0:e056ac8fecf8 214 static const int num_of_elem_push = (2 * BufferSize);
valeyev 0:e056ac8fecf8 215 COMPLEX_TYPE push_buffer = {0};
valeyev 0:e056ac8fecf8 216 COMPLEX_TYPE pop_buffer = {0};
valeyev 0:e056ac8fecf8 217
valeyev 0:e056ac8fecf8 218 /* Push 2 elements and pop one element in each cycle. */
valeyev 0:e056ac8fecf8 219 for (uint32_t i = 0; i < num_of_elem_push; i += 2) {
valeyev 0:e056ac8fecf8 220 comp_set(&push_buffer, 0xAA + i, 0xBB + i, 0xCC + i);
valeyev 0:e056ac8fecf8 221 cb.push(push_buffer);
valeyev 0:e056ac8fecf8 222 comp_set(&push_buffer, 0xAA + i + 1, 0xBB + i + 1, 0xCC + i + 1);
valeyev 0:e056ac8fecf8 223 cb.push(push_buffer);
valeyev 0:e056ac8fecf8 224 if ((i / 2 + 1) < BufferSize) {
valeyev 0:e056ac8fecf8 225 TEST_ASSERT_EQUAL(i / 2 + 2, cb.size());
valeyev 0:e056ac8fecf8 226 } else {
valeyev 0:e056ac8fecf8 227 TEST_ASSERT_EQUAL(BufferSize, cb.size());
valeyev 0:e056ac8fecf8 228 }
valeyev 0:e056ac8fecf8 229
valeyev 0:e056ac8fecf8 230 TEST_ASSERT_TRUE(cb.pop(pop_buffer));
valeyev 0:e056ac8fecf8 231 if ((i / 2 + 1) < BufferSize) {
valeyev 0:e056ac8fecf8 232 TEST_ASSERT_EQUAL(i / 2 + 1, cb.size());
valeyev 0:e056ac8fecf8 233 } else {
valeyev 0:e056ac8fecf8 234 TEST_ASSERT_EQUAL(BufferSize - 1, cb.size());
valeyev 0:e056ac8fecf8 235 }
valeyev 0:e056ac8fecf8 236
valeyev 0:e056ac8fecf8 237 /* First element has been overwritten. */
valeyev 0:e056ac8fecf8 238 if (i == (num_of_elem_push - 2)) {
valeyev 0:e056ac8fecf8 239 const bool result = comp_is_equal(&pop_buffer, 0xAA + 1 + i / 2, 0xBB + 1 + i / 2, 0xCC + 1 + i / 2);
valeyev 0:e056ac8fecf8 240 TEST_ASSERT_TRUE(result);
valeyev 0:e056ac8fecf8 241 } else {
valeyev 0:e056ac8fecf8 242 const bool result = comp_is_equal(&pop_buffer, 0xAA + i / 2, 0xBB + i / 2, 0xCC + i / 2);
valeyev 0:e056ac8fecf8 243 TEST_ASSERT_TRUE(result);
valeyev 0:e056ac8fecf8 244 }
valeyev 0:e056ac8fecf8 245 }
valeyev 0:e056ac8fecf8 246
valeyev 0:e056ac8fecf8 247 /* Pop the rest - one element has been overwritten. */
valeyev 0:e056ac8fecf8 248 for (uint32_t i = 0; i < (num_of_elem_push / 2 - 1); i++) {
valeyev 0:e056ac8fecf8 249 TEST_ASSERT_TRUE(cb.pop(pop_buffer));
valeyev 0:e056ac8fecf8 250 const bool result = comp_is_equal(&pop_buffer, 0xAA + num_of_elem_push / 2 + i + 1,
valeyev 0:e056ac8fecf8 251 0xBB + num_of_elem_push / 2 + i + 1, 0xCC + num_of_elem_push / 2 + i + 1);
valeyev 0:e056ac8fecf8 252 TEST_ASSERT_TRUE(result);
valeyev 0:e056ac8fecf8 253 }
valeyev 0:e056ac8fecf8 254 }
valeyev 0:e056ac8fecf8 255
valeyev 0:e056ac8fecf8 256 /* Test circular buffer - test pop(), empty(), full(), size() after CircularBuffer creation.
valeyev 0:e056ac8fecf8 257 *
valeyev 0:e056ac8fecf8 258 * Given is a circular buffer.
valeyev 0:e056ac8fecf8 259 * When circular buffer is created.
valeyev 0:e056ac8fecf8 260 * Then circular buffer is empty:
valeyev 0:e056ac8fecf8 261 * - empty() returns true,
valeyev 0:e056ac8fecf8 262 * - pop() function returns false,
valeyev 0:e056ac8fecf8 263 * - full() function returns false,
valeyev 0:e056ac8fecf8 264 * - size() function returns 0,
valeyev 0:e056ac8fecf8 265 *
valeyev 0:e056ac8fecf8 266 */
valeyev 0:e056ac8fecf8 267 void test_pop_empty_full_size_after_creation()
valeyev 0:e056ac8fecf8 268 {
valeyev 0:e056ac8fecf8 269 CircularBuffer<int, 1> cb;
valeyev 0:e056ac8fecf8 270 int data = 0;
valeyev 0:e056ac8fecf8 271
valeyev 0:e056ac8fecf8 272 TEST_ASSERT_TRUE(cb.empty());
valeyev 0:e056ac8fecf8 273 TEST_ASSERT_FALSE(cb.pop(data));
valeyev 0:e056ac8fecf8 274 TEST_ASSERT_FALSE(cb.full());
valeyev 0:e056ac8fecf8 275 TEST_ASSERT_EQUAL(0, cb.size());
valeyev 0:e056ac8fecf8 276 }
valeyev 0:e056ac8fecf8 277
valeyev 0:e056ac8fecf8 278 /* Test circular buffer - test empty() function.
valeyev 0:e056ac8fecf8 279 *
valeyev 0:e056ac8fecf8 280 * Given is a circular buffer with the capacity equal to N (BufferSize).
valeyev 0:e056ac8fecf8 281 * When operations on circular buffer are performed (push, pop).
valeyev 0:e056ac8fecf8 282 * Then empty() function returns true if buffer is empty, false otherwise.
valeyev 0:e056ac8fecf8 283 *
valeyev 0:e056ac8fecf8 284 */
valeyev 0:e056ac8fecf8 285 template<typename T, uint32_t BufferSize>
valeyev 0:e056ac8fecf8 286 void test_empty()
valeyev 0:e056ac8fecf8 287 {
valeyev 0:e056ac8fecf8 288 CircularBuffer<T, BufferSize> cb;
valeyev 0:e056ac8fecf8 289 T data = 0;
valeyev 0:e056ac8fecf8 290
valeyev 0:e056ac8fecf8 291 /* Push max elements. */
valeyev 0:e056ac8fecf8 292 for (uint32_t i = 0; i < BufferSize; i++) {
valeyev 0:e056ac8fecf8 293 cb.push(data);
valeyev 0:e056ac8fecf8 294 TEST_ASSERT_FALSE(cb.empty());
valeyev 0:e056ac8fecf8 295 }
valeyev 0:e056ac8fecf8 296
valeyev 0:e056ac8fecf8 297 /* Push next 2*BufferSize elements (overwrite entries). */
valeyev 0:e056ac8fecf8 298 for (uint32_t i = 0; i < (2 * BufferSize); i++) {
valeyev 0:e056ac8fecf8 299 cb.push(data);
valeyev 0:e056ac8fecf8 300 TEST_ASSERT_FALSE(cb.empty());
valeyev 0:e056ac8fecf8 301 }
valeyev 0:e056ac8fecf8 302
valeyev 0:e056ac8fecf8 303 /* Pop (BufferSize - 1) elements (leave one). */
valeyev 0:e056ac8fecf8 304 for (uint32_t i = 0; i < (BufferSize - 1); i++) {
valeyev 0:e056ac8fecf8 305 TEST_ASSERT_TRUE(cb.pop(data));
valeyev 0:e056ac8fecf8 306 TEST_ASSERT_FALSE(cb.empty());
valeyev 0:e056ac8fecf8 307 }
valeyev 0:e056ac8fecf8 308
valeyev 0:e056ac8fecf8 309 /* Take one which is left. */
valeyev 0:e056ac8fecf8 310 TEST_ASSERT_TRUE(cb.pop(data));
valeyev 0:e056ac8fecf8 311 TEST_ASSERT_TRUE(cb.empty());
valeyev 0:e056ac8fecf8 312
valeyev 0:e056ac8fecf8 313 /* Add one element to the empty buffer. */
valeyev 0:e056ac8fecf8 314 cb.push(data);
valeyev 0:e056ac8fecf8 315 TEST_ASSERT_FALSE(cb.empty());
valeyev 0:e056ac8fecf8 316 }
valeyev 0:e056ac8fecf8 317
valeyev 0:e056ac8fecf8 318 /* Test circular buffer - test full() function.
valeyev 0:e056ac8fecf8 319 *
valeyev 0:e056ac8fecf8 320 * Given is a circular buffer with the capacity equal to N (BufferSize).
valeyev 0:e056ac8fecf8 321 * When operations on circular buffer are performed (push, pop).
valeyev 0:e056ac8fecf8 322 * Then full() function returns true if buffer is full, false otherwise.
valeyev 0:e056ac8fecf8 323 *
valeyev 0:e056ac8fecf8 324 */
valeyev 0:e056ac8fecf8 325 template<typename T, uint32_t BufferSize>
valeyev 0:e056ac8fecf8 326 void test_full()
valeyev 0:e056ac8fecf8 327 {
valeyev 0:e056ac8fecf8 328 CircularBuffer<T, BufferSize> cb;
valeyev 0:e056ac8fecf8 329 T data = 0;
valeyev 0:e056ac8fecf8 330
valeyev 0:e056ac8fecf8 331 /* Push max elements - 1. */
valeyev 0:e056ac8fecf8 332 for (uint32_t i = 0; i < (BufferSize - 1); i++) {
valeyev 0:e056ac8fecf8 333 cb.push(data);
valeyev 0:e056ac8fecf8 334 TEST_ASSERT_FALSE(cb.full());
valeyev 0:e056ac8fecf8 335 }
valeyev 0:e056ac8fecf8 336
valeyev 0:e056ac8fecf8 337 /* Push one element - buffer should be full now. */
valeyev 0:e056ac8fecf8 338 cb.push(data);
valeyev 0:e056ac8fecf8 339 TEST_ASSERT_TRUE(cb.full());
valeyev 0:e056ac8fecf8 340
valeyev 0:e056ac8fecf8 341 /* Push next 2*BufferSize elements (overwrite entries). */
valeyev 0:e056ac8fecf8 342 for (uint32_t i = 0; i < (2 * BufferSize); i++) {
valeyev 0:e056ac8fecf8 343 cb.push(data);
valeyev 0:e056ac8fecf8 344 TEST_ASSERT_TRUE(cb.full());
valeyev 0:e056ac8fecf8 345 }
valeyev 0:e056ac8fecf8 346
valeyev 0:e056ac8fecf8 347 /* Pop all elements. */
valeyev 0:e056ac8fecf8 348 for (uint32_t i = 0; i < BufferSize; i++) {
valeyev 0:e056ac8fecf8 349 TEST_ASSERT_TRUE(cb.pop(data));
valeyev 0:e056ac8fecf8 350 TEST_ASSERT_FALSE(cb.full());
valeyev 0:e056ac8fecf8 351 }
valeyev 0:e056ac8fecf8 352 }
valeyev 0:e056ac8fecf8 353
valeyev 0:e056ac8fecf8 354 /* Test circular buffer - test reset() function.
valeyev 0:e056ac8fecf8 355 *
valeyev 0:e056ac8fecf8 356 * Given is a circular buffer with the capacity equal to N (BufferSize).
valeyev 0:e056ac8fecf8 357 * When reset operation is performed on circular buffer.
valeyev 0:e056ac8fecf8 358 * Then circular buffer is cleared.
valeyev 0:e056ac8fecf8 359 *
valeyev 0:e056ac8fecf8 360 */
valeyev 0:e056ac8fecf8 361 template<typename T, uint32_t BufferSize>
valeyev 0:e056ac8fecf8 362 void test_reset()
valeyev 0:e056ac8fecf8 363 {
valeyev 0:e056ac8fecf8 364 CircularBuffer<T, BufferSize> cb;
valeyev 0:e056ac8fecf8 365 T data = 0xAA;
valeyev 0:e056ac8fecf8 366
valeyev 0:e056ac8fecf8 367 /* Push max elements. */
valeyev 0:e056ac8fecf8 368 for (uint32_t i = 0; i < BufferSize; i++) {
valeyev 0:e056ac8fecf8 369 cb.push(data);
valeyev 0:e056ac8fecf8 370 }
valeyev 0:e056ac8fecf8 371
valeyev 0:e056ac8fecf8 372 TEST_ASSERT_TRUE(cb.full());
valeyev 0:e056ac8fecf8 373 TEST_ASSERT_FALSE(cb.empty());
valeyev 0:e056ac8fecf8 374 TEST_ASSERT_EQUAL(BufferSize, cb.size());
valeyev 0:e056ac8fecf8 375
valeyev 0:e056ac8fecf8 376 cb.reset();
valeyev 0:e056ac8fecf8 377
valeyev 0:e056ac8fecf8 378 TEST_ASSERT_FALSE(cb.full());
valeyev 0:e056ac8fecf8 379 TEST_ASSERT_TRUE(cb.empty());
valeyev 0:e056ac8fecf8 380 TEST_ASSERT_FALSE(cb.pop(data));
valeyev 0:e056ac8fecf8 381 TEST_ASSERT_EQUAL(0, cb.size());
valeyev 0:e056ac8fecf8 382
valeyev 0:e056ac8fecf8 383 /* Check if after reset push and pop operations work. */
valeyev 0:e056ac8fecf8 384 for (uint32_t i = 0; i < BufferSize; i++) {
valeyev 0:e056ac8fecf8 385 cb.push(data);
valeyev 0:e056ac8fecf8 386 data++;
valeyev 0:e056ac8fecf8 387 }
valeyev 0:e056ac8fecf8 388
valeyev 0:e056ac8fecf8 389 for (uint32_t i = 0; i < BufferSize; i++) {
valeyev 0:e056ac8fecf8 390 cb.pop(data);
valeyev 0:e056ac8fecf8 391 TEST_ASSERT_EQUAL(0xAA + i, data);
valeyev 0:e056ac8fecf8 392 }
valeyev 0:e056ac8fecf8 393 }
valeyev 0:e056ac8fecf8 394
valeyev 0:e056ac8fecf8 395 /* Test circular buffer - creation of circular buffer with max buffer size consistent with counter type.
valeyev 0:e056ac8fecf8 396 *
valeyev 0:e056ac8fecf8 397 * Given is a circular buffer.
valeyev 0:e056ac8fecf8 398 * When circular buffer is created with buffer size equal to 255 and counter type equal to unsigned char.
valeyev 0:e056ac8fecf8 399 * Then circular buffer is successfully created.
valeyev 0:e056ac8fecf8 400 *
valeyev 0:e056ac8fecf8 401 */
valeyev 0:e056ac8fecf8 402 void test_counter_type_buffer_size()
valeyev 0:e056ac8fecf8 403 {
valeyev 0:e056ac8fecf8 404 CircularBuffer<int, 255, unsigned char> cb;
valeyev 0:e056ac8fecf8 405 int data = 100;
valeyev 0:e056ac8fecf8 406
valeyev 0:e056ac8fecf8 407 /* Perform some operations. */
valeyev 0:e056ac8fecf8 408 cb.push(data);
valeyev 0:e056ac8fecf8 409 data = 0;
valeyev 0:e056ac8fecf8 410 cb.pop(data);
valeyev 0:e056ac8fecf8 411 TEST_ASSERT_EQUAL(100, data);
valeyev 0:e056ac8fecf8 412 }
valeyev 0:e056ac8fecf8 413
valeyev 0:e056ac8fecf8 414 utest::v1::status_t greentea_failure_handler(const Case *const source, const failure_t reason)
valeyev 0:e056ac8fecf8 415 {
valeyev 0:e056ac8fecf8 416 greentea_case_failure_abort_handler(source, reason);
valeyev 0:e056ac8fecf8 417 return STATUS_CONTINUE;
valeyev 0:e056ac8fecf8 418 }
valeyev 0:e056ac8fecf8 419
valeyev 0:e056ac8fecf8 420 Case cases[] = {
valeyev 0:e056ac8fecf8 421 Case("Input does not exceed capacity(1) push max, pop max.",
valeyev 0:e056ac8fecf8 422 test_input_does_not_exceed_capacity_push_max_pop_max<uint32_t, 1, unsigned int>, greentea_failure_handler),
valeyev 0:e056ac8fecf8 423 Case("Input does not exceed capacity(3) push max, pop max.",
valeyev 0:e056ac8fecf8 424 test_input_does_not_exceed_capacity_push_max_pop_max<char, 3, unsigned int>, greentea_failure_handler),
valeyev 0:e056ac8fecf8 425
valeyev 0:e056ac8fecf8 426 Case("Input does not exceed capacity(5) push 2, pop 1.",
valeyev 0:e056ac8fecf8 427 test_input_does_not_exceed_capacity_push_2_pop_1<uint32_t, 5, unsigned char>, greentea_failure_handler),
valeyev 0:e056ac8fecf8 428 Case("Input does not exceed capacity(10) push 2, pop 1.",
valeyev 0:e056ac8fecf8 429 test_input_does_not_exceed_capacity_push_2_pop_1<char, 10, unsigned char>, greentea_failure_handler),
valeyev 0:e056ac8fecf8 430
valeyev 0:e056ac8fecf8 431 Case("Input exceeds capacity(1) push max+1, pop max.",
valeyev 0:e056ac8fecf8 432 test_input_exceeds_capacity_push_max_plus_1_pop_max<uint32_t, 1, unsigned int>, greentea_failure_handler),
valeyev 0:e056ac8fecf8 433 Case("Input exceeds capacity(3) push max+1, pop max.",
valeyev 0:e056ac8fecf8 434 test_input_exceeds_capacity_push_max_plus_1_pop_max<char, 3, unsigned int>, greentea_failure_handler),
valeyev 0:e056ac8fecf8 435
valeyev 0:e056ac8fecf8 436 Case("Input exceeds capacity(5) push 2, pop 1.",
valeyev 0:e056ac8fecf8 437 test_input_exceeds_capacity_push_2_pop_1<uint32_t, 5, unsigned short>, greentea_failure_handler),
valeyev 0:e056ac8fecf8 438 Case("Input exceeds capacity(10) push 2, pop 1.",
valeyev 0:e056ac8fecf8 439 test_input_exceeds_capacity_push_2_pop_1<char, 10, unsigned short>, greentea_failure_handler),
valeyev 0:e056ac8fecf8 440
valeyev 0:e056ac8fecf8 441 Case("empty() returns true when buffer(3 elements) is empty.", test_empty<uint32_t, 3>, greentea_failure_handler),
valeyev 0:e056ac8fecf8 442 Case("empty() returns true when buffer(5 elements) is empty.", test_empty<uint32_t, 5>, greentea_failure_handler),
valeyev 0:e056ac8fecf8 443
valeyev 0:e056ac8fecf8 444 Case("full() returns true when buffer(3 elements) is full.", test_full<uint32_t, 3>, greentea_failure_handler),
valeyev 0:e056ac8fecf8 445 Case("full() returns true when buffer(5 elements) is full.", test_full<uint32_t, 5>, greentea_failure_handler),
valeyev 0:e056ac8fecf8 446
valeyev 0:e056ac8fecf8 447 Case("reset() clears the buffer.", test_reset<uint32_t, 5>, greentea_failure_handler),
valeyev 0:e056ac8fecf8 448
valeyev 0:e056ac8fecf8 449 Case("Test pop(), empty(), full(), size() after CircularBuffer creation.",
valeyev 0:e056ac8fecf8 450 test_pop_empty_full_size_after_creation, greentea_failure_handler),
valeyev 0:e056ac8fecf8 451
valeyev 0:e056ac8fecf8 452 Case("Test CounterType/BufferSize boarder case.", test_counter_type_buffer_size, greentea_failure_handler),
valeyev 0:e056ac8fecf8 453
valeyev 0:e056ac8fecf8 454 Case("Input exceeds capacity(5) push 2, pop 1 - complex type.",
valeyev 0:e056ac8fecf8 455 test_input_exceeds_capacity_push_2_pop_1_complex_type<5, unsigned short>, greentea_failure_handler),
valeyev 0:e056ac8fecf8 456 };
valeyev 0:e056ac8fecf8 457
valeyev 0:e056ac8fecf8 458 utest::v1::status_t greentea_test_setup(const size_t number_of_cases)
valeyev 0:e056ac8fecf8 459 {
valeyev 0:e056ac8fecf8 460 GREENTEA_SETUP(15, "default_auto");
valeyev 0:e056ac8fecf8 461 return greentea_test_setup_handler(number_of_cases);
valeyev 0:e056ac8fecf8 462 }
valeyev 0:e056ac8fecf8 463
valeyev 0:e056ac8fecf8 464 Specification specification(greentea_test_setup, cases, greentea_test_teardown_handler);
valeyev 0:e056ac8fecf8 465
valeyev 0:e056ac8fecf8 466 int main()
valeyev 0:e056ac8fecf8 467 {
valeyev 0:e056ac8fecf8 468 return Harness::run(specification);
valeyev 0:e056ac8fecf8 469 }