/** * 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); }