Mercurial > hg > ucx / file comparison

comparison: tests/test_hash_map.c

tests/test_hash_map.c

changeset 1605
55b13f583356
parent 1604
68b75c091028
equal deleted inserted replaced
1604:68b75c091028 1605:55b13f583356
114 CxTestingAllocator talloc; 114 CxTestingAllocator talloc;
115 cx_testing_allocator_init(&talloc); 115 cx_testing_allocator_init(&talloc);
116 CxAllocator *allocator = &talloc.base; 116 CxAllocator *allocator = &talloc.base;
117 CX_TEST_DO { 117 CX_TEST_DO {
118 CxMap *map = cxHashMapCreate(allocator, CX_STORE_POINTERS, 4); 118 CxMap *map = cxHashMapCreate(allocator, CX_STORE_POINTERS, 4);
119 cxDefineAdvancedDestructor(map, cxFree, allocator); 119 cxSetAdvancedDestructor(map, cxFree, allocator);
120 120
121 char *val1 = cxMalloc(allocator, 8); 121 char *val1 = cxMalloc(allocator, 8);
122 strcpy(val1, "val 1"); 122 strcpy(val1, "val 1");
123 char *val2 = cxMalloc(allocator, 8); 123 char *val2 = cxMalloc(allocator, 8);
124 strcpy(val2, "val 2"); 124 strcpy(val2, "val 2");
288 } 288 }
289 cx_testing_allocator_destroy(&talloc); 289 cx_testing_allocator_destroy(&talloc);
290 } 290 }
291 291
292 CX_TEST(test_hash_map_integer_keys) { 292 CX_TEST(test_hash_map_integer_keys) {
293 CxMap *map = cxHashMapCreateSimple(sizeof(cxstring)); 293 CxMap *map = cxHashMapCreate(NULL, sizeof(cxstring), 0);
294 CX_TEST_DO { 294 CX_TEST_DO {
295 cxstring s1 = cx_str("hello"); 295 cxstring s1 = cx_str("hello");
296 cxstring s2 = cx_str("world"); 296 cxstring s2 = cx_str("world");
297 297
298 cxMapPut(map, UINT32_C(70875), &s1); 298 cxMapPut(map, UINT32_C(70875), &s1);
535 *((int*)dst) = *((int*)src) + *((int*)data); 535 *((int*)dst) = *((int*)src) + *((int*)data);
536 return dst; 536 return dst;
537 } 537 }
538 538
539 CX_TEST(test_hash_map_clone) { 539 CX_TEST(test_hash_map_clone) {
540 CxMap *dst = cxHashMapCreateSimple(sizeof(int)); 540 CxMap *dst = cxHashMapCreate(NULL, sizeof(int), 0);
541 CxMap *src = cxHashMapCreateSimple(sizeof(int)); 541 CxMap *src = cxHashMapCreate(NULL, sizeof(int), 0);
542 const char *exist_keys[] = {"k1", "k2", "k3"}; 542 const char *exist_keys[] = {"k1", "k2", "k3"};
543 int exists[] = {1, 3, 4}; 543 int exists[] = {1, 3, 4};
544 const char *source_keys[] = {"k4", "k2", "k5"}; 544 const char *source_keys[] = {"k4", "k2", "k5"};
545 int source[] = {7, 9, 15}; 545 int source[] = {7, 9, 15};
546 for (unsigned int i = 0 ; i < 3 ; i++) { 546 for (unsigned int i = 0 ; i < 3 ; i++) {
564 cxMapFree(dst); 564 cxMapFree(dst);
565 cxMapFree(src); 565 cxMapFree(src);
566 } 566 }
567 567
568 CX_TEST(test_hash_map_clone_alloc_fail) { 568 CX_TEST(test_hash_map_clone_alloc_fail) {
569 CxMap *dst = cxHashMapCreateSimple(sizeof(int)); 569 CxMap *dst = cxHashMapCreate(NULL, sizeof(int), 0);
570 CxMap *src = cxHashMapCreateSimple(sizeof(int)); 570 CxMap *src = cxHashMapCreate(NULL, sizeof(int), 0);
571 const char *exist_keys[] = {"k1", "k2", "k3"}; 571 const char *exist_keys[] = {"k1", "k2", "k3"};
572 int exists[] = {1, 3, 4}; 572 int exists[] = {1, 3, 4};
573 const char *source_keys[] = {"k4", "k2", "k5"}; 573 const char *source_keys[] = {"k4", "k2", "k5"};
574 int source[] = {7, 9, 15}; 574 int source[] = {7, 9, 15};
575 for (unsigned int i = 0 ; i < 3 ; i++) { 575 for (unsigned int i = 0 ; i < 3 ; i++) {
600 600
601 CX_TEST(test_hash_map_clone_ptr) { 601 CX_TEST(test_hash_map_clone_ptr) {
602 CxTestingAllocator talloc; 602 CxTestingAllocator talloc;
603 cx_testing_allocator_init(&talloc); 603 cx_testing_allocator_init(&talloc);
604 CxAllocator *allocator = &talloc.base; 604 CxAllocator *allocator = &talloc.base;
605 CxMap *dst = cxHashMapCreateSimple(CX_STORE_POINTERS); 605 CxMap *dst = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
606 cxDefineAdvancedDestructor(dst, cxFree, allocator); 606 cxSetAdvancedDestructor(dst, cxFree, allocator);
607 CxMap *src = cxHashMapCreateSimple(CX_STORE_POINTERS); 607 CxMap *src = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
608 const char *exist_keys[] = {"k1", "k2", "k3"}; 608 const char *exist_keys[] = {"k1", "k2", "k3"};
609 int exists[] = {1, 3, 4}; 609 int exists[] = {1, 3, 4};
610 const char *source_keys[] = {"k4", "k2", "k5"}; 610 const char *source_keys[] = {"k4", "k2", "k5"};
611 int source[] = {7, 9, 15}; 611 int source[] = {7, 9, 15};
612 for (unsigned int i = 0 ; i < 3 ; i++) { 612 for (unsigned int i = 0 ; i < 3 ; i++) {
636 cxMapFree(src); 636 cxMapFree(src);
637 cx_testing_allocator_destroy(&talloc); 637 cx_testing_allocator_destroy(&talloc);
638 } 638 }
639 639
640 CX_TEST(test_hash_map_difference) { 640 CX_TEST(test_hash_map_difference) {
641 CxMap *dst = cxHashMapCreateSimple(sizeof(int)); 641 CxMap *dst = cxHashMapCreate(NULL, sizeof(int), 0);
642 642
643 CxMap *s1 = cxHashMapCreateSimple(CX_STORE_POINTERS); 643 CxMap *s1 = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
644 CxMap *s2 = cxHashMapCreateSimple(CX_STORE_POINTERS); 644 CxMap *s2 = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
645 const char *s1_keys[] = {"k1", "k2", "k3"}; 645 const char *s1_keys[] = {"k1", "k2", "k3"};
646 int s1_values[] = {1, 3, 4}; 646 int s1_values[] = {1, 3, 4};
647 const char *s2_keys[] = {"k4", "k2", "k5"}; 647 const char *s2_keys[] = {"k4", "k2", "k5"};
648 int s2_values[] = {7, 9, 15}; 648 int s2_values[] = {7, 9, 15};
649 for (unsigned int i = 0 ; i < 3 ; i++) { 649 for (unsigned int i = 0 ; i < 3 ; i++) {
662 cxMapFree(s1); 662 cxMapFree(s1);
663 cxMapFree(s2); 663 cxMapFree(s2);
664 } 664 }
665 665
666 CX_TEST(test_hash_map_difference_alloc_fail) { 666 CX_TEST(test_hash_map_difference_alloc_fail) {
667 CxMap *dst = cxHashMapCreateSimple(sizeof(int)); 667 CxMap *dst = cxHashMapCreate(NULL, sizeof(int), 0);
668 668
669 CxMap *s1 = cxHashMapCreateSimple(CX_STORE_POINTERS); 669 CxMap *s1 = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
670 CxMap *s2 = cxHashMapCreateSimple(CX_STORE_POINTERS); 670 CxMap *s2 = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
671 const char *s1_keys[] = {"k1", "k2", "k3"}; 671 const char *s1_keys[] = {"k1", "k2", "k3"};
672 int s1_values[] = {1, 3, 4}; 672 int s1_values[] = {1, 3, 4};
673 const char *s2_keys[] = {"k4", "k2", "k5"}; 673 const char *s2_keys[] = {"k4", "k2", "k5"};
674 int s2_values[] = {7, 9, 15}; 674 int s2_values[] = {7, 9, 15};
675 for (unsigned int i = 0 ; i < 3 ; i++) { 675 for (unsigned int i = 0 ; i < 3 ; i++) {
692 cxMapFree(s1); 692 cxMapFree(s1);
693 cxMapFree(s2); 693 cxMapFree(s2);
694 } 694 }
695 695
696 CX_TEST(test_hash_map_list_difference) { 696 CX_TEST(test_hash_map_list_difference) {
697 CxMap *dst = cxHashMapCreateSimple(sizeof(int)); 697 CxMap *dst = cxHashMapCreate(NULL, sizeof(int), 0);
698 CxMap *src = cxHashMapCreateSimple(sizeof(int)); 698 CxMap *src = cxHashMapCreate(NULL, sizeof(int), 0);
699 CxList *keys = cxArrayListCreate(NULL, cx_hash_key_cmp, sizeof(CxHashKey), 4); 699 CxList *keys = cxArrayListCreate(NULL, sizeof(CxHashKey), 4);
700 cxSetCompareFunc(keys, cx_hash_key_cmp);
700 701
701 const char *src_keys[] = {"k1", "k2", "k3"}; 702 const char *src_keys[] = {"k1", "k2", "k3"};
702 int src_values[] = {1, 3, 4}; 703 int src_values[] = {1, 3, 4};
703 for (unsigned int i = 0 ; i < 3 ; i++) { 704 for (unsigned int i = 0 ; i < 3 ; i++) {
704 cxMapPut(src, src_keys[i], &src_values[i]); 705 cxMapPut(src, src_keys[i], &src_values[i]);
720 cxMapFree(src); 721 cxMapFree(src);
721 cxListFree(keys); 722 cxListFree(keys);
722 } 723 }
723 724
724 CX_TEST(test_hash_map_list_difference_alloc_fail) { 725 CX_TEST(test_hash_map_list_difference_alloc_fail) {
725 CxMap *dst = cxHashMapCreateSimple(sizeof(int)); 726 CxMap *dst = cxHashMapCreate(NULL, sizeof(int), 0);
726 CxMap *src = cxHashMapCreateSimple(sizeof(int)); 727 CxMap *src = cxHashMapCreate(NULL, sizeof(int), 0);
727 CxList *keys = cxArrayListCreate(NULL, cx_hash_key_cmp, sizeof(CxHashKey), 4); 728 CxList *keys = cxArrayListCreate(NULL, sizeof(CxHashKey), 4);
729 cxSetCompareFunc(keys, cx_hash_key_cmp);
728 730
729 const char *src_keys[] = {"k1", "k2", "k3"}; 731 const char *src_keys[] = {"k1", "k2", "k3"};
730 int src_values[] = {1, 3, 4}; 732 int src_values[] = {1, 3, 4};
731 for (unsigned int i = 0 ; i < 3 ; i++) { 733 for (unsigned int i = 0 ; i < 3 ; i++) {
732 cxMapPut(src, src_keys[i], &src_values[i]); 734 cxMapPut(src, src_keys[i], &src_values[i]);
752 cxMapFree(src); 754 cxMapFree(src);
753 cxListFree(keys); 755 cxListFree(keys);
754 } 756 }
755 757
756 CX_TEST(test_hash_map_difference_non_empty_target) { 758 CX_TEST(test_hash_map_difference_non_empty_target) {
757 CxMap *dst = cxHashMapCreateSimple(CX_STORE_POINTERS); 759 CxMap *dst = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
758 cxDefineAdvancedDestructor(dst, cxFree, (void*) cxDefaultAllocator); 760 cxSetAdvancedDestructor(dst, cxFree, (void*) cxDefaultAllocator);
759 761
760 CxMap *s1 = cxHashMapCreateSimple(sizeof(int)); 762 CxMap *s1 = cxHashMapCreate(NULL, sizeof(int), 0);
761 CxMap *s2 = cxHashMapCreateSimple(sizeof(int)); 763 CxMap *s2 = cxHashMapCreate(NULL, sizeof(int), 0);
762 const char *s1_keys[] = {"k1", "k2", "k3"}; 764 const char *s1_keys[] = {"k1", "k2", "k3"};
763 int s1_values[] = {1, 3, 4}; 765 int s1_values[] = {1, 3, 4};
764 const char *s2_keys[] = {"k4", "k2", "k5"}; 766 const char *s2_keys[] = {"k4", "k2", "k5"};
765 int s2_values[] = {7, 9, 15}; 767 int s2_values[] = {7, 9, 15};
766 for (unsigned int i = 0 ; i < 3 ; i++) { 768 for (unsigned int i = 0 ; i < 3 ; i++) {
786 cxMapFree(s1); 788 cxMapFree(s1);
787 cxMapFree(s2); 789 cxMapFree(s2);
788 } 790 }
789 791
790 CX_TEST(test_hash_map_list_difference_non_empty_target) { 792 CX_TEST(test_hash_map_list_difference_non_empty_target) {
791 CxMap *dst = cxHashMapCreateSimple(CX_STORE_POINTERS); 793 CxMap *dst = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
792 cxDefineAdvancedDestructor(dst, cxFree, (void*) cxDefaultAllocator); 794 cxSetAdvancedDestructor(dst, cxFree, (void*) cxDefaultAllocator);
793 CxMap *src = cxHashMapCreateSimple(sizeof(int)); 795 CxMap *src = cxHashMapCreate(NULL, sizeof(int), 0);
794 CxList *keys = cxArrayListCreate(NULL, cx_hash_key_cmp, sizeof(CxHashKey), 4); 796 CxList *keys = cxArrayListCreate(NULL, sizeof(CxHashKey), 4);
797 cxSetCompareFunc(keys, cx_hash_key_cmp);
795 798
796 const char *src_keys[] = {"k1", "k2", "k3"}; 799 const char *src_keys[] = {"k1", "k2", "k3"};
797 int src_values[] = {1, 3, 4}; 800 int src_values[] = {1, 3, 4};
798 for (unsigned int i = 0 ; i < 3 ; i++) { 801 for (unsigned int i = 0 ; i < 3 ; i++) {
799 cxMapPut(src, src_keys[i], &src_values[i]); 802 cxMapPut(src, src_keys[i], &src_values[i]);
825 828
826 CX_TEST(test_hash_map_difference_ptr) { 829 CX_TEST(test_hash_map_difference_ptr) {
827 CxTestingAllocator talloc; 830 CxTestingAllocator talloc;
828 cx_testing_allocator_init(&talloc); 831 cx_testing_allocator_init(&talloc);
829 CxAllocator *allocator = &talloc.base; 832 CxAllocator *allocator = &talloc.base;
830 CxMap *dst = cxHashMapCreateSimple(CX_STORE_POINTERS); 833 CxMap *dst = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
831 cxDefineAdvancedDestructor(dst, cxFree, allocator); 834 cxSetAdvancedDestructor(dst, cxFree, allocator);
832 835
833 CxMap *s1 = cxHashMapCreateSimple(CX_STORE_POINTERS); 836 CxMap *s1 = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
834 CxMap *s2 = cxHashMapCreateSimple(CX_STORE_POINTERS); 837 CxMap *s2 = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
835 const char *s1_keys[] = {"k1", "k2", "k3"}; 838 const char *s1_keys[] = {"k1", "k2", "k3"};
836 int s1_values[] = {1, 3, 4}; 839 int s1_values[] = {1, 3, 4};
837 const char *s2_keys[] = {"k4", "k2", "k5"}; 840 const char *s2_keys[] = {"k4", "k2", "k5"};
838 int s2_values[] = {7, 9, 15}; 841 int s2_values[] = {7, 9, 15};
839 for (unsigned int i = 0 ; i < 3 ; i++) { 842 for (unsigned int i = 0 ; i < 3 ; i++) {
856 cxMapFree(s2); 859 cxMapFree(s2);
857 cx_testing_allocator_destroy(&talloc); 860 cx_testing_allocator_destroy(&talloc);
858 } 861 }
859 862
860 CX_TEST(test_hash_map_intersection) { 863 CX_TEST(test_hash_map_intersection) {
861 CxMap *dst = cxHashMapCreateSimple(sizeof(int)); 864 CxMap *dst = cxHashMapCreate(NULL, sizeof(int), 0);
862 865
863 CxMap *s1 = cxHashMapCreateSimple(CX_STORE_POINTERS); 866 CxMap *s1 = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
864 CxMap *s2 = cxHashMapCreateSimple(CX_STORE_POINTERS); 867 CxMap *s2 = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
865 const char *s1_keys[] = {"k1", "k2", "k3", "k4"}; 868 const char *s1_keys[] = {"k1", "k2", "k3", "k4"};
866 int s1_values[] = {1, 3, 4, 6}; 869 int s1_values[] = {1, 3, 4, 6};
867 const char *s2_keys[] = {"k4", "k5", "k2", "k6"}; 870 const char *s2_keys[] = {"k4", "k5", "k2", "k6"};
868 int s2_values[] = {5, 9, 15, 23}; 871 int s2_values[] = {5, 9, 15, 23};
869 for (unsigned int i = 0 ; i < 4 ; i++) { 872 for (unsigned int i = 0 ; i < 4 ; i++) {
881 cxMapFree(s1); 884 cxMapFree(s1);
882 cxMapFree(s2); 885 cxMapFree(s2);
883 } 886 }
884 887
885 CX_TEST(test_hash_map_intersection_alloc_fail) { 888 CX_TEST(test_hash_map_intersection_alloc_fail) {
886 CxMap *dst = cxHashMapCreateSimple(sizeof(int)); 889 CxMap *dst = cxHashMapCreate(NULL, sizeof(int), 0);
887 890
888 CxMap *s1 = cxHashMapCreateSimple(CX_STORE_POINTERS); 891 CxMap *s1 = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
889 CxMap *s2 = cxHashMapCreateSimple(CX_STORE_POINTERS); 892 CxMap *s2 = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
890 const char *s1_keys[] = {"k1", "k2", "k3", "k4"}; 893 const char *s1_keys[] = {"k1", "k2", "k3", "k4"};
891 int s1_values[] = {1, 3, 4, 6}; 894 int s1_values[] = {1, 3, 4, 6};
892 const char *s2_keys[] = {"k4", "k5", "k2", "k6"}; 895 const char *s2_keys[] = {"k4", "k5", "k2", "k6"};
893 int s2_values[] = {5, 9, 15, 23}; 896 int s2_values[] = {5, 9, 15, 23};
894 for (unsigned int i = 0 ; i < 4 ; i++) { 897 for (unsigned int i = 0 ; i < 4 ; i++) {
910 cxMapFree(s1); 913 cxMapFree(s1);
911 cxMapFree(s2); 914 cxMapFree(s2);
912 } 915 }
913 916
914 CX_TEST(test_hash_map_list_intersection) { 917 CX_TEST(test_hash_map_list_intersection) {
915 CxMap *dst = cxHashMapCreateSimple(sizeof(int)); 918 CxMap *dst = cxHashMapCreate(NULL, sizeof(int), 0);
916 CxMap *src = cxHashMapCreateSimple(sizeof(int)); 919 CxMap *src = cxHashMapCreate(NULL, sizeof(int), 0);
917 CxList *keys = cxArrayListCreate(NULL, cx_hash_key_cmp, sizeof(CxHashKey), 4); 920 CxList *keys = cxArrayListCreate(NULL, sizeof(CxHashKey), 4);
921 cxSetCompareFunc(keys, cx_hash_key_cmp);
918 922
919 const char *src_keys[] = {"k1", "k2", "k3", "k4"}; 923 const char *src_keys[] = {"k1", "k2", "k3", "k4"};
920 int src_values[] = {1, 3, 4, 6}; 924 int src_values[] = {1, 3, 4, 6};
921 for (unsigned int i = 0 ; i < 4 ; i++) { 925 for (unsigned int i = 0 ; i < 4 ; i++) {
922 cxMapPut(src, src_keys[i], &src_values[i]); 926 cxMapPut(src, src_keys[i], &src_values[i]);
937 cxMapFree(src); 941 cxMapFree(src);
938 cxListFree(keys); 942 cxListFree(keys);
939 } 943 }
940 944
941 CX_TEST(test_hash_map_list_intersection_alloc_fail) { 945 CX_TEST(test_hash_map_list_intersection_alloc_fail) {
942 CxMap *dst = cxHashMapCreateSimple(sizeof(int)); 946 CxMap *dst = cxHashMapCreate(NULL, sizeof(int), 0);
943 CxMap *src = cxHashMapCreateSimple(sizeof(int)); 947 CxMap *src = cxHashMapCreate(NULL, sizeof(int), 0);
944 CxList *keys = cxArrayListCreate(NULL, cx_hash_key_cmp, sizeof(CxHashKey), 4); 948 CxList *keys = cxArrayListCreate(NULL, sizeof(CxHashKey), 4);
949 cxSetCompareFunc(keys, cx_hash_key_cmp);
945 950
946 const char *src_keys[] = {"k1", "k2", "k3", "k4"}; 951 const char *src_keys[] = {"k1", "k2", "k3", "k4"};
947 int src_values[] = {1, 3, 4, 6}; 952 int src_values[] = {1, 3, 4, 6};
948 for (unsigned int i = 0 ; i < 4 ; i++) { 953 for (unsigned int i = 0 ; i < 4 ; i++) {
949 cxMapPut(src, src_keys[i], &src_values[i]); 954 cxMapPut(src, src_keys[i], &src_values[i]);
968 cxMapFree(src); 973 cxMapFree(src);
969 cxListFree(keys); 974 cxListFree(keys);
970 } 975 }
971 976
972 CX_TEST(test_hash_map_intersection_non_empty_target) { 977 CX_TEST(test_hash_map_intersection_non_empty_target) {
973 CxMap *dst = cxHashMapCreateSimple(CX_STORE_POINTERS); 978 CxMap *dst = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
974 cxDefineAdvancedDestructor(dst, cxFree, (void*) cxDefaultAllocator); 979 cxSetAdvancedDestructor(dst, cxFree, (void*) cxDefaultAllocator);
975 980
976 CxMap *s1 = cxHashMapCreateSimple(sizeof(int)); 981 CxMap *s1 = cxHashMapCreate(NULL, sizeof(int), 0);
977 CxMap *s2 = cxHashMapCreateSimple(sizeof(int)); 982 CxMap *s2 = cxHashMapCreate(NULL, sizeof(int), 0);
978 const char *s1_keys[] = {"k1", "k2", "k3", "k4"}; 983 const char *s1_keys[] = {"k1", "k2", "k3", "k4"};
979 int s1_values[] = {1, 3, 4, 6}; 984 int s1_values[] = {1, 3, 4, 6};
980 const char *s2_keys[] = {"k4", "k5", "k2", "k6"}; 985 const char *s2_keys[] = {"k4", "k5", "k2", "k6"};
981 int s2_values[] = {5, 9, 15, 23}; 986 int s2_values[] = {5, 9, 15, 23};
982 for (unsigned int i = 0 ; i < 4 ; i++) { 987 for (unsigned int i = 0 ; i < 4 ; i++) {
1001 cxMapFree(s1); 1006 cxMapFree(s1);
1002 cxMapFree(s2); 1007 cxMapFree(s2);
1003 } 1008 }
1004 1009
1005 CX_TEST(test_hash_map_list_intersection_non_empty_target) { 1010 CX_TEST(test_hash_map_list_intersection_non_empty_target) {
1006 CxMap *dst = cxHashMapCreateSimple(CX_STORE_POINTERS); 1011 CxMap *dst = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
1007 cxDefineAdvancedDestructor(dst, cxFree, (void*) cxDefaultAllocator); 1012 cxSetAdvancedDestructor(dst, cxFree, (void*) cxDefaultAllocator);
1008 CxMap *src = cxHashMapCreateSimple(sizeof(int)); 1013 CxMap *src = cxHashMapCreate(NULL, sizeof(int), 0);
1009 CxList *keys = cxArrayListCreate(NULL, cx_hash_key_cmp, sizeof(CxHashKey), 4); 1014 CxList *keys = cxArrayListCreate(NULL, sizeof(CxHashKey), 4);
1015 cxSetCompareFunc(keys, cx_hash_key_cmp);
1010 1016
1011 const char *src_keys[] = {"k1", "k2", "k3", "k4"}; 1017 const char *src_keys[] = {"k1", "k2", "k3", "k4"};
1012 int src_values[] = {1, 3, 4, 6}; 1018 int src_values[] = {1, 3, 4, 6};
1013 for (unsigned int i = 0 ; i < 4 ; i++) { 1019 for (unsigned int i = 0 ; i < 4 ; i++) {
1014 cxMapPut(src, src_keys[i], &src_values[i]); 1020 cxMapPut(src, src_keys[i], &src_values[i]);
1040 1046
1041 CX_TEST(test_hash_map_intersection_ptr) { 1047 CX_TEST(test_hash_map_intersection_ptr) {
1042 CxTestingAllocator talloc; 1048 CxTestingAllocator talloc;
1043 cx_testing_allocator_init(&talloc); 1049 cx_testing_allocator_init(&talloc);
1044 CxAllocator *allocator = &talloc.base; 1050 CxAllocator *allocator = &talloc.base;
1045 CxMap *dst = cxHashMapCreateSimple(CX_STORE_POINTERS); 1051 CxMap *dst = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
1046 cxDefineAdvancedDestructor(dst, cxFree, allocator); 1052 cxSetAdvancedDestructor(dst, cxFree, allocator);
1047 1053
1048 CxMap *s1 = cxHashMapCreateSimple(CX_STORE_POINTERS); 1054 CxMap *s1 = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
1049 CxMap *s2 = cxHashMapCreateSimple(CX_STORE_POINTERS); 1055 CxMap *s2 = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
1050 const char *s1_keys[] = {"k1", "k2", "k3", "k4"}; 1056 const char *s1_keys[] = {"k1", "k2", "k3", "k4"};
1051 int s1_values[] = {1, 3, 4, 6}; 1057 int s1_values[] = {1, 3, 4, 6};
1052 const char *s2_keys[] = {"k4", "k5", "k2", "k6"}; 1058 const char *s2_keys[] = {"k4", "k5", "k2", "k6"};
1053 int s2_values[] = {5, 9, 15, 23}; 1059 int s2_values[] = {5, 9, 15, 23};
1054 for (unsigned int i = 0 ; i < 4 ; i++) { 1060 for (unsigned int i = 0 ; i < 4 ; i++) {
1068 cxMapFree(s2); 1074 cxMapFree(s2);
1069 cx_testing_allocator_destroy(&talloc); 1075 cx_testing_allocator_destroy(&talloc);
1070 } 1076 }
1071 1077
1072 CX_TEST(test_hash_map_union) { 1078 CX_TEST(test_hash_map_union) {
1073 CxMap *s1 = cxHashMapCreateSimple(sizeof(int)); 1079 CxMap *s1 = cxHashMapCreate(NULL, sizeof(int), 0);
1074 CxMap *s2 = cxHashMapCreateSimple(sizeof(int)); 1080 CxMap *s2 = cxHashMapCreate(NULL, sizeof(int), 0);
1075 const char *s1_keys[] = {"k1", "k2", "k3", "k4"}; 1081 const char *s1_keys[] = {"k1", "k2", "k3", "k4"};
1076 int s1_values[] = {1, 3, 4, 6}; 1082 int s1_values[] = {1, 3, 4, 6};
1077 const char *s2_keys[] = {"k4", "k5", "k2", "k6"}; 1083 const char *s2_keys[] = {"k4", "k5", "k2", "k6"};
1078 int s2_values[] = {5, 9, 15, 23}; 1084 int s2_values[] = {5, 9, 15, 23};
1079 for (unsigned int i = 0 ; i < 4 ; i++) { 1085 for (unsigned int i = 0 ; i < 4 ; i++) {
1097 1103
1098 CX_TEST(test_hash_map_union_ptr) { 1104 CX_TEST(test_hash_map_union_ptr) {
1099 CxTestingAllocator talloc; 1105 CxTestingAllocator talloc;
1100 cx_testing_allocator_init(&talloc); 1106 cx_testing_allocator_init(&talloc);
1101 CxAllocator *allocator = &talloc.base; 1107 CxAllocator *allocator = &talloc.base;
1102 CxMap *dst = cxHashMapCreateSimple(CX_STORE_POINTERS); 1108 CxMap *dst = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
1103 cxDefineAdvancedDestructor(dst, cxFree, allocator); 1109 cxSetAdvancedDestructor(dst, cxFree, allocator);
1104 1110
1105 CxMap *s1 = cxHashMapCreateSimple(sizeof(int)); 1111 CxMap *s1 = cxHashMapCreate(NULL, sizeof(int), 0);
1106 CxMap *s2 = cxHashMapCreateSimple(sizeof(int)); 1112 CxMap *s2 = cxHashMapCreate(NULL, sizeof(int), 0);
1107 const char *s1_keys[] = {"k1", "k2", "k3", "k4"}; 1113 const char *s1_keys[] = {"k1", "k2", "k3", "k4"};
1108 int s1_values[] = {1, 3, 4, 6}; 1114 int s1_values[] = {1, 3, 4, 6};
1109 const char *s2_keys[] = {"k4", "k5", "k2", "k6"}; 1115 const char *s2_keys[] = {"k4", "k5", "k2", "k6"};
1110 int s2_values[] = {5, 9, 15, 23}; 1116 int s2_values[] = {5, 9, 15, 23};
1111 for (unsigned int i = 0 ; i < 4 ; i++) { 1117 for (unsigned int i = 0 ; i < 4 ; i++) {
1130 cxMapFree(s2); 1136 cxMapFree(s2);
1131 cx_testing_allocator_destroy(&talloc); 1137 cx_testing_allocator_destroy(&talloc);
1132 } 1138 }
1133 1139
1134 CX_TEST(test_hash_map_union_alloc_fail) { 1140 CX_TEST(test_hash_map_union_alloc_fail) {
1135 CxMap *s1 = cxHashMapCreateSimple(sizeof(int)); 1141 CxMap *s1 = cxHashMapCreate(NULL, sizeof(int), 0);
1136 CxMap *s2 = cxHashMapCreateSimple(sizeof(int)); 1142 CxMap *s2 = cxHashMapCreate(NULL, sizeof(int), 0);
1137 const char *s1_keys[] = {"k1", "k2", "k3", "k4"}; 1143 const char *s1_keys[] = {"k1", "k2", "k3", "k4"};
1138 int s1_values[] = {1, 3, 4, 6}; 1144 int s1_values[] = {1, 3, 4, 6};
1139 const char *s2_keys[] = {"k4", "k5", "k2", "k6"}; 1145 const char *s2_keys[] = {"k4", "k5", "k2", "k6"};
1140 int s2_values[] = {5, 9, 15, 23}; 1146 int s2_values[] = {5, 9, 15, 23};
1141 for (unsigned int i = 0 ; i < 4 ; i++) { 1147 for (unsigned int i = 0 ; i < 4 ; i++) {
1161 cxMapFree(s2); 1167 cxMapFree(s2);
1162 } 1168 }
1163 1169
1164 CX_TEST(test_hash_map_simple_clones) { 1170 CX_TEST(test_hash_map_simple_clones) {
1165 int v = 47; // the value does not matter in this test 1171 int v = 47; // the value does not matter in this test
1166 CxMap *a = cxHashMapCreateSimple(sizeof(int)); 1172 CxMap *a = cxHashMapCreate(NULL, sizeof(int), 0);
1167 cxMapPut(a, "k1", &v); 1173 cxMapPut(a, "k1", &v);
1168 cxMapPut(a, "k2", &v); 1174 cxMapPut(a, "k2", &v);
1169 cxMapPut(a, "k3", &v); 1175 cxMapPut(a, "k3", &v);
1170 cxMapPut(a, "k4", &v); 1176 cxMapPut(a, "k4", &v);
1171 1177
1172 CxMap *b = cxHashMapCreateSimple(sizeof(int)); 1178 CxMap *b = cxHashMapCreate(NULL, sizeof(int), 0);
1173 cxMapPut(b, "k0", &v); 1179 cxMapPut(b, "k0", &v);
1174 cxMapPut(b, "k2", &v); 1180 cxMapPut(b, "k2", &v);
1175 cxMapPut(b, "k5", &v); 1181 cxMapPut(b, "k5", &v);
1176 1182
1177 CxMap *c = cxHashMapCreateSimple(sizeof(int)); 1183 CxMap *c = cxHashMapCreate(NULL, sizeof(int), 0);
1178 cxMapPut(c, "k3", &v); 1184 cxMapPut(c, "k3", &v);
1179 cxMapPut(c, "k4", &v); 1185 cxMapPut(c, "k4", &v);
1180 cxMapPut(c, "k5", &v); 1186 cxMapPut(c, "k5", &v);
1181 1187
1182 1188
1183 CxHashKey k; 1189 CxHashKey k;
1184 CxList *kl1 = cxArrayListCreateSimple(sizeof(CxHashKey), 4); 1190 CxList *kl1 = cxArrayListCreate(NULL, sizeof(CxHashKey), 4);
1185 cxCollectionCompareFunc(kl1, cx_hash_key_cmp); 1191 cxSetCompareFunc(kl1, cx_hash_key_cmp);
1186 k = CX_HASH_KEY("k0"); 1192 k = CX_HASH_KEY("k0");
1187 cxListAdd(kl1, &k); 1193 cxListAdd(kl1, &k);
1188 k = CX_HASH_KEY("k2"); 1194 k = CX_HASH_KEY("k2");
1189 cxListAdd(kl1, &k); 1195 cxListAdd(kl1, &k);
1190 k = CX_HASH_KEY("k5"); 1196 k = CX_HASH_KEY("k5");
1191 cxListAdd(kl1, &k); 1197 cxListAdd(kl1, &k);
1192 1198
1193 CxList *kl2 = cxArrayListCreateSimple(sizeof(CxHashKey), 4); 1199 CxList *kl2 = cxArrayListCreate(NULL, sizeof(CxHashKey), 4);
1194 cxCollectionCompareFunc(kl2, cx_hash_key_cmp); 1200 cxSetCompareFunc(kl2, cx_hash_key_cmp);
1195 k = CX_HASH_KEY("k3"); 1201 k = CX_HASH_KEY("k3");
1196 cxListAdd(kl2, &k); 1202 cxListAdd(kl2, &k);
1197 k = CX_HASH_KEY("k4"); 1203 k = CX_HASH_KEY("k4");
1198 cxListAdd(kl2, &k); 1204 cxListAdd(kl2, &k);
1199 k = CX_HASH_KEY("k5"); 1205 k = CX_HASH_KEY("k5");
1200 cxListAdd(kl2, &k); 1206 cxListAdd(kl2, &k);
1201 1207
1202 CxMap *d1 = cxHashMapCreateSimple(sizeof(int)); 1208 CxMap *d1 = cxHashMapCreate(NULL, sizeof(int), 0);
1203 CxMap *d2 = cxHashMapCreateSimple(sizeof(int)); 1209 CxMap *d2 = cxHashMapCreate(NULL, sizeof(int), 0);
1204 1210
1205 CX_TEST_DO { 1211 CX_TEST_DO {
1206 CX_TEST_ASSERT(0 == cxMapCloneShallow(d1, a)); 1212 CX_TEST_ASSERT(0 == cxMapCloneShallow(d1, a));
1207 CX_TEST_ASSERT(!cxMapContains(d1, "k0")); 1213 CX_TEST_ASSERT(!cxMapContains(d1, "k0"));
1208 CX_TEST_ASSERT(cxMapContains(d1, "k1")); 1214 CX_TEST_ASSERT(cxMapContains(d1, "k1"));
1262 cxMapFree(d1); 1268 cxMapFree(d1);
1263 cxMapFree(d2); 1269 cxMapFree(d2);
1264 } 1270 }
1265 1271
1266 CX_TEST(test_hash_map_compare) { 1272 CX_TEST(test_hash_map_compare) {
1267 CxMap *map1 = cxHashMapCreateSimple(sizeof(int)); 1273 CxMap *map1 = cxHashMapCreate(NULL, sizeof(int), 0);
1268 CxMap *map2 = cxHashMapCreateSimple(CX_STORE_POINTERS); 1274 CxMap *map2 = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
1269 // TODO: fix specification of compare function once #622 is realized 1275 // TODO: fix specification of compare function once #622 is realized
1270 map1->collection.cmpfunc = cx_cmp_int; 1276 map1->collection.cmpfunc = cx_cmp_int;
1271 map2->collection.cmpfunc = cx_cmp_int; 1277 map2->collection.cmpfunc = cx_cmp_int;
1272 1278
1273 // some ints we can point to in the pointer map 1279 // some ints we can point to in the pointer map

Mercurial Repository: ucx

mercurial