ut_list.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 
00035 void
00036 ut_list_new_000(CuTest *tc)
00037 {
00038     pPmObj_t pobj = C_NULL;
00039     PmReturn_t retval;
00040 
00041     retval = pm_init(MEMSPACE_RAM, C_NULL);
00042     retval = list_new(&pobj);
00043 
00044     CuAssertTrue(tc, retval == PM_RET_OK);
00045     CuAssertPtrNotNull(tc, pobj);
00046     CuAssertTrue(tc, OBJ_GET_TYPE(pobj) == OBJ_TYPE_LST);
00047     CuAssertTrue(tc, ((pPmDict_t)pobj)->length == 0);
00048 }
00049 
00050 
00059 void
00060 ut_list_append_000(CuTest *tc)
00061 {
00062     pPmObj_t pobj = C_NULL;
00063     pPmObj_t pval;
00064     PmReturn_t retval;
00065 
00066     retval = pm_init(MEMSPACE_RAM, C_NULL);
00067     retval = list_new(&pobj);
00068 
00069     retval = list_append(PM_ONE, PM_ONE);
00070     CuAssertTrue(tc, retval == PM_RET_EX_TYPE);
00071     retval = list_append(pobj, PM_ONE);
00072     CuAssertPtrNotNull(tc, pobj);
00073     CuAssertTrue(tc, ((pPmList_t)pobj)->length == 1);
00074     retval = list_getItem(pobj, 0, &pval);
00075     CuAssertTrue(tc, pval == PM_ONE);
00076     retval = list_getItem(pobj, -1, &pval);
00077     CuAssertTrue(tc, pval == PM_ONE);
00078 }
00079 
00106 void
00107 ut_list_removeItem_000(CuTest *tc)
00108 {
00109     pPmObj_t pobj = C_NULL;
00110     pPmObj_t pval;
00111     pPmObj_t pitem0, pitem1, pitem2, pitem3, pitem4, pitem5;
00112     PmReturn_t retval;
00113 
00114     retval = pm_init(MEMSPACE_RAM, C_NULL);
00115     retval = list_new(&pobj);
00116 
00117     retval = int_new(0, &pitem0);
00118     CuAssertTrue(tc, retval == PM_RET_OK);
00119     retval = int_new(1, &pitem1);
00120     CuAssertTrue(tc, retval == PM_RET_OK);
00121     retval = int_new(2, &pitem2);
00122     CuAssertTrue(tc, retval == PM_RET_OK);
00123     retval = int_new(3, &pitem3);
00124     CuAssertTrue(tc, retval == PM_RET_OK);
00125     retval = int_new(4, &pitem4);
00126     CuAssertTrue(tc, retval == PM_RET_OK);
00127     retval = int_new(5, &pitem5);
00128     CuAssertTrue(tc, retval == PM_RET_OK);
00129 
00130     retval = list_append(pobj, pitem0);
00131     CuAssertTrue(tc, retval == PM_RET_OK);
00132     retval = list_append(pobj, pitem1);
00133     CuAssertTrue(tc, retval == PM_RET_OK);
00134     retval = list_append(pobj, pitem2);
00135     CuAssertTrue(tc, retval == PM_RET_OK);
00136     retval = list_append(pobj, pitem3);
00137     CuAssertTrue(tc, retval == PM_RET_OK);
00138     retval = list_append(pobj, pitem4);
00139     CuAssertTrue(tc, retval == PM_RET_OK);
00140 
00141 
00142     CuAssertTrue(tc, ((pPmList_t)pobj)->length == 5);
00143 
00144     retval = list_remove(pobj, pitem0);
00145     CuAssertTrue(tc, retval == PM_RET_OK);
00146     CuAssertTrue(tc, ((pPmList_t)pobj)->length == 4);
00147     retval = list_getItem(pobj, 0, &pval);
00148     CuAssertTrue(tc, pval == pitem1);
00149     retval = list_getItem(pobj, -1, &pval);
00150     CuAssertTrue(tc, pval == pitem4);
00151 
00152     retval = list_remove(pobj, pitem5);
00153     CuAssertTrue(tc, retval == PM_RET_EX_VAL);
00154 
00155     retval = list_remove(pobj, pitem4);
00156     CuAssertTrue(tc, retval == PM_RET_OK);
00157     CuAssertTrue(tc, ((pPmList_t)pobj)->length == 3);
00158     retval = list_getItem(pobj, -1, &pval);
00159     CuAssertTrue(tc, pval == pitem3);
00160 
00161     retval = list_remove(pobj, pitem4);
00162     CuAssertTrue(tc, retval == PM_RET_EX_VAL);
00163 
00164     retval = list_remove(pobj, pitem2);
00165     CuAssertTrue(tc, retval == PM_RET_OK);
00166     CuAssertTrue(tc, ((pPmList_t)pobj)->length == 2);
00167     retval = list_getItem(pobj, 0, &pval);
00168     CuAssertTrue(tc, pval == pitem1);
00169     retval = list_getItem(pobj, 1, &pval);
00170     CuAssertTrue(tc, pval == pitem3);
00171 
00172     retval = list_remove(pobj, pitem1);
00173     CuAssertTrue(tc, retval == PM_RET_OK);
00174     retval = list_remove(pobj, pitem3);
00175     CuAssertTrue(tc, retval == PM_RET_OK);
00176     CuAssertTrue(tc, ((pPmList_t)pobj)->length == 0);
00177 
00178     retval = list_append(pobj, pitem5);
00179     CuAssertTrue(tc, retval == PM_RET_OK);
00180     CuAssertTrue(tc, ((pPmList_t)pobj)->length == 1);
00181     retval = list_getItem(pobj, 0, &pval);
00182     CuAssertTrue(tc, pval == pitem5);
00183 
00184 }
00185 
00186 
00201 void
00202 ut_list_getItem_000(CuTest *tc)
00203 {
00204     pPmObj_t pobj = C_NULL;
00205     pPmObj_t pval;
00206     PmReturn_t retval;
00207 
00208     retval = pm_init(MEMSPACE_RAM, C_NULL);
00209     retval = list_new(&pobj);
00210 
00211     retval = list_getItem(PM_ONE, 0, &pval);
00212     CuAssertTrue(tc, retval == PM_RET_EX_TYPE);
00213     retval = list_getItem(pobj, -1, &pval);
00214     CuAssertTrue(tc, retval == PM_RET_EX_INDX);
00215     retval = list_getItem(pobj, 1, &pval);
00216     CuAssertTrue(tc, retval == PM_RET_EX_INDX);
00217     retval = list_getItem(pobj, 0, &pval);
00218     CuAssertTrue(tc, retval == PM_RET_EX_INDX);
00219 
00220     retval = list_append(pobj, PM_ONE);
00221     retval = list_getItem(pobj, -2, &pval);
00222     CuAssertTrue(tc, retval == PM_RET_EX_INDX);
00223     retval = list_getItem(pobj, 1, &pval);
00224     CuAssertTrue(tc, retval == PM_RET_EX_INDX);
00225     retval = list_getItem(pobj, 10, &pval);
00226     CuAssertTrue(tc, retval == PM_RET_EX_INDX);
00227     retval = list_getItem(pobj, 0, &pval);
00228     CuAssertTrue(tc, retval == PM_RET_OK);
00229     CuAssertTrue(tc, ((pPmList_t)pobj)->length == 1);
00230     CuAssertTrue(tc, pval == PM_ONE);
00231 }
00232 
00233 
00238 void
00239 ut_list_getItem_001(CuTest *tc)
00240 {
00241     pPmObj_t plist;
00242     pPmObj_t pobj0;
00243     pPmObj_t pobj1;
00244     pPmObj_t pobj2;
00245     pPmObj_t pget;
00246     PmReturn_t retval;
00247 
00248     retval = pm_init(MEMSPACE_RAM, C_NULL);
00249 
00250     retval = list_new(&plist);
00251     retval = dict_new(&pobj0);
00252     retval = tuple_new(0, &pobj1);
00253     retval = int_new(42, &pobj2);
00254 
00255     retval = list_append(plist, pobj0);
00256     retval = list_append(plist, pobj1);
00257     retval = list_append(plist, pobj2);
00258 
00259     retval = list_getItem(plist, 0, &pget);
00260     CuAssertTrue(tc, pget == pobj0);
00261     retval = list_getItem(plist, 1, &pget);
00262     CuAssertTrue(tc, pget == pobj1);
00263     retval = list_getItem(plist, 2, &pget);
00264     CuAssertTrue(tc, pget == pobj2);
00265 }
00266 
00267 
00282 void
00283 ut_list_setItem_000(CuTest *tc)
00284 {
00285     pPmObj_t pobj = C_NULL;
00286     pPmObj_t pval;
00287     PmReturn_t retval;
00288 
00289     retval = pm_init(MEMSPACE_RAM, C_NULL);
00290     retval = list_new(&pobj);
00291 
00292     retval = list_setItem(PM_ONE, 0, PM_ONE);
00293     CuAssertTrue(tc, retval == PM_RET_EX_TYPE);
00294     retval = list_setItem(pobj, -1, PM_ONE);
00295     CuAssertTrue(tc, retval == PM_RET_EX_INDX);
00296     retval = list_setItem(pobj, 1, PM_ONE);
00297     CuAssertTrue(tc, retval == PM_RET_EX_INDX);
00298     retval = list_setItem(pobj, 0, PM_ONE);
00299     CuAssertTrue(tc, retval == PM_RET_EX_INDX);
00300 
00301     retval = list_append(pobj, PM_ONE);
00302     retval = list_setItem(pobj, -1, PM_ONE);
00303     CuAssertTrue(tc, retval == PM_RET_OK);
00304     retval = list_setItem(pobj, 1, PM_ONE);
00305     CuAssertTrue(tc, retval == PM_RET_EX_INDX);
00306     retval = list_setItem(pobj, 10, PM_ONE);
00307     CuAssertTrue(tc, retval == PM_RET_EX_INDX);
00308     retval = list_setItem(pobj, 0, PM_ZERO);
00309     CuAssertTrue(tc, retval == PM_RET_OK);
00310     CuAssertTrue(tc, ((pPmList_t)pobj)->length == 1);
00311     retval = list_getItem(pobj, 0, &pval);
00312     CuAssertTrue(tc, pval == PM_ZERO);
00313 }
00314 
00315 
00322 void
00323 ut_list_setItem_001(CuTest *tc)
00324 {
00325     pPmObj_t plist;
00326     pPmObj_t pobj0;
00327     pPmObj_t pobj1;
00328     pPmObj_t pobj2;
00329     pPmObj_t pget;
00330     PmReturn_t retval;
00331 
00332     retval = pm_init(MEMSPACE_RAM, C_NULL);
00333 
00334     retval = list_new(&plist);
00335     retval = dict_new(&pobj0);
00336     retval = tuple_new(0, &pobj1);
00337     retval = int_new(42, &pobj2);
00338 
00339     retval = list_append(plist, PM_NONE);
00340     retval = list_append(plist, PM_NONE);
00341     retval = list_append(plist, PM_NONE);
00342 
00343     retval = list_setItem(plist, 0, pobj0);
00344     CuAssertTrue(tc, retval == PM_RET_OK);
00345     retval = list_setItem(plist, 1, pobj1);
00346     CuAssertTrue(tc, retval == PM_RET_OK);
00347     retval = list_setItem(plist, 2, pobj2);
00348     CuAssertTrue(tc, retval == PM_RET_OK);
00349 
00350     retval = list_getItem(plist, 0, &pget);
00351     CuAssertTrue(tc, pget == pobj0);
00352     retval = list_getItem(plist, 1, &pget);
00353     CuAssertTrue(tc, pget == pobj1);
00354     retval = list_getItem(plist, 2, &pget);
00355     CuAssertTrue(tc, pget == pobj2);
00356 }
00357 
00358 
00374 void
00375 ut_list_copy_000(CuTest *tc)
00376 {
00377     pPmObj_t pobj = C_NULL;
00378     pPmObj_t pval;
00379     PmReturn_t retval;
00380 
00381     retval = pm_init(MEMSPACE_RAM, C_NULL);
00382     retval = list_new(&pobj);
00383 
00384     retval = list_copy(PM_ONE, &pval);
00385     CuAssertTrue(tc, retval == PM_RET_EX_TYPE);
00386     retval = list_copy(pobj, &pval);
00387     CuAssertTrue(tc, retval == PM_RET_OK);
00388     CuAssertTrue(tc, pobj != pval);
00389     CuAssertTrue(tc, OBJ_GET_TYPE(pval) == OBJ_TYPE_LST);
00390     CuAssertTrue(tc, ((pPmList_t)pval)->length == 0);
00391 
00392     retval = list_append(pobj, PM_ONE);
00393     retval = list_copy(pobj, &pval);
00394     CuAssertTrue(tc, retval == PM_RET_OK);
00395     CuAssertTrue(tc, pobj != pval);
00396     CuAssertTrue(tc, OBJ_GET_TYPE(pval) == OBJ_TYPE_LST);
00397     CuAssertTrue(tc, obj_compare(pval, pobj) == C_SAME);
00398 }
00399 
00400 
00414 void
00415 ut_list_replicate_000(CuTest *tc)
00416 {
00417     pPmObj_t pobj = C_NULL;
00418     pPmObj_t pval;
00419     PmReturn_t retval;
00420 
00421     retval = pm_init(MEMSPACE_RAM, C_NULL);
00422     retval = list_new(&pobj);
00423 
00424     retval = list_replicate(PM_ONE, 1, &pval);
00425     CuAssertTrue(tc, retval == PM_RET_EX_TYPE);
00426     retval = list_replicate(pobj, 1, &pval);
00427     CuAssertTrue(tc, retval == PM_RET_OK);
00428     CuAssertTrue(tc, pobj != pval);
00429     CuAssertTrue(tc, OBJ_GET_TYPE(pval) == OBJ_TYPE_LST);
00430     CuAssertTrue(tc, ((pPmList_t)pval)->length == 0);
00431 
00432     retval = list_append(pobj, PM_ONE);
00433     retval = list_replicate(pobj, 1, &pval);
00434     CuAssertTrue(tc, retval == PM_RET_OK);
00435     CuAssertTrue(tc, pobj != pval);
00436     CuAssertTrue(tc, OBJ_GET_TYPE(pval) == OBJ_TYPE_LST);
00437     CuAssertTrue(tc, ((pPmList_t)pval)->length == ((pPmList_t)pobj)->length);
00438 }
00439 
00440 
00445 void
00446 ut_list_replicate_001(CuTest *tc)
00447 {
00448     pPmObj_t plist;
00449     pPmObj_t preplicated;
00450     pPmObj_t pexpected;
00451     pPmObj_t pobj0;
00452     pPmObj_t pobj1;
00453     pPmObj_t pobj2;
00454     PmReturn_t retval;
00455 
00456     retval = pm_init(MEMSPACE_RAM, C_NULL);
00457 
00458     /* Build the original list */
00459     retval = list_new(&plist);
00460     retval = dict_new(&pobj0);
00461     retval = tuple_new(0, &pobj1);
00462     retval = int_new(42, &pobj2);
00463 
00464     retval = list_append(plist, pobj0);
00465     retval = list_append(plist, pobj1);
00466     retval = list_append(plist, pobj2);
00467 
00468     /* Build the expected list */
00469     retval = list_new(&pexpected);
00470     retval = list_append(pexpected, pobj0);
00471     retval = list_append(pexpected, pobj1);
00472     retval = list_append(pexpected, pobj2);
00473     retval = list_append(pexpected, pobj0);
00474     retval = list_append(pexpected, pobj1);
00475     retval = list_append(pexpected, pobj2);
00476 
00477     /* Create the replicated list */
00478     retval = list_replicate(plist, 2, &preplicated);
00479     CuAssertTrue(tc, retval == PM_RET_OK);
00480     CuAssertTrue(tc, obj_compare(preplicated, pexpected) == C_SAME);
00481 }
00482 
00483 
00504 void
00505 ut_list_insert_000(CuTest *tc)
00506 {
00507     pPmObj_t plist;
00508     pPmObj_t pobj0;
00509     pPmObj_t pobj1;
00510     pPmObj_t pget;
00511     PmReturn_t retval;
00512 
00513     retval = pm_init(MEMSPACE_RAM, C_NULL);
00514     retval = list_new(&plist);
00515     retval = tuple_new(0, &pobj0);
00516     retval = dict_new(&pobj1);
00517 
00518     /* Call on non-list, expect a TypeError */
00519     retval = list_insert(pobj0, 0, pobj0);
00520     CuAssertTrue(tc, retval == PM_RET_EX_TYPE);
00521 
00522     /* Call on empty list */
00523     retval = list_insert(plist, 0, pobj0);
00524     CuAssertTrue(tc, retval == PM_RET_OK);
00525     CuAssertTrue(tc, ((pPmList_t)plist)->length == 1);
00526     retval = list_getItem(plist, 0, &pget);
00527     CuAssertTrue(tc, pobj0 == pget);
00528 
00529     /* Call on list of length 1 with index 0 */
00530     retval = list_insert(plist, 0, pobj1);
00531     CuAssertTrue(tc, retval == PM_RET_OK);
00532     CuAssertTrue(tc, ((pPmList_t)plist)->length == 2);
00533     retval = list_getItem(plist, 0, &pget);
00534     CuAssertTrue(tc, pobj1 == pget);
00535 
00536     /* Call on list of length 1 with index 1 */
00537     retval = list_new(&plist);
00538     retval = list_insert(plist, 0, pobj0);
00539     retval = list_insert(plist, 1, pobj1);
00540     CuAssertTrue(tc, retval == PM_RET_OK);
00541     CuAssertTrue(tc, ((pPmList_t)plist)->length == 2);
00542     retval = list_getItem(plist, 1, &pget);
00543     CuAssertTrue(tc, pobj1 == pget);
00544 
00545     /* Call on list of length 1 with index >1 */
00546     retval = list_new(&plist);
00547     retval = list_insert(plist, 0, pobj0);
00548     retval = list_insert(plist, 10, pobj1);
00549     CuAssertTrue(tc, retval == PM_RET_OK);
00550     CuAssertTrue(tc, ((pPmList_t)plist)->length == 2);
00551     retval = list_getItem(plist, 1, &pget);
00552     CuAssertTrue(tc, pobj1 == pget);
00553 }
00554 
00555 
00564 void
00565 ut_list_index_000(CuTest *tc)
00566 {
00567     pPmObj_t plist;
00568     pPmObj_t pobj0;
00569     pPmObj_t pobj1;
00570     pPmObj_t pobj2;
00571     uint16_t index;
00572     PmReturn_t retval;
00573 
00574     retval = pm_init(MEMSPACE_RAM, C_NULL);
00575     retval = list_new(&plist);
00576     retval = tuple_new(0, &pobj0);
00577     retval = dict_new(&pobj1);
00578     retval = int_new(42, &pobj2);
00579 
00580     /* Call on non-list, expect a TypeError */
00581     retval = list_index(pobj0, 0, &index);
00582     CuAssertTrue(tc, retval == PM_RET_EX_TYPE);
00583     
00584     /* Call on empty list, expect a ValueError */
00585     retval = list_index(plist, pobj1, &index);
00586     CuAssertTrue(tc, retval == PM_RET_EX_VAL);
00587     
00588     retval = list_append(plist, pobj0);
00589     retval = list_append(plist, pobj1);
00590     retval = list_append(plist, pobj2);
00591     
00592     /* Call on non-empty list, expect proper indices */
00593     retval = list_index(plist, pobj0, &index);
00594     CuAssertTrue(tc, index == 0);
00595     retval = list_index(plist, pobj1, &index);
00596     CuAssertTrue(tc, index == 1);
00597     retval = list_index(plist, pobj2, &index);
00598     CuAssertTrue(tc, index == 2);
00599 }
00600 
00601 
00603 CuSuite *getSuite_testList(void)
00604 {
00605     CuSuite* suite = CuSuiteNew();
00606 
00607     SUITE_ADD_TEST(suite, ut_list_new_000);
00608     SUITE_ADD_TEST(suite, ut_list_append_000);
00609     SUITE_ADD_TEST(suite, ut_list_getItem_000);
00610     SUITE_ADD_TEST(suite, ut_list_getItem_001);
00611     SUITE_ADD_TEST(suite, ut_list_setItem_000);
00612     SUITE_ADD_TEST(suite, ut_list_setItem_001);
00613     SUITE_ADD_TEST(suite, ut_list_copy_000);
00614     SUITE_ADD_TEST(suite, ut_list_replicate_000);
00615     SUITE_ADD_TEST(suite, ut_list_replicate_001);
00616     SUITE_ADD_TEST(suite, ut_list_removeItem_000);
00617     SUITE_ADD_TEST(suite, ut_list_insert_000);
00618     SUITE_ADD_TEST(suite, ut_list_index_000);
00619 
00620     return suite;
00621 }

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