/* Authors: Pavel Březina Copyright (C) 2014 Red Hat This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program 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 General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ #include #include #include "tests/cmocka/common_mock.h" #include "lib/sifp/sss_sifp.h" #include "lib/sifp/sss_sifp_dbus.h" #include "lib/sifp/sss_sifp_private.h" struct { sss_sifp_ctx *dbus_ctx; DBusMessage *reply; } test_ctx; DBusConnection * __wrap_dbus_bus_get(DBusBusType type, DBusError *error) { /* we won't use the connection anywhere, so we can just return NULL */ return NULL; } DBusMessage * __wrap_dbus_connection_send_with_reply_and_block(DBusConnection *connection, DBusMessage *message, int timeout_milliseconds, DBusError *error) { if (message == NULL || error == NULL) { return NULL; } return sss_mock_ptr_type(DBusMessage *); } static void reply_variant_basic(DBusMessage *reply, const char *type, const void *val) { DBusMessageIter iter; DBusMessageIter variant_iter; dbus_bool_t bret; dbus_message_iter_init_append(reply, &iter); bret = dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT, type, &variant_iter); assert_true(bret); /* Now add the value */ bret = dbus_message_iter_append_basic(&variant_iter, type[0], val); assert_true(bret); bret = dbus_message_iter_close_container(&iter, &variant_iter); assert_true(bret); } static void reply_variant_array(DBusMessage *reply, const char *type, int num_vals, uint8_t *vals, unsigned int item_size) { DBusMessageIter iter; DBusMessageIter variant_iter; DBusMessageIter array_iter; dbus_bool_t bret; char array_type[3]; int i; void *addr; array_type[0] = DBUS_TYPE_ARRAY; array_type[1] = type[0]; array_type[2] = '\0'; dbus_message_iter_init_append(reply, &iter); bret = dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT, array_type, &variant_iter); assert_true(bret); bret = dbus_message_iter_open_container(&variant_iter, DBUS_TYPE_ARRAY, type, &array_iter); assert_true(bret); for (i = 0; i < num_vals; i++) { addr = vals + i*item_size; bret = dbus_message_iter_append_basic(&array_iter, type[0], addr); assert_true(bret); } bret = dbus_message_iter_close_container(&iter, &array_iter); assert_true(bret); bret = dbus_message_iter_close_container(&iter, &variant_iter); assert_true(bret); } static void test_setup(void **state) { sss_sifp_error ret; ret = sss_sifp_init(&test_ctx.dbus_ctx); assert_int_equal(ret, SSS_SIFP_OK); test_ctx.reply = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN); assert_non_null(test_ctx.reply); } static void test_teardown_parser(void **state) { sss_sifp_free(&test_ctx.dbus_ctx); assert_null(test_ctx.dbus_ctx); dbus_message_unref(test_ctx.reply); test_ctx.reply = NULL; } static void test_teardown_api(void **state) { sss_sifp_free(&test_ctx.dbus_ctx); assert_null(test_ctx.dbus_ctx); /* sss_sifp is responsible for freeing the reply */ } void test_sss_sifp_strdup_valid(void **state) { const char *str = "test_string"; char *dup = sss_sifp_strdup(test_ctx.dbus_ctx, str); assert_non_null(dup); assert_string_equal(str, dup); sss_sifp_free_string(test_ctx.dbus_ctx, &dup); assert_null(dup); } void test_sss_sifp_strdup_null(void **state) { char *dup = sss_sifp_strdup(test_ctx.dbus_ctx, NULL); assert_null(dup); } void test_sss_sifp_strcat_valid(void **state) { char *cat = sss_sifp_strcat(test_ctx.dbus_ctx, "hello ", "world"); assert_non_null(cat); assert_string_equal("hello world", cat); sss_sifp_free_string(test_ctx.dbus_ctx, &cat); assert_null(cat); } void test_sss_sifp_strcat_left_null(void **state) { char *cat = sss_sifp_strcat(test_ctx.dbus_ctx, NULL, "world"); assert_non_null(cat); assert_string_equal("world", cat); sss_sifp_free_string(test_ctx.dbus_ctx, &cat); assert_null(cat); } void test_sss_sifp_strcat_right_null(void **state) { char *cat = sss_sifp_strcat(test_ctx.dbus_ctx, "hello ", NULL); assert_non_null(cat); assert_string_equal("hello ", cat); sss_sifp_free_string(test_ctx.dbus_ctx, &cat); assert_null(cat); } void test_sss_sifp_strcat_both_null(void **state) { char *cat = sss_sifp_strcat(test_ctx.dbus_ctx, NULL, NULL); assert_null(cat); } void test_sss_sifp_parse_object_path_valid(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; dbus_bool_t bret; sss_sifp_error ret; const char *path_in = "/object/path"; char *path_out = NULL; /* prepare message */ bret = dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &path_in, DBUS_TYPE_INVALID); assert_true(bret); /* test */ ret = sss_sifp_parse_object_path(ctx, reply, &path_out); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(path_out); assert_string_equal(path_in, path_out); sss_sifp_free_string(ctx, &path_out); assert_null(path_out); } void test_sss_sifp_parse_object_path_invalid(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; dbus_bool_t bret; sss_sifp_error ret; uint16_t path_in = 10; char *path_out = NULL; /* prepare message */ bret = dbus_message_append_args(reply, DBUS_TYPE_UINT16, &path_in, DBUS_TYPE_INVALID); assert_true(bret); /* test */ ret = sss_sifp_parse_object_path(ctx, reply, &path_out); assert_int_not_equal(ret, SSS_SIFP_OK); assert_null(path_out); } void test_sss_sifp_parse_object_path_list_valid(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; dbus_bool_t bret; sss_sifp_error ret; char **path_out = NULL; const char *path_in[] = {"/object/path1", "/object/path2"}; const char **paths = path_in; int path_in_len = 2; int i; /* prepare message */ bret = dbus_message_append_args(reply, DBUS_TYPE_ARRAY, DBUS_TYPE_OBJECT_PATH, &paths, path_in_len, DBUS_TYPE_INVALID); assert_true(bret); /* test */ ret = sss_sifp_parse_object_path_list(ctx, reply, &path_out); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(path_out); for (i = 0; path_out[i] != NULL; i++) { assert_true(i < path_in_len); assert_non_null(path_out[i]); assert_string_equal(path_in[i], path_out[i]); } sss_sifp_free_string_array(ctx, &path_out); assert_null(path_out); } void test_sss_sifp_parse_object_path_list_invalid(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; dbus_bool_t bret; sss_sifp_error ret; char **path_out = NULL; const char *path_in = "/object/path"; /* prepare message */ bret = dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &path_in, DBUS_TYPE_INVALID); assert_true(bret); /* test */ ret = sss_sifp_parse_object_path_list(ctx, reply, &path_out); assert_int_not_equal(ret, SSS_SIFP_OK); assert_null(path_out); } void test_sss_sifp_parse_attr_bool(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; sss_sifp_error ret; sss_sifp_attr **attrs = NULL; const char *name = "test-attr"; dbus_bool_t in = 1; bool out; /* prepare message */ reply_variant_basic(reply, DBUS_TYPE_BOOLEAN_AS_STRING, &in); /* test */ ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(attrs); assert_non_null(attrs[0]); assert_null(attrs[1]); assert_int_equal(attrs[0]->num_values, 1); assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_BOOL); assert_string_equal(attrs[0]->name, name); ret = sss_sifp_find_attr_as_bool(attrs, name, &out); assert_int_equal(ret, SSS_SIFP_OK); assert_true(in == out); sss_sifp_free_attrs(ctx, &attrs); assert_null(attrs); } void test_sss_sifp_parse_attr_int16(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; sss_sifp_error ret; sss_sifp_attr **attrs = NULL; const char *name = "test-attr"; int16_t in = INT16_MIN; int16_t out; /* prepare message */ reply_variant_basic(reply, DBUS_TYPE_INT16_AS_STRING, &in); /* test */ ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(attrs); assert_non_null(attrs[0]); assert_null(attrs[1]); assert_int_equal(attrs[0]->num_values, 1); assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_INT16); assert_string_equal(attrs[0]->name, name); ret = sss_sifp_find_attr_as_int16(attrs, name, &out); assert_int_equal(ret, SSS_SIFP_OK); assert_int_equal(in, out); sss_sifp_free_attrs(ctx, &attrs); assert_null(attrs); } void test_sss_sifp_parse_attr_uint16(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; sss_sifp_error ret; sss_sifp_attr **attrs = NULL; const char *name = "test-attr"; uint16_t in = UINT16_MAX; uint16_t out; /* prepare message */ reply_variant_basic(reply, DBUS_TYPE_UINT16_AS_STRING, &in); /* test */ ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(attrs); assert_non_null(attrs[0]); assert_null(attrs[1]); assert_int_equal(attrs[0]->num_values, 1); assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_UINT16); assert_string_equal(attrs[0]->name, name); ret = sss_sifp_find_attr_as_uint16(attrs, name, &out); assert_int_equal(ret, SSS_SIFP_OK); assert_int_equal(in, out); sss_sifp_free_attrs(ctx, &attrs); assert_null(attrs); } void test_sss_sifp_parse_attr_int32(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; sss_sifp_error ret; sss_sifp_attr **attrs = NULL; const char *name = "test-attr"; int32_t in = INT32_MIN; int32_t out; /* prepare message */ reply_variant_basic(reply, DBUS_TYPE_INT32_AS_STRING, &in); /* test */ ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(attrs); assert_non_null(attrs[0]); assert_null(attrs[1]); assert_int_equal(attrs[0]->num_values, 1); assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_INT32); assert_string_equal(attrs[0]->name, name); ret = sss_sifp_find_attr_as_int32(attrs, name, &out); assert_int_equal(ret, SSS_SIFP_OK); assert_int_equal(in, out); sss_sifp_free_attrs(ctx, &attrs); assert_null(attrs); } void test_sss_sifp_parse_attr_uint32(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; sss_sifp_error ret; sss_sifp_attr **attrs = NULL; const char *name = "test-attr"; uint32_t in = UINT32_MAX; uint32_t out; /* prepare message */ reply_variant_basic(reply, DBUS_TYPE_UINT32_AS_STRING, &in); /* test */ ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(attrs); assert_non_null(attrs[0]); assert_null(attrs[1]); assert_int_equal(attrs[0]->num_values, 1); assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_UINT32); assert_string_equal(attrs[0]->name, name); ret = sss_sifp_find_attr_as_uint32(attrs, name, &out); assert_int_equal(ret, SSS_SIFP_OK); assert_int_equal(in, out); sss_sifp_free_attrs(ctx, &attrs); assert_null(attrs); sss_sifp_free_attrs(ctx, &attrs); assert_null(attrs); } void test_sss_sifp_parse_attr_int64(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; sss_sifp_error ret; sss_sifp_attr **attrs = NULL; const char *name = "test-attr"; int64_t in = INT64_MIN; int64_t out; /* prepare message */ reply_variant_basic(reply, DBUS_TYPE_INT64_AS_STRING, &in); /* test */ ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(attrs); assert_non_null(attrs[0]); assert_null(attrs[1]); assert_int_equal(attrs[0]->num_values, 1); assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_INT64); assert_string_equal(attrs[0]->name, name); ret = sss_sifp_find_attr_as_int64(attrs, name, &out); assert_int_equal(ret, SSS_SIFP_OK); assert_int_equal(in, out); sss_sifp_free_attrs(ctx, &attrs); assert_null(attrs); } void test_sss_sifp_parse_attr_uint64(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; sss_sifp_error ret; sss_sifp_attr **attrs = NULL; const char *name = "test-attr"; uint64_t in = UINT64_MAX; uint64_t out; /* prepare message */ reply_variant_basic(reply, DBUS_TYPE_UINT64_AS_STRING, &in); /* test */ ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(attrs); assert_non_null(attrs[0]); assert_null(attrs[1]); assert_int_equal(attrs[0]->num_values, 1); assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_UINT64); assert_string_equal(attrs[0]->name, name); ret = sss_sifp_find_attr_as_uint64(attrs, name, &out); assert_int_equal(ret, SSS_SIFP_OK); assert_int_equal(in, out); sss_sifp_free_attrs(ctx, &attrs); assert_null(attrs); } void test_sss_sifp_parse_attr_string(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; sss_sifp_error ret; sss_sifp_attr **attrs = NULL; const char *name = "test-attr"; const char *in = "test value"; const char *out; /* prepare message */ reply_variant_basic(reply, DBUS_TYPE_STRING_AS_STRING, &in); /* test */ ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(attrs); assert_non_null(attrs[0]); assert_null(attrs[1]); assert_int_equal(attrs[0]->num_values, 1); assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_STRING); assert_string_equal(attrs[0]->name, name); ret = sss_sifp_find_attr_as_string(attrs, name, &out); assert_int_equal(ret, SSS_SIFP_OK); assert_string_equal(in, out); sss_sifp_free_attrs(ctx, &attrs); assert_null(attrs); } void test_sss_sifp_parse_attr_object_path(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; sss_sifp_error ret; sss_sifp_attr **attrs = NULL; const char *name = "test-attr"; const char *in = "/object/path"; const char *out; /* prepare message */ reply_variant_basic(reply, DBUS_TYPE_OBJECT_PATH_AS_STRING, &in); /* test */ ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(attrs); assert_non_null(attrs[0]); assert_null(attrs[1]); assert_int_equal(attrs[0]->num_values, 1); assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_STRING); assert_string_equal(attrs[0]->name, name); ret = sss_sifp_find_attr_as_string(attrs, name, &out); assert_int_equal(ret, SSS_SIFP_OK); assert_string_equal(in, out); sss_sifp_free_attrs(ctx, &attrs); assert_null(attrs); } void test_sss_sifp_parse_attr_string_dict(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; DBusMessageIter iter; DBusMessageIter var_iter; DBusMessageIter array_iter; DBusMessageIter dict_iter; dbus_bool_t bret; sss_sifp_error ret; sss_sifp_attr **attrs = NULL; const char *name = "test-attr"; struct { const char *key; const char *value; } data = {"key", "value"}; hash_table_t *out; hash_key_t key; hash_value_t value; char **values; int hret; /* prepare message */ dbus_message_iter_init_append(reply, &iter); bret = dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT, DBUS_TYPE_ARRAY_AS_STRING DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &var_iter); assert_true(bret); bret = dbus_message_iter_open_container(&var_iter, DBUS_TYPE_ARRAY, DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &array_iter); assert_true(bret); bret = dbus_message_iter_open_container(&array_iter, DBUS_TYPE_DICT_ENTRY, NULL, &dict_iter); assert_true(bret); bret = dbus_message_iter_append_basic(&dict_iter, DBUS_TYPE_STRING, &data.key); assert_true(bret); bret = dbus_message_iter_append_basic(&dict_iter, DBUS_TYPE_STRING, &data.value); assert_true(bret); bret = dbus_message_iter_close_container(&array_iter, &dict_iter); assert_true(bret); bret = dbus_message_iter_close_container(&var_iter, &array_iter); assert_true(bret); bret = dbus_message_iter_close_container(&iter, &var_iter); assert_true(bret); ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(attrs); assert_non_null(attrs[0]); assert_null(attrs[1]); assert_int_equal(attrs[0]->num_values, 1); assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_STRING_DICT); assert_string_equal(attrs[0]->name, name); ret = sss_sifp_find_attr_as_string_dict(attrs, name, &out); assert_int_equal(ret, SSS_SIFP_OK); assert_int_equal(hash_count(out), 1); key.type = HASH_KEY_STRING; key.str = discard_const(data.key); hret = hash_lookup(out, &key, &value); assert_int_equal(hret, HASH_SUCCESS); assert_int_equal(value.type, HASH_VALUE_PTR); assert_non_null(value.ptr); values = value.ptr; assert_non_null(values[0]); assert_string_equal(values[0], data.value); assert_null(values[1]); sss_sifp_free_attrs(ctx, &attrs); assert_null(attrs); } void test_sss_sifp_parse_attr_bool_array(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; sss_sifp_error ret; sss_sifp_attr **attrs = NULL; const char *name = "test-attr"; unsigned int num_values = 5; dbus_bool_t in_array[] = {1, 1, 0, 0, 1}; dbus_bool_t *in = in_array; unsigned int out_num; bool *out; unsigned int i; /* prepare message */ reply_variant_array(reply, DBUS_TYPE_BOOLEAN_AS_STRING, num_values, (uint8_t*)in, sizeof(dbus_bool_t)); /* test */ ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(attrs); assert_non_null(attrs[0]); assert_null(attrs[1]); assert_int_equal(attrs[0]->num_values, num_values); assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_BOOL); assert_string_equal(attrs[0]->name, name); ret = sss_sifp_find_attr_as_bool_array(attrs, name, &out_num, &out); assert_int_equal(ret, SSS_SIFP_OK); assert_int_equal(num_values, out_num); for (i = 0; i < num_values; i++) { assert_true(in[i] == out[i]); } sss_sifp_free_attrs(ctx, &attrs); assert_null(attrs); } void test_sss_sifp_parse_attr_bool_array_empty(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; sss_sifp_error ret; sss_sifp_attr **attrs = NULL; const char *name = "test-attr"; unsigned int num_values = 0; unsigned int out_num; bool *out; /* prepare message */ reply_variant_array(reply, DBUS_TYPE_BOOLEAN_AS_STRING, num_values, NULL, sizeof(dbus_bool_t)); /* test */ ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(attrs); assert_non_null(attrs[0]); assert_null(attrs[1]); assert_int_equal(attrs[0]->num_values, num_values); assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_BOOL); assert_string_equal(attrs[0]->name, name); ret = sss_sifp_find_attr_as_bool_array(attrs, name, &out_num, &out); assert_int_equal(ret, SSS_SIFP_ATTR_NULL); assert_int_equal(num_values, out_num); assert_null(out); sss_sifp_free_attrs(ctx, &attrs); assert_null(attrs); } void test_sss_sifp_parse_attr_int16_array(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; sss_sifp_error ret; sss_sifp_attr **attrs = NULL; const char *name = "test-attr"; unsigned int num_values = 5; int16_t in_array[] = {10, 15, -10, -15, 5559}; int16_t *in = in_array; unsigned int out_num; int16_t *out; unsigned int i; /* prepare message */ reply_variant_array(reply, DBUS_TYPE_INT16_AS_STRING, num_values, (uint8_t*)in, sizeof(int16_t)); /* test */ ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(attrs); assert_non_null(attrs[0]); assert_null(attrs[1]); assert_int_equal(attrs[0]->num_values, num_values); assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_INT16); assert_string_equal(attrs[0]->name, name); ret = sss_sifp_find_attr_as_int16_array(attrs, name, &out_num, &out); assert_int_equal(ret, SSS_SIFP_OK); assert_int_equal(num_values, out_num); for (i = 0; i < num_values; i++) { assert_int_equal(in[i], out[i]); } sss_sifp_free_attrs(ctx, &attrs); assert_null(attrs); } void test_sss_sifp_parse_attr_int16_array_empty(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; sss_sifp_error ret; sss_sifp_attr **attrs = NULL; const char *name = "test-attr"; unsigned int num_values = 0; unsigned int out_num; int16_t *out; /* prepare message */ reply_variant_array(reply, DBUS_TYPE_INT16_AS_STRING, num_values, NULL, sizeof(int16_t)); /* test */ ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(attrs); assert_non_null(attrs[0]); assert_null(attrs[1]); assert_int_equal(attrs[0]->num_values, num_values); assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_INT16); assert_string_equal(attrs[0]->name, name); ret = sss_sifp_find_attr_as_int16_array(attrs, name, &out_num, &out); assert_int_equal(ret, SSS_SIFP_ATTR_NULL); assert_int_equal(num_values, out_num); assert_null(out); sss_sifp_free_attrs(ctx, &attrs); assert_null(attrs); } void test_sss_sifp_parse_attr_uint16_array(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; sss_sifp_error ret; sss_sifp_attr **attrs = NULL; const char *name = "test-attr"; unsigned int num_values = 5; uint16_t in_array[] = {10, 15, 8885, 3224, 5559}; uint16_t *in = in_array; unsigned int out_num; uint16_t *out; unsigned int i; /* prepare message */ reply_variant_array(reply, DBUS_TYPE_UINT16_AS_STRING, num_values, (uint8_t*)in, sizeof(uint16_t)); /* test */ ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(attrs); assert_non_null(attrs[0]); assert_null(attrs[1]); assert_int_equal(attrs[0]->num_values, num_values); assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_UINT16); assert_string_equal(attrs[0]->name, name); ret = sss_sifp_find_attr_as_uint16_array(attrs, name, &out_num, &out); assert_int_equal(ret, SSS_SIFP_OK); assert_int_equal(num_values, out_num); for (i = 0; i < num_values; i++) { assert_int_equal(in[i], out[i]); } sss_sifp_free_attrs(ctx, &attrs); assert_null(attrs); } void test_sss_sifp_parse_attr_uint16_array_empty(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; sss_sifp_error ret; sss_sifp_attr **attrs = NULL; const char *name = "test-attr"; unsigned int num_values = 0; unsigned int out_num; uint16_t *out; /* prepare message */ reply_variant_array(reply, DBUS_TYPE_UINT16_AS_STRING, num_values, NULL, sizeof(uint16_t)); /* test */ ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(attrs); assert_non_null(attrs[0]); assert_null(attrs[1]); assert_int_equal(attrs[0]->num_values, num_values); assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_UINT16); assert_string_equal(attrs[0]->name, name); ret = sss_sifp_find_attr_as_uint16_array(attrs, name, &out_num, &out); assert_int_equal(ret, SSS_SIFP_ATTR_NULL); assert_int_equal(num_values, out_num); assert_null(out); sss_sifp_free_attrs(ctx, &attrs); assert_null(attrs); } void test_sss_sifp_parse_attr_int32_array(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; sss_sifp_error ret; sss_sifp_attr **attrs = NULL; const char *name = "test-attr"; unsigned int num_values = 5; int32_t in_array[] = {10, 15, -10, -15, 5559}; int32_t *in = in_array; unsigned int out_num; int32_t *out; unsigned int i; /* prepare message */ reply_variant_array(reply, DBUS_TYPE_INT32_AS_STRING, num_values, (uint8_t*)in, sizeof(int32_t)); /* test */ ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(attrs); assert_non_null(attrs[0]); assert_null(attrs[1]); assert_int_equal(attrs[0]->num_values, num_values); assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_INT32); assert_string_equal(attrs[0]->name, name); ret = sss_sifp_find_attr_as_int32_array(attrs, name, &out_num, &out); assert_int_equal(ret, SSS_SIFP_OK); assert_int_equal(num_values, out_num); for (i = 0; i < num_values; i++) { assert_int_equal(in[i], out[i]); } sss_sifp_free_attrs(ctx, &attrs); assert_null(attrs); } void test_sss_sifp_parse_attr_int32_array_empty(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; sss_sifp_error ret; sss_sifp_attr **attrs = NULL; const char *name = "test-attr"; unsigned int num_values = 0; unsigned int out_num; int32_t *out; /* prepare message */ reply_variant_array(reply, DBUS_TYPE_INT32_AS_STRING, num_values, NULL, sizeof(int32_t)); /* test */ ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(attrs); assert_non_null(attrs[0]); assert_null(attrs[1]); assert_int_equal(attrs[0]->num_values, num_values); assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_INT32); assert_string_equal(attrs[0]->name, name); ret = sss_sifp_find_attr_as_int32_array(attrs, name, &out_num, &out); assert_int_equal(ret, SSS_SIFP_ATTR_NULL); assert_int_equal(num_values, out_num); assert_null(out); sss_sifp_free_attrs(ctx, &attrs); assert_null(attrs); } void test_sss_sifp_parse_attr_uint32_array(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; sss_sifp_error ret; sss_sifp_attr **attrs = NULL; const char *name = "test-attr"; unsigned int num_values = 5; uint32_t in_array[] = {10, 15, 8885, 3224, 5559}; uint32_t *in = in_array; unsigned int out_num; uint32_t *out; unsigned int i; /* prepare message */ reply_variant_array(reply, DBUS_TYPE_UINT32_AS_STRING, num_values, (uint8_t*)in, sizeof(uint32_t)); /* test */ ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(attrs); assert_non_null(attrs[0]); assert_null(attrs[1]); assert_int_equal(attrs[0]->num_values, num_values); assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_UINT32); assert_string_equal(attrs[0]->name, name); ret = sss_sifp_find_attr_as_uint32_array(attrs, name, &out_num, &out); assert_int_equal(ret, SSS_SIFP_OK); assert_int_equal(num_values, out_num); for (i = 0; i < num_values; i++) { assert_int_equal(in[i], out[i]); } sss_sifp_free_attrs(ctx, &attrs); assert_null(attrs); } void test_sss_sifp_parse_attr_uint32_array_empty(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; sss_sifp_error ret; sss_sifp_attr **attrs = NULL; const char *name = "test-attr"; unsigned int num_values = 0; unsigned int out_num; uint32_t *out; /* prepare message */ reply_variant_array(reply, DBUS_TYPE_UINT32_AS_STRING, num_values, NULL, sizeof(uint32_t)); /* test */ ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(attrs); assert_non_null(attrs[0]); assert_null(attrs[1]); assert_int_equal(attrs[0]->num_values, num_values); assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_UINT32); assert_string_equal(attrs[0]->name, name); ret = sss_sifp_find_attr_as_uint32_array(attrs, name, &out_num, &out); assert_int_equal(ret, SSS_SIFP_ATTR_NULL); assert_int_equal(num_values, out_num); assert_null(out); sss_sifp_free_attrs(ctx, &attrs); assert_null(attrs); } void test_sss_sifp_parse_attr_int64_array(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; sss_sifp_error ret; sss_sifp_attr **attrs = NULL; const char *name = "test-attr"; unsigned int num_values = 5; int64_t in_array[] = {10, 15, -10, -15, 5559}; int64_t *in = in_array; unsigned int out_num; int64_t *out; unsigned int i; /* prepare message */ reply_variant_array(reply, DBUS_TYPE_INT64_AS_STRING, num_values, (uint8_t*)in, sizeof(int64_t)); /* test */ ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(attrs); assert_non_null(attrs[0]); assert_null(attrs[1]); assert_int_equal(attrs[0]->num_values, num_values); assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_INT64); assert_string_equal(attrs[0]->name, name); ret = sss_sifp_find_attr_as_int64_array(attrs, name, &out_num, &out); assert_int_equal(ret, SSS_SIFP_OK); assert_int_equal(num_values, out_num); for (i = 0; i < num_values; i++) { assert_int_equal(in[i], out[i]); } sss_sifp_free_attrs(ctx, &attrs); assert_null(attrs); } void test_sss_sifp_parse_attr_int64_array_empty(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; sss_sifp_error ret; sss_sifp_attr **attrs = NULL; const char *name = "test-attr"; unsigned int num_values = 0; unsigned int out_num; int64_t *out; /* prepare message */ reply_variant_array(reply, DBUS_TYPE_INT64_AS_STRING, num_values, NULL, sizeof(int64_t)); /* test */ ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(attrs); assert_non_null(attrs[0]); assert_null(attrs[1]); assert_int_equal(attrs[0]->num_values, num_values); assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_INT64); assert_string_equal(attrs[0]->name, name); ret = sss_sifp_find_attr_as_int64_array(attrs, name, &out_num, &out); assert_int_equal(ret, SSS_SIFP_ATTR_NULL); assert_int_equal(num_values, out_num); assert_null(out); sss_sifp_free_attrs(ctx, &attrs); assert_null(attrs); } void test_sss_sifp_parse_attr_uint64_array(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; sss_sifp_error ret; sss_sifp_attr **attrs = NULL; const char *name = "test-attr"; unsigned int num_values = 5; uint64_t in_array[] = {10, 15, 8885, 3224, 5559}; uint64_t *in = in_array; unsigned int out_num; uint64_t *out; unsigned int i; /* prepare message */ reply_variant_array(reply, DBUS_TYPE_UINT64_AS_STRING, num_values, (uint8_t*)in, sizeof(uint64_t)); /* test */ ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(attrs); assert_non_null(attrs[0]); assert_null(attrs[1]); assert_int_equal(attrs[0]->num_values, num_values); assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_UINT64); assert_string_equal(attrs[0]->name, name); ret = sss_sifp_find_attr_as_uint64_array(attrs, name, &out_num, &out); assert_int_equal(ret, SSS_SIFP_OK); assert_int_equal(num_values, out_num); for (i = 0; i < num_values; i++) { assert_int_equal(in[i], out[i]); } sss_sifp_free_attrs(ctx, &attrs); assert_null(attrs); } void test_sss_sifp_parse_attr_uint64_array_empty(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; sss_sifp_error ret; sss_sifp_attr **attrs = NULL; const char *name = "test-attr"; unsigned int num_values = 0; unsigned int out_num; uint64_t *out; /* prepare message */ reply_variant_array(reply, DBUS_TYPE_UINT64_AS_STRING, num_values, NULL, sizeof(uint64_t)); /* test */ ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(attrs); assert_non_null(attrs[0]); assert_null(attrs[1]); assert_int_equal(attrs[0]->num_values, num_values); assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_UINT64); assert_string_equal(attrs[0]->name, name); ret = sss_sifp_find_attr_as_uint64_array(attrs, name, &out_num, &out); assert_int_equal(ret, SSS_SIFP_ATTR_NULL); assert_int_equal(num_values, out_num); assert_null(out); sss_sifp_free_attrs(ctx, &attrs); assert_null(attrs); } void test_sss_sifp_parse_attr_string_array(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; sss_sifp_error ret; sss_sifp_attr **attrs = NULL; const char *name = "test-attr"; unsigned int num_values = 6; const char *in_array[] = {"I", "don't", "like", "writing", "unit", "tests"}; const char **in = in_array; unsigned int out_num; const char * const *out; unsigned int i; /* prepare message */ reply_variant_array(reply, DBUS_TYPE_STRING_AS_STRING, num_values, (uint8_t*)in, sizeof(const char*)); /* test */ ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(attrs); assert_non_null(attrs[0]); assert_null(attrs[1]); assert_int_equal(attrs[0]->num_values, num_values); assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_STRING); assert_string_equal(attrs[0]->name, name); ret = sss_sifp_find_attr_as_string_array(attrs, name, &out_num, &out); assert_int_equal(ret, SSS_SIFP_OK); assert_int_equal(num_values, out_num); for (i = 0; i < num_values; i++) { assert_string_equal(in[i], out[i]); } sss_sifp_free_attrs(ctx, &attrs); assert_null(attrs); } void test_sss_sifp_parse_attr_string_array_empty(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; sss_sifp_error ret; sss_sifp_attr **attrs = NULL; const char *name = "test-attr"; unsigned int num_values = 0; unsigned int out_num; const char * const *out; /* prepare message */ reply_variant_array(reply, DBUS_TYPE_STRING_AS_STRING, num_values, NULL, sizeof(const char*)); /* test */ ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(attrs); assert_non_null(attrs[0]); assert_null(attrs[1]); assert_int_equal(attrs[0]->num_values, num_values); assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_STRING); assert_string_equal(attrs[0]->name, name); ret = sss_sifp_find_attr_as_string_array(attrs, name, &out_num, &out); assert_int_equal(ret, SSS_SIFP_ATTR_NULL); assert_int_equal(num_values, out_num); assert_null(out); sss_sifp_free_attrs(ctx, &attrs); assert_null(attrs); } void test_sss_sifp_parse_attr_object_path_array(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; sss_sifp_error ret; sss_sifp_attr **attrs = NULL; const char *name = "test-attr"; unsigned int num_values = 2; const char *in_array[] = {"/object/path1", "/object/path2"}; const char **in = in_array; unsigned int out_num; const char * const *out; unsigned int i; /* prepare message */ reply_variant_array(reply, DBUS_TYPE_OBJECT_PATH_AS_STRING, num_values, (uint8_t*)in, sizeof(const char*)); /* test */ ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(attrs); assert_non_null(attrs[0]); assert_null(attrs[1]); assert_int_equal(attrs[0]->num_values, num_values); assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_STRING); assert_string_equal(attrs[0]->name, name); ret = sss_sifp_find_attr_as_string_array(attrs, name, &out_num, &out); assert_int_equal(ret, SSS_SIFP_OK); assert_int_equal(num_values, out_num); for (i = 0; i < num_values; i++) { assert_string_equal(in[i], out[i]); } sss_sifp_free_attrs(ctx, &attrs); assert_null(attrs); } void test_sss_sifp_parse_attr_object_path_array_empty(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; sss_sifp_error ret; sss_sifp_attr **attrs = NULL; const char *name = "test-attr"; unsigned int num_values = 0; unsigned int out_num; const char * const *out; /* prepare message */ reply_variant_array(reply, DBUS_TYPE_OBJECT_PATH_AS_STRING, num_values, NULL, sizeof(const char*)); /* test */ ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(attrs); assert_non_null(attrs[0]); assert_null(attrs[1]); assert_int_equal(attrs[0]->num_values, num_values); assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_STRING); assert_string_equal(attrs[0]->name, name); ret = sss_sifp_find_attr_as_string_array(attrs, name, &out_num, &out); assert_int_equal(ret, SSS_SIFP_ATTR_NULL); assert_int_equal(num_values, out_num); assert_null(out); sss_sifp_free_attrs(ctx, &attrs); assert_null(attrs); } void test_sss_sifp_parse_attr_string_dict_array(void **state) { return; sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; DBusMessageIter iter; DBusMessageIter var_iter; DBusMessageIter array_iter; DBusMessageIter dict_iter; DBusMessageIter val_iter; dbus_bool_t bret; sss_sifp_error ret; sss_sifp_attr **attrs = NULL; const char *name = "test-attr"; static struct { const char *key; const char *values[]; } data = {"key", {"value1", "value2", "value3"}}; unsigned int num_values = 3; hash_table_t *out; hash_key_t key; hash_value_t value; char **values; unsigned int i; int hret; /* prepare message */ dbus_message_iter_init_append(reply, &iter); bret = dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT, DBUS_TYPE_ARRAY_AS_STRING DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &var_iter); assert_true(bret); bret = dbus_message_iter_open_container(&var_iter, DBUS_TYPE_ARRAY, DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &array_iter); assert_true(bret); bret = dbus_message_iter_open_container(&array_iter, DBUS_TYPE_DICT_ENTRY, NULL, &dict_iter); assert_true(bret); bret = dbus_message_iter_append_basic(&dict_iter, DBUS_TYPE_STRING, &data.key); assert_true(bret); bret = dbus_message_iter_open_container(&dict_iter, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING, &val_iter); assert_true(bret); for (i = 0; i < num_values; i++) { bret = dbus_message_iter_append_basic(&val_iter, DBUS_TYPE_STRING, &data.values[i]); assert_true(bret); } bret = dbus_message_iter_close_container(&dict_iter, &val_iter); assert_true(bret); bret = dbus_message_iter_close_container(&array_iter, &dict_iter); assert_true(bret); bret = dbus_message_iter_close_container(&var_iter, &array_iter); assert_true(bret); bret = dbus_message_iter_close_container(&iter, &var_iter); assert_true(bret); ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(attrs); assert_non_null(attrs[0]); assert_null(attrs[1]); assert_int_equal(attrs[0]->num_values, 1); assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_STRING_DICT); assert_string_equal(attrs[0]->name, name); ret = sss_sifp_find_attr_as_string_dict(attrs, name, &out); assert_int_equal(ret, SSS_SIFP_OK); assert_int_equal(hash_count(out), 1); key.type = HASH_KEY_STRING; key.str = discard_const(data.key); hret = hash_lookup(out, &key, &value); assert_int_equal(hret, HASH_SUCCESS); assert_int_equal(value.type, HASH_VALUE_PTR); assert_non_null(value.ptr); values = value.ptr; for (i = 0; i < num_values; i++) { assert_non_null(values[i]); assert_string_equal(values[i], data.values[i]); } assert_null(values[i]); sss_sifp_free_attrs(ctx, &attrs); assert_null(attrs); } void test_sss_sifp_parse_attr_list(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; DBusMessageIter iter; DBusMessageIter array_iter; DBusMessageIter dict_iter; DBusMessageIter var_iter; dbus_bool_t bret; sss_sifp_error ret; sss_sifp_attr **attrs = NULL; struct { const char *name; uint32_t value; } data[] = {{"attr1", 1}, {"attr2", 2}, {"attr3", 3}, {NULL, 0}}; uint32_t out; int i; /* prepare message */ dbus_message_iter_init_append(reply, &iter); bret = dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &array_iter); assert_true(bret); for (i = 0; data[i].name != NULL; i++) { bret = dbus_message_iter_open_container(&array_iter, DBUS_TYPE_DICT_ENTRY, NULL, &dict_iter); assert_true(bret); bret = dbus_message_iter_append_basic(&dict_iter, DBUS_TYPE_STRING, &data[i].name); assert_true(bret); bret = dbus_message_iter_open_container(&dict_iter, DBUS_TYPE_VARIANT, DBUS_TYPE_UINT32_AS_STRING, &var_iter); assert_true(bret); bret = dbus_message_iter_append_basic(&var_iter, DBUS_TYPE_UINT32, &data[i].value); assert_true(bret); bret = dbus_message_iter_close_container(&dict_iter, &var_iter); assert_true(bret); bret = dbus_message_iter_close_container(&array_iter, &dict_iter); assert_true(bret); } bret = dbus_message_iter_close_container(&iter, &array_iter); assert_true(bret); ret = sss_sifp_parse_attr_list(ctx, reply, &attrs); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(attrs); for (i = 0; data[i].name != NULL; i++) { assert_non_null(attrs[i]); assert_int_equal(attrs[i]->num_values, 1); assert_int_equal(attrs[i]->type, SSS_SIFP_ATTR_TYPE_UINT32); assert_string_equal(attrs[i]->name, data[i].name); ret = sss_sifp_find_attr_as_uint32(attrs, data[i].name, &out); assert_int_equal(ret, SSS_SIFP_OK); assert_int_equal(data[i].value, out); } assert_null(attrs[i]); sss_sifp_free_attrs(ctx, &attrs); assert_null(attrs); } void test_sss_sifp_parse_attr_list_empty(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; DBusMessageIter iter; DBusMessageIter array_iter; dbus_bool_t bret; sss_sifp_error ret; sss_sifp_attr **attrs = NULL; /* prepare message */ dbus_message_iter_init_append(reply, &iter); bret = dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &array_iter); assert_true(bret); bret = dbus_message_iter_close_container(&iter, &array_iter); assert_true(bret); ret = sss_sifp_parse_attr_list(ctx, reply, &attrs); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(attrs); assert_null(attrs[0]); sss_sifp_free_attrs(ctx, &attrs); assert_null(attrs); } void test_sss_sifp_get_iface_for_object(void **state) { int i; const char *iface = NULL; static struct { const char *path; const char *iface; } data[] = {{SSS_SIFP_PATH_IFP "/Components/Monitor", SSS_SIFP_IFACE_COMPONENTS}, {SSS_SIFP_PATH_IFP "/Domains/LDAP", SSS_SIFP_IFACE_DOMAINS}, {SSS_SIFP_PATH_IFP "/Services/NSS", SSS_SIFP_IFACE_SERVICES}, {SSS_SIFP_PATH_IFP "/Users/2154", SSS_SIFP_IFACE_USERS}, {SSS_SIFP_PATH_IFP "/Groups/3441", SSS_SIFP_IFACE_GROUPS}, {NULL, NULL}}; for (i = 0; data[i].path != NULL; i++) { iface = sss_sifp_get_iface_for_object(data[i].path); assert_non_null(iface); assert_string_equal(data[i].iface, iface); } } void test_sss_sifp_fetch_attr(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; sss_sifp_error ret; sss_sifp_attr **attrs = NULL; const char *name = "test-attr"; uint32_t in = UINT32_MAX; uint32_t out; /* prepare message */ reply_variant_basic(reply, DBUS_TYPE_UINT32_AS_STRING, &in); will_return(__wrap_dbus_connection_send_with_reply_and_block, reply); /* test */ ret = sss_sifp_fetch_attr(ctx, "/test/object", "test.com", name, &attrs); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(attrs); assert_non_null(attrs[0]); assert_null(attrs[1]); assert_int_equal(attrs[0]->num_values, 1); assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_UINT32); assert_string_equal(attrs[0]->name, name); ret = sss_sifp_find_attr_as_uint32(attrs, name, &out); assert_int_equal(ret, SSS_SIFP_OK); assert_int_equal(in, out); sss_sifp_free_attrs(ctx, &attrs); assert_null(attrs); } void test_sss_sifp_fetch_all_attrs(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; DBusMessageIter iter; DBusMessageIter array_iter; DBusMessageIter dict_iter; DBusMessageIter var_iter; dbus_bool_t bret; sss_sifp_error ret; sss_sifp_attr **attrs = NULL; struct { const char *name; uint32_t value; } data[] = {{"attr1", 1}, {"attr2", 2}, {"attr3", 3}, {NULL, 0}}; uint32_t out; int i; /* prepare message */ dbus_message_iter_init_append(reply, &iter); bret = dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &array_iter); assert_true(bret); for (i = 0; data[i].name != NULL; i++) { bret = dbus_message_iter_open_container(&array_iter, DBUS_TYPE_DICT_ENTRY, NULL, &dict_iter); assert_true(bret); bret = dbus_message_iter_append_basic(&dict_iter, DBUS_TYPE_STRING, &data[i].name); assert_true(bret); bret = dbus_message_iter_open_container(&dict_iter, DBUS_TYPE_VARIANT, DBUS_TYPE_UINT32_AS_STRING, &var_iter); assert_true(bret); bret = dbus_message_iter_append_basic(&var_iter, DBUS_TYPE_UINT32, &data[i].value); assert_true(bret); bret = dbus_message_iter_close_container(&dict_iter, &var_iter); assert_true(bret); bret = dbus_message_iter_close_container(&array_iter, &dict_iter); assert_true(bret); } bret = dbus_message_iter_close_container(&iter, &array_iter); assert_true(bret); will_return(__wrap_dbus_connection_send_with_reply_and_block, reply); ret = sss_sifp_fetch_all_attrs(ctx, "/test/object", "test.com", &attrs); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(attrs); for (i = 0; data[i].name != NULL; i++) { assert_non_null(attrs[i]); assert_int_equal(attrs[i]->num_values, 1); assert_int_equal(attrs[i]->type, SSS_SIFP_ATTR_TYPE_UINT32); assert_string_equal(attrs[i]->name, data[i].name); ret = sss_sifp_find_attr_as_uint32(attrs, data[i].name, &out); assert_int_equal(ret, SSS_SIFP_OK); assert_int_equal(data[i].value, out); } assert_null(attrs[i]); sss_sifp_free_attrs(ctx, &attrs); assert_null(attrs); } void test_sss_sifp_fetch_object(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; DBusMessageIter iter; DBusMessageIter array_iter; DBusMessageIter dict_iter; DBusMessageIter var_iter; const char *path = "/test/object"; const char *iface = "test.com"; dbus_bool_t bret; sss_sifp_error ret; sss_sifp_object *object = NULL; struct { const char *name; const char *value; } data[] = {{"name", "test-object"}, {"a1", "a"}, {"a2", "b"}, {NULL, 0}}; const char *out; int i; /* prepare message */ dbus_message_iter_init_append(reply, &iter); bret = dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &array_iter); assert_true(bret); for (i = 0; data[i].name != NULL; i++) { bret = dbus_message_iter_open_container(&array_iter, DBUS_TYPE_DICT_ENTRY, NULL, &dict_iter); assert_true(bret); bret = dbus_message_iter_append_basic(&dict_iter, DBUS_TYPE_STRING, &data[i].name); assert_true(bret); bret = dbus_message_iter_open_container(&dict_iter, DBUS_TYPE_VARIANT, DBUS_TYPE_STRING_AS_STRING, &var_iter); assert_true(bret); bret = dbus_message_iter_append_basic(&var_iter, DBUS_TYPE_STRING, &data[i].value); assert_true(bret); bret = dbus_message_iter_close_container(&dict_iter, &var_iter); assert_true(bret); bret = dbus_message_iter_close_container(&array_iter, &dict_iter); assert_true(bret); } bret = dbus_message_iter_close_container(&iter, &array_iter); assert_true(bret); will_return(__wrap_dbus_connection_send_with_reply_and_block, reply); ret = sss_sifp_fetch_object(ctx, path, iface, &object); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(object); assert_non_null(object->attrs); assert_non_null(object->name); assert_non_null(object->object_path); assert_non_null(object->interface); assert_string_equal(object->name, "test-object"); assert_string_equal(object->object_path, path); assert_string_equal(object->interface, iface); for (i = 0; data[i].name != NULL; i++) { assert_non_null(object->attrs[i]); assert_int_equal(object->attrs[i]->num_values, 1); assert_int_equal(object->attrs[i]->type, SSS_SIFP_ATTR_TYPE_STRING); assert_string_equal(object->attrs[i]->name, data[i].name); ret = sss_sifp_find_attr_as_string(object->attrs, data[i].name, &out); assert_int_equal(ret, SSS_SIFP_OK); assert_string_equal(data[i].value, out); } assert_null(object->attrs[i]); sss_sifp_free_object(ctx, &object); assert_null(object); } void test_sss_sifp_invoke_list_zeroargs(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; dbus_bool_t bret; sss_sifp_error ret; char **path_out = NULL; const char *path_in[] = {"/object/path1", "/object/path2"}; const char **paths = path_in; int path_in_len = 2; int i; /* prepare message */ bret = dbus_message_append_args(reply, DBUS_TYPE_ARRAY, DBUS_TYPE_OBJECT_PATH, &paths, path_in_len, DBUS_TYPE_INVALID); assert_true(bret); will_return(__wrap_dbus_connection_send_with_reply_and_block, reply); /* test */ ret = sss_sifp_invoke_list(ctx, "MyMethod", &path_out, DBUS_TYPE_INVALID); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(path_out); for (i = 0; path_out[i] != NULL; i++) { assert_true(i < path_in_len); assert_non_null(path_out[i]); assert_string_equal(path_in[i], path_out[i]); } sss_sifp_free_string_array(ctx, &path_out); assert_null(path_out); } void test_sss_sifp_invoke_list_withargs(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; dbus_bool_t bret; sss_sifp_error ret; char **path_out = NULL; const char *path_in[] = {"/object/path1", "/object/path2"}; const char **paths = path_in; const char *arg = "first-arg"; int path_in_len = 2; int i; /* prepare message */ bret = dbus_message_append_args(reply, DBUS_TYPE_ARRAY, DBUS_TYPE_OBJECT_PATH, &paths, path_in_len, DBUS_TYPE_INVALID); assert_true(bret); will_return(__wrap_dbus_connection_send_with_reply_and_block, reply); /* test */ ret = sss_sifp_invoke_list(ctx, "MyMethod", &path_out, DBUS_TYPE_STRING, &arg, DBUS_TYPE_INVALID); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(path_out); for (i = 0; path_out[i] != NULL; i++) { assert_true(i < path_in_len); assert_non_null(path_out[i]); assert_string_equal(path_in[i], path_out[i]); } sss_sifp_free_string_array(ctx, &path_out); assert_null(path_out); } void test_sss_sifp_invoke_find_zeroargs(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; dbus_bool_t bret; sss_sifp_error ret; const char *path_in = "/object/path"; char *path_out = NULL; /* prepare message */ bret = dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &path_in, DBUS_TYPE_INVALID); assert_true(bret); will_return(__wrap_dbus_connection_send_with_reply_and_block, reply); /* test */ ret = sss_sifp_invoke_find(ctx, "MyMethod", &path_out, DBUS_TYPE_INVALID); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(path_out); assert_string_equal(path_in, path_out); sss_sifp_free_string(ctx, &path_out); assert_null(path_out); } void test_sss_sifp_invoke_find_withargs(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *reply = test_ctx.reply; dbus_bool_t bret; sss_sifp_error ret; const char *path_in = "/object/path"; char *path_out = NULL; const char *arg = "first-arg"; /* prepare message */ bret = dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &path_in, DBUS_TYPE_INVALID); assert_true(bret); will_return(__wrap_dbus_connection_send_with_reply_and_block, reply); /* test */ ret = sss_sifp_invoke_find(ctx, "MyMethod", &path_out, DBUS_TYPE_STRING, &arg, DBUS_TYPE_INVALID); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(path_out); assert_string_equal(path_in, path_out); sss_sifp_free_string(ctx, &path_out); assert_null(path_out); } void test_sss_sifp_list_domains(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *msg_paths = NULL; DBusMessage *msg_ldap = NULL; DBusMessage *msg_ipa = NULL; dbus_bool_t bret; sss_sifp_error ret; const char *in[] = {SSS_SIFP_PATH_IFP "/Domains/LDAP", SSS_SIFP_PATH_IFP "/Domains/IPA"}; const char **paths = in; const char *names[] = {"LDAP", "IPA"}; char **out = NULL; int in_len = 2; int i; msg_paths = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN); assert_non_null(msg_paths); msg_ldap = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN); assert_non_null(msg_ldap); msg_ipa = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN); assert_non_null(msg_ipa); /* prepare message */ bret = dbus_message_append_args(msg_paths, DBUS_TYPE_ARRAY, DBUS_TYPE_OBJECT_PATH, &paths, in_len, DBUS_TYPE_INVALID); assert_true(bret); reply_variant_basic(msg_ldap, DBUS_TYPE_STRING_AS_STRING, &names[0]); reply_variant_basic(msg_ipa, DBUS_TYPE_STRING_AS_STRING, &names[1]); will_return(__wrap_dbus_connection_send_with_reply_and_block, msg_paths); will_return(__wrap_dbus_connection_send_with_reply_and_block, msg_ldap); will_return(__wrap_dbus_connection_send_with_reply_and_block, msg_ipa); /* test */ ret = sss_sifp_list_domains(ctx, &out); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(out); for (i = 0; i < in_len; i++) { assert_non_null(out[i]); assert_string_equal(out[i], names[i]); } assert_null(out[i]); sss_sifp_free_string_array(ctx, &out); assert_null(out); /* messages are unrefed in the library */ } void test_sss_sifp_fetch_domain_by_name(void **state) { sss_sifp_ctx *ctx = test_ctx.dbus_ctx; DBusMessage *msg_path = NULL; DBusMessage *msg_props = NULL; DBusMessageIter iter; DBusMessageIter array_iter; DBusMessageIter dict_iter; DBusMessageIter var_iter; dbus_bool_t bret; sss_sifp_error ret; const char *in =SSS_SIFP_PATH_IFP "/Domains/LDAP"; const char *name = "LDAP"; const char *prop = NULL; sss_sifp_object *out = NULL; struct { const char *name; const char *value; } props[] = {{"name", name}, {"a1", "a"}, {"a2", "b"}, {NULL, 0}}; int i; msg_path = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN); assert_non_null(msg_path); msg_props = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN); assert_non_null(msg_props); /* prepare message */ bret = dbus_message_append_args(msg_path, DBUS_TYPE_OBJECT_PATH, &in, DBUS_TYPE_INVALID); assert_true(bret); dbus_message_iter_init_append(msg_props, &iter); bret = dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &array_iter); assert_true(bret); for (i = 0; props[i].name != NULL; i++) { bret = dbus_message_iter_open_container(&array_iter, DBUS_TYPE_DICT_ENTRY, NULL, &dict_iter); assert_true(bret); bret = dbus_message_iter_append_basic(&dict_iter, DBUS_TYPE_STRING, &props[i].name); assert_true(bret); bret = dbus_message_iter_open_container(&dict_iter, DBUS_TYPE_VARIANT, DBUS_TYPE_STRING_AS_STRING, &var_iter); assert_true(bret); bret = dbus_message_iter_append_basic(&var_iter, DBUS_TYPE_STRING, &props[i].value); assert_true(bret); bret = dbus_message_iter_close_container(&dict_iter, &var_iter); assert_true(bret); bret = dbus_message_iter_close_container(&array_iter, &dict_iter); assert_true(bret); } bret = dbus_message_iter_close_container(&iter, &array_iter); assert_true(bret); will_return(__wrap_dbus_connection_send_with_reply_and_block, msg_path); will_return(__wrap_dbus_connection_send_with_reply_and_block, msg_props); /* test */ ret = sss_sifp_fetch_domain_by_name(ctx, name, &out); assert_int_equal(ret, SSS_SIFP_OK); assert_non_null(out); assert_non_null(out->attrs); assert_non_null(out->name); assert_non_null(out->object_path); assert_non_null(out->interface); assert_string_equal(out->name, name); assert_string_equal(out->object_path, in); assert_string_equal(out->interface, SSS_SIFP_IFACE_DOMAINS); for (i = 0; props[i].name != NULL; i++) { assert_non_null(out->attrs[i]); assert_int_equal(out->attrs[i]->num_values, 1); assert_int_equal(out->attrs[i]->type, SSS_SIFP_ATTR_TYPE_STRING); assert_string_equal(out->attrs[i]->name, props[i].name); ret = sss_sifp_find_attr_as_string(out->attrs, props[i].name, &prop); assert_int_equal(ret, SSS_SIFP_OK); assert_string_equal(props[i].value, prop); } assert_null(out->attrs[i]); sss_sifp_free_object(ctx, &out); assert_null(out); /* messages are unrefed in the library */ } int main(int argc, const char *argv[]) { int rv; int no_cleanup = 0; poptContext pc; int opt; struct poptOption long_options[] = { POPT_AUTOHELP SSSD_DEBUG_OPTS {"no-cleanup", 'n', POPT_ARG_NONE, &no_cleanup, 0, _("Do not delete the test database after a test run"), NULL }, POPT_TABLEEND }; const UnitTest tests[] = { unit_test_setup_teardown(test_sss_sifp_strdup_valid, test_setup, test_teardown_parser), unit_test_setup_teardown(test_sss_sifp_strdup_null, test_setup, test_teardown_parser), unit_test_setup_teardown(test_sss_sifp_strcat_valid, test_setup, test_teardown_parser), unit_test_setup_teardown(test_sss_sifp_strcat_left_null, test_setup, test_teardown_parser), unit_test_setup_teardown(test_sss_sifp_strcat_right_null, test_setup, test_teardown_parser), unit_test_setup_teardown(test_sss_sifp_strcat_both_null, test_setup, test_teardown_parser), unit_test_setup_teardown(test_sss_sifp_parse_object_path_valid, test_setup, test_teardown_parser), unit_test_setup_teardown(test_sss_sifp_parse_object_path_invalid, test_setup, test_teardown_parser), unit_test_setup_teardown(test_sss_sifp_parse_object_path_list_valid, test_setup, test_teardown_parser), unit_test_setup_teardown(test_sss_sifp_parse_object_path_list_invalid, test_setup, test_teardown_parser), unit_test_setup_teardown(test_sss_sifp_parse_attr_bool, test_setup, test_teardown_parser), unit_test_setup_teardown(test_sss_sifp_parse_attr_int16, test_setup, test_teardown_parser), unit_test_setup_teardown(test_sss_sifp_parse_attr_uint16, test_setup, test_teardown_parser), unit_test_setup_teardown(test_sss_sifp_parse_attr_int32, test_setup, test_teardown_parser), unit_test_setup_teardown(test_sss_sifp_parse_attr_uint32, test_setup, test_teardown_parser), unit_test_setup_teardown(test_sss_sifp_parse_attr_int64, test_setup, test_teardown_parser), unit_test_setup_teardown(test_sss_sifp_parse_attr_uint64, test_setup, test_teardown_parser), unit_test_setup_teardown(test_sss_sifp_parse_attr_string, test_setup, test_teardown_parser), unit_test_setup_teardown(test_sss_sifp_parse_attr_object_path, test_setup, test_teardown_parser), unit_test_setup_teardown(test_sss_sifp_parse_attr_string_dict, test_setup, test_teardown_parser), unit_test_setup_teardown(test_sss_sifp_parse_attr_bool_array, test_setup, test_teardown_parser), unit_test_setup_teardown(test_sss_sifp_parse_attr_bool_array_empty, test_setup, test_teardown_parser), unit_test_setup_teardown(test_sss_sifp_parse_attr_int32_array, test_setup, test_teardown_parser), unit_test_setup_teardown(test_sss_sifp_parse_attr_int32_array_empty, test_setup, test_teardown_parser), unit_test_setup_teardown(test_sss_sifp_parse_attr_uint32_array, test_setup, test_teardown_parser), unit_test_setup_teardown(test_sss_sifp_parse_attr_uint32_array_empty, test_setup, test_teardown_parser), unit_test_setup_teardown(test_sss_sifp_parse_attr_int64_array, test_setup, test_teardown_parser), unit_test_setup_teardown(test_sss_sifp_parse_attr_int64_array_empty, test_setup, test_teardown_parser), unit_test_setup_teardown(test_sss_sifp_parse_attr_uint64_array, test_setup, test_teardown_parser), unit_test_setup_teardown(test_sss_sifp_parse_attr_uint64_array_empty, test_setup, test_teardown_parser), unit_test_setup_teardown(test_sss_sifp_parse_attr_string_array, test_setup, test_teardown_parser), unit_test_setup_teardown(test_sss_sifp_parse_attr_string_array_empty, test_setup, test_teardown_parser), unit_test_setup_teardown(test_sss_sifp_parse_attr_object_path_array, test_setup, test_teardown_parser), unit_test_setup_teardown(test_sss_sifp_parse_attr_object_path_array_empty, test_setup, test_teardown_parser), unit_test_setup_teardown(test_sss_sifp_parse_attr_string_dict_array, test_setup, test_teardown_parser), unit_test_setup_teardown(test_sss_sifp_parse_attr_list, test_setup, test_teardown_parser), unit_test_setup_teardown(test_sss_sifp_parse_attr_list_empty, test_setup, test_teardown_parser), unit_test(test_sss_sifp_get_iface_for_object), unit_test_setup_teardown(test_sss_sifp_fetch_attr, test_setup, test_teardown_api), unit_test_setup_teardown(test_sss_sifp_fetch_all_attrs, test_setup, test_teardown_api), unit_test_setup_teardown(test_sss_sifp_fetch_object, test_setup, test_teardown_api), unit_test_setup_teardown(test_sss_sifp_invoke_list_zeroargs, test_setup, test_teardown_api), unit_test_setup_teardown(test_sss_sifp_invoke_list_withargs, test_setup, test_teardown_api), unit_test_setup_teardown(test_sss_sifp_invoke_find_zeroargs, test_setup, test_teardown_api), unit_test_setup_teardown(test_sss_sifp_invoke_find_withargs, test_setup, test_teardown_api), unit_test_setup_teardown(test_sss_sifp_list_domains, test_setup, test_teardown_api), unit_test_setup_teardown(test_sss_sifp_fetch_domain_by_name, test_setup, test_teardown_api), }; /* Set debug level to invalid value so we can deside if -d 0 was used. */ debug_level = SSSDBG_INVALID; pc = poptGetContext(argv[0], argc, argv, long_options, 0); while((opt = poptGetNextOpt(pc)) != -1) { switch(opt) { default: fprintf(stderr, "\nInvalid option %s: %s\n\n", poptBadOption(pc, 0), poptStrerror(opt)); poptPrintUsage(pc, stderr, 0); return 1; } } poptFreeContext(pc); DEBUG_CLI_INIT(debug_level); rv = run_tests(tests); return rv; }