From patchwork Fri Oct 14 18:19:57 2011 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Michael Roth X-Patchwork-Id: 119900 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from lists.gnu.org (lists.gnu.org [140.186.70.17]) (using TLSv1 with cipher AES256-SHA (256/256 bits)) (Client did not present a certificate) by ozlabs.org (Postfix) with ESMTPS id 9B61AB708F for ; Sat, 15 Oct 2011 05:35:50 +1100 (EST) Received: from localhost ([::1]:59305 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1REmNf-0004Wi-FK for incoming@patchwork.ozlabs.org; Fri, 14 Oct 2011 14:21:15 -0400 Received: from eggs.gnu.org ([140.186.70.92]:53521) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1REmND-0003sH-8R for qemu-devel@nongnu.org; Fri, 14 Oct 2011 14:20:50 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1REmNA-0005e1-MR for qemu-devel@nongnu.org; Fri, 14 Oct 2011 14:20:47 -0400 Received: from mout.perfora.net ([74.208.4.195]:62462) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1REmNA-0005do-4P for qemu-devel@nongnu.org; Fri, 14 Oct 2011 14:20:44 -0400 Received: from illuin.austin.ibm.com ([32.97.110.59]) by mrelay.perfora.net (node=mrus1) with ESMTP (Nemesis) id 0MEovS-1RHTFs02HK-00GRaO; Fri, 14 Oct 2011 14:20:33 -0400 From: Michael Roth To: qemu-devel@nongnu.org Date: Fri, 14 Oct 2011 13:19:57 -0500 Message-Id: <1318616402-18474-6-git-send-email-mdroth@linux.vnet.ibm.com> X-Mailer: git-send-email 1.7.4.1 In-Reply-To: <1318616402-18474-1-git-send-email-mdroth@linux.vnet.ibm.com> References: <1318616402-18474-1-git-send-email-mdroth@linux.vnet.ibm.com> X-Provags-ID: V02:K0:4UqzgpPzrgQDEsH9nbWV9GGlPtxmXMxbMpgZCsL12Bh ChtVcHZw3aAXqle8IJiO/UXFU+JfYuYDjr6kCS/kC5EdzZDjED j+AD00j2dyt9/XXDBTVx7aODaIG9uvofoaN7pY5KRxXe2cM18x +JnQ21UyjjDBTuRGNQucNxEY/1tIysT7akgfvmMuEsqVkKqXUE 5vLs1drYBSMyYkHNt9VMI1Pf2y64rkW/fsXoPA7ApJsLgCO3Pd TYRnszLHKYFUkxGl+08nKsnSJ5r+9KfmiRyBJyuIyuwWe3ai8J dlL5dXaImFVpafnr0gEKiOJSVYQ7Ly0mfTm7g/mUjT+kIde84A HzJJjRwXzE6EM2vlr2ZEFXqH1285LEEXchUJV2ZyYRv+wW2lBJ pJaEA5QZzz7og21nmvz95p5NjZy2vAv6QU= X-detected-operating-system: by eggs.gnu.org: Genre and OS details not recognized. X-Received-From: 74.208.4.195 Cc: aliguori@us.ibm.com, mdroth@linux.vnet.ibm.com Subject: [Qemu-devel] [PATCH 05/10] qapi: test cases for QEMUFile input/output visitors X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.14 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org Sender: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org Signed-off-by: Michael Roth --- Makefile | 2 +- test-visitor.c | 404 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 405 insertions(+), 1 deletions(-) diff --git a/Makefile b/Makefile index f63fc02..50803b0 100644 --- a/Makefile +++ b/Makefile @@ -204,7 +204,7 @@ qmp-marshal.c: $(SRC_PATH)/qapi-schema.json $(SRC_PATH)/scripts/qapi-commands.py $(call quiet-command,$(PYTHON) $(SRC_PATH)/scripts/qapi-commands.py -m -o "." < $<, " GEN $@") test-visitor.o: $(addprefix $(qapi-dir)/, test-qapi-types.c test-qapi-types.h test-qapi-visit.c test-qapi-visit.h) $(qapi-obj-y) -test-visitor: test-visitor.o qfloat.o qint.o qdict.o qstring.o qlist.o qbool.o $(qapi-obj-y) error.o osdep.o $(oslib-obj-y) qjson.o json-streamer.o json-lexer.o json-parser.o qerror.o qemu-error.o qemu-tool.o $(qapi-dir)/test-qapi-visit.o $(qapi-dir)/test-qapi-types.o +test-visitor: test-visitor.o qfloat.o qint.o qdict.o qstring.o qlist.o qbool.o $(qapi-obj-y) error.o osdep.o $(oslib-obj-y) qjson.o json-streamer.o json-lexer.o json-parser.o qerror.o qemu-error.o qemu-tool.o $(qapi-dir)/test-qapi-visit.o $(qapi-dir)/test-qapi-types.o qapi/qemu-file-input-visitor.o qapi/qemu-file-output-visitor.o qemu-file.o test-qmp-commands.o: $(addprefix $(qapi-dir)/, test-qapi-types.c test-qapi-types.h test-qapi-visit.c test-qapi-visit.h test-qmp-marshal.c test-qmp-commands.h) $(qapi-obj-y) test-qmp-commands: test-qmp-commands.o qfloat.o qint.o qdict.o qstring.o qlist.o qbool.o $(qapi-obj-y) error.o osdep.o $(oslib-obj-y) qjson.o json-streamer.o json-lexer.o json-parser.o qerror.o qemu-error.o qemu-tool.o $(qapi-dir)/test-qapi-visit.o $(qapi-dir)/test-qapi-types.o $(qapi-dir)/test-qmp-marshal.o module.o diff --git a/test-visitor.c b/test-visitor.c index 847ce14..15a9ce9 100644 --- a/test-visitor.c +++ b/test-visitor.c @@ -4,6 +4,10 @@ #include "test-qapi-types.h" #include "test-qapi-visit.h" #include "qemu-objects.h" +#include "qapi/qemu-file-output-visitor.h" +#include "qapi/qemu-file-input-visitor.h" +#include "hw/hw.h" +#include "qemu-common.h" typedef struct TestStruct { @@ -323,6 +327,404 @@ static void test_nested_enums(void) qapi_free_NestedEnumsOne(nested_enums_cpy); } +#define TEST_QEMU_FILE_PATH "/tmp/test_qemu_file_visitors" + +typedef struct QEMUFileValue { + union { + bool boolean; + double number; + uint8_t u8; + uint16_t u16; + uint32_t u32; + uint64_t u64; + int8_t s8; + int16_t s16; + int32_t s32; + int64_t s64; + uintmax_t umax; + } value; + union { + uint8_t u8[32]; + uint16_t u16[32]; + uint32_t u32[32]; + uint64_t u64[32]; + int8_t s8[32]; + int16_t s16[32]; + int32_t s32[32]; + int64_t s64[32]; + uintmax_t umax[32]; + } array; + size_t array_len; + enum { + QFV_BOOL = 0, + QFV_NUMBER, + QFV_U8, + QFV_U16, + QFV_U32, + QFV_U64, + QFV_S8, + QFV_S16, + QFV_S32, + QFV_S64, + QFV_U8_ARRAY, + QFV_EOL, + } type; +} QEMUFileValue; + +QEMUFileValue qfvalues[] = { + { .value.boolean = true, .type = QFV_BOOL }, + { .value.boolean = false, .type = QFV_BOOL }, + { .value.number = 3.14159265, .type = QFV_NUMBER }, + { .value.u8 = 0, .type = QFV_U8 }, + { .value.u8 = 1, .type = QFV_U8 }, + { .value.u8 = 128, .type = QFV_U8 }, + { .value.u8 = 255u, .type = QFV_U8 }, + { .value.u16 = 0, .type = QFV_U16 }, + { .value.u16 = 1, .type = QFV_U16 }, + { .value.u16 = 32768, .type = QFV_U16 }, + { .value.u16 = 65535u, .type = QFV_U16 }, + { .value.u32 = 0, .type = QFV_U32 }, + { .value.u32 = 1, .type = QFV_U32 }, + { .value.u32 = 2147483648, .type = QFV_U32 }, + { .value.u32 = 4294967295u, .type = QFV_U32 }, + { .value.u64 = 0, .type = QFV_U64 }, + { .value.u64 = 1, .type = QFV_U64 }, + { .value.u64 = 9223372036854775808u, .type = QFV_U64 }, + { .value.u64 = 18446744073709551615u, .type = QFV_U64 }, + { .value.s8 = 0, .type = QFV_S8 }, + { .value.s8 = 1, .type = QFV_S8 }, + { .value.s8 = 128, .type = QFV_S8 }, + { .value.s8 = -1, .type = QFV_S8 }, + { .value.s16 = 0, .type = QFV_S16 }, + { .value.s16 = 1, .type = QFV_S16 }, + { .value.s16 = 32768, .type = QFV_S16 }, + { .value.s16 = -1, .type = QFV_S16 }, + { .value.s32 = 0, .type = QFV_S32 }, + { .value.s32 = 1, .type = QFV_S32 }, + { .value.s32 = 2147483648, .type = QFV_S32 }, + { .value.s32 = -1, .type = QFV_S32 }, + { .value.s64 = 0, .type = QFV_S64 }, + { .value.s64 = 1, .type = QFV_S64 }, + { .value.s64 = 9223372036854775808u, .type = QFV_S64 }, + { .value.s64 = -1, .type = QFV_S64 }, + { .array.u8 = { }, .array_len = 0, .type = QFV_U8_ARRAY }, + { .array.u8 = { 1, 2, 3, 4 }, .array_len = 4, .type = QFV_U8_ARRAY }, + { .type = QFV_EOL } +}; + +static void qfv_process(QEMUFileValue *qfv, bool visitor, bool write, + void *opaque) +{ + int i; + void *ptr; + + switch (qfv->type) { + case QFV_BOOL: + if (visitor) { + visit_type_bool(opaque, &qfv->value.boolean, NULL, NULL); + } else { + if (write) { + qemu_put_byte(opaque, qfv->value.boolean); + } else { + qfv->value.boolean = qemu_get_byte(opaque); + } + } + break; + case QFV_NUMBER: + if (visitor) { + visit_type_number(opaque, &qfv->value.number, NULL, NULL); + } else { + if (write) { + qemu_put_be64s(opaque, (uint64_t *)&qfv->value.number); + } else { + qemu_get_be64s(opaque, (uint64_t *)&qfv->value.number); + } + } + break; + case QFV_U8: + if (visitor) { + visit_type_uint8(opaque, &qfv->value.u8, NULL, NULL); + } else { + if (write) { + qemu_put_byte(opaque, qfv->value.u8); + } else { + qfv->value.u8 = qemu_get_byte(opaque); + } + } + break; + case QFV_U16: + if (visitor) { + visit_type_uint16(opaque, &qfv->value.u16, NULL, NULL); + } else { + if (write) { + qemu_put_be16(opaque, qfv->value.u16); + } else { + qfv->value.u16 = qemu_get_be16(opaque); + } + } + break; + case QFV_U32: + if (visitor) { + visit_type_uint32(opaque, &qfv->value.u32, NULL, NULL); + } else { + if (write) { + qemu_put_be32(opaque, qfv->value.u32); + } else { + qfv->value.u32 = qemu_get_be32(opaque); + } + } + break; + case QFV_U64: + if (visitor) { + visit_type_uint64(opaque, &qfv->value.u64, NULL, NULL); + } else { + if (write) { + qemu_put_be64(opaque, qfv->value.u64); + } else { + qfv->value.u64 = qemu_get_be64(opaque); + } + } + break; + case QFV_S8: + if (visitor) { + visit_type_int8(opaque, &qfv->value.s8, NULL, NULL); + } else { + if (write) { + qemu_put_byte(opaque, qfv->value.s8); + } else { + qfv->value.s8 = qemu_get_byte(opaque); + } + } + break; + case QFV_S16: + if (visitor) { + visit_type_int16(opaque, &qfv->value.s16, NULL, NULL); + } else { + if (write) { + qemu_put_be16(opaque, qfv->value.s16); + } else { + qfv->value.s16 = qemu_get_be16(opaque); + } + } + break; + case QFV_S32: + if (visitor) { + visit_type_int32(opaque, &qfv->value.s32, NULL, NULL); + } else { + if (write) { + qemu_put_be32(opaque, qfv->value.s32); + } else { + qfv->value.s32 = qemu_get_be32(opaque); + } + } + break; + case QFV_S64: + if (visitor) { + visit_type_int64(opaque, &qfv->value.s64, NULL, NULL); + } else { + if (write) { + qemu_put_be64(opaque, qfv->value.s64); + } else { + qfv->value.s64 = qemu_get_be64(opaque); + } + } + break; + case QFV_U8_ARRAY: + if (visitor) { + ptr = qfv->array.u8; + visit_start_array(opaque, (void **)&ptr, NULL, + qfv->array_len, sizeof(uint8_t), NULL); + for (i = 0; i < qfv->array_len; i++, visit_next_array(opaque, NULL)) { + visit_type_uint8(opaque, &((uint8_t *)ptr)[i], NULL, NULL); + } + visit_end_array(opaque, NULL); + } else { + for (i = 0; i < qfv->array_len; i++) { + if (write) { + qemu_put_byte(opaque, qfv->array.u8[i]); + } else { + qfv->array.u8[i] = qemu_get_byte(opaque); + } + } + } + break; + default: + return; + } +} + +static void qfv_visitor_write(QEMUFileValue *qfv, Visitor *v) +{ + qfv_process(qfv, true, true, v); +} + +static void qfv_visitor_read(QEMUFileValue *qfv, Visitor *v) +{ + qfv_process(qfv, true, false, v); +} + +static void qfv_write(QEMUFileValue *qfv, QEMUFile *f) +{ + qfv_process(qfv, false, true, f); +} + +static void qfv_read(QEMUFileValue *qfv, QEMUFile *f) +{ + qfv_process(qfv, false, false, f); +} + +static void test_qemu_file_in_visitor(void) +{ + QEMUFile *f1, *f2; + QemuFileInputVisitor *qfi; + QemuFileOutputVisitor *qfo; + Visitor *v; + QEMUFileValue qfval1, qfval2; + int i, j; + TestStruct ts, *pts; + TestStructList *lts; + + /* write our test scalars/arrays */ + f1 = qemu_fopen(TEST_QEMU_FILE_PATH, "wb"); + g_assert(f1); + qfo = qemu_file_output_visitor_new(f1); + v = qemu_file_output_get_visitor(qfo); + for (i = 0; qfvalues[i].type != QFV_EOL; i++) { + qfv_write(&qfvalues[i], f1); + } + /* write our test struct/list. qemu_put_* interfaces have + * no analogue for this and instead rely on byte arrays, + * so we'll write this using a visitor and simply test + * visitor input/output compatibility + */ + /* write a simple struct */ + ts.x = 42; + ts.y = 43; + pts = &ts; + visit_type_TestStruct(v, &pts, NULL, NULL); + /* throw in a linked list as well */ + lts = g_malloc0(sizeof(*lts)); + lts->value = g_malloc0(sizeof(TestStruct)); + lts->value->x = 44; + lts->value->y = 45; + lts->next = g_malloc0(sizeof(*lts)); + lts->next->value = g_malloc0(sizeof(TestStruct)); + lts->next->value->x = 46; + lts->next->value->y = 47; + visit_type_TestStructList(v, <s, NULL, NULL); + g_free(lts->next->value); + g_free(lts->next); + g_free(lts->value); + g_free(lts); + + qemu_file_output_visitor_cleanup(qfo); + qemu_fclose(f1); + + /* make sure qemu_get_be* and input visitor read same/correct input */ + f1 = qemu_fopen(TEST_QEMU_FILE_PATH, "rb"); + f2 = qemu_fopen(TEST_QEMU_FILE_PATH, "rb"); + qfi = qemu_file_input_visitor_new(f2); + g_assert(qfi); + v = qemu_file_input_get_visitor(qfi); + g_assert(v); + for (i = 0; qfvalues[i].type != QFV_EOL; i++) { + qfval1.value.umax = qfval2.value.umax = 0; + memset(qfval1.array.umax, 0, sizeof(qfval1.array.umax)); + memset(qfval2.array.umax, 0, sizeof(qfval2.array.umax)); + qfval1.type = qfval2.type = qfvalues[i].type; + qfval1.array_len = qfval2.array_len = qfvalues[i].array_len; + qfv_read(&qfval1, f1); + qfv_visitor_read(&qfval2, v); + if (qfvalues[i].type >= QFV_U8_ARRAY) { + for (j = 0; j < qfvalues[i].array_len; j++) { + g_assert(qfval1.array.u8[j] == qfval2.array.u8[j]); + g_assert(qfval2.array.u8[j] == qfvalues[i].array.u8[j]); + } + } else { + g_assert(qfval1.value.umax == qfval2.value.umax); + g_assert(qfval2.value.umax == qfvalues[i].value.umax); + } + } + qemu_file_input_visitor_cleanup(qfi); + qemu_fclose(f1); + qemu_fclose(f2); + unlink(TEST_QEMU_FILE_PATH); +} + +static void test_qemu_file_out_visitor(void) +{ + QEMUFile *f; + QemuFileOutputVisitor *qfo; + Visitor *v; + QEMUFileValue qfval1; + int i, j; + TestStruct ts, *pts; + TestStructList *lts; + + /* write test scalars/arrays using an output visitor */ + f = qemu_fopen(TEST_QEMU_FILE_PATH, "wb"); + g_assert(f); + qfo = qemu_file_output_visitor_new(f); + g_assert(qfo); + v = qemu_file_output_get_visitor(qfo); + g_assert(v); + for (i = 0; qfvalues[i].type != QFV_EOL; i++) { + qfv_visitor_write(&qfvalues[i], v); + } + /* write a simple struct */ + ts.x = 42; + ts.y = 43; + pts = &ts; + visit_type_TestStruct(v, &pts, NULL, NULL); + /* throw in a linked list as well */ + lts = g_malloc0(sizeof(*lts)); + lts->value = g_malloc0(sizeof(TestStruct)); + lts->value->x = 44; + lts->value->y = 45; + lts->next = g_malloc0(sizeof(*lts)); + lts->next->value = g_malloc0(sizeof(TestStruct)); + lts->next->value->x = 46; + lts->next->value->y = 47; + visit_type_TestStructList(v, <s, NULL, NULL); + g_free(lts->next->value); + g_free(lts->next); + g_free(lts->value); + g_free(lts); + + qemu_file_output_visitor_cleanup(qfo); + qemu_fclose(f); + + /* make sure output visitor wrote the expected values */ + f = qemu_fopen(TEST_QEMU_FILE_PATH, "rb"); + g_assert(f); + for (i = 0; qfvalues[i].type != QFV_EOL; i++) { + qfval1.type = qfvalues[i].type; + qfval1.value.umax = 0; + memset(qfval1.array.umax, 0, sizeof(qfval1.array.umax)); + qfval1.array_len = qfvalues[i].array_len; + + qfv_read(&qfval1, f); + if (qfvalues[i].type >= QFV_U8_ARRAY) { + for (j = 0; j < qfvalues[i].array_len; j++) { + g_assert(qfval1.array.u8[j] == qfvalues[i].array.u8[j]); + } + } else { + g_assert(qfval1.value.umax == qfvalues[i].value.umax); + } + } + /* test the struct */ + g_assert(qemu_get_be64(f) == ts.x); + g_assert(qemu_get_be64(f) == ts.y); + /* test the linked list */ + g_assert(qemu_get_be64(f) == 44); + g_assert(qemu_get_be64(f) == 45); + g_assert(qemu_get_be64(f) == 46); + g_assert(qemu_get_be64(f) == 47); + + qemu_fclose(f); + unlink(TEST_QEMU_FILE_PATH); +} + int main(int argc, char **argv) { g_test_init(&argc, &argv, NULL); @@ -331,6 +733,8 @@ int main(int argc, char **argv) g_test_add_func("/0.15/nested_structs", test_nested_structs); g_test_add_func("/0.15/enums", test_enums); g_test_add_func("/0.15/nested_enums", test_nested_enums); + g_test_add_func("/1.0/qemu_file_input_visitor", test_qemu_file_in_visitor); + g_test_add_func("/1.0/qemu_file_output_visitor", test_qemu_file_out_visitor); g_test_run();