pelib  2.0.0
src/test_fifo.c
Go to the documentation of this file.
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 }