Mercurial > hg > ucx / file comparison

comparison: tests/test_list.c

tests/test_list.c

changeset 854
fe0d69d72bcd
parent 853
d4baf4dd55c3
child 855
35bcb3216c0d
equal deleted inserted replaced
853:d4baf4dd55c3 854:fe0d69d72bcd
620 } 620 }
621 621
622 622
623 CX_TEST(test_empty_list_size) { 623 CX_TEST(test_empty_list_size) {
624 CX_TEST_DO { 624 CX_TEST_DO {
625 CX_TEST_ASSERT(cxEmptyList->size == 0); 625 CX_TEST_ASSERT(cxEmptyList->base.size == 0);
626 CX_TEST_ASSERT(cxListSize(cxEmptyList) == 0); 626 CX_TEST_ASSERT(cxListSize(cxEmptyList) == 0);
627 } 627 }
628 } 628 }
629 629
630 CX_TEST(test_empty_list_iterator) { 630 CX_TEST(test_empty_list_iterator) {
704 cx_testing_allocator_init(&talloc); 704 cx_testing_allocator_init(&talloc);
705 CxAllocator *alloc = &talloc.base; 705 CxAllocator *alloc = &talloc.base;
706 CX_TEST_DO { 706 CX_TEST_DO {
707 CxList *list = cxLinkedListCreate(alloc, cx_cmp_int, sizeof(int)); 707 CxList *list = cxLinkedListCreate(alloc, cx_cmp_int, sizeof(int));
708 CX_TEST_ASSERT(list != NULL); 708 CX_TEST_ASSERT(list != NULL);
709 CX_TEST_ASSERT(list->item_size == sizeof(int)); 709 CX_TEST_ASSERT(list->base.item_size == sizeof(int));
710 CX_TEST_ASSERT(list->simple_destructor == NULL); 710 CX_TEST_ASSERT(list->base.simple_destructor == NULL);
711 CX_TEST_ASSERT(list->advanced_destructor == NULL); 711 CX_TEST_ASSERT(list->base.advanced_destructor == NULL);
712 CX_TEST_ASSERT(list->destructor_data == NULL); 712 CX_TEST_ASSERT(list->base.destructor_data == NULL);
713 CX_TEST_ASSERT(cxListSize(list) == 0); 713 CX_TEST_ASSERT(cxListSize(list) == 0);
714 CX_TEST_ASSERT(list->allocator == alloc); 714 CX_TEST_ASSERT(list->base.allocator == alloc);
715 CX_TEST_ASSERT(list->cmpfunc == cx_cmp_int); 715 CX_TEST_ASSERT(list->base.cmpfunc == cx_cmp_int);
716 CX_TEST_ASSERT(!cxListIsStoringPointers(list)); 716 CX_TEST_ASSERT(!cxListIsStoringPointers(list));
717 cxListDestroy(list); 717 cxListDestroy(list);
718 CX_TEST_ASSERT(cx_testing_allocator_verify(&talloc)); 718 CX_TEST_ASSERT(cx_testing_allocator_verify(&talloc));
719 } 719 }
720 cx_testing_allocator_destroy(&talloc); 720 cx_testing_allocator_destroy(&talloc);
722 722
723 CX_TEST(test_list_ll_create_simple) { 723 CX_TEST(test_list_ll_create_simple) {
724 CxList *list = cxLinkedListCreateSimple(sizeof(int)); 724 CxList *list = cxLinkedListCreateSimple(sizeof(int));
725 CX_TEST_DO { 725 CX_TEST_DO {
726 CX_TEST_ASSERT(list != NULL); 726 CX_TEST_ASSERT(list != NULL);
727 CX_TEST_ASSERT(list->item_size == sizeof(int)); 727 CX_TEST_ASSERT(list->base.item_size == sizeof(int));
728 CX_TEST_ASSERT(list->simple_destructor == NULL); 728 CX_TEST_ASSERT(list->base.simple_destructor == NULL);
729 CX_TEST_ASSERT(list->advanced_destructor == NULL); 729 CX_TEST_ASSERT(list->base.advanced_destructor == NULL);
730 CX_TEST_ASSERT(list->destructor_data == NULL); 730 CX_TEST_ASSERT(list->base.destructor_data == NULL);
731 CX_TEST_ASSERT(cxListSize(list) == 0); 731 CX_TEST_ASSERT(cxListSize(list) == 0);
732 CX_TEST_ASSERT(list->allocator == cxDefaultAllocator); 732 CX_TEST_ASSERT(list->base.allocator == cxDefaultAllocator);
733 CX_TEST_ASSERT(list->cmpfunc == NULL); 733 CX_TEST_ASSERT(list->base.cmpfunc == NULL);
734 CX_TEST_ASSERT(!cxListIsStoringPointers(list)); 734 CX_TEST_ASSERT(!cxListIsStoringPointers(list));
735 } 735 }
736 cxListDestroy(list); 736 cxListDestroy(list);
737 } 737 }
738 738
739 CX_TEST(test_list_ll_store_pointers) { 739 CX_TEST(test_list_ll_store_pointers) {
740 CxList *list = cxLinkedListCreateSimple(47); 740 CxList *list = cxLinkedListCreateSimple(47);
741 CX_TEST_DO { 741 CX_TEST_DO {
742 CX_TEST_ASSERT(!cxListIsStoringPointers(list)); 742 CX_TEST_ASSERT(!cxListIsStoringPointers(list));
743 cxListStorePointers(list); 743 cxListStorePointers(list);
744 CX_TEST_ASSERT(list->item_size == sizeof(void *)); 744 CX_TEST_ASSERT(list->base.item_size == sizeof(void *));
745 CX_TEST_ASSERT(list->cl != NULL); 745 CX_TEST_ASSERT(list->cl != NULL);
746 CX_TEST_ASSERT(list->climpl != NULL); 746 CX_TEST_ASSERT(list->climpl != NULL);
747 CX_TEST_ASSERT(cxListIsStoringPointers(list)); 747 CX_TEST_ASSERT(cxListIsStoringPointers(list));
748 cxListStoreObjects(list); 748 cxListStoreObjects(list);
749 CX_TEST_ASSERT(list->cl != NULL); 749 CX_TEST_ASSERT(list->cl != NULL);
755 755
756 CX_TEST(test_list_ll_create_simple_for_pointers) { 756 CX_TEST(test_list_ll_create_simple_for_pointers) {
757 CxList *list = cxLinkedListCreateSimple(CX_STORE_POINTERS); 757 CxList *list = cxLinkedListCreateSimple(CX_STORE_POINTERS);
758 CX_TEST_DO { 758 CX_TEST_DO {
759 CX_TEST_ASSERT(list != NULL); 759 CX_TEST_ASSERT(list != NULL);
760 CX_TEST_ASSERT(list->item_size == sizeof(void*)); 760 CX_TEST_ASSERT(list->base.item_size == sizeof(void*));
761 CX_TEST_ASSERT(list->simple_destructor == NULL); 761 CX_TEST_ASSERT(list->base.simple_destructor == NULL);
762 CX_TEST_ASSERT(list->advanced_destructor == NULL); 762 CX_TEST_ASSERT(list->base.advanced_destructor == NULL);
763 CX_TEST_ASSERT(list->destructor_data == NULL); 763 CX_TEST_ASSERT(list->base.destructor_data == NULL);
764 CX_TEST_ASSERT(cxListSize(list) == 0); 764 CX_TEST_ASSERT(cxListSize(list) == 0);
765 CX_TEST_ASSERT(list->allocator == cxDefaultAllocator); 765 CX_TEST_ASSERT(list->base.allocator == cxDefaultAllocator);
766 CX_TEST_ASSERT(list->cmpfunc == cx_cmp_ptr); 766 CX_TEST_ASSERT(list->base.cmpfunc == cx_cmp_ptr);
767 CX_TEST_ASSERT(cxListIsStoringPointers(list)); 767 CX_TEST_ASSERT(cxListIsStoringPointers(list));
768 } 768 }
769 cxListDestroy(list); 769 cxListDestroy(list);
770 } 770 }
771 771
774 cx_testing_allocator_init(&talloc); 774 cx_testing_allocator_init(&talloc);
775 CxAllocator *alloc = &talloc.base; 775 CxAllocator *alloc = &talloc.base;
776 CX_TEST_DO { 776 CX_TEST_DO {
777 CxList *list = cxArrayListCreate(alloc, cx_cmp_int, sizeof(int), 8); 777 CxList *list = cxArrayListCreate(alloc, cx_cmp_int, sizeof(int), 8);
778 CX_TEST_ASSERT(list != NULL); 778 CX_TEST_ASSERT(list != NULL);
779 CX_TEST_ASSERT(list->item_size == sizeof(int)); 779 CX_TEST_ASSERT(list->base.item_size == sizeof(int));
780 CX_TEST_ASSERT(list->simple_destructor == NULL); 780 CX_TEST_ASSERT(list->base.simple_destructor == NULL);
781 CX_TEST_ASSERT(list->advanced_destructor == NULL); 781 CX_TEST_ASSERT(list->base.advanced_destructor == NULL);
782 CX_TEST_ASSERT(list->destructor_data == NULL); 782 CX_TEST_ASSERT(list->base.destructor_data == NULL);
783 CX_TEST_ASSERT(cxListSize(list) == 0); 783 CX_TEST_ASSERT(cxListSize(list) == 0);
784 CX_TEST_ASSERT(list->allocator == alloc); 784 CX_TEST_ASSERT(list->base.allocator == alloc);
785 CX_TEST_ASSERT(list->cmpfunc == cx_cmp_int); 785 CX_TEST_ASSERT(list->base.cmpfunc == cx_cmp_int);
786 CX_TEST_ASSERT(!cxListIsStoringPointers(list)); 786 CX_TEST_ASSERT(!cxListIsStoringPointers(list));
787 cxListDestroy(list); 787 cxListDestroy(list);
788 CX_TEST_ASSERT(cx_testing_allocator_verify(&talloc)); 788 CX_TEST_ASSERT(cx_testing_allocator_verify(&talloc));
789 } 789 }
790 cx_testing_allocator_destroy(&talloc); 790 cx_testing_allocator_destroy(&talloc);
792 792
793 CX_TEST(test_list_arl_create_simple) { 793 CX_TEST(test_list_arl_create_simple) {
794 CxList *list = cxArrayListCreateSimple(sizeof(int), 8); 794 CxList *list = cxArrayListCreateSimple(sizeof(int), 8);
795 CX_TEST_DO { 795 CX_TEST_DO {
796 CX_TEST_ASSERT(list != NULL); 796 CX_TEST_ASSERT(list != NULL);
797 CX_TEST_ASSERT(list->item_size == sizeof(int)); 797 CX_TEST_ASSERT(list->base.item_size == sizeof(int));
798 CX_TEST_ASSERT(list->simple_destructor == NULL); 798 CX_TEST_ASSERT(list->base.simple_destructor == NULL);
799 CX_TEST_ASSERT(list->advanced_destructor == NULL); 799 CX_TEST_ASSERT(list->base.advanced_destructor == NULL);
800 CX_TEST_ASSERT(list->destructor_data == NULL); 800 CX_TEST_ASSERT(list->base.destructor_data == NULL);
801 CX_TEST_ASSERT(cxListSize(list) == 0); 801 CX_TEST_ASSERT(cxListSize(list) == 0);
802 CX_TEST_ASSERT(list->allocator == cxDefaultAllocator); 802 CX_TEST_ASSERT(list->base.allocator == cxDefaultAllocator);
803 CX_TEST_ASSERT(list->cmpfunc == NULL); 803 CX_TEST_ASSERT(list->base.cmpfunc == NULL);
804 CX_TEST_ASSERT(!cxListIsStoringPointers(list)); 804 CX_TEST_ASSERT(!cxListIsStoringPointers(list));
805 } 805 }
806 cxListDestroy(list); 806 cxListDestroy(list);
807 } 807 }
808 808
809 CX_TEST(test_list_arl_create_simple_for_pointers) { 809 CX_TEST(test_list_arl_create_simple_for_pointers) {
810 CxList *list = cxArrayListCreateSimple(CX_STORE_POINTERS, 8); 810 CxList *list = cxArrayListCreateSimple(CX_STORE_POINTERS, 8);
811 CX_TEST_DO { 811 CX_TEST_DO {
812 CX_TEST_ASSERT(list != NULL); 812 CX_TEST_ASSERT(list != NULL);
813 CX_TEST_ASSERT(list->item_size == sizeof(void*)); 813 CX_TEST_ASSERT(list->base.item_size == sizeof(void*));
814 CX_TEST_ASSERT(list->simple_destructor == NULL); 814 CX_TEST_ASSERT(list->base.simple_destructor == NULL);
815 CX_TEST_ASSERT(list->advanced_destructor == NULL); 815 CX_TEST_ASSERT(list->base.advanced_destructor == NULL);
816 CX_TEST_ASSERT(list->destructor_data == NULL); 816 CX_TEST_ASSERT(list->base.destructor_data == NULL);
817 CX_TEST_ASSERT(cxListSize(list) == 0); 817 CX_TEST_ASSERT(cxListSize(list) == 0);
818 CX_TEST_ASSERT(list->allocator == cxDefaultAllocator); 818 CX_TEST_ASSERT(list->base.allocator == cxDefaultAllocator);
819 CX_TEST_ASSERT(list->cmpfunc == cx_cmp_ptr); 819 CX_TEST_ASSERT(list->base.cmpfunc == cx_cmp_ptr);
820 CX_TEST_ASSERT(cxListIsStoringPointers(list)); 820 CX_TEST_ASSERT(cxListIsStoringPointers(list));
821 } 821 }
822 cxListDestroy(list); 822 cxListDestroy(list);
823 } 823 }
824 824
846 846
847 CX_TEST(test_list_pll_destroy_simple_destr) { 847 CX_TEST(test_list_pll_destroy_simple_destr) {
848 CX_TEST_DO { 848 CX_TEST_DO {
849 int item = 0; 849 int item = 0;
850 CxList *list = cxLinkedListCreate(cxDefaultAllocator, cx_cmp_int, CX_STORE_POINTERS); 850 CxList *list = cxLinkedListCreate(cxDefaultAllocator, cx_cmp_int, CX_STORE_POINTERS);
851 list->simple_destructor = test_fake_simple_int_destr; 851 list->base.simple_destructor = test_fake_simple_int_destr;
852 cxListAdd(list, &item); 852 cxListAdd(list, &item);
853 cxListDestroy(list); 853 cxListDestroy(list);
854 CX_TEST_ASSERT(item == 42); 854 CX_TEST_ASSERT(item == 42);
855 } 855 }
856 } 856 }
860 cx_testing_allocator_init(&talloc); 860 cx_testing_allocator_init(&talloc);
861 CxAllocator *alloc = &talloc.base; 861 CxAllocator *alloc = &talloc.base;
862 CX_TEST_DO { 862 CX_TEST_DO {
863 void *item = cxMalloc(alloc, sizeof(int)); 863 void *item = cxMalloc(alloc, sizeof(int));
864 CxList *list = cxLinkedListCreate(cxDefaultAllocator, cx_cmp_int, CX_STORE_POINTERS); 864 CxList *list = cxLinkedListCreate(cxDefaultAllocator, cx_cmp_int, CX_STORE_POINTERS);
865 list->destructor_data = alloc; 865 list->base.destructor_data = alloc;
866 list->advanced_destructor = (cx_destructor_func2) cxFree; 866 list->base.advanced_destructor = (cx_destructor_func2) cxFree;
867 cxListAdd(list, item); 867 cxListAdd(list, item);
868 CX_TEST_ASSERT(!cx_testing_allocator_verify(&talloc)); 868 CX_TEST_ASSERT(!cx_testing_allocator_verify(&talloc));
869 cxListDestroy(list); 869 cxListDestroy(list);
870 CX_TEST_ASSERT(cx_testing_allocator_verify(&talloc)); 870 CX_TEST_ASSERT(cx_testing_allocator_verify(&talloc));
871 } 871 }
892 892
893 CX_TEST(test_list_parl_destroy_simple_destr) { 893 CX_TEST(test_list_parl_destroy_simple_destr) {
894 CX_TEST_DO { 894 CX_TEST_DO {
895 int item = 0; 895 int item = 0;
896 CxList *list = cxArrayListCreate(cxDefaultAllocator, cx_cmp_int, CX_STORE_POINTERS, 4); 896 CxList *list = cxArrayListCreate(cxDefaultAllocator, cx_cmp_int, CX_STORE_POINTERS, 4);
897 list->simple_destructor = test_fake_simple_int_destr; 897 list->base.simple_destructor = test_fake_simple_int_destr;
898 cxListAdd(list, &item); 898 cxListAdd(list, &item);
899 cxListDestroy(list); 899 cxListDestroy(list);
900 CX_TEST_ASSERT(item == 42); 900 CX_TEST_ASSERT(item == 42);
901 } 901 }
902 } 902 }
906 cx_testing_allocator_init(&talloc); 906 cx_testing_allocator_init(&talloc);
907 CxAllocator *alloc = &talloc.base; 907 CxAllocator *alloc = &talloc.base;
908 CX_TEST_DO { 908 CX_TEST_DO {
909 void *item = cxMalloc(alloc, sizeof(int)); 909 void *item = cxMalloc(alloc, sizeof(int));
910 CxList *list = cxArrayListCreate(cxDefaultAllocator, cx_cmp_int, CX_STORE_POINTERS, 4); 910 CxList *list = cxArrayListCreate(cxDefaultAllocator, cx_cmp_int, CX_STORE_POINTERS, 4);
911 list->destructor_data = alloc; 911 list->base.destructor_data = alloc;
912 list->advanced_destructor = (cx_destructor_func2) cxFree; 912 list->base.advanced_destructor = (cx_destructor_func2) cxFree;
913 cxListAdd(list, item); 913 cxListAdd(list, item);
914 CX_TEST_ASSERT(!cx_testing_allocator_verify(&talloc)); 914 CX_TEST_ASSERT(!cx_testing_allocator_verify(&talloc));
915 cxListDestroy(list); 915 cxListDestroy(list);
916 CX_TEST_ASSERT(cx_testing_allocator_verify(&talloc)); 916 CX_TEST_ASSERT(cx_testing_allocator_verify(&talloc));
917 } 917 }
1205 roll_out_test_combos(iterator, { 1205 roll_out_test_combos(iterator, {
1206 const size_t len = 50; 1206 const size_t len = 50;
1207 int *testdata = int_test_data_added_to_list(list, isptrlist, len); 1207 int *testdata = int_test_data_added_to_list(list, isptrlist, len);
1208 1208
1209 CxIterator iter = cxListIterator(list); 1209 CxIterator iter = cxListIterator(list);
1210 CX_TEST_ASSERT(iter.elem_size == list->item_size); 1210 CX_TEST_ASSERT(iter.elem_size == list->base.item_size);
1211 CX_TEST_ASSERT(iter.elem_count == list->size); 1211 CX_TEST_ASSERT(iter.elem_count == list->base.size);
1212 size_t i = 0; 1212 size_t i = 0;
1213 cx_foreach(int*, x, iter) { 1213 cx_foreach(int*, x, iter) {
1214 CX_TEST_ASSERT(i == iter.index); 1214 CX_TEST_ASSERT(i == iter.index);
1215 CX_TEST_ASSERT(*x == testdata[iter.index]); 1215 CX_TEST_ASSERT(*x == testdata[iter.index]);
1216 i++; 1216 i++;
1223 i--; 1223 i--;
1224 } 1224 }
1225 CX_TEST_ASSERT(i == 0); 1225 CX_TEST_ASSERT(i == 0);
1226 i = len / 2; 1226 i = len / 2;
1227 CxIterator mut_iter = cxListMutIteratorAt(list, i); 1227 CxIterator mut_iter = cxListMutIteratorAt(list, i);
1228 CX_TEST_ASSERT(mut_iter.elem_size == list->item_size); 1228 CX_TEST_ASSERT(mut_iter.elem_size == list->base.item_size);
1229 CX_TEST_ASSERT(mut_iter.elem_count == list->size); 1229 CX_TEST_ASSERT(mut_iter.elem_count == list->base.size);
1230 size_t j = 0; 1230 size_t j = 0;
1231 cx_foreach(int*, x, mut_iter) { 1231 cx_foreach(int*, x, mut_iter) {
1232 CX_TEST_ASSERT(mut_iter.index == len / 2 + j / 2); 1232 CX_TEST_ASSERT(mut_iter.index == len / 2 + j / 2);
1233 CX_TEST_ASSERT(*x == testdata[i]); 1233 CX_TEST_ASSERT(*x == testdata[i]);
1234 if (i % 2 == 1) cxIteratorFlagRemoval(mut_iter); 1234 if (i % 2 == 1) cxIteratorFlagRemoval(mut_iter);
1393 } 1393 }
1394 1394
1395 roll_out_test_combos(simple_destr, { 1395 roll_out_test_combos(simple_destr, {
1396 const size_t len = 60; 1396 const size_t len = 60;
1397 int *testdata = int_test_data_added_to_list(list, isptrlist, len); 1397 int *testdata = int_test_data_added_to_list(list, isptrlist, len);
1398 list->simple_destructor = simple_destr_test_fun; 1398 list->base.simple_destructor = simple_destr_test_fun;
1399 CX_TEST_CALL_SUBROUTINE(test_list_verify_destructor, list, testdata, len); 1399 CX_TEST_CALL_SUBROUTINE(test_list_verify_destructor, list, testdata, len);
1400 free(testdata); 1400 free(testdata);
1401 }) 1401 })
1402 1402
1403 roll_out_test_combos(advanced_destr, { 1403 roll_out_test_combos(advanced_destr, {
1404 const size_t len = 75; 1404 const size_t len = 75;
1405 int *testdata = int_test_data_added_to_list(list, isptrlist, len); 1405 int *testdata = int_test_data_added_to_list(list, isptrlist, len);
1406 list->advanced_destructor = advanced_destr_test_fun; 1406 list->base.advanced_destructor = advanced_destr_test_fun;
1407 CX_TEST_CALL_SUBROUTINE(test_list_verify_destructor, list, testdata, len); 1407 CX_TEST_CALL_SUBROUTINE(test_list_verify_destructor, list, testdata, len);
1408 free(testdata); 1408 free(testdata);
1409 }) 1409 })
1410 1410
1411 CxTestSuite *cx_test_suite_array_list(void) { 1411 CxTestSuite *cx_test_suite_array_list(void) {

Mercurial Repository: ucx

mercurial