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

[libvirt] [PATCH 1/5] util: multi-value virTypedParameter



The `virTypedParamsValidate' function now can be instructed to allow
multiple entries for some of the keys. For this flag the type with
the `VIR_TYPED_PARAM_MULTIPLE' flag.

Add unit tests for this new behaviour.

Signed-off-by: Pavel Boldin <pboldin mirantis com>
---
 include/libvirt/libvirt-host.h |   8 ++
 src/util/virtypedparam.c       | 107 ++++++++++++++++---------
 tests/Makefile.am              |   6 ++
 tests/virtypedparamtest.c      | 177 +++++++++++++++++++++++++++++++++++++++++
 4 files changed, 259 insertions(+), 39 deletions(-)
 create mode 100644 tests/virtypedparamtest.c

diff --git a/include/libvirt/libvirt-host.h b/include/libvirt/libvirt-host.h
index 953366b..a3e8b88 100644
--- a/include/libvirt/libvirt-host.h
+++ b/include/libvirt/libvirt-host.h
@@ -180,6 +180,14 @@ typedef enum {
 } virTypedParameterType;
 
 /**
+ * VIR_TYPED_PARAM_MULTIPLE:
+ *
+ * Flag indiciating that the params has multiple occurences of the parameter.
+ * Only used as a flag for @type argument of the virTypedParamsValidate.
+ */
+# define VIR_TYPED_PARAM_MULTIPLE (1 << 31)
+
+/**
  * virTypedParameterFlags:
  *
  * Flags related to libvirt APIs that use virTypedParameter.
diff --git a/src/util/virtypedparam.c b/src/util/virtypedparam.c
index de2d447..bd47609 100644
--- a/src/util/virtypedparam.c
+++ b/src/util/virtypedparam.c
@@ -47,11 +47,18 @@ VIR_ENUM_IMPL(virTypedParameter, VIR_TYPED_PARAM_LAST,
  * internal utility functions (those in libvirt_private.syms) may
  * report errors that the caller will dispatch.  */
 
+static int _virTypedParamsSortName(const void *left, const void *right)
+{
+    const virTypedParameter *param_left = left, *param_right = right;
+    return strcmp(param_left->field, param_right->field);
+}
+
 /* Validate that PARAMS contains only recognized parameter names with
- * correct types, and with no duplicates.  Pass in as many name/type
- * pairs as appropriate, and pass NULL to end the list of accepted
- * parameters.  Return 0 on success, -1 on failure with error message
- * already issued.  */
+ * correct types, and with no duplicates except for parameters
+ * specified with VIR_TYPED_PARAM_MULTIPLE flag in type.
+ * Pass in as many name/type pairs as appropriate, and pass NULL to end
+ * the list of accepted parameters.  Return 0 on success, -1 on failure
+ * with error message already issued.  */
 int
 virTypedParamsValidate(virTypedParameterPtr params, int nparams, ...)
 {
@@ -60,60 +67,82 @@ virTypedParamsValidate(virTypedParameterPtr params, int nparams, ...)
     size_t i, j;
     const char *name;
     int type;
+    size_t nkeys = 0, nkeysmax = 0;
+    virTypedParameterPtr sorted = NULL, keys = NULL;
 
     va_start(ap, nparams);
 
-    /* Yes, this is quadratic, but since we reject duplicates and
-     * unknowns, it is constrained by the number of var-args passed
-     * in, which is expected to be small enough to not be
-     * noticeable.  */
-    for (i = 0; i < nparams; i++) {
-        va_end(ap);
-        va_start(ap, nparams);
+    if (VIR_ALLOC_N(sorted, nparams) < 0)
+        goto cleanup;
 
-        name = va_arg(ap, const char *);
-        while (name) {
-            type = va_arg(ap, int);
-            if (STREQ(params[i].field, name)) {
-                if (params[i].type != type) {
-                    const char *badtype;
-
-                    badtype = virTypedParameterTypeToString(params[i].type);
-                    if (!badtype)
-                        badtype = virTypedParameterTypeToString(0);
-                    virReportError(VIR_ERR_INVALID_ARG,
-                                   _("invalid type '%s' for parameter '%s', "
-                                     "expected '%s'"),
-                                   badtype, params[i].field,
-                                   virTypedParameterTypeToString(type));
-                }
-                break;
-            }
-            name = va_arg(ap, const char *);
-        }
-        if (!name) {
-            virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED,
-                           _("parameter '%s' not supported"),
-                           params[i].field);
+    /* Here we intentially don't copy values */
+    memcpy(sorted, params, sizeof(*params) * nparams);
+    qsort(sorted, nparams, sizeof(*sorted), _virTypedParamsSortName);
+
+    name = va_arg(ap, const char *);
+    while (name) {
+        type = va_arg(ap, int);
+        if (VIR_RESIZE_N(keys, nkeysmax, nkeys, 1) < 0)
+            goto cleanup;
+
+        if (virStrcpyStatic(keys[nkeys].field, name) == NULL) {
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("Field name '%s' too long"), name);
             goto cleanup;
         }
-        for (j = 0; j < i; j++) {
-            if (STREQ(params[i].field, params[j].field)) {
+
+        keys[nkeys].type = type & ~VIR_TYPED_PARAM_MULTIPLE;
+        /* Value is not used anyway */
+        keys[nkeys].value.i = type & VIR_TYPED_PARAM_MULTIPLE;
+
+        nkeys++;
+        name = va_arg(ap, const char *);
+    }
+
+    qsort(keys, nkeys, sizeof(*keys), _virTypedParamsSortName);
+
+    for (i = 0, j = 0; i < nparams && j < nkeys;) {
+        if (STRNEQ(sorted[i].field, keys[j].field)) {
+            j++;
+        } else {
+            if (i > j && !(keys[j].value.i & VIR_TYPED_PARAM_MULTIPLE)) {
                 virReportError(VIR_ERR_INVALID_ARG,
                                _("parameter '%s' occurs multiple times"),
-                               params[i].field);
+                               sorted[i].field);
                 goto cleanup;
             }
+            if (sorted[i].type != keys[j].type) {
+                const char *badtype;
+
+                badtype = virTypedParameterTypeToString(sorted[i].type);
+                if (!badtype)
+                    badtype = virTypedParameterTypeToString(0);
+                virReportError(VIR_ERR_INVALID_ARG,
+                               _("invalid type '%s' for parameter '%s', "
+                                 "expected '%s'"),
+                               badtype, sorted[i].field,
+                               virTypedParameterTypeToString(keys[j].type));
+            }
+            i++;
         }
     }
 
+    if (j == nkeys && i != nparams) {
+        virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED,
+                       _("parameter '%s' not supported"),
+                       sorted[i].field);
+        goto cleanup;
+    }
+
     ret = 0;
  cleanup:
     va_end(ap);
+    VIR_FREE(sorted);
+    VIR_FREE(keys);
     return ret;
-
 }
 
+
 /* Check if params contains only specified parameter names. Return true if
  * only specified names are present in params, false if params contains any
  * unspecified parameter name. */
diff --git a/tests/Makefile.am b/tests/Makefile.am
index 8e2dbec..9efb441 100644
--- a/tests/Makefile.am
+++ b/tests/Makefile.am
@@ -182,6 +182,7 @@ test_programs = virshtest sockettest \
 	virhostdevtest \
 	vircaps2xmltest \
 	virnetdevtest \
+	virtypedparamtest \
 	$(NULL)
 
 if WITH_REMOTE
@@ -1225,6 +1226,11 @@ objecteventtest_SOURCES = \
 	testutils.c testutils.h
 objecteventtest_LDADD = $(LDADDS)
 
+virtypedparamtest_SOURCES = \
+	virtypedparamtest.c testutils.h testutils.c
+virtypedparamtest_LDADD = $(LDADDS)
+
+
 if WITH_LINUX
 fchosttest_SOURCES = \
        fchosttest.c testutils.h testutils.c
diff --git a/tests/virtypedparamtest.c b/tests/virtypedparamtest.c
new file mode 100644
index 0000000..27b7e60
--- /dev/null
+++ b/tests/virtypedparamtest.c
@@ -0,0 +1,177 @@
+/*
+ * virtypedparamtest.c: Test typed param functions
+ *
+ * Copyright (C) 2015 Mirantis, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library.  If not, see
+ * <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <config.h>
+
+#include <stdio.h>
+#include <virtypedparam.h>
+
+#include "testutils.h"
+
+#define VIR_FROM_THIS VIR_FROM_NONE
+
+typedef struct _TypedParameterTest {
+    /* Test name for logging */
+    const char          *name;
+    /* Flags of the "foobar" parameter check */
+    int                  foobar_flags;
+    /* Parameters to validate */
+    virTypedParameterPtr params;
+    /* Amount of parameters */
+    int                  nparams;
+
+    /* Expected error code */
+    int                  expected_errcode;
+    /* Expected error message */
+    const char          *expected_errmessage;
+} TypedParameterTest;
+
+static int
+testTypedParamsValidate(const void *opaque)
+{
+    int rv;
+    TypedParameterTest *test = (TypedParameterTest *)opaque;
+    virErrorPtr errptr;
+
+    rv = virTypedParamsValidate(
+            test->params, test->nparams,
+            "foobar", VIR_TYPED_PARAM_STRING | test->foobar_flags,
+            "foo", VIR_TYPED_PARAM_INT,
+            "bar", VIR_TYPED_PARAM_UINT,
+            NULL);
+
+    if (test->expected_errcode) {
+        errptr = virGetLastError();
+
+        rv = (errptr == NULL) || ((rv < 0) &&
+                                  !(errptr->code == test->expected_errcode));
+        if (errptr && test->expected_errmessage) {
+            rv = STRNEQ(test->expected_errmessage, errptr->message);
+            if (rv)
+                printf("%s\n", errptr->message);
+        }
+    }
+
+    return rv;
+}
+
+#define TEST(testname) {                    \
+                        .name = testname,
+
+#define ENDTEST    },
+
+#define FOOBAR_SINGLE   .foobar_flags = 0,
+#define FOOBAR_MULTIPLE .foobar_flags = VIR_TYPED_PARAM_MULTIPLE,
+
+#define EXPECTED_OK .expected_errcode = 0, .expected_errmessage = NULL,
+#define EXPECTED_ERROR(code, msg) .expected_errcode = code, \
+                                  .expected_errmessage = msg,
+
+#define PARAMS_ARRAY(...) ((virTypedParameter[]){ __VA_ARGS__ })
+#define PARAMS_SIZE(...) ARRAY_CARDINALITY(PARAMS_ARRAY(__VA_ARGS__))
+
+#define PARAMS(...) \
+    .params  = PARAMS_ARRAY(__VA_ARGS__), \
+    .nparams = PARAMS_SIZE(__VA_ARGS__),
+
+#define PARAM(field_, type_) { .field = field_, .type = type_ }
+
+static int
+testTypedParamsValidator(void)
+{
+    size_t i;
+    int rv = 0;
+
+    TypedParameterTest test[] = {
+        TEST("Invalid arg type")
+            FOOBAR_SINGLE
+            PARAMS(PARAM("foobar", VIR_TYPED_PARAM_INT))
+            EXPECTED_ERROR(
+                VIR_ERR_INVALID_ARG,
+                "invalid argument: invalid type 'int' for parameter "
+                "'foobar', expected 'string'"
+            )
+        ENDTEST
+        TEST("Extra arg")
+            FOOBAR_SINGLE
+            PARAMS(PARAM("f", VIR_TYPED_PARAM_INT))
+            EXPECTED_ERROR(
+                VIR_ERR_INVALID_ARG,
+                "argument unsupported: parameter 'f' not supported"
+            )
+        ENDTEST
+        TEST("Valid parameters")
+            FOOBAR_SINGLE
+            PARAMS(
+                PARAM("bar",    VIR_TYPED_PARAM_UINT),
+                PARAM("foobar", VIR_TYPED_PARAM_STRING),
+                PARAM("foo",    VIR_TYPED_PARAM_INT)
+            )
+            EXPECTED_OK
+        ENDTEST
+        TEST("Duplicates incorrect")
+            FOOBAR_SINGLE
+            PARAMS(
+                PARAM("bar",    VIR_TYPED_PARAM_UINT),
+                PARAM("foobar", VIR_TYPED_PARAM_STRING),
+                PARAM("foobar", VIR_TYPED_PARAM_STRING),
+                PARAM("foo",    VIR_TYPED_PARAM_INT)
+            )
+            EXPECTED_ERROR(
+                VIR_ERR_INVALID_ARG,
+                "invalid argument: parameter 'foobar' occurs multiple times"
+            )
+        ENDTEST
+        TEST("Duplicates OK for marked")
+            FOOBAR_MULTIPLE
+            PARAMS(
+                PARAM("bar",    VIR_TYPED_PARAM_UINT),
+                PARAM("foobar", VIR_TYPED_PARAM_STRING),
+                PARAM("foobar", VIR_TYPED_PARAM_STRING),
+                PARAM("foo",    VIR_TYPED_PARAM_INT)
+            )
+            EXPECTED_OK
+        },
+        TEST(NULL) ENDTEST
+    };
+
+    for (i = 0; test[i].name; ++i) {
+        if (virtTestRun(test[i].name, testTypedParamsValidate, &test[i]) < 0)
+            rv = -1;
+    }
+
+    return rv;
+}
+
+static int
+mymain(void)
+{
+    int rv = 0;
+
+    if (testTypedParamsValidator() < 0)
+        rv = -1;
+
+    if (rv < 0)
+        return EXIT_FAILURE;
+    return EXIT_SUCCESS;
+}
+
+VIRT_TEST_MAIN(mymain)
-- 
1.9.1


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