1 /* 2 * Generic QObject unit-tests. 3 * 4 * Copyright (C) 2017 Red Hat Inc. 5 * 6 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later. 7 * See the COPYING.LIB file in the top-level directory. 8 */ 9 10 #include "qemu/osdep.h" 11 #include "block/qdict.h" 12 #include "qapi/error.h" 13 #include "qapi/qmp/qbool.h" 14 #include "qapi/qmp/qdict.h" 15 #include "qapi/qmp/qlist.h" 16 #include "qapi/qmp/qnull.h" 17 #include "qapi/qmp/qnum.h" 18 #include "qapi/qmp/qstring.h" 19 #include "qemu-common.h" 20 21 #include <math.h> 22 23 /* Marks the end of the test_equality() argument list. 24 * We cannot use NULL there because that is a valid argument. */ 25 static QObject test_equality_end_of_arguments; 26 27 /** 28 * Test whether all variadic QObject *arguments are equal (@expected 29 * is true) or whether they are all not equal (@expected is false). 30 * Every QObject is tested to be equal to itself (to test 31 * reflexivity), all tests are done both ways (to test symmetry), and 32 * transitivity is not assumed but checked (each object is compared to 33 * every other one). 34 * 35 * Note that qobject_is_equal() is not really an equivalence relation, 36 * so this function may not be used for all objects (reflexivity is 37 * not guaranteed, e.g. in the case of a QNum containing NaN). 38 * 39 * The @_ argument is required because a boolean may not be the last 40 * argument before a variadic argument list (C11 7.16.1.4 para. 4). 41 */ 42 static void do_test_equality(bool expected, int _, ...) 43 { 44 va_list ap_count, ap_extract; 45 QObject **args; 46 int arg_count = 0; 47 int i, j; 48 49 va_start(ap_count, _); 50 va_copy(ap_extract, ap_count); 51 while (va_arg(ap_count, QObject *) != &test_equality_end_of_arguments) { 52 arg_count++; 53 } 54 va_end(ap_count); 55 56 args = g_new(QObject *, arg_count); 57 for (i = 0; i < arg_count; i++) { 58 args[i] = va_arg(ap_extract, QObject *); 59 } 60 va_end(ap_extract); 61 62 for (i = 0; i < arg_count; i++) { 63 g_assert(qobject_is_equal(args[i], args[i]) == true); 64 65 for (j = i + 1; j < arg_count; j++) { 66 g_assert(qobject_is_equal(args[i], args[j]) == expected); 67 } 68 } 69 70 g_free(args); 71 } 72 73 #define check_equal(...) \ 74 do_test_equality(true, 0, __VA_ARGS__, &test_equality_end_of_arguments) 75 #define check_unequal(...) \ 76 do_test_equality(false, 0, __VA_ARGS__, &test_equality_end_of_arguments) 77 78 static void do_free_all(int _, ...) 79 { 80 va_list ap; 81 QObject *obj; 82 83 va_start(ap, _); 84 while ((obj = va_arg(ap, QObject *)) != NULL) { 85 qobject_unref(obj); 86 } 87 va_end(ap); 88 } 89 90 #define free_all(...) \ 91 do_free_all(0, __VA_ARGS__, NULL) 92 93 static void qobject_is_equal_null_test(void) 94 { 95 check_unequal(qnull(), NULL); 96 } 97 98 static void qobject_is_equal_num_test(void) 99 { 100 QNum *u0, *i0, *d0, *dnan, *um42, *im42, *dm42; 101 102 u0 = qnum_from_uint(0u); 103 i0 = qnum_from_int(0); 104 d0 = qnum_from_double(0.0); 105 dnan = qnum_from_double(NAN); 106 um42 = qnum_from_uint((uint64_t)-42); 107 im42 = qnum_from_int(-42); 108 dm42 = qnum_from_double(-42.0); 109 110 /* Integers representing a mathematically equal number should 111 * compare equal */ 112 check_equal(u0, i0); 113 /* Doubles, however, are always unequal to integers */ 114 check_unequal(u0, d0); 115 check_unequal(i0, d0); 116 117 /* Do not assume any object is equal to itself -- note however 118 * that NaN cannot occur in a JSON object anyway. */ 119 g_assert(qobject_is_equal(QOBJECT(dnan), QOBJECT(dnan)) == false); 120 121 /* No unsigned overflow */ 122 check_unequal(um42, im42); 123 check_unequal(um42, dm42); 124 check_unequal(im42, dm42); 125 126 free_all(u0, i0, d0, dnan, um42, im42, dm42); 127 } 128 129 static void qobject_is_equal_bool_test(void) 130 { 131 QBool *btrue_0, *btrue_1, *bfalse_0, *bfalse_1; 132 133 btrue_0 = qbool_from_bool(true); 134 btrue_1 = qbool_from_bool(true); 135 bfalse_0 = qbool_from_bool(false); 136 bfalse_1 = qbool_from_bool(false); 137 138 check_equal(btrue_0, btrue_1); 139 check_equal(bfalse_0, bfalse_1); 140 check_unequal(btrue_0, bfalse_0); 141 142 free_all(btrue_0, btrue_1, bfalse_0, bfalse_1); 143 } 144 145 static void qobject_is_equal_string_test(void) 146 { 147 QString *str_base, *str_whitespace_0, *str_whitespace_1, *str_whitespace_2; 148 QString *str_whitespace_3, *str_case, *str_built; 149 150 str_base = qstring_from_str("foo"); 151 str_whitespace_0 = qstring_from_str(" foo"); 152 str_whitespace_1 = qstring_from_str("foo "); 153 str_whitespace_2 = qstring_from_str("foo\b"); 154 str_whitespace_3 = qstring_from_str("fooo\b"); 155 str_case = qstring_from_str("Foo"); 156 157 /* Should yield "foo" */ 158 str_built = qstring_from_substr("buffoon", 3, 6); 159 160 check_unequal(str_base, str_whitespace_0, str_whitespace_1, 161 str_whitespace_2, str_whitespace_3, str_case); 162 163 check_equal(str_base, str_built); 164 165 free_all(str_base, str_whitespace_0, str_whitespace_1, str_whitespace_2, 166 str_whitespace_3, str_case, str_built); 167 } 168 169 static void qobject_is_equal_list_test(void) 170 { 171 QList *list_0, *list_1, *list_cloned; 172 QList *list_reordered, *list_longer, *list_shorter; 173 174 list_0 = qlist_new(); 175 list_1 = qlist_new(); 176 list_reordered = qlist_new(); 177 list_longer = qlist_new(); 178 list_shorter = qlist_new(); 179 180 qlist_append_int(list_0, 1); 181 qlist_append_int(list_0, 2); 182 qlist_append_int(list_0, 3); 183 184 qlist_append_int(list_1, 1); 185 qlist_append_int(list_1, 2); 186 qlist_append_int(list_1, 3); 187 188 qlist_append_int(list_reordered, 1); 189 qlist_append_int(list_reordered, 3); 190 qlist_append_int(list_reordered, 2); 191 192 qlist_append_int(list_longer, 1); 193 qlist_append_int(list_longer, 2); 194 qlist_append_int(list_longer, 3); 195 qlist_append_null(list_longer); 196 197 qlist_append_int(list_shorter, 1); 198 qlist_append_int(list_shorter, 2); 199 200 list_cloned = qlist_copy(list_0); 201 202 check_equal(list_0, list_1, list_cloned); 203 check_unequal(list_0, list_reordered, list_longer, list_shorter); 204 205 /* With a NaN in it, the list should no longer compare equal to 206 * itself */ 207 qlist_append(list_0, qnum_from_double(NAN)); 208 g_assert(qobject_is_equal(QOBJECT(list_0), QOBJECT(list_0)) == false); 209 210 free_all(list_0, list_1, list_cloned, list_reordered, list_longer, 211 list_shorter); 212 } 213 214 static void qobject_is_equal_dict_test(void) 215 { 216 QDict *dict_0, *dict_1, *dict_cloned; 217 QDict *dict_different_key, *dict_different_value, *dict_different_null_key; 218 QDict *dict_longer, *dict_shorter, *dict_nested; 219 QDict *dict_crumpled; 220 221 dict_0 = qdict_new(); 222 dict_1 = qdict_new(); 223 dict_different_key = qdict_new(); 224 dict_different_value = qdict_new(); 225 dict_different_null_key = qdict_new(); 226 dict_longer = qdict_new(); 227 dict_shorter = qdict_new(); 228 dict_nested = qdict_new(); 229 230 qdict_put_int(dict_0, "f.o", 1); 231 qdict_put_int(dict_0, "bar", 2); 232 qdict_put_int(dict_0, "baz", 3); 233 qdict_put_null(dict_0, "null"); 234 235 qdict_put_int(dict_1, "f.o", 1); 236 qdict_put_int(dict_1, "bar", 2); 237 qdict_put_int(dict_1, "baz", 3); 238 qdict_put_null(dict_1, "null"); 239 240 qdict_put_int(dict_different_key, "F.o", 1); 241 qdict_put_int(dict_different_key, "bar", 2); 242 qdict_put_int(dict_different_key, "baz", 3); 243 qdict_put_null(dict_different_key, "null"); 244 245 qdict_put_int(dict_different_value, "f.o", 42); 246 qdict_put_int(dict_different_value, "bar", 2); 247 qdict_put_int(dict_different_value, "baz", 3); 248 qdict_put_null(dict_different_value, "null"); 249 250 qdict_put_int(dict_different_null_key, "f.o", 1); 251 qdict_put_int(dict_different_null_key, "bar", 2); 252 qdict_put_int(dict_different_null_key, "baz", 3); 253 qdict_put_null(dict_different_null_key, "none"); 254 255 qdict_put_int(dict_longer, "f.o", 1); 256 qdict_put_int(dict_longer, "bar", 2); 257 qdict_put_int(dict_longer, "baz", 3); 258 qdict_put_int(dict_longer, "xyz", 4); 259 qdict_put_null(dict_longer, "null"); 260 261 qdict_put_int(dict_shorter, "f.o", 1); 262 qdict_put_int(dict_shorter, "bar", 2); 263 qdict_put_int(dict_shorter, "baz", 3); 264 265 qdict_put(dict_nested, "f", qdict_new()); 266 qdict_put_int(qdict_get_qdict(dict_nested, "f"), "o", 1); 267 qdict_put_int(dict_nested, "bar", 2); 268 qdict_put_int(dict_nested, "baz", 3); 269 qdict_put_null(dict_nested, "null"); 270 271 dict_cloned = qdict_clone_shallow(dict_0); 272 273 check_equal(dict_0, dict_1, dict_cloned); 274 check_unequal(dict_0, dict_different_key, dict_different_value, 275 dict_different_null_key, dict_longer, dict_shorter, 276 dict_nested); 277 278 dict_crumpled = qobject_to(QDict, qdict_crumple(dict_1, &error_abort)); 279 check_equal(dict_crumpled, dict_nested); 280 281 qdict_flatten(dict_nested); 282 check_equal(dict_0, dict_nested); 283 284 /* Containing an NaN value will make this dict compare unequal to 285 * itself */ 286 qdict_put(dict_0, "NaN", qnum_from_double(NAN)); 287 g_assert(qobject_is_equal(QOBJECT(dict_0), QOBJECT(dict_0)) == false); 288 289 free_all(dict_0, dict_1, dict_cloned, dict_different_key, 290 dict_different_value, dict_different_null_key, dict_longer, 291 dict_shorter, dict_nested, dict_crumpled); 292 } 293 294 static void qobject_is_equal_conversion_test(void) 295 { 296 QNum *u0, *i0, *d0; 297 QString *s0, *s_empty; 298 QBool *bfalse; 299 300 u0 = qnum_from_uint(0u); 301 i0 = qnum_from_int(0); 302 d0 = qnum_from_double(0.0); 303 s0 = qstring_from_str("0"); 304 s_empty = qstring_new(); 305 bfalse = qbool_from_bool(false); 306 307 /* No automatic type conversion */ 308 check_unequal(u0, s0, s_empty, bfalse, qnull(), NULL); 309 check_unequal(i0, s0, s_empty, bfalse, qnull(), NULL); 310 check_unequal(d0, s0, s_empty, bfalse, qnull(), NULL); 311 312 free_all(u0, i0, d0, s0, s_empty, bfalse); 313 } 314 315 int main(int argc, char **argv) 316 { 317 g_test_init(&argc, &argv, NULL); 318 319 g_test_add_func("/public/qobject_is_equal_null", 320 qobject_is_equal_null_test); 321 g_test_add_func("/public/qobject_is_equal_num", qobject_is_equal_num_test); 322 g_test_add_func("/public/qobject_is_equal_bool", 323 qobject_is_equal_bool_test); 324 g_test_add_func("/public/qobject_is_equal_string", 325 qobject_is_equal_string_test); 326 g_test_add_func("/public/qobject_is_equal_list", 327 qobject_is_equal_list_test); 328 g_test_add_func("/public/qobject_is_equal_dict", 329 qobject_is_equal_dict_test); 330 g_test_add_func("/public/qobject_is_equal_conversion", 331 qobject_is_equal_conversion_test); 332 333 return g_test_run(); 334 } 335