pelib
2.0.0
|
00001 /* 00002 * fifo_test.c 00003 * 00004 * Created on: 26 Jan 2012 00005 * Copyright 2012 Nicolas Melot 00006 * 00007 * This file is part of pelib. 00008 * 00009 * pelib is free software: you can redistribute it and/or modify 00010 * it under the terms of the GNU General Public License as published by 00011 * the Free Software Foundation, either version 3 of the License, or 00012 * (at your option) any later version. 00013 * 00014 * pelib is distributed in the hope that it will be useful, 00015 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00016 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00017 * GNU General Public License for more details. 00018 * 00019 * You should have received a copy of the GNU General Public License 00020 * along with pelib. If not, see <http://www.gnu.org/licenses/>. 00021 * 00022 */ 00023 00024 #include <stdlib.h> 00025 #include <stdio.h> 00026 #include <string.h> 00027 00028 #include <pelib/unit.h> 00029 #include <pelib/size_t.h> 00030 00031 #define CAPACITY 10 00032 #define VALUE 10 00033 #define TO_TAIL 7 00034 #define FROM_HEAD 4 00035 #define DISCARD (CAPACITY - 7) 00036 #define OFFSET 1 // Must fit between 0 and FROM_HEAD, TO_TAIL and CAPACITY and FROM_HEAD and TO_TAIL 00037 00038 cfifo_t(size_t) *cfifo; 00039 size_t value; 00040 size_t reverse[CAPACITY], normal[CAPACITY], different[CAPACITY]; 00041 00042 void 00043 init() 00044 { 00045 unsigned int i; 00046 00047 cfifo = pelib_alloc_collection(cfifo_t(size_t))(CAPACITY); 00048 pelib_init(cfifo_t(size_t))(cfifo); 00049 value = VALUE; 00050 00051 for (i = 0; i < CAPACITY; i++) 00052 { 00053 pelib_cfifo_push(size_t)(cfifo, i + VALUE); 00054 normal[i] = VALUE + TO_TAIL + i; 00055 reverse[i] = VALUE + CAPACITY + FROM_HEAD + i; 00056 different[i] = -1; 00057 } 00058 } 00059 00060 void 00061 cleanup() 00062 { 00063 pelib_free(cfifo_t(size_t))(cfifo); 00064 } 00065 00066 void 00067 setup() 00068 { 00069 // do nothing 00070 } 00071 00072 void 00073 teardown() 00074 { 00075 // do nothing 00076 } 00077 00078 static void 00079 test_pop() 00080 { 00081 unsigned int i; 00082 00083 i = pelib_cfifo_pop(size_t)(cfifo); 00084 00085 assert(i == VALUE); 00086 } 00087 00088 /* 00089 static void 00090 test_pop_too_much() 00091 { 00092 unsigned int i; 00093 00094 for (i = 0; i < CAPACITY + 1; i++) 00095 { 00096 pelib_cfifo_pop(size_t)(cfifo); 00097 } 00098 } 00099 */ 00100 00101 static void 00102 test_push() 00103 { 00104 unsigned int i; 00105 00106 for (i = 0; i < CAPACITY; i++) 00107 { 00108 pelib_cfifo_pop(size_t)(cfifo); 00109 } 00110 00111 for (i = 0; i < CAPACITY; i++) 00112 { 00113 pelib_cfifo_push(size_t)(cfifo, VALUE * 2 + i); 00114 } 00115 00116 assert(pelib_cfifo_peek(size_t)(cfifo, 0) == VALUE * 2); 00117 } 00118 00119 static void 00120 test_push_too_much() 00121 { 00122 unsigned int i, res; 00123 00124 for (i = 0; i < CAPACITY + 1; i++) 00125 { 00126 res = pelib_cfifo_push(size_t)(cfifo, VALUE); 00127 } 00128 00129 assert(res == 0); 00130 } 00131 00132 static void 00133 test_is_full_or_empty() 00134 { 00135 unsigned int i; 00136 00137 assert(pelib_cfifo_is_full(size_t)(cfifo) == 1); 00138 assert(pelib_cfifo_is_empty(size_t)(cfifo) == 0); 00139 00140 for (i = 0; i < (CAPACITY + 1) / 2; i++) 00141 { 00142 pelib_cfifo_pop(size_t)(cfifo); 00143 } 00144 00145 assert(pelib_cfifo_is_full(size_t)(cfifo) == 0); 00146 assert(pelib_cfifo_is_empty(size_t)(cfifo) == 0); 00147 00148 for (; i < (CAPACITY + 1); i++) 00149 { 00150 pelib_cfifo_pop(size_t)(cfifo); 00151 } 00152 00153 assert(pelib_cfifo_is_full(size_t)(cfifo) == 0); 00154 assert(pelib_cfifo_is_empty(size_t)(cfifo) == 1); 00155 } 00156 00157 static void 00158 test_string() 00159 { 00160 char* str; 00161 00162 // Full fifo with read_ptr and write_ptr at the edge [>>10:11:12:13:14:15:16:17:18:19] 00163 str = pelib_string(cfifo_t(size_t))(*cfifo); 00164 assert_equals_str(str, "[>>10:11:12:13:14:15:16:17:18:19]"); 00165 free(str); 00166 00167 pelib_cfifo_pop(size_t)(cfifo); 00168 pelib_cfifo_pop(size_t)(cfifo); 00169 pelib_cfifo_pop(size_t)(cfifo); 00170 pelib_cfifo_pop(size_t)(cfifo); 00171 pelib_cfifo_pop(size_t)(cfifo); 00172 pelib_cfifo_pop(size_t)(cfifo); 00173 00174 // Not full fifo, reverse mode with read_ptr in the middle [>.:.:.:.:.:.:>16:17:18:19] 00175 str = pelib_string(cfifo_t(size_t))(*cfifo); 00176 assert_equals_str(str, "[>.:.:.:.:.:.:>16:17:18:19]"); 00177 free(str); 00178 00179 pelib_cfifo_push(size_t)(cfifo, 2); 00180 pelib_cfifo_push(size_t)(cfifo, 5); 00181 00182 // Not full fifo, reverse mode with write_ptr and read_ptr in the middle [2:5:>.:.:.:.:>16:17:18:19] 00183 str = pelib_string(cfifo_t(size_t))(*cfifo); 00184 assert_equals_str(str, "[2:5:>.:.:.:.:>16:17:18:19]"); 00185 free(str); 00186 00187 pelib_cfifo_push(size_t)(cfifo, 2); 00188 pelib_cfifo_push(size_t)(cfifo, 5); 00189 pelib_cfifo_push(size_t)(cfifo, 7); 00190 pelib_cfifo_push(size_t)(cfifo, 4); 00191 00192 // Full fifo with write_ptr and read_ptr in the middle [2:5:2:5:7:4:>>16:17:18:19] 00193 str = pelib_string(cfifo_t(size_t))(*cfifo); 00194 assert_equals_str(str, "[2:5:2:5:7:4:>>16:17:18:19]"); 00195 free(str); 00196 00197 pelib_cfifo_pop(size_t)(cfifo); 00198 pelib_cfifo_pop(size_t)(cfifo); 00199 pelib_cfifo_pop(size_t)(cfifo); 00200 pelib_cfifo_pop(size_t)(cfifo); 00201 00202 // Not full fifo with read_ptr at the edge and write_ptr in the middle [>2:5:2:5:7:4:>.:.:.:.] 00203 str = pelib_string(cfifo_t(size_t))(*cfifo); 00204 assert_equals_str(str, "[>2:5:2:5:7:4:>.:.:.:.]"); 00205 free(str); 00206 00207 pelib_cfifo_pop(size_t)(cfifo); 00208 pelib_cfifo_pop(size_t)(cfifo); 00209 pelib_cfifo_pop(size_t)(cfifo); 00210 pelib_cfifo_pop(size_t)(cfifo); 00211 pelib_cfifo_pop(size_t)(cfifo); 00212 pelib_cfifo_pop(size_t)(cfifo); 00213 00214 // Empty fifo with write_ptr and read_ptr in the middle [.:.:.:.:.:.:>>.:.:.:.] 00215 str = pelib_string(cfifo_t(size_t))(*cfifo); 00216 assert_equals_str(str, "[.:.:.:.:.:.:>>.:.:.:.]"); 00217 free(str); 00218 00219 pelib_cfifo_push(size_t)(cfifo, 1); 00220 pelib_cfifo_push(size_t)(cfifo, 6); 00221 pelib_cfifo_push(size_t)(cfifo, 9); 00222 pelib_cfifo_push(size_t)(cfifo, 8); 00223 00224 // Not full fifo, normal mode with write_ptr and read_ptr in the middle [>.:.:.:.:.:.:>1:6:9:8] 00225 str = pelib_string(cfifo_t(size_t))(*cfifo); 00226 assert_equals_str(str, "[>.:.:.:.:.:.:>1:6:9:8]"); 00227 free(str); 00228 00229 pelib_cfifo_pop(size_t)(cfifo); 00230 pelib_cfifo_pop(size_t)(cfifo); 00231 pelib_cfifo_pop(size_t)(cfifo); 00232 pelib_cfifo_pop(size_t)(cfifo); 00233 00234 // Empty fifo with write_ptr and read_ptr in edge [>>.:.:.:.:.:.:.:.:.:.] 00235 str = pelib_string(cfifo_t(size_t))(*cfifo); 00236 assert_equals_str(str, "[>>.:.:.:.:.:.:.:.:.:.]"); 00237 free(str); 00238 00239 pelib_cfifo_push(size_t)(cfifo, 1); 00240 pelib_cfifo_push(size_t)(cfifo, 6); 00241 pelib_cfifo_push(size_t)(cfifo, 9); 00242 pelib_cfifo_push(size_t)(cfifo, 8); 00243 00244 // Not full fifo, normal mode with write_ptr in the middle amd and read_ptr at the edge [>1:6:9:8<:.:.:.:.:.:.] 00245 str = pelib_string(cfifo_t(size_t))(*cfifo); 00246 assert_equals_str(str, "[>1:6:9:8:>.:.:.:.:.:.]"); 00247 free(str); 00248 } 00249 00250 static void 00251 cfifo_pushmem_full() 00252 { 00253 int ret, i; 00254 00255 // Testing if adding more elements to fifo results in 0 and keeps fifo full 00256 ret = pelib_cfifo_pushmem(size_t)(cfifo, normal, CAPACITY); 00257 assert(pelib_cfifo_is_full(size_t)(cfifo)); 00258 assert(ret == 0); 00259 00260 for(i = 0; i < CAPACITY; i++) 00261 { 00262 assert(pelib_cfifo_pop(size_t)(cfifo) == i + VALUE); 00263 } 00264 } 00265 00266 static void 00267 cfifo_pushmem_normal() 00268 { 00269 unsigned int i, ret; 00270 00271 // Empty fifo 00272 for(i = 0; i < CAPACITY; i++) 00273 { 00274 pelib_cfifo_pop(size_t)(cfifo); 00275 } 00276 00277 // Fill it till TO_HEAD 00278 for(i = 0; i < TO_TAIL; i++) 00279 { 00280 pelib_cfifo_push(size_t)(cfifo, i + VALUE); 00281 } 00282 00283 // Now fifo is reverse, write_ptr start at buffer + FROM_HEAD and read_ptr at buffer - TO_TAIL 00284 ret = pelib_cfifo_pushmem(size_t)(cfifo, normal, CAPACITY - TO_TAIL); 00285 assert(pelib_cfifo_is_full(size_t)(cfifo)); 00286 assert(ret == CAPACITY - TO_TAIL); 00287 00288 for(i = 0; i < CAPACITY; i++) 00289 { 00290 assert(pelib_cfifo_pop(size_t)(cfifo) == i + VALUE); 00291 } 00292 } 00293 00294 static void 00295 cfifo_pushmem_reverse() 00296 { 00297 unsigned int i, ret; 00298 00299 // Now fifo is at normal state, there are TO_TAIL free spots just before the end of buffer 00300 for(i = 0; i < TO_TAIL; i++) 00301 { 00302 pelib_cfifo_pop(size_t)(cfifo); 00303 } 00304 00305 // Now fifo has CAPACITY - TO_TAIL elements, stored at the end of its buffer 00306 for(i = 0; i < FROM_HEAD; i++) 00307 { 00308 pelib_cfifo_push(size_t)(cfifo, i + VALUE + CAPACITY); 00309 } 00310 00311 // Now fifo is reverse, write_ptr start at buffer + FROM_HEAD and read_ptr at buffer - TO_TAIL 00312 ret = pelib_cfifo_pushmem(size_t)(cfifo, reverse, TO_TAIL - FROM_HEAD); 00313 assert(pelib_cfifo_is_full(size_t)(cfifo)); 00314 assert(ret == TO_TAIL - FROM_HEAD); 00315 00316 00317 for(i = 0; i < CAPACITY; i++) 00318 { 00319 assert(pelib_cfifo_pop(size_t)(cfifo) == i + VALUE + TO_TAIL); 00320 } 00321 } 00322 00323 static void 00324 cfifo_pushmem_normal_and_reverse() 00325 { 00326 unsigned int i, ret; 00327 00328 // Empty fifo 00329 for(i = 0; i < CAPACITY; i++) 00330 { 00331 pelib_cfifo_pop(size_t)(cfifo); 00332 } 00333 00334 // Fill it till TO_TAIL 00335 for(i = 0; i < TO_TAIL; i++) 00336 { 00337 pelib_cfifo_push(size_t)(cfifo, i + VALUE); 00338 } 00339 00340 // Pop to FROM_HEAD 00341 for(i = 0; i < FROM_HEAD; i++) 00342 { 00343 pelib_cfifo_pop(size_t)(cfifo); 00344 } 00345 00346 // Now fifo is normal, write_ptr start at buffer + TO_TAIL and read_ptr at buffer - FROM_HEAD 00347 ret = pelib_cfifo_pushmem(size_t)(cfifo, normal, CAPACITY - TO_TAIL + FROM_HEAD); 00348 assert(pelib_cfifo_is_full(size_t)(cfifo)); 00349 assert(ret == CAPACITY - TO_TAIL + FROM_HEAD); 00350 00351 for(i = 0; i < CAPACITY; i++) 00352 { 00353 assert(pelib_cfifo_pop(size_t)(cfifo) == i + VALUE + FROM_HEAD); 00354 } 00355 } 00356 00357 static void 00358 cfifo_pushmem_too_much() 00359 { 00360 unsigned int i, ret; 00361 00362 // Empty fifo 00363 for(i = 0; i < CAPACITY; i++) 00364 { 00365 pelib_cfifo_pop(size_t)(cfifo); 00366 } 00367 00368 // Fill it till TO_TAIL 00369 for(i = 0; i < TO_TAIL; i++) 00370 { 00371 pelib_cfifo_push(size_t)(cfifo, i + VALUE); 00372 } 00373 00374 // Now fifo is inormal, write_ptr start at buffer + TO_TAIL and read_ptr at buffer - FROM_HEAD 00375 ret = pelib_cfifo_pushmem(size_t)(cfifo, normal, CAPACITY - TO_TAIL + FROM_HEAD); 00376 assert(pelib_cfifo_is_full(size_t)(cfifo)); 00377 assert(ret == CAPACITY - TO_TAIL); 00378 00379 for(i = 0; i < CAPACITY; i++) 00380 { 00381 assert(pelib_cfifo_pop(size_t)(cfifo) == i + VALUE); 00382 } 00383 } 00384 00385 void 00386 cfifo_popmem_simple() 00387 { 00388 int ret, i; 00389 00390 ret = pelib_cfifo_popmem(size_t)(cfifo, different, CAPACITY); 00391 assert(ret == CAPACITY); 00392 assert(pelib_cfifo_is_empty(size_t)(cfifo)); 00393 00394 for(i = 0; i < CAPACITY; i++) 00395 { 00396 assert(different[i] == cfifo->buffer[i]); 00397 } 00398 } 00399 00400 void 00401 cfifo_popmem_partial() 00402 { 00403 int ret, i; 00404 00405 ret = pelib_cfifo_popmem(size_t)(cfifo, different, CAPACITY / 2); 00406 assert(ret == CAPACITY / 2); 00407 assert(!pelib_cfifo_is_empty(size_t)(cfifo)); 00408 assert(!pelib_cfifo_is_full(size_t)(cfifo)); 00409 00410 for(i = 0; i < CAPACITY / 2; i++) 00411 { 00412 assert(different[i] == cfifo->buffer[i]); 00413 } 00414 } 00415 00416 void 00417 cfifo_popmem_reverse() 00418 { 00419 int i; 00420 00421 for(i = 0; i < TO_TAIL; i++) 00422 { 00423 pelib_cfifo_pop(size_t)(cfifo); 00424 } 00425 00426 for(i = 0; i < FROM_HEAD; i++) 00427 { 00428 pelib_cfifo_push(size_t)(cfifo, i + VALUE + CAPACITY); 00429 } 00430 00431 pelib_cfifo_popmem(size_t)(cfifo, different, CAPACITY - TO_TAIL + FROM_HEAD); 00432 00433 assert(pelib_cfifo_is_empty(size_t)(cfifo)); 00434 00435 for(i = 0; i < CAPACITY - TO_TAIL + FROM_HEAD; i++) 00436 { 00437 assert(different[i] == i + VALUE + TO_TAIL); 00438 } 00439 } 00440 00441 void 00442 cfifo_popmem_too_much() 00443 { 00444 int i, ret; 00445 00446 for(i = 0; i < TO_TAIL; i++) 00447 { 00448 pelib_cfifo_pop(size_t)(cfifo); 00449 } 00450 00451 ret = pelib_cfifo_popmem(size_t)(cfifo, different, CAPACITY); 00452 00453 assert(pelib_cfifo_is_empty(size_t)(cfifo)); 00454 assert(ret == CAPACITY - TO_TAIL); 00455 00456 for(i = 0; i < CAPACITY - TO_TAIL; i++) 00457 { 00458 assert(different[i] == i + VALUE + TO_TAIL); 00459 } 00460 } 00461 00462 void 00463 test_peekmem_simple() 00464 { 00465 int ret, i; 00466 00467 ret = pelib_cfifo_peekmem(size_t)(cfifo, different, CAPACITY, 0); 00468 assert(ret == CAPACITY); 00469 assert(pelib_cfifo_is_full(size_t)(cfifo)); 00470 00471 for(i = 0; i < CAPACITY; i++) 00472 { 00473 assert(different[i] == cfifo->buffer[i]); 00474 } 00475 } 00476 00477 void 00478 test_peekmem_partial() 00479 { 00480 int ret, i; 00481 00482 ret = pelib_cfifo_peekmem(size_t)(cfifo, different, CAPACITY / 2, 0); 00483 assert(ret == CAPACITY / 2); 00484 assert(!pelib_cfifo_is_empty(size_t)(cfifo)); 00485 assert(pelib_cfifo_is_full(size_t)(cfifo)); 00486 00487 for(i = 0; i < CAPACITY / 2; i++) 00488 { 00489 assert(different[i] == cfifo->buffer[i]); 00490 } 00491 } 00492 00493 void 00494 test_peekmem_reverse() 00495 { 00496 size_t i; 00497 00498 for(i = 0; i < TO_TAIL; i++) 00499 { 00500 pelib_cfifo_pop(size_t)(cfifo); 00501 } 00502 00503 for(i = 0; i < FROM_HEAD; i++) 00504 { 00505 pelib_cfifo_push(size_t)(cfifo, i + VALUE + CAPACITY); 00506 } 00507 00508 pelib_cfifo_peekmem(size_t)(cfifo, different, CAPACITY - TO_TAIL + FROM_HEAD, 0); 00509 assert(pelib_cfifo_length(size_t)(cfifo) == CAPACITY - TO_TAIL + FROM_HEAD); 00510 00511 for(i = 0; i < CAPACITY - TO_TAIL + FROM_HEAD; i++) 00512 { 00513 assert_equals_size_t(different[i], i + VALUE + TO_TAIL); 00514 } 00515 } 00516 00517 void 00518 test_peekmem_too_much() 00519 { 00520 size_t ret, i; 00521 00522 for(i = 0; i < TO_TAIL; i++) 00523 { 00524 pelib_cfifo_pop(size_t)(cfifo); 00525 } 00526 00527 ret = pelib_cfifo_peekmem(size_t)(cfifo, different, CAPACITY, 0); 00528 00529 assert_equals_size_t(pelib_cfifo_length(size_t)(cfifo), (size_t)(CAPACITY - TO_TAIL)); 00530 assert_equals_size_t(ret, (size_t)(CAPACITY - TO_TAIL)); 00531 00532 for(i = 0; i < CAPACITY - TO_TAIL; i++) 00533 { 00534 assert(different[i] == i + VALUE + TO_TAIL); 00535 } 00536 } 00537 00538 void 00539 cfifo_length() 00540 { 00541 assert(pelib_cfifo_length(size_t)(cfifo) == CAPACITY); 00542 00543 pelib_cfifo_popmem(size_t)(cfifo, normal, FROM_HEAD); 00544 assert(pelib_cfifo_length(size_t)(cfifo) == CAPACITY - FROM_HEAD); 00545 00546 pelib_cfifo_popmem(size_t)(cfifo, normal, TO_TAIL - FROM_HEAD); 00547 assert(pelib_cfifo_length(size_t)(cfifo) == CAPACITY - TO_TAIL); 00548 00549 pelib_cfifo_popmem(size_t)(cfifo, normal, CAPACITY - TO_TAIL); 00550 assert(pelib_cfifo_length(size_t)(cfifo) == 0); 00551 00552 pelib_cfifo_pushmem(size_t)(cfifo, normal, FROM_HEAD); 00553 assert(pelib_cfifo_length(size_t)(cfifo) == FROM_HEAD); 00554 00555 pelib_cfifo_pushmem(size_t)(cfifo, normal, TO_TAIL - FROM_HEAD); 00556 assert(pelib_cfifo_length(size_t)(cfifo) == TO_TAIL); 00557 00558 pelib_cfifo_pushmem(size_t)(cfifo, normal, CAPACITY - TO_TAIL); 00559 assert(pelib_cfifo_length(size_t)(cfifo) == CAPACITY); 00560 } 00561 00562 void 00563 cfifo_last() 00564 { 00565 int i; 00566 00567 assert(pelib_cfifo_last(size_t)(cfifo) == VALUE + CAPACITY - 1); 00568 pelib_cfifo_pop(size_t)(cfifo); 00569 assert(pelib_cfifo_last(size_t)(cfifo) == VALUE + CAPACITY - 1); 00570 for(i = 0; i < CAPACITY - 1; i++) 00571 { 00572 pelib_cfifo_pop(size_t)(cfifo); 00573 } 00574 assert(pelib_cfifo_last(size_t)(cfifo) == 0); 00575 00576 pelib_cfifo_push(size_t)(cfifo, 3); 00577 assert(pelib_cfifo_last(size_t)(cfifo) == 3); 00578 00579 pelib_cfifo_push(size_t)(cfifo, 7); 00580 assert(pelib_cfifo_last(size_t)(cfifo) == 7); 00581 } 00582 00583 void 00584 test_discard() 00585 { 00586 size_t res; 00587 00588 // Do not discard anything 00589 res = pelib_cfifo_discard(size_t)(cfifo, 0); 00590 assert(res == 0); 00591 assert(pelib_cfifo_length(size_t)(cfifo) == CAPACITY); 00592 00593 // Discard a few values 00594 res = pelib_cfifo_discard(size_t)(cfifo, DISCARD); 00595 assert(res == DISCARD); 00596 assert(pelib_cfifo_length(size_t)(cfifo) == CAPACITY - DISCARD); 00597 00598 // Discard all remaining values 00599 res = pelib_cfifo_discard(size_t)(cfifo, CAPACITY - DISCARD); 00600 assert(res == CAPACITY - DISCARD); 00601 assert(pelib_cfifo_length(size_t)(cfifo) == 0); 00602 00603 // Discard even more values 00604 res = pelib_cfifo_discard(size_t)(cfifo, DISCARD); 00605 assert(res == 0); 00606 assert(pelib_cfifo_length(size_t)(cfifo) == 0); 00607 } 00608 00609 void 00610 test_discard_too_much() 00611 { 00612 size_t res; 00613 00614 // Discard more elements than in fifo 00615 res = pelib_cfifo_discard(size_t)(cfifo, CAPACITY + DISCARD); 00616 assert(res == CAPACITY); 00617 assert(pelib_cfifo_length(size_t)(cfifo) == 0); 00618 } 00619 00620 void 00621 test_fill() 00622 { 00623 size_t res; 00624 00625 // Get rid of everything in fifo 00626 pelib_cfifo_discard(size_t)(cfifo, CAPACITY); 00627 00628 // Do not fill at all 00629 res = pelib_cfifo_fill(size_t)(cfifo, 0); 00630 assert(res == 0); 00631 assert(pelib_cfifo_length(size_t)(cfifo) == 0); 00632 00633 // Fill a few values 00634 res = pelib_cfifo_fill(size_t)(cfifo, DISCARD); 00635 assert(res == DISCARD); 00636 assert(pelib_cfifo_length(size_t)(cfifo) == DISCARD); 00637 00638 // Fill as much as remaining free spots 00639 res = pelib_cfifo_fill(size_t)(cfifo, CAPACITY - DISCARD); 00640 assert(res == CAPACITY - DISCARD); 00641 assert(pelib_cfifo_length(size_t)(cfifo) == CAPACITY); 00642 assert(pelib_cfifo_is_full(size_t)(cfifo)); 00643 00644 // Fill with even more values 00645 res = pelib_cfifo_fill(size_t)(cfifo, DISCARD); 00646 assert(res == 0); 00647 assert(pelib_cfifo_length(size_t)(cfifo) == CAPACITY); 00648 assert(pelib_cfifo_is_full(size_t)(cfifo)); 00649 } 00650 00651 void 00652 test_fill_too_much() 00653 { 00654 size_t res; 00655 00656 // Empty fifo 00657 pelib_cfifo_discard(size_t)(cfifo, CAPACITY); 00658 00659 // Fill with more value than capacity contains 00660 res = pelib_cfifo_fill(size_t)(cfifo, CAPACITY + DISCARD); 00661 00662 assert(res == CAPACITY); 00663 assert(pelib_cfifo_length(size_t)(cfifo) == CAPACITY); 00664 assert(pelib_cfifo_is_full(size_t)(cfifo)); 00665 } 00666 00667 void 00668 test_popfifo_simple() 00669 { 00670 size_t res; 00671 int i; 00672 00673 cfifo_t(size_t) *recipient; 00674 recipient = pelib_alloc_collection(cfifo_t(size_t))(CAPACITY); 00675 pelib_init(cfifo_t(size_t))(recipient); 00676 00677 // Pop nothing 00678 res = pelib_cfifo_popfifo(size_t)(cfifo, recipient, 0); 00679 assert(res == 0); 00680 assert(pelib_cfifo_is_full(size_t)(cfifo)); 00681 assert(pelib_cfifo_is_empty(size_t)(recipient)); 00682 00683 // Pop everything 00684 res = pelib_cfifo_popfifo(size_t)(cfifo, recipient, CAPACITY); 00685 assert(res == CAPACITY); 00686 assert(pelib_cfifo_is_full(size_t)(recipient)); 00687 assert(pelib_cfifo_is_empty(size_t)(cfifo)); 00688 00689 for(i = 0; i < CAPACITY; i++) 00690 { 00691 assert(pelib_cfifo_peek(size_t)(recipient, i) == i + VALUE) 00692 } 00693 00694 // Try to pop more, but first add values to cfifo 00695 for(i = 0; i < TO_TAIL; i++) 00696 { 00697 pelib_cfifo_push(size_t)(cfifo, i); 00698 } 00699 00700 // Pop everything added 00701 res = pelib_cfifo_popfifo(size_t)(cfifo, recipient, TO_TAIL); 00702 assert(res == 0); 00703 assert(pelib_cfifo_is_full(size_t)(recipient)); 00704 assert(!pelib_cfifo_is_empty(size_t)(cfifo)); 00705 00706 // Empty source and recipient fifo and try to insert again 00707 pelib_cfifo_discard(size_t)(recipient, CAPACITY); 00708 pelib_cfifo_discard(size_t)(cfifo, CAPACITY); 00709 res = pelib_cfifo_popfifo(size_t)(cfifo, recipient, CAPACITY); 00710 assert(res == 0); 00711 assert(pelib_cfifo_is_empty(size_t)(recipient)); 00712 assert(pelib_cfifo_is_empty(size_t)(cfifo)); 00713 00714 // Good ol' cleanup 00715 pelib_free(cfifo_t(size_t))(recipient); 00716 } 00717 00718 void 00719 test_popfifo_complex() 00720 { 00721 int i; 00722 size_t res; 00723 00724 // Make reference fifo in reverse state 00725 pelib_cfifo_discard(size_t)(cfifo, TO_TAIL); 00726 for(i = 0; i < FROM_HEAD; i++) 00727 { 00728 pelib_cfifo_push(size_t)(cfifo, i + VALUE + CAPACITY); 00729 } 00730 00731 // Make a recipient fifo in reverse state, but less free space 00732 cfifo_t(size_t) *recipient; 00733 recipient = pelib_alloc_collection(cfifo_t(size_t))(CAPACITY); 00734 pelib_init(cfifo_t(size_t))(recipient); 00735 00736 for(i = 0; i < CAPACITY; i++) 00737 { 00738 pelib_cfifo_push(size_t)(recipient, i + VALUE); 00739 } 00740 pelib_cfifo_discard(size_t)(recipient, TO_TAIL - OFFSET); 00741 for(i = 0; i < FROM_HEAD + OFFSET; i++) 00742 { 00743 pelib_cfifo_push(size_t)(recipient, i + VALUE + CAPACITY); 00744 } 00745 00746 res = pelib_cfifo_popfifo(size_t)(cfifo, recipient, CAPACITY); 00747 assert(res == TO_TAIL - FROM_HEAD - 2 * OFFSET); 00748 assert(pelib_cfifo_length(size_t)(recipient) == CAPACITY); 00749 assert(pelib_cfifo_is_full(size_t)(recipient)); 00750 assert(!pelib_cfifo_is_full(size_t)(cfifo)); 00751 assert(!pelib_cfifo_is_empty(size_t)(cfifo)); 00752 assert(pelib_cfifo_length(size_t)(cfifo) == FROM_HEAD + CAPACITY - TO_TAIL - (TO_TAIL - FROM_HEAD - 2 * OFFSET)); 00753 00754 /* TODO: Make sure recipient indeed has the expected values */ 00755 00756 // Good ol' cleanup 00757 pelib_free(cfifo_t(size_t))(recipient); 00758 } 00759 00760 void 00761 run() 00762 { 00763 test(test_pop); 00764 //test(test_pop_too_much); 00765 test(test_discard); 00766 test(test_discard_too_much); 00767 test(test_push); 00768 test(test_push_too_much); 00769 test(test_fill); 00770 test(test_fill_too_much); 00771 test(test_is_full_or_empty); 00772 test(test_string); 00773 //test(test_string_content); 00774 test(cfifo_pushmem_full); 00775 test(cfifo_pushmem_normal); 00776 test(cfifo_pushmem_reverse); 00777 test(cfifo_pushmem_normal_and_reverse); 00778 test(cfifo_pushmem_too_much); 00779 test(cfifo_popmem_simple); 00780 test(cfifo_popmem_partial); 00781 test(cfifo_popmem_reverse); 00782 test(cfifo_popmem_too_much); 00783 test(test_peekmem_simple); 00784 test(test_peekmem_partial); 00785 test(test_peekmem_reverse); 00786 test(test_peekmem_too_much); 00787 test(cfifo_length); 00788 test(cfifo_last); 00789 test(test_popfifo_simple); 00790 test(test_popfifo_complex); 00791 }