예제 #1
0
파일: TestCoreRts.c 프로젝트: 4hosi/FreeRDP
void test_rpc_in_write(void **state)
{
	int status;
	status = rpc_in_write(NULL, NULL, 64);
	assert_int_equal(status, 64);
}
예제 #2
0
/*
 * Test the case of a SRV record query where the
 * fake hosts file entry is minimal in the sense
 * that it omits the priority and weight entries.
 * The server then fills in some default values.
 */
static void test_res_fake_srv_query_minimal(void **state)
{
    int rv;
    struct __res_state dnsstate;
    unsigned char answer[ANSIZE];
    ns_msg handle;
    ns_rr rr;   /* expanded resource record */
    const uint8_t *rrdata;
    int prio;
    int weight;
    int port;
    char hostname[MAXDNAME];
    char addr[INET_ADDRSTRLEN];

    (void) state; /* unused */

    memset(&dnsstate, 0, sizeof(struct __res_state));
    rv = res_ninit(&dnsstate);
    assert_int_equal(rv, 0);

    rv = res_nquery(&dnsstate, "_krb5._tcp.cwrap.org", ns_c_in, ns_t_srv,
                    answer, sizeof(answer));
    assert_in_range(rv, 1, 256);

    ns_initparse(answer, sizeof(answer), &handle);

    /*
     * The query must finish w/o an error, have one answer and the answer
     * must be a parseable RR of type SRV and have the priority, weight,
     * port and hostname as in the fake hosts file
     */
    assert_int_equal(ns_msg_getflag(handle, ns_f_rcode), ns_r_noerror);
    assert_int_equal(ns_msg_count(handle, ns_s_an), 1);
    assert_int_equal(ns_parserr(&handle, ns_s_an, 0, &rr), 0);
    assert_int_equal(ns_rr_type(rr), ns_t_srv);

    rrdata = ns_rr_rdata(rr);
    NS_GET16(prio, rrdata);
    NS_GET16(weight, rrdata);
    NS_GET16(port, rrdata);

    rv = ns_name_uncompress(ns_msg_base(handle),
                            ns_msg_end(handle),
                            rrdata,
                            hostname, MAXDNAME);
    assert_int_not_equal(rv, -1);

    assert_int_equal(prio, 1);
    assert_int_equal(weight, 100);
    assert_int_equal(port, 88);
    assert_string_equal(hostname, "krb5.cwrap.org");

    /* The additional section contains the A record of krb5.cwrap.org */
    assert_int_equal(ns_msg_count(handle, ns_s_ar), 1);
    assert_int_equal(ns_parserr(&handle, ns_s_ar, 0, &rr), 0);
    assert_int_equal(ns_rr_type(rr), ns_t_a);
    assert_string_equal(ns_rr_name(rr), "krb5.cwrap.org");
    assert_non_null(inet_ntop(AF_INET, ns_rr_rdata(rr),
                              addr, sizeof(addr)));
    assert_string_equal(addr, "127.0.0.23");
}
예제 #3
0
static void test_res_fake_cname_query(void **state)
{
    int rv;
    struct __res_state dnsstate;
    unsigned char answer[ANSIZE];
    ns_msg handle;
    ns_rr rr;   /* expanded resource record */
    const uint8_t *rrdata;
    char cname[MAXDNAME];
    char addr[INET_ADDRSTRLEN];

    (void) state; /* unused */

    memset(&dnsstate, 0, sizeof(struct __res_state));
    rv = res_ninit(&dnsstate);
    assert_int_equal(rv, 0);

    rv = res_nquery(&dnsstate, "rwrap.org", ns_c_in, ns_t_cname,
                    answer, sizeof(answer));
    assert_in_range(rv, 1, 256);

    ns_initparse(answer, 256, &handle);
    ns_initparse(answer, sizeof(answer), &handle);

    /*
     * The query must finish w/o an error, have one answer and the answer
     * must be a parseable RR of type CNAME and have the cname as in the
     * fake hosts file
     */
    assert_int_equal(ns_msg_getflag(handle, ns_f_rcode), ns_r_noerror);
    assert_int_equal(ns_msg_count(handle, ns_s_an), 1);
    assert_int_equal(ns_parserr(&handle, ns_s_an, 0, &rr), 0);
    assert_int_equal(ns_rr_type(rr), ns_t_cname);

    rrdata = ns_rr_rdata(rr);

    rv = ns_name_uncompress(ns_msg_base(handle),
                            ns_msg_end(handle),
                            rrdata,
                            cname, MAXDNAME);
    assert_int_not_equal(rv, -1);

    assert_string_equal(cname, "web.cwrap.org");

    /* The CNAME points to an A record that's present in the additional
     * section
     */
    assert_int_equal(ns_msg_count(handle, ns_s_ar), 2);

    assert_int_equal(ns_parserr(&handle, ns_s_ar, 0, &rr), 0);
    assert_int_equal(ns_rr_type(rr), ns_t_cname);
    assert_string_equal(ns_rr_name(rr), "web.cwrap.org");
    rrdata = ns_rr_rdata(rr);

    rv = ns_name_uncompress(ns_msg_base(handle),
                            ns_msg_end(handle),
                            rrdata,
                            cname, MAXDNAME);
    assert_int_not_equal(rv, -1);

    assert_string_equal(cname, "www.cwrap.org");

    assert_int_equal(ns_parserr(&handle, ns_s_ar, 1, &rr), 0);
    assert_int_equal(ns_rr_type(rr), ns_t_a);
    assert_string_equal(ns_rr_name(rr), "www.cwrap.org");
    assert_non_null(inet_ntop(AF_INET, ns_rr_rdata(rr),
                              addr, sizeof(addr)));
    assert_string_equal(addr, "127.0.0.22");
}
예제 #4
0
static void curl_perform(mangusta_ctx_t * ctx, const char *url, long ver, const char *method) {
    CURL *curl;
    CURLcode res;

    curl = curl_easy_init();
    if (curl != NULL) {
        struct curl_slist *chunk = NULL;
        struct curl_httppost *formpost = NULL;
        struct curl_httppost *lastptr = NULL;

        curl_easy_setopt(curl, CURLOPT_USERAGENT, "Test suite");
        /*curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_NONE); */
        curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, ver);
        curl_easy_setopt(curl, CURLOPT_VERBOSE, 0L);
        curl_easy_setopt(curl, CURLOPT_URL, url);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, &curl_dummy_write);

        if (!strcmp(method, "GET")) {
            /* Nothing to do */
        } else if (!strcmp(method, "POST")) {
            curl_easy_setopt(curl, CURLOPT_POST, 1L);
            curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, "sendfile", CURLFORM_FILE, __FILE__, CURLFORM_END);
            curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, "filename", CURLFORM_COPYCONTENTS, __FILE__, CURLFORM_END);
            curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, "submit", CURLFORM_COPYCONTENTS, "send", CURLFORM_END);
            curl_easy_setopt(curl, CURLOPT_HTTPPOST, formpost);
        } else if (!strcmp(method, "PUT")) {
            curl_easy_setopt(curl, CURLOPT_PUT, 1L);
            curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
            curl_easy_setopt(curl, CURLOPT_READFUNCTION, curl_dummy_read);
        } else if (!strcmp(method, "DELETE")) {
            curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, method);
            curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
            curl_easy_setopt(curl, CURLOPT_READFUNCTION, curl_dummy_read);
        } else {
            assert_non_null(1);
        }

        if (strstr(url, "test2") != NULL) {
            chunk = curl_slist_append(chunk, "Transfer-Encoding: chunked");
        }

        res = curl_easy_setopt(curl, CURLOPT_HTTPHEADER, chunk);
        res = curl_easy_perform(curl);

        if (CURLE_OK == res) {
            char *ct;
            long rc;

            res = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &rc);
            res = curl_easy_getinfo(curl, CURLINFO_CONTENT_TYPE, &ct);

            printf("CLIENT STATUS: %ld\n", rc);
            assert_int_equal(rc, 200);

        } else {
            assert_int_equal(res, CURLE_OK);
        }

        if (must_shutdown) {
            mangusta_context_stop(ctx);
        }

	curl_formfree(formpost);
        curl_slist_free_all(chunk);

        /* always cleanup */
        curl_easy_cleanup(curl);
    }

    return;
}
예제 #5
0
static void test_rehash(void ** UNUSED(state))
{
    void *hash_table = RESTc_new(RESTc_HashTable, 2);
    assert_non_null(hash_table);
    struct test_value_object *elementf = (struct test_value_object *) RESTc_new(_test_value_object, 7, 7);
    struct test_value_object *elementa = (struct test_value_object *) RESTc_new(_test_value_object, 2, 2);
    struct test_value_object *elementb = (struct test_value_object *) RESTc_new(_test_value_object, 4, 4);
    struct test_value_object *elementc = (struct test_value_object *) RESTc_new(_test_value_object, 8, 8);
    struct test_value_object *elementd = (struct test_value_object *) RESTc_new(_test_value_object, 16, 16);
    struct test_value_object *elemente = (struct test_value_object *) RESTc_new(_test_value_object, 1, 1);
    assert_non_null(elementa);
    assert_non_null(elementb);
    assert_non_null(elementc);
    assert_non_null(elementd);
    assert_non_null(elemente);
    assert_non_null(elementf);
    assert_int_equal(RESTc_HashTable.insert(hash_table, elementa), true);
    assert_int_equal(RESTc_HashTable.insert(hash_table, elementb), true);
    assert_int_equal(RESTc_HashTable.insert(hash_table, elementc), true);
    assert_int_equal(RESTc_HashTable.insert(hash_table, elementd), true);
    assert_int_equal(RESTc_HashTable.insert(hash_table, elemente), true);
    assert_int_equal(RESTc_HashTable.insert(hash_table, elementf), true);
    struct test_value_object const* helementa = (struct test_value_object const*) RESTc_HashTable.find(hash_table, elementa);
    struct test_value_object const* helementb = (struct test_value_object const*) RESTc_HashTable.find(hash_table, elementb);
    struct test_value_object const* helementc = (struct test_value_object const*) RESTc_HashTable.find(hash_table, elementc);
    struct test_value_object const* helementd = (struct test_value_object const*) RESTc_HashTable.find(hash_table, elementd);
    struct test_value_object const* helemente = (struct test_value_object const*) RESTc_HashTable.find(hash_table, elemente);
    struct test_value_object const* helementf = (struct test_value_object const*) RESTc_HashTable.find(hash_table, elementf);
    assert_non_null(helementa);
    assert_non_null(helementb);
    assert_non_null(helementc);
    assert_non_null(helementd);
    assert_non_null(helemente);
    assert_non_null(helementf);
    assert_true(elementa != helementa);
    assert_true(elementb != helementb);
    assert_true(elementc != helementc);
    assert_true(elementd != helementd);
    assert_true(elemente != helemente);
    assert_true(elementf != helementf);
    assert_int_equal(elementa->value, helementa->value);
    assert_int_equal(elementb->value, helementb->value);
    assert_int_equal(elementc->value, helementc->value);
    assert_int_equal(elementd->value, helementd->value);
    assert_int_equal(elemente->value, helemente->value);
    assert_int_equal(elementf->value, helementf->value);
    RESTc_delete(elementa);
    RESTc_delete(elementb);
    RESTc_delete(elementc);
    RESTc_delete(elementd);
    RESTc_delete(elemente);
    RESTc_delete(elementf);
    RESTc_delete(hash_table);
}
예제 #6
0
/* This test will fail since the mock connect_to_database() will attempt to
 * retrieve a value for the parameter port which isn't specified by this
 * test function. */
static void test_connect_to_product_database_missing_parameter(void **state) {
    expect_string(connect_to_database, url, "products.abcd.org");
    will_return(connect_to_database, 0xDA7ABA53);
    assert_int_equal((uintptr_t)connect_to_product_database(), 0xDA7ABA53);
}
예제 #7
0
static void test_parse_good_numbers(void **state)
{
    {
        const char *data = "[0.1]";
        JsonElement *json = NULL;
        assert_int_equal(JSON_PARSE_OK, JsonParse(&data, &json));
        assert_true(json);
        JsonElementDestroy(json);
    }

    {
        const char *data = "[0.1234567890123456789]";
        JsonElement *json = NULL;
        assert_int_equal(JSON_PARSE_OK, JsonParse(&data, &json));
        assert_true(json);
        JsonElementDestroy(json);
    }

    {
        const char *data = "[0.1234e10]";
        JsonElement *json = NULL;
        assert_int_equal(JSON_PARSE_OK, JsonParse(&data, &json));
        assert_true(json);
        JsonElementDestroy(json);
    }

    {
        const char *data = "[0.1234e+10]";
        JsonElement *json = NULL;
        assert_int_equal(JSON_PARSE_OK, JsonParse(&data, &json));
        assert_true(json);
        JsonElementDestroy(json);
    }

    {
        const char *data = "[0.1234e-10]";
        JsonElement *json = NULL;
        assert_int_equal(JSON_PARSE_OK, JsonParse(&data, &json));
        assert_true(json);
        JsonElementDestroy(json);
    }

    {
        const char *data = "[1203e10]";
        JsonElement *json = NULL;
        assert_int_equal(JSON_PARSE_OK, JsonParse(&data, &json));
        assert_true(json);
        JsonElementDestroy(json);
    }

    {
        const char *data = "[1203e+10]";
        JsonElement *json = NULL;
        assert_int_equal(JSON_PARSE_OK, JsonParse(&data, &json));
        assert_true(json);
        JsonElementDestroy(json);
    }

    {
        const char *data = "[123e-10]";
        JsonElement *json = NULL;
        assert_int_equal(JSON_PARSE_OK, JsonParse(&data, &json));
        assert_true(json);
        JsonElementDestroy(json);
    }

    {
        const char *data = "[0e-10]";
        JsonElement *json = NULL;
        assert_int_equal(JSON_PARSE_OK, JsonParse(&data, &json));
        assert_true(json);
        JsonElementDestroy(json);
    }

    {
        const char *data = "[0.0e-10]";
        JsonElement *json = NULL;
        assert_int_equal(JSON_PARSE_OK, JsonParse(&data, &json));
        assert_true(json);
        JsonElementDestroy(json);
    }

    {
        const char *data = "[-0.0e-10]";
        JsonElement *json = NULL;
        assert_int_equal(JSON_PARSE_OK, JsonParse(&data, &json));
        assert_true(json);
        JsonElementDestroy(json);
    }
}
예제 #8
0
파일: main.c 프로젝트: Diamorph/CoursesRepo
static void Create__new__queue(void **queue){
    queue_t * q = queue_new();
    assert_int_equal(queue_size(q),0);
    queue_remove(&q);
}
예제 #9
0
파일: _string.c 프로젝트: JunhanPark/rtos
static void strtoll_func() {
	/* Without integner prefix(e.g. 0x, 0b...) */
	char text[1024] = "12345670qwert\0";
	char* non_intger;
	long long int rtn = 0;
	int base = 0;

		/* base 0 */
	rtn = __strtoll(text, &non_intger, base);
	assert_int_equal(rtn, 12345670);
	assert_memory_equal(non_intger, text + 8, strlen(text + 8));

		/* base 8 */
	base = 8;
	rtn = __strtoll(text, &non_intger, base);
	assert_int_equal(rtn, 012345670);
	assert_memory_equal(non_intger, text + 8, strlen(text + 8));

		/* base 10 */
	base = 10;
	rtn = __strtoll(text, &non_intger, base);
	assert_int_equal(rtn, 12345670);
	assert_memory_equal(non_intger, text + 8, strlen(text + 8));

		/* base 16 */
	base = 16;
	rtn = __strtoll(text, &non_intger, base);
	assert_int_equal(rtn, 0x12345670);
	assert_memory_equal(non_intger, text + 8, strlen(text + 8));



	/* With prefix 0(octet)*/
	memset(text, 0, 1024);
	strncpy(text, "012345670qwert", strlen("012345670qwert"));

		/* base 0 */
	base = 0;
	rtn = __strtoll(text, &non_intger, base);
	assert_int_equal(rtn, 012345670);
	assert_memory_equal(non_intger, text + 9, strlen(text + 9));

		/* base 8 */
	base = 8;
	rtn = __strtoll(text, &non_intger, base);
	assert_int_equal(rtn, 012345670);
	assert_memory_equal(non_intger, text + 9, strlen(text + 9));

		/* base 10 */
	base = 10;
	rtn = __strtoll(text, &non_intger, base);
	assert_int_equal(rtn, 12345670);
	assert_memory_equal(non_intger, text + 9, strlen(text + 9));

		/* base 16 */
	base = 16;
	rtn = __strtoll(text, &non_intger, base);
	assert_int_equal(rtn, 0x12345670);
	assert_memory_equal(non_intger, text + 9, strlen(text + 9));


	/* With prefix 0x(hex)*/
	memset(text, 0, 1024);
	strncpy(text, "0x12345670qwert", strlen("0x12345670qwert"));

		/* base 0 */
	base = 0;
	rtn = __strtoll(text, &non_intger, base);
	assert_int_equal(rtn, 0x12345670);
	assert_memory_equal(non_intger, text + 10, strlen(text + 10));

		/* base 8 */
	base = 8;
	rtn = __strtoll(text, &non_intger, base);
	assert_int_equal(rtn, 0);
	assert_memory_equal(non_intger, text + 1, strlen(text + 1));

		/* base 10 */
	base = 10;
	rtn = __strtoll(text, &non_intger, base);
	assert_int_equal(rtn, 0);
	assert_memory_equal(non_intger, text + 1, strlen(text + 1));

		/* base 16 */
	base = 16;
	rtn = __strtoll(text, &non_intger, base);
	assert_int_equal(rtn, 0x12345670);
	assert_memory_equal(non_intger, text + 10, strlen(text + 10));
}
예제 #10
0
static void check_csync_pathes(void **state)
{
    CSYNC *csync = *state;
    int rc;

    _csync_exclude_add( &(csync->excludes), "/exclude" );

    /* Check toplevel dir, the pattern only works for toplevel dir. */
    rc = csync_excluded(csync, "/exclude", CSYNC_FTW_TYPE_DIR);
    assert_int_equal(rc, CSYNC_FILE_EXCLUDE_LIST);

    rc = csync_excluded(csync, "/foo/exclude", CSYNC_FTW_TYPE_DIR);
    assert_int_equal(rc, CSYNC_NOT_EXCLUDED);

    /* check for a file called exclude. Must still work */
    rc = csync_excluded(csync, "/exclude", CSYNC_FTW_TYPE_FILE);
    assert_int_equal(rc, CSYNC_FILE_EXCLUDE_LIST);

    rc = csync_excluded(csync, "/foo/exclude", CSYNC_FTW_TYPE_FILE);
    assert_int_equal(rc, CSYNC_NOT_EXCLUDED);

    /* Add an exclude for directories only: excl/ */
    _csync_exclude_add( &(csync->excludes), "excl/" );
    rc = csync_excluded(csync, "/excl", CSYNC_FTW_TYPE_DIR);
    assert_int_equal(rc, CSYNC_FILE_EXCLUDE_LIST);

    rc = csync_excluded(csync, "meep/excl", CSYNC_FTW_TYPE_DIR);
    assert_int_equal(rc, CSYNC_FILE_EXCLUDE_LIST);

    rc = csync_excluded(csync, "meep/excl/file", CSYNC_FTW_TYPE_FILE);
    assert_int_equal(rc, CSYNC_FILE_EXCLUDE_LIST);

    rc = csync_excluded(csync, "/excl", CSYNC_FTW_TYPE_FILE);
    assert_int_equal(rc, CSYNC_NOT_EXCLUDED);

    _csync_exclude_add(&csync->excludes, "/excludepath/withsubdir");

    rc = csync_excluded(csync, "/excludepath/withsubdir", CSYNC_FTW_TYPE_DIR);
    assert_int_equal(rc, CSYNC_FILE_EXCLUDE_LIST);

    rc = csync_excluded(csync, "/excludepath/withsubdir", CSYNC_FTW_TYPE_FILE);
    assert_int_equal(rc, CSYNC_FILE_EXCLUDE_LIST);

    rc = csync_excluded(csync, "/excludepath/withsubdir2", CSYNC_FTW_TYPE_DIR);
    assert_int_equal(rc, CSYNC_NOT_EXCLUDED);

    rc = csync_excluded(csync, "/excludepath/withsubdir/foo", CSYNC_FTW_TYPE_DIR);
    assert_int_equal(rc, CSYNC_FILE_EXCLUDE_LIST);
}
예제 #11
0
static void check_csync_excluded(void **state)
{
    CSYNC *csync = *state;
    int rc;

    rc = csync_excluded(csync, "", CSYNC_FTW_TYPE_FILE);
    assert_int_equal(rc, CSYNC_NOT_EXCLUDED);
    rc = csync_excluded(csync, "/", CSYNC_FTW_TYPE_FILE);
    assert_int_equal(rc, CSYNC_NOT_EXCLUDED);

    rc = csync_excluded(csync, "krawel_krawel", CSYNC_FTW_TYPE_FILE);
    assert_int_equal(rc, CSYNC_NOT_EXCLUDED);
    rc = csync_excluded(csync, ".kde/share/config/kwin.eventsrc", CSYNC_FTW_TYPE_FILE);
    assert_int_equal(rc, CSYNC_NOT_EXCLUDED);
    rc = csync_excluded(csync, ".htaccess/cache-maximegalon/cache1.txt", CSYNC_FTW_TYPE_FILE);
    assert_int_equal(rc, CSYNC_FILE_EXCLUDE_LIST);
    rc = csync_excluded(csync, "mozilla/.htaccess", CSYNC_FTW_TYPE_DIR);
    assert_int_equal(rc, CSYNC_FILE_EXCLUDE_LIST);

    /*
     * Test for patterns in subdirs. '.beagle' is defined as a pattern and has
     * to be found in top dir as well as in directories underneath.
     */
    rc = csync_excluded(csync, ".apdisk", CSYNC_FTW_TYPE_DIR);
    assert_int_equal(rc, CSYNC_FILE_EXCLUDE_LIST);
    rc = csync_excluded(csync, "foo/.apdisk", CSYNC_FTW_TYPE_DIR);
    assert_int_equal(rc, CSYNC_FILE_EXCLUDE_LIST);
    rc = csync_excluded(csync, "foo/bar/.apdisk", CSYNC_FTW_TYPE_DIR);
    assert_int_equal(rc, CSYNC_FILE_EXCLUDE_LIST);

    rc = csync_excluded(csync, ".java", CSYNC_FTW_TYPE_FILE);
    assert_int_equal(rc, CSYNC_NOT_EXCLUDED);

    /* Files in the ignored dir .java will also be ignored. */
    rc = csync_excluded(csync, ".apdisk/totally_amazing.jar", CSYNC_FTW_TYPE_FILE);
    assert_int_equal(rc, CSYNC_FILE_EXCLUDE_LIST);

    /* and also in subdirs */
    rc = csync_excluded(csync, "projects/.apdisk/totally_amazing.jar", CSYNC_FTW_TYPE_FILE);
    assert_int_equal(rc, CSYNC_FILE_EXCLUDE_LIST);

    /* csync-journal is ignored in general silently. */
    rc = csync_excluded(csync, ".csync_journal.db", CSYNC_FTW_TYPE_FILE);
    assert_int_equal(rc, CSYNC_FILE_SILENTLY_EXCLUDED);
    rc = csync_excluded(csync, ".csync_journal.db.ctmp", CSYNC_FTW_TYPE_FILE);
    assert_int_equal(rc, CSYNC_FILE_SILENTLY_EXCLUDED);
    rc = csync_excluded(csync, "subdir/.csync_journal.db", CSYNC_FTW_TYPE_FILE);
    assert_int_equal(rc, CSYNC_FILE_SILENTLY_EXCLUDED);

    /* pattern ]*.directory - ignore and remove */
    rc = csync_excluded(csync, "my.~directory", CSYNC_FTW_TYPE_FILE);
    assert_int_equal(rc, CSYNC_FILE_EXCLUDE_AND_REMOVE);

    rc = csync_excluded(csync, "/a_folder/my.~directory", CSYNC_FTW_TYPE_FILE);
    assert_int_equal(rc, CSYNC_FILE_EXCLUDE_AND_REMOVE);

    /* Not excluded because the pattern .netscape/cache requires directory. */
    rc = csync_excluded(csync, ".netscape/cache", CSYNC_FTW_TYPE_FILE);
    assert_int_equal(rc, CSYNC_NOT_EXCLUDED);

    /* Not excluded  */
    rc = csync_excluded(csync, "unicode/中文.hé", CSYNC_FTW_TYPE_FILE);
    assert_int_equal(rc, CSYNC_NOT_EXCLUDED);
    /* excluded  */
    rc = csync_excluded(csync, "unicode/пятницы.txt", CSYNC_FTW_TYPE_FILE);
    assert_int_equal(rc, CSYNC_FILE_EXCLUDE_LIST);
    rc = csync_excluded(csync, "unicode/中文.💩", CSYNC_FTW_TYPE_FILE);
    assert_int_equal(rc, CSYNC_FILE_EXCLUDE_LIST);

    /* path wildcards */
    rc = csync_excluded(csync, "foobar/my_manuscript.out", CSYNC_FTW_TYPE_FILE);
    assert_int_equal(rc, CSYNC_FILE_EXCLUDE_LIST);

    rc = csync_excluded(csync, "latex_tmp/my_manuscript.run.xml", CSYNC_FTW_TYPE_FILE);
    assert_int_equal(rc, CSYNC_FILE_EXCLUDE_LIST);

    rc = csync_excluded(csync, "word_tmp/my_manuscript.run.xml", CSYNC_FTW_TYPE_FILE);
    assert_int_equal(rc, CSYNC_NOT_EXCLUDED);

    rc = csync_excluded(csync, "latex/my_manuscript.tex.tmp", CSYNC_FTW_TYPE_FILE);
    assert_int_equal(rc, CSYNC_NOT_EXCLUDED);

    rc = csync_excluded(csync, "latex/songbook/my_manuscript.tex.tmp", CSYNC_FTW_TYPE_FILE);
    assert_int_equal(rc, CSYNC_FILE_EXCLUDE_LIST);
}
예제 #12
0
파일: str_test.c 프로젝트: pombredanne/core
static void test_string_to_long(void **state)
{
    assert_int_equal(1234567, StringToLong("1234567"));
}
예제 #13
0
파일: str_test.c 프로젝트: pombredanne/core
static void test_substring_evil(void **state)
{
    char *new_string = StringSubstring("abcdef", 6, 4, -4);

    assert_int_equal(new_string, NULL);
}
예제 #14
0
static void test_embedded_tag(void **state)
{
    assert_int_equal(1, cbor_encode_tag(1, buffer, 512));
    assert_memory_equal(buffer, ((unsigned char[]) {
        0xC1
    }), 1);
예제 #15
0
static void check_c_compare_file(void **state)
{
    int rc;
    (void) state;

    rc = c_copy(check_src_file, check_dst_file, 0644);
    assert_int_equal(rc, 0);

    rc = c_compare_file( check_src_file, check_dst_file );
    assert_int_equal(rc, 1);

    /* Check error conditions */
    rc = c_compare_file( NULL, check_dst_file );
    assert_int_equal(rc, -1);
    rc = c_compare_file( check_dst_file, NULL );
    assert_int_equal(rc, -1);
    rc = c_compare_file( NULL, NULL );
    assert_int_equal(rc, -1);

    rc = c_compare_file( check_src_file, "/I_do_not_exist_in_the_filesystem.dummy");
    assert_int_equal(rc, -1);
    rc = c_compare_file( "/I_do_not_exist_in_the_filesystem.dummy", check_dst_file);
    assert_int_equal(rc, -1);

    rc = system("echo \"hallo42\" > /tmp/check/foo.txt");
    assert_int_equal(rc, 0);
    rc = system("echo \"hallo52\" > /tmp/check/bar.txt");
    assert_int_equal(rc, 0);
    rc = c_compare_file( check_src_file, check_dst_file );
    assert_int_equal(rc, 0);

    /* Create two 1MB random files */
    rc = system("dd if=/dev/urandom of=/tmp/check/foo.txt bs=1024 count=1024");
    assert_int_equal(rc, 0);
    rc = system("dd if=/dev/urandom of=/tmp/check/bar.txt bs=1024 count=1024");
    assert_int_equal(rc, 0);
    rc = c_compare_file( check_src_file, check_dst_file );
    assert_int_equal(rc, 0);

    /* Create two 1MB random files with different size */
    rc = system("dd if=/dev/urandom of=/tmp/check/foo.txt bs=1024 count=1024");
    assert_int_equal(rc, 0);
    rc = system("dd if=/dev/urandom of=/tmp/check/bar.txt bs=1024 count=1020");
    assert_int_equal(rc, 0);
    rc = c_compare_file( check_src_file, check_dst_file );
    assert_int_equal(rc, 0);

    /* compare two big files which are equal */
    rc = c_copy(check_src_file, check_dst_file, 0644);
    assert_int_equal(rc, 0);

    rc = c_compare_file( check_src_file, check_dst_file );
    assert_int_equal(rc, 1);
}
void test_connect_to_customer_database(void **state) {
    will_return(connect_to_database, 0x0DA7ABA53);
    assert_int_equal((int)connect_to_customer_database(), 0x0DA7ABA53);
}
예제 #17
0
/* This test will fail since the expected URL is different to the URL that is
 * passed to connect_to_database() by connect_to_product_database(). */
static void test_connect_to_product_database_bad_url(void **state) {
    expect_string(connect_to_database, url, "products.abcd.com");
    expect_value(connect_to_database, port, 322);
    will_return(connect_to_database, 0xDA7ABA53);
    assert_int_equal((uintptr_t)connect_to_product_database(), 0xDA7ABA53);
}
예제 #18
0
static void test_ipv6(void)
{
    /*
     * This test will check the ipv6 parser. We will directly call to it, we will not check
     * the generic frontend.
     * Cases to test:
     * 0000:0000:0000:0000:0000:0000:0000:0000 Ok
     * 0:0:0:0:0:0:0:0 Ok
     * a:b:c:d::1 Ok
     * a:b:c:d:0:1:2:3 Ok
     * [a::b] Ok
     * [a:b:c:d:e:f:0:1]:8080 Ok
     * 0:1:2::4 Ok
     * 0::2:3:4 Ok
     * ::3:4 Ok
     * ::::::: Fail
     * A:B:C:D:E:F:0:1 Fail
     */
    struct IPV6Address ipv6;
    memset(&ipv6, 0, sizeof(struct IPV6Address));
    assert_int_equal(0, IPV6_parser("0000:0000:0000:0000:0000:0000:0000:0000", &ipv6));
    assert_int_equal(ipv6.sixteen[0], 0);
    assert_int_equal(ipv6.sixteen[1], 0);
    assert_int_equal(ipv6.sixteen[2], 0);
    assert_int_equal(ipv6.sixteen[3], 0);
    assert_int_equal(ipv6.sixteen[4], 0);
    assert_int_equal(ipv6.sixteen[5], 0);
    assert_int_equal(ipv6.sixteen[6], 0);
    assert_int_equal(ipv6.sixteen[7], 0);
    assert_int_equal(ipv6.port, 0);
    memset(&ipv6, 0, sizeof(struct IPV6Address));
    assert_int_equal(0, IPV6_parser("0:0:0:0:0:0:0:0", &ipv6));
    assert_int_equal(ipv6.sixteen[0], 0);
    assert_int_equal(ipv6.sixteen[1], 0);
    assert_int_equal(ipv6.sixteen[2], 0);
    assert_int_equal(ipv6.sixteen[3], 0);
    assert_int_equal(ipv6.sixteen[4], 0);
    assert_int_equal(ipv6.sixteen[5], 0);
    assert_int_equal(ipv6.sixteen[6], 0);
    assert_int_equal(ipv6.sixteen[7], 0);
    assert_int_equal(ipv6.port, 0);
    memset(&ipv6, 0, sizeof(struct IPV6Address));
    assert_int_equal(0, IPV6_parser("a:b:c:d::1", &ipv6));
    assert_int_equal(ipv6.sixteen[0], 0x0a);
    assert_int_equal(ipv6.sixteen[1], 0x0b);
    assert_int_equal(ipv6.sixteen[2], 0x0c);
    assert_int_equal(ipv6.sixteen[3], 0x0d);
    assert_int_equal(ipv6.sixteen[4], 0);
    assert_int_equal(ipv6.sixteen[5], 0);
    assert_int_equal(ipv6.sixteen[6], 0);
    assert_int_equal(ipv6.sixteen[7], 1);
    assert_int_equal(ipv6.port, 0);
    memset(&ipv6, 0, sizeof(struct IPV6Address));
    assert_int_equal(0, IPV6_parser("a:b:c:d:0:1:2:3", &ipv6));
    assert_int_equal(ipv6.sixteen[0], 0x0a);
    assert_int_equal(ipv6.sixteen[1], 0x0b);
    assert_int_equal(ipv6.sixteen[2], 0x0c);
    assert_int_equal(ipv6.sixteen[3], 0x0d);
    assert_int_equal(ipv6.sixteen[4], 0);
    assert_int_equal(ipv6.sixteen[5], 1);
    assert_int_equal(ipv6.sixteen[6], 2);
    assert_int_equal(ipv6.sixteen[7], 3);
    assert_int_equal(ipv6.port, 0);
    memset(&ipv6, 0, sizeof(struct IPV6Address));
    assert_int_equal(0, IPV6_parser("[a::b]", &ipv6));
    assert_int_equal(ipv6.sixteen[0], 0x0a);
    assert_int_equal(ipv6.sixteen[1], 0);
    assert_int_equal(ipv6.sixteen[2], 0);
    assert_int_equal(ipv6.sixteen[3], 0);
    assert_int_equal(ipv6.sixteen[4], 0);
    assert_int_equal(ipv6.sixteen[5], 0);
    assert_int_equal(ipv6.sixteen[6], 0);
    assert_int_equal(ipv6.sixteen[7], 0x0b);
    assert_int_equal(ipv6.port, 0);
    memset(&ipv6, 0, sizeof(struct IPV6Address));
    assert_int_equal(0, IPV6_parser("[a:b:c:d:e:f:0:1]:8080", &ipv6));
    assert_int_equal(ipv6.sixteen[0], 0x0a);
    assert_int_equal(ipv6.sixteen[1], 0x0b);
    assert_int_equal(ipv6.sixteen[2], 0x0c);
    assert_int_equal(ipv6.sixteen[3], 0x0d);
    assert_int_equal(ipv6.sixteen[4], 0x0e);
    assert_int_equal(ipv6.sixteen[5], 0x0f);
    assert_int_equal(ipv6.sixteen[6], 0);
    assert_int_equal(ipv6.sixteen[7], 1);
    assert_int_equal(ipv6.port, 8080);
    memset(&ipv6, 0, sizeof(struct IPV6Address));
    assert_int_equal(0, IPV6_parser("0:1:2::4", &ipv6));
    assert_int_equal(ipv6.sixteen[0], 0);
    assert_int_equal(ipv6.sixteen[1], 1);
    assert_int_equal(ipv6.sixteen[2], 2);
    assert_int_equal(ipv6.sixteen[3], 0);
    assert_int_equal(ipv6.sixteen[4], 0);
    assert_int_equal(ipv6.sixteen[5], 0);
    assert_int_equal(ipv6.sixteen[6], 0);
    assert_int_equal(ipv6.sixteen[7], 4);
    assert_int_equal(ipv6.port, 0);
    memset(&ipv6, 0, sizeof(struct IPV6Address));
    assert_int_equal(0, IPV6_parser("0::2:3:4", &ipv6));
    assert_int_equal(ipv6.sixteen[0], 0);
    assert_int_equal(ipv6.sixteen[1], 0);
    assert_int_equal(ipv6.sixteen[2], 0);
    assert_int_equal(ipv6.sixteen[3], 0);
    assert_int_equal(ipv6.sixteen[4], 0);
    assert_int_equal(ipv6.sixteen[5], 2);
    assert_int_equal(ipv6.sixteen[6], 3);
    assert_int_equal(ipv6.sixteen[7], 4);
    assert_int_equal(ipv6.port, 0);
    memset(&ipv6, 0, sizeof(struct IPV6Address));
    assert_int_equal(0, IPV6_parser("::3:4", &ipv6));
    assert_int_equal(ipv6.sixteen[0], 0);
    assert_int_equal(ipv6.sixteen[1], 0);
    assert_int_equal(ipv6.sixteen[2], 0);
    assert_int_equal(ipv6.sixteen[3], 0);
    assert_int_equal(ipv6.sixteen[4], 0);
    assert_int_equal(ipv6.sixteen[5], 0);
    assert_int_equal(ipv6.sixteen[6], 3);
    assert_int_equal(ipv6.sixteen[7], 4);
    assert_int_equal(ipv6.port, 0);
    memset(&ipv6, 0, sizeof(struct IPV6Address));
    assert_int_equal(-1, IPV6_parser(":::::::", &ipv6));
    memset(&ipv6, 0, sizeof(struct IPV6Address));
    assert_int_equal(-1, IPV6_parser("A:B:C:D:E:F:0:1", &ipv6));
}
예제 #19
0
static void test_basic_blocks(void **state)
{
    uc_engine *uc = *state;
    uc_hook trace1;

#define BASEADDR    0x1000000

    uint64_t address = BASEADDR;
    const uint8_t code[] = {
        0x33, 0xC0,     // xor  eax, eax
        0x90,           // nop
        0x90,           // nop
        0xEB, 0x00,     // jmp  $+2
        0x90,           // nop
        0x90,           // nop
        0x90,           // nop
    };

    static const struct bb blocks[] = {
        {BASEADDR,      6},
        {BASEADDR+ 6,   3},
    };

    struct bbtest bbtest = {
        .blocks = blocks,
        .blocknum = 0,
    };


#undef BASEADDR

    // map 2MB memory for this emulation
    OK(uc_mem_map(uc, address, 2 * 1024 * 1024, UC_PROT_ALL));

    // write machine code to be emulated to memory
    OK(uc_mem_write(uc, address, code, sizeof(code)));

    // trace all basic blocks
    OK(uc_hook_add(uc, &trace1, UC_HOOK_BLOCK, test_basic_blocks_hook, &bbtest, 1, 0));

    OK(uc_emu_start(uc, address, address+sizeof(code), 0, 0));
}

/******************************************************************************/

// callback for tracing basic blocks
static void hook_block(uc_engine *uc, uint64_t address, uint32_t size, void *user_data)
{
    //printf(">>> Tracing basic block at 0x%"PRIx64 ", block size = 0x%x\n", address, size);
}

// callback for tracing instruction
static void hook_code(uc_engine *uc, uint64_t address, uint32_t size, void *user_data)
{
    //int eflags;
    //printf(">>> Tracing instruction at 0x%"PRIx64 ", instruction size = 0x%x\n", address, size);

    //uc_reg_read(uc, UC_X86_REG_EFLAGS, &eflags);
    //printf(">>> --- EFLAGS is 0x%x\n", eflags);

    // Uncomment below code to stop the emulation using uc_emu_stop()
    // if (address == 0x1000009)
    //    uc_emu_stop(uc);
}

static void test_i386(void **state)
{
    uc_engine *uc;
    uc_err err;
    uint32_t tmp;
    uc_hook trace1, trace2;

    const uint8_t code[] = "\x41\x4a"; // INC ecx; DEC edx
    const uint64_t address = 0x1000000;

    int r_ecx = 0x1234;     // ECX register
    int r_edx = 0x7890;     // EDX register

    // Initialize emulator in X86-32bit mode
    err = uc_open(UC_ARCH_X86, UC_MODE_32, &uc);
    uc_assert_success(err);

    // map 2MB memory for this emulation
    err = uc_mem_map(uc, address, 2 * 1024 * 1024, UC_PROT_ALL);
    uc_assert_success(err);

    // write machine code to be emulated to memory
    err = uc_mem_write(uc, address, code, sizeof(code)-1);
    uc_assert_success(err);

    // initialize machine registers
    err = uc_reg_write(uc, UC_X86_REG_ECX, &r_ecx);
    uc_assert_success(err);
    err = uc_reg_write(uc, UC_X86_REG_EDX, &r_edx);
    uc_assert_success(err);

    // tracing all basic blocks with customized callback
    err = uc_hook_add(uc, &trace1, UC_HOOK_BLOCK, hook_block, NULL, 1, 0);
    uc_assert_success(err);

    // tracing all instruction by having @begin > @end
    err = uc_hook_add(uc, &trace2, UC_HOOK_CODE, hook_code, NULL, 1, 0);
    uc_assert_success(err);

    // emulate machine code in infinite time
    err = uc_emu_start(uc, address, address+sizeof(code)-1, 0, 0);
    uc_assert_success(err);

    // now print out some registers
    //printf(">>> Emulation done. Below is the CPU context\n");

    uc_reg_read(uc, UC_X86_REG_ECX, &r_ecx);
    uc_reg_read(uc, UC_X86_REG_EDX, &r_edx);

    assert_int_equal(r_ecx, 0x1235);
    assert_int_equal(r_edx, 0x788F);

    // read from memory
    err = uc_mem_read(uc, address, (uint8_t *)&tmp, 4);
    uc_assert_success(err);
    //printf(">>> Read 4 bytes from [0x%"PRIX64"] = 0x%x\n", address, tmp);

    uc_close(uc);
}
예제 #20
0
static void test_generic_interface(void)
{
    /*
     * This test might seem short, but it is intentional.
     * All the parsing tests should be implemented directly
     * on the corresponding parser test. Keep this test as
     * lean as possible.
     */
    IPAddress *address = NULL;
    Buffer *buffer = NULL;

    buffer = BufferNew();
    assert_true(buffer != NULL);
    BufferSet(buffer, "127.0.0.1", strlen("127.0.0.1"));
    address = IPAddressNew(buffer);
    assert_true(address != NULL);
    assert_int_equal(IP_ADDRESS_TYPE_IPV4, IPAddressType(address));
    assert_string_equal("127.0.0.1", BufferData(IPAddressGetAddress(address)));
    assert_int_equal(0, IPAddressGetPort(address));
    assert_int_equal(0, IPAddressDestroy(&address));

    BufferSet(buffer, "127.0.0.1:8080", strlen("127.0.0.1:8080"));
    address = IPAddressNew(buffer);
    assert_true(address != NULL);
    assert_int_equal(IP_ADDRESS_TYPE_IPV4, IPAddressType(address));
    assert_string_equal("127.0.0.1", BufferData(IPAddressGetAddress(address)));
    assert_int_equal(8080, IPAddressGetPort(address));
    assert_int_equal(0, IPAddressDestroy(&address));

    BufferSet(buffer, "0:1:2:3:4:5:6:7", strlen("0:1:2:3:4:5:6:7"));
    address = IPAddressNew(buffer);
    assert_true(address != NULL);
    assert_int_equal(IP_ADDRESS_TYPE_IPV6, IPAddressType(address));
    assert_string_equal("0:1:2:3:4:5:6:7", BufferData(IPAddressGetAddress(address)));
    assert_int_equal(0, IPAddressGetPort(address));
    assert_int_equal(0, IPAddressDestroy(&address));

    BufferSet(buffer, "[0:1:2:3:4:5:6:7]:9090", strlen("[0:1:2:3:4:5:6:7]:9090"));
    address = IPAddressNew(buffer);
    assert_true(address != NULL);
    assert_int_equal(IP_ADDRESS_TYPE_IPV6, IPAddressType(address));
    assert_string_equal("0:1:2:3:4:5:6:7", BufferData(IPAddressGetAddress(address)));
    assert_int_equal(9090, IPAddressGetPort(address));
    assert_int_equal(0, IPAddressDestroy(&address));

    BufferDestroy(buffer);
}
예제 #21
0
static void test_array_remove_range(void **state)
{
    {
        // remove whole
        JsonElement *arr = JsonArrayCreate(5);

        JsonArrayAppendString(arr, "one");
        JsonArrayAppendString(arr, "two");
        JsonArrayAppendString(arr, "three");
        JsonArrayRemoveRange(arr, 0, 2);

        assert_int_equal(JsonElementLength(arr), 0);

        JsonElementDestroy(arr);
    }

    {
        // remove middle
        JsonElement *arr = JsonArrayCreate(5);

        JsonArrayAppendString(arr, "one");
        JsonArrayAppendString(arr, "two");
        JsonArrayAppendString(arr, "three");
        JsonArrayRemoveRange(arr, 1, 1);

        assert_int_equal(JsonElementLength(arr), 2);
        assert_string_equal(JsonArrayGetAsString(arr, 0), "one");
        assert_string_equal(JsonArrayGetAsString(arr, 1), "three");

        JsonElementDestroy(arr);
    }

    {
        // remove rest
        JsonElement *arr = JsonArrayCreate(5);

        JsonArrayAppendString(arr, "one");
        JsonArrayAppendString(arr, "two");
        JsonArrayAppendString(arr, "three");
        JsonArrayRemoveRange(arr, 1, 2);

        assert_int_equal(JsonElementLength(arr), 1);
        assert_string_equal(JsonArrayGetAsString(arr, 0), "one");

        JsonElementDestroy(arr);
    }

    {
        // remove but last
        JsonElement *arr = JsonArrayCreate(5);

        JsonArrayAppendString(arr, "one");
        JsonArrayAppendString(arr, "two");
        JsonArrayAppendString(arr, "three");
        JsonArrayRemoveRange(arr, 0, 1);

        assert_int_equal(JsonElementLength(arr), 1);
        assert_string_equal(JsonArrayGetAsString(arr, 0), "three");

        JsonElementDestroy(arr);
    }
}
예제 #22
0
static void test_ipv4_address_comparison(void)
{
    /*
     * We test different IPV4 combinations:
     * 1.1.1.1 vs 1.1.1.1         -> equal
     * 1.2.3.4 vs 1.1.1.1         -> not equal
     * 1.2.3.4 vs 1.2.1.1         -> not equal
     * 1.2.3.4 vs 1.2.3.1         -> not equal
     * 2.2.3.4 vs 1.2.3.4         -> not equal
     * 1.2.3.4 vs 1.2.3.4         -> equal
     * 1.2.3.4 vs NULL            -> error
     * 1.2.3.4 vs 1:2:3:4:5:6:7:8 -> error
     */
    IPAddress *a = NULL;
    IPAddress *b = NULL;
    Buffer *bufferA = NULL;
    Buffer *bufferB = NULL;
            
    bufferA = BufferNew();
    assert_true(bufferA != NULL);
    BufferSet(bufferA, "1.1.1.1", strlen("1.1.1.1"));
    a = IPAddressNew(bufferA);
    assert_true(a != NULL);

    bufferB = BufferNew();
    assert_true(bufferB != NULL);
    BufferSet(bufferB, "1.1.1.1", strlen("1.1.1.1"));
    b = IPAddressNew(bufferB);
    assert_true(b != NULL);
    
    assert_true(IPAddressIsEqual(a, b));
    
    BufferSet(bufferA, "1.2.3.4", strlen("1.2.3.4"));
    assert_int_equal(IPAddressDestroy(&a), 0);
    a = IPAddressNew(bufferA);
    assert_true(a != NULL);
    
    assert_false(IPAddressIsEqual(a, b));       

    BufferSet(bufferB, "1.2.1.1", strlen("1.2.1.1"));
    assert_int_equal(IPAddressDestroy(&b), 0);
    b = IPAddressNew(bufferB);
    assert_true(b != NULL);

    assert_false(IPAddressIsEqual(a, b));

    BufferSet(bufferB, "1.2.3.1", strlen("1.2.3.1"));
    assert_int_equal(IPAddressDestroy(&b), 0);
    b = IPAddressNew(bufferB);
    assert_true(b != NULL);

    assert_false(IPAddressIsEqual(a, b));

    BufferSet(bufferA, "2.2.3.4", strlen("2.2.3.4"));
    assert_int_equal(IPAddressDestroy(&a), 0);
    a = IPAddressNew(bufferA);
    assert_true(a != NULL);

    BufferSet(bufferB, "1.2.3.4", strlen("1.2.3.4"));
    assert_int_equal(IPAddressDestroy(&b), 0);
    b = IPAddressNew(bufferB);
    assert_true(b != NULL);

    assert_false(IPAddressIsEqual(a, b));

    BufferSet(bufferA, "1.2.3.4", strlen("1.2.3.4"));
    assert_int_equal(IPAddressDestroy(&a), 0);
    a = IPAddressNew(bufferA);
    assert_true(a != NULL);

    assert_true(IPAddressIsEqual(a, b));

    assert_int_equal(IPAddressIsEqual(a, NULL), -1);
    assert_int_equal(IPAddressIsEqual(NULL, a), -1);

    BufferSet(bufferA, "1:2:3:4:5:6:7:8", strlen("1:2:3:4:5:6:7:8"));
    assert_int_equal(IPAddressDestroy(&a), 0);
    a = IPAddressNew(bufferA);
    assert_true(a != NULL);

    assert_int_equal(IPAddressIsEqual(a, b), -1);
    assert_int_equal(IPAddressIsEqual(b, a), -1);
}
예제 #23
0
static void test_remove(void ** UNUSED(state))
{
    struct test_value_object const *helementa, *helementb, *helementc, *helementd;
    void *hash_table = RESTc_new(RESTc_HashTable, 10);
    assert_non_null(hash_table);
    struct test_value_object *elementa = (struct test_value_object *) RESTc_new(_test_value_object, 99, 99);
    struct test_value_object *elementb = (struct test_value_object *) RESTc_new(_test_value_object, 19, 19);
    struct test_value_object *elementc = (struct test_value_object *) RESTc_new(_test_value_object, 0, 0);
    struct test_value_object *elementd = (struct test_value_object *) RESTc_new(_test_value_object, 36, 36);
    assert_non_null(elementa);
    assert_non_null(elementb);
    assert_non_null(elementc);
    assert_non_null(elementd);
    assert_int_equal(RESTc_HashTable.insert(hash_table, elementa), true);
    assert_int_equal(RESTc_HashTable.insert(hash_table, elementb), true);
    assert_int_equal(RESTc_HashTable.insert(hash_table, elementc), true);
    assert_int_equal(RESTc_HashTable.insert(hash_table, elementd), true);
    assert_int_equal(RESTc_HashTable.remove(hash_table, elementd), true);
    helementa = (struct test_value_object const*) RESTc_HashTable.find(hash_table, elementa);
    helementb = (struct test_value_object const*) RESTc_HashTable.find(hash_table, elementb);
    helementc = (struct test_value_object const*) RESTc_HashTable.find(hash_table, elementc);
    helementd = (struct test_value_object const*) RESTc_HashTable.find(hash_table, elementd);
    assert_non_null(helementa);
    assert_non_null(helementb);
    assert_non_null(helementc);
    assert_null(helementd);
    assert_true(elementa != helementa);
    assert_true(elementb != helementb);
    assert_true(elementc != helementc);
    assert_int_equal(elementa->value, helementa->value);
    assert_int_equal(elementb->value, helementb->value);
    assert_int_equal(elementc->value, helementc->value);
    assert_int_equal(RESTc_HashTable.remove(hash_table, elementd), false);
    assert_int_equal(RESTc_HashTable.remove(hash_table, elementa), true);
    helementa = (struct test_value_object const*) RESTc_HashTable.find(hash_table, elementa);
    helementb = (struct test_value_object const*) RESTc_HashTable.find(hash_table, elementb);
    helementc = (struct test_value_object const*) RESTc_HashTable.find(hash_table, elementc);
    helementd = (struct test_value_object const*) RESTc_HashTable.find(hash_table, elementd);
    assert_null(helementa);
    assert_non_null(helementb);
    assert_non_null(helementc);
    assert_null(helementd);
    assert_true(elementb != helementb);
    assert_true(elementc != helementc);
    assert_int_equal(elementb->value, helementb->value);
    assert_int_equal(elementc->value, helementc->value);
    assert_int_equal(RESTc_HashTable.remove(hash_table, elementa), false);
    assert_int_equal(RESTc_HashTable.remove(hash_table, elementd), false);
    assert_int_equal(RESTc_HashTable.remove(hash_table, elementc), true);
    helementa = (struct test_value_object const*) RESTc_HashTable.find(hash_table, elementa);
    helementb = (struct test_value_object const*) RESTc_HashTable.find(hash_table, elementb);
    helementc = (struct test_value_object const*) RESTc_HashTable.find(hash_table, elementc);
    helementd = (struct test_value_object const*) RESTc_HashTable.find(hash_table, elementd);
    assert_null(helementa);
    assert_non_null(helementb);
    assert_null(helementc);
    assert_null(helementd);
    assert_true(elementb != helementb);
    assert_int_equal(elementb->value, helementb->value);
    assert_int_equal(RESTc_HashTable.remove(hash_table, elementd), false);
    assert_int_equal(RESTc_HashTable.remove(hash_table, elementc), false);
    assert_int_equal(RESTc_HashTable.remove(hash_table, elementa), false);
    assert_int_equal(RESTc_HashTable.remove(hash_table, elementb), true);
    helementa = (struct test_value_object const*) RESTc_HashTable.find(hash_table, elementa);
    helementb = (struct test_value_object const*) RESTc_HashTable.find(hash_table, elementb);
    helementc = (struct test_value_object const*) RESTc_HashTable.find(hash_table, elementc);
    helementd = (struct test_value_object const*) RESTc_HashTable.find(hash_table, elementd);
    assert_null(helementa);
    assert_null(helementb);
    assert_null(helementc);
    assert_null(helementd);
    RESTc_delete(elementa);
    RESTc_delete(elementb);
    RESTc_delete(elementc);
    RESTc_delete(elementd);
    RESTc_delete(hash_table);
}
예제 #24
0
static void test_ipv6_address_comparison(void)
{
    /*
     * We test different IPV6 combinations:
     * 1:1:1:1:1:1:1:1 vs 1:1:1:1:1:1:1:1 -> equal
     * 1:2:3:4:5:6:7:8 vs 1:1:1:1:1:1:1:1 -> not equal
     * 1:2:3:4:5:6:7:8 vs 1:2:1:1:1:1:1:1 -> not equal
     * 1:2:3:4:5:6:7:8 vs 1:2:3:1:1:1:1:1 -> not equal
     * 1:2:3:4:5:6:7:8 vs 1:2:3:4:1:1:1:1 -> not equal
     * 1:2:3:4:5:6:7:8 vs 1:2:3:4:5:1:1:1 -> not equal
     * 1:2:3:4:5:6:7:8 vs 1:2:3:4:5:6:1:1 -> not equal
     * 1:2:3:4:5:6:7:8 vs 1:2:3:4:5:6:7:1 -> not equal
     * 2:2:3:4:5:6:7:8 vs 1:2:3:4:5:6:7:8 -> not equal
     * 1:2:3:4:5:6:7:8 vs 1:2:3:4:5:6:7:8 -> equal
     * Exotic variants
     * 1:0:0:0:0:0:0:1 vs 1::1            -> equal
     * 1:1:0:0:0:0:0:1 vs 1::1            -> not equal
     * 1:1:0:0:0:0:0:1 vs 1:1::1          -> equal
     * 1:0:0:0:0:0:1:1 vs 1::1:1          -> equal
     * Error conditions
     * 1::1:1 vs NULL                     -> error
     * 1::1:1 vs 1.2.3.4                  -> error
     */

    IPAddress *a = NULL;
    IPAddress *b = NULL;
    Buffer *bufferA = NULL;
    Buffer *bufferB = NULL;

    bufferA = BufferNew();
    assert_true(bufferA != NULL);
    BufferSet(bufferA, "1:1:1:1:1:1:1:1", strlen("1:1:1:1:1:1:1:1"));
    a = IPAddressNew(bufferA);
    assert_true(a != NULL);

    bufferB = BufferNew();
    assert_true(bufferB != NULL);
    BufferSet(bufferB, "1:1:1:1:1:1:1:1", strlen("1:1:1:1:1:1:1:1"));
    b = IPAddressNew(bufferB);
    assert_true(b != NULL);

    assert_true(IPAddressIsEqual(a, b));

    assert_true(bufferA != NULL);
    BufferSet(bufferA, "1:2:3:4:5:6:7:8", strlen("1:1:1:1:1:1:1:1"));
    assert_int_equal(IPAddressDestroy(&a), 0);
    a = IPAddressNew(bufferA);
    assert_true(a != NULL);

    assert_false(IPAddressIsEqual(a, b));

    assert_true(bufferB != NULL);
    BufferSet(bufferB, "1:2:1:1:1:1:1:1", strlen("1:2:1:1:1:1:1:1"));
    assert_int_equal(IPAddressDestroy(&b), 0);
    b = IPAddressNew(bufferB);
    assert_true(b != NULL);

    assert_false(IPAddressIsEqual(a, b));

    assert_true(bufferB != NULL);
    BufferSet(bufferB, "1:2:3:1:1:1:1:1", strlen("1:2:3:1:1:1:1:1"));
    assert_int_equal(IPAddressDestroy(&b), 0);
    b = IPAddressNew(bufferB);
    assert_true(b != NULL);

    assert_false(IPAddressIsEqual(a, b));

    assert_true(bufferB != NULL);
    BufferSet(bufferB, "1:2:3:4:1:1:1:1", strlen("1:2:3:4:1:1:1:1"));
    assert_int_equal(IPAddressDestroy(&b), 0);
    b = IPAddressNew(bufferB);
    assert_true(b != NULL);

    assert_false(IPAddressIsEqual(a, b));

    assert_true(bufferB != NULL);
    BufferSet(bufferB, "1:2:3:4:5:1:1:1", strlen("1:2:3:4:5:1:1:1"));
    assert_int_equal(IPAddressDestroy(&b), 0);
    b = IPAddressNew(bufferB);
    assert_true(b != NULL);

    assert_false(IPAddressIsEqual(a, b));

    assert_true(bufferB != NULL);
    BufferSet(bufferB, "1:2:3:4:5:6:1:1", strlen("1:2:3:4:5:6:1:1"));
    assert_int_equal(IPAddressDestroy(&b), 0);
    b = IPAddressNew(bufferB);
    assert_true(b != NULL);

    assert_false(IPAddressIsEqual(a, b));

    assert_true(bufferB != NULL);
    BufferSet(bufferB, "1:2:3:4:5:6:7:1", strlen("1:2:3:4:5:6:7:1"));
    assert_int_equal(IPAddressDestroy(&b), 0);
    b = IPAddressNew(bufferB);
    assert_true(b != NULL);

    assert_false(IPAddressIsEqual(a, b));

    assert_true(bufferB != NULL);
    BufferSet(bufferB, "2:2:3:4:5:6:7:8", strlen("2:2:3:4:5:6:7:8"));
    assert_int_equal(IPAddressDestroy(&b), 0);
    b = IPAddressNew(bufferB);
    assert_true(b != NULL);

    assert_false(IPAddressIsEqual(a, b));

    assert_true(bufferA != NULL);
    BufferSet(bufferA, "1:0:0:0:0:0:0:1", strlen("1:0:0:0:0:0:0:1"));
    assert_int_equal(IPAddressDestroy(&a), 0);
    a = IPAddressNew(bufferA);
    assert_true(a != NULL);

    assert_true(bufferB != NULL);
    BufferSet(bufferB, "1::1", strlen("1::1"));
    assert_int_equal(IPAddressDestroy(&b), 0);
    b = IPAddressNew(bufferB);
    assert_true(b != NULL);

    assert_true(IPAddressIsEqual(a, b));

    assert_true(bufferA != NULL);
    BufferSet(bufferA, "1:1:0:0:0:0:0:1", strlen("1:1:0:0:0:0:0:1"));
    assert_int_equal(IPAddressDestroy(&a), 0);
    a = IPAddressNew(bufferA);
    assert_true(a != NULL);

    assert_false(IPAddressIsEqual(a, b));

    assert_true(bufferB != NULL);
    BufferSet(bufferB, "1:1::1", strlen("1:1::1"));
    assert_int_equal(IPAddressDestroy(&b), 0);
    b = IPAddressNew(bufferB);
    assert_true(b != NULL);

    assert_true(IPAddressIsEqual(a, b));

    assert_true(bufferA != NULL);
    BufferSet(bufferA, "1::1:1", strlen("1::1:1"));
    assert_int_equal(IPAddressDestroy(&a), 0);
    a = IPAddressNew(bufferA);
    assert_true(a != NULL);

    assert_true(bufferB != NULL);
    BufferSet(bufferB, "1:0:0:0:0:0:1:1", strlen("1:0:0:0:0:0:1:1"));
    assert_int_equal(IPAddressDestroy(&b), 0);
    b = IPAddressNew(bufferB);
    assert_true(b != NULL);

    assert_true(IPAddressIsEqual(a, b));

    assert_int_equal(IPAddressIsEqual(a, NULL), -1);

    assert_true(bufferB != NULL);
    BufferSet(bufferB, "1.2.3.4", strlen("1.2.3.4"));
    assert_int_equal(IPAddressDestroy(&b), 0);
    b = IPAddressNew(bufferB);
    assert_true(b != NULL);

    assert_int_equal(IPAddressIsEqual(a, b), -1);
}
예제 #25
0
static void test_pdu_to_host_byte_order(void **state)
{
	struct pdu_serial_notify pdu_serial;
	struct pdu_end_of_data_v1 pdu_eod;

	UNUSED(state);

	pdu_serial.ver = 1;
	pdu_serial.type = SERIAL_NOTIFY;
	pdu_serial.session_id = 0xDDFF;
	pdu_serial.len = 0xC;
	pdu_serial.sn = 0xDF;

	rtr_pdu_footer_to_host_byte_order(&pdu_serial);
	rtr_pdu_header_to_host_byte_order(&pdu_serial);

	assert_int_equal(pdu_serial.ver, 1);
	assert_int_equal(pdu_serial.type, SERIAL_NOTIFY);
	assert_int_equal(pdu_serial.len, 0xC000000);
	assert_int_equal(pdu_serial.sn, 0xDF000000);

	pdu_eod.ver = 1;
	pdu_eod.type = EOD;
	pdu_eod.session_id = 0xFDDF;
	pdu_eod.len = 0x18;
	pdu_eod.sn = 0xFEDCBA;
	pdu_eod.refresh_interval = 0xAF;
	pdu_eod.retry_interval = 0xDC;
	pdu_eod.expire_interval = 0xCCF;

	rtr_pdu_header_to_host_byte_order(&pdu_eod);
	rtr_pdu_footer_to_host_byte_order(&pdu_eod);

	assert_int_equal(pdu_eod.ver, 1);
	assert_int_equal(pdu_eod.type, EOD);
	assert_int_equal(pdu_eod.session_id, 0xDFFD);
	assert_int_equal(pdu_eod.len, 0x18000000);
	assert_int_equal(pdu_eod.sn, 0xBADCFE00);
	assert_int_equal(pdu_eod.refresh_interval, 0xAF000000);
	assert_int_equal(pdu_eod.retry_interval, 0xDC000000);
	assert_int_equal(pdu_eod.expire_interval, 0xCF0C0000);
}
예제 #26
0
static void test_isipaddress(void)
{
    /*
     * This test is just a summary of the other tests.
     * We just check that this interface works accordingly, most of the
     * functionality has already been tested.
     * 1.2.3.4         -> ok
     * 1.2..3          -> not
     * 1.a.2.3         -> not
     * 256.255.255.255 -> not
     * 255.255.255.255 -> ok
     * 1:0:0:0:0:0:0:1 -> ok
     * 1:1:1:1:0:1:1:1 -> ok
     * a:b:c:d:e:f:0:1 -> ok
     * a:b:c:d:e:f:g:h -> not
     * ffff:ffff:fffff:0:0:0:0:1 -> not
     */
    IPAddress *address = NULL;
    Buffer *bufferAddress = NULL;

    bufferAddress = BufferNew();
    assert_true (bufferAddress != NULL);

    BufferSet(bufferAddress, "1.2.3.4", strlen("1.2.3.4"));
    assert_true(IPAddressIsIPAddress(bufferAddress, NULL));
    assert_true(IPAddressIsIPAddress(bufferAddress, &address));
    assert_true(address != NULL);
    assert_int_equal(IPAddressType(address), IP_ADDRESS_TYPE_IPV4);
    BufferClear(bufferAddress);
    assert_int_equal(IPAddressDestroy(&address), 0);

    BufferSet(bufferAddress, "1.2..3", strlen("1.2..3"));
    assert_false(IPAddressIsIPAddress(bufferAddress, NULL));
    assert_false(IPAddressIsIPAddress(bufferAddress, &address));
    assert_true(address == NULL);
    BufferClear(bufferAddress);

    BufferSet(bufferAddress, "1.a.2.3", strlen("1.a.2.3"));
    assert_false(IPAddressIsIPAddress(bufferAddress, NULL));
    assert_false(IPAddressIsIPAddress(bufferAddress, &address));
    assert_true(address == NULL);
    BufferClear(bufferAddress);

    BufferSet(bufferAddress, "256.255.255.255", strlen("256.255.255.255"));
    assert_false(IPAddressIsIPAddress(bufferAddress, NULL));
    assert_false(IPAddressIsIPAddress(bufferAddress, &address));
    assert_true(address == NULL);
    BufferClear(bufferAddress);

    BufferSet(bufferAddress, "255.255.255.255", strlen("255.255.255.255"));
    assert_true(IPAddressIsIPAddress(bufferAddress, NULL));
    assert_true(IPAddressIsIPAddress(bufferAddress, &address));
    assert_true(address != NULL);
    assert_int_equal(IPAddressType(address), IP_ADDRESS_TYPE_IPV4);
    BufferClear(bufferAddress);
    assert_int_equal(IPAddressDestroy(&address), 0);

    BufferSet(bufferAddress, "1:0:0:0:0:0:0:1", strlen("1:0:0:0:0:0:0:1"));
    assert_true(IPAddressIsIPAddress(bufferAddress, NULL));
    assert_true(IPAddressIsIPAddress(bufferAddress, &address));
    assert_true(address != NULL);
    assert_int_equal(IPAddressType(address), IP_ADDRESS_TYPE_IPV6);
    BufferClear(bufferAddress);
    assert_int_equal(IPAddressDestroy(&address), 0);

    BufferSet(bufferAddress, "1:1:1:1:0:1:1:1", strlen("1:1:1:1:0:1:1:1"));
    assert_true(IPAddressIsIPAddress(bufferAddress, NULL));
    assert_true(IPAddressIsIPAddress(bufferAddress, &address));
    assert_true(address != NULL);
    assert_int_equal(IPAddressType(address), IP_ADDRESS_TYPE_IPV6);
    BufferClear(bufferAddress);
    assert_int_equal(IPAddressDestroy(&address), 0);

    BufferSet(bufferAddress, "a:b:c:d:e:f:0:1", strlen("a:b:c:d:e:f:0:1"));
    assert_true(IPAddressIsIPAddress(bufferAddress, NULL));
    assert_true(IPAddressIsIPAddress(bufferAddress, &address));
    assert_true(address != NULL);
    assert_int_equal(IPAddressType(address), IP_ADDRESS_TYPE_IPV6);
    BufferClear(bufferAddress);
    assert_int_equal(IPAddressDestroy(&address), 0);

    BufferSet(bufferAddress, "a:b:c:d:e:f:g:h", strlen("a:b:c:d:e:f:g:h"));
    assert_false(IPAddressIsIPAddress(bufferAddress, NULL));
    assert_false(IPAddressIsIPAddress(bufferAddress, &address));
    BufferClear(bufferAddress);

    BufferSet(bufferAddress, "ffff:ffff:fffff:0:0:0:0:1", strlen("ffff:ffff:fffff:0:0:0:0:1"));
    assert_false(IPAddressIsIPAddress(bufferAddress, NULL));
    assert_false(IPAddressIsIPAddress(bufferAddress, &address));
    BufferClear(bufferAddress);
}
예제 #27
0
static void test_res_fake_soa_query(void **state)
{
    int rv;
    struct __res_state dnsstate;
    unsigned char answer[ANSIZE];
    ns_msg handle;
    ns_rr rr;   /* expanded resource record */
    const uint8_t *rrdata;
    char nameser[MAXDNAME];
    char admin[MAXDNAME];
    int serial;
    int refresh;
    int retry;
    int expire;
    int minimum;

    (void) state; /* unused */

    memset(&dnsstate, 0, sizeof(struct __res_state));
    rv = res_ninit(&dnsstate);
    assert_int_equal(rv, 0);

    rv = res_nquery(&dnsstate, "cwrap.org", ns_c_in, ns_t_soa,
                    answer, sizeof(answer));
    assert_in_range(rv, 1, 100);

    ns_initparse(answer, sizeof(answer), &handle);

    /*
     * The query must finish w/o an error, have one answer and the answer
     * must be a parseable RR of type SOA and have the data as in the fake
     * hosts file
     */
    assert_int_equal(ns_msg_getflag(handle, ns_f_rcode), ns_r_noerror);
    assert_int_equal(ns_msg_count(handle, ns_s_an), 1);
    assert_int_equal(ns_parserr(&handle, ns_s_an, 0, &rr), 0);
    assert_int_equal(ns_rr_type(rr), ns_t_soa);

    rrdata = ns_rr_rdata(rr);

    rv = ns_name_uncompress(ns_msg_base(handle),
                            ns_msg_end(handle),
                            rrdata,
                            nameser, MAXDNAME);
    assert_int_not_equal(rv, -1);
    rrdata += rv;

    rv = ns_name_uncompress(ns_msg_base(handle),
                            ns_msg_end(handle),
                            rrdata,
                            admin, MAXDNAME);
    assert_int_not_equal(rv, -1);
    rrdata += rv;

    NS_GET32(serial, rrdata);
    NS_GET32(refresh, rrdata);
    NS_GET32(retry, rrdata);
    NS_GET32(expire, rrdata);
    NS_GET32(minimum, rrdata);

    assert_string_equal(nameser, "ns1.cwrap.org");
    assert_string_equal(admin, "admin.cwrap.org");
    assert_int_equal(serial, 2014100457);
    assert_int_equal(refresh, 3600);
    assert_int_equal(retry, 300);
    assert_int_equal(expire, 1814400);
    assert_int_equal(minimum, 600);
}
예제 #28
0
static void test_ipv4(void)
{
    /*
     * This test will check the ipv4 parser. We will directly call to it, we will not check
     * the generic frontend.
     * Cases to test:
     * 0.0.0.0 Ok
     * 255.255.255.255 Ok
     * 1.1.1.1 Ok
     * 1.1.1.1:1 Ok
     * 1.2.3.4 Ok
     * 5.6.7.8:9 Ok
     * 10.0.0.9:0 Ok
     * 10.0.0.10:5308 Ok
     * 192.168.56.10:65535 Ok
     * 0 Fail
     * 0.1 Fail
     * 0.1.2 Fail
     * 0:0 Fail
     * 1.1.1.260 Fail
     * 1.1.260.1 Fail
     * 1.260.1.1 Fail
     * 260.1.1.1 Fail
     * 260.260.260.260 Fail
     * 1.1.1.1: Fail
     * 2.3.4.5:65536 Fail
     * a.b.c.d Fail
     */
    struct IPV4Address ipv4;
    memset(&ipv4, 0, sizeof(struct IPV4Address));
    assert_int_equal(0, IPV4_parser("0.0.0.0", &ipv4));
    assert_int_equal(ipv4.octets[0], 0);
    assert_int_equal(ipv4.octets[1], 0);
    assert_int_equal(ipv4.octets[2], 0);
    assert_int_equal(ipv4.octets[3], 0);
    assert_int_equal(ipv4.port, 0);
    memset(&ipv4, 0, sizeof(struct IPV4Address));
    assert_int_equal(0, IPV4_parser("255.255.255.255", &ipv4));
    assert_int_equal(ipv4.octets[0], 255);
    assert_int_equal(ipv4.octets[1], 255);
    assert_int_equal(ipv4.octets[2], 255);
    assert_int_equal(ipv4.octets[3], 255);
    assert_int_equal(ipv4.port, 0);
    memset(&ipv4, 0, sizeof(struct IPV4Address));
    assert_int_equal(0, IPV4_parser("1.1.1.1", &ipv4));
    assert_int_equal(ipv4.octets[0], 1);
    assert_int_equal(ipv4.octets[1], 1);
    assert_int_equal(ipv4.octets[2], 1);
    assert_int_equal(ipv4.octets[3], 1);
    assert_int_equal(ipv4.port, 0);
    memset(&ipv4, 0, sizeof(struct IPV4Address));
    assert_int_equal(0, IPV4_parser("1.1.1.1:1", &ipv4));
    assert_int_equal(ipv4.octets[0], 1);
    assert_int_equal(ipv4.octets[1], 1);
    assert_int_equal(ipv4.octets[2], 1);
    assert_int_equal(ipv4.octets[3], 1);
    assert_int_equal(ipv4.port, 1);
    memset(&ipv4, 0, sizeof(struct IPV4Address));
    assert_int_equal(0, IPV4_parser("1.2.3.4", &ipv4));
    assert_int_equal(ipv4.octets[0], 1);
    assert_int_equal(ipv4.octets[1], 2);
    assert_int_equal(ipv4.octets[2], 3);
    assert_int_equal(ipv4.octets[3], 4);
    assert_int_equal(ipv4.port, 0);
    memset(&ipv4, 0, sizeof(struct IPV4Address));
    assert_int_equal(0, IPV4_parser("5.6.7.8:9", &ipv4));
    assert_int_equal(ipv4.octets[0], 5);
    assert_int_equal(ipv4.octets[1], 6);
    assert_int_equal(ipv4.octets[2], 7);
    assert_int_equal(ipv4.octets[3], 8);
    assert_int_equal(ipv4.port, 9);
    memset(&ipv4, 0, sizeof(struct IPV4Address));
    assert_int_equal(0, IPV4_parser("10.0.0.9:0", &ipv4));
    assert_int_equal(ipv4.octets[0], 10);
    assert_int_equal(ipv4.octets[1], 0);
    assert_int_equal(ipv4.octets[2], 0);
    assert_int_equal(ipv4.octets[3], 9);
    assert_int_equal(ipv4.port, 0);
    memset(&ipv4, 0, sizeof(struct IPV4Address));
    assert_int_equal(0, IPV4_parser("10.0.0.10:5308", &ipv4));
    assert_int_equal(ipv4.octets[0], 10);
    assert_int_equal(ipv4.octets[1], 0);
    assert_int_equal(ipv4.octets[2], 0);
    assert_int_equal(ipv4.octets[3], 10);
    assert_int_equal(ipv4.port, 5308);
    memset(&ipv4, 0, sizeof(struct IPV4Address));
    assert_int_equal(0, IPV4_parser("192.168.56.10:65535", &ipv4));
    assert_int_equal(ipv4.octets[0], 192);
    assert_int_equal(ipv4.octets[1], 168);
    assert_int_equal(ipv4.octets[2], 56);
    assert_int_equal(ipv4.octets[3], 10);
    assert_int_equal(ipv4.port, 65535);
    memset(&ipv4, 0, sizeof(struct IPV4Address));
    assert_int_equal(-1, IPV4_parser("0", &ipv4));
    memset(&ipv4, 0, sizeof(struct IPV4Address));
    assert_int_equal(-1, IPV4_parser("0.1", &ipv4));
    memset(&ipv4, 0, sizeof(struct IPV4Address));
    assert_int_equal(-1, IPV4_parser("0.1.2", &ipv4));
    memset(&ipv4, 0, sizeof(struct IPV4Address));
    assert_int_equal(-1, IPV4_parser("0:0", &ipv4));
    memset(&ipv4, 0, sizeof(struct IPV4Address));
    assert_int_equal(-1, IPV4_parser("1.1.1.260", &ipv4));
    memset(&ipv4, 0, sizeof(struct IPV4Address));
    assert_int_equal(-1, IPV4_parser("1.1.260.1", &ipv4));
    memset(&ipv4, 0, sizeof(struct IPV4Address));
    assert_int_equal(-1, IPV4_parser("1.260.1.1", &ipv4));
    memset(&ipv4, 0, sizeof(struct IPV4Address));
    assert_int_equal(-1, IPV4_parser("260.1.1.1", &ipv4));
    memset(&ipv4, 0, sizeof(struct IPV4Address));
    assert_int_equal(-1, IPV4_parser("260.260.260.260", &ipv4));
    memset(&ipv4, 0, sizeof(struct IPV4Address));
    assert_int_equal(-1, IPV4_parser("1.1.1.1:", &ipv4));
    memset(&ipv4, 0, sizeof(struct IPV4Address));
    assert_int_equal(-1, IPV4_parser("2.3.4.5:65536", &ipv4));
    memset(&ipv4, 0, sizeof(struct IPV4Address));
    assert_int_equal(-1, IPV4_parser("a.b.c.d", &ipv4));
}
예제 #29
0
static void test_res_fake_a_via_cname(void **state)
{
    int rv;
    struct __res_state dnsstate;
    unsigned char answer[ANSIZE];
    ns_msg handle;
    ns_rr rr;   /* expanded resource record */
    const uint8_t *rrdata;
    char cname[MAXDNAME];
    char addr[INET_ADDRSTRLEN];

    (void) state; /* unused */

    memset(&dnsstate, 0, sizeof(struct __res_state));
    rv = res_ninit(&dnsstate);
    assert_int_equal(rv, 0);

    /* Query for A record, but the key is a CNAME. The expected result is
     * that the whole chain of CNAMEs will be included in the answer section
     * along with the resulting A
     */
    rv = res_nquery(&dnsstate, "rwrap.org", ns_c_in, ns_t_a,
                    answer, sizeof(answer));
    assert_in_range(rv, 1, 256);

    ns_initparse(answer, sizeof(answer), &handle);

    /*
     * The query must finish w/o an error, have three answers and the answers
     * must be a parseable RR of type CNAME and have the cname as in the
     * fake hosts file
     */
    assert_int_equal(ns_msg_getflag(handle, ns_f_rcode), ns_r_noerror);
    assert_int_equal(ns_msg_count(handle, ns_s_an), 3);

    assert_int_equal(ns_parserr(&handle, ns_s_an, 0, &rr), 0);
    assert_int_equal(ns_rr_type(rr), ns_t_cname);

    rrdata = ns_rr_rdata(rr);

    rv = ns_name_uncompress(ns_msg_base(handle),
                            ns_msg_end(handle),
                            rrdata,
                            cname, MAXDNAME);
    assert_int_not_equal(rv, -1);

    assert_string_equal(cname, "web.cwrap.org");

    assert_int_equal(ns_parserr(&handle, ns_s_an, 1, &rr), 0);
    assert_int_equal(ns_rr_type(rr), ns_t_cname);

    rrdata = ns_rr_rdata(rr);

    rv = ns_name_uncompress(ns_msg_base(handle),
                            ns_msg_end(handle),
                            rrdata,
                            cname, MAXDNAME);
    assert_int_not_equal(rv, -1);

    assert_string_equal(cname, "www.cwrap.org");

    assert_int_equal(ns_parserr(&handle, ns_s_an, 2, &rr), 0);
    assert_int_equal(ns_rr_type(rr), ns_t_a);
    assert_string_equal(ns_rr_name(rr), "www.cwrap.org");
    assert_non_null(inet_ntop(AF_INET, ns_rr_rdata(rr),
                              addr, sizeof(addr)));
    assert_string_equal(addr, "127.0.0.22");
}
예제 #30
0
/* Ensure add() adds two integers correctly. */
static void test_add(void **state) {
        (void) state; /* unused */

	assert_int_equal(add(3, 3), 6);
	assert_int_equal(add(3, -3), 0);
}