return NULL;
}
- options = qobject_to_qdict(options_obj);
+ options = qobject_to(QDict, options_obj);
if (!options) {
qobject_decref(options_obj);
error_setg(errp, "Invalid JSON object given");
}
visit_complete(v, &obj);
- qdict = qobject_to_qdict(obj);
+ qdict = qobject_to(QDict, obj);
qdict_flatten(qdict);
/* bdrv_open_inherit() defaults to the values in bdrv_flags (for
qobj = qdict_crumple(qdict, errp);
QDECREF(qdict);
- qdict = qobject_to_qdict(qobj);
+ qdict = qobject_to(QDict, qobj);
if (qdict == NULL) {
ret = -EINVAL;
goto done;
{
switch (qobject_type(obj)) {
case QTYPE_QNUM: {
- QNum *value = qobject_to_qnum(obj);
+ QNum *value = qobject_to(QNum, obj);
char *tmp = qnum_to_string(value);
func_fprintf(f, "%s", tmp);
g_free(tmp);
break;
}
case QTYPE_QSTRING: {
- QString *value = qobject_to_qstring(obj);
+ QString *value = qobject_to(QString, obj);
func_fprintf(f, "%s", qstring_get_str(value));
break;
}
case QTYPE_QDICT: {
- QDict *value = qobject_to_qdict(obj);
+ QDict *value = qobject_to(QDict, obj);
dump_qdict(func_fprintf, f, comp_indent, value);
break;
}
case QTYPE_QLIST: {
- QList *value = qobject_to_qlist(obj);
+ QList *value = qobject_to(QList, obj);
dump_qlist(func_fprintf, f, comp_indent, value);
break;
}
case QTYPE_QBOOL: {
- QBool *value = qobject_to_qbool(obj);
+ QBool *value = qobject_to(QBool, obj);
func_fprintf(f, "%s", qbool_get_bool(value) ? "true" : "false");
break;
}
visit_type_ImageInfoSpecific(v, NULL, &info_spec, &error_abort);
visit_complete(v, &obj);
- data = qdict_get(qobject_to_qdict(obj), "data");
+ data = qdict_get(qobject_to(QDict, obj), "data");
dump_qobject(func_fprintf, f, 1, data);
qobject_decref(obj);
visit_free(v);
qobj = qdict_crumple(qdict, errp);
QDECREF(qdict);
- qdict = qobject_to_qdict(qobj);
+ qdict = qobject_to(QDict, qobj);
if (qdict == NULL) {
ret = -EINVAL;
goto fail;
/* Now get the QAPI type BlockdevCreateOptions */
qobj = qdict_crumple(qdict, errp);
QDECREF(qdict);
- qdict = qobject_to_qdict(qobj);
+ qdict = qobject_to(QDict, qobj);
if (qdict == NULL) {
ret = -EINVAL;
goto finish;
qobj = qdict_crumple(qdict, errp);
QDECREF(qdict);
- qdict = qobject_to_qdict(qobj);
+ qdict = qobject_to(QDict, qobj);
if (qdict == NULL) {
ret = -EINVAL;
goto fail;
if (!keypairs_json) {
return ret;
}
- keypairs = qobject_to_qlist(qobject_from_json(keypairs_json,
- &error_abort));
+ keypairs = qobject_to(QList,
+ qobject_from_json(keypairs_json, &error_abort));
remaining = qlist_size(keypairs) / 2;
assert(remaining);
while (remaining--) {
- name = qobject_to_qstring(qlist_pop(keypairs));
- value = qobject_to_qstring(qlist_pop(keypairs));
+ name = qobject_to(QString, qlist_pop(keypairs));
+ value = qobject_to(QString, qlist_pop(keypairs));
assert(name && value);
key = qstring_get_str(name);
return -EINVAL;
}
- qdict = qobject_to_qdict(obj);
+ qdict = qobject_to(QDict, obj);
qdict_flatten(qdict);
qdict_put_str(qdict, "driver", "sheepdog");
qobj = qdict_crumple(qdict, errp);
QDECREF(qdict);
- qdict = qobject_to_qdict(qobj);
+ qdict = qobject_to(QDict, qobj);
if (qdict == NULL) {
ret = -EINVAL;
goto fail;
qobj = qdict_crumple(qdict, errp);
QDECREF(qdict);
- qdict = qobject_to_qdict(qobj);
+ qdict = qobject_to(QDict, qobj);
if (qdict == NULL) {
ret = -EINVAL;
goto fail;
case QTYPE_QSTRING: {
unsigned long long length;
- const char *str = qstring_get_str(qobject_to_qstring(entry->value));
+ const char *str = qstring_get_str(qobject_to(QString,
+ entry->value));
if (parse_uint_full(str, &length, 10) == 0 &&
length > 0 && length <= UINT_MAX) {
block_acct_add_interval(stats, (unsigned) length);
}
case QTYPE_QNUM: {
- int64_t length = qnum_get_int(qobject_to_qnum(entry->value));
+ int64_t length = qnum_get_int(qobject_to(QNum, entry->value));
if (length > 0 && length <= UINT_MAX) {
block_acct_add_interval(stats, (unsigned) length);
}
visit_complete(v, &obj);
- qdict = qobject_to_qdict(obj);
+ qdict = qobject_to(QDict, obj);
qdict_flatten(qdict);
/* Fill in optional s3/s4 related properties */
o = object_property_get_qobject(obj, ACPI_PM_PROP_S3_DISABLED, NULL);
if (o) {
- pm->s3_disabled = qnum_get_uint(qobject_to_qnum(o));
+ pm->s3_disabled = qnum_get_uint(qobject_to(QNum, o));
} else {
pm->s3_disabled = false;
}
qobject_decref(o);
o = object_property_get_qobject(obj, ACPI_PM_PROP_S4_DISABLED, NULL);
if (o) {
- pm->s4_disabled = qnum_get_uint(qobject_to_qnum(o));
+ pm->s4_disabled = qnum_get_uint(qobject_to(QNum, o));
} else {
pm->s4_disabled = false;
}
qobject_decref(o);
o = object_property_get_qobject(obj, ACPI_PM_PROP_S4_VAL, NULL);
if (o) {
- pm->s4_val = qnum_get_uint(qobject_to_qnum(o));
+ pm->s4_val = qnum_get_uint(qobject_to(QNum, o));
} else {
pm->s4_val = false;
}
static void build_append_pci_bus_devices(Aml *parent_scope, PCIBus *bus,
bool pcihp_bridge_en)
{
- Aml *dev, *notify_method, *method;
+ Aml *dev, *notify_method = NULL, *method;
QObject *bsel;
PCIBus *sec;
int i;
bsel = object_property_get_qobject(OBJECT(bus), ACPI_PCIHP_PROP_BSEL, NULL);
if (bsel) {
- uint64_t bsel_val = qnum_get_uint(qobject_to_qnum(bsel));
+ uint64_t bsel_val = qnum_get_uint(qobject_to(QNum, bsel));
aml_append(parent_scope, aml_name_decl("BSEL", aml_int(bsel_val)));
notify_method = aml_method("DVNT", 2, AML_NOTSERIALIZED);
/* If bus supports hotplug select it and notify about local events */
if (bsel) {
- uint64_t bsel_val = qnum_get_uint(qobject_to_qnum(bsel));
+ uint64_t bsel_val = qnum_get_uint(qobject_to(QNum, bsel));
aml_append(method, aml_store(aml_int(bsel_val), aml_name("BNUM")));
aml_append(method,
if (!o) {
return false;
}
- mcfg->mcfg_base = qnum_get_uint(qobject_to_qnum(o));
+ mcfg->mcfg_base = qnum_get_uint(qobject_to(QNum, o));
qobject_decref(o);
o = object_property_get_qobject(pci_host, PCIE_HOST_MCFG_SIZE, NULL);
assert(o);
- mcfg->mcfg_size = qnum_get_uint(qobject_to_qnum(o));
+ mcfg->mcfg_size = qnum_get_uint(qobject_to(QNum, o));
qobject_decref(o);
return true;
}
/* Unthrottled event */
monitor_qapi_event_emit(event, qdict);
} else {
- QDict *data = qobject_to_qdict(qdict_get(qdict, "data"));
+ QDict *data = qobject_to(QDict, qdict_get(qdict, "data"));
MonitorQAPIEventState key = { .event = event, .data = data };
evstate = g_hash_table_lookup(monitor_qapi_event_state, &key);
goto err_out;
}
- qdict = qobject_to_qdict(req);
+ qdict = qobject_to(QDict, req);
if (qdict) {
id = qdict_get(qdict, "id");
qobject_incref(id);
rsp = qmp_dispatch(cur_mon->qmp.commands, req);
if (mon->qmp.commands == &qmp_cap_negotiation_commands) {
- qdict = qdict_get_qdict(qobject_to_qdict(rsp), "error");
+ qdict = qdict_get_qdict(qobject_to(QDict, rsp), "error");
if (qdict
&& !g_strcmp0(qdict_get_try_str(qdict, "class"),
QapiErrorClass_str(ERROR_CLASS_COMMAND_NOT_FOUND))) {
if (rsp) {
if (id) {
- qdict_put_obj(qobject_to_qdict(rsp), "id", id);
+ qdict_put_obj(qobject_to(QDict, rsp), "id", id);
id = NULL;
}
bool has_exec_key = false;
QDict *dict = NULL;
- dict = qobject_to_qdict(request);
+ dict = qobject_to(QDict, request);
if (!dict) {
error_setg(errp, "QMP input must be a JSON object");
return NULL;
if (qobject_type(qobj) == QTYPE_QDICT) {
assert(name);
- ret = qdict_get(qobject_to_qdict(qobj), name);
+ ret = qdict_get(qobject_to(QDict, qobj), name);
if (tos->h && consume && ret) {
bool removed = g_hash_table_remove(tos->h, name);
assert(removed);
return NULL;
}
- qstr = qobject_to_qstring(qobj);
+ qstr = qobject_to(QString, qobj);
if (!qstr) {
switch (qobject_type(qobj)) {
case QTYPE_QDICT:
if (qobject_type(obj) == QTYPE_QDICT) {
h = g_hash_table_new(g_str_hash, g_str_equal);
- qdict_iter(qobject_to_qdict(obj), qdict_add_key, h);
+ qdict_iter(qobject_to(QDict, obj), qdict_add_key, h);
tos->h = h;
} else {
assert(qobject_type(obj) == QTYPE_QLIST);
- tos->entry = qlist_first(qobject_to_qlist(obj));
+ tos->entry = qlist_first(qobject_to(QList, obj));
tos->index = -1;
}
if (!qobj) {
return;
}
- qnum = qobject_to_qnum(qobj);
+ qnum = qobject_to(QNum, qobj);
if (!qnum || !qnum_get_try_int(qnum, obj)) {
error_setg(errp, QERR_INVALID_PARAMETER_TYPE,
full_name(qiv, name), "integer");
if (!qobj) {
return;
}
- qnum = qobject_to_qnum(qobj);
+ qnum = qobject_to(QNum, qobj);
if (!qnum) {
goto err;
}
if (!qobj) {
return;
}
- qbool = qobject_to_qbool(qobj);
+ qbool = qobject_to(QBool, qobj);
if (!qbool) {
error_setg(errp, QERR_INVALID_PARAMETER_TYPE,
full_name(qiv, name), "boolean");
if (!qobj) {
return;
}
- qstr = qobject_to_qstring(qobj);
+ qstr = qobject_to(QString, qobj);
if (!qstr) {
error_setg(errp, QERR_INVALID_PARAMETER_TYPE,
full_name(qiv, name), "string");
if (!qobj) {
return;
}
- qnum = qobject_to_qnum(qobj);
+ qnum = qobject_to(QNum, qobj);
if (!qnum) {
error_setg(errp, QERR_INVALID_PARAMETER_TYPE,
full_name(qiv, name), "number");
}
return NULL;
}
- args = qobject_to_qdict(obj);
+ args = qobject_to(QDict, obj);
assert(args);
v = qobject_input_visitor_new(QOBJECT(args));
} else {
switch (qobject_type(cur)) {
case QTYPE_QDICT:
assert(name);
- qdict_put_obj(qobject_to_qdict(cur), name, value);
+ qdict_put_obj(qobject_to(QDict, cur), name, value);
break;
case QTYPE_QLIST:
assert(!name);
- qlist_append_obj(qobject_to_qlist(cur), value);
+ qlist_append_obj(qobject_to(QList, cur), value);
break;
default:
g_assert_not_reached();
g_assert(s && parser);
g_debug("process_event: called");
- qdict = qobject_to_qdict(json_parser_parse_err(tokens, NULL, &err));
+ qdict = qobject_to(QDict, json_parser_parse_err(tokens, NULL, &err));
if (err || !qdict) {
QDECREF(qdict);
qdict = qdict_new();
Object *obj;
if (props) {
- pdict = qobject_to_qdict(props);
+ pdict = qobject_to(QDict, props);
if (!pdict) {
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, "props", "dict");
return;
goto out;
}
- qdict_put_obj(dict, qstring_get_str(qobject_to_qstring(key)), value);
+ qdict_put_obj(dict, qstring_get_str(qobject_to(QString, key)), value);
qobject_decref(key);
*/
bool qbool_is_equal(const QObject *x, const QObject *y)
{
- return qobject_to_qbool(x)->value == qobject_to_qbool(y)->value;
+ return qobject_to(QBool, x)->value == qobject_to(QBool, y)->value;
}
/**
void qbool_destroy_obj(QObject *obj)
{
assert(obj != NULL);
- g_free(qobject_to_qbool(obj));
+ g_free(qobject_to(QBool, obj));
}
*/
double qdict_get_double(const QDict *qdict, const char *key)
{
- return qnum_get_double(qobject_to_qnum(qdict_get(qdict, key)));
+ return qnum_get_double(qobject_to(QNum, qdict_get(qdict, key)));
}
/**
*/
int64_t qdict_get_int(const QDict *qdict, const char *key)
{
- return qnum_get_int(qobject_to_qnum(qdict_get(qdict, key)));
+ return qnum_get_int(qobject_to(QNum, qdict_get(qdict, key)));
}
/**
*/
bool qdict_get_bool(const QDict *qdict, const char *key)
{
- return qbool_get_bool(qobject_to_qbool(qdict_get(qdict, key)));
+ return qbool_get_bool(qobject_to(QBool, qdict_get(qdict, key)));
}
/**
*/
QList *qdict_get_qlist(const QDict *qdict, const char *key)
{
- return qobject_to_qlist(qdict_get(qdict, key));
+ return qobject_to(QList, qdict_get(qdict, key));
}
/**
*/
QDict *qdict_get_qdict(const QDict *qdict, const char *key)
{
- return qobject_to_qdict(qdict_get(qdict, key));
+ return qobject_to(QDict, qdict_get(qdict, key));
}
/**
*/
const char *qdict_get_str(const QDict *qdict, const char *key)
{
- return qstring_get_str(qobject_to_qstring(qdict_get(qdict, key)));
+ return qstring_get_str(qobject_to(QString, qdict_get(qdict, key)));
}
/**
int64_t qdict_get_try_int(const QDict *qdict, const char *key,
int64_t def_value)
{
- QNum *qnum = qobject_to_qnum(qdict_get(qdict, key));
+ QNum *qnum = qobject_to(QNum, qdict_get(qdict, key));
int64_t val;
if (!qnum || !qnum_get_try_int(qnum, &val)) {
*/
bool qdict_get_try_bool(const QDict *qdict, const char *key, bool def_value)
{
- QBool *qbool = qobject_to_qbool(qdict_get(qdict, key));
+ QBool *qbool = qobject_to(QBool, qdict_get(qdict, key));
return qbool ? qbool_get_bool(qbool) : def_value;
}
*/
const char *qdict_get_try_str(const QDict *qdict, const char *key)
{
- QString *qstr = qobject_to_qstring(qdict_get(qdict, key));
+ QString *qstr = qobject_to(QString, qdict_get(qdict, key));
return qstr ? qstring_get_str(qstr) : NULL;
}
*/
bool qdict_is_equal(const QObject *x, const QObject *y)
{
- const QDict *dict_x = qobject_to_qdict(x);
- const QDict *dict_y = qobject_to_qdict(y);
+ const QDict *dict_x = qobject_to(QDict, x);
+ const QDict *dict_y = qobject_to(QDict, y);
const QDictEntry *e;
if (qdict_size(dict_x) != qdict_size(dict_y)) {
QDict *qdict;
assert(obj != NULL);
- qdict = qobject_to_qdict(obj);
+ qdict = qobject_to(QDict, obj);
for (i = 0; i < QDICT_BUCKET_MAX; i++) {
QDictEntry *entry = QLIST_FIRST(&qdict->table[i]);
new_key = g_strdup_printf("%s.%i", prefix, i);
if (qobject_type(value) == QTYPE_QDICT) {
- qdict_flatten_qdict(qobject_to_qdict(value), target, new_key);
+ qdict_flatten_qdict(qobject_to(QDict, value), target, new_key);
} else if (qobject_type(value) == QTYPE_QLIST) {
- qdict_flatten_qlist(qobject_to_qlist(value), target, new_key);
+ qdict_flatten_qlist(qobject_to(QList, value), target, new_key);
} else {
/* All other types are moved to the target unchanged. */
qobject_incref(value);
if (qobject_type(value) == QTYPE_QDICT) {
/* Entries of QDicts are processed recursively, the QDict object
* itself disappears. */
- qdict_flatten_qdict(qobject_to_qdict(value), target,
+ qdict_flatten_qdict(qobject_to(QDict, value), target,
new_key ? new_key : entry->key);
delete = true;
} else if (qobject_type(value) == QTYPE_QLIST) {
- qdict_flatten_qlist(qobject_to_qlist(value), target,
+ qdict_flatten_qlist(qobject_to(QList, value), target,
new_key ? new_key : entry->key);
delete = true;
} else if (prefix) {
qdict_put_obj(two_level, prefix, child);
}
qobject_incref(ent->value);
- qdict_put_obj(qobject_to_qdict(child), suffix, ent->value);
+ qdict_put_obj(qobject_to(QDict, child), suffix, ent->value);
} else {
if (child) {
error_setg(errp, "Key %s prefix is already set as a dict",
ent = qdict_next(two_level, ent)) {
if (qobject_type(ent->value) == QTYPE_QDICT) {
- child = qdict_crumple(qobject_to_qdict(ent->value), errp);
+ child = qdict_crumple(qobject_to(QDict, ent->value), errp);
if (!child) {
goto error;
}
}
qobject_incref(child);
- qlist_append_obj(qobject_to_qlist(dst), child);
+ qlist_append_obj(qobject_to(QList, dst), child);
}
QDECREF(multi_level);
multi_level = NULL;
qstring_append(str, "null");
break;
case QTYPE_QNUM: {
- QNum *val = qobject_to_qnum(obj);
+ QNum *val = qobject_to(QNum, obj);
char *buffer = qnum_to_string(val);
qstring_append(str, buffer);
g_free(buffer);
break;
}
case QTYPE_QSTRING: {
- QString *val = qobject_to_qstring(obj);
+ QString *val = qobject_to(QString, obj);
const char *ptr;
int cp;
char buf[16];
}
case QTYPE_QDICT: {
ToJsonIterState s;
- QDict *val = qobject_to_qdict(obj);
+ QDict *val = qobject_to(QDict, obj);
s.count = 0;
s.str = str;
}
case QTYPE_QLIST: {
ToJsonIterState s;
- QList *val = qobject_to_qlist(obj);
+ QList *val = qobject_to(QList, obj);
s.count = 0;
s.str = str;
break;
}
case QTYPE_QBOOL: {
- QBool *val = qobject_to_qbool(obj);
+ QBool *val = qobject_to(QBool, obj);
if (qbool_get_bool(val)) {
qstring_append(str, "true");
*/
bool qlist_is_equal(const QObject *x, const QObject *y)
{
- const QList *list_x = qobject_to_qlist(x);
- const QList *list_y = qobject_to_qlist(y);
+ const QList *list_x = qobject_to(QList, x);
+ const QList *list_y = qobject_to(QList, y);
const QListEntry *entry_x, *entry_y;
entry_x = qlist_first(list_x);
QListEntry *entry, *next_entry;
assert(obj != NULL);
- qlist = qobject_to_qlist(obj);
+ qlist = qobject_to(QList, obj);
QTAILQ_FOREACH_SAFE(entry, &qlist->head, next, next_entry) {
QTAILQ_REMOVE(&qlist->head, entry, next);
switch (lhs->type) {
case QTYPE_QBOOL:
- return lhs->value.qbool == qbool_get_bool(qobject_to_qbool(rhs));
+ return lhs->value.qbool == qbool_get_bool(qobject_to(QBool, rhs));
case QTYPE_QNUM:
- return lhs->value.qnum == qnum_get_int(qobject_to_qnum(rhs));
+ return lhs->value.qnum == qnum_get_int(qobject_to(QNum, rhs));
case QTYPE_QSTRING:
return (strcmp(lhs->value.qstr,
- qstring_get_str(qobject_to_qstring(rhs))) == 0);
+ qstring_get_str(qobject_to(QString, rhs))) == 0);
case QTYPE_QDICT:
- return qlit_equal_qdict(lhs, qobject_to_qdict(rhs));
+ return qlit_equal_qdict(lhs, qobject_to(QDict, rhs));
case QTYPE_QLIST:
- return qlit_equal_qlist(lhs, qobject_to_qlist(rhs));
+ return qlit_equal_qlist(lhs, qobject_to(QList, rhs));
case QTYPE_QNULL:
return true;
default:
*/
bool qnum_is_equal(const QObject *x, const QObject *y)
{
- QNum *num_x = qobject_to_qnum(x);
- QNum *num_y = qobject_to_qnum(y);
+ QNum *num_x = qobject_to(QNum, x);
+ QNum *num_y = qobject_to(QNum, y);
switch (num_x->kind) {
case QNUM_I64:
void qnum_destroy_obj(QObject *obj)
{
assert(obj != NULL);
- g_free(qobject_to_qnum(obj));
+ g_free(qobject_to(QNum, obj));
}
*/
bool qstring_is_equal(const QObject *x, const QObject *y)
{
- return !strcmp(qobject_to_qstring(x)->string,
- qobject_to_qstring(y)->string);
+ return !strcmp(qobject_to(QString, x)->string,
+ qobject_to(QString, y)->string);
}
/**
QString *qs;
assert(obj != NULL);
- qs = qobject_to_qstring(obj);
+ qs = qobject_to(QString, obj);
g_free(qs->string);
g_free(qs);
}
if (!ret) {
return NULL;
}
- qstring = qobject_to_qstring(ret);
+ qstring = qobject_to(QString, ret);
if (!qstring) {
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name, "string");
retval = NULL;
if (!ret) {
return false;
}
- qbool = qobject_to_qbool(ret);
+ qbool = qobject_to(QBool, ret);
if (!qbool) {
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name, "boolean");
retval = false;
return -1;
}
- qnum = qobject_to_qnum(ret);
+ qnum = qobject_to(QNum, ret);
if (!qnum || !qnum_get_try_int(qnum, &retval)) {
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name, "int");
retval = -1;
if (!ret) {
return 0;
}
- qnum = qobject_to_qnum(ret);
+ qnum = qobject_to(QNum, ret);
if (!qnum || !qnum_get_try_uint(qnum, &retval)) {
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name, "uint");
retval = 0;
xc = x86_cpu_from_model(model->name,
model->has_props ?
- qobject_to_qdict(model->props) :
+ qobject_to(QDict, model->props) :
NULL, &err);
if (err) {
goto out;
Object *obj;
if (info->props) {
- qdict = qobject_to_qdict(info->props);
+ qdict = qobject_to(QDict, info->props);
if (!qdict) {
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, "props", "dict");
return;
g_assert(qdict_size(qdict) == 1);
ent = QLIST_FIRST(&qdict->table[12345 % QDICT_BUCKET_MAX]);
- qn = qobject_to_qnum(ent->value);
+ qn = qobject_to(QNum, ent->value);
g_assert_cmpint(qnum_get_int(qn), ==, num);
QDECREF(qdict);
obj = qdict_get(tests_dict, key);
g_assert(obj != NULL);
- qn = qobject_to_qnum(obj);
+ qn = qobject_to(QNum, obj);
g_assert_cmpint(qnum_get_int(qn), ==, value);
QDECREF(tests_dict);
static void qobject_to_qdict_test(void)
{
QDict *tests_dict = qdict_new();
- g_assert(qobject_to_qdict(QOBJECT(tests_dict)) == tests_dict);
+ g_assert(qobject_to(QDict, QOBJECT(tests_dict)) == tests_dict);
QDECREF(tests_dict);
}
qdict_array_split(test_dict, &test_list);
- dict1 = qobject_to_qdict(qlist_pop(test_list));
- dict2 = qobject_to_qdict(qlist_pop(test_list));
- int1 = qobject_to_qnum(qlist_pop(test_list));
+ dict1 = qobject_to(QDict, qlist_pop(test_list));
+ dict2 = qobject_to(QDict, qlist_pop(test_list));
+ int1 = qobject_to(QNum, qlist_pop(test_list));
g_assert(dict1);
g_assert(dict2);
qdict_array_split(test_dict, &test_list);
- int1 = qobject_to_qnum(qlist_pop(test_list));
+ int1 = qobject_to(QNum, qlist_pop(test_list));
g_assert(int1);
g_assert(qlist_empty(test_list));
qdict_put_str(src, "vnc.acl..name", "acl0");
qdict_put_str(src, "vnc.acl.rule..name", "acl0");
- dst = qobject_to_qdict(qdict_crumple(src, &error_abort));
+ dst = qobject_to(QDict, qdict_crumple(src, &error_abort));
g_assert(dst);
g_assert_cmpint(qdict_size(dst), ==, 1);
g_assert(rules);
g_assert_cmpint(qlist_size(rules), ==, 2);
- rule = qobject_to_qdict(qlist_pop(rules));
+ rule = qobject_to(QDict, qlist_pop(rules));
g_assert(rule);
g_assert_cmpint(qdict_size(rule), ==, 2);
g_assert_cmpstr("fred", ==, qdict_get_str(rule, "match"));
g_assert_cmpstr("allow", ==, qdict_get_str(rule, "policy"));
QDECREF(rule);
- rule = qobject_to_qdict(qlist_pop(rules));
+ rule = qobject_to(QDict, qlist_pop(rules));
g_assert(rule);
g_assert_cmpint(qdict_size(rule), ==, 2);
g_assert_cmpstr("bob", ==, qdict_get_str(rule, "match"));
QString *str;
obj = qobject_from_json(test_cases[i].encoded, &error_abort);
- str = qobject_to_qstring(obj);
+ str = qobject_to(QString, obj);
g_assert(str);
g_assert_cmpstr(qstring_get_str(str), ==, test_cases[i].decoded);
QString *str;
obj = qobject_from_json(test_cases[i].encoded, &error_abort);
- str = qobject_to_qstring(obj);
+ str = qobject_to(QString, obj);
g_assert(str);
g_assert(strcmp(qstring_get_str(str), test_cases[i].decoded) == 0);
QString *str;
obj = qobject_from_json(test_cases[i].encoded, &error_abort);
- str = qobject_to_qstring(obj);
+ str = qobject_to(QString, obj);
g_assert(str);
g_assert(strcmp(qstring_get_str(str), test_cases[i].decoded) == 0);
obj = qobject_from_json(json_in, utf8_out ? &error_abort : NULL);
if (utf8_out) {
- str = qobject_to_qstring(obj);
+ str = qobject_to(QString, obj);
g_assert(str);
g_assert_cmpstr(qstring_get_str(str), ==, utf8_out);
} else {
*/
if (0 && json_out != json_in) {
obj = qobject_from_json(json_out, &error_abort);
- str = qobject_to_qstring(obj);
+ str = qobject_to(QString, obj);
g_assert(str);
g_assert_cmpstr(qstring_get_str(str), ==, utf8_out);
}
for (i = 0; test_cases[i].decoded; i++) {
QString *str;
- str = qobject_to_qstring(qobject_from_jsonf("%s",
- test_cases[i].decoded));
+ str = qobject_to(QString,
+ qobject_from_jsonf("%s", test_cases[i].decoded));
g_assert(str);
g_assert(strcmp(qstring_get_str(str), test_cases[i].decoded) == 0);
QNum *qnum;
int64_t val;
- qnum = qobject_to_qnum(qobject_from_json(test_cases[i].encoded,
- &error_abort));
+ qnum = qobject_to(QNum,
+ qobject_from_json(test_cases[i].encoded,
+ &error_abort));
g_assert(qnum);
g_assert(qnum_get_try_int(qnum, &val));
g_assert_cmpint(val, ==, test_cases[i].decoded);
uint64_t val;
int64_t ival;
- qnum = qobject_to_qnum(qobject_from_json(maxu64, &error_abort));
+ qnum = qobject_to(QNum, qobject_from_json(maxu64, &error_abort));
g_assert(qnum);
g_assert_cmpuint(qnum_get_uint(qnum), ==, 18446744073709551615U);
g_assert(!qnum_get_try_int(qnum, &ival));
QDECREF(str);
QDECREF(qnum);
- qnum = qobject_to_qnum(qobject_from_json(gtu64, &error_abort));
+ qnum = qobject_to(QNum, qobject_from_json(gtu64, &error_abort));
g_assert(qnum);
g_assert_cmpfloat(qnum_get_double(qnum), ==, 18446744073709552e3);
g_assert(!qnum_get_try_uint(qnum, &val));
QDECREF(str);
QDECREF(qnum);
- qnum = qobject_to_qnum(qobject_from_json(lti64, &error_abort));
+ qnum = qobject_to(QNum, qobject_from_json(lti64, &error_abort));
g_assert(qnum);
g_assert_cmpfloat(qnum_get_double(qnum), ==, -92233720368547758e2);
g_assert(!qnum_get_try_uint(qnum, &val));
QNum *qnum;
obj = qobject_from_json(test_cases[i].encoded, &error_abort);
- qnum = qobject_to_qnum(obj);
+ qnum = qobject_to(QNum, obj);
g_assert(qnum);
g_assert(qnum_get_double(qnum) == test_cases[i].decoded);
double valuef = 2.323423423;
int64_t val;
- qnum = qobject_to_qnum(qobject_from_jsonf("%d", value));
+ qnum = qobject_to(QNum, qobject_from_jsonf("%d", value));
g_assert(qnum_get_try_int(qnum, &val));
g_assert_cmpint(val, ==, value);
QDECREF(qnum);
- qnum = qobject_to_qnum(qobject_from_jsonf("%lld", value_ll));
+ qnum = qobject_to(QNum, qobject_from_jsonf("%lld", value_ll));
g_assert(qnum_get_try_int(qnum, &val));
g_assert_cmpint(val, ==, value_ll);
QDECREF(qnum);
- qnum = qobject_to_qnum(qobject_from_jsonf("%f", valuef));
+ qnum = qobject_to(QNum, qobject_from_jsonf("%f", valuef));
g_assert(qnum_get_double(qnum) == valuef);
QDECREF(qnum);
}
QString *str;
obj = qobject_from_json("true", &error_abort);
- qbool = qobject_to_qbool(obj);
+ qbool = qobject_to(QBool, obj);
g_assert(qbool);
g_assert(qbool_get_bool(qbool) == true);
QDECREF(qbool);
obj = qobject_from_json("false", &error_abort);
- qbool = qobject_to_qbool(obj);
+ qbool = qobject_to(QBool, obj);
g_assert(qbool);
g_assert(qbool_get_bool(qbool) == false);
QDECREF(qbool);
- qbool = qobject_to_qbool(qobject_from_jsonf("%i", false));
+ qbool = qobject_to(QBool, qobject_from_jsonf("%i", false));
g_assert(qbool);
g_assert(qbool_get_bool(qbool) == false);
QDECREF(qbool);
/* Test that non-zero values other than 1 get collapsed to true */
- qbool = qobject_to_qbool(qobject_from_jsonf("%i", 2));
+ qbool = qobject_to(QBool, qobject_from_jsonf("%i", 2));
g_assert(qbool);
g_assert(qbool_get_bool(qbool) == true);
QDECREF(qbool);
qlist = qlist_new();
- g_assert(qobject_to_qlist(QOBJECT(qlist)) == qlist);
+ g_assert(qobject_to(QList, QOBJECT(qlist)) == qlist);
QDECREF(qlist);
}
g_assert(opaque == NULL);
- qi = qobject_to_qnum(obj);
+ qi = qobject_to(QNum, obj);
g_assert(qi != NULL);
g_assert(qnum_get_try_int(qi, &val));
g_assert(!qlit_equal_qobject(&qlit_foo, qobj));
- qdict_put(qobject_to_qdict(qobj), "bee", qlist_new());
+ qdict_put(qobject_to(QDict, qobj), "bee", qlist_new());
g_assert(!qlit_equal_qobject(&qlit, qobj));
qobject_decref(qobj);
QDict *qdict;
QList *bee;
- qdict = qobject_to_qdict(qobj);
+ qdict = qobject_to(QDict, qobj);
g_assert_cmpint(qdict_get_int(qdict, "foo"), ==, 42);
g_assert_cmpstr(qdict_get_str(qdict, "bar"), ==, "hello world");
g_assert(qobject_type(qdict_get(qdict, "baz")) == QTYPE_QNULL);
bee = qdict_get_qlist(qdict, "bee");
obj = qlist_pop(bee);
- g_assert_cmpint(qnum_get_int(qobject_to_qnum(obj)), ==, 43);
+ g_assert_cmpint(qnum_get_int(qobject_to(QNum, obj)), ==, 43);
qobject_decref(obj);
obj = qlist_pop(bee);
- g_assert_cmpint(qnum_get_int(qobject_to_qnum(obj)), ==, 44);
+ g_assert_cmpint(qnum_get_int(qobject_to(QNum, obj)), ==, 44);
qobject_decref(obj);
obj = qlist_pop(bee);
- g_assert(qbool_get_bool(qobject_to_qbool(obj)));
+ g_assert(qbool_get_bool(qobject_to(QBool, obj)));
qobject_decref(obj);
qobject_decref(qobj);
QNum *qn;
qn = qnum_from_int(0);
- g_assert(qobject_to_qnum(QOBJECT(qn)) == qn);
+ g_assert(qobject_to(QNum, QOBJECT(qn)) == qn);
QDECREF(qn);
qn = qnum_from_double(0);
- g_assert(qobject_to_qnum(QOBJECT(qn)) == qn);
+ g_assert(qobject_to(QNum, QOBJECT(qn)) == qn);
QDECREF(qn);
}
dict_different_null_key, dict_longer, dict_shorter,
dict_nested);
- dict_crumpled = qobject_to_qdict(qdict_crumple(dict_1, &local_err));
+ dict_crumpled = qobject_to(QDict, qdict_crumple(dict_1, &local_err));
g_assert(!local_err);
check_equal(dict_crumpled, dict_nested);
QString *qstring;
qstring = qstring_from_str("foo");
- g_assert(qobject_to_qstring(QOBJECT(qstring)) == qstring);
+ g_assert(qobject_to(QString, QOBJECT(qstring)) == qstring);
QDECREF(qstring);
}
QListEntry *e;
QLIST_FOREACH_ENTRY(types, e) {
- QDict *d = qobject_to_qdict(qlist_entry_obj(e));
+ QDict *d = qobject_to(QDict, qlist_entry_obj(e));
const char *name = qdict_get_str(d, "name");
QINCREF(d);
qdict_put(index, name, d);
QListEntry *e;
QLIST_FOREACH_ENTRY(types, e) {
- QDict *d = qobject_to_qdict(qlist_entry_obj(e));
+ QDict *d = qobject_to(QDict, qlist_entry_obj(e));
const char *ename = qdict_get_str(d, "name");
if (!strcmp(ename, name)) {
return d;
index = qom_type_index(types);
QLIST_FOREACH_ENTRY(types, e) {
- QDict *d = qobject_to_qdict(qlist_entry_obj(e));
+ QDict *d = qobject_to(QDict, qlist_entry_obj(e));
const char *name = qdict_get_str(d, "name");
g_assert(qom_has_parent(index, name, parent));
non_abstract = qom_list_types(NULL, false);
QLIST_FOREACH_ENTRY(all_types, e) {
- QDict *d = qobject_to_qdict(qlist_entry_obj(e));
+ QDict *d = qobject_to(QDict, qlist_entry_obj(e));
const char *name = qdict_get_str(d, "name");
bool abstract = qdict_haskey(d, "abstract") ?
qdict_get_bool(d, "abstract") :
types = device_type_list(false);
QLIST_FOREACH_ENTRY(types, entry) {
- type = qdict_get_try_str(qobject_to_qdict(qlist_entry_obj(entry)),
- "name");
+ type = qdict_get_try_str(qobject_to(QDict, qlist_entry_obj(entry)),
+ "name");
g_assert(type);
test_one_device(type);
}
index = qom_type_index(all_types);
QLIST_FOREACH_ENTRY(all_types, e) {
- QDict *d = qobject_to_qdict(qlist_entry_obj(e));
+ QDict *d = qobject_to(QDict, qlist_entry_obj(e));
const char *name = qdict_get_str(d, "name");
/*
}
g_assert(!qmp->response);
- qmp->response = qobject_to_qdict(obj);
+ qmp->response = qobject_to(QDict, obj);
g_assert(qmp->response);
}
g_assert(list);
for (p = qlist_first(list); p; p = qlist_next(p)) {
- minfo = qobject_to_qdict(qlist_entry_obj(p));
+ minfo = qobject_to(QDict, qlist_entry_obj(p));
g_assert(minfo);
qobj = qdict_get(minfo, "name");
g_assert(qobj);
- qstr = qobject_to_qstring(qobj);
+ qstr = qobject_to(QString, qobj);
g_assert(qstr);
mname = qstring_get_str(qstr);
cb(mname);
QDict *cpu, *props;
int64_t cpu_idx, node;
- cpu = qobject_to_qdict(e);
+ cpu = qobject_to(QDict, e);
g_assert(qdict_haskey(cpu, "CPU"));
g_assert(qdict_haskey(cpu, "props"));
QDict *cpu, *props;
int64_t socket, core, thread, node;
- cpu = qobject_to_qdict(e);
+ cpu = qobject_to(QDict, e);
g_assert(qdict_haskey(cpu, "props"));
props = qdict_get_qdict(cpu, "props");
QDict *cpu, *props;
int64_t core, node;
- cpu = qobject_to_qdict(e);
+ cpu = qobject_to(QDict, e);
g_assert(qdict_haskey(cpu, "props"));
props = qdict_get_qdict(cpu, "props");
QDict *cpu, *props;
int64_t thread, node;
- cpu = qobject_to_qdict(e);
+ cpu = qobject_to(QDict, e);
g_assert(qdict_haskey(cpu, "props"));
props = qdict_get_qdict(cpu, "props");
}
g_assert(qdict_haskey(response, "return"));
- list = qobject_to_qlist(qdict_get(response, "return"));
+ list = qobject_to(QList, qdict_get(response, "return"));
QLIST_FOREACH_ENTRY(list, entry) {
- tuple = qobject_to_qdict(qlist_entry_obj(entry));
+ tuple = qobject_to(QDict, qlist_entry_obj(entry));
bool is_child = strstart(qdict_get_str(tuple, "type"), "child<", NULL);
bool is_link = strstart(qdict_get_str(tuple, "type"), "link<", NULL);
g_assert(!object_property_get_bool(OBJECT(chr), "connected", &error_abort));
addr = object_property_get_qobject(OBJECT(chr), "addr", &error_abort);
- qdict = qobject_to_qdict(addr);
+ qdict = qobject_to(QDict, addr);
port = qdict_get_str(qdict, "port");
tmp = g_strdup_printf("tcp:127.0.0.1:%s", port);
QDECREF(qdict);
g_assert(qlist);
for (i = 0; i < ARRAY_SIZE(expected); i++) {
- qstr = qobject_to_qstring(qlist_pop(qlist));
+ qstr = qobject_to(QString, qlist_pop(qlist));
g_assert(qstr);
g_assert_cmpstr(qstring_get_str(qstr), ==, expected[i]);
QDECREF(qstr);
QDECREF(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_any(v, "a", &any, &error_abort);
- qlist = qobject_to_qlist(any);
+ qlist = qobject_to(QList, any);
g_assert(qlist);
- qstr = qobject_to_qstring(qlist_pop(qlist));
+ qstr = qobject_to(QString, qlist_pop(qlist));
g_assert_cmpstr(qstring_get_str(qstr), ==, "null");
QDECREF(qstr);
- qstr = qobject_to_qstring(qlist_pop(qlist));
+ qstr = qobject_to(QString, qlist_pop(qlist));
g_assert_cmpstr(qstring_get_str(qstr), ==, "1");
g_assert(qlist_empty(qlist));
QDECREF(qstr);
/* check there is at least a cpu */
list = qdict_get_qlist(ret, "return");
entry = qlist_first(list);
- g_assert(qdict_haskey(qobject_to_qdict(entry->value), "online"));
- g_assert(qdict_haskey(qobject_to_qdict(entry->value), "logical-id"));
+ g_assert(qdict_haskey(qobject_to(QDict, entry->value), "online"));
+ g_assert(qdict_haskey(qobject_to(QDict, entry->value), "logical-id"));
QDECREF(ret);
}
list = qdict_get_qlist(ret, "return");
entry = qlist_first(list);
if (entry) {
- g_assert(qdict_haskey(qobject_to_qdict(entry->value), "name"));
- g_assert(qdict_haskey(qobject_to_qdict(entry->value), "mountpoint"));
- g_assert(qdict_haskey(qobject_to_qdict(entry->value), "type"));
- g_assert(qdict_haskey(qobject_to_qdict(entry->value), "disk"));
+ g_assert(qdict_haskey(qobject_to(QDict, entry->value), "name"));
+ g_assert(qdict_haskey(qobject_to(QDict, entry->value), "mountpoint"));
+ g_assert(qdict_haskey(qobject_to(QDict, entry->value), "type"));
+ g_assert(qdict_haskey(qobject_to(QDict, entry->value), "disk"));
}
QDECREF(ret);
entry = qlist_first(list);
/* newer versions of qga may return empty list without error */
if (entry) {
- g_assert(qdict_haskey(qobject_to_qdict(entry->value), "phys-index"));
- g_assert(qdict_haskey(qobject_to_qdict(entry->value), "online"));
+ g_assert(qdict_haskey(qobject_to(QDict, entry->value),
+ "phys-index"));
+ g_assert(qdict_haskey(qobject_to(QDict, entry->value), "online"));
}
}
/* check there is at least an interface */
list = qdict_get_qlist(ret, "return");
entry = qlist_first(list);
- g_assert(qdict_haskey(qobject_to_qdict(entry->value), "name"));
+ g_assert(qdict_haskey(qobject_to(QDict, entry->value), "name"));
QDECREF(ret);
}
resp = qmp_dispatch(&qmp_commands, QOBJECT(req));
assert(resp != NULL);
- assert(!qdict_haskey(qobject_to_qdict(resp), "error"));
+ assert(!qdict_haskey(qobject_to(QDict, resp), "error"));
qobject_decref(resp);
QDECREF(req);
resp = qmp_dispatch(&qmp_commands, QOBJECT(req));
assert(resp != NULL);
- assert(qdict_haskey(qobject_to_qdict(resp), "error"));
+ assert(qdict_haskey(qobject_to(QDict, resp), "error"));
qobject_decref(resp);
QDECREF(req);
resp = qmp_dispatch(&qmp_commands, QOBJECT(req));
assert(resp != NULL);
- assert(qdict_haskey(qobject_to_qdict(resp), "error"));
+ assert(qdict_haskey(qobject_to(QDict, resp), "error"));
qobject_decref(resp);
QDECREF(req);
resp_obj = qmp_dispatch(&qmp_commands, QOBJECT(req));
assert(resp_obj);
- resp = qobject_to_qdict(resp_obj);
+ resp = qobject_to(QDict, resp_obj);
assert(resp && !qdict_haskey(resp, "error"));
ret = qdict_get(resp, "return");
assert(ret);
qdict_put(req, "arguments", args);
qdict_put_str(req, "execute", "user_def_cmd2");
- ret = qobject_to_qdict(test_qmp_dispatch(req));
+ ret = qobject_to(QDict, test_qmp_dispatch(req));
assert(!strcmp(qdict_get_str(ret, "string0"), "blah1"));
ret_dict = qdict_get_qdict(ret, "dict1");
qdict_put(req, "arguments", args3);
qdict_put_str(req, "execute", "guest-get-time");
- ret3 = qobject_to_qnum(test_qmp_dispatch(req));
+ ret3 = qobject_to(QNum, test_qmp_dispatch(req));
g_assert(qnum_get_try_int(ret3, &val));
g_assert_cmpint(val, ==, 66);
QDECREF(ret3);
switch (qobject_type(obj1)) {
case QTYPE_QBOOL:
- d->result = (qbool_get_bool(qobject_to_qbool(obj1)) ==
- qbool_get_bool(qobject_to_qbool(obj2)));
+ d->result = (qbool_get_bool(qobject_to(QBool, obj1)) ==
+ qbool_get_bool(qobject_to(QBool, obj2)));
return;
case QTYPE_QNUM:
- g_assert(qnum_get_try_int(qobject_to_qnum(obj1), &val1));
- g_assert(qnum_get_try_int(qobject_to_qnum(obj2), &val2));
+ g_assert(qnum_get_try_int(qobject_to(QNum, obj1), &val1));
+ g_assert(qnum_get_try_int(qobject_to(QNum, obj2), &val2));
d->result = val1 == val2;
return;
case QTYPE_QSTRING:
- d->result = g_strcmp0(qstring_get_str(qobject_to_qstring(obj1)),
- qstring_get_str(qobject_to_qstring(obj2))) == 0;
+ d->result = g_strcmp0(qstring_get_str(qobject_to(QString, obj1)),
+ qstring_get_str(qobject_to(QString, obj2))) == 0;
return;
case QTYPE_QDICT:
- d_new.expect = qobject_to_qdict(obj2);
+ d_new.expect = qobject_to(QDict, obj2);
d_new.result = true;
- qdict_iter(qobject_to_qdict(obj1), qdict_cmp_do_simple, &d_new);
+ qdict_iter(qobject_to(QDict, obj1), qdict_cmp_do_simple, &d_new);
d->result = d_new.result;
return;
default:
v = visitor_input_test_init(data, "-42");
visit_type_any(v, NULL, &res, &error_abort);
- qnum = qobject_to_qnum(res);
+ qnum = qobject_to(QNum, res);
g_assert(qnum);
g_assert(qnum_get_try_int(qnum, &val));
g_assert_cmpint(val, ==, -42);
v = visitor_input_test_init(data, "{ 'integer': -42, 'boolean': true, 'string': 'foo' }");
visit_type_any(v, NULL, &res, &error_abort);
- qdict = qobject_to_qdict(res);
+ qdict = qobject_to(QDict, res);
g_assert(qdict && qdict_size(qdict) == 3);
qobj = qdict_get(qdict, "integer");
g_assert(qobj);
- qnum = qobject_to_qnum(qobj);
+ qnum = qobject_to(QNum, qobj);
g_assert(qnum);
g_assert(qnum_get_try_int(qnum, &val));
g_assert_cmpint(val, ==, -42);
qobj = qdict_get(qdict, "boolean");
g_assert(qobj);
- qbool = qobject_to_qbool(qobj);
+ qbool = qobject_to(QBool, qobj);
g_assert(qbool);
g_assert(qbool_get_bool(qbool) == true);
qobj = qdict_get(qdict, "string");
g_assert(qobj);
- qstring = qobject_to_qstring(qobj);
+ qstring = qobject_to(QString, qobj);
g_assert(qstring);
g_assert_cmpstr(qstring_get_str(qstring), ==, "foo");
qobject_decref(res);
visit_type_int(data->ov, NULL, &value, &error_abort);
- qnum = qobject_to_qnum(visitor_get(data));
+ qnum = qobject_to(QNum, visitor_get(data));
g_assert(qnum);
g_assert(qnum_get_try_int(qnum, &val));
g_assert_cmpint(val, ==, value);
visit_type_bool(data->ov, NULL, &value, &error_abort);
- qbool = qobject_to_qbool(visitor_get(data));
+ qbool = qobject_to(QBool, visitor_get(data));
g_assert(qbool);
g_assert(qbool_get_bool(qbool) == value);
}
visit_type_number(data->ov, NULL, &value, &error_abort);
- qnum = qobject_to_qnum(visitor_get(data));
+ qnum = qobject_to(QNum, visitor_get(data));
g_assert(qnum);
g_assert(qnum_get_double(qnum) == value);
}
visit_type_str(data->ov, NULL, &string, &error_abort);
- qstr = qobject_to_qstring(visitor_get(data));
+ qstr = qobject_to(QString, visitor_get(data));
g_assert(qstr);
g_assert_cmpstr(qstring_get_str(qstr), ==, string);
}
/* A null string should return "" */
visit_type_str(data->ov, NULL, &string, &error_abort);
- qstr = qobject_to_qstring(visitor_get(data));
+ qstr = qobject_to(QString, visitor_get(data));
g_assert(qstr);
g_assert_cmpstr(qstring_get_str(qstr), ==, "");
}
for (i = 0; i < ENUM_ONE__MAX; i++) {
visit_type_EnumOne(data->ov, "unused", &i, &error_abort);
- qstr = qobject_to_qstring(visitor_get(data));
+ qstr = qobject_to(QString, visitor_get(data));
g_assert(qstr);
g_assert_cmpstr(qstring_get_str(qstr), ==, EnumOne_str(i));
visitor_reset(data);
visit_type_TestStruct(data->ov, NULL, &p, &error_abort);
- qdict = qobject_to_qdict(visitor_get(data));
+ qdict = qobject_to(QDict, visitor_get(data));
g_assert(qdict);
g_assert_cmpint(qdict_size(qdict), ==, 3);
g_assert_cmpint(qdict_get_int(qdict, "integer"), ==, 42);
visit_type_UserDefTwo(data->ov, "unused", &ud2, &error_abort);
- qdict = qobject_to_qdict(visitor_get(data));
+ qdict = qobject_to(QDict, visitor_get(data));
g_assert(qdict);
g_assert_cmpint(qdict_size(qdict), ==, 2);
g_assert_cmpstr(qdict_get_str(qdict, "string0"), ==, strings[0]);
visit_type_TestStructList(data->ov, NULL, &head, &error_abort);
- qlist = qobject_to_qlist(visitor_get(data));
+ qlist = qobject_to(QList, visitor_get(data));
g_assert(qlist);
g_assert(!qlist_empty(qlist));
QLIST_FOREACH_ENTRY(qlist, entry) {
QDict *qdict;
- qdict = qobject_to_qdict(entry->value);
+ qdict = qobject_to(QDict, entry->value);
g_assert(qdict);
g_assert_cmpint(qdict_size(qdict), ==, 3);
g_assert_cmpint(qdict_get_int(qdict, "integer"), ==, value_int + i);
qobj = QOBJECT(qnum_from_int(-42));
visit_type_any(data->ov, NULL, &qobj, &error_abort);
- qnum = qobject_to_qnum(visitor_get(data));
+ qnum = qobject_to(QNum, visitor_get(data));
g_assert(qnum);
g_assert(qnum_get_try_int(qnum, &val));
g_assert_cmpint(val, ==, -42);
qobj = QOBJECT(qdict);
visit_type_any(data->ov, NULL, &qobj, &error_abort);
qobject_decref(qobj);
- qdict = qobject_to_qdict(visitor_get(data));
+ qdict = qobject_to(QDict, visitor_get(data));
g_assert(qdict);
- qnum = qobject_to_qnum(qdict_get(qdict, "integer"));
+ qnum = qobject_to(QNum, qdict_get(qdict, "integer"));
g_assert(qnum);
g_assert(qnum_get_try_int(qnum, &val));
g_assert_cmpint(val, ==, -42);
- qbool = qobject_to_qbool(qdict_get(qdict, "boolean"));
+ qbool = qobject_to(QBool, qdict_get(qdict, "boolean"));
g_assert(qbool);
g_assert(qbool_get_bool(qbool) == true);
- qstring = qobject_to_qstring(qdict_get(qdict, "string"));
+ qstring = qobject_to(QString, qdict_get(qdict, "string"));
g_assert(qstring);
g_assert_cmpstr(qstring_get_str(qstring), ==, "foo");
}
tmp->u.value1.boolean = true;
visit_type_UserDefFlatUnion(data->ov, NULL, &tmp, &error_abort);
- qdict = qobject_to_qdict(visitor_get(data));
+ qdict = qobject_to(QDict, visitor_get(data));
g_assert(qdict);
g_assert_cmpstr(qdict_get_str(qdict, "enum1"), ==, "value1");
g_assert_cmpstr(qdict_get_str(qdict, "string"), ==, "str");
tmp->u.i = 42;
visit_type_UserDefAlternate(data->ov, NULL, &tmp, &error_abort);
- qnum = qobject_to_qnum(visitor_get(data));
+ qnum = qobject_to(QNum, visitor_get(data));
g_assert(qnum);
g_assert(qnum_get_try_int(qnum, &val));
g_assert_cmpint(val, ==, 42);
tmp->u.e = ENUM_ONE_VALUE1;
visit_type_UserDefAlternate(data->ov, NULL, &tmp, &error_abort);
- qstr = qobject_to_qstring(visitor_get(data));
+ qstr = qobject_to(QString, visitor_get(data));
g_assert(qstr);
g_assert_cmpstr(qstring_get_str(qstr), ==, "value1");
tmp->u.udfu.u.value1.boolean = true;
visit_type_UserDefAlternate(data->ov, NULL, &tmp, &error_abort);
- qdict = qobject_to_qdict(visitor_get(data));
+ qdict = qobject_to(QDict, visitor_get(data));
g_assert(qdict);
g_assert_cmpint(qdict_size(qdict), ==, 4);
g_assert_cmpint(qdict_get_int(qdict, "integer"), ==, 1);
visit_type_null(data->ov, "a", &null, &error_abort);
visit_check_struct(data->ov, &error_abort);
visit_end_struct(data->ov, NULL);
- qdict = qobject_to_qdict(visitor_get(data));
+ qdict = qobject_to(QDict, visitor_get(data));
g_assert(qdict);
g_assert_cmpint(qdict_size(qdict), ==, 1);
nil = qdict_get(qdict, "a");
QList *qlist;
int i;
- qdict = qobject_to_qdict(qobj);
+ qdict = qobject_to(QDict, qobj);
g_assert(qdict);
g_assert(qdict_haskey(qdict, "data"));
- qlist = qlist_copy(qobject_to_qlist(qdict_get(qdict, "data")));
+ qlist = qlist_copy(qobject_to(QList, qdict_get(qdict, "data")));
switch (kind) {
case USER_DEF_NATIVE_LIST_UNION_KIND_U8:
tmp = qlist_peek(qlist);
g_assert(tmp);
- qvalue = qobject_to_qnum(tmp);
+ qvalue = qobject_to(QNum, tmp);
g_assert(qnum_get_try_uint(qvalue, &val));
g_assert_cmpint(val, ==, i);
qobject_decref(qlist_pop(qlist));
tmp = qlist_peek(qlist);
g_assert(tmp);
- qvalue = qobject_to_qnum(tmp);
+ qvalue = qobject_to(QNum, tmp);
g_assert(qnum_get_try_int(qvalue, &val));
g_assert_cmpint(val, ==, i);
qobject_decref(qlist_pop(qlist));
QBool *qvalue;
tmp = qlist_peek(qlist);
g_assert(tmp);
- qvalue = qobject_to_qbool(tmp);
+ qvalue = qobject_to(QBool, tmp);
g_assert_cmpint(qbool_get_bool(qvalue), ==, i % 3 == 0);
qobject_decref(qlist_pop(qlist));
}
gchar str[8];
tmp = qlist_peek(qlist);
g_assert(tmp);
- qvalue = qobject_to_qstring(tmp);
+ qvalue = qobject_to(QString, tmp);
sprintf(str, "%d", i);
g_assert_cmpstr(qstring_get_str(qvalue), ==, str);
qobject_decref(qlist_pop(qlist));
tmp = qlist_peek(qlist);
g_assert(tmp);
- qvalue = qobject_to_qnum(tmp);
+ qvalue = qobject_to(QNum, tmp);
g_string_printf(double_expected, "%.6f", (double)i / 3);
g_string_printf(double_actual, "%.6f", qnum_get_double(qvalue));
g_assert_cmpstr(double_actual->str, ==, double_expected->str);
g_assert(qdict_haskey(resp, "return"));
ret = qdict_get_qlist(resp, "return");
- cpu0 = qobject_to_qdict(qlist_peek(ret));
+ cpu0 = qobject_to(QDict, qlist_peek(ret));
path = g_strdup(qdict_get_str(cpu0, "qom_path"));
QDECREF(resp);
return path;
#ifdef CONFIG_HAS_GLIB_SUBPROCESS_TESTS
static bool qom_get_bool(const char *path, const char *prop)
{
- QBool *value = qobject_to_qbool(qom_get(path, prop));
+ QBool *value = qobject_to(QBool, qom_get(path, prop));
bool b = qbool_get_bool(value);
QDECREF(value);
qtest_start(args->cmdline);
path = get_cpu0_qom_path();
- value = qobject_to_qnum(qom_get(path, args->property));
+ value = qobject_to(QNum, qom_get(path, args->property));
g_assert(qnum_get_try_int(value, &val));
g_assert_cmpint(val, ==, args->expected_value);
qtest_end();
const QListEntry *e;
for (e = qlist_first(features); e; e = qlist_next(e)) {
- QDict *w = qobject_to_qdict(qlist_entry_obj(e));
+ QDict *w = qobject_to(QDict, qlist_entry_obj(e));
const char *rreg = qdict_get_str(w, "cpuid-register");
uint32_t reax = qdict_get_int(w, "cpuid-input-eax");
bool has_ecx = qdict_haskey(w, "cpuid-input-ecx");
recx = qdict_get_int(w, "cpuid-input-ecx");
}
if (eax == reax && (!has_ecx || ecx == recx) && !strcmp(rreg, reg)) {
- g_assert(qnum_get_try_int(qobject_to_qnum(qdict_get(w, "features")),
- &val));
+ g_assert(qnum_get_try_int(qobject_to(QNum,
+ qdict_get(w, "features")),
+ &val));
return val;
}
}
qtest_start(args->cmdline);
path = get_cpu0_qom_path();
- present = qobject_to_qlist(qom_get(path, "feature-words"));
- filtered = qobject_to_qlist(qom_get(path, "filtered-features"));
+ present = qobject_to(QList, qom_get(path, "feature-words"));
+ filtered = qobject_to(QList, qom_get(path, "filtered-features"));
value = get_feature_word(present, args->in_eax, args->in_ecx, args->reg);
value |= get_feature_word(filtered, args->in_eax, args->in_ecx, args->reg);
qtest_end();
if (!next) {
return NULL;
}
- cur = qobject_to_qdict(next);
+ cur = qobject_to(QDict, next);
assert(cur);
}
has_member = true;
}
- qdict = qobject_to_qdict(ent->value);
+ qdict = qobject_to(QDict, ent->value);
if (!qdict) {
continue;
}
}
QLIST_FOREACH_ENTRY(list, list_entry) {
- QDict *section = qobject_to_qdict(qlist_entry_obj(list_entry));
+ QDict *section = qobject_to(QDict, qlist_entry_obj(list_entry));
char *opt_name;
if (!section) {
switch (qobject_type(obj)) {
case QTYPE_QSTRING:
- value = qstring_get_str(qobject_to_qstring(obj));
+ value = qstring_get_str(qobject_to(QString, obj));
break;
case QTYPE_QNUM:
- tmp = qnum_to_string(qobject_to_qnum(obj));
+ tmp = qnum_to_string(qobject_to(QNum, obj));
value = tmp;
break;
case QTYPE_QBOOL:
pstrcpy(buf, sizeof(buf),
- qbool_get_bool(qobject_to_qbool(obj)) ? "on" : "off");
+ qbool_get_bool(qobject_to(QBool, obj)) ? "on" : "off");
value = buf;
break;
default:
projects / qemu-xen.git / commitdiff