From 5ec1d31f32583761c05691c951576b6213037393 Mon Sep 17 00:00:00 2001
From: Sumit Bose <sbose@redhat.com>
Date: Fri, 7 Feb 2014 15:54:30 +0100
Subject: [PATCH 94/97] IPA: refactor idmap code and add test
---
Makefile.am | 15 +++
src/providers/ipa/ipa_common.h | 10 ++
src/providers/ipa/ipa_idmap.c | 248 +++++++++++++++----------------------
src/tests/cmocka/test_ipa_idmap.c | 249 ++++++++++++++++++++++++++++++++++++++
4 files changed, 374 insertions(+), 148 deletions(-)
create mode 100644 src/tests/cmocka/test_ipa_idmap.c
diff --git a/Makefile.am b/Makefile.am
index 16648f9aa2275b60ec84a95ff8a26b1225b97918..2e1a1e6bacfb79e4ef7068a22a64c21d23858cb9 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -150,6 +150,7 @@ if HAVE_CMOCKA
dyndns-tests \
fqnames-tests \
test_sss_idmap \
+ test_ipa_idmap \
test_utils \
ad_access_filter_tests \
ad_common_tests \
@@ -1359,6 +1360,20 @@ test_sss_idmap_LDADD = \
$(SSSD_INTERNAL_LTLIBS) \
libsss_test_common.la
+test_ipa_idmap_SOURCES = \
+ src/tests/cmocka/test_ipa_idmap.c \
+ src/providers/ipa/ipa_idmap.c
+test_ipa_idmap_CFLAGS = \
+ $(AM_CFLAGS)
+test_ipa_idmap_LDFLAGS = \
+ -Wl,-wrap,sysdb_get_ranges
+test_ipa_idmap_LDADD = \
+ $(CMOCKA_LIBS) \
+ $(POPT_LIBS) \
+ libsss_idmap.la \
+ $(SSSD_INTERNAL_LTLIBS) \
+ libsss_test_common.la
+
test_utils_SOURCES = \
src/tests/cmocka/test_utils.c
test_utils_CFLAGS = \
diff --git a/src/providers/ipa/ipa_common.h b/src/providers/ipa/ipa_common.h
index 02f0baf55f0d226eeb8956076b9bbcce285d4a94..0b8a17c532b7b0081dc749dcef1e6c0e684a7ed2 100644
--- a/src/providers/ipa/ipa_common.h
+++ b/src/providers/ipa/ipa_common.h
@@ -195,6 +195,16 @@ int ipa_sudo_init(struct be_ctx *be_ctx,
struct bet_ops **ops,
void **pvt_data);
+errno_t get_idmap_data_from_range(struct range_info *r, char *domain_name,
+ char **_name, char **_sid, uint32_t *_rid,
+ struct sss_idmap_range *_range,
+ bool *_external_mapping);
+
+errno_t ipa_idmap_get_ranges_from_sysdb(struct sdap_idmap_ctx *idmap_ctx,
+ const char *dom_name,
+ const char *dom_sid_str,
+ bool allow_collisions);
+
errno_t ipa_idmap_init(TALLOC_CTX *mem_ctx,
struct sdap_id_ctx *id_ctx,
struct sdap_idmap_ctx **_idmap_ctx);
diff --git a/src/providers/ipa/ipa_idmap.c b/src/providers/ipa/ipa_idmap.c
index eaca0ed3c3ce2622fbf80dff13d22e2e521f54fe..a65086af4cb4bec7ab85774f3ca1a3555056cee0 100644
--- a/src/providers/ipa/ipa_idmap.c
+++ b/src/providers/ipa/ipa_idmap.c
@@ -156,9 +156,68 @@ done:
return ret;
}
-errno_t ipa_idmap_find_new_domain(struct sdap_idmap_ctx *idmap_ctx,
- const char *dom_name,
- const char *dom_sid_str)
+errno_t get_idmap_data_from_range(struct range_info *r, char *domain_name,
+ char **_name, char **_sid, uint32_t *_rid,
+ struct sss_idmap_range *_range,
+ bool *_external_mapping)
+{
+ if (r->range_type == NULL) {
+ /* Older IPA servers might not have the range_type attribute, but
+ * only support local ranges and trusts with algorithmic mapping. */
+
+ if (r->trusted_dom_sid == NULL && r->secondary_base_rid != 0) {
+ /* local IPA domain */
+ *_rid = 0;
+ *_external_mapping = true;
+ *_name = domain_name;
+ *_sid = NULL;
+ } else if (r->trusted_dom_sid != NULL
+ && r->secondary_base_rid == 0) {
+ /* trusted domain */
+ *_rid = r->base_rid;
+ *_external_mapping = false;
+ *_name = r->trusted_dom_sid;
+ *_sid = r->trusted_dom_sid;
+ } else {
+ DEBUG(SSSDBG_MINOR_FAILURE, ("Cannot determine range type, " \
+ "for id range [%s].\n",
+ r->name));
+ return EINVAL;
+ }
+ } else {
+ if (strcmp(r->range_type, IPA_RANGE_LOCAL) == 0) {
+ *_rid = 0;
+ *_external_mapping = true;
+ *_name = domain_name;
+ *_sid = NULL;
+ } else if (strcmp(r->range_type, IPA_RANGE_AD_TRUST_POSIX) == 0) {
+ *_rid = 0;
+ *_external_mapping = true;
+ *_name = r->trusted_dom_sid;
+ *_sid = r->trusted_dom_sid;
+ } else if (strcmp(r->range_type, IPA_RANGE_AD_TRUST) == 0) {
+ *_rid = r->base_rid;
+ *_external_mapping = false;
+ *_name = r->trusted_dom_sid;
+ *_sid = r->trusted_dom_sid;
+ } else {
+ DEBUG(SSSDBG_MINOR_FAILURE, ("Range type [%s] of id range " \
+ "[%s] not supported.\n", \
+ r->range_type, r->name));
+ return EINVAL;
+ }
+ }
+
+ _range->min = r->base_id;
+ _range->max = r->base_id + r->id_range_size -1;
+
+ return EOK;
+}
+
+errno_t ipa_idmap_get_ranges_from_sysdb(struct sdap_idmap_ctx *idmap_ctx,
+ const char *dom_name,
+ const char *dom_sid_str,
+ bool allow_collisions)
{
int ret;
size_t range_count;
@@ -166,7 +225,6 @@ errno_t ipa_idmap_find_new_domain(struct sdap_idmap_ctx *idmap_ctx,
TALLOC_CTX *tmp_ctx;
size_t c;
enum idmap_error_code err;
- struct range_info *r;
struct sss_idmap_range range;
uint32_t rid;
bool external_mapping;
@@ -187,74 +245,39 @@ errno_t ipa_idmap_find_new_domain(struct sdap_idmap_ctx *idmap_ctx,
}
for (c = 0; c < range_count; c++) {
- r = range_list[c];
-
- if (r->range_type == NULL) {
- /* Older IPA servers might not have the range_type attribute, but
- * only support local ranges and trusts with algorithmic mapping. */
-
- if (r->trusted_dom_sid == NULL && r->secondary_base_rid != 0) {
- /* local IPA domain */
- rid = 0;
- external_mapping = true;
- name = idmap_ctx->id_ctx->be->domain->name;
- sid = NULL;
- } else if (r->trusted_dom_sid != NULL
- && r->secondary_base_rid == 0) {
- /* trusted domain */
- rid = r->base_rid;
- external_mapping = false;
- name = r->trusted_dom_sid;
- sid = r->trusted_dom_sid;
- } else {
- DEBUG(SSSDBG_MINOR_FAILURE, ("Cannot determine range type, " \
- "skipping id ange [%s].\n",
- r->name));
- continue;
- }
- } else {
- if (strcmp(r->range_type, IPA_RANGE_LOCAL) == 0) {
- rid = 0;
- external_mapping = true;
- name = idmap_ctx->id_ctx->be->domain->name;
- sid = NULL;
- } else if (strcmp(r->range_type, IPA_RANGE_AD_TRUST_POSIX) == 0) {
- rid = 0;
- external_mapping = true;
- name = r->trusted_dom_sid;
- sid = r->trusted_dom_sid;
- } else if (strcmp(r->range_type, IPA_RANGE_AD_TRUST) == 0) {
- rid = r->base_rid;
- external_mapping = false;
- name = r->trusted_dom_sid;
- sid = r->trusted_dom_sid;
- } else {
- DEBUG(SSSDBG_MINOR_FAILURE, ("Range type [%s] not supported, " \
- "skipping id range [%s].\n",
- r->range_type, r->name));
- continue;
- }
+ ret = get_idmap_data_from_range(range_list[c],
+ idmap_ctx->id_ctx->be->domain->name,
+ &name, &sid, &rid, &range,
+ &external_mapping);
+ if (ret != EOK) {
+ DEBUG(SSSDBG_OP_FAILURE, ("get_idmap_data_from_range failed for " \
+ "id range [%s], skipping.\n",
+ range_list[c]->name));
+ continue;
}
- range.min = r->base_id;
- range.max = r->base_id + r->id_range_size -1;
err = sss_idmap_add_domain_ex(idmap_ctx->map, name, sid, &range,
- r->name, rid, external_mapping);
- if (err != IDMAP_SUCCESS && err != IDMAP_COLLISION) {
- DEBUG(SSSDBG_CRIT_FAILURE, ("Could not add range [%s] to ID map\n",
- r->name));
- ret = EIO;
+ range_list[c]->name, rid,
+ external_mapping);
+ if (err != IDMAP_SUCCESS) {
+ if (!allow_collisions || err != IDMAP_COLLISION) {
+ DEBUG(SSSDBG_CRIT_FAILURE, ("Could not add range [%s] to ID map\n",
+ range_list[c]->name));
+ ret = EIO;
+ goto done;
+ }
+ }
+ }
+
+ if (dom_name != NULL || dom_sid_str != NULL) {
+ ret = ipa_idmap_check_posix_child(idmap_ctx, dom_name, dom_sid_str,
+ range_count, range_list);
+ if (ret != EOK) {
+ DEBUG(SSSDBG_OP_FAILURE, ("ipa_idmap_check_posix_child failed.\n"));
goto done;
}
}
- ret = ipa_idmap_check_posix_child(idmap_ctx, dom_name, dom_sid_str,
- range_count, range_list);
- if (ret != EOK) {
- DEBUG(SSSDBG_OP_FAILURE, ("ipa_idmap_check_posix_child failed.\n"));
- goto done;
- }
-
ret = EOK;
done:
@@ -263,6 +286,14 @@ done:
return ret;
}
+errno_t ipa_idmap_find_new_domain(struct sdap_idmap_ctx *idmap_ctx,
+ const char *dom_name,
+ const char *dom_sid_str)
+{
+ return ipa_idmap_get_ranges_from_sysdb(idmap_ctx, dom_name, dom_sid_str,
+ true);
+}
+
errno_t ipa_idmap_init(TALLOC_CTX *mem_ctx,
struct sdap_id_ctx *id_ctx,
struct sdap_idmap_ctx **_idmap_ctx)
@@ -270,17 +301,7 @@ errno_t ipa_idmap_init(TALLOC_CTX *mem_ctx,
errno_t ret;
TALLOC_CTX *tmp_ctx;
enum idmap_error_code err;
- size_t c;
struct sdap_idmap_ctx *idmap_ctx = NULL;
- struct sysdb_ctx *sysdb = id_ctx->be->domain->sysdb;
- size_t range_count;
- struct range_info **range_list;
- struct range_info *r;
- struct sss_idmap_range range;
- uint32_t rid;
- bool external_mapping;
- char *name;
- char *sid;
tmp_ctx = talloc_new(NULL);
if (!tmp_ctx) return ENOMEM;
@@ -309,82 +330,13 @@ errno_t ipa_idmap_init(TALLOC_CTX *mem_ctx,
goto done;
}
-
- /* Read in any existing mappings from the cache */
- ret = sysdb_get_ranges(tmp_ctx, sysdb, &range_count, &range_list);
- if (ret != EOK && ret != ENOENT) {
- DEBUG(SSSDBG_FATAL_FAILURE,
- ("Could not read ranges from the cache: [%s]\n",
- strerror(ret)));
+ ret = ipa_idmap_get_ranges_from_sysdb(idmap_ctx, NULL, NULL, false);
+ if (ret != EOK) {
+ DEBUG(SSSDBG_OP_FAILURE,
+ ("ipa_idmap_get_ranges_from_sysdb failed.\n"));
goto done;
}
- DEBUG(SSSDBG_CONF_SETTINGS,
- ("Initializing [%zu] domains for ID-mapping\n", range_count));
-
- for (c = 0; c < range_count; c++) {
-
- r = range_list[c];
-
- if (r->range_type == NULL) {
- /* Older IPA servers might not have the range_type attribute, but
- * only support local ranges and trusts with algorithmic mapping. */
-
- if (r->trusted_dom_sid == NULL && r->secondary_base_rid != 0) {
- /* local IPA domain */
- rid = 0;
- external_mapping = true;
- sid = NULL;
- name = id_ctx->be->domain->name;
- } else if (r->trusted_dom_sid != NULL
- && r->secondary_base_rid == 0) {
- /* trusted domain */
- rid = r->base_rid;
- external_mapping = false;
- sid = r->trusted_dom_sid;
- name = sid;
- } else {
- DEBUG(SSSDBG_MINOR_FAILURE, ("Cannot determine range type, " \
- "skipping id ange [%s].\n",
- r->name));
- continue;
- }
- } else {
- if (strcmp(r->range_type, IPA_RANGE_LOCAL) == 0) {
- rid = 0;
- external_mapping = true;
- sid = NULL;
- name = id_ctx->be->domain->name;
- } else if (strcmp(r->range_type, IPA_RANGE_AD_TRUST_POSIX) == 0) {
- rid = 0;
- external_mapping = true;
- sid = r->trusted_dom_sid;
- name = sid;
- } else if (strcmp(r->range_type, IPA_RANGE_AD_TRUST) == 0) {
- rid = r->base_rid;
- external_mapping = false;
- sid = r->trusted_dom_sid;
- name = sid;
- } else {
- DEBUG(SSSDBG_MINOR_FAILURE, ("Range type [%s] not supported, " \
- "skipping id range [%s].\n",
- r->range_type, r->name));
- continue;
- }
- }
-
- range.min = r->base_id;
- range.max = r->base_id + r->id_range_size -1;
- err = sss_idmap_add_domain_ex(idmap_ctx->map, name, sid, &range,
- r->name, rid, external_mapping);
- if (err != IDMAP_SUCCESS) {
- DEBUG(SSSDBG_CRIT_FAILURE, ("Could not add range [%s] to ID map\n",
- r->name));
- ret = EIO;
- goto done;
- }
- }
-
*_idmap_ctx = talloc_steal(mem_ctx, idmap_ctx);
ret = EOK;
diff --git a/src/tests/cmocka/test_ipa_idmap.c b/src/tests/cmocka/test_ipa_idmap.c
new file mode 100644
index 0000000000000000000000000000000000000000..2fb2cde2f9a7f1172fb69b268d19b559ff9d2f32
--- /dev/null
+++ b/src/tests/cmocka/test_ipa_idmap.c
@@ -0,0 +1,249 @@
+/*
+ Authors:
+ Sumit Bose <sbose@redhat.com>
+
+ Copyright (C) 2014 Red Hat
+
+ SSSD tests: Unit tests for id-mapping in the IPA provider
+
+ 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 <http://www.gnu.org/licenses/>.
+*/
+
+#include <popt.h>
+
+#include "tests/cmocka/common_mock.h"
+#include "lib/idmap/sss_idmap.h"
+#include "providers/ipa/ipa_common.h"
+#include "providers/ldap/sdap_idmap.h"
+
+#define RANGE_NAME discard_const("range1")
+#define DOMAIN_SID discard_const("S-1-5-21-2-3-4")
+#define DOMAIN_NAME discard_const("dom.test")
+#define BASE_RID 111
+#define SECONDARY_BASE_RID 11223344
+#define BASE_ID 123456
+#define RANGE_SIZE 222222
+#define RANGE_MAX (BASE_ID + RANGE_SIZE - 1)
+
+void test_get_idmap_data_from_range(void **state)
+{
+ char *dom_name;
+ char *sid;
+ uint32_t rid;
+ struct sss_idmap_range range;
+ bool external_mapping;
+ size_t c;
+ errno_t ret;
+
+ struct test_data {
+ struct range_info r;
+ errno_t exp_ret;
+ char *exp_dom_name;
+ char *exp_sid;
+ uint32_t exp_rid;
+ struct sss_idmap_range exp_range;
+ bool exp_external_mapping;
+ } d[] = {
+ /* working IPA_RANGE_LOCAL range */
+ {{RANGE_NAME, BASE_ID, RANGE_SIZE, BASE_RID, SECONDARY_BASE_RID,
+ NULL, discard_const(IPA_RANGE_LOCAL)},
+ EOK, DOMAIN_NAME, NULL, 0, {BASE_ID, RANGE_MAX}, true},
+ /* working old-style IPA_RANGE_LOCAL range without range type */
+ {{RANGE_NAME, BASE_ID, RANGE_SIZE, BASE_RID, SECONDARY_BASE_RID,
+ NULL, NULL},
+ EOK, DOMAIN_NAME, NULL, 0, {BASE_ID, RANGE_MAX}, true},
+ /* old-style IPA_RANGE_LOCAL without SID and secondary base rid */
+ {{RANGE_NAME, BASE_ID, RANGE_SIZE, BASE_RID, 0, NULL, NULL},
+ EINVAL, NULL, NULL, 0, {0, 0}, false},
+ /* old-style range with SID and secondary base rid */
+ {{RANGE_NAME, BASE_ID, RANGE_SIZE, BASE_RID, SECONDARY_BASE_RID,
+ DOMAIN_SID, NULL},
+ EINVAL, NULL, NULL, 0, {0, 0}, false},
+ /* working IPA_RANGE_AD_TRUST range */
+ {{RANGE_NAME, BASE_ID, RANGE_SIZE, BASE_RID, 0, DOMAIN_SID,
+ discard_const(IPA_RANGE_AD_TRUST)},
+ EOK, DOMAIN_SID, DOMAIN_SID, BASE_RID, {BASE_ID, RANGE_MAX}, false},
+ /* working old-style IPA_RANGE_AD_TRUST range without range type */
+ {{RANGE_NAME, BASE_ID, RANGE_SIZE, BASE_RID, 0, DOMAIN_SID, NULL},
+ EOK, DOMAIN_SID, DOMAIN_SID, BASE_RID, {BASE_ID, RANGE_MAX}, false},
+ /* working IPA_RANGE_AD_TRUST_POSIX range */
+ {{RANGE_NAME, BASE_ID, RANGE_SIZE, BASE_RID, 0, DOMAIN_SID,
+ discard_const(IPA_RANGE_AD_TRUST_POSIX)},
+ EOK, DOMAIN_SID, DOMAIN_SID, 0, {BASE_ID, RANGE_MAX}, true},
+ {{0}, 0, NULL, NULL, 0, {0, 0}, false}
+ };
+
+ for (c = 0; d[c].exp_dom_name != NULL; c++) {
+ ret = get_idmap_data_from_range(&d[c].r, DOMAIN_NAME, &dom_name, &sid,
+ &rid, &range, &external_mapping);
+ assert_int_equal(ret, d[c].exp_ret);
+ assert_string_equal(dom_name, d[c].exp_dom_name);
+ if (d[c].exp_sid == NULL) {
+ assert_null(sid);
+ } else {
+ assert_string_equal(sid, d[c].exp_sid);
+ }
+ assert_int_equal(rid, d[c].exp_rid);
+ assert_int_equal(range.min, d[c].exp_range.min);
+ assert_int_equal(range.max, d[c].exp_range.max);
+ assert_true(external_mapping == d[c].exp_external_mapping);
+ }
+}
+
+errno_t __wrap_sysdb_get_ranges(TALLOC_CTX *mem_ctx, struct sysdb_ctx *sysdb,
+ size_t *range_count,
+ struct range_info ***range_list)
+{
+
+ *range_count = sss_mock_type(size_t);
+ *range_list = talloc_steal(mem_ctx,
+ sss_mock_ptr_type(struct range_info **));
+ return EOK;
+}
+
+struct test_ctx {
+ struct sdap_idmap_ctx *idmap_ctx;
+ struct sdap_id_ctx *sdap_id_ctx;
+};
+
+static struct range_info **get_range_list(TALLOC_CTX *mem_ctx)
+{
+ struct range_info **range_list;
+
+ range_list = talloc_array(mem_ctx, struct range_info *, 2);
+ assert_non_null(range_list);
+
+ range_list[0] = talloc_zero(range_list, struct range_info);
+ assert_non_null(range_list[0]);
+
+ range_list[0]->name = talloc_strdup(range_list[0], RANGE_NAME);
+ assert_non_null( range_list[0]->name);
+ range_list[0]->base_id = BASE_ID;
+ range_list[0]->id_range_size = RANGE_SIZE;
+ range_list[0]->base_rid = BASE_RID;
+ range_list[0]->secondary_base_rid = 0;
+ range_list[0]->trusted_dom_sid = talloc_strdup(range_list[0], DOMAIN_SID);
+ assert_non_null(range_list[0]->trusted_dom_sid);
+ range_list[0]->range_type = talloc_strdup(range_list[0],
+ IPA_RANGE_AD_TRUST);
+ assert_non_null(range_list[0]->range_type);
+
+ return range_list;
+}
+
+void setup_idmap_ctx(void **state)
+{
+ int ret;
+ struct test_ctx *test_ctx;
+
+ assert_true(leak_check_setup());
+
+ test_ctx = talloc_zero(global_talloc_context, struct test_ctx);
+ assert_non_null(test_ctx);
+
+ test_ctx->sdap_id_ctx = talloc_zero(test_ctx,
+ struct sdap_id_ctx);
+ assert_non_null(test_ctx->sdap_id_ctx);
+
+ test_ctx->sdap_id_ctx->be = talloc_zero(test_ctx->sdap_id_ctx,
+ struct be_ctx);
+ assert_non_null(test_ctx->sdap_id_ctx->be);
+
+ test_ctx->sdap_id_ctx->be->domain = talloc_zero(test_ctx->sdap_id_ctx->be,
+ struct sss_domain_info);
+ assert_non_null(test_ctx->sdap_id_ctx->be->domain);
+
+ test_ctx->sdap_id_ctx->be->domain->name =
+ talloc_strdup(test_ctx->sdap_id_ctx->be->domain, DOMAIN_NAME);
+ assert_non_null(test_ctx->sdap_id_ctx->be->domain->name);
+
+ will_return(__wrap_sysdb_get_ranges, 1);
+ will_return(__wrap_sysdb_get_ranges, get_range_list(global_talloc_context));
+
+ ret = ipa_idmap_init(test_ctx, test_ctx->sdap_id_ctx,
+ &test_ctx->idmap_ctx);
+ assert_int_equal(ret, EOK);
+
+ check_leaks_push(test_ctx);
+ *state = test_ctx;
+}
+
+void teardown_idmap_ctx(void **state)
+{
+ struct test_ctx *test_ctx = talloc_get_type(*state, struct test_ctx);
+
+ assert_non_null(test_ctx);
+
+ assert_true(check_leaks_pop(test_ctx) == true);
+
+ talloc_free(test_ctx);
+ assert_true(leak_check_teardown());
+}
+
+void test_ipa_idmap_get_ranges_from_sysdb(void **state)
+{
+ int ret;
+ struct test_ctx *test_ctx = talloc_get_type(*state, struct test_ctx);
+ assert_non_null(test_ctx);
+
+ will_return(__wrap_sysdb_get_ranges, 1);
+ will_return(__wrap_sysdb_get_ranges, get_range_list(test_ctx->idmap_ctx));
+ ret = ipa_idmap_get_ranges_from_sysdb(test_ctx->idmap_ctx,
+ DOMAIN_NAME, DOMAIN_SID, true);
+ assert_int_equal(ret, EOK);
+
+ will_return(__wrap_sysdb_get_ranges, 1);
+ will_return(__wrap_sysdb_get_ranges, get_range_list(global_talloc_context));
+ ret = ipa_idmap_get_ranges_from_sysdb(test_ctx->idmap_ctx,
+ DOMAIN_NAME, DOMAIN_SID, false);
+ assert_int_equal(ret, EIO);
+}
+
+int main(int argc, const char *argv[])
+{
+ poptContext pc;
+ int opt;
+ struct poptOption long_options[] = {
+ POPT_AUTOHELP
+ SSSD_DEBUG_OPTS
+ POPT_TABLEEND
+ };
+
+ const UnitTest tests[] = {
+ unit_test(test_get_idmap_data_from_range),
+ unit_test_setup_teardown(test_ipa_idmap_get_ranges_from_sysdb,
+ setup_idmap_ctx, teardown_idmap_ctx),
+ };
+
+ /* 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_INIT(debug_level);
+
+ tests_set_cwd();
+
+ return run_tests(tests);
+}
--
1.8.5.3