/* Testsuite setup and teardown */
void dyndns_test_setup(void **state)
{
struct sss_test_conf_param params[] = {
{ "dyndns_update", "true" },
{ "dyndns_refresh_interval", "2" },
{ NULL, NULL }, /* Sentinel */
};
assert_true(leak_check_setup());
dyndns_test_ctx = talloc_zero(global_talloc_context, struct dyndns_test_ctx);
assert_non_null(dyndns_test_ctx);
dyndns_test_ctx->tctx = create_dom_test_ctx(dyndns_test_ctx, TESTS_PATH,
TEST_CONF_DB, TEST_DOM_NAME,
TEST_ID_PROVIDER, params);
assert_non_null(dyndns_test_ctx->tctx);
dyndns_test_ctx->be_ctx = talloc_zero(dyndns_test_ctx, struct be_ctx);
assert_non_null(dyndns_test_ctx->be_ctx);
dyndns_test_ctx->be_ctx->cdb = dyndns_test_ctx->tctx->confdb;
dyndns_test_ctx->be_ctx->ev = dyndns_test_ctx->tctx->ev;
dyndns_test_ctx->be_ctx->conf_path = dyndns_test_ctx->tctx->conf_dom_path;
}
static int test_ncache_setup(void **state)
{
struct ncache_test_ctx *test_ctx;
assert_true(leak_check_setup());
test_ctx = talloc_zero(global_talloc_context, struct ncache_test_ctx);
assert_non_null(test_ctx);
test_dom_suite_setup(TESTS_PATH);
test_ctx->tctx = create_dom_test_ctx(test_ctx, TESTS_PATH, TEST_CONF_DB,
TEST_DOM_NAME, "ipa", NULL);
assert_non_null(test_ctx->tctx);
create_groups(test_ctx, test_ctx->tctx->dom);
create_users(test_ctx, test_ctx->tctx->dom);
check_leaks_push(test_ctx);
*state = (void *)test_ctx;
return 0;
}
static struct sss_domain_info *create_test_domain(TALLOC_CTX *mem_ctx,
const char *name,
const char *flatname,
struct sss_domain_info *parent,
struct sss_names_ctx *nctx)
{
struct sss_domain_info *dom;
dom = talloc_zero(mem_ctx, struct sss_domain_info);
assert_non_null(dom);
/* just to make new_subdomain happy */
dom->sysdb = talloc_zero(dom, struct sysdb_ctx);
assert_non_null(dom->sysdb);
dom->name = discard_const(name);
dom->flat_name = discard_const(flatname);
dom->parent = parent;
dom->names = nctx;
dom->provider = discard_const(PROVIDER);
dom->conn_name = discard_const(CONNNAME);
return dom;
}
static int session_setup(void **state)
{
struct torture_state *s = *state;
int verbosity = torture_libssh_verbosity();
struct passwd *pwd;
int rc;
pwd = getpwnam("bob");
assert_non_null(pwd);
rc = setuid(pwd->pw_uid);
assert_return_code(rc, errno);
s->ssh.session = ssh_new();
assert_non_null(s->ssh.session);
rc = ssh_options_set(s->ssh.session, SSH_OPTIONS_LOG_VERBOSITY, &verbosity);
assert_ssh_return_code(s->ssh.session, rc);
rc = ssh_options_set(s->ssh.session, SSH_OPTIONS_HOST, TORTURE_SSH_SERVER);
assert_ssh_return_code(s->ssh.session, rc);
return 0;
}
void test_set_err_msg(void **state)
{
struct extdom_req *req;
struct test_data *test_data;
test_data = (struct test_data *) *state;
req = test_data->req;
assert_null(req->err_msg);
set_err_msg(NULL, NULL);
assert_null(req->err_msg);
set_err_msg(req, NULL);
assert_null(req->err_msg);
set_err_msg(req, "Test [%s][%d].", "ABCD", 1234);
assert_non_null(req->err_msg);
assert_string_equal(req->err_msg, "Test [ABCD][1234].");
set_err_msg(req, "2nd Test [%s][%d].", "ABCD", 1234);
assert_non_null(req->err_msg);
assert_string_equal(req->err_msg, "Test [ABCD][1234].");
}
static struct ifp_ctx *
mock_ifp_ctx(TALLOC_CTX *mem_ctx)
{
struct ifp_ctx *ifp_ctx;
ifp_ctx = talloc_zero(mem_ctx, struct ifp_ctx);
assert_non_null(ifp_ctx);
ifp_ctx->rctx = mock_rctx(ifp_ctx, NULL, NULL, NULL);
assert_non_null(ifp_ctx->rctx);
ifp_ctx->rctx->allowed_uids = talloc_array(ifp_ctx->rctx, uint32_t, 1);
assert_non_null(ifp_ctx->rctx->allowed_uids);
ifp_ctx->rctx->allowed_uids[0] = geteuid();
ifp_ctx->rctx->allowed_uids_count = 1;
ifp_ctx->sysbus = talloc_zero(ifp_ctx, struct sysbus_ctx);
assert_non_null(ifp_ctx->sysbus);
ifp_ctx->sysbus->conn = talloc_zero(ifp_ctx, struct sbus_connection);
assert_non_null(ifp_ctx->sysbus->conn);
return ifp_ctx;
}
static int test_sss_idmap_teardown(void **state)
{
struct test_ctx *test_ctx;
test_ctx = talloc_get_type(*state, struct test_ctx);
assert_non_null(test_ctx);
talloc_free(test_ctx->idmap_ctx);
talloc_free(test_ctx->mem_idmap);
assert_true(check_leaks_pop(test_ctx) == true);
talloc_free(test_ctx);
assert_true(leak_check_teardown());
return 0;
}
static void test_env(void **state)
{
const char *v;
struct stat sb;
int ret;
(void) state; /* unused */
v = getenv("PAM_WRAPPER_RUNTIME_DIR");
assert_non_null(v);
ret = stat(v, &sb);
assert_int_not_equal(ret, -1);
assert_true(S_ISDIR(sb.st_mode));
}
static void
test_source_parse_config_reserved_name11(void **state)
{
const char *a = "BLOGC_VERSION: 1.0\r\n";
blogc_error_t *err = NULL;
b_trie_t *source = blogc_source_parse(a, strlen(a), &err);
assert_null(source);
assert_non_null(err);
assert_int_equal(err->type, BLOGC_ERROR_SOURCE_PARSER);
assert_string_equal(err->msg,
"'BLOGC_VERSION' variable is forbidden in source files. It will be set "
"for you by the compiler.");
blogc_error_free(err);
b_trie_free(source);
}
static void
test_content_parse_horizontal_rule(void **state)
{
char *html = blogc_content_parse("bola\nguda\n\n**", NULL);
assert_non_null(html);
assert_string_equal(html,
"<p>bola\n"
"guda</p>\n"
"<hr />\n");
free(html);
html = blogc_content_parse("bola\nguda\n\n++++", NULL);
assert_non_null(html);
assert_string_equal(html,
"<p>bola\n"
"guda</p>\n"
"<hr />\n");
free(html);
html = blogc_content_parse("bola\nguda\n\n--\n", NULL);
assert_non_null(html);
assert_string_equal(html,
"<p>bola\n"
"guda</p>\n"
"<hr />\n");
free(html);
html = blogc_content_parse("bola\nguda\n\n****\n", NULL);
assert_non_null(html);
assert_string_equal(html,
"<p>bola\n"
"guda</p>\n"
"<hr />\n");
free(html);
html = blogc_content_parse(
"bola\n"
"\n"
"**\n"
"\n"
"chunda\n", NULL);
assert_non_null(html);
assert_string_equal(html,
"<p>bola</p>\n"
"<hr />\n"
"<p>chunda</p>\n");
free(html);
html = blogc_content_parse(
"bola\n"
"\n"
"----\n"
"\n"
"chunda\n", NULL);
assert_non_null(html);
assert_string_equal(html,
"<p>bola</p>\n"
"<hr />\n"
"<p>chunda</p>\n");
free(html);
}
static int teardown_passdb(void **state)
{
const char *db;
(void) state; /* unused */
db = getenv("PAM_MATRIX_PASSWD");
assert_non_null(db);
unlink(db);
/* Don't pollute environment for other tests */
unsetenv("PAM_MATRIX_PASSWD");
return 0;
}
static void
test_content_parse_header(void **state)
{
char *html = blogc_content_parse("## bola", NULL);
assert_non_null(html);
assert_string_equal(html, "<h2 id=\"bola\">bola</h2>\n");
free(html);
html = blogc_content_parse("## bola\n", NULL);
assert_non_null(html);
assert_string_equal(html, "<h2 id=\"bola\">bola</h2>\n");
free(html);
html = blogc_content_parse(
"bola\n"
"\n"
"## bola\n"
"\n"
"guda\n", NULL);
assert_non_null(html);
assert_string_equal(html,
"<p>bola</p>\n"
"<h2 id=\"bola\">bola</h2>\n"
"<p>guda</p>\n");
free(html);
}
static void
test_source_parse_invalid_separator(void **state)
{
const char *a = "BOLA: asd\n---#";
blogc_error_t *err = NULL;
b_trie_t *source = blogc_source_parse(a, strlen(a), &err);
assert_null(source);
assert_non_null(err);
assert_int_equal(err->type, BLOGC_ERROR_SOURCE_PARSER);
assert_string_equal(err->msg,
"Invalid content separator. Must be more than one '-' characters.\n"
"Error occurred near to '#'");
blogc_error_free(err);
b_trie_free(source);
}
/*
*Test Safety With Bad Data Input
*/
void test_svg_null_input( void ** _ )
{
svg_t * svgh;
(void)_;
/*Get a new handle*/
assert_non_null(
svgh = svg()
);
svg_incref(NULL);
svg_decref(NULL);
svg_decref(svgh);
}
static void
sr_new_val_test(void **state)
{
int rc = 0;
sr_val_t *value = NULL;
rc = sr_new_val(NULL, &value);
assert_int_equal(SR_ERR_OK, rc);
#ifdef USE_SR_MEM_MGMT
assert_non_null(value->_sr_mem);
assert_int_equal(1, value->_sr_mem->obj_count);
assert_true(0 < value->_sr_mem->used_total);
#else
assert_null(value->_sr_mem);
#endif
assert_null(value->xpath);
assert_false(value->dflt);
assert_int_equal(SR_UNKNOWN_T, value->type);
assert_int_equal(0, value->data.uint64_val);
sr_free_val(value);
rc = sr_new_val(XPATH1, &value);
assert_int_equal(SR_ERR_OK, rc);
#ifdef USE_SR_MEM_MGMT
assert_non_null(value->_sr_mem);
assert_int_equal(1, value->_sr_mem->obj_count);
assert_true(0 < value->_sr_mem->used_total);
#else
assert_null(value->_sr_mem);
#endif
assert_string_equal(XPATH1, value->xpath);
assert_false(value->dflt);
assert_int_equal(SR_UNKNOWN_T, value->type);
assert_int_equal(0, value->data.uint64_val);
sr_free_val(value);
}
static void setup_dir(void **state) {
int rc;
mbchar_t *dir = c_utf8_to_locale(CSYNC_TEST_DIR);
setup(state);
rc = _tmkdir(dir, MKDIR_MASK);
c_free_locale_string(dir);
assert_int_equal(rc, 0);
assert_non_null(getcwd(wd_buffer, WD_BUFFER_SIZE));
rc = chdir(CSYNC_TEST_DIR);
assert_int_equal(rc, 0);
}
static void
cl_notif_priority_test(void **state)
{
sr_conn_ctx_t *conn = *state;
assert_non_null(conn);
sr_session_ctx_t *session = NULL;
sr_subscription_ctx_t *subscription = NULL;
priority_t priority = {0};
int rc = SR_ERR_OK;
/* start session */
rc = sr_session_start(conn, SR_DS_RUNNING, SR_SESS_DEFAULT, &session);
assert_int_equal(rc, SR_ERR_OK);
rc = sr_module_change_subscribe(session, "test-module", priority_zero_cb, &priority,
0, SR_SUBSCR_DEFAULT, &subscription);
assert_int_equal(rc, SR_ERR_OK);
rc = sr_module_change_subscribe(session, "test-module", priority_two_cb, &priority,
2, SR_SUBSCR_DEFAULT | SR_SUBSCR_CTX_REUSE, &subscription);
assert_int_equal(rc, SR_ERR_OK);
rc = sr_module_change_subscribe(session, "test-module", priority_one_cb, &priority,
1, SR_SUBSCR_DEFAULT | SR_SUBSCR_CTX_REUSE, &subscription);
assert_int_equal(rc, SR_ERR_OK);
rc = sr_set_item(session, "/test-module:user[name='userA']", NULL, SR_EDIT_DEFAULT);
assert_int_equal(rc, SR_ERR_OK);
rc = sr_commit(session);
assert_int_equal(rc, SR_ERR_OK);
/* timeout 10 sec */
for (size_t i = 0; i < 1000; i++) {
if (priority.count >= 3) break;
usleep(10000); /* 10 ms */
}
assert_int_equal(priority.count, 3);
assert_int_equal(2, priority.cb [0]);
assert_int_equal(1, priority.cb [1]);
assert_int_equal(0, priority.cb [2]);
/* check that cb were called in correct order according to the priority */
sr_unsubscribe(session, subscription);
sr_session_stop(session);
}
static void
test_gf_mem_set_acct_info_memory(void **state)
{
xlator_t *xl;
char *alloc_ptr;
char *temp_ptr;
size_t size;
uint32_t type;
const char *typestr = "TEST";
size = 8196;
type = 9;
// Initialize xl
xl = helper_xlator_init(10);
assert_null(xl->mem_acct.rec[type].typestr);
// Test allocation
temp_ptr = test_calloc(1, size + GF_MEM_HEADER_SIZE + GF_MEM_TRAILER_SIZE);
assert_non_null(temp_ptr);
alloc_ptr = temp_ptr;
gf_mem_set_acct_info(xl, &alloc_ptr, size, type, typestr);
//Check values
assert_ptr_equal(typestr, xl->mem_acct.rec[type].typestr);
assert_int_equal(xl->mem_acct.rec[type].size, size);
assert_int_equal(xl->mem_acct.rec[type].num_allocs, 1);
assert_int_equal(xl->mem_acct.rec[type].total_allocs, 1);
assert_int_equal(xl->mem_acct.rec[type].max_size, size);
assert_int_equal(xl->mem_acct.rec[type].max_num_allocs, 1);
// Check memory
helper_check_memory_headers(temp_ptr, xl, size, type);
// Check that alloc_ptr has been moved correctly
// by gf_mem_set_acct_info
{
mem_header_t *p;
p = (mem_header_t *)temp_ptr;
p++;
p->type = 1234;
assert_int_equal(*(uint32_t *)alloc_ptr, p->type);
}
free(temp_ptr);
helper_xlator_destroy(xl);
}
void pkd_stop(struct pkd_result *out) {
int rc = 0;
ctx.keep_going = 0;
rc = pthread_kill(ctx.tid, SIGUSR1);
assert_int_equal(rc, 0);
rc = pthread_join(ctx.tid, NULL);
assert_int_equal(rc, 0);
assert_non_null(out);
out->ok = (ctx.rc == 0);
return;
}
static void test_insertTop(void **state)
{
const int a = 1001;
LinkedList *list = createList();
assert_non_null(list);
assert_false(insertTop(NULL, NULL));
int b = 0;
assert_false(insertTop(NULL, &b));
for (int i = 0; i < a; i++)
{
int *c = malloc(sizeof(int));
assert_true(insertTop(list, c));
assert_ptr_equal(list->head->data, c);
}
destroyList(list);
}
/**
* Testing new arrays
* TODO: testing also free
*/
static void test_grf_array_new(void** state){
(void) state;
GrfArray* array = grf_array_new();
assert_non_null(array);
assert_int_equal(grf_array_get_num_elements(array),0);
assert_int_equal(grf_array_get_type(array),GRF_UINT8);
assert_int_equal(grf_array_get_dim(array), 0);
assert_int_equal(grf_array_get_bitsize(array), 0);
assert_int_equal(grf_array_get_num_bytes(array), 0);
uint32_t* size = grf_array_get_size(array);
assert_null(size);
assert_null(grf_array_get_step(array));
void* data = grf_array_get_data(array);
assert_null(data);
grf_array_free(array);
}
static void test_short_indef(void **state)
{
bs = cbor_load(data10, 6, &res);
assert_non_null(bs);
assert_true(cbor_typeof(bs) == CBOR_TYPE_BYTESTRING);
assert_true(cbor_isa_bytestring(bs));
assert_true(cbor_bytestring_length(bs) == 0);
assert_true(cbor_bytestring_is_indefinite(bs));
assert_true(cbor_bytestring_chunk_count(bs) == 1);
assert_true(res.read == 5);
assert_true(cbor_isa_bytestring(cbor_bytestring_chunks_handle(bs)[0]));
assert_true(cbor_bytestring_length(cbor_bytestring_chunks_handle(bs)[0]) == 1);
assert_true(*cbor_bytestring_handle(cbor_bytestring_chunks_handle(bs)[0]) == 0xA1);
cbor_decref(&bs);
assert_null(bs);
}
static void
test_nc_rpc_unlock(void **state)
{
(void)state;
struct nc_rpc *rpc = NULL;
struct nc_rpc_lock *unlock_rpc = NULL;
rpc = nc_rpc_unlock(NC_DATASTORE_RUNNING);
assert_non_null(rpc);
assert_int_equal(nc_rpc_get_type(rpc), NC_RPC_UNLOCK);
unlock_rpc = (struct nc_rpc_lock *)rpc;
assert_int_equal(unlock_rpc->type, NC_RPC_UNLOCK);
assert_int_equal(unlock_rpc->target, NC_DATASTORE_RUNNING);
nc_rpc_free(rpc);
}
static int
rp_setup(void **state)
{
rp_ctx_t *rp_ctx = NULL;
int rc = 0;
sr_logger_init("rp_test");
sr_log_stderr(SR_LL_DBG);
rc = rp_init(NULL, &rp_ctx);
assert_int_equal(rc, SR_ERR_OK);
assert_non_null(rp_ctx);
*state = rp_ctx;
return 0;
}
static void
daemon_kill()
{
FILE *pidfile = NULL;
int pid = 0, ret = 0;
/* read PID of the daemon from sysrepo PID file */
pidfile = fopen(SR_DAEMON_PID_FILE, "r");
assert_non_null(pidfile);
ret = fscanf(pidfile, "%d", &pid);
assert_int_equal(ret, 1);
/* send SIGTERM to the daemon process */
ret = kill(pid, SIGTERM);
assert_int_not_equal(ret, -1);
}
static int setup(void **state)
{
struct ssh_callbacks_struct *cb;
cb = malloc(sizeof(struct ssh_callbacks_struct));
assert_non_null(cb);
ZERO_STRUCTP(cb);
cb->userdata = (void *) 0x0badc0de;
cb->auth_function = myauthcallback;
ssh_callbacks_init(cb);
*state = cb;
return 0;
}
static void setup_init(void **state) {
CSYNC *csync;
int rc;
rc = csync_create(&csync, "/tmp/check_csync1", "/tmp/check_csync2");
assert_int_equal(rc, 0);
free(csync->options.config_dir);
csync->options.config_dir = c_strdup("/tmp/check_csync1/");
assert_non_null(csync->options.config_dir);
rc = csync_exclude_load(csync, BINARYDIR "/config/" CSYNC_EXCLUDE_FILE);
assert_int_equal(rc, 0);
*state = csync;
}
/*
* Add an objectSID in string form to the supplied message
*
*
*/
static void add_sid(
struct ldb_message *msg,
const char *sid_str)
{
struct ldb_val v;
enum ndr_err_code ndr_err;
struct dom_sid *sid = NULL;
sid = talloc_zero(msg, struct dom_sid);
assert_non_null(sid);
assert_true(string_to_sid(sid, sid_str));
ndr_err = ndr_push_struct_blob(&v, msg, sid,
(ndr_push_flags_fn_t)ndr_push_dom_sid);
assert_true(NDR_ERR_CODE_IS_SUCCESS(ndr_err));
assert_int_equal(0, ldb_msg_add_value(msg, "objectSID", &v, NULL));
}
void printf_test() {
run_container_t* B = run_container_create();
assert_non_null(B);
run_container_add(B, 1);
run_container_add(B, 2);
run_container_add(B, 3);
run_container_add(B, 10);
run_container_add(B, 10000);
run_container_printf(B);
printf("\n");
run_container_free(B);
}
static void torture_auth_cert(void **state) {
struct torture_state *s = *state;
ssh_session session = s->ssh.session;
ssh_key privkey = NULL;
ssh_key cert = NULL;
char bob_ssh_key[1024];
char bob_ssh_cert[2048];
struct passwd *pwd;
int rc;
pwd = getpwnam("bob");
assert_non_null(pwd);
snprintf(bob_ssh_key,
sizeof(bob_ssh_key),
"%s/.ssh_cert/id_rsa",
pwd->pw_dir);
snprintf(bob_ssh_cert,
sizeof(bob_ssh_cert),
"%s-cert.pub",
bob_ssh_key);
/* cert has been signed for login as alice */
rc = ssh_options_set(session, SSH_OPTIONS_USER, TORTURE_SSH_USER_ALICE);
assert_int_equal(rc, SSH_OK);
rc = ssh_connect(session);
assert_int_equal(rc, SSH_OK);
rc = ssh_pki_import_privkey_file(bob_ssh_key, NULL, NULL, NULL, &privkey);
assert_int_equal(rc, SSH_OK);
rc = ssh_pki_import_cert_file(bob_ssh_cert, &cert);
assert_int_equal(rc, SSH_OK);
rc = ssh_pki_copy_cert_to_privkey(cert, privkey);
assert_int_equal(rc, SSH_OK);
rc = ssh_userauth_try_publickey(session, NULL, cert);
assert_int_equal(rc, SSH_AUTH_SUCCESS);
rc = ssh_userauth_publickey(session, NULL, privkey);
assert_int_equal(rc, SSH_AUTH_SUCCESS);
ssh_key_free(privkey);
ssh_key_free(cert);
}
