/**
* Creates 100 sessions, searches for one by session id, drops it.
* Outstanding 99 sessions should be removed automatically in teardown.
*/
static void
session_find_id(void **state) {
#ifdef __linux__
sm_ctx_t *ctx = *state;
sm_connection_t *conn = NULL;
sm_session_t *sess = NULL;
int sockets[2] = { 0, };
int rc = SR_ERR_OK;
/* create some sockets */
socketpair(AF_UNIX, SOCK_STREAM, 0, sockets);
/* start a connection */
rc = sm_connection_start(ctx, CM_AF_UNIX_CLIENT, sockets[0], &conn);
assert_int_equal(rc, SR_ERR_OK);
assert_non_null(conn);
/* create 100 sessions */
size_t i = 0;
for (i = 0; i < 100; i ++) {
rc = sm_session_create(ctx, conn, NULL, &sess);
assert_int_equal(rc, SR_ERR_OK);
assert_non_null(sess);
}
/* save session id of last session */
uint32_t id = sess->id;
sess = NULL;
/* find session by id */
rc = sm_session_find_id(ctx, id, &sess);
assert_int_equal(rc, SR_ERR_OK);
assert_non_null(sess);
/* drop session */
rc = sm_session_drop(ctx, sess);
assert_int_equal(rc, SR_ERR_OK);
/* find session by id again - should return not found */
sess = NULL;
rc = sm_session_find_id(ctx, id, &sess);
assert_int_equal(rc, SR_ERR_NOT_FOUND);
assert_null(sess);
/* stop the connection */
rc = sm_connection_stop(ctx, conn);
assert_int_equal(rc, SR_ERR_OK);
#endif
}
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].");
}
void
Test_WinPacketClone_ReturnsNullWhenCloneFails(void **state)
{
WinPacketRawAllocateClone_Callback =
Fake_WinPacketRawAllocateClone_ReturnsNull;
PWIN_PACKET packet = Fake_WinPacketAllocateNonOwned();
PWIN_PACKET_RAW rawPacket = WinPacketToRawPacket(packet);
PWIN_PACKET cloned = WinPacketClone(packet);
assert_null(cloned);
assert_int_equal(WinPacketRawGetChildCountOf(rawPacket), 0);
Fake_WinPacketFree(packet);
}
static void
test_inval_expr4(void **state)
{
struct ly_ctx *ctx = *state;
const char *yang = "module features {\n"
" yang-version 1.1;\n"
" namespace \"urn:features\";\n"
" prefix f;\n"
" feature a;\n"
" feature b;\n"
" feature c { if-feature \"a b\"; }}";
assert_null(lys_parse_mem(ctx, yang, LYS_IN_YANG));
assert_int_equal(ly_vecode, LYVE_INARG);
}
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);
}
void test_encodeData(void)
{
QRcode *qrcode;
testStart("Test QRencode_encodeData.");
qrcode = QRcode_encodeData(0, NULL, 0, QR_ECLEVEL_H);
assert_null(qrcode, "QRcode_encodeData(NULL, 0) returned something.\n");
if(qrcode != NULL) QRcode_free(qrcode);
qrcode = QRcode_encodeData(10, (unsigned char*)"test\0\0test", 0, QR_ECLEVEL_H);
assert_nonnull(qrcode, "QRcode_encodeData() failed.\n");
if(qrcode != NULL) QRcode_free(qrcode);
testFinish();
}
void test_mqr_new(void)
{
QRinput *input;
testStart("Testing QRinput_newMQR().");
input = QRinput_newMQR(0, QR_ECLEVEL_L);
assert_null(input, "Version 0 passed.\n");
QRinput_free(input);
input = QRinput_newMQR(5, QR_ECLEVEL_L);
assert_null(input, "Version 5 passed.\n");
QRinput_free(input);
input = QRinput_newMQR(1, QR_ECLEVEL_M);
assert_null(input, "Invalid ECLEVEL passed.\n");
QRinput_free(input);
input = QRinput_newMQR(1, QR_ECLEVEL_L);
assert_equal(input->version, 1, "QRinput.version was not as expected.\n");
assert_equal(input->level, QR_ECLEVEL_L, "QRinput.version was not as expected.\n");
QRinput_free(input);
testFinish();
}
void test_invalid_input(void)
{
QRinput *input;
QRcode *code;
testStart("Testing invalid input.");
input = QRinput_new();
QRinput_append(input, QR_MODE_AN, 5, (unsigned char *)"TEST1");
input->version = -1;
input->level = QR_ECLEVEL_L;
code = QRcode_encodeInput(input);
assert_null(code, "invalid version(-1) was not checked.\n");
if(code != NULL) QRcode_free(code);
input->version = 41;
input->level = QR_ECLEVEL_L;
code = QRcode_encodeInput(input);
assert_null(code, "invalid version(41) access was not checked.\n");
if(code != NULL) QRcode_free(code);
input->version = 1;
input->level = (QRecLevel)(QR_ECLEVEL_H + 1);
code = QRcode_encodeInput(input);
assert_null(code, "invalid level(H+1) access was not checked.\n");
if(code != NULL) QRcode_free(code);
input->version = 1;
input->level = (QRecLevel)-1;
code = QRcode_encodeInput(input);
assert_null(code, "invalid level(-1) access was not checked.\n");
if(code != NULL) QRcode_free(code);
QRinput_free(input);
testFinish();
}
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);
}
void test_splitentry3(void)
{
QRinput *input;
QRinput_Struct *s;
QRinput_List *e00, *e01, *e10, *e11;
QRinput_InputList *list;
const char *str = "abcdefghijklmno";
testStart("Testing QRinput_splitEntry. (does not split an entry)");
/* version 1 symbol contains 152 bit (19 byte) data.
* 20 bits for a structured-append header, so 132 bits can be used.
* 15 bytes of 8-bit data is suitable for the symbol.
* (mode(4) + length(8) + data(120) == 132.)
*/
input = QRinput_new2(1, QR_ECLEVEL_L);
QRinput_append(input, QR_MODE_8, strlen(str), (unsigned char *)str);
QRinput_append(input, QR_MODE_8, strlen(str), (unsigned char *)str);
s = QRinput_splitQRinputToStruct(input);
list = s->head;
e00 = list->input->head;
e01 = e00->next;
list = list->next;
e10 = list->input->head;
e11 = e00->next;
assert_equal(e00->mode, QR_MODE_STRUCTURE, "Structure header is missing?");
assert_equal(e01->mode, QR_MODE_8, "no data?!");
assert_null(e01->next, "Input list is not terminated!\n");
assert_equal(e10->mode, QR_MODE_STRUCTURE, "Structure header is missing?");
assert_equal(e11->mode, QR_MODE_8, "no data?!");
assert_null(e11->next, "Input list is not terminated!\n");
QRinput_free(input);
QRinput_Struct_free(s);
testFinish();
}
static void
test_circle1(void **state)
{
struct ly_ctx *ctx = *state;
const char *yang = "module features {\n"
" yang-version 1.1;\n"
" namespace \"urn:features\";\n"
" prefix f;\n"
" feature a { if-feature \"b and c\"; }\n"
" feature b { if-feature c; }\n"
" feature c { if-feature \"a or b\"; }}";
assert_null(lys_parse_mem(ctx, yang, LYS_IN_YANG));
assert_int_equal(ly_vecode, LYVE_CIRC_FEATURES);
}
void test_cell_set_owner(void)
{
printf("\ntest_cell_set_owner\n");
s_cell c;
s_player p;
init_cell(&c, 1, 4);
init_player(&p, 1, "test", 1, STRATEGY_NONE, 10);
assert_null(c.owner);
cell_set_owner(&c, &p);
assert_str_equals(c.owner->name, "test");
assert_int_equals(c.owner->nb_cells, 1);
free_cell(&c);
}
END_TEST
START_TEST (bogus_context_input)
{
jsonpath bogus_path;
parser_context context;
context.path = &bogus_path;
context.input = NULL;
context.length = 5;
reset_errno();
assert_null(parse(&context));
assert_errno(EINVAL);
}
/*
* Test GUCArrayReset
*
* superuser: return NULL
*/
void
test__GUCArrayReset__superuser(void **state)
{
ArrayType *in;
ArrayType *out;
will_return(superuser, true);
in = construct_empty_array(TEXTOID);
assert_not_null(in);
out = GUCArrayReset(in);
assert_null(out);
pfree(in);
}
END_TEST
START_TEST (bogus_context_path)
{
uint8_t bogus_input = 64;
parser_context context;
context.path = NULL;
context.input = &bogus_input;
context.length = 5;
reset_errno();
assert_null(parse(&context));
assert_errno(EINVAL);
}
static void
test_discard_entry(void **state)
{
struct entry *e;
krb5_context context = *state;
krb5_data req = string2data("I'm a test request");
krb5_data rep = string2data("I'm a test response");
e = insert_entry(context, &req, &rep, 0);
discard_entry(context, e);
assert_null(k5_hashtab_get(hash_table, req.data, req.length));
assert_int_equal(num_entries, 0);
assert_int_equal(total_size, 0);
}
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);
}
void test_getgrgid_r_wrapper(void **state)
{
int ret;
struct group grp;
char *buf;
size_t buf_len, max_big_buf_len;
struct test_data *test_data;
test_data = (struct test_data *) *state;
ret = get_buffer(&buf_len, &buf);
assert_int_equal(ret, 0);
ret = getgrgid_r_wrapper(test_data->ctx, 99999, &grp, &buf, &buf_len);
assert_int_equal(ret, ENOENT);
ret = getgrgid_r_wrapper(test_data->ctx, 11111, &grp, &buf, &buf_len);
assert_int_equal(ret, 0);
assert_string_equal(grp.gr_name, "group");
assert_string_equal(grp.gr_passwd, "x");
assert_int_equal(grp.gr_gid, 11111);
assert_string_equal(grp.gr_mem[0], "member0001");
assert_string_equal(grp.gr_mem[1], "member0002");
assert_null(grp.gr_mem[2]);
free(buf);
ret = get_buffer(&buf_len, &buf);
assert_int_equal(ret, 0);
ret = getgrgid_r_wrapper(test_data->ctx, 22222, &grp, &buf, &buf_len);
assert_int_equal(ret, 0);
assert_string_equal(grp.gr_name, "group_big");
assert_string_equal(grp.gr_passwd, "x");
assert_int_equal(grp.gr_gid, 22222);
assert_string_equal(grp.gr_mem[0], "member0001");
assert_string_equal(grp.gr_mem[1], "member0002");
free(buf);
ret = get_buffer(&buf_len, &buf);
assert_int_equal(ret, 0);
max_big_buf_len = test_data->ctx->max_nss_buf_size;
test_data->ctx->max_nss_buf_size = 1024;
ret = getgrgid_r_wrapper(test_data->ctx, 22222, &grp, &buf, &buf_len);
test_data->ctx->max_nss_buf_size = max_big_buf_len;
assert_int_equal(ret, ERANGE);
free(buf);
}
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);
}
static void three_elements(void **state) {
(void) state; /* unused */
struct ListNode *head = NULL;
head = createList(head, 3);
head = reverseList(head);
struct ListNode *p = head;
assert_int_equal(p->val, 3);
assert_non_null(p->next);
p = p->next;
assert_int_equal(p->val, 2);
assert_non_null(p->next);
p = p->next;
assert_int_equal(p->val, 1);
assert_null(p->next);
}
END_TEST
START_TEST (bogus_context_length)
{
jsonpath bogus_path;
uint8_t bogus_input = 64;
parser_context context;
context.path = &bogus_path;
context.input = &bogus_input;
context.length = 0;
reset_errno();
assert_null(parse(&context));
assert_errno(EINVAL);
}
static void
test_kdc_check_lookaside_empty(void **state)
{
krb5_boolean result;
krb5_data *result_data;
krb5_context context = *state;
krb5_data req = string2data("I'm a test request");
/* Set result_data so we can verify that it is reset to NULL. */
result_data = &req;
result = kdc_check_lookaside(context, &req, &result_data);
assert_false(result);
assert_null(result_data);
assert_int_equal(hits, 0);
}
void test_init_cell(void)
{
printf("\ntest_init_cell\n");
s_cell c;
int result;
result = init_cell(&c, 1, 4);
assert_null(c.owner);
assert_int_equals(result, 1);
assert_int_equals(c.id, 1);
assert_int_equals(c.nb_pawns, 0);
assert_int_equals(c.nb_neighbours, 0);
assert_int_equals(c.nb_max_neighbours, 3);
free_cell(&c);
}
static void torture_options_proxycommand(void **state) {
ssh_session session = *state;
int rc;
/* Enable ProxyCommand */
rc = ssh_options_set(session, SSH_OPTIONS_PROXYCOMMAND, "ssh -q -A -X -W %h:%p JUMPHOST");
assert_int_equal(rc, 0);
assert_string_equal(session->opts.ProxyCommand, "ssh -q -A -X -W %h:%p JUMPHOST");
/* Disable ProxyCommand */
rc = ssh_options_set(session, SSH_OPTIONS_PROXYCOMMAND, "none");
assert_int_equal(rc, 0);
assert_null(session->opts.ProxyCommand);
}
void get_form_type_field_returns_null_when_not_present(void **state)
{
form_init_module();
DataForm *form = _new_form();
FormField *field = _new_field();
field->var = strdup("var1");
field->values = g_slist_append(field->values, strdup("value1"));
form->fields = g_slist_append(form->fields, field);
char *result = form_get_form_type_field(form);
assert_null(result);
form_destroy(form);
}
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_map_stack(void) {
Map *m1 = make_map(NULL);
map_put(m1, "x", (void *)1);
map_put(m1, "y", (void *)2);
assert_int(1, (int)(intptr_t)map_get(m1, "x"));
Map *m2 = make_map(m1);
assert_int(1, (int)(intptr_t)map_get(m2, "x"));
map_put(m2, "x", (void *)3);
assert_int(3, (int)(intptr_t)map_get(m2, "x"));
assert_int(1, (int)(intptr_t)map_get(m1, "x"));
MapIter *iter = map_iter(m2);
assert_string("x", map_next(iter, NULL));
assert_string("y", map_next(iter, NULL));
assert_null(map_next(iter, NULL));
}
static void test_samba_module_probe_slash(void **state)
{
char dummy_module_path[4096] = {0};
const char *module_env;
NTSTATUS status;
snprintf(dummy_module_path,
sizeof(dummy_module_path),
"%s/bin/modules/rpc/test_dummy_module.so",
SRCDIR);
status = smb_probe_module("rpc", dummy_module_path);
assert_true(NT_STATUS_IS_ERR(status));
module_env = getenv("UNITTEST_DUMMY_MODULE_LOADED");
assert_null(module_env);
}
static void do_test_get_by_dn(const char *dn, const char **dns, size_t n,
const char **dns2, size_t n2, int expected_result)
{
TALLOC_CTX *tmp_ctx;
struct sdap_options *opts;
struct sdap_domain *sdom;
struct sdap_domain *sdom2;
struct sdap_domain *res_sdom;
struct sdap_search_base **search_bases;
struct sdap_search_base **search_bases2;
tmp_ctx = talloc_new(NULL);
assert_non_null(tmp_ctx);
search_bases = generate_bases(tmp_ctx, dns, n);
search_bases2 = generate_bases(tmp_ctx, dns2, n2);
sdom = talloc_zero(tmp_ctx, struct sdap_domain);
assert_non_null(sdom);
sdom2 = talloc_zero(tmp_ctx, struct sdap_domain);
assert_non_null(sdom2);
sdom->search_bases = search_bases;
sdom->next = sdom2;
sdom->prev = NULL;
sdom2->search_bases = search_bases2;
sdom2->next = NULL;
sdom2->prev = sdom;
opts = talloc(tmp_ctx, struct sdap_options);
assert_non_null(opts);
opts->sdom = sdom;
res_sdom = sdap_domain_get_by_dn(opts, dn);
switch (expected_result) {
case DN_NOT_IN_DOMS:
assert_null(res_sdom);
break;
case DN_IN_DOM1:
assert_true(res_sdom == sdom);
break;
case DN_IN_DOM2:
assert_true(res_sdom == sdom2);
break;
}
talloc_free(tmp_ctx);
}
static void
test_kdc_insert_lookaside_cache_expire(void **state)
{
struct entry *e;
krb5_context context = *state;
krb5_data req1 = string2data("I'm a test request");
krb5_data rep1 = string2data("I'm a test response");
size_t e1_size = entry_size(&req1, &rep1);
krb5_data req2 = string2data("I'm a different test request");
size_t e2_size = entry_size(&req2, NULL);
struct entry *hash1_ent, *hash2_ent, *exp_ent;
time_return(0, 0);
kdc_insert_lookaside(context, &req1, &rep1);
hash1_ent = k5_hashtab_get(hash_table, req1.data, req1.length);
assert_non_null(hash1_ent);
assert_true(data_eq(hash1_ent->req_packet, req1));
assert_true(data_eq(hash1_ent->reply_packet, rep1));
exp_ent = K5_TAILQ_FIRST(&expiration_queue);
assert_true(data_eq(exp_ent->req_packet, req1));
assert_true(data_eq(exp_ent->reply_packet, rep1));
assert_int_equal(num_entries, 1);
assert_int_equal(total_size, e1_size);
/* Increase hits on entry */
e = k5_hashtab_get(hash_table, req1.data, req1.length);
assert_non_null(e);
e->num_hits = 5;
time_return(STALE_TIME + 1, 0);
kdc_insert_lookaside(context, &req2, NULL);
assert_null(k5_hashtab_get(hash_table, req1.data, req1.length));
assert_int_equal(max_hits_per_entry, 5);
hash2_ent = k5_hashtab_get(hash_table, req2.data, req2.length);
assert_non_null(hash2_ent);
assert_true(data_eq(hash2_ent->req_packet, req2));
assert_int_equal(hash2_ent-> reply_packet.length, 0);
exp_ent = K5_TAILQ_FIRST(&expiration_queue);
assert_true(data_eq(exp_ent->req_packet, req2));
assert_int_equal(exp_ent->reply_packet.length, 0);
assert_int_equal(num_entries, 1);
assert_int_equal(total_size, e2_size);
}
