tests/check-qobject.c

   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("form", 0, 2);
 159     qstring_append_chr(str_built, 'o');
 160
 161     check_unequal(str_base, str_whitespace_0, str_whitespace_1,
 162                   str_whitespace_2, str_whitespace_3, str_case);
 163
 164     check_equal(str_base, str_built);
 165
 166     free_all(str_base, str_whitespace_0, str_whitespace_1, str_whitespace_2,
 167              str_whitespace_3, str_case, str_built);
 168 }
 169
 170 static void qobject_is_equal_list_test(void)
 171 {
 172     QList *list_0, *list_1, *list_cloned;
 173     QList *list_reordered, *list_longer, *list_shorter;
 174
 175     list_0 = qlist_new();
 176     list_1 = qlist_new();
 177     list_reordered = qlist_new();
 178     list_longer = qlist_new();
 179     list_shorter = qlist_new();
 180
 181     qlist_append_int(list_0, 1);
 182     qlist_append_int(list_0, 2);
 183     qlist_append_int(list_0, 3);
 184
 185     qlist_append_int(list_1, 1);
 186     qlist_append_int(list_1, 2);
 187     qlist_append_int(list_1, 3);
 188
 189     qlist_append_int(list_reordered, 1);
 190     qlist_append_int(list_reordered, 3);
 191     qlist_append_int(list_reordered, 2);
 192
 193     qlist_append_int(list_longer, 1);
 194     qlist_append_int(list_longer, 2);
 195     qlist_append_int(list_longer, 3);
 196     qlist_append_null(list_longer);
 197
 198     qlist_append_int(list_shorter, 1);
 199     qlist_append_int(list_shorter, 2);
 200
 201     list_cloned = qlist_copy(list_0);
 202
 203     check_equal(list_0, list_1, list_cloned);
 204     check_unequal(list_0, list_reordered, list_longer, list_shorter);
 205
 206     /* With a NaN in it, the list should no longer compare equal to
 207      * itself */
 208     qlist_append(list_0, qnum_from_double(NAN));
 209     g_assert(qobject_is_equal(QOBJECT(list_0), QOBJECT(list_0)) == false);
 210
 211     free_all(list_0, list_1, list_cloned, list_reordered, list_longer,
 212              list_shorter);
 213 }
 214
 215 static void qobject_is_equal_dict_test(void)
 216 {
 217     QDict *dict_0, *dict_1, *dict_cloned;
 218     QDict *dict_different_key, *dict_different_value, *dict_different_null_key;
 219     QDict *dict_longer, *dict_shorter, *dict_nested;
 220     QDict *dict_crumpled;
 221
 222     dict_0 = qdict_new();
 223     dict_1 = qdict_new();
 224     dict_different_key = qdict_new();
 225     dict_different_value = qdict_new();
 226     dict_different_null_key = qdict_new();
 227     dict_longer = qdict_new();
 228     dict_shorter = qdict_new();
 229     dict_nested = qdict_new();
 230
 231     qdict_put_int(dict_0, "f.o", 1);
 232     qdict_put_int(dict_0, "bar", 2);
 233     qdict_put_int(dict_0, "baz", 3);
 234     qdict_put_null(dict_0, "null");
 235
 236     qdict_put_int(dict_1, "f.o", 1);
 237     qdict_put_int(dict_1, "bar", 2);
 238     qdict_put_int(dict_1, "baz", 3);
 239     qdict_put_null(dict_1, "null");
 240
 241     qdict_put_int(dict_different_key, "F.o", 1);
 242     qdict_put_int(dict_different_key, "bar", 2);
 243     qdict_put_int(dict_different_key, "baz", 3);
 244     qdict_put_null(dict_different_key, "null");
 245
 246     qdict_put_int(dict_different_value, "f.o", 42);
 247     qdict_put_int(dict_different_value, "bar", 2);
 248     qdict_put_int(dict_different_value, "baz", 3);
 249     qdict_put_null(dict_different_value, "null");
 250
 251     qdict_put_int(dict_different_null_key, "f.o", 1);
 252     qdict_put_int(dict_different_null_key, "bar", 2);
 253     qdict_put_int(dict_different_null_key, "baz", 3);
 254     qdict_put_null(dict_different_null_key, "none");
 255
 256     qdict_put_int(dict_longer, "f.o", 1);
 257     qdict_put_int(dict_longer, "bar", 2);
 258     qdict_put_int(dict_longer, "baz", 3);
 259     qdict_put_int(dict_longer, "xyz", 4);
 260     qdict_put_null(dict_longer, "null");
 261
 262     qdict_put_int(dict_shorter, "f.o", 1);
 263     qdict_put_int(dict_shorter, "bar", 2);
 264     qdict_put_int(dict_shorter, "baz", 3);
 265
 266     qdict_put(dict_nested, "f", qdict_new());
 267     qdict_put_int(qdict_get_qdict(dict_nested, "f"), "o", 1);
 268     qdict_put_int(dict_nested, "bar", 2);
 269     qdict_put_int(dict_nested, "baz", 3);
 270     qdict_put_null(dict_nested, "null");
 271
 272     dict_cloned = qdict_clone_shallow(dict_0);
 273
 274     check_equal(dict_0, dict_1, dict_cloned);
 275     check_unequal(dict_0, dict_different_key, dict_different_value,
 276                   dict_different_null_key, dict_longer, dict_shorter,
 277                   dict_nested);
 278
 279     dict_crumpled = qobject_to(QDict, qdict_crumple(dict_1, &error_abort));
 280     check_equal(dict_crumpled, dict_nested);
 281
 282     qdict_flatten(dict_nested);
 283     check_equal(dict_0, dict_nested);
 284
 285     /* Containing an NaN value will make this dict compare unequal to
 286      * itself */
 287     qdict_put(dict_0, "NaN", qnum_from_double(NAN));
 288     g_assert(qobject_is_equal(QOBJECT(dict_0), QOBJECT(dict_0)) == false);
 289
 290     free_all(dict_0, dict_1, dict_cloned, dict_different_key,
 291              dict_different_value, dict_different_null_key, dict_longer,
 292              dict_shorter, dict_nested, dict_crumpled);
 293 }
 294
 295 static void qobject_is_equal_conversion_test(void)
 296 {
 297     QNum *u0, *i0, *d0;
 298     QString *s0, *s_empty;
 299     QBool *bfalse;
 300
 301     u0 = qnum_from_uint(0u);
 302     i0 = qnum_from_int(0);
 303     d0 = qnum_from_double(0.0);
 304     s0 = qstring_from_str("0");
 305     s_empty = qstring_new();
 306     bfalse = qbool_from_bool(false);
 307
 308     /* No automatic type conversion */
 309     check_unequal(u0, s0, s_empty, bfalse, qnull(), NULL);
 310     check_unequal(i0, s0, s_empty, bfalse, qnull(), NULL);
 311     check_unequal(d0, s0, s_empty, bfalse, qnull(), NULL);
 312
 313     free_all(u0, i0, d0, s0, s_empty, bfalse);
 314 }
 315
 316 int main(int argc, char **argv)
 317 {
 318     g_test_init(&argc, &argv, NULL);
 319
 320     g_test_add_func("/public/qobject_is_equal_null",
 321                     qobject_is_equal_null_test);
 322     g_test_add_func("/public/qobject_is_equal_num", qobject_is_equal_num_test);
 323     g_test_add_func("/public/qobject_is_equal_bool",
 324                     qobject_is_equal_bool_test);
 325     g_test_add_func("/public/qobject_is_equal_string",
 326                     qobject_is_equal_string_test);
 327     g_test_add_func("/public/qobject_is_equal_list",
 328                     qobject_is_equal_list_test);
 329     g_test_add_func("/public/qobject_is_equal_dict",
 330                     qobject_is_equal_dict_test);
 331     g_test_add_func("/public/qobject_is_equal_conversion",
 332                     qobject_is_equal_conversion_test);
 333
 334     return g_test_run();
 335 }