run.c File Reference

#include "rz_test.h"
#include <rz_cons.h>

Go to the source code of this file.

Macros
#define	crlf2lf(x)   (x)
#define	JQ_CMD   "jq"

Functions
static RzSubprocessOutput *	subprocess_runner (const char *file, const char *args[], size_t args_size, const char *envvars[], const char *envvals[], size_t env_size, ut64 timeout_ms, void *user)
static RzSubprocessOutput *	run_rz_test (RzTestRunConfig *config, ut64 timeout_ms, const char *cmds, RzList *files, RzList *extra_args, bool load_plugins, RzTestCmdRunner runner, void *user)
RZ_API RzSubprocessOutput *	rz_test_run_cmd_test (RzTestRunConfig *config, RzCmdTest *test, RzTestCmdRunner runner, void *user)
RZ_API bool	rz_test_cmp_cmd_output (const char *output, const char *expect, const char *regexp)
RZ_API bool	rz_test_check_cmd_test (RzSubprocessOutput *out, RzCmdTest *test)
RZ_API bool	rz_test_check_jq_available (void)
RZ_API RzSubprocessOutput *	rz_test_run_json_test (RzTestRunConfig *config, RzJsonTest *test, RzTestCmdRunner runner, void *user)
RZ_API bool	rz_test_check_json_test (RzSubprocessOutput *out, RzJsonTest *test)
RZ_API RzAsmTestOutput *	rz_test_run_asm_test (RzTestRunConfig *config, RzAsmTest *test)
RZ_API bool	rz_test_check_asm_test (RzAsmTestOutput *out, RzAsmTest *test)
RZ_API void	rz_test_asm_test_output_free (RzAsmTestOutput *out)
RZ_API RzSubprocessOutput *	rz_test_run_fuzz_test (RzTestRunConfig *config, RzFuzzTest *test, RzTestCmdRunner runner, void *user)
RZ_API bool	rz_test_check_fuzz_test (RzSubprocessOutput *out)
RZ_API char *	rz_test_test_name (RzTest *test)
RZ_API bool	rz_test_broken (RzTest *test)
RZ_API RzTestResultInfo *	rz_test_run_test (RzTestRunConfig *config, RzTest *test)
RZ_API void	rz_test_test_result_info_free (RzTestResultInfo *result)

Macro Definition Documentation

crlf2lf

#define crlf2lf

(

x

)

(x)

Definition at line 24 of file run.c.

JQ_CMD

#define JQ_CMD   "jq"

Definition at line 221 of file run.c.

Function Documentation

run_rz_test()

static RzSubprocessOutput* run_rz_test ( RzTestRunConfig *  config, ut64  timeout_ms, const char *  cmds, RzList *  files, RzList *  extra_args, bool  load_plugins, RzTestCmdRunner  runner, void *  user  )

static

Definition at line 113 of file run.c.

                                                                                                                                                                                             {
    RzPVector args;
    rz_pvector_init(&args, NULL);
    rz_pvector_push(&args, "-escr.utf8=0");
    rz_pvector_push(&args, "-escr.color=0");
    rz_pvector_push(&args, "-escr.interactive=0");
    rz_pvector_push(&args, "-N");
    RzListIter *it;
    void *extra_arg, *file_arg;
    rz_list_foreach (extra_args, it, extra_arg) {
        rz_pvector_push(&args, extra_arg);
    }
    rz_pvector_push(&args, "-Qc");
#if __WINDOWS__
    char *wcmds = convert_win_cmds(cmds);
    rz_pvector_push(&args, wcmds);
#else
    rz_pvector_push(&args, (void *)cmds);
#endif
    rz_list_foreach (files, it, file_arg) {
        rz_pvector_push(&args, file_arg);
    }
 
    const char *envvars[] = {
#if __WINDOWS__
        "ANSICON",
#endif
        "RZ_NOPLUGINS"
    };
    const char *envvals[] = {
#if __WINDOWS__
        "1",
#endif
        "1"
    };
#if __WINDOWS__
    size_t env_size = load_plugins ? 1 : 2;
#else
    size_t env_size = load_plugins ? 0 : 1;
#endif
    RzSubprocessOutput *out = runner(config->rz_cmd, args.v.a, rz_pvector_len(&args), envvars, envvals, env_size, timeout_ms, user);
    rz_pvector_clear(&args);
#if __WINDOWS__
    free(wcmds);
#endif
    return out;
}

References args, files, free(), NULL, out, rz_pvector_clear(), rz_pvector_init(), rz_pvector_len(), and rz_pvector_push().

Referenced by rz_test_run_cmd_test(), rz_test_run_fuzz_test(), and rz_test_run_json_test().

rz_test_asm_test_output_free()

RZ_API void rz_test_asm_test_output_free

(

RzAsmTestOutput *

out

)

Definition at line 422 of file run.c.

                                                               {
    if (!out) {
        return;
    }
    free(out->disasm);
    free(out->bytes);
    free(out->il);
    free(out->il_report);
    free(out);
}

References free(), and out.

Referenced by rz_test_test_result_info_free().

rz_test_broken()

RZ_API bool rz_test_broken

(

RzTest *

test

)

Definition at line 468 of file run.c.

                                         {
    switch (test->type) {
    case RZ_TEST_TYPE_CMD:
        return test->cmd_test->broken.value;
    case RZ_TEST_TYPE_ASM:
        return test->asm_test->mode & RZ_ASM_TEST_MODE_BROKEN ? true : false;
    case RZ_TEST_TYPE_JSON:
        return test->json_test->broken;
    case RZ_TEST_TYPE_FUZZ:
        return false;
    }
    return false;
}

References RZ_ASM_TEST_MODE_BROKEN, RZ_TEST_TYPE_ASM, RZ_TEST_TYPE_CMD, RZ_TEST_TYPE_FUZZ, RZ_TEST_TYPE_JSON, and true.

Referenced by rz_test_run_test().

rz_test_check_asm_test()

RZ_API bool rz_test_check_asm_test	(	RzAsmTestOutput *	out,
		RzAsmTest *	test
	)

Definition at line 389 of file run.c.

                                                                          {
    if (!out) {
        return false;
    }
    if (test->mode & RZ_ASM_TEST_MODE_ASSEMBLE) {
        if (!out->bytes || !test->bytes || out->bytes_size != test->bytes_size || out->as_timeout) {
            return false;
        }
        if (memcmp(out->bytes, test->bytes, test->bytes_size) != 0) {
            return false;
        }
    }
    if (test->mode & RZ_ASM_TEST_MODE_DISASSEMBLE) {
        if (!out->disasm || !test->disasm || out->as_timeout) {
            return false;
        }
        if (strcmp(out->disasm, test->disasm) != 0) {
            return false;
        }
    }
    if (test->il) {
        // expect some IL, no failure, no report and no timeout
        if (!out->il || out->il_failed || (out->il_report && *out->il_report) || out->il_timeout) {
            return false;
        }
        // IL must also be correct
        if (strcmp(out->il, test->il) != 0) {
            return false;
        }
    }
    return true;
}

References out, RZ_ASM_TEST_MODE_ASSEMBLE, and RZ_ASM_TEST_MODE_DISASSEMBLE.

Referenced by rz_test_run_test().

rz_test_check_cmd_test()

RZ_API bool rz_test_check_cmd_test	(	RzSubprocessOutput *	out,
		RzCmdTest *	test
	)

Definition at line 204 of file run.c.

                                                                             {
    if (!out || out->ret != 0 || !out->out || !out->err || out->timeout) {
        return false;
    }
    const char *expect_out = test->expect.value;
    const char *regexp_out = test->regexp_out.value;
    if (expect_out && !rz_test_cmp_cmd_output((char *)out->out, expect_out, regexp_out)) {
        return false;
    }
    const char *expect_err = test->expect_err.value;
    const char *regexp_err = test->regexp_err.value;
    if (expect_err && !rz_test_cmp_cmd_output((char *)out->err, expect_err, regexp_err)) {
        return false;
    }
    return true;
}

References out, and rz_test_cmp_cmd_output().

Referenced by rz_test_run_test().

rz_test_check_fuzz_test()

RZ_API bool rz_test_check_fuzz_test

(

RzSubprocessOutput *

out

)

Definition at line 447 of file run.c.

                                                             {
    return out && out->ret == 0 && out->out && out->err && !out->timeout;
}

References out.

Referenced by rz_test_run_test().

rz_test_check_jq_available()

RZ_API bool rz_test_check_jq_available

(

void

)

Definition at line 223 of file run.c.

                                             {
    const char *args[] = { "." };
    const char *invalid_json = "this is not json lol";
    RzSubprocess *proc = rz_subprocess_start(JQ_CMD, args, 1, NULL, NULL, 0);
    if (proc) {
        rz_subprocess_stdin_write(proc, (const ut8 *)invalid_json, strlen(invalid_json));
        rz_subprocess_wait(proc, UT64_MAX);
    }
    bool invalid_detected = proc && rz_subprocess_ret(proc) != 0;
    rz_subprocess_free(proc);
 
    const char *valid_json = "{\"this is\":\"valid json\",\"lol\":true}";
    proc = rz_subprocess_start(JQ_CMD, args, 1, NULL, NULL, 0);
    if (proc) {
        rz_subprocess_stdin_write(proc, (const ut8 *)valid_json, strlen(valid_json));
        rz_subprocess_wait(proc, UT64_MAX);
    }
    bool valid_detected = proc && rz_subprocess_ret(proc) == 0;
    rz_subprocess_free(proc);
 
    return invalid_detected && valid_detected;
}

References args, JQ_CMD, NULL, proc, rz_subprocess_free(), rz_subprocess_ret(), rz_subprocess_start(), rz_subprocess_stdin_write(), rz_subprocess_wait(), and UT64_MAX.

Referenced by rz_test_main().

rz_test_check_json_test()

RZ_API bool rz_test_check_json_test	(	RzSubprocessOutput *	out,
		RzJsonTest *	test
	)

Definition at line 254 of file run.c.

                                                                               {
    if (!out || out->ret != 0 || !out->out || !out->err || out->timeout) {
        return false;
    }
    const char *args[] = { "." };
    RzSubprocess *proc = rz_subprocess_start(JQ_CMD, args, 1, NULL, NULL, 0);
    rz_subprocess_stdin_write(proc, (const ut8 *)out->out, strlen((char *)out->out));
    rz_subprocess_wait(proc, UT64_MAX);
    bool ret = rz_subprocess_ret(proc) == 0;
    rz_subprocess_free(proc);
    return ret;
}

References args, JQ_CMD, NULL, out, proc, rz_subprocess_free(), rz_subprocess_ret(), rz_subprocess_start(), rz_subprocess_stdin_write(), rz_subprocess_wait(), and UT64_MAX.

Referenced by rz_test_run_test().

rz_test_cmp_cmd_output()

RZ_API bool rz_test_cmp_cmd_output	(	const char *	output,
		const char *	expect,
		const char *	regexp
	)

Definition at line 192 of file run.c.

                                                                                               {
    if (regexp) {
        RzList *matches = rz_regex_get_match_list(regexp, "e", output);
        const char *match = rz_list_to_str(matches, '\0');
        bool equal = (0 == strcmp(expect, match));
        rz_list_free(matches);
        RZ_FREE(match);
        return equal;
    }
    return (0 == strcmp(expect, output));
}

References expect, output, RZ_FREE, rz_list_free(), rz_list_to_str(), and rz_regex_get_match_list().

Referenced by print_result_diff(), and rz_test_check_cmd_test().

rz_test_run_asm_test()

RZ_API RzAsmTestOutput* rz_test_run_asm_test	(	RzTestRunConfig *	config,
		RzAsmTest *	test
	)

Definition at line 267 of file run.c.

                                                                                       {
    RzAsmTestOutput *out = RZ_NEW0(RzAsmTestOutput);
    if (!out) {
        return NULL;
    }
 
    RzPVector args;
    rz_pvector_init(&args, NULL);
 
    if (test->arch) {
        rz_pvector_push(&args, "-a");
        rz_pvector_push(&args, (void *)test->arch);
    }
 
    if (test->cpu) {
        rz_pvector_push(&args, "-c");
        rz_pvector_push(&args, (void *)test->cpu);
    }
 
    char bits[0x20];
    if (test->bits) {
        snprintf(bits, sizeof(bits), "%d", test->bits);
        rz_pvector_push(&args, "-b");
        rz_pvector_push(&args, bits);
    }
 
    if (test->mode & RZ_ASM_TEST_MODE_BIG_ENDIAN) {
        rz_pvector_push(&args, "-e");
    }
 
    char offset[0x20];
    if (test->offset) {
        rz_snprintf(offset, sizeof(offset), "0x%" PFMT64x, test->offset);
        rz_pvector_push(&args, "-o");
        rz_pvector_push(&args, offset);
    }
 
    if (test->mode & RZ_ASM_TEST_MODE_ASSEMBLE) {
        rz_pvector_push(&args, test->disasm);
        RzSubprocess *proc = rz_subprocess_start(config->rz_asm_cmd, args.v.a, rz_pvector_len(&args), NULL, NULL, 0);
        if (rz_subprocess_wait(proc, config->timeout_ms) == RZ_SUBPROCESS_TIMEDOUT) {
            rz_subprocess_kill(proc);
            out->as_timeout = true;
            goto rip;
        }
        if (rz_subprocess_ret(proc) != 0) {
            goto rip;
        }
        char *hex = (char *)crlf2lf(rz_subprocess_out(proc, NULL));
        size_t hexlen = strlen(hex);
        if (!hexlen) {
            goto rip;
        }
        ut8 *bytes = malloc(hexlen);
        int byteslen = rz_hex_str2bin(hex, bytes);
        free(hex);
        if (byteslen <= 0) {
            free(bytes);
            goto rip;
        }
        out->bytes = bytes;
        out->bytes_size = (size_t)byteslen;
    rip:
        rz_pvector_pop(&args);
        rz_subprocess_free(proc);
    }
    if (test->mode & RZ_ASM_TEST_MODE_DISASSEMBLE) {
        char *hex = rz_hex_bin2strdup(test->bytes, test->bytes_size);
        if (!hex) {
            goto beach;
        }
        rz_pvector_push(&args, "-d");
        rz_pvector_push(&args, hex);
        RzSubprocess *proc = rz_subprocess_start(config->rz_asm_cmd, args.v.a, rz_pvector_len(&args), NULL, NULL, 0);
        if (rz_subprocess_wait(proc, config->timeout_ms) == RZ_SUBPROCESS_TIMEDOUT) {
            rz_subprocess_kill(proc);
            out->disas_timeout = true;
            goto ship;
        }
        if (rz_subprocess_ret(proc) != 0) {
            goto ship;
        }
        char *disasm = (char *)crlf2lf(rz_subprocess_out(proc, NULL));
        rz_str_trim(disasm);
        out->disasm = disasm;
    ship:
        free(hex);
        rz_pvector_pop(&args);
        rz_pvector_pop(&args);
        rz_subprocess_free(proc);
    }
    if (test->il) {
        char *hex = rz_hex_bin2strdup(test->bytes, test->bytes_size);
        if (!hex) {
            goto beach;
        }
        rz_pvector_push(&args, "-I");
        rz_pvector_push(&args, hex);
        RzSubprocess *proc = rz_subprocess_start(config->rz_asm_cmd, args.v.a, rz_pvector_len(&args), NULL, NULL, 0);
        if (rz_subprocess_wait(proc, config->timeout_ms) == RZ_SUBPROCESS_TIMEDOUT) {
            rz_subprocess_kill(proc);
            out->il_timeout = true;
        } else {
            char *il = (char *)crlf2lf(rz_subprocess_out(proc, NULL));
            rz_str_trim(il);
            char *il_err = (char *)crlf2lf(rz_subprocess_err(proc, NULL));
            rz_str_trim(il_err);
            out->il = il;
            out->il_report = il_err;
            out->il_failed = rz_subprocess_ret(proc) != 0;
        }
        free(hex);
        rz_pvector_pop(&args);
        rz_pvector_pop(&args);
        rz_subprocess_free(proc);
    }
 
beach:
    rz_pvector_clear(&args);
    return out;
}

References args, bits(), bytes, crlf2lf, free(), hex, malloc(), NULL, out, PFMT64x, proc, rip(), RZ_ASM_TEST_MODE_ASSEMBLE, RZ_ASM_TEST_MODE_BIG_ENDIAN, RZ_ASM_TEST_MODE_DISASSEMBLE, rz_hex_bin2strdup(), rz_hex_str2bin(), RZ_NEW0, rz_pvector_clear(), rz_pvector_init(), rz_pvector_len(), rz_pvector_pop(), rz_pvector_push(), rz_snprintf(), rz_str_trim(), rz_subprocess_err(), rz_subprocess_free(), rz_subprocess_kill(), rz_subprocess_out(), rz_subprocess_ret(), rz_subprocess_start(), RZ_SUBPROCESS_TIMEDOUT, rz_subprocess_wait(), and snprintf.

Referenced by rz_test_run_test().

rz_test_run_cmd_test()

RZ_API RzSubprocessOutput* rz_test_run_cmd_test	(	RzTestRunConfig *	config,
		RzCmdTest *	test,
		RzTestCmdRunner	runner,
		void *	user
	)

Definition at line 161 of file run.c.

                                                                                                                              {
    RzList *extra_args = test->args.value ? rz_str_split_duplist(test->args.value, " ", true) : NULL;
    RzList *files = test->file.value ? rz_str_split_duplist(test->file.value, "\n", true) : NULL;
    RzListIter *it;
    RzListIter *tmpit;
    char *token;
    rz_list_foreach_safe (extra_args, it, tmpit, token) {
        if (!*token) {
            rz_list_delete(extra_args, it);
        }
    }
    rz_list_foreach_safe (files, it, tmpit, token) {
        if (!*token) {
            rz_list_delete(files, it);
        }
    }
    if (rz_list_empty(files)) {
        if (!files) {
            files = rz_list_new();
        } else {
            files->free = NULL;
        }
        rz_list_push(files, "=");
    }
    ut64 timeout_ms = test->timeout.set ? test->timeout.value * 1000 : config->timeout_ms;
    RzSubprocessOutput *out = run_rz_test(config, timeout_ms, test->cmds.value, files, extra_args, test->load_plugins, runner, user);
    rz_list_free(extra_args);
    rz_list_free(files);
    return out;
}

References files, NULL, out, run_rz_test(), rz_list_delete(), rz_list_free(), rz_list_new(), rz_list_push(), rz_str_split_duplist(), and ut64().

Referenced by print_result_diff(), and rz_test_run_test().

rz_test_run_fuzz_test()

RZ_API RzSubprocessOutput* rz_test_run_fuzz_test	(	RzTestRunConfig *	config,
		RzFuzzTest *	test,
		RzTestCmdRunner	runner,
		void *	user
	)

Definition at line 433 of file run.c.

                                                                                                                                {
    const char *cmd = "aaa";
    RzList *files = rz_list_new();
    rz_list_push(files, test->file);
#if ASAN
    if (rz_str_endswith(test->file, "/swift_read")) {
        cmd = "?F";
    }
#endif
    RzSubprocessOutput *ret = run_rz_test(config, config->timeout_ms, cmd, files, NULL, false, runner, user);
    rz_list_free(files);
    return ret;
}

References cmd, files, NULL, run_rz_test(), rz_list_free(), rz_list_new(), rz_list_push(), and rz_str_endswith().

Referenced by print_result_diff(), and rz_test_run_test().

rz_test_run_json_test()

RZ_API RzSubprocessOutput* rz_test_run_json_test	(	RzTestRunConfig *	config,
		RzJsonTest *	test,
		RzTestCmdRunner	runner,
		void *	user
	)

Definition at line 246 of file run.c.

                                                                                                                                {
    RzList *files = rz_list_new();
    rz_list_push(files, (void *)config->json_test_file);
    RzSubprocessOutput *ret = run_rz_test(config, config->timeout_ms, test->cmd, files, NULL, test->load_plugins, runner, user);
    rz_list_free(files);
    return ret;
}

References files, NULL, run_rz_test(), rz_list_free(), rz_list_new(), and rz_list_push().

Referenced by rz_test_run_test().

rz_test_run_test()

RZ_API RzTestResultInfo* rz_test_run_test	(	RzTestRunConfig *	config,
		RzTest *	test
	)

Definition at line 482 of file run.c.

                                                                                 {
    RzTestResultInfo *ret = RZ_NEW0(RzTestResultInfo);
    if (!ret) {
        return NULL;
    }
    ret->test = test;
    bool success = false;
    ut64 start_time = rz_time_now_mono();
    switch (test->type) {
    case RZ_TEST_TYPE_CMD: {
        RzCmdTest *cmd_test = test->cmd_test;
        RzSubprocessOutput *out = rz_test_run_cmd_test(config, cmd_test, subprocess_runner, NULL);
        success = rz_test_check_cmd_test(out, cmd_test);
        ret->proc_out = out;
        ret->timeout = out && out->timeout;
        ret->run_failed = !out;
        break;
    }
    case RZ_TEST_TYPE_ASM: {
        RzAsmTest *asm_test = test->asm_test;
        RzAsmTestOutput *out = rz_test_run_asm_test(config, asm_test);
        success = rz_test_check_asm_test(out, asm_test);
        ret->asm_out = out;
        if (out) {
            ret->timeout = out->as_timeout || out->disas_timeout || out->il_timeout;
        }
        ret->run_failed = !out;
        break;
    }
    case RZ_TEST_TYPE_JSON: {
        RzJsonTest *json_test = test->json_test;
        RzSubprocessOutput *out = rz_test_run_json_test(config, json_test, subprocess_runner, NULL);
        success = rz_test_check_json_test(out, json_test);
        ret->proc_out = out;
        if (out) {
            ret->timeout = out->timeout;
        }
        ret->run_failed = !out;
        break;
    }
    case RZ_TEST_TYPE_FUZZ: {
        RzFuzzTest *fuzz_test = test->fuzz_test;
        RzSubprocessOutput *out = rz_test_run_fuzz_test(config, fuzz_test, subprocess_runner, NULL);
        success = rz_test_check_fuzz_test(out);
        ret->proc_out = out;
        if (out) {
            ret->timeout = out->timeout;
        }
        ret->run_failed = !out;
    }
    }
    ret->time_elapsed = rz_time_now_mono() - start_time;
    bool broken = rz_test_broken(test);
#if ASAN
#if !RZ_ASSERT_STDOUT
#error RZ_ASSERT_STDOUT undefined or 0
#endif
    RzSubprocessOutput *out = ret->proc_out;
    if (!success && test->type == RZ_TEST_TYPE_CMD && strstr(test->path, "/dbg") && (!out->out || (!strstr((char *)out->out, "WARNING:") && !strstr((char *)out->out, "ERROR:") && !strstr((char *)out->out, "FATAL:"))) && (!out->err || (!strstr((char *)out->err, "Sanitizer") && !strstr((char *)out->err, "runtime error:")))) {
        broken = true;
    }
#endif
    if (!success) {
        ret->result = broken ? RZ_TEST_RESULT_BROKEN : RZ_TEST_RESULT_FAILED;
    } else {
        ret->result = broken ? RZ_TEST_RESULT_FIXED : RZ_TEST_RESULT_OK;
    }
    return ret;
}

References rz_test_test_result_info_t::asm_out, NULL, out, rz_test_test_result_info_t::proc_out, rz_test_test_result_info_t::result, rz_test_test_result_info_t::run_failed, RZ_NEW0, rz_test_broken(), rz_test_check_asm_test(), rz_test_check_cmd_test(), rz_test_check_fuzz_test(), rz_test_check_json_test(), RZ_TEST_RESULT_BROKEN, RZ_TEST_RESULT_FAILED, RZ_TEST_RESULT_FIXED, RZ_TEST_RESULT_OK, rz_test_run_asm_test(), rz_test_run_cmd_test(), rz_test_run_fuzz_test(), rz_test_run_json_test(), RZ_TEST_TYPE_ASM, RZ_TEST_TYPE_CMD, RZ_TEST_TYPE_FUZZ, RZ_TEST_TYPE_JSON, rz_time_now_mono(), start_time, subprocess_runner(), rz_test_test_result_info_t::test, test_customized_mnem::test(), rz_test_test_result_info_t::time_elapsed, rz_test_test_result_info_t::timeout, and ut64().

Referenced by worker_th().

rz_test_test_name()

RZ_API char* rz_test_test_name

(

RzTest *

test

)

Definition at line 451 of file run.c.

                                             {
    switch (test->type) {
    case RZ_TEST_TYPE_CMD:
        if (test->cmd_test->name.value) {
            return strdup(test->cmd_test->name.value);
        }
        return strdup("<unnamed>");
    case RZ_TEST_TYPE_ASM:
        return rz_str_newf("<asm> %s", test->asm_test->disasm ? test->asm_test->disasm : "");
    case RZ_TEST_TYPE_JSON:
        return rz_str_newf("<json> %s", test->json_test->cmd ? test->json_test->cmd : "");
    case RZ_TEST_TYPE_FUZZ:
        return rz_str_newf("<fuzz> %s", test->fuzz_test->file);
    }
    return NULL;
}

References NULL, rz_str_newf(), RZ_TEST_TYPE_ASM, RZ_TEST_TYPE_CMD, RZ_TEST_TYPE_FUZZ, RZ_TEST_TYPE_JSON, and strdup().

Referenced by print_new_results().

rz_test_test_result_info_free()

RZ_API void rz_test_test_result_info_free

(

RzTestResultInfo *

result

)

Definition at line 552 of file run.c.

                                                                    {
    if (!result) {
        return;
    }
    if (result->test) {
        switch (result->test->type) {
        case RZ_TEST_TYPE_CMD:
        case RZ_TEST_TYPE_JSON:
        case RZ_TEST_TYPE_FUZZ:
            rz_subprocess_output_free(result->proc_out);
            break;
        case RZ_TEST_TYPE_ASM:
            rz_test_asm_test_output_free(result->asm_out);
            break;
        }
    }
    free(result);
}

References rz_test_test_result_info_t::asm_out, free(), rz_test_test_result_info_t::proc_out, rz_subprocess_output_free(), rz_test_asm_test_output_free(), RZ_TEST_TYPE_ASM, RZ_TEST_TYPE_CMD, RZ_TEST_TYPE_FUZZ, RZ_TEST_TYPE_JSON, rz_test_test_result_info_t::test, and rz_test_test_t::type.

Referenced by rz_test_main().

subprocess_runner()

static RzSubprocessOutput* subprocess_runner ( const char *  file, const char *  args[], size_t  args_size, const char *  envvars[], const char *  envvals[], size_t  env_size, ut64  timeout_ms, void *  user  )

static

Definition at line 27 of file run.c.

                                                                                                {
    RzSubprocess *proc = rz_subprocess_start(file, args, args_size, envvars, envvals, env_size);
    if (!proc) {
        return NULL;
    }
    RzSubprocessWaitReason r = rz_subprocess_wait(proc, timeout_ms);
    if (r == RZ_SUBPROCESS_TIMEDOUT) {
        rz_subprocess_kill(proc);
    }
    RzSubprocessOutput *out = rz_subprocess_drain(proc);
    if (out) {
        out->timeout = r == RZ_SUBPROCESS_TIMEDOUT;
        out->out = crlf2lf(out->out);
        out->err = crlf2lf(out->err);
    }
    rz_subprocess_free(proc);
    return out;
}

References args, crlf2lf, NULL, out, proc, r, rz_subprocess_drain(), rz_subprocess_free(), rz_subprocess_kill(), rz_subprocess_start(), RZ_SUBPROCESS_TIMEDOUT, and rz_subprocess_wait().

Referenced by rz_test_run_test().