tests: Rename UserDefNativeListUnion to UserDefListUnion

+3 -3

tests/qapi-schema/qapi-schema-test.json

··· 113 113 # for testing use of 'str' within alternates 114 114 { 'alternate': 'AltStrObj', 'data': { 's': 'str', 'o': 'TestStruct' } } 115 115 116 - # for testing native lists 117 - { 'union': 'UserDefNativeListUnion', 116 + # for testing lists 117 + { 'union': 'UserDefListUnion', 118 118 'data': { 'integer': ['int'], 119 119 's8': ['int8'], 120 120 's16': ['int16'], ··· 147 147 'returns': 'int' } 148 148 { 'command': 'guest-sync', 'data': { 'arg': 'any' }, 'returns': 'any' } 149 149 { 'command': 'boxed-struct', 'boxed': true, 'data': 'UserDefZero' } 150 - { 'command': 'boxed-union', 'data': 'UserDefNativeListUnion', 'boxed': true } 150 + { 'command': 'boxed-union', 'data': 'UserDefListUnion', 'boxed': true } 151 151 152 152 # Smoke test on out-of-band and allow-preconfig-test 153 153 { 'command': 'test-flags-command', 'allow-oob': true, 'allow-preconfig': true }

+4 -4

tests/qapi-schema/qapi-schema-test.out

··· 144 144 member data: sizeList optional=False 145 145 object q_obj_anyList-wrapper 146 146 member data: anyList optional=False 147 - enum UserDefNativeListUnionKind 147 + enum UserDefListUnionKind 148 148 member integer 149 149 member s8 150 150 member s16 ··· 159 159 member string 160 160 member sizes 161 161 member any 162 - object UserDefNativeListUnion 163 - member type: UserDefNativeListUnionKind optional=False 162 + object UserDefListUnion 163 + member type: UserDefListUnionKind optional=False 164 164 tag type 165 165 case integer: q_obj_intList-wrapper 166 166 case s8: q_obj_int8List-wrapper ··· 209 209 gen=True success_response=True boxed=False oob=False preconfig=False 210 210 command boxed-struct UserDefZero -> None 211 211 gen=True success_response=True boxed=True oob=False preconfig=False 212 - command boxed-union UserDefNativeListUnion -> None 212 + command boxed-union UserDefListUnion -> None 213 213 gen=True success_response=True boxed=True oob=False preconfig=False 214 214 command test-flags-command None -> None 215 215 gen=True success_response=True boxed=False oob=True preconfig=True

+8 -8

tests/test-clone-visitor.c

··· 63 63 qapi_free_AltEnumBool(s_dst); 64 64 } 65 65 66 - static void test_clone_native_list(void) 66 + static void test_clone_list_union(void) 67 67 { 68 68 uint8List *src, *dst; 69 69 uint8List *tmp = NULL; ··· 102 102 103 103 static void test_clone_complex1(void) 104 104 { 105 - UserDefNativeListUnion *src, *dst; 105 + UserDefListUnion *src, *dst; 106 106 107 - src = g_new0(UserDefNativeListUnion, 1); 108 - src->type = USER_DEF_NATIVE_LIST_UNION_KIND_STRING; 107 + src = g_new0(UserDefListUnion, 1); 108 + src->type = USER_DEF_LIST_UNION_KIND_STRING; 109 109 110 - dst = QAPI_CLONE(UserDefNativeListUnion, src); 110 + dst = QAPI_CLONE(UserDefListUnion, src); 111 111 g_assert(dst); 112 112 g_assert_cmpint(dst->type, ==, src->type); 113 113 g_assert(!dst->u.string.data); 114 114 115 - qapi_free_UserDefNativeListUnion(src); 116 - qapi_free_UserDefNativeListUnion(dst); 115 + qapi_free_UserDefListUnion(src); 116 + qapi_free_UserDefListUnion(dst); 117 117 } 118 118 119 119 static void test_clone_complex2(void) ··· 192 192 193 193 g_test_add_func("/visitor/clone/struct", test_clone_struct); 194 194 g_test_add_func("/visitor/clone/alternate", test_clone_alternate); 195 - g_test_add_func("/visitor/clone/native_list", test_clone_native_list); 195 + g_test_add_func("/visitor/clone/list_union", test_clone_list_union); 196 196 g_test_add_func("/visitor/clone/empty", test_clone_empty); 197 197 g_test_add_func("/visitor/clone/complex1", test_clone_complex1); 198 198 g_test_add_func("/visitor/clone/complex2", test_clone_complex2);

+1 -1

tests/test-qmp-cmds.c

··· 87 87 { 88 88 } 89 89 90 - void qmp_boxed_union(UserDefNativeListUnion *arg, Error **errp) 90 + void qmp_boxed_union(UserDefListUnion *arg, Error **errp) 91 91 { 92 92 } 93 93

+98 -98

tests/test-qobject-input-visitor.c

··· 686 686 qapi_free_AltEnumInt(asi); 687 687 } 688 688 689 - static void test_native_list_integer_helper(TestInputVisitorData *data, 690 - const void *unused, 691 - UserDefNativeListUnionKind kind) 689 + static void test_list_union_integer_helper(TestInputVisitorData *data, 690 + const void *unused, 691 + UserDefListUnionKind kind) 692 692 { 693 - UserDefNativeListUnion *cvalue = NULL; 693 + UserDefListUnion *cvalue = NULL; 694 694 Visitor *v; 695 695 GString *gstr_list = g_string_new(""); 696 696 GString *gstr_union = g_string_new(""); ··· 703 703 } 704 704 } 705 705 g_string_append_printf(gstr_union, "{ 'type': '%s', 'data': [ %s ] }", 706 - UserDefNativeListUnionKind_str(kind), 706 + UserDefListUnionKind_str(kind), 707 707 gstr_list->str); 708 708 v = visitor_input_test_init_raw(data, gstr_union->str); 709 709 710 - visit_type_UserDefNativeListUnion(v, NULL, &cvalue, &error_abort); 710 + visit_type_UserDefListUnion(v, NULL, &cvalue, &error_abort); 711 711 g_assert(cvalue != NULL); 712 712 g_assert_cmpint(cvalue->type, ==, kind); 713 713 714 714 switch (kind) { 715 - case USER_DEF_NATIVE_LIST_UNION_KIND_INTEGER: { 715 + case USER_DEF_LIST_UNION_KIND_INTEGER: { 716 716 intList *elem = NULL; 717 717 for (i = 0, elem = cvalue->u.integer.data; 718 718 elem; elem = elem->next, i++) { ··· 720 720 } 721 721 break; 722 722 } 723 - case USER_DEF_NATIVE_LIST_UNION_KIND_S8: { 723 + case USER_DEF_LIST_UNION_KIND_S8: { 724 724 int8List *elem = NULL; 725 725 for (i = 0, elem = cvalue->u.s8.data; elem; elem = elem->next, i++) { 726 726 g_assert_cmpint(elem->value, ==, i); 727 727 } 728 728 break; 729 729 } 730 - case USER_DEF_NATIVE_LIST_UNION_KIND_S16: { 730 + case USER_DEF_LIST_UNION_KIND_S16: { 731 731 int16List *elem = NULL; 732 732 for (i = 0, elem = cvalue->u.s16.data; elem; elem = elem->next, i++) { 733 733 g_assert_cmpint(elem->value, ==, i); 734 734 } 735 735 break; 736 736 } 737 - case USER_DEF_NATIVE_LIST_UNION_KIND_S32: { 737 + case USER_DEF_LIST_UNION_KIND_S32: { 738 738 int32List *elem = NULL; 739 739 for (i = 0, elem = cvalue->u.s32.data; elem; elem = elem->next, i++) { 740 740 g_assert_cmpint(elem->value, ==, i); 741 741 } 742 742 break; 743 743 } 744 - case USER_DEF_NATIVE_LIST_UNION_KIND_S64: { 744 + case USER_DEF_LIST_UNION_KIND_S64: { 745 745 int64List *elem = NULL; 746 746 for (i = 0, elem = cvalue->u.s64.data; elem; elem = elem->next, i++) { 747 747 g_assert_cmpint(elem->value, ==, i); 748 748 } 749 749 break; 750 750 } 751 - case USER_DEF_NATIVE_LIST_UNION_KIND_U8: { 751 + case USER_DEF_LIST_UNION_KIND_U8: { 752 752 uint8List *elem = NULL; 753 753 for (i = 0, elem = cvalue->u.u8.data; elem; elem = elem->next, i++) { 754 754 g_assert_cmpint(elem->value, ==, i); 755 755 } 756 756 break; 757 757 } 758 - case USER_DEF_NATIVE_LIST_UNION_KIND_U16: { 758 + case USER_DEF_LIST_UNION_KIND_U16: { 759 759 uint16List *elem = NULL; 760 760 for (i = 0, elem = cvalue->u.u16.data; elem; elem = elem->next, i++) { 761 761 g_assert_cmpint(elem->value, ==, i); 762 762 } 763 763 break; 764 764 } 765 - case USER_DEF_NATIVE_LIST_UNION_KIND_U32: { 765 + case USER_DEF_LIST_UNION_KIND_U32: { 766 766 uint32List *elem = NULL; 767 767 for (i = 0, elem = cvalue->u.u32.data; elem; elem = elem->next, i++) { 768 768 g_assert_cmpint(elem->value, ==, i); 769 769 } 770 770 break; 771 771 } 772 - case USER_DEF_NATIVE_LIST_UNION_KIND_U64: { 772 + case USER_DEF_LIST_UNION_KIND_U64: { 773 773 uint64List *elem = NULL; 774 774 for (i = 0, elem = cvalue->u.u64.data; elem; elem = elem->next, i++) { 775 775 g_assert_cmpint(elem->value, ==, i); ··· 782 782 783 783 g_string_free(gstr_union, true); 784 784 g_string_free(gstr_list, true); 785 - qapi_free_UserDefNativeListUnion(cvalue); 785 + qapi_free_UserDefListUnion(cvalue); 786 786 } 787 787 788 - static void test_visitor_in_native_list_int(TestInputVisitorData *data, 789 - const void *unused) 788 + static void test_visitor_in_list_union_int(TestInputVisitorData *data, 789 + const void *unused) 790 790 { 791 - test_native_list_integer_helper(data, unused, 792 - USER_DEF_NATIVE_LIST_UNION_KIND_INTEGER); 791 + test_list_union_integer_helper(data, unused, 792 + USER_DEF_LIST_UNION_KIND_INTEGER); 793 793 } 794 794 795 - static void test_visitor_in_native_list_int8(TestInputVisitorData *data, 796 - const void *unused) 795 + static void test_visitor_in_list_union_int8(TestInputVisitorData *data, 796 + const void *unused) 797 797 { 798 - test_native_list_integer_helper(data, unused, 799 - USER_DEF_NATIVE_LIST_UNION_KIND_S8); 798 + test_list_union_integer_helper(data, unused, 799 + USER_DEF_LIST_UNION_KIND_S8); 800 800 } 801 801 802 - static void test_visitor_in_native_list_int16(TestInputVisitorData *data, 803 - const void *unused) 802 + static void test_visitor_in_list_union_int16(TestInputVisitorData *data, 803 + const void *unused) 804 804 { 805 - test_native_list_integer_helper(data, unused, 806 - USER_DEF_NATIVE_LIST_UNION_KIND_S16); 805 + test_list_union_integer_helper(data, unused, 806 + USER_DEF_LIST_UNION_KIND_S16); 807 807 } 808 808 809 - static void test_visitor_in_native_list_int32(TestInputVisitorData *data, 810 - const void *unused) 809 + static void test_visitor_in_list_union_int32(TestInputVisitorData *data, 810 + const void *unused) 811 811 { 812 - test_native_list_integer_helper(data, unused, 813 - USER_DEF_NATIVE_LIST_UNION_KIND_S32); 812 + test_list_union_integer_helper(data, unused, 813 + USER_DEF_LIST_UNION_KIND_S32); 814 814 } 815 815 816 - static void test_visitor_in_native_list_int64(TestInputVisitorData *data, 817 - const void *unused) 816 + static void test_visitor_in_list_union_int64(TestInputVisitorData *data, 817 + const void *unused) 818 818 { 819 - test_native_list_integer_helper(data, unused, 820 - USER_DEF_NATIVE_LIST_UNION_KIND_S64); 819 + test_list_union_integer_helper(data, unused, 820 + USER_DEF_LIST_UNION_KIND_S64); 821 821 } 822 822 823 - static void test_visitor_in_native_list_uint8(TestInputVisitorData *data, 823 + static void test_visitor_in_list_union_uint8(TestInputVisitorData *data, 824 824 const void *unused) 825 825 { 826 - test_native_list_integer_helper(data, unused, 827 - USER_DEF_NATIVE_LIST_UNION_KIND_U8); 826 + test_list_union_integer_helper(data, unused, 827 + USER_DEF_LIST_UNION_KIND_U8); 828 828 } 829 829 830 - static void test_visitor_in_native_list_uint16(TestInputVisitorData *data, 831 - const void *unused) 830 + static void test_visitor_in_list_union_uint16(TestInputVisitorData *data, 831 + const void *unused) 832 832 { 833 - test_native_list_integer_helper(data, unused, 834 - USER_DEF_NATIVE_LIST_UNION_KIND_U16); 833 + test_list_union_integer_helper(data, unused, 834 + USER_DEF_LIST_UNION_KIND_U16); 835 835 } 836 836 837 - static void test_visitor_in_native_list_uint32(TestInputVisitorData *data, 838 - const void *unused) 837 + static void test_visitor_in_list_union_uint32(TestInputVisitorData *data, 838 + const void *unused) 839 839 { 840 - test_native_list_integer_helper(data, unused, 841 - USER_DEF_NATIVE_LIST_UNION_KIND_U32); 840 + test_list_union_integer_helper(data, unused, 841 + USER_DEF_LIST_UNION_KIND_U32); 842 842 } 843 843 844 - static void test_visitor_in_native_list_uint64(TestInputVisitorData *data, 845 - const void *unused) 844 + static void test_visitor_in_list_union_uint64(TestInputVisitorData *data, 845 + const void *unused) 846 846 { 847 - test_native_list_integer_helper(data, unused, 848 - USER_DEF_NATIVE_LIST_UNION_KIND_U64); 847 + test_list_union_integer_helper(data, unused, 848 + USER_DEF_LIST_UNION_KIND_U64); 849 849 } 850 850 851 - static void test_visitor_in_native_list_bool(TestInputVisitorData *data, 851 + static void test_visitor_in_list_union_bool(TestInputVisitorData *data, 852 852 const void *unused) 853 853 { 854 - UserDefNativeListUnion *cvalue = NULL; 854 + UserDefListUnion *cvalue = NULL; 855 855 boolList *elem = NULL; 856 856 Visitor *v; 857 857 GString *gstr_list = g_string_new(""); ··· 869 869 gstr_list->str); 870 870 v = visitor_input_test_init_raw(data, gstr_union->str); 871 871 872 - visit_type_UserDefNativeListUnion(v, NULL, &cvalue, &error_abort); 872 + visit_type_UserDefListUnion(v, NULL, &cvalue, &error_abort); 873 873 g_assert(cvalue != NULL); 874 - g_assert_cmpint(cvalue->type, ==, USER_DEF_NATIVE_LIST_UNION_KIND_BOOLEAN); 874 + g_assert_cmpint(cvalue->type, ==, USER_DEF_LIST_UNION_KIND_BOOLEAN); 875 875 876 876 for (i = 0, elem = cvalue->u.boolean.data; elem; elem = elem->next, i++) { 877 877 g_assert_cmpint(elem->value, ==, (i % 3 == 0) ? 1 : 0); ··· 879 879 880 880 g_string_free(gstr_union, true); 881 881 g_string_free(gstr_list, true); 882 - qapi_free_UserDefNativeListUnion(cvalue); 882 + qapi_free_UserDefListUnion(cvalue); 883 883 } 884 884 885 - static void test_visitor_in_native_list_string(TestInputVisitorData *data, 886 - const void *unused) 885 + static void test_visitor_in_list_union_string(TestInputVisitorData *data, 886 + const void *unused) 887 887 { 888 - UserDefNativeListUnion *cvalue = NULL; 888 + UserDefListUnion *cvalue = NULL; 889 889 strList *elem = NULL; 890 890 Visitor *v; 891 891 GString *gstr_list = g_string_new(""); ··· 902 902 gstr_list->str); 903 903 v = visitor_input_test_init_raw(data, gstr_union->str); 904 904 905 - visit_type_UserDefNativeListUnion(v, NULL, &cvalue, &error_abort); 905 + visit_type_UserDefListUnion(v, NULL, &cvalue, &error_abort); 906 906 g_assert(cvalue != NULL); 907 - g_assert_cmpint(cvalue->type, ==, USER_DEF_NATIVE_LIST_UNION_KIND_STRING); 907 + g_assert_cmpint(cvalue->type, ==, USER_DEF_LIST_UNION_KIND_STRING); 908 908 909 909 for (i = 0, elem = cvalue->u.string.data; elem; elem = elem->next, i++) { 910 910 gchar str[8]; ··· 914 914 915 915 g_string_free(gstr_union, true); 916 916 g_string_free(gstr_list, true); 917 - qapi_free_UserDefNativeListUnion(cvalue); 917 + qapi_free_UserDefListUnion(cvalue); 918 918 } 919 919 920 920 #define DOUBLE_STR_MAX 16 921 921 922 - static void test_visitor_in_native_list_number(TestInputVisitorData *data, 923 - const void *unused) 922 + static void test_visitor_in_list_union_number(TestInputVisitorData *data, 923 + const void *unused) 924 924 { 925 - UserDefNativeListUnion *cvalue = NULL; 925 + UserDefListUnion *cvalue = NULL; 926 926 numberList *elem = NULL; 927 927 Visitor *v; 928 928 GString *gstr_list = g_string_new(""); ··· 939 939 gstr_list->str); 940 940 v = visitor_input_test_init_raw(data, gstr_union->str); 941 941 942 - visit_type_UserDefNativeListUnion(v, NULL, &cvalue, &error_abort); 942 + visit_type_UserDefListUnion(v, NULL, &cvalue, &error_abort); 943 943 g_assert(cvalue != NULL); 944 - g_assert_cmpint(cvalue->type, ==, USER_DEF_NATIVE_LIST_UNION_KIND_NUMBER); 944 + g_assert_cmpint(cvalue->type, ==, USER_DEF_LIST_UNION_KIND_NUMBER); 945 945 946 946 for (i = 0, elem = cvalue->u.number.data; elem; elem = elem->next, i++) { 947 947 GString *double_expected = g_string_new(""); ··· 957 957 958 958 g_string_free(gstr_union, true); 959 959 g_string_free(gstr_list, true); 960 - qapi_free_UserDefNativeListUnion(cvalue); 960 + qapi_free_UserDefListUnion(cvalue); 961 961 } 962 962 963 963 static void input_visitor_test_add(const char *testpath, ··· 1192 1192 visit_end_list(v, NULL); 1193 1193 } 1194 1194 1195 - static void test_visitor_in_fail_union_native_list(TestInputVisitorData *data, 1196 - const void *unused) 1195 + static void test_visitor_in_fail_union_list(TestInputVisitorData *data, 1196 + const void *unused) 1197 1197 { 1198 - UserDefNativeListUnion *tmp = NULL; 1198 + UserDefListUnion *tmp = NULL; 1199 1199 Error *err = NULL; 1200 1200 Visitor *v; 1201 1201 1202 1202 v = visitor_input_test_init(data, 1203 1203 "{ 'type': 'integer', 'data' : [ 'string' ] }"); 1204 1204 1205 - visit_type_UserDefNativeListUnion(v, NULL, &tmp, &err); 1205 + visit_type_UserDefListUnion(v, NULL, &tmp, &err); 1206 1206 error_free_or_abort(&err); 1207 1207 g_assert(!tmp); 1208 1208 } ··· 1335 1335 NULL, test_visitor_in_wrong_type); 1336 1336 input_visitor_test_add("/visitor/input/alternate-number", 1337 1337 NULL, test_visitor_in_alternate_number); 1338 - input_visitor_test_add("/visitor/input/native_list/int", 1339 - NULL, test_visitor_in_native_list_int); 1340 - input_visitor_test_add("/visitor/input/native_list/int8", 1341 - NULL, test_visitor_in_native_list_int8); 1342 - input_visitor_test_add("/visitor/input/native_list/int16", 1343 - NULL, test_visitor_in_native_list_int16); 1344 - input_visitor_test_add("/visitor/input/native_list/int32", 1345 - NULL, test_visitor_in_native_list_int32); 1346 - input_visitor_test_add("/visitor/input/native_list/int64", 1347 - NULL, test_visitor_in_native_list_int64); 1348 - input_visitor_test_add("/visitor/input/native_list/uint8", 1349 - NULL, test_visitor_in_native_list_uint8); 1350 - input_visitor_test_add("/visitor/input/native_list/uint16", 1351 - NULL, test_visitor_in_native_list_uint16); 1352 - input_visitor_test_add("/visitor/input/native_list/uint32", 1353 - NULL, test_visitor_in_native_list_uint32); 1354 - input_visitor_test_add("/visitor/input/native_list/uint64", 1355 - NULL, test_visitor_in_native_list_uint64); 1356 - input_visitor_test_add("/visitor/input/native_list/bool", 1357 - NULL, test_visitor_in_native_list_bool); 1358 - input_visitor_test_add("/visitor/input/native_list/str", 1359 - NULL, test_visitor_in_native_list_string); 1360 - input_visitor_test_add("/visitor/input/native_list/number", 1361 - NULL, test_visitor_in_native_list_number); 1338 + input_visitor_test_add("/visitor/input/list_union/int", 1339 + NULL, test_visitor_in_list_union_int); 1340 + input_visitor_test_add("/visitor/input/list_union/int8", 1341 + NULL, test_visitor_in_list_union_int8); 1342 + input_visitor_test_add("/visitor/input/list_union/int16", 1343 + NULL, test_visitor_in_list_union_int16); 1344 + input_visitor_test_add("/visitor/input/list_union/int32", 1345 + NULL, test_visitor_in_list_union_int32); 1346 + input_visitor_test_add("/visitor/input/list_union/int64", 1347 + NULL, test_visitor_in_list_union_int64); 1348 + input_visitor_test_add("/visitor/input/list_union/uint8", 1349 + NULL, test_visitor_in_list_union_uint8); 1350 + input_visitor_test_add("/visitor/input/list_union/uint16", 1351 + NULL, test_visitor_in_list_union_uint16); 1352 + input_visitor_test_add("/visitor/input/list_union/uint32", 1353 + NULL, test_visitor_in_list_union_uint32); 1354 + input_visitor_test_add("/visitor/input/list_union/uint64", 1355 + NULL, test_visitor_in_list_union_uint64); 1356 + input_visitor_test_add("/visitor/input/list_union/bool", 1357 + NULL, test_visitor_in_list_union_bool); 1358 + input_visitor_test_add("/visitor/input/list_union/str", 1359 + NULL, test_visitor_in_list_union_string); 1360 + input_visitor_test_add("/visitor/input/list_union/number", 1361 + NULL, test_visitor_in_list_union_number); 1362 1362 input_visitor_test_add("/visitor/input/fail/struct", 1363 1363 NULL, test_visitor_in_fail_struct); 1364 1364 input_visitor_test_add("/visitor/input/fail/struct-nested", ··· 1377 1377 NULL, test_visitor_in_fail_union_flat_no_discrim); 1378 1378 input_visitor_test_add("/visitor/input/fail/alternate", 1379 1379 NULL, test_visitor_in_fail_alternate); 1380 - input_visitor_test_add("/visitor/input/fail/union-native-list", 1381 - NULL, test_visitor_in_fail_union_native_list); 1380 + input_visitor_test_add("/visitor/input/fail/union-list", 1381 + NULL, test_visitor_in_fail_union_list); 1382 1382 input_visitor_test_add("/visitor/input/qapi-introspect", 1383 1383 NULL, test_visitor_in_qmp_introspect); 1384 1384

+95 -95

tests/test-qobject-output-visitor.c

··· 474 474 g_assert(qobject_type(nil) == QTYPE_QNULL); 475 475 } 476 476 477 - static void init_native_list(UserDefNativeListUnion *cvalue) 477 + static void init_list_union(UserDefListUnion *cvalue) 478 478 { 479 479 int i; 480 480 switch (cvalue->type) { 481 - case USER_DEF_NATIVE_LIST_UNION_KIND_INTEGER: { 481 + case USER_DEF_LIST_UNION_KIND_INTEGER: { 482 482 intList **list = &cvalue->u.integer.data; 483 483 for (i = 0; i < 32; i++) { 484 484 *list = g_new0(intList, 1); ··· 488 488 } 489 489 break; 490 490 } 491 - case USER_DEF_NATIVE_LIST_UNION_KIND_S8: { 491 + case USER_DEF_LIST_UNION_KIND_S8: { 492 492 int8List **list = &cvalue->u.s8.data; 493 493 for (i = 0; i < 32; i++) { 494 494 *list = g_new0(int8List, 1); ··· 498 498 } 499 499 break; 500 500 } 501 - case USER_DEF_NATIVE_LIST_UNION_KIND_S16: { 501 + case USER_DEF_LIST_UNION_KIND_S16: { 502 502 int16List **list = &cvalue->u.s16.data; 503 503 for (i = 0; i < 32; i++) { 504 504 *list = g_new0(int16List, 1); ··· 508 508 } 509 509 break; 510 510 } 511 - case USER_DEF_NATIVE_LIST_UNION_KIND_S32: { 511 + case USER_DEF_LIST_UNION_KIND_S32: { 512 512 int32List **list = &cvalue->u.s32.data; 513 513 for (i = 0; i < 32; i++) { 514 514 *list = g_new0(int32List, 1); ··· 518 518 } 519 519 break; 520 520 } 521 - case USER_DEF_NATIVE_LIST_UNION_KIND_S64: { 521 + case USER_DEF_LIST_UNION_KIND_S64: { 522 522 int64List **list = &cvalue->u.s64.data; 523 523 for (i = 0; i < 32; i++) { 524 524 *list = g_new0(int64List, 1); ··· 528 528 } 529 529 break; 530 530 } 531 - case USER_DEF_NATIVE_LIST_UNION_KIND_U8: { 531 + case USER_DEF_LIST_UNION_KIND_U8: { 532 532 uint8List **list = &cvalue->u.u8.data; 533 533 for (i = 0; i < 32; i++) { 534 534 *list = g_new0(uint8List, 1); ··· 538 538 } 539 539 break; 540 540 } 541 - case USER_DEF_NATIVE_LIST_UNION_KIND_U16: { 541 + case USER_DEF_LIST_UNION_KIND_U16: { 542 542 uint16List **list = &cvalue->u.u16.data; 543 543 for (i = 0; i < 32; i++) { 544 544 *list = g_new0(uint16List, 1); ··· 548 548 } 549 549 break; 550 550 } 551 - case USER_DEF_NATIVE_LIST_UNION_KIND_U32: { 551 + case USER_DEF_LIST_UNION_KIND_U32: { 552 552 uint32List **list = &cvalue->u.u32.data; 553 553 for (i = 0; i < 32; i++) { 554 554 *list = g_new0(uint32List, 1); ··· 558 558 } 559 559 break; 560 560 } 561 - case USER_DEF_NATIVE_LIST_UNION_KIND_U64: { 561 + case USER_DEF_LIST_UNION_KIND_U64: { 562 562 uint64List **list = &cvalue->u.u64.data; 563 563 for (i = 0; i < 32; i++) { 564 564 *list = g_new0(uint64List, 1); ··· 568 568 } 569 569 break; 570 570 } 571 - case USER_DEF_NATIVE_LIST_UNION_KIND_BOOLEAN: { 571 + case USER_DEF_LIST_UNION_KIND_BOOLEAN: { 572 572 boolList **list = &cvalue->u.boolean.data; 573 573 for (i = 0; i < 32; i++) { 574 574 *list = g_new0(boolList, 1); ··· 578 578 } 579 579 break; 580 580 } 581 - case USER_DEF_NATIVE_LIST_UNION_KIND_STRING: { 581 + case USER_DEF_LIST_UNION_KIND_STRING: { 582 582 strList **list = &cvalue->u.string.data; 583 583 for (i = 0; i < 32; i++) { 584 584 *list = g_new0(strList, 1); ··· 588 588 } 589 589 break; 590 590 } 591 - case USER_DEF_NATIVE_LIST_UNION_KIND_NUMBER: { 591 + case USER_DEF_LIST_UNION_KIND_NUMBER: { 592 592 numberList **list = &cvalue->u.number.data; 593 593 for (i = 0; i < 32; i++) { 594 594 *list = g_new0(numberList, 1); ··· 603 603 } 604 604 } 605 605 606 - static void check_native_list(QObject *qobj, 607 - UserDefNativeListUnionKind kind) 606 + static void check_list_union(QObject *qobj, 607 + UserDefListUnionKind kind) 608 608 { 609 609 QDict *qdict; 610 610 QList *qlist; ··· 616 616 qlist = qlist_copy(qobject_to(QList, qdict_get(qdict, "data"))); 617 617 618 618 switch (kind) { 619 - case USER_DEF_NATIVE_LIST_UNION_KIND_U8: 620 - case USER_DEF_NATIVE_LIST_UNION_KIND_U16: 621 - case USER_DEF_NATIVE_LIST_UNION_KIND_U32: 622 - case USER_DEF_NATIVE_LIST_UNION_KIND_U64: 619 + case USER_DEF_LIST_UNION_KIND_U8: 620 + case USER_DEF_LIST_UNION_KIND_U16: 621 + case USER_DEF_LIST_UNION_KIND_U32: 622 + case USER_DEF_LIST_UNION_KIND_U64: 623 623 for (i = 0; i < 32; i++) { 624 624 QObject *tmp; 625 625 QNum *qvalue; ··· 634 634 } 635 635 break; 636 636 637 - case USER_DEF_NATIVE_LIST_UNION_KIND_S8: 638 - case USER_DEF_NATIVE_LIST_UNION_KIND_S16: 639 - case USER_DEF_NATIVE_LIST_UNION_KIND_S32: 640 - case USER_DEF_NATIVE_LIST_UNION_KIND_S64: 637 + case USER_DEF_LIST_UNION_KIND_S8: 638 + case USER_DEF_LIST_UNION_KIND_S16: 639 + case USER_DEF_LIST_UNION_KIND_S32: 640 + case USER_DEF_LIST_UNION_KIND_S64: 641 641 /* 642 642 * All integer elements in JSON arrays get stored into QNums 643 643 * when we convert to QObjects, so we can check them all in 644 644 * the same fashion, so simply fall through here. 645 645 */ 646 - case USER_DEF_NATIVE_LIST_UNION_KIND_INTEGER: 646 + case USER_DEF_LIST_UNION_KIND_INTEGER: 647 647 for (i = 0; i < 32; i++) { 648 648 QObject *tmp; 649 649 QNum *qvalue; ··· 657 657 qobject_unref(qlist_pop(qlist)); 658 658 } 659 659 break; 660 - case USER_DEF_NATIVE_LIST_UNION_KIND_BOOLEAN: 660 + case USER_DEF_LIST_UNION_KIND_BOOLEAN: 661 661 for (i = 0; i < 32; i++) { 662 662 QObject *tmp; 663 663 QBool *qvalue; ··· 668 668 qobject_unref(qlist_pop(qlist)); 669 669 } 670 670 break; 671 - case USER_DEF_NATIVE_LIST_UNION_KIND_STRING: 671 + case USER_DEF_LIST_UNION_KIND_STRING: 672 672 for (i = 0; i < 32; i++) { 673 673 QObject *tmp; 674 674 QString *qvalue; ··· 681 681 qobject_unref(qlist_pop(qlist)); 682 682 } 683 683 break; 684 - case USER_DEF_NATIVE_LIST_UNION_KIND_NUMBER: 684 + case USER_DEF_LIST_UNION_KIND_NUMBER: 685 685 for (i = 0; i < 32; i++) { 686 686 QObject *tmp; 687 687 QNum *qvalue; ··· 706 706 qobject_unref(qlist); 707 707 } 708 708 709 - static void test_native_list(TestOutputVisitorData *data, 710 - const void *unused, 711 - UserDefNativeListUnionKind kind) 709 + static void test_list_union(TestOutputVisitorData *data, 710 + const void *unused, 711 + UserDefListUnionKind kind) 712 712 { 713 - UserDefNativeListUnion *cvalue = g_new0(UserDefNativeListUnion, 1); 713 + UserDefListUnion *cvalue = g_new0(UserDefListUnion, 1); 714 714 QObject *obj; 715 715 716 716 cvalue->type = kind; 717 - init_native_list(cvalue); 717 + init_list_union(cvalue); 718 718 719 - visit_type_UserDefNativeListUnion(data->ov, NULL, &cvalue, &error_abort); 719 + visit_type_UserDefListUnion(data->ov, NULL, &cvalue, &error_abort); 720 720 721 721 obj = visitor_get(data); 722 - check_native_list(obj, cvalue->type); 723 - qapi_free_UserDefNativeListUnion(cvalue); 722 + check_list_union(obj, cvalue->type); 723 + qapi_free_UserDefListUnion(cvalue); 724 724 } 725 725 726 - static void test_visitor_out_native_list_int(TestOutputVisitorData *data, 727 - const void *unused) 726 + static void test_visitor_out_list_union_int(TestOutputVisitorData *data, 727 + const void *unused) 728 728 { 729 - test_native_list(data, unused, USER_DEF_NATIVE_LIST_UNION_KIND_INTEGER); 729 + test_list_union(data, unused, USER_DEF_LIST_UNION_KIND_INTEGER); 730 730 } 731 731 732 - static void test_visitor_out_native_list_int8(TestOutputVisitorData *data, 733 - const void *unused) 732 + static void test_visitor_out_list_union_int8(TestOutputVisitorData *data, 733 + const void *unused) 734 734 { 735 - test_native_list(data, unused, USER_DEF_NATIVE_LIST_UNION_KIND_S8); 735 + test_list_union(data, unused, USER_DEF_LIST_UNION_KIND_S8); 736 736 } 737 737 738 - static void test_visitor_out_native_list_int16(TestOutputVisitorData *data, 739 - const void *unused) 738 + static void test_visitor_out_list_union_int16(TestOutputVisitorData *data, 739 + const void *unused) 740 740 { 741 - test_native_list(data, unused, USER_DEF_NATIVE_LIST_UNION_KIND_S16); 741 + test_list_union(data, unused, USER_DEF_LIST_UNION_KIND_S16); 742 742 } 743 743 744 - static void test_visitor_out_native_list_int32(TestOutputVisitorData *data, 745 - const void *unused) 744 + static void test_visitor_out_list_union_int32(TestOutputVisitorData *data, 745 + const void *unused) 746 746 { 747 - test_native_list(data, unused, USER_DEF_NATIVE_LIST_UNION_KIND_S32); 747 + test_list_union(data, unused, USER_DEF_LIST_UNION_KIND_S32); 748 748 } 749 749 750 - static void test_visitor_out_native_list_int64(TestOutputVisitorData *data, 751 - const void *unused) 750 + static void test_visitor_out_list_union_int64(TestOutputVisitorData *data, 751 + const void *unused) 752 752 { 753 - test_native_list(data, unused, USER_DEF_NATIVE_LIST_UNION_KIND_S64); 753 + test_list_union(data, unused, USER_DEF_LIST_UNION_KIND_S64); 754 754 } 755 755 756 - static void test_visitor_out_native_list_uint8(TestOutputVisitorData *data, 757 - const void *unused) 756 + static void test_visitor_out_list_union_uint8(TestOutputVisitorData *data, 757 + const void *unused) 758 758 { 759 - test_native_list(data, unused, USER_DEF_NATIVE_LIST_UNION_KIND_U8); 759 + test_list_union(data, unused, USER_DEF_LIST_UNION_KIND_U8); 760 760 } 761 761 762 - static void test_visitor_out_native_list_uint16(TestOutputVisitorData *data, 763 - const void *unused) 762 + static void test_visitor_out_list_union_uint16(TestOutputVisitorData *data, 763 + const void *unused) 764 764 { 765 - test_native_list(data, unused, USER_DEF_NATIVE_LIST_UNION_KIND_U16); 765 + test_list_union(data, unused, USER_DEF_LIST_UNION_KIND_U16); 766 766 } 767 767 768 - static void test_visitor_out_native_list_uint32(TestOutputVisitorData *data, 769 - const void *unused) 768 + static void test_visitor_out_list_union_uint32(TestOutputVisitorData *data, 769 + const void *unused) 770 770 { 771 - test_native_list(data, unused, USER_DEF_NATIVE_LIST_UNION_KIND_U32); 771 + test_list_union(data, unused, USER_DEF_LIST_UNION_KIND_U32); 772 772 } 773 773 774 - static void test_visitor_out_native_list_uint64(TestOutputVisitorData *data, 775 - const void *unused) 774 + static void test_visitor_out_list_union_uint64(TestOutputVisitorData *data, 775 + const void *unused) 776 776 { 777 - test_native_list(data, unused, USER_DEF_NATIVE_LIST_UNION_KIND_U64); 777 + test_list_union(data, unused, USER_DEF_LIST_UNION_KIND_U64); 778 778 } 779 779 780 - static void test_visitor_out_native_list_bool(TestOutputVisitorData *data, 781 - const void *unused) 780 + static void test_visitor_out_list_union_bool(TestOutputVisitorData *data, 781 + const void *unused) 782 782 { 783 - test_native_list(data, unused, USER_DEF_NATIVE_LIST_UNION_KIND_BOOLEAN); 783 + test_list_union(data, unused, USER_DEF_LIST_UNION_KIND_BOOLEAN); 784 784 } 785 785 786 - static void test_visitor_out_native_list_str(TestOutputVisitorData *data, 787 - const void *unused) 786 + static void test_visitor_out_list_union_str(TestOutputVisitorData *data, 787 + const void *unused) 788 788 { 789 - test_native_list(data, unused, USER_DEF_NATIVE_LIST_UNION_KIND_STRING); 789 + test_list_union(data, unused, USER_DEF_LIST_UNION_KIND_STRING); 790 790 } 791 791 792 - static void test_visitor_out_native_list_number(TestOutputVisitorData *data, 793 - const void *unused) 792 + static void test_visitor_out_list_union_number(TestOutputVisitorData *data, 793 + const void *unused) 794 794 { 795 - test_native_list(data, unused, USER_DEF_NATIVE_LIST_UNION_KIND_NUMBER); 795 + test_list_union(data, unused, USER_DEF_LIST_UNION_KIND_NUMBER); 796 796 } 797 797 798 798 static void output_visitor_test_add(const char *testpath, ··· 841 841 &out_visitor_data, test_visitor_out_alternate); 842 842 output_visitor_test_add("/visitor/output/null", 843 843 &out_visitor_data, test_visitor_out_null); 844 - output_visitor_test_add("/visitor/output/native_list/int", 844 + output_visitor_test_add("/visitor/output/list_union/int", 845 845 &out_visitor_data, 846 - test_visitor_out_native_list_int); 847 - output_visitor_test_add("/visitor/output/native_list/int8", 846 + test_visitor_out_list_union_int); 847 + output_visitor_test_add("/visitor/output/list_union/int8", 848 848 &out_visitor_data, 849 - test_visitor_out_native_list_int8); 850 - output_visitor_test_add("/visitor/output/native_list/int16", 849 + test_visitor_out_list_union_int8); 850 + output_visitor_test_add("/visitor/output/list_union/int16", 851 851 &out_visitor_data, 852 - test_visitor_out_native_list_int16); 853 - output_visitor_test_add("/visitor/output/native_list/int32", 852 + test_visitor_out_list_union_int16); 853 + output_visitor_test_add("/visitor/output/list_union/int32", 854 854 &out_visitor_data, 855 - test_visitor_out_native_list_int32); 856 - output_visitor_test_add("/visitor/output/native_list/int64", 855 + test_visitor_out_list_union_int32); 856 + output_visitor_test_add("/visitor/output/list_union/int64", 857 857 &out_visitor_data, 858 - test_visitor_out_native_list_int64); 859 - output_visitor_test_add("/visitor/output/native_list/uint8", 858 + test_visitor_out_list_union_int64); 859 + output_visitor_test_add("/visitor/output/list_union/uint8", 860 860 &out_visitor_data, 861 - test_visitor_out_native_list_uint8); 862 - output_visitor_test_add("/visitor/output/native_list/uint16", 861 + test_visitor_out_list_union_uint8); 862 + output_visitor_test_add("/visitor/output/list_union/uint16", 863 863 &out_visitor_data, 864 - test_visitor_out_native_list_uint16); 865 - output_visitor_test_add("/visitor/output/native_list/uint32", 864 + test_visitor_out_list_union_uint16); 865 + output_visitor_test_add("/visitor/output/list_union/uint32", 866 866 &out_visitor_data, 867 - test_visitor_out_native_list_uint32); 868 - output_visitor_test_add("/visitor/output/native_list/uint64", 867 + test_visitor_out_list_union_uint32); 868 + output_visitor_test_add("/visitor/output/list_union/uint64", 869 869 &out_visitor_data, 870 - test_visitor_out_native_list_uint64); 871 - output_visitor_test_add("/visitor/output/native_list/bool", 870 + test_visitor_out_list_union_uint64); 871 + output_visitor_test_add("/visitor/output/list_union/bool", 872 872 &out_visitor_data, 873 - test_visitor_out_native_list_bool); 874 - output_visitor_test_add("/visitor/output/native_list/string", 873 + test_visitor_out_list_union_bool); 874 + output_visitor_test_add("/visitor/output/list_union/string", 875 875 &out_visitor_data, 876 - test_visitor_out_native_list_str); 877 - output_visitor_test_add("/visitor/output/native_list/number", 876 + test_visitor_out_list_union_str); 877 + output_visitor_test_add("/visitor/output/list_union/number", 878 878 &out_visitor_data, 879 - test_visitor_out_native_list_number); 879 + test_visitor_out_list_union_number); 880 880 881 881 g_test_run(); 882 882