1 files changed, 301 insertions, 0 deletions
diff --git a/src/util/profile/test_vtable.c b/src/util/profile/test_vtable.c
new file mode 100644
index 0000000000..115eed1e21
--- /dev/null
+++ b/src/util/profile/test_vtable.c
@@ -0,0 +1,301 @@
+/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/* util/profile/test_vtable.c - Test program for vtable-backed profiles */
+/*
+ * Copyright (C) 2011 by the Massachusetts Institute of Technology.
+ * All rights reserved.
+ *
+ * Export of this software from the United States of America may
+ *   require a specific license from the United States Government.
+ *   It is the responsibility of any person or organization contemplating
+ *   export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation, and that
+ * the name of M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ */
+
+/*
+ * This test program exercises vtable profile functionality using two vtables,
+ * one which implements just the basic methods and one which implements all of
+ * the methods.  The program doesn't attempt to create a working profile
+ * implementation; it just verifies the expected control flow into the vtable
+ * and back out to the caller.
+ */
+
+#include <k5-platform.h>
+#include "profile.h"
+
+static int basic_cbdata;
+static int full_cbdata;
+static const char *empty_names[] = { NULL };
+static const char *name_string = "get_string";
+static const char *name_int = "get_int";
+static const char *name_bool = "get_bool";
+
+static long
+basic_get_values(void *cbdata, const char *const *names, char ***ret_values)
+{
+    assert(cbdata == &basic_cbdata);
+    assert(names == empty_names);
+    *ret_values = calloc(3, sizeof(*ret_values));
+    (*ret_values)[0] = strdup("one");
+    (*ret_values)[1] = strdup("two");
+    (*ret_values)[2] = NULL;
+    return 0;
+}
+
+static void
+free_values(void *cbdata, char **values)
+{
+    char **v;
+
+    for (v = values; *v; v++)
+	free(*v);
+    free(values);
+}
+
+static long
+full_get_values(void *cbdata, const char *const *names, char ***ret_values)
+{
+    assert(cbdata == &full_cbdata);
+    *ret_values = calloc(2, sizeof(*ret_values));
+    if (names[0] == name_string)
+	(*ret_values)[0] = strdup("string result");
+    else if (names[0] == name_int)
+	(*ret_values)[0] = strdup("23");
+    else if (names[0] == name_bool)
+	(*ret_values)[0] = strdup("on");
+    else {
+	free(*ret_values);
+	return PROF_NO_RELATION;
+    }
+    (*ret_values)[1] = NULL;
+    return 0;
+}
+
+static void
+full_cleanup(void *cbdata)
+{
+    assert(cbdata == &full_cbdata);
+}
+
+static void
+full_copy(void *cbdata, void **ret_cbdata)
+{
+    assert(cbdata == &full_cbdata);
+    *ret_cbdata = &full_cbdata;
+}
+
+struct iterator {
+    int count;
+};
+
+static long
+full_iterator_create(void *cbdata, const char *const *names, int flags,
+		     void **ret_iter)
+{
+    struct iterator *iter;
+
+    assert(cbdata == &full_cbdata);
+    assert(names == empty_names);
+    assert(flags == 126);
+    iter = malloc(sizeof(*iter));
+    iter->count = 0;
+    *ret_iter = iter;
+    return 0;
+}
+
+static long
+full_iterator(void *cbdata, void *iter_arg, char **ret_name, char **ret_value)
+{
+    struct iterator *iter = iter_arg;
+
+    assert(cbdata == &full_cbdata);
+    assert(iter->count >= 0 && iter->count <= 2);
+    if (iter->count == 0) {
+	*ret_name = strdup("name1");
+	*ret_value = strdup("value1");
+    } else if (iter->count == 1) {
+	*ret_name = strdup("name2");
+	*ret_value = NULL;
+    } else {
+	*ret_name = NULL;
+	*ret_value = NULL;
+    }
+    iter->count++;
+    return 0;
+}
+
+static void
+full_iterator_free(void *cbdata, void *iter_arg)
+{
+    struct iterator *iter = iter_arg;
+    
+    assert(cbdata == &full_cbdata);
+    assert(iter->count == 3);
+    free(iter);
+}
+
+static void
+full_free_string(void *cbdata, char *string)
+{
+    assert(cbdata == &full_cbdata);
+    free(string);
+}
+
+static long
+full_writable(void *cbdata, int *writable)
+{
+    assert(cbdata == &full_cbdata);
+    *writable = 12;
+    return 0;
+}
+
+static long
+full_modified(void *cbdata, int *modified)
+{
+    assert(cbdata == &full_cbdata);
+    *modified = 6;
+    return 0;
+}
+
+static long
+full_update_relation(void *cbdata, const char **names,
+		     const char *old_value, const char *new_value)
+{
+    assert(cbdata == &full_cbdata);
+    assert(names == empty_names);
+    assert(old_value == name_string || old_value == NULL);
+    assert(new_value == NULL);
+    return 0;
+}
+
+static long
+full_rename_section(void *cbdata, const char **names, const char *new_name)
+{
+    assert(cbdata == &full_cbdata);
+    assert(names == empty_names);
+    assert(new_name == name_int);
+    return 0;
+}
+
+static long
+full_add_relation(void *cbdata, const char **names, const char *new_value)
+{
+    assert(cbdata == &full_cbdata);
+    assert(names == empty_names);
+    assert(new_value == name_bool);
+    return 0;
+}
+
+static long
+full_flush(void *cbdata)
+{
+    assert(cbdata == &full_cbdata);
+}
+
+struct profile_vtable basic_vtable = {
+    1,
+    basic_get_values,
+    free_values,
+};
+
+struct profile_vtable full_vtable = {
+    1,
+    full_get_values,
+    free_values,
+    full_cleanup,
+    full_copy,
+
+    full_iterator_create,
+    full_iterator,
+    full_iterator_free,
+    full_free_string,
+
+    full_writable,
+    full_modified,
+    full_update_relation,
+    full_rename_section,
+    full_add_relation,
+    full_flush
+};
+
+int main()
+{
+    profile_t profile;
+    char **values, *str, *name, *value;
+    void *iter;
+    int intval;
+
+    assert(profile_init_vtable(&basic_vtable, &basic_cbdata, &profile) == 0);
+    assert(profile_get_values(profile, empty_names, &values) == 0);
+    assert(strcmp(values[0], "one") == 0);
+    assert(strcmp(values[1], "two") == 0);
+    assert(values[2] == NULL);
+    profile_free_list(values);
+    assert(profile_iterator_create(profile, NULL, 0, &iter) ==
+	   PROF_UNSUPPORTED);
+    assert(profile_is_writable(profile, &intval) == 0);
+    assert(intval == 0);
+    assert(profile_is_modified(profile, &intval) == 0);
+    assert(intval == 0);
+    assert(profile_update_relation(profile, NULL, NULL, NULL) ==
+	   PROF_UNSUPPORTED);
+    assert(profile_clear_relation(profile, NULL) == PROF_UNSUPPORTED);
+    assert(profile_rename_section(profile, NULL, NULL) == PROF_UNSUPPORTED);
+    assert(profile_add_relation(profile, NULL, NULL) == PROF_UNSUPPORTED);
+    profile_flush(profile);
+    profile_abandon(profile);
+
+    assert(profile_init_vtable(&full_vtable, &full_cbdata, &profile) == 0);
+    assert(profile_get_string(profile, name_string, NULL, NULL, "wrong",
+			      &str) == 0);
+    assert(strcmp(str, "string result") == 0);
+    profile_release_string(str);
+    assert(profile_get_integer(profile, name_int, NULL, NULL, 24,
+			       &intval) == 0);
+    assert(intval == 23);
+    assert(profile_get_boolean(profile, name_bool, NULL, NULL, 0,
+			       &intval) == 0);
+    assert(intval == 1);
+    assert(profile_get_integer(profile, "xxx", NULL, NULL, 62, &intval) == 0);
+    assert(intval == 62);
+
+    assert(profile_iterator_create(profile, empty_names, 126, &iter) == 0);
+    assert(profile_iterator(&iter, &name, &value) == 0);
+    assert(strcmp(name, "name1") == 0);
+    assert(strcmp(value, "value1") == 0);
+    profile_release_string(name);
+    profile_release_string(value);
+    assert(profile_iterator(&iter, &name, &value) == 0);
+    assert(strcmp(name, "name2") == 0);
+    assert(value == NULL);
+    profile_release_string(name);
+    assert(profile_iterator(&iter, &name, &value) == 0);
+    assert(iter == NULL);
+    assert(name == NULL);
+    assert(value == NULL);
+
+    assert(profile_is_writable(profile, &intval) == 0);
+    assert(intval == 12);
+    assert(profile_is_modified(profile, &intval) == 0);
+    assert(intval == 6);
+    assert(profile_update_relation(profile, empty_names, name_string,
+				   NULL) == 0);
+    assert(profile_clear_relation(profile, empty_names) == 0);
+    assert(profile_rename_section(profile, empty_names, name_int) == 0);
+    assert(profile_add_relation(profile, empty_names, name_bool) == 0);
+    profile_release(profile);
+
+    return 0;
+}