static void test_2(void **state) { struct data *data = *state; assert_true(tj_buffer_appendString( data->source, "A $MAN, a $PLAN, a $CANAL, Panama!")); assert_true(tj_template_variables_setFromString( data->vars, "MAN", "man")); assert_true(tj_template_variables_setFromString( data->vars, "PLAN", "plan")); assert_true(tj_template_variables_setFromString( data->vars, "CANAL", "canal")); assert_true(tj_template_variables_apply( data->vars, data->target, data->source)); assert_string_equal(tj_buffer_getAsString(data->target), "A man, a plan, a canal, Panama!"); }
static void TestCheckConfigIsDefault(ExecConfig *c) { assert_int_equal(10800, c->agent_expireafter); assert_string_equal("", c->exec_command); assert_string_equal("LOG_USER",c->log_facility); assert_string_equal("",c->mail_from_address); assert_int_equal(30, c->mail_max_lines); assert_string_equal("", c->mail_server); assert_string_equal("",c->mail_to_address); assert_string_equal("",c->mail_subject); assert_int_equal(0, c->splay_time); assert_int_equal(12, StringSetSize(c->schedule)); }
static void test_rewind(void) { char *buf; assert_int_equal(0, add_completion("acd")); assert_int_equal(0, add_completion("abc")); completion_group_end(); assert_int_equal(0, add_completion("a")); buf = next_completion(); assert_string_equal("abc", buf); free(buf); rewind_completion(); free(next_completion()); buf = next_completion(); assert_string_equal("abc", buf); free(buf); buf = next_completion(); assert_string_equal("acd", buf); free(buf); rewind_completion(); free(next_completion()); buf = next_completion(); assert_string_equal("abc", buf); free(buf); buf = next_completion(); assert_string_equal("acd", buf); free(buf); buf = next_completion(); assert_string_equal("a", buf); free(buf); buf = next_completion(); assert_string_equal("abc", buf); free(buf); }
static void ofp_http_match_test(void** state) { CHECK_ZERO_MEMORY_ALLOCATED; ofp_http_request_description_t desc; inplace_string_set(&desc.method, "GET"); inplace_string_set(&desc.host, "example.com"); inplace_string_set(&desc.uri, "/index.html"); ofp_uri_list_t* uris = ofp_uri_list_new(); ofp_uri_list_entry_t* matchEntry = NULL; int result = http_match(&desc, "example.com", uris, &matchEntry); assert_null(matchEntry); assert_int_equal(HttpMatchUrlNotInList, result); ofp_uri_list_entry_add_uri(uris, strdup("/index.html")); result = http_match(&desc, "example.com", uris, &matchEntry); assert_non_null(matchEntry); assert_non_null(matchEntry->uri); assert_int_equal(HttpMatchStartWith, result); #if REGEX inplace_string_set(&desc.uri, "/phish/index.html"); ofp_uri_list_entry_add_regex(uris, ovh_regex_new("/plop.*\\.html")); result = http_match(&desc, "example.com", uris, &matchEntry); assert_null(matchEntry); assert_int_equal(HttpMatchUrlNotInList, result); ofp_uri_list_entry_add_regex(uris, ovh_regex_new("/phish.*\\.html")); result = http_match(&desc, "example.com", uris, &matchEntry); assert_non_null(matchEntry); assert_non_null(matchEntry->regex); assert_string_equal("/phish.*\\.html", matchEntry->regex->pattern); assert_int_equal(HttpMatchRegex, result); #endif ofp_uri_list_free_elements(uris); ofp_uri_list_free(uris); CHECK_ZERO_MEMORY_ALLOCATED; }
static void sr_test_all_printers(sr_node_t *tree, int depth_level, const char *expected) { int rc = SR_ERR_OK; char *mem = NULL; char filepath1[] = "/tmp/sr_tree_test1.XXXXXX", filepath2[] = "/tmp/sr_tree_test2.XXXXXX"; int fd = 0; FILE *stream = NULL; mode_t orig_umask = umask(S_IRWXO|S_IRWXG); /* memory */ rc = sr_print_tree_mem(&mem, tree, depth_level); assert_int_equal(SR_ERR_OK, rc); if (NULL == expected) { assert_null(mem); } else { assert_non_null(mem); assert_string_equal(expected, mem); } free(mem); /* fd */ fd = mkstemp(filepath1); assert_true(0 < fd); rc = sr_print_tree_fd(fd, tree, depth_level); assert_int_equal(SR_ERR_OK, rc); close(fd); test_file_content(filepath1, expected ? expected : "", false); unlink(filepath1); /* stream */ fd = mkstemp(filepath2); assert_true(0 < fd); stream = fdopen(fd, "w"); assert_non_null(stream); rc = sr_print_tree_stream(stream, tree, depth_level); assert_int_equal(SR_ERR_OK, rc); fclose(stream); test_file_content(filepath2, expected ? expected : "", false); unlink(filepath2); umask(orig_umask); }
static void test_expand_scalar_array_with_scalar_arg(void **state) { EvalContext *ctx = *state; { VarRef *lval = VarRefParse("default:bundle.foo[one]"); EvalContextVariablePut(ctx, lval, "first", CF_DATA_TYPE_STRING, NULL); VarRefDestroy(lval); } { VarRef *lval = VarRefParse("default:bundle.bar"); EvalContextVariablePut(ctx, lval, "one", CF_DATA_TYPE_STRING, NULL); VarRefDestroy(lval); } Buffer *res = BufferNew(); ExpandScalar(ctx, "default", "bundle", "a$(foo[$(bar)])b", res); assert_string_equal("afirstb", BufferData(res)); BufferDestroy(res); }
static void test_unlink_augment(void **state) { struct state *st = (struct state *)*state; struct lyd_node *node; /* schema */ st->mod = lys_parse_path(st->ctx, TESTS_DIR"/data/files/when-unlink.yin", LYS_IN_YIN); assert_ptr_not_equal(st->mod, NULL); st->dt = lyd_new_path(NULL, st->ctx, "/when-unlink:top/d", "1", 0, 0); assert_ptr_not_equal(st->dt, NULL); node = lyd_new_path(st->dt, st->ctx, "/when-unlink:top/d", "2", 0, 0); assert_ptr_not_equal(node, NULL); assert_int_equal(lyd_validate(&(st->dt), LYD_OPT_CONFIG, NULL), 0); lyd_print_mem(&(st->xml), st->dt, LYD_XML, LYP_WITHSIBLINGS); assert_string_equal(st->xml, "<top xmlns=\"urn:libyang:tests:when-unlink\"><d>1</d><d>2</d></top>"); }
static void test_expand_scalar_two_scalars_nested(void **state) { EvalContext *ctx = *state; { VarRef *lval = VarRefParse("default:bundle.one"); EvalContextVariablePut(ctx, lval, "first", CF_DATA_TYPE_STRING, NULL); VarRefDestroy(lval); } { VarRef *lval = VarRefParse("default:bundle.two"); EvalContextVariablePut(ctx, lval, "one", CF_DATA_TYPE_STRING, NULL); VarRefDestroy(lval); } Buffer *res = BufferNew(); ExpandScalar(ctx, "default", "bundle", "a $($(two))b", res); assert_string_equal("a firstb", BufferData(res)); BufferDestroy(res); }
static void test_replace(void) { VariableTable *t = ReferenceTable(); VarRef *ref = VarRefParse("scope1.lval1"); TestGet(t, "scope1.lval1"); Rval rval = (Rval) { "foo", RVAL_TYPE_SCALAR }; assert_true(VariableTablePut(t, ref, &rval, DATA_TYPE_STRING, NULL, NULL)); Variable *v = VariableTableGet(t, ref); assert_true(v != NULL); assert_string_equal("foo", RvalScalarValue(v->rval)); VarRefDestroy(ref); VariableTableDestroy(t); }
static void test_iterator_current(void **state) { const char *data = ARRAY_SIMPLE; JsonElement *arr = JsonParse(&data); JsonElement *json = JsonObjectCreate(1); JsonObjectAppendArray(json, "array", arr); JsonIterator it = JsonIteratorInit(json); while (JsonIteratorNextValue(&it) != NULL) { assert_int_equal((int)JsonIteratorCurrentElementType(&it), (int)JSON_ELEMENT_TYPE_CONTAINER); assert_int_equal((int)JsonIteratorCurrentContrainerType(&it), (int)JSON_CONTAINER_TYPE_ARRAY); assert_string_equal(JsonIteratorCurrentKey(&it), "array"); } JsonElementDestroy(json); }
static void test_periodic_event_callback() { init_timer(); char user_data[] = "It's time!!!"; will_return_count( mock_clock_gettime, 0, -1 ); assert_true( add_periodic_event_callback( 1, mock_timer_event_callback, user_data ) ); timer_callback_info *callback = find_timer_callback( mock_timer_event_callback ); assert_true( callback != NULL ); assert_true( callback->function == mock_timer_event_callback ); assert_string_equal( callback->user_data, "It's time!!!" ); assert_int_equal( callback->interval.tv_sec, 1 ); assert_int_equal( callback->interval.tv_nsec, 0 ); delete_timer_event( mock_timer_event_callback, user_data ); assert_true( find_timer_callback( mock_timer_event_callback ) == NULL ); finalize_timer(); }
void contact_presence_online_when_same_prioroty(void **state) { PContact contact = p_contact_new("*****@*****.**", "bob", NULL, "both", "is offline", FALSE); Resource *resource_online = resource_new("resource_online", RESOURCE_ONLINE, NULL, 10); Resource *resource_away = resource_new("resource_away", RESOURCE_AWAY, NULL, 10); Resource *resource_xa = resource_new("resource_xa", RESOURCE_XA, NULL, 10); Resource *resource_dnd = resource_new("resource_dnd", RESOURCE_DND, NULL, 10); p_contact_set_presence(contact, resource_online); p_contact_set_presence(contact, resource_away); p_contact_set_presence(contact, resource_xa); p_contact_set_presence(contact, resource_dnd); const char *presence = p_contact_presence(contact); assert_string_equal("online", presence); p_contact_free(contact); }
static void check_to_multibyte(void **state) { int rc = -1; mbchar_t *mb_string = c_utf8_path_to_locale( TESTSTRING ); mbchar_t *mb_null = c_utf8_path_to_locale( NULL ); (void) state; #ifdef _WIN32 assert_int_equal( wcscmp( LTESTSTRING, mb_string), 0 ); #else assert_string_equal(mb_string, TESTSTRING); #endif assert_true( mb_null == NULL ); assert_int_equal(rc, -1); c_free_locale_string(mb_string); c_free_locale_string(mb_null); }
void add_unique_value_does_nothing_when_exists(void **state) { form_init_module(); DataForm *form = _new_form(); g_hash_table_insert(form->tag_to_var, strdup("tag1"), strdup("var1")); g_hash_table_insert(form->tag_to_var, strdup("tag2"), strdup("var2")); FormField *field1 = _new_field(); field1->var = strdup("var1"); field1->type_t = FIELD_JID_MULTI; field1->values = g_slist_append(field1->values, strdup("*****@*****.**")); form->fields = g_slist_append(form->fields, field1); FormField *field2 = _new_field(); field2->var = strdup("var2"); field2->type_t = FIELD_LIST_SINGLE; field2->values = g_slist_append(field2->values, strdup("value2")); form->fields = g_slist_append(form->fields, field2); gboolean ret = form_add_unique_value(form, "tag1", "*****@*****.**"); int length = 0; char *value = NULL; GSList *curr_field = form->fields; while (curr_field != NULL) { FormField *field = curr_field->data; if (g_strcmp0(field->var, "var1") == 0) { length = g_slist_length(field->values); value = field->values->data; break; } curr_field = g_slist_next(curr_field); } assert_false(ret); assert_int_equal(length, 1); assert_string_equal(value, "*****@*****.**"); form_destroy(form); }
TEST(link_is_not_resolved_by_default, IF(not_windows)) { assert_success(os_mkdir("dir", 0700)); cfg.chase_links = 0; /* symlink() is not available on Windows, but other code is fine. */ #ifndef _WIN32 assert_success(symlink("dir", "dir-link")); #endif assert_non_null(get_cwd(curr_view->curr_dir, sizeof(curr_view->curr_dir))); assert_true(change_directory(curr_view, "dir-link") >= 0); assert_string_equal("dir-link", get_last_path_component(curr_view->curr_dir)); /* Go out of the directory so that we can remove it. */ assert_true(change_directory(curr_view, "..") >= 0); assert_success(rmdir("dir")); assert_success(remove("dir-link")); }
static void test_show_object_array(void) { JsonElement *json = JsonObjectCreate(10); JsonElement *array = JsonArrayCreate(10); JsonArrayAppendString(array, "one"); JsonArrayAppendString(array, "two"); JsonObjectAppendArray(json, "first", array); Writer *writer = StringWriter(); JsonWrite(writer, json, 0); char *output = StringWriterClose(writer); assert_string_equal(OBJECT_ARRAY, output); JsonDestroy(json); free(output); }
static void check_c_dirname(void **state) { char *dname; (void) state; /* unused */ dname = c_dirname("/usr/lib"); assert_string_equal(dname, "/usr"); free(dname); dname = c_dirname("/usr//"); assert_string_equal(dname, "/"); free(dname); dname = c_dirname("usr"); assert_string_equal(dname, "."); free(dname); dname = c_dirname("/"); assert_string_equal(dname, "/"); free(dname); dname = c_dirname("///"); assert_string_equal(dname, "/"); free(dname); dname = c_dirname("."); assert_string_equal(dname, "."); free(dname); dname = c_dirname(".."); assert_string_equal(dname, "."); free(dname); dname = c_dirname(NULL); assert_string_equal(dname, "."); free(dname); }
static void check_csync_vio_lseek(void **state) { CSYNC *csync = *state; csync_vio_method_handle_t *fh; char test[16] = {0}; int rc; fh = csync_vio_open(csync, CSYNC_TEST_FILE, O_RDONLY, 0644); assert_non_null(fh); rc = csync_vio_lseek(csync, fh, 10, SEEK_SET); assert_int_equal(rc, 10); rc = csync_vio_read(csync, fh, test, 4); assert_int_equal(rc, 4); assert_string_equal(test, "test"); rc = csync_vio_close(csync, fh); assert_int_equal(rc, 0); }
static void test_parse_escaped_string(void) { { const char *data = "\"\\\\\""; const char *original = data; JsonElement *json = NULL; assert_int_equal(JSON_PARSE_OK, JsonParse(&data, &json)); assert_string_equal("\\", JsonPrimitiveGetAsString(json)); char *out = JsonToString(json); assert_string_equal(original, out); free(out); JsonDestroy(json); } { // included by paranoia from Redmine #5773 const char *data = "\"/\\\\//\\\\/\\\\\""; const char *original = data; JsonElement *json = NULL; assert_int_equal(JSON_PARSE_OK, JsonParse(&data, &json)); assert_string_equal("/\\//\\/\\", JsonPrimitiveGetAsString(json)); char *out = JsonToString(json); assert_string_equal(original, out); free(out); JsonDestroy(json); } { const char *data = "\"x\\tx\""; const char *original = data; JsonElement *json = NULL; assert_int_equal(JSON_PARSE_OK, JsonParse(&data, &json)); assert_string_equal("x\tx", JsonPrimitiveGetAsString(json)); char *out = JsonToString(json); assert_string_equal(original, out); free(out); JsonDestroy(json); } }
static void test_unary_extensions(void) { char buf[][20] = { "file.jpg", "program-1.0.zip", "tar.zip", }; assert_string_equal("jpg", cut_extension(buf[0])); assert_string_equal("file", buf[0]); assert_string_equal("zip", cut_extension(buf[1])); assert_string_equal("program-1.0", buf[1]); assert_string_equal("zip", cut_extension(buf[2])); assert_string_equal("tar", buf[2]); }
static void torture_generate_pubkey_from_privkey_ecdsa(void **state) { char pubkey_original[4096] = {0}; char pubkey_generated[4096] = {0}; ssh_key privkey; ssh_key pubkey; int rc; (void) state; /* unused */ rc = torture_read_one_line(LIBSSH_ECDSA_TESTKEY ".pub", pubkey_original, sizeof(pubkey_original)); assert_true(rc == 0); /* remove the public key, generate it from the private key and write it. */ unlink(LIBSSH_ECDSA_TESTKEY ".pub"); rc = ssh_pki_import_privkey_file(LIBSSH_ECDSA_TESTKEY, NULL, NULL, NULL, &privkey); assert_true(rc == 0); rc = ssh_pki_export_privkey_to_pubkey(privkey, &pubkey); assert_true(rc == SSH_OK); rc = ssh_pki_export_pubkey_file(pubkey, LIBSSH_ECDSA_TESTKEY ".pub"); assert_true(rc == 0); rc = torture_read_one_line(LIBSSH_ECDSA_TESTKEY ".pub", pubkey_generated, sizeof(pubkey_generated)); assert_true(rc == 0); assert_string_equal(pubkey_original, pubkey_generated); ssh_key_free(privkey); ssh_key_free(pubkey); }
static void test_content_parse_inline_code(void **state) { char *html = blogc_content_parse_inline("``bola``"); assert_non_null(html); assert_string_equal(html, "<code>bola</code>"); free(html); html = blogc_content_parse_inline("``bola``\n"); assert_non_null(html); assert_string_equal(html, "<code>bola</code>\n"); free(html); html = blogc_content_parse_inline("`bola`"); assert_non_null(html); assert_string_equal(html, "<code>bola</code>"); free(html); html = blogc_content_parse_inline("`bola`\n"); assert_non_null(html); assert_string_equal(html, "<code>bola</code>\n"); free(html); html = blogc_content_parse_inline("``bo*la``\n"); assert_non_null(html); assert_string_equal(html, "<code>bo*la</code>\n"); free(html); // invalid html = blogc_content_parse_inline("``bola\n"); assert_non_null(html); assert_string_equal(html, "<code>bola\n"); free(html); html = blogc_content_parse_inline("`bola\n"); assert_non_null(html); assert_string_equal(html, "<code>bola\n"); free(html); html = blogc_content_parse_inline("``bola`\n"); assert_non_null(html); assert_string_equal(html, "<code>bola<code>\n"); free(html); }
static void check_iconv_ascii(void **state) { #ifdef _WIN32 const mbchar_t *in = L"abc/ABC\\123"; // UTF-8 #else #ifdef __APPLE__ const mbchar_t *in = "abc/ABC\\123"; // UTF-8-MAC #else const mbchar_t *in = "abc/ABC\\123"; // UTF-8 #endif #endif char *out = NULL; const char *exp_out = "abc/ABC\\123"; out = c_utf8_from_locale(in); assert_string_equal(out, exp_out); c_free_locale_string(out); assert_null(out); (void) state; /* unused */ }
static void check_iconv_from_native_normalization(void **state) { char *out = NULL; #ifdef _WIN32 const mbchar_t *in = L"\x48\xc3\xa4"; // UTF-8 #else #ifdef __APPLE__ const mbchar_t *in = "\x48\x61\xcc\x88"; // UTF-8-MAC #else const mbchar_t *in = "\x48\xc3\xa4"; // UTF-8 #endif #endif const char *exp_out = "\x48\xc3\xa4"; // UTF-8 out = c_utf8_from_locale(in); assert_string_equal(out, exp_out); c_free_locale_string(out); assert_null(out); (void) state; /* unused */ }
static void execd_config_empty_cb(const EvalContext *ctx, const Policy *policy) { ExecdConfig *config = ExecdConfigNew(ctx, policy); assert_int_equal(12, StringSetSize(config->schedule)); assert_int_equal(true, StringSetContains(config->schedule, "Min00")); assert_int_equal(true, StringSetContains(config->schedule, "Min05")); assert_int_equal(true, StringSetContains(config->schedule, "Min10")); assert_int_equal(true, StringSetContains(config->schedule, "Min15")); assert_int_equal(true, StringSetContains(config->schedule, "Min20")); assert_int_equal(true, StringSetContains(config->schedule, "Min25")); assert_int_equal(true, StringSetContains(config->schedule, "Min30")); assert_int_equal(true, StringSetContains(config->schedule, "Min35")); assert_int_equal(true, StringSetContains(config->schedule, "Min40")); assert_int_equal(true, StringSetContains(config->schedule, "Min45")); assert_int_equal(true, StringSetContains(config->schedule, "Min50")); assert_int_equal(true, StringSetContains(config->schedule, "Min55")); assert_int_equal(0, config->splay_time); assert_string_equal("LOG_USER", config->log_facility); ExecdConfigDestroy(config); }
void set_value_updates_when_one(void **state) { form_init_module(); DataForm *form = _new_form(); g_hash_table_insert(form->tag_to_var, strdup("tag1"), strdup("var1")); g_hash_table_insert(form->tag_to_var, strdup("tag2"), strdup("var2")); FormField *field1 = _new_field(); field1->var = strdup("var1"); field1->type_t = FIELD_TEXT_SINGLE; form->fields = g_slist_append(form->fields, field1); FormField *field2 = _new_field(); field2->var = strdup("var2"); field2->type_t = FIELD_LIST_SINGLE; field2->values = g_slist_append(field2->values, strdup("value2")); form->fields = g_slist_append(form->fields, field2); form_set_value(form, "tag2", "a new value"); int length = 0; char *value = NULL; GSList *curr_field = form->fields; while (curr_field != NULL) { FormField *field = curr_field->data; if (g_strcmp0(field->var, "var2") == 0) { length = g_slist_length(field->values); value = field->values->data; break; } curr_field = g_slist_next(curr_field); } assert_int_equal(length, 1); assert_string_equal(value, "a new value"); form_destroy(form); }
static void test_lys_print_mem_yin(void **state) { (void) state; /* unused */ const struct lys_module *module; LYS_INFORMAT yang_format = LYS_IN_YIN; char *result = NULL; int rc; module = lys_parse_mem(ctx, lys_module_a, yang_format); if (!module) { fail(); } rc = lys_print_mem(&result, module, LYS_OUT_YIN, NULL, 0, 0); if (rc) { fail(); } assert_string_equal(result_yin, result); free(result); }
static void test_reinsert_of_deleted_lowhest_priority_wildcards_entry_succeeds() { oxm_matches *carol = create_oxm_matches(); set_carol_match_entry( carol ); oxm_matches *carol_wildcards = create_oxm_matches(); set_carol_wildcards_entry( carol_wildcards ); assert_true( insert_match_entry( carol_wildcards, LOW_PRIORITY, xstrdup( CAROL_MATCH_SERVICE_NAME ) ) ); XFREE( delete_match_strict_entry( carol_wildcards, LOW_PRIORITY ) ); void *data = lookup_match_strict_entry( carol, LOW_PRIORITY ); assert_true( data == NULL ); data = lookup_match_entry( carol ); assert_true( data == NULL ); assert_true( insert_match_entry( carol_wildcards, LOW_PRIORITY, xstrdup( CAROL_MATCH_OTHER_SERVICE_NAME ) ) ); data = lookup_match_entry( carol ); assert_true( data != NULL ); assert_string_equal( ( char * ) data, CAROL_MATCH_OTHER_SERVICE_NAME ); XFREE( delete_match_strict_entry( carol_wildcards, LOW_PRIORITY ) ); delete_oxm_matches( carol ); delete_oxm_matches( carol_wildcards ); }
static void test_actions_to_string_with_multiple_actions() { char str[ 128 ]; char expected_str[] = "output: port=1 max_len=65535, set_vlan_vid: vlan_vid=0xbeef"; uint16_t actions_length = sizeof( struct ofp_action_output ) + sizeof( struct ofp_action_vlan_vid ); void *actions = malloc( actions_length ); memset( actions, 0, actions_length ); struct ofp_action_output *output = actions; struct ofp_action_vlan_vid *vlan_vid = ( struct ofp_action_vlan_vid * ) ( ( char * ) actions + sizeof( struct ofp_action_output ) ); output->type = OFPAT_OUTPUT; output->len = sizeof( struct ofp_action_output ); output->port = 1; output->max_len = 65535; vlan_vid->type = OFPAT_SET_VLAN_VID; vlan_vid->len = sizeof( struct ofp_action_vlan_vid ); vlan_vid->vlan_vid = 0xbeef; assert_true( actions_to_string( ( const struct ofp_action_header * ) actions, actions_length, str, sizeof( str ) ) ); assert_string_equal( str, expected_str ); free( actions ); }
void contact_presence_uses_highest_priority(void **state) { PContact contact = p_contact_new("*****@*****.**", "bob", NULL, "both", "is offline", FALSE); Resource *resource10 = resource_new("resource10", RESOURCE_ONLINE, NULL, 10); Resource *resource20 = resource_new("resource20", RESOURCE_CHAT, NULL, 20); Resource *resource30 = resource_new("resource30", RESOURCE_AWAY, NULL, 30); Resource *resource1 = resource_new("resource1", RESOURCE_XA, NULL, 1); Resource *resource2 = resource_new("resource2", RESOURCE_DND, NULL, 2); p_contact_set_presence(contact, resource10); p_contact_set_presence(contact, resource20); p_contact_set_presence(contact, resource30); p_contact_set_presence(contact, resource1); p_contact_set_presence(contact, resource2); const char *presence = p_contact_presence(contact); assert_string_equal("away", presence); p_contact_free(contact); }