Ejemplo n.º 1
0
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!");
}
Ejemplo n.º 2
0
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));
}
Ejemplo n.º 3
0
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);
}
Ejemplo n.º 4
0
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;
}
Ejemplo n.º 5
0
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);
}
Ejemplo n.º 6
0
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);
}
Ejemplo n.º 7
0
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>");
}
Ejemplo n.º 8
0
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);
}
Ejemplo n.º 9
0
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);
}
Ejemplo n.º 10
0
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);
}
Ejemplo n.º 11
0
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();
}
Ejemplo n.º 12
0
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);
}
Ejemplo n.º 13
0
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);
}
Ejemplo n.º 14
0
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);
}
Ejemplo n.º 15
0
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"));
}
Ejemplo n.º 16
0
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);
}
Ejemplo n.º 17
0
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);
}
Ejemplo n.º 18
0
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);
}
Ejemplo n.º 19
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);
    }
}
Ejemplo n.º 20
0
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]);
}
Ejemplo n.º 21
0
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);
}
Ejemplo n.º 22
0
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);
}
Ejemplo n.º 23
0
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 */
}
Ejemplo n.º 24
0
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 */
}
Ejemplo n.º 25
0
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);
}
Ejemplo n.º 26
0
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);
}
Ejemplo n.º 27
0
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);
}
Ejemplo n.º 28
0
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 );
}
Ejemplo n.º 29
0
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 );
}
Ejemplo n.º 30
0
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);
}