ut_seglist.c

00001 /*
00002 # This file is Copyright 2003, 2006, 2007, 2009 Dean Hall.
00003 #
00004 # This file is part of the Python-on-a-Chip program.
00005 # Python-on-a-Chip is free software: you can redistribute it and/or modify
00006 # it under the terms of the GNU LESSER GENERAL PUBLIC LICENSE Version 2.1.
00007 #
00008 # Python-on-a-Chip is distributed in the hope that it will be useful,
00009 # but WITHOUT ANY WARRANTY; without even the implied warranty of
00010 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
00011 # A copy of the GNU LESSER GENERAL PUBLIC LICENSE Version 2.1
00012 # is seen in the file COPYING up one directory from this.
00013 */
00014 
00015 
00022 #include "CuTest.h"
00023 #include "pm.h"
00024 
00025 
00031 void
00032 ut_seglist_new_000(CuTest *tc)
00033 {
00034     PmReturn_t retval;
00035     pSeglist_t pseglist;
00036 
00037     retval = seglist_new(&pseglist);
00038 
00039     CuAssertTrue(tc, retval == PM_RET_OK);
00040     CuAssertPtrNotNull(tc, pseglist);
00041 }
00042 
00043 
00049 void
00050 ut_seglist_appendItem_000(CuTest *tc)
00051 {
00052     PmReturn_t retval;
00053     pSeglist_t pseglist;
00054 
00055     retval = seglist_new(&pseglist);
00056     retval = seglist_appendItem(pseglist, PM_ZERO);
00057 
00058     CuAssertTrue(tc, retval == PM_RET_OK);
00059     CuAssertTrue(tc, pseglist->sl_length == 1);
00060 }
00061 
00062 
00068 void
00069 ut_seglist_appendItem_001(CuTest *tc)
00070 {
00071     PmReturn_t retval;
00072     pSeglist_t pseglist;
00073     int8_t i;
00074 
00075     retval = seglist_new(&pseglist);
00076     for (i=8; i>0; i--)
00077     {
00078         seglist_appendItem(pseglist, PM_ZERO);
00079     }
00080     retval = seglist_appendItem(pseglist, PM_ONE);
00081 
00082     CuAssertTrue(tc, retval == PM_RET_OK);
00083     CuAssertTrue(tc, pseglist->sl_length == 9);
00084 }
00085 
00086 
00092 void
00093 ut_seglist_insertItem_000(CuTest *tc)
00094 {
00095     PmReturn_t retval;
00096     pSeglist_t pseglist;
00097 
00098     retval = seglist_new(&pseglist);
00099     retval = seglist_insertItem(pseglist, PM_ZERO, 0);
00100 
00101     CuAssertTrue(tc, retval == PM_RET_OK);
00102     CuAssertTrue(tc, pseglist->sl_length == 1);
00103 }
00104 
00105 
00111 void
00112 ut_seglist_insertItem_001(CuTest *tc)
00113 {
00114     PmReturn_t retval;
00115     pSeglist_t pseglist;
00116     int8_t i;
00117 
00118     retval = seglist_new(&pseglist);
00119     retval = seglist_insertItem(pseglist, PM_ONE, 0);
00120     for (i=8; i>0; i--)
00121     {
00122         seglist_insertItem(pseglist, PM_ZERO, 0);
00123     }
00124 
00125     CuAssertTrue(tc, retval == PM_RET_OK);
00126     CuAssertTrue(tc, pseglist->sl_length == 9);
00127 }
00128 
00129 
00135 void
00136 ut_seglist_insertItem_002(CuTest *tc)
00137 {
00138     PmReturn_t retval;
00139     pSeglist_t pseglist;
00140     pPmObj_t pobj;
00141     int8_t i;
00142 
00143     seglist_new(&pseglist);
00144     seglist_insertItem(pseglist, PM_ONE, 0);
00145     for (i=8; i>0; i--)
00146     {
00147         seglist_insertItem(pseglist, PM_ZERO, 0);
00148     }
00149     retval = seglist_getItem(pseglist, 0, &pobj);
00150     CuAssertTrue(tc, retval == PM_RET_OK);
00151     CuAssertTrue(tc, pobj == PM_ZERO);
00152 
00153     retval = seglist_getItem(pseglist, 8, &pobj);
00154     CuAssertTrue(tc, retval == PM_RET_OK);
00155     CuAssertTrue(tc, pobj == PM_ONE);
00156 }
00157 
00158 
00164 void
00165 ut_seglist_getItem_000(CuTest *tc)
00166 {
00167     PmReturn_t retval;
00168     pSeglist_t pseglist;
00169     pPmObj_t pobj;
00170 
00171     seglist_new(&pseglist);
00172     seglist_appendItem(pseglist, PM_ZERO);
00173     retval = seglist_getItem(pseglist, 0, &pobj);
00174 
00175     CuAssertTrue(tc, retval == PM_RET_OK);
00176     CuAssertTrue(tc, pobj == PM_ZERO);
00177 }
00178 
00179 
00185 void
00186 ut_seglist_getItem_001(CuTest *tc)
00187 {
00188     PmReturn_t retval;
00189     pSeglist_t pseglist;
00190     pPmObj_t pobj;
00191     int8_t i;
00192 
00193     retval = seglist_new(&pseglist);
00194     for (i=8; i>0; i--)
00195     {
00196         seglist_appendItem(pseglist, PM_ZERO);
00197     }
00198     seglist_appendItem(pseglist, PM_ONE);
00199     retval = seglist_getItem(pseglist, 0, &pobj);
00200     CuAssertTrue(tc, retval == PM_RET_OK);
00201     CuAssertTrue(tc, pobj == PM_ZERO);
00202 
00203     retval = seglist_getItem(pseglist, 8, &pobj);
00204     CuAssertTrue(tc, retval == PM_RET_OK);
00205     CuAssertTrue(tc, pobj == PM_ONE);
00206 }
00207 
00239 void
00240 ut_seglist_removeItem_000(CuTest *tc)
00241 {
00242     PmReturn_t retval;
00243     pSeglist_t pseglist;
00244     pPmObj_t pobj;
00245     int8_t i;
00246     pPmObj_t item[11];
00247 
00248     retval = seglist_new(&pseglist);
00249     for (i=0; i<11; i++)
00250     {
00251         retval = int_new(i, &item[i]);
00252         CuAssertTrue(tc, retval == PM_RET_OK);
00253     }
00254     
00255     for (i=0; i<10; i++)
00256     {
00257         retval = seglist_appendItem(pseglist, (pPmObj_t)item[i]);
00258         CuAssertTrue(tc, retval == PM_RET_OK);
00259     }
00260 
00261     CuAssertTrue(tc, pseglist->sl_length == 10);
00262     
00263         
00264     for (i=0; i<10; i++)
00265     {
00266         retval = seglist_getItem(pseglist, i, &pobj);
00267         CuAssertTrue(tc, retval == PM_RET_OK);
00268         CuAssertTrue(tc, pobj == item[i]);
00269     }
00270     
00271     retval = seglist_removeItem(pseglist, 9);
00272     CuAssertTrue(tc, retval == PM_RET_OK);
00273     CuAssertTrue(tc, pseglist->sl_length == 9);
00274     retval = seglist_getItem(pseglist, 8, &pobj);
00275     CuAssertTrue(tc, retval == PM_RET_OK);
00276     CuAssertTrue(tc, pobj == item[8]);
00277 
00278     /* Testing seglist_removeItem(pseglist, 9) for a PM_RET_ASSERT_FAIL
00279      * return code is only valid if the VM is compiled with DEBUG. This can
00280      * not be determined here, so the test is deactivated as it will wreak
00281      * havoc inside the seglist if executed without C_ASSERT stopping the
00282      * operation.
00283      */
00284     /*
00285     retval = seglist_removeItem(pseglist, 9);
00286     CuAssertTrue(tc, retval == PM_RET_ASSERT_FAIL);
00287     */
00288     
00289     /* TODO check if number of segments has actually decreased if item 8 is
00290      * removed; also check heap usage after GC
00291      */
00292 
00293     retval = seglist_appendItem(pseglist, (pPmObj_t)item[10]);
00294     CuAssertTrue(tc, retval == PM_RET_OK);
00295     CuAssertTrue(tc, pseglist->sl_length == 10);
00296     retval = seglist_getItem(pseglist, 9, &pobj);
00297     CuAssertTrue(tc, retval == PM_RET_OK);
00298     CuAssertTrue(tc, pobj == item[10]);
00299 
00300     retval = seglist_removeItem(pseglist, 9);
00301     CuAssertTrue(tc, retval == PM_RET_OK);
00302     retval = seglist_removeItem(pseglist, 8);
00303     CuAssertTrue(tc, retval == PM_RET_OK);
00304     retval = seglist_removeItem(pseglist, 7);
00305     CuAssertTrue(tc, retval == PM_RET_OK);
00306     CuAssertTrue(tc, pseglist->sl_length == 7);
00307 
00308     retval = seglist_appendItem(pseglist, (pPmObj_t)item[10]);
00309     CuAssertTrue(tc, retval == PM_RET_OK);
00310     CuAssertTrue(tc, pseglist->sl_length == 8);
00311     retval = seglist_getItem(pseglist, 7, &pobj);
00312     CuAssertTrue(tc, retval == PM_RET_OK);
00313     CuAssertTrue(tc, pobj == item[10]);
00314     retval = seglist_getItem(pseglist, 6, &pobj);
00315     CuAssertTrue(tc, retval == PM_RET_OK);
00316     CuAssertTrue(tc, pobj == item[6]);
00317 
00318     retval = seglist_appendItem(pseglist, (pPmObj_t)item[2]);
00319     CuAssertTrue(tc, retval == PM_RET_OK);
00320     retval = seglist_getItem(pseglist, 8, &pobj);
00321     CuAssertTrue(tc, retval == PM_RET_OK);
00322     CuAssertTrue(tc, pobj == item[2]);
00323 
00324     for (i=0; i<9; i++)
00325     {
00326         retval = seglist_removeItem(pseglist, 0);
00327         CuAssertTrue(tc, retval == PM_RET_OK);
00328     }
00329     CuAssertTrue(tc, pseglist->sl_length == 0);
00330     retval = seglist_appendItem(pseglist, (pPmObj_t)item[2]);
00331     CuAssertTrue(tc, retval == PM_RET_OK);
00332     CuAssertTrue(tc, pseglist->sl_length == 1);
00333     retval = seglist_getItem(pseglist, 0, &pobj);
00334     CuAssertTrue(tc, retval == PM_RET_OK);
00335     CuAssertTrue(tc, pobj == item[2]);
00336 }
00337 
00339 CuSuite *getSuite_testSeglist(void)
00340 {
00341     CuSuite* suite = CuSuiteNew();
00342 
00343     SUITE_ADD_TEST(suite, ut_seglist_new_000);
00344     SUITE_ADD_TEST(suite, ut_seglist_appendItem_000);
00345     SUITE_ADD_TEST(suite, ut_seglist_appendItem_001);
00346     SUITE_ADD_TEST(suite, ut_seglist_insertItem_000);
00347     SUITE_ADD_TEST(suite, ut_seglist_insertItem_001);
00348     SUITE_ADD_TEST(suite, ut_seglist_insertItem_002);
00349     SUITE_ADD_TEST(suite, ut_seglist_getItem_000);
00350     SUITE_ADD_TEST(suite, ut_seglist_getItem_001);
00351     SUITE_ADD_TEST(suite, ut_seglist_removeItem_000);
00352 
00353     return suite;
00354 }

Generated on Mon Oct 18 07:40:47 2010 for Python-on-a-chip by  doxygen 1.5.9