Example #1
0
static void test_file(const char *filename)
{
	int size, i;
	char **list_str; 
	char *content, *tmp;
	struct CMUnitTest *tests;
	int issue_num, number_of_tests;

	printf("[+] TARGET: %s\n", filename);
	content = readfile(filename);
	counter = 0;
	failed_setup = 0;
	function = NULL;		

	if (strstr(filename, "issue")) {
		number_of_tests = 0;
		list_lines = split(content, "\n", &size_lines);	
		tests = NULL;
		for (i = 0; i < size_lines; ++i) {
			if ((!strncmp(list_lines[i], "// !# issue", 11) && e_flag == 1) || 
					(!strncmp(list_lines[i], "!# issue", 8) && e_flag == 0)) {
				tests = (struct CMUnitTest *)realloc(tests, sizeof(struct CMUnitTest) * (number_of_tests + 1));
				tests[number_of_tests] = (struct CMUnitTest)cmocka_unit_test_setup_teardown(test_issue, setup_issue, teardown_issue);
				tests[number_of_tests].name = strdup(list_lines[i]);
				number_of_tests ++;
			}
		}

		_cmocka_run_group_tests("Testing issues", tests, number_of_tests, NULL, NULL);
	} else {
		list_lines = split(content, "\n", &size_lines);
		number_of_tests = 0;

		tests = NULL;
		for (i = 1; i < size_lines; ++i) {
			if ((!strncmp(list_lines[i], "// 0x", 5) && e_flag == 1) || (!strncmp(list_lines[i], "0x", 2) && e_flag == 0)) {
				tmp = (char *)malloc(sizeof(char) * 100);
				sprintf(tmp, "Line %d", i+1);
				tests = (struct CMUnitTest *)realloc(tests, sizeof(struct CMUnitTest) * (number_of_tests + 1));
				tests[number_of_tests] = (struct CMUnitTest)cmocka_unit_test_setup_teardown(test_MC, setup_MC, teardown_MC);
				tests[number_of_tests].name = tmp;
				number_of_tests ++;
			}
		}

		_cmocka_run_group_tests("Testing MC", tests, number_of_tests, NULL, NULL);
	}

	printf("[+] DONE: %s\n", filename);
	printf("[!] Noted:\n[  ERROR   ] --- \"<capstone result>\" != \"<user result>\"\n");	
	printf("\n\n");
	free_strs(list_lines, size_lines);
}
Example #2
0
///Główna funkcja, odpala testy
int main(void)
{
	const struct CMUnitTest tests[] = {
		cmocka_unit_test_setup_teardown(dictionary_insert_test, dictionary_setup, dictionary_teardown),
		cmocka_unit_test_setup_teardown(dictionary_delete_test, dictionary_setup, dictionary_teardown),
		cmocka_unit_test_setup_teardown(dictionary_find_test, dictionary_setup, dictionary_teardown),
		cmocka_unit_test_setup_teardown(dictionary_hints_word_with_ignores_test, dictionary_setup, dictionary_teardown),
		cmocka_unit_test_setup_teardown(dictionary_hints_word_without_ignores_test, dictionary_setup, dictionary_teardown),
	};

	return cmocka_run_group_tests(tests, NULL, NULL);
}
Example #3
0
int main(void)
{
    const struct CMUnitTest tests[] = {
                    cmocka_unit_test_setup_teardown(test_invalid, setup_f, teardown_f),
                    cmocka_unit_test_setup_teardown(test_simple, setup_f, teardown_f),
                    cmocka_unit_test_setup_teardown(test_advanced, setup_f, teardown_f),
                    cmocka_unit_test_setup_teardown(test_attributes, setup_f, teardown_f),
                    cmocka_unit_test_setup_teardown(test_functions_operators, setup_f, teardown_f),
                    };

    return cmocka_run_group_tests(tests, NULL, NULL);
}
Example #4
0
int
main() {
    const struct CMUnitTest tests[] = {
            cmocka_unit_test_setup_teardown(cm_session_test, cm_setup, cm_teardown),
            cmocka_unit_test_setup_teardown(cm_session_neg_test, cm_setup, NULL),
            cmocka_unit_test_setup_teardown(cm_buffers_test, cm_setup, cm_teardown),
            cmocka_unit_test_setup_teardown(cm_signals_test, cm_setup, cm_teardown),
    };

    watchdog_start(300);
    int ret = cmocka_run_group_tests(tests, NULL, NULL);
    watchdog_stop();
    return ret;
}
int main(void) {
    const struct CMUnitTest tests[] = {
      cmocka_unit_test(dictionary_init_test), 
      cmocka_unit_test(dictionary_add_test),      
      cmocka_unit_test(dictionary_find_test),      
      cmocka_unit_test(dictionary_delete_test),      
      cmocka_unit_test_setup_teardown(dictionary_delete_all, dictionary_setup, dictionary_teardown),
      cmocka_unit_test_setup_teardown(dictionary_delete_and_find, dictionary_setup, dictionary_teardown),
      cmocka_unit_test_setup_teardown(dictionary_insert_the_same, dictionary_setup, dictionary_teardown),
      cmocka_unit_test_setup_teardown(dictionary_delete_non_existing, dictionary_setup, dictionary_teardown),
    };

    return cmocka_run_group_tests(tests, NULL, NULL);
}
Example #6
0
int main(void)
{
    const struct CMUnitTest tests[] = {
                    cmocka_unit_test_teardown(test_parse_print_yin, teardown_f),
                    cmocka_unit_test_teardown(test_parse_print_yang, teardown_f),
                    cmocka_unit_test_setup_teardown(test_parse_print_xml, setup_f, teardown_f),
                    cmocka_unit_test_setup_teardown(test_parse_print_json, setup_f, teardown_f),
                    cmocka_unit_test_setup_teardown(test_parse_print_oookeys_xml, setup_f, teardown_f),
                    cmocka_unit_test_setup_teardown(test_parse_print_oookeys_json, setup_f, teardown_f),
                    cmocka_unit_test_teardown(test_parse_noncharacters_xml, teardown_f),
    };

    return cmocka_run_group_tests(tests, NULL, NULL);
}
Example #7
0
int main(void)
{
    const struct CMUnitTest tests[] = {
                    cmocka_unit_test_setup_teardown(test_instid_unlink, setup_f, teardown_f) };

    return cmocka_run_group_tests(tests, NULL, NULL);
}
Example #8
0
int main() {
	const struct CMUnitTest tests[] = {
		cmocka_unit_test_setup_teardown(test_resume_yield_status,
				test_setup, test_teardown),
	};
	return cmocka_run_group_tests(tests, NULL, NULL);
}
Example #9
0
int
main() {
    const struct CMUnitTest tests[] = {
        cmocka_unit_test_setup_teardown(sysrepo_daemon_test, test_setup, test_teardown),
    };

    return cmocka_run_group_tests(tests, NULL, NULL);
}
Example #10
0
int
main() {
    const struct CMUnitTest tests[] = {
            cmocka_unit_test_setup_teardown(perf_get_item_test, sysrepo_setup, sysrepo_teardown),
    };

    return cmocka_run_group_tests(tests, NULL, NULL);
}
Example #11
0
/**
  Funkcja główna testu.
  */
int main(void) {
    const struct CMUnitTest tests[] = {
        cmocka_unit_test(word_list_init_test),
        cmocka_unit_test(word_list_add_to_empty_test),
        cmocka_unit_test_setup_teardown(word_list_get_test, word_list_setup, word_list_teardown),
    };

    return cmocka_run_group_tests(tests, NULL, NULL);
}
Example #12
0
int
main(void)
{
    const struct CMUnitTest tests[] = {
        cmocka_unit_test_setup_teardown(TEST_TYPEDEF_GROUPING, setup_f, teardown_f),
    };

    return cmocka_run_group_tests(tests, NULL, NULL);
}
Example #13
0
int
main(void)
{
    const struct CMUnitTest tests[] = {
        cmocka_unit_test_setup_teardown(TEST_RPC_OUTPUT, setup_f, teardown_f),
    };

    return cmocka_run_group_tests(tests, NULL, NULL);
}
Example #14
0
int main(int argc, const char *argv[])
{
    const struct CMUnitTest tests[] = {
        cmocka_unit_test(test_getpwnam_r_wrapper),
        cmocka_unit_test(test_getpwuid_r_wrapper),
        cmocka_unit_test(test_getgrnam_r_wrapper),
        cmocka_unit_test(test_getgrgid_r_wrapper),
        cmocka_unit_test(test_get_user_grouplist),
        cmocka_unit_test_setup_teardown(test_set_err_msg,
                                        extdom_req_setup, extdom_req_teardown),
        cmocka_unit_test_setup_teardown(test_encode,
                                        extdom_req_setup, extdom_req_teardown),
        cmocka_unit_test(test_decode),
    };

    assert_non_null(original_fopen);
    return cmocka_run_group_tests(tests, extdom_req_setup, extdom_req_teardown);
}
int
main(void)
{
    const struct CMUnitTest init_destroy[] = {
        cmocka_unit_test_setup_teardown(test_dummy, setup_ssh, teardown_ssh)
    };

    return cmocka_run_group_tests(init_destroy, NULL, NULL);
}
Example #16
0
int main(void)
{
    const struct CMUnitTest tests[] = {
        cmocka_unit_test(test_create_eval_req_invalid),
        cmocka_unit_test_setup_teardown(test_create_eval_req_nogroups,
                                        test_create_eval_req_nogroups_setup,
                                        test_create_eval_req_nogroups_teardown),
        cmocka_unit_test_setup_teardown(test_create_eval_req_valid_groups,
                                        test_create_eval_req_valid_groups_setup,
                                        test_create_eval_req_valid_groups_teardown),
        cmocka_unit_test_setup_teardown(test_create_eval_req_skip_invalid_groups,
                                        test_create_eval_req_invalid_groups_setup,
                                        test_create_eval_req_invalid_groups_teardown),
    };

    return cmocka_run_group_tests(tests,
                                  eval_req_test_setup,
                                  eval_req_test_teardown);
}
Example #17
0
int
main(void) {
    const struct CMUnitTest tests[] = {
        cmocka_unit_test(null_test_success),
        cmocka_unit_test_setup_teardown(int_test_success, setup, teardown),
/*        cmocka_unit_test(failing_test), */
    };

    return cmocka_run_group_tests_name("success_test", tests, NULL, NULL);
}
Example #18
0
int torture_run_tests(void) {
    int rc;
    struct CMUnitTest tests[] = {
        cmocka_unit_test_setup_teardown(torture_auth_none,
                                        session_setup,
                                        session_teardown),
        cmocka_unit_test_setup_teardown(torture_auth_none_nonblocking,
                                        session_setup,
                                        session_teardown),
        cmocka_unit_test_setup_teardown(torture_auth_password,
                                        session_setup,
                                        session_teardown),
        cmocka_unit_test_setup_teardown(torture_auth_password_nonblocking,
                                        session_setup,
                                        session_teardown),
        cmocka_unit_test_setup_teardown(torture_auth_kbdint,
                                        session_setup,
                                        session_teardown),
        cmocka_unit_test_setup_teardown(torture_auth_kbdint_nonblocking,
                                        session_setup,
                                        session_teardown),
        cmocka_unit_test_setup_teardown(torture_auth_autopubkey,
                                        pubkey_setup,
                                        session_teardown),
        cmocka_unit_test_setup_teardown(torture_auth_autopubkey_nonblocking,
                                        pubkey_setup,
                                        session_teardown),
        cmocka_unit_test_setup_teardown(torture_auth_agent,
                                        agent_setup,
                                        agent_teardown),
        cmocka_unit_test_setup_teardown(torture_auth_agent_nonblocking,
                                        agent_setup,
                                        agent_teardown),
    };

    ssh_init();
    torture_filter_tests(tests);
    rc = cmocka_run_group_tests(tests, sshd_setup, sshd_teardown);
    ssh_finalize();

    return rc;
}
Example #19
0
int torture_run_tests(void) {
    int rc;
    const struct CMUnitTest tests[] = {
        cmocka_unit_test_setup_teardown(test_ssh_channel_request_x11,
                                        setup,
                                        teardown)
    };

    rc = cmocka_run_group_tests(tests, NULL, NULL);
    return rc;
}
Example #20
0
int
main() {
    const struct CMUnitTest tests[] = {
            cmocka_unit_test_setup_teardown(sysrepo_daemon_test, test_setup, test_teardown),
    };

    watchdog_start(300);
    int ret = cmocka_run_group_tests(tests, NULL, NULL);
    watchdog_stop();
    return ret;
}
Example #21
0
int torture_run_tests(void) {
    int rc;
    struct CMUnitTest tests[] = {
        cmocka_unit_test_setup_teardown(torture_connect_nonblocking, session_setup, session_teardown),
        cmocka_unit_test_setup_teardown(torture_connect_double, session_setup, session_teardown),
        cmocka_unit_test_setup_teardown(torture_connect_failure, session_setup, session_teardown),
#if 0
        cmocka_unit_test_setup_teardown(torture_connect_timeout, session_setup, session_teardown),
#endif
        cmocka_unit_test_setup_teardown(torture_connect_socket, session_setup, session_teardown),
    };

    ssh_init();

    torture_filter_tests(tests);
    rc = cmocka_run_group_tests(tests, sshd_setup, sshd_teardown);

    ssh_finalize();
    return rc;
}
Example #22
0
int
main(void)
{
    const struct CMUnitTest cmut[] = {
        cmocka_unit_test_setup_teardown(test_fullset, setup_ctx_yin, teardown_ctx),
        cmocka_unit_test_setup_teardown(test_fullset, setup_ctx_yang, teardown_ctx),
        cmocka_unit_test_setup_teardown(test_circle1, setup_ctx_yang, teardown_ctx),
        cmocka_unit_test_setup_teardown(test_circle2, setup_ctx_yang, teardown_ctx),
        cmocka_unit_test_setup_teardown(test_inval_expr1, setup_ctx_yang, teardown_ctx),
        cmocka_unit_test_setup_teardown(test_inval_expr2, setup_ctx_yang, teardown_ctx),
        cmocka_unit_test_setup_teardown(test_inval_expr3, setup_ctx_yang, teardown_ctx),
        cmocka_unit_test_setup_teardown(test_inval_expr4, setup_ctx_yang, teardown_ctx),
        cmocka_unit_test_setup_teardown(test_inval_expr5, setup_ctx_yang, teardown_ctx)
    };

    return cmocka_run_group_tests(cmut, NULL, NULL);
}
Example #23
0
int torture_run_tests(void)
{
    const struct CMUnitTest tests[] = {
        cmocka_unit_test_setup_teardown(check_csync_detect_update, setup, teardown_rm),
        cmocka_unit_test_setup_teardown(check_csync_detect_update_db_none, setup, teardown),
        cmocka_unit_test_setup_teardown(check_csync_detect_update_db_eval, setup, teardown),
        cmocka_unit_test_setup_teardown(check_csync_detect_update_db_rename, setup, teardown),
        cmocka_unit_test_setup_teardown(check_csync_detect_update_db_new, setup, teardown_rm),
        cmocka_unit_test_setup_teardown(check_csync_detect_update_null, setup, teardown_rm),

        cmocka_unit_test_setup_teardown(check_csync_ftw, setup_ftw, teardown_rm),
        cmocka_unit_test_setup_teardown(check_csync_ftw_empty_uri, setup_ftw, teardown_rm),
        cmocka_unit_test_setup_teardown(check_csync_ftw_failing_fn, setup_ftw, teardown_rm),
    };

    return cmocka_run_group_tests(tests, NULL, NULL);
}
Example #24
0
int main(int argc, const char *argv[])
{
    poptContext pc;
    int opt;
    struct poptOption long_options[] = {
        POPT_AUTOHELP
        SSSD_DEBUG_OPTS
        POPT_TABLEEND
    };

    const struct CMUnitTest tests[] = {
        cmocka_unit_test_setup_teardown(test_add_domain,
                                        test_sss_idmap_setup,
                                        test_sss_idmap_teardown),
        cmocka_unit_test_setup_teardown(test_map_id,
                                        test_sss_idmap_setup_with_domains,
                                        test_sss_idmap_teardown),
        cmocka_unit_test_setup_teardown(test_map_id_external,
                                        test_sss_idmap_setup_with_external_mappings,
                                        test_sss_idmap_teardown),
        cmocka_unit_test_setup_teardown(test_check_sid_id,
                                        test_sss_idmap_setup_with_domains,
                                        test_sss_idmap_teardown),
        cmocka_unit_test_setup_teardown(test_check_sid_id,
                                        test_sss_idmap_setup_with_external_mappings,
                                        test_sss_idmap_teardown),
        cmocka_unit_test_setup_teardown(test_has_algorithmic,
                                        test_sss_idmap_setup_with_both,
                                        test_sss_idmap_teardown),
        cmocka_unit_test_setup_teardown(test_has_algorithmic_by_name,
                                        test_sss_idmap_setup_with_both,
                                        test_sss_idmap_teardown),
        cmocka_unit_test(test_sss_idmap_check_collision_ex),
    };

    /* Set debug level to invalid value so we can deside if -d 0 was used. */
    debug_level = SSSDBG_INVALID;

    pc = poptGetContext(argv[0], argc, argv, long_options, 0);
    while((opt = poptGetNextOpt(pc)) != -1) {
        switch(opt) {
        default:
            fprintf(stderr, "\nInvalid option %s: %s\n\n",
                    poptBadOption(pc, 0), poptStrerror(opt));
            poptPrintUsage(pc, stderr, 0);
            return 1;
        }
    }
    poptFreeContext(pc);

    DEBUG_CLI_INIT(debug_level);

    tests_set_cwd();

    return cmocka_run_group_tests(tests, NULL, NULL);
}
Example #25
0
int torture_run_tests(void)
{
    typedef ExcludedFilesTest T;

    const struct CMUnitTest tests[] = {
        cmocka_unit_test_setup_teardown(T::check_csync_exclude_add, T::setup, T::teardown),
        cmocka_unit_test_setup_teardown(T::check_csync_excluded, T::setup_init, T::teardown),
        cmocka_unit_test_setup_teardown(T::check_csync_excluded_traversal, T::setup_init, T::teardown),
        cmocka_unit_test_setup_teardown(T::check_csync_dir_only, T::setup, T::teardown),
        cmocka_unit_test_setup_teardown(T::check_csync_pathes, T::setup_init, T::teardown),
        cmocka_unit_test_setup_teardown(T::check_csync_wildcards, T::setup, T::teardown),
        cmocka_unit_test_setup_teardown(T::check_csync_regex_translation, T::setup, T::teardown),
        cmocka_unit_test_setup_teardown(T::check_csync_bname_trigger, T::setup, T::teardown),
        cmocka_unit_test_setup_teardown(T::check_csync_is_windows_reserved_word, T::setup_init, T::teardown),
        cmocka_unit_test_setup_teardown(T::check_csync_excluded_performance, T::setup_init, T::teardown),
        cmocka_unit_test(T::check_csync_exclude_expand_escapes),
        cmocka_unit_test(T::check_version_directive),
    };

    return cmocka_run_group_tests(tests, NULL, NULL);
}
Example #26
0
int main(void)
{
    const struct CMUnitTest tests[] = {
                    cmocka_unit_test_setup_teardown(test_empty, setup_f, teardown_f),
                    cmocka_unit_test_setup_teardown(test_empty_tag, setup_f, teardown_f),
                    cmocka_unit_test_setup_teardown(test_status, setup_f, teardown_f),
                    cmocka_unit_test_setup_teardown(test_df1, setup_f, teardown_f),
                    cmocka_unit_test_setup_teardown(test_df2, setup_f, teardown_f),
                    cmocka_unit_test_setup_teardown(test_df3, setup_f, teardown_f),
                    cmocka_unit_test_setup_teardown(test_df4, setup_f, teardown_f),
                    cmocka_unit_test_setup_teardown(test_feature, setup_f, teardown_f), };

    return cmocka_run_group_tests(tests, NULL, NULL);
}
int main(void) {
	const struct CMUnitTest tests[] = {
		cmocka_unit_test_setup_teardown(
			test_objectSID_in_domain,
			setup,
			teardown),
		cmocka_unit_test_setup_teardown(
			test_objectSID_not_in_domain,
			setup,
			teardown),
		cmocka_unit_test_setup_teardown(
			test_no_objectSID,
			setup,
			teardown),
		cmocka_unit_test_setup_teardown(
			test_modify_no_objectSID,
			setup,
			teardown),
		cmocka_unit_test_setup_teardown(
			test_modify_of_objectSID_not_replicated,
			setup,
			teardown),
		cmocka_unit_test_setup_teardown(
			test_modify_of_objectSID_replicated,
			setup,
			teardown),
	};

	cmocka_set_message_output(CM_OUTPUT_SUBUNIT);
	return cmocka_run_group_tests(tests, NULL, NULL);
}
Example #28
0
int torture_run_tests(void) {
    int rc;
    struct CMUnitTest tests[] = {
        cmocka_unit_test_setup_teardown(torture_hostkey_rsa, session_setup,
                                        session_teardown),
        cmocka_unit_test_setup_teardown(torture_hostkey_ed25519, session_setup,
                                        session_teardown),
#ifdef HAVE_ECC
        cmocka_unit_test_setup_teardown(torture_hostkey_ecdsa, session_setup,
                                        session_teardown),
#endif
#ifdef HAVE_DSA
        cmocka_unit_test_setup_teardown(torture_hostkey_dss, session_setup,
                                        session_teardown),
#endif
        /* the client is able to handle SHA2 extension (if negotiated) */
        cmocka_unit_test_setup_teardown(torture_hostkey_rsa_sha256,
                                        session_setup, session_teardown),
        cmocka_unit_test_setup_teardown(torture_hostkey_rsa_sha512,
                                        session_setup, session_teardown),
    };

    ssh_init();

    torture_filter_tests(tests);
    rc = cmocka_run_group_tests(tests, sshd_setup, sshd_teardown);

    ssh_finalize();
    return rc;
}
Example #29
0
int torture_run_tests(void) {
    int rc;
    struct CMUnitTest tests[] = {
        cmocka_unit_test_setup_teardown(torture_knownhosts_export,
                                        session_setup,
                                        session_teardown),
        cmocka_unit_test_setup_teardown(torture_knownhosts_write_and_verify,
                                        session_setup,
                                        session_teardown),
        cmocka_unit_test_setup_teardown(torture_knownhosts_precheck,
                                        session_setup,
                                        session_teardown),
        cmocka_unit_test_setup_teardown(torture_knownhosts_other,
                                        session_setup,
                                        session_teardown),
        cmocka_unit_test_setup_teardown(torture_knownhosts_unknown,
                                        session_setup,
                                        session_teardown),
        cmocka_unit_test_setup_teardown(torture_knownhosts_conflict,
                                        session_setup,
                                        session_teardown),
    };

    ssh_init();

    torture_filter_tests(tests);
    rc = cmocka_run_group_tests(tests, sshd_group_setup, sshd_group_teardown);

    ssh_finalize();
    return rc;
}
Example #30
0
static void test_basic_blocks(void **state)
{
    uc_engine *uc = *state;
    uc_hook trace1, trace2;

#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, (uint64_t)1, (uint64_t)0));
    OK(uc_hook_add(uc, &trace2, UC_HOOK_BLOCK, test_basic_blocks_hook2, &bbtest, (uint64_t)1, (uint64_t)0));

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

int main(void)
{
    const struct CMUnitTest tests[] = {
        cmocka_unit_test_setup_teardown(test_basic_blocks, setup32, teardown),
    };
    return cmocka_run_group_tests(tests, NULL, NULL);
}