[PATCH 07/15] testutilsqemuschema: Pass in 'schema' and 'debug' variables to workers in a struct

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



Refactor the code so that we pass in the repeated 'schema' and 'debug'
arguments via a new struct testQEMUSchemaValidateCtxt. This will
simplify adding new parameters in the future.

Signed-off-by: Peter Krempa <pkrempa@xxxxxxxxxx>
---
 tests/testutilsqemuschema.c | 152 ++++++++++++++++++------------------
 1 file changed, 76 insertions(+), 76 deletions(-)

diff --git a/tests/testutilsqemuschema.c b/tests/testutilsqemuschema.c
index a43cbe2f91..b449171d15 100644
--- a/tests/testutilsqemuschema.c
+++ b/tests/testutilsqemuschema.c
@@ -21,16 +21,21 @@
 #include "testutilsqemuschema.h"
 #include "qemu/qemu_qapi.h"

+struct testQEMUSchemaValidateCtxt {
+    virHashTablePtr schema;
+    virBufferPtr debug;
+};
+
+
 static int
 testQEMUSchemaValidateRecurse(virJSONValuePtr obj,
                               virJSONValuePtr root,
-                              virHashTablePtr schema,
-                              virBufferPtr debug);
+                              struct testQEMUSchemaValidateCtxt *ctxt);

 static int
 testQEMUSchemaValidateBuiltin(virJSONValuePtr obj,
                               virJSONValuePtr root,
-                              virBufferPtr debug)
+                              struct testQEMUSchemaValidateCtxt *ctxt)
 {
     const char *t = virJSONValueObjectGetString(root, "json-type");
     const char *s = NULL;
@@ -81,17 +86,16 @@ testQEMUSchemaValidateBuiltin(virJSONValuePtr obj,

  cleanup:
     if (ret == 0)
-        virBufferAsprintf(debug, "'%s': OK", s);
+        virBufferAsprintf(ctxt->debug, "'%s': OK", s);
     else
-        virBufferAsprintf(debug, "ERROR: expected type '%s', actual type %d",
+        virBufferAsprintf(ctxt->debug, "ERROR: expected type '%s', actual type %d",
                           t, virJSONValueGetType(obj));
     return ret;
 }

 struct testQEMUSchemaValidateObjectMemberData {
     virJSONValuePtr rootmembers;
-    virHashTablePtr schema;
-    virBufferPtr debug;
+    struct testQEMUSchemaValidateCtxt *ctxt;
     bool missingMandatory;
 };

@@ -128,27 +132,26 @@ testQEMUSchemaValidateObjectMember(const char *key,
     virJSONValuePtr keyschema = NULL;
     int rc;

-    virBufferStrcat(data->debug, key, ": ", NULL);
+    virBufferStrcat(data->ctxt->debug, key, ": ", NULL);

     /* lookup 'member' entry for key */
     if (!(keymember = testQEMUSchemaStealObjectMemberByName(key, data->rootmembers))) {
-        virBufferAddLit(data->debug, "ERROR: attribute not in schema\n");
+        virBufferAddLit(data->ctxt->debug, "ERROR: attribute not in schema\n");
         return -1;
     }

     /* lookup schema entry for keytype */
     if (!(keytype = virJSONValueObjectGetString(keymember, "type")) ||
-        !(keyschema = virHashLookup(data->schema, keytype))) {
-        virBufferAsprintf(data->debug, "ERROR: can't find schema for type '%s'\n",
+        !(keyschema = virHashLookup(data->ctxt->schema, keytype))) {
+        virBufferAsprintf(data->ctxt->debug, "ERROR: can't find schema for type '%s'\n",
                           NULLSTR(keytype));
         return -2;
     }

     /* recurse */
-    rc = testQEMUSchemaValidateRecurse(value, keyschema, data->schema,
-                                        data->debug);
+    rc = testQEMUSchemaValidateRecurse(value, keyschema, data->ctxt);

-    virBufferAddLit(data->debug, "\n");
+    virBufferAddLit(data->ctxt->debug, "\n");
     return rc;
 }

@@ -181,8 +184,7 @@ static int
 testQEMUSchemaValidateObjectMergeVariant(virJSONValuePtr root,
                                          const char *variantfield,
                                          const char *variantname,
-                                         virHashTablePtr schema,
-                                         virBufferPtr debug)
+                                         struct testQEMUSchemaValidateCtxt *ctxt)
 {
     size_t i;
     g_autoptr(virJSONValue) variants = NULL;
@@ -193,7 +195,7 @@ testQEMUSchemaValidateObjectMergeVariant(virJSONValuePtr root,
     const char *varianttype = NULL;

     if (!(variants = virJSONValueObjectStealArray(root, "variants"))) {
-        virBufferAddLit(debug, "ERROR: missing 'variants' in schema\n");
+        virBufferAddLit(ctxt->debug, "ERROR: missing 'variants' in schema\n");
         return -2;
     }

@@ -208,14 +210,14 @@ testQEMUSchemaValidateObjectMergeVariant(virJSONValuePtr root,
     }

     if (!varianttype) {
-        virBufferAsprintf(debug, "ERROR: variant '%s' for discriminator '%s' not found\n",
+        virBufferAsprintf(ctxt->debug, "ERROR: variant '%s' for discriminator '%s' not found\n",
                           variantname, variantfield);
         return -1;
     }

-    if (!(variantschema = virHashLookup(schema, varianttype)) ||
+    if (!(variantschema = virHashLookup(ctxt->schema, varianttype)) ||
         !(variantschemamembers = virJSONValueObjectGetArray(variantschema, "members"))) {
-        virBufferAsprintf(debug,
+        virBufferAsprintf(ctxt->debug,
                           "ERROR: missing schema or schema members for variant '%s'(%s)\n",
                           variantname, varianttype);
         return -2;
@@ -241,7 +243,7 @@ testQEMUSchemaValidateObjectMandatoryMember(size_t pos G_GNUC_UNUSED,
     struct testQEMUSchemaValidateObjectMemberData *data = opaque;

     if (virJSONValueObjectHasKey(item, "default") != 1) {
-        virBufferAsprintf(data->debug, "ERROR: missing mandatory attribute '%s'\n",
+        virBufferAsprintf(data->ctxt->debug, "ERROR: missing mandatory attribute '%s'\n",
                           NULLSTR(virJSONValueObjectGetString(item, "name")));
         data->missingMandatory = true;
     }
@@ -253,22 +255,20 @@ testQEMUSchemaValidateObjectMandatoryMember(size_t pos G_GNUC_UNUSED,
 static int
 testQEMUSchemaValidateObject(virJSONValuePtr obj,
                              virJSONValuePtr root,
-                             virHashTablePtr schema,
-                             virBufferPtr debug)
+                             struct testQEMUSchemaValidateCtxt *ctxt)
 {
-    struct testQEMUSchemaValidateObjectMemberData data = { NULL, schema,
-                                                           debug, false };
+    struct testQEMUSchemaValidateObjectMemberData data = { NULL, ctxt, false };
     g_autoptr(virJSONValue) localroot = NULL;
     const char *variantfield;
     const char *variantname;

     if (virJSONValueGetType(obj) != VIR_JSON_TYPE_OBJECT) {
-        virBufferAddLit(debug, "ERROR: not an object");
+        virBufferAddLit(ctxt->debug, "ERROR: not an object");
         return -1;
     }

-    virBufferAddLit(debug, "{\n");
-    virBufferAdjustIndent(debug, 3);
+    virBufferAddLit(ctxt->debug, "{\n");
+    virBufferAdjustIndent(ctxt->debug, 3);

     /* copy schema */
     if (!(localroot = virJSONValueCopy(root)))
@@ -277,14 +277,13 @@ testQEMUSchemaValidateObject(virJSONValuePtr obj,
     /* remove variant */
     if ((variantfield = virJSONValueObjectGetString(localroot, "tag"))) {
         if (!(variantname = virJSONValueObjectGetString(obj, variantfield))) {
-            virBufferAsprintf(debug, "ERROR: missing variant discriminator attribute '%s'\n",
+            virBufferAsprintf(ctxt->debug, "ERROR: missing variant discriminator attribute '%s'\n",
                               variantfield);
             return -1;
         }

         if (testQEMUSchemaValidateObjectMergeVariant(localroot, variantfield,
-                                                     variantname,
-                                                     schema, debug) < 0)
+                                                     variantname, ctxt) < 0)
             return -1;
     }

@@ -306,8 +305,8 @@ testQEMUSchemaValidateObject(virJSONValuePtr obj,
     if (data.missingMandatory)
         return -1;

-    virBufferAdjustIndent(debug, -3);
-    virBufferAddLit(debug, "} OK");
+    virBufferAdjustIndent(ctxt->debug, -3);
+    virBufferAddLit(ctxt->debug, "} OK");
     return 0;
 }

@@ -315,7 +314,7 @@ testQEMUSchemaValidateObject(virJSONValuePtr obj,
 static int
 testQEMUSchemaValidateEnum(virJSONValuePtr obj,
                            virJSONValuePtr root,
-                           virBufferPtr debug)
+                           struct testQEMUSchemaValidateCtxt *ctxt)
 {
     const char *objstr;
     virJSONValuePtr values = NULL;
@@ -323,14 +322,14 @@ testQEMUSchemaValidateEnum(virJSONValuePtr obj,
     size_t i;

     if (virJSONValueGetType(obj) != VIR_JSON_TYPE_STRING) {
-        virBufferAddLit(debug, "ERROR: not a string");
+        virBufferAddLit(ctxt->debug, "ERROR: not a string");
         return -1;
     }

     objstr = virJSONValueGetString(obj);

     if (!(values = virJSONValueObjectGetArray(root, "values"))) {
-        virBufferAsprintf(debug, "ERROR: missing enum values in schema '%s'",
+        virBufferAsprintf(ctxt->debug, "ERROR: missing enum values in schema '%s'",
                           NULLSTR(virJSONValueObjectGetString(root, "name")));
         return -2;
     }
@@ -339,12 +338,12 @@ testQEMUSchemaValidateEnum(virJSONValuePtr obj,
         value = virJSONValueArrayGet(values, i);

         if (STREQ_NULLABLE(objstr, virJSONValueGetString(value))) {
-            virBufferAsprintf(debug, "'%s' OK", NULLSTR(objstr));
+            virBufferAsprintf(ctxt->debug, "'%s' OK", NULLSTR(objstr));
             return 0;
         }
     }

-    virBufferAsprintf(debug, "ERROR: enum value '%s' is not in schema",
+    virBufferAsprintf(ctxt->debug, "ERROR: enum value '%s' is not in schema",
                       NULLSTR(objstr));
     return -1;
 }
@@ -353,8 +352,7 @@ testQEMUSchemaValidateEnum(virJSONValuePtr obj,
 static int
 testQEMUSchemaValidateArray(virJSONValuePtr objs,
                             virJSONValuePtr root,
-                            virHashTablePtr schema,
-                            virBufferPtr debug)
+                            struct testQEMUSchemaValidateCtxt *ctxt)
 {
     const char *elemtypename = virJSONValueObjectGetString(root, "element-type");
     virJSONValuePtr elementschema;
@@ -362,29 +360,29 @@ testQEMUSchemaValidateArray(virJSONValuePtr objs,
     size_t i;

     if (virJSONValueGetType(objs) != VIR_JSON_TYPE_ARRAY) {
-        virBufferAddLit(debug, "ERROR: not an array\n");
+        virBufferAddLit(ctxt->debug, "ERROR: not an array\n");
         return -1;
     }

     if (!elemtypename ||
-        !(elementschema = virHashLookup(schema, elemtypename))) {
-        virBufferAsprintf(debug, "ERROR: missing schema for array element type '%s'",
+        !(elementschema = virHashLookup(ctxt->schema, elemtypename))) {
+        virBufferAsprintf(ctxt->debug, "ERROR: missing schema for array element type '%s'",
                          NULLSTR(elemtypename));
         return -2;
     }

-    virBufferAddLit(debug, "[\n");
-    virBufferAdjustIndent(debug, 3);
+    virBufferAddLit(ctxt->debug, "[\n");
+    virBufferAdjustIndent(ctxt->debug, 3);

     for (i = 0; i < virJSONValueArraySize(objs); i++) {
         obj = virJSONValueArrayGet(objs, i);

-        if (testQEMUSchemaValidateRecurse(obj, elementschema, schema, debug) < 0)
+        if (testQEMUSchemaValidateRecurse(obj, elementschema, ctxt) < 0)
             return -1;
-        virBufferAddLit(debug, ",\n");
+        virBufferAddLit(ctxt->debug, ",\n");
     }
-    virBufferAddLit(debug, "] OK");
-    virBufferAdjustIndent(debug, -3);
+    virBufferAddLit(ctxt->debug, "] OK");
+    virBufferAdjustIndent(ctxt->debug, -3);

     return 0;
 }
@@ -392,8 +390,7 @@ testQEMUSchemaValidateArray(virJSONValuePtr objs,
 static int
 testQEMUSchemaValidateAlternate(virJSONValuePtr obj,
                                 virJSONValuePtr root,
-                                virHashTablePtr schema,
-                                virBufferPtr debug)
+                                struct testQEMUSchemaValidateCtxt *ctxt)
 {
     virJSONValuePtr members;
     virJSONValuePtr member;
@@ -405,44 +402,44 @@ testQEMUSchemaValidateAlternate(virJSONValuePtr obj,
     int rc;

     if (!(members = virJSONValueObjectGetArray(root, "members"))) {
-        virBufferAddLit(debug, "ERROR: missing 'members' for alternate schema");
+        virBufferAddLit(ctxt->debug, "ERROR: missing 'members' for alternate schema");
         return -2;
     }

-    virBufferAddLit(debug, "(\n");
-    virBufferAdjustIndent(debug, 3);
-    indent = virBufferGetIndent(debug);
+    virBufferAddLit(ctxt->debug, "(\n");
+    virBufferAdjustIndent(ctxt->debug, 3);
+    indent = virBufferGetIndent(ctxt->debug);

     n = virJSONValueArraySize(members);
     for (i = 0; i < n; i++) {
         membertype = NULL;

         /* P != NP */
-        virBufferAsprintf(debug, "(alternate %zu/%zu)\n", i + 1, n);
-        virBufferAdjustIndent(debug, 3);
+        virBufferAsprintf(ctxt->debug, "(alternate %zu/%zu)\n", i + 1, n);
+        virBufferAdjustIndent(ctxt->debug, 3);

         if (!(member = virJSONValueArrayGet(members, i)) ||
             !(membertype = virJSONValueObjectGetString(member, "type")) ||
-            !(memberschema = virHashLookup(schema, membertype))) {
-            virBufferAsprintf(debug, "ERROR: missing schema for alternate type '%s'",
+            !(memberschema = virHashLookup(ctxt->schema, membertype))) {
+            virBufferAsprintf(ctxt->debug, "ERROR: missing schema for alternate type '%s'",
                               NULLSTR(membertype));
             return -2;
         }

-        rc = testQEMUSchemaValidateRecurse(obj, memberschema, schema, debug);
+        rc = testQEMUSchemaValidateRecurse(obj, memberschema, ctxt);

-        virBufferAddLit(debug, "\n");
-        virBufferSetIndent(debug, indent);
-        virBufferAsprintf(debug, "(/alternate %zu/%zu)\n", i + 1, n);
+        virBufferAddLit(ctxt->debug, "\n");
+        virBufferSetIndent(ctxt->debug, indent);
+        virBufferAsprintf(ctxt->debug, "(/alternate %zu/%zu)\n", i + 1, n);

         if (rc == 0) {
-            virBufferAdjustIndent(debug, -3);
-            virBufferAddLit(debug, ") OK");
+            virBufferAdjustIndent(ctxt->debug, -3);
+            virBufferAddLit(ctxt->debug, ") OK");
             return 0;
         }
     }

-    virBufferAddLit(debug, "ERROR: no alternate type was matched");
+    virBufferAddLit(ctxt->debug, "ERROR: no alternate type was matched");
     return -1;
 }

@@ -450,25 +447,24 @@ testQEMUSchemaValidateAlternate(virJSONValuePtr obj,
 static int
 testQEMUSchemaValidateRecurse(virJSONValuePtr obj,
                               virJSONValuePtr root,
-                              virHashTablePtr schema,
-                              virBufferPtr debug)
+                              struct testQEMUSchemaValidateCtxt *ctxt)
 {
     const char *n = virJSONValueObjectGetString(root, "name");
     const char *t = virJSONValueObjectGetString(root, "meta-type");

     if (STREQ_NULLABLE(t, "builtin")) {
-        return testQEMUSchemaValidateBuiltin(obj, root, debug);
+        return testQEMUSchemaValidateBuiltin(obj, root, ctxt);
     } else if (STREQ_NULLABLE(t, "object")) {
-        return testQEMUSchemaValidateObject(obj, root, schema, debug);
+        return testQEMUSchemaValidateObject(obj, root, ctxt);
     } else if (STREQ_NULLABLE(t, "enum")) {
-        return testQEMUSchemaValidateEnum(obj, root, debug);
+        return testQEMUSchemaValidateEnum(obj, root, ctxt);
     } else if (STREQ_NULLABLE(t, "array")) {
-        return testQEMUSchemaValidateArray(obj, root, schema, debug);
+        return testQEMUSchemaValidateArray(obj, root, ctxt);
     } else if (STREQ_NULLABLE(t, "alternate")) {
-        return testQEMUSchemaValidateAlternate(obj, root, schema, debug);
+        return testQEMUSchemaValidateAlternate(obj, root, ctxt);
     }

-    virBufferAsprintf(debug,
+    virBufferAsprintf(ctxt->debug,
                       "qapi schema meta-type '%s' of type '%s' not handled\n",
                       NULLSTR(t), NULLSTR(n));
     return -2;
@@ -494,7 +490,9 @@ testQEMUSchemaValidate(virJSONValuePtr obj,
                        virHashTablePtr schema,
                        virBufferPtr debug)
 {
-    return testQEMUSchemaValidateRecurse(obj, root, schema, debug);
+    struct testQEMUSchemaValidateCtxt ctxt = { .schema = schema,
+                                               .debug = debug };
+    return testQEMUSchemaValidateRecurse(obj, root, &ctxt);
 }


@@ -518,6 +516,8 @@ testQEMUSchemaValidateCommand(const char *command,
                               virHashTablePtr schema,
                               virBufferPtr debug)
 {
+    struct testQEMUSchemaValidateCtxt ctxt = { .schema = schema,
+                                               .debug = debug };
     g_autofree char *schemapatharguments = g_strdup_printf("%s/arg-type", command);
     g_autoptr(virJSONValue) emptyargs = NULL;
     virJSONValuePtr schemarootcommand;
@@ -538,7 +538,7 @@ testQEMUSchemaValidateCommand(const char *command,
         return -1;
     }

-    return testQEMUSchemaValidateRecurse(arguments, schemarootarguments, schema, debug);
+    return testQEMUSchemaValidateRecurse(arguments, schemarootarguments, &ctxt);
 }


-- 
2.26.2





[Index of Archives]     [Virt Tools]     [Libvirt Users]     [Lib OS Info]     [Fedora Users]     [Fedora Desktop]     [Fedora SELinux]     [Big List of Linux Books]     [Yosemite News]     [KDE Users]     [Fedora Tools]

  Powered by Linux