rz_test.h File Reference

#include <rz_util.h>

Go to the source code of this file.

Classes
struct	rz_test_cmd_test_string_record
struct	rz_test_cmd_test_bool_record
struct	rz_test_cmd_test_num_record
struct	rz_test_cmd_test_t
struct	rz_test_asm_test_t
struct	rz_test_json_test_t
struct	rz_test_fuzz_test_t
struct	rz_test_test_t
struct	rz_test_test_database_t
struct	rz_test_run_config_t
struct	rz_test_asm_test_output_t
struct	rz_test_test_result_info_t

Macros
#define	RZ_TEST_OS   "unknown"
#define	RZ_TEST_ARCH   "unknown"
#define	RZ_TEST_ARCH_OS   RZ_TEST_OS "-" RZ_TEST_ARCH
#define	RZ_CMD_TEST_FOREACH_RECORD_NOP(name, field)
#define	RZ_CMD_TEST_FOREACH_RECORD(macro_str, macro_bool, macro_int)

Typedefs
typedef struct rz_test_cmd_test_string_record	RzCmdTestStringRecord
typedef struct rz_test_cmd_test_bool_record	RzCmdTestBoolRecord
typedef struct rz_test_cmd_test_num_record	RzCmdTestNumRecord
typedef struct rz_test_cmd_test_t	RzCmdTest
typedef enum rz_test_asm_test_mode_t	RzAsmTestMode
typedef struct rz_test_asm_test_t	RzAsmTest
typedef struct rz_test_json_test_t	RzJsonTest
typedef struct rz_test_fuzz_test_t	RzFuzzTest
typedef enum rz_test_test_type_t	RzTestType
typedef struct rz_test_test_t	RzTest
typedef struct rz_test_test_database_t	RzTestDatabase
typedef struct rz_test_run_config_t	RzTestRunConfig
typedef struct rz_test_asm_test_output_t	RzAsmTestOutput
typedef enum rz_test_test_result_t	RzTestResult
typedef struct rz_test_test_result_info_t	RzTestResultInfo
typedef RzSubprocessOutput *(*	RzTestCmdRunner) (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)

Enumerations
enum	rz_test_asm_test_mode_t { RZ_ASM_TEST_MODE_ASSEMBLE = 1 , RZ_ASM_TEST_MODE_DISASSEMBLE = (1 << 1) , RZ_ASM_TEST_MODE_BIG_ENDIAN = (1 << 2) , RZ_ASM_TEST_MODE_BROKEN = (1 << 3) }
enum	rz_test_test_type_t { RZ_TEST_TYPE_CMD , RZ_TEST_TYPE_ASM , RZ_TEST_TYPE_JSON , RZ_TEST_TYPE_FUZZ }
enum	rz_test_test_result_t { RZ_TEST_RESULT_OK , RZ_TEST_RESULT_FAILED , RZ_TEST_RESULT_BROKEN , RZ_TEST_RESULT_FIXED }

Functions
RZ_API RzCmdTest *	rz_test_cmd_test_new (void)
RZ_API void	rz_test_cmd_test_free (RzCmdTest *test)
RZ_API RzPVector *	rz_test_load_cmd_test_file (const char *file)
RZ_API RzAsmTest *	rz_test_asm_test_new (void)
RZ_API void	rz_test_asm_test_free (RzAsmTest *test)
RZ_API RzPVector *	rz_test_load_asm_test_file (RzStrConstPool *strpool, const char *file)
RZ_API RzJsonTest *	rz_test_json_test_new (void)
RZ_API void	rz_test_json_test_free (RzJsonTest *test)
RZ_API RzPVector *	rz_test_load_json_test_file (const char *file)
RZ_API RzTestDatabase *	rz_test_test_database_new (void)
RZ_API void	rz_test_test_database_free (RzTestDatabase *db)
RZ_API bool	rz_test_test_database_load (RzTestDatabase *db, const char *path)
RZ_API bool	rz_test_test_database_load_fuzz (RzTestDatabase *db, const char *path)
RZ_API RzSubprocessOutput *	rz_test_run_cmd_test (RzTestRunConfig *config, RzCmdTest *test, RzTestCmdRunner runner, void *user)
RZ_API bool	rz_test_check_cmd_test (RzSubprocessOutput *out, RzCmdTest *test)
RZ_API bool	rz_test_cmp_cmd_output (const char *output, const char *expect, const char *regexp)
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 void	rz_test_test_free (RzTest *test)
RZ_API char *	rz_test_test_name (RzTest *test)
RZ_API bool	rz_test_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

RZ_CMD_TEST_FOREACH_RECORD

#define RZ_CMD_TEST_FOREACH_RECORD	(		macro_str,
			macro_bool,
			macro_int
	)

Value:

    macro_str ("NAME", name) \
    macro_str ("FILE", file) \
    macro_str ("ARGS", args) \
    macro_int ("TIMEOUT", timeout) \
    macro_str ("SOURCE", source) \
    macro_str ("CMDS", cmds) \
    macro_str ("EXPECT", expect) \
    macro_str ("EXPECT_ERR", expect_err) \
    macro_str ("REGEXP_FILTER_OUT", regexp_out) \
    macro_str ("REGEXP_FILTER_ERR", regexp_err) \
    macro_bool ("BROKEN", broken)

Definition at line 74 of file rz_test.h.

RZ_CMD_TEST_FOREACH_RECORD_NOP

#define RZ_CMD_TEST_FOREACH_RECORD_NOP	(		name,
			field
	)

Definition at line 73 of file rz_test.h.

RZ_TEST_ARCH

#define RZ_TEST_ARCH   "unknown"

Definition at line 30 of file rz_test.h.

RZ_TEST_ARCH_OS

#define RZ_TEST_ARCH_OS   RZ_TEST_OS "-" RZ_TEST_ARCH

Definition at line 33 of file rz_test.h.

RZ_TEST_OS

#define RZ_TEST_OS   "unknown"

Definition at line 18 of file rz_test.h.

Typedef Documentation

RzAsmTest

typedef struct rz_test_asm_test_t RzAsmTest

RzAsmTestMode

typedef enum rz_test_asm_test_mode_t RzAsmTestMode

RzAsmTestOutput

typedef struct rz_test_asm_test_output_t RzAsmTestOutput

RzCmdTest

typedef struct rz_test_cmd_test_t RzCmdTest

RzCmdTestBoolRecord

typedef struct rz_test_cmd_test_bool_record RzCmdTestBoolRecord

RzCmdTestNumRecord

typedef struct rz_test_cmd_test_num_record RzCmdTestNumRecord

RzCmdTestStringRecord

typedef struct rz_test_cmd_test_string_record RzCmdTestStringRecord

RzFuzzTest

typedef struct rz_test_fuzz_test_t RzFuzzTest

RzJsonTest

typedef struct rz_test_json_test_t RzJsonTest

RzTest

typedef struct rz_test_test_t RzTest

RzTestCmdRunner

typedef RzSubprocessOutput*(* RzTestCmdRunner) (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)

Definition at line 197 of file rz_test.h.

RzTestDatabase

typedef struct rz_test_test_database_t RzTestDatabase

RzTestResult

typedef enum rz_test_test_result_t RzTestResult

RzTestResultInfo

typedef struct rz_test_test_result_info_t RzTestResultInfo

RzTestRunConfig

typedef struct rz_test_run_config_t RzTestRunConfig

RzTestType

typedef enum rz_test_test_type_t RzTestType

Enumeration Type Documentation

rz_test_asm_test_mode_t

enum rz_test_asm_test_mode_t

Enumerator
RZ_ASM_TEST_MODE_ASSEMBLE
RZ_ASM_TEST_MODE_DISASSEMBLE
RZ_ASM_TEST_MODE_BIG_ENDIAN
RZ_ASM_TEST_MODE_BROKEN

Definition at line 88 of file rz_test.h.

                                     {
    RZ_ASM_TEST_MODE_ASSEMBLE = 1,
    RZ_ASM_TEST_MODE_DISASSEMBLE = (1 << 1),
    RZ_ASM_TEST_MODE_BIG_ENDIAN = (1 << 2),
    RZ_ASM_TEST_MODE_BROKEN = (1 << 3)
} RzAsmTestMode;

rz_test_test_result_t

enum rz_test_test_result_t

Enumerator
RZ_TEST_RESULT_OK
RZ_TEST_RESULT_FAILED
RZ_TEST_RESULT_BROKEN
RZ_TEST_RESULT_FIXED

Definition at line 161 of file rz_test.h.

                                   {
    RZ_TEST_RESULT_OK,
    RZ_TEST_RESULT_FAILED,
    RZ_TEST_RESULT_BROKEN,
    RZ_TEST_RESULT_FIXED
} RzTestResult;

rz_test_test_type_t

enum rz_test_test_type_t

Enumerator
RZ_TEST_TYPE_CMD
RZ_TEST_TYPE_ASM
RZ_TEST_TYPE_JSON
RZ_TEST_TYPE_FUZZ

Definition at line 119 of file rz_test.h.

                                 {
    RZ_TEST_TYPE_CMD,
    RZ_TEST_TYPE_ASM,
    RZ_TEST_TYPE_JSON,
    RZ_TEST_TYPE_FUZZ
} RzTestType;

Function Documentation

rz_test_asm_test_free()

RZ_API void rz_test_asm_test_free

(

RzAsmTest *

test

)

Definition at line 263 of file load.c.

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

References free().

Referenced by rz_test_test_free().

rz_test_asm_test_new()

RZ_API RzAsmTest* rz_test_asm_test_new

(

void

)

Definition at line 259 of file load.c.

                                             {
    return RZ_NEW0(RzAsmTest);
}

References RZ_NEW0.

Referenced by rz_test_load_asm_test_file().

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_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_cmd_test_free()

RZ_API void rz_test_cmd_test_free

(

RzCmdTest *

test

)

Definition at line 14 of file load.c.

                                                   {
    if (!test) {
        return;
    }
#define DO_KEY_STR(key, field) free(test->field.value);
    RZ_CMD_TEST_FOREACH_RECORD(DO_KEY_STR, RZ_CMD_TEST_FOREACH_RECORD_NOP, RZ_CMD_TEST_FOREACH_RECORD_NOP)
#undef DO_KEY_STR
    free(test);
}

References DO_KEY_STR, free(), RZ_CMD_TEST_FOREACH_RECORD, and RZ_CMD_TEST_FOREACH_RECORD_NOP.

Referenced by rz_test_load_cmd_test_file(), and rz_test_test_free().

rz_test_cmd_test_new()

RZ_API RzCmdTest* rz_test_cmd_test_new

(

void

)

Definition at line 10 of file load.c.

                                             {
    return RZ_NEW0(RzCmdTest);
}

References RZ_NEW0.

Referenced by rz_test_load_cmd_test_file().

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_json_test_free()

RZ_API void rz_test_json_test_free

(

RzJsonTest *

test

)

Definition at line 474 of file load.c.

                                                     {
    if (!test) {
        return;
    }
    free(test->cmd);
    free(test);
}

References free().

Referenced by rz_test_load_json_test_file(), and rz_test_test_free().

rz_test_json_test_new()

RZ_API RzJsonTest* rz_test_json_test_new

(

void

)

Definition at line 470 of file load.c.

                                               {
    return RZ_NEW0(RzJsonTest);
}

References RZ_NEW0.

Referenced by rz_test_load_json_test_file().

rz_test_load_asm_test_file()

RZ_API RzPVector* rz_test_load_asm_test_file	(	RzStrConstPool *	strpool,
		const char *	file
	)

Definition at line 313 of file load.c.

                                                                                        {
    const char *arch;
    const char *cpu;
    int bits;
    if (!parse_asm_path(file, strpool, &arch, &cpu, &bits)) {
        eprintf("Failed to parse arch/cpu/bits from path %s\n", file);
        return NULL;
    }
 
    char *contents = rz_file_slurp(file, NULL);
    if (!contents) {
        eprintf("Failed to open file \"%s\"\n", file);
        return NULL;
    }
 
    RzPVector *ret = rz_pvector_new(NULL);
    if (!ret) {
        return NULL;
    }
 
    ut64 linenum = 0;
    char *line = contents;
    size_t linesz;
    char *nextline;
    do {
        nextline = readline(line, &linesz);
        linenum++;
        if (!linesz) {
            continue;
        }
        if (*line == '#') {
            continue;
        }
 
        // mode flags
        int mode = 0;
        while (*line && *line != ' ') {
            switch (*line) {
            case 'a':
                mode |= RZ_ASM_TEST_MODE_ASSEMBLE;
                break;
            case 'd':
                mode |= RZ_ASM_TEST_MODE_DISASSEMBLE;
                break;
            case 'E':
                mode |= RZ_ASM_TEST_MODE_BIG_ENDIAN;
                break;
            case 'B':
                mode |= RZ_ASM_TEST_MODE_BROKEN;
                break;
            default:
                eprintf(LINEFMT "Warning: Invalid mode char '%c'\n", file, linenum, *line);
                goto fail;
            }
            line++;
        }
        if (!(mode & RZ_ASM_TEST_MODE_ASSEMBLE) && !(mode & RZ_ASM_TEST_MODE_DISASSEMBLE)) {
            eprintf(LINEFMT "Warning: Mode specifies neither assemble nor disassemble.\n", file, linenum);
            continue;
        }
 
        // disasm
        char *disasm = strchr(line, '"');
        if (!disasm) {
            eprintf(LINEFMT "Error: Expected \" to begin disassembly.\n", file, linenum);
            goto fail;
        }
        disasm++;
        char *hex = strchr(disasm, '"');
        if (!hex) {
            eprintf(LINEFMT "Error: Expected \" to end disassembly.\n", file, linenum);
            goto fail;
        }
        *hex = '\0';
        hex++;
        rz_str_trim(disasm);
 
        // hex
        while (*hex && *hex == ' ') {
            hex++;
        }
 
        // remove comment at the end of the line
        char *latecmt = strchr(hex, '#');
        if (latecmt) {
            *latecmt = '\0';
        }
 
        // offset (optional)
        char *offset = strchr(hex, ' ');
        char *il = NULL;
        if (offset) {
            *offset = '\0';
            offset++;
 
            // IL (optional, the entire rest)
            il = strchr(offset, ' ');
            if (il) {
                *il = '\0';
                il++;
            }
        }
 
        size_t hexlen = strlen(hex);
        if (!hexlen) {
            eprintf(LINEFMT "Error: Expected hex chars.\n", file, linenum);
            goto fail;
        }
        ut8 *bytes = malloc(hexlen);
        if (!bytes) {
            break;
        }
        int bytesz = rz_hex_str2bin(hex, bytes);
        if (bytesz == 0) {
            eprintf(LINEFMT "Error: Expected hex chars.\n", file, linenum);
            free(bytes);
            goto fail;
        }
        if (bytesz < 0) {
            eprintf(LINEFMT "Error: Odd number of hex chars: %s\n", file, linenum, hex);
            free(bytes);
            goto fail;
        }
 
        RzAsmTest *test = rz_test_asm_test_new();
        if (!test) {
            free(bytes);
            goto fail;
        }
        test->line = linenum;
        test->bits = bits;
        test->arch = arch;
        test->cpu = cpu;
        test->mode = mode;
        char *endptr = NULL;
        test->offset = offset ? (ut64)strtoull(offset, &endptr, 0) : 0;
        if (endptr && *endptr) {
            eprintf(LINEFMT "Error: Invalid offset string: \"%s\"\n", file, linenum, offset);
            free(bytes);
            goto fail;
        }
        test->disasm = strdup(disasm);
        test->bytes = bytes;
        test->bytes_size = (size_t)bytesz;
        test->il = il ? strdup(il) : NULL;
        rz_pvector_push(ret, test);
    } while ((line = nextline));
 
beach:
    free(contents);
    return ret;
fail:
    rz_pvector_free(ret);
    ret = NULL;
    goto beach;
}

References arch, bits(), bytes, cpu, eprintf, fail, free(), hex, setup::line, LINEFMT, malloc(), NULL, parse_asm_path(), readline(), RZ_ASM_TEST_MODE_ASSEMBLE, RZ_ASM_TEST_MODE_BIG_ENDIAN, RZ_ASM_TEST_MODE_BROKEN, RZ_ASM_TEST_MODE_DISASSEMBLE, rz_file_slurp(), rz_hex_str2bin(), rz_pvector_free(), rz_pvector_new(), rz_pvector_push(), rz_str_trim(), rz_test_asm_test_new(), strdup(), and ut64().

Referenced by database_load().

rz_test_load_cmd_test_file()

RZ_API RzPVector* rz_test_load_cmd_test_file

(

const char *

file

)

Definition at line 105 of file load.c.

                                                               {
    char *contents = rz_file_slurp(file, NULL);
    if (!contents) {
        eprintf("Failed to open file \"%s\"\n", file);
        return NULL;
    }
 
    RzPVector *ret = rz_pvector_new(NULL);
    if (!ret) {
        free(contents);
        return NULL;
    }
    RzCmdTest *test = rz_test_cmd_test_new();
    if (!test) {
        free(contents);
        rz_pvector_free(ret);
        return NULL;
    }
 
    ut64 linenum = 0;
    char *line = contents;
    size_t linesz;
    char *nextline;
    do {
        nextline = readline(line, &linesz);
        linenum++;
        if (!linesz) {
            continue;
        }
        if (*line == '#') {
            continue;
        }
 
        char *val = strchr(line, '=');
        if (val) {
            *val = '\0';
            val++;
        } else if (!val && !(strcmp(line, "RUN") == 0)) {
            eprintf("Error: No value for key \"%s\".\n", line);
            goto fail;
        }
 
        // RUN is the only cmd without value
        if (strcmp(line, "RUN") == 0) {
            test->run_line = linenum;
            if (!test->cmds.value) {
                eprintf(LINEFMT "Error: Test without CMDS key\n", file, linenum);
                goto fail;
            }
            if (!(test->expect.value || test->expect_err.value)) {
                eprintf(LINEFMT "Error: Test without EXPECT or EXPECT_ERR key"
                        " (did you forget an EOF?)\n",
                    file, linenum);
                goto fail;
            }
            rz_pvector_push(ret, test);
            test = rz_test_cmd_test_new();
            if (!test) {
                goto beach;
            }
            continue;
        }
 
#define DO_KEY_STR(key, field) \
    if (strcmp(line, key) == 0) { \
        if (test->field.value) { \
            free(test->field.value); \
            eprintf(LINEFMT "Warning: Duplicate key \"%s\"\n", file, linenum, key); \
        } \
        test->field.line_begin = linenum; \
        test->field.value = read_string_val(&nextline, val, &linenum); \
        test->field.line_end = linenum + 1; \
        if (!test->field.value) { \
            eprintf(LINEFMT "Error: Failed to read value for key \"%s\"\n", file, linenum, key); \
            goto fail; \
        } \
        continue; \
    }
 
#define DO_KEY_BOOL(key, field) \
    if (strcmp(line, key) == 0) { \
        if (test->field.value) { \
            eprintf(LINEFMT "Warning: Duplicate key \"%s\"\n", file, linenum, key); \
        } \
        test->field.set = true; \
        /* Strip comment */ \
        char *cmt = strchr(val, '#'); \
        if (cmt) { \
            *cmt = '\0'; \
            cmt--; \
            while (cmt > val && *cmt == ' ') { \
                *cmt = '\0'; \
                cmt--; \
            } \
        } \
        if (!strcmp(val, "1")) { \
            test->field.value = true; \
        } else if (!strcmp(val, "0")) { \
            test->field.value = false; \
        } else { \
            eprintf(LINEFMT "Error: Invalid value \"%s\" for boolean key \"%s\", only \"1\" or \"0\" allowed.\n", file, linenum, val, key); \
            goto fail; \
        } \
        continue; \
    }
 
#define DO_KEY_NUM(key, field) \
    if (strcmp(line, key) == 0) { \
        if (test->field.value) { \
            eprintf(LINEFMT "Warning: Duplicate key \"%s\"\n", file, linenum, key); \
        } \
        test->field.set = true; \
        /* Strip comment */ \
        char *cmt = strchr(val, '#'); \
        if (cmt) { \
            *cmt = '\0'; \
            cmt--; \
            while (cmt > val && *cmt == ' ') { \
                *cmt = '\0'; \
                cmt--; \
            } \
        } \
        char *endval; \
        test->field.value = strtol(val, &endval, 0); \
        if (!endval || *endval) { \
            eprintf(LINEFMT "Error: Invalid value \"%s\" for numeric key \"%s\", only numbers allowed.\n", file, linenum, val, key); \
            goto fail; \
        } \
        continue; \
    }
 
        RZ_CMD_TEST_FOREACH_RECORD(DO_KEY_STR, DO_KEY_BOOL, DO_KEY_NUM)
#undef DO_KEY_STR
#undef DO_KEY_BOOL
#undef DO_KEY_NUM
 
        eprintf(LINEFMT "Unknown key \"%s\".\n", file, linenum, line);
    } while ((line = nextline));
beach:
    free(contents);
 
    if (test && (test->name.value || test->cmds.value || test->expect.value)) {
        eprintf("Warning: found test tokens at the end of \"%s\" without RUN.\n", file);
    }
    rz_test_cmd_test_free(test);
    return ret;
fail:
    rz_test_cmd_test_free(test);
    test = NULL;
    rz_pvector_free(ret);
    ret = NULL;
    goto beach;
}

References DO_KEY_BOOL, DO_KEY_NUM, DO_KEY_STR, eprintf, fail, free(), setup::line, LINEFMT, NULL, readline(), RZ_CMD_TEST_FOREACH_RECORD, rz_file_slurp(), rz_pvector_free(), rz_pvector_new(), rz_pvector_push(), rz_test_cmd_test_free(), rz_test_cmd_test_new(), ut64(), and val.

Referenced by database_load().

rz_test_load_json_test_file()

RZ_API RzPVector* rz_test_load_json_test_file

(

const char *

file

)

Definition at line 482 of file load.c.

                                                                {
    char *contents = rz_file_slurp(file, NULL);
    if (!contents) {
        eprintf("Failed to open file \"%s\"\n", file);
        return NULL;
    }
 
    RzPVector *ret = rz_pvector_new(NULL);
    if (!ret) {
        free(contents);
        return NULL;
    }
 
    ut64 linenum = 0;
    char *line = contents;
    size_t linesz;
    char *nextline;
    do {
        nextline = readline(line, &linesz);
        linenum++;
        if (!linesz) {
            continue;
        }
        if (*line == '#') {
            continue;
        }
 
        char *broken_token = strstr(line, "BROKEN");
        if (broken_token) {
            *broken_token = '\0';
        }
 
        rz_str_trim(line);
        if (!*line) {
            // empty line
            continue;
        }
 
        RzJsonTest *test = rz_test_json_test_new();
        if (!test) {
            break;
        }
        test->line = linenum;
        test->cmd = strdup(line);
        if (!test->cmd) {
            rz_test_json_test_free(test);
            break;
        }
        test->broken = broken_token ? true : false;
        rz_pvector_push(ret, test);
    } while ((line = nextline));
 
    free(contents);
    return ret;
}

References eprintf, free(), setup::line, NULL, readline(), rz_file_slurp(), rz_pvector_new(), rz_pvector_push(), rz_str_trim(), rz_test_json_test_free(), rz_test_json_test_new(), strdup(), true, and ut64().

Referenced by database_load().

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_broken()

RZ_API bool rz_test_test_broken

(

RzTest *

test

)

rz_test_test_database_free()

RZ_API void rz_test_test_database_free

(

RzTestDatabase *

db

)

Definition at line 577 of file load.c.

                                                           {
    if (!db) {
        return;
    }
    rz_pvector_clear(&db->tests);
    rz_str_constpool_fini(&db->strpool);
    free(db);
}

References free(), rz_pvector_clear(), rz_str_constpool_fini(), rz_test_test_database_t::strpool, and rz_test_test_database_t::tests.

Referenced by rz_test_main().

rz_test_test_database_load()

RZ_API bool rz_test_test_database_load	(	RzTestDatabase *	db,
		const char *	path
	)

Definition at line 756 of file load.c.

                                                                             {
    return database_load(db, path, 4);
}

References database_load(), and path.

Referenced by rz_test_main().

rz_test_test_database_load_fuzz()

RZ_API bool rz_test_test_database_load_fuzz	(	RzTestDatabase *	db,
		const char *	path
	)

Definition at line 782 of file load.c.

                                                                                  {
    if (rz_file_is_directory(path)) {
        RzList *dir = rz_sys_dir(path);
        if (!dir) {
            return false;
        }
        RzListIter *it;
        const char *subname;
        RzStrBuf subpath;
        rz_strbuf_init(&subpath);
        bool ret = true;
        rz_list_foreach (dir, it, subname) {
            if (*subname == '.') {
                continue;
            }
            rz_strbuf_setf(&subpath, "%s%s%s", path, RZ_SYS_DIR, subname);
            if (rz_file_is_directory(rz_strbuf_get(&subpath))) {
                // only load 1 level deep
                continue;
            }
            database_load_fuzz_file(db, path, rz_strbuf_get(&subpath));
        }
        rz_strbuf_fini(&subpath);
        rz_list_free(dir);
        return ret;
    }
 
    if (!rz_file_exists(path)) {
        eprintf("Path \"%s\" does not exist\n", path);
        return false;
    }
 
    // Just a single file
    database_load_fuzz_file(db, path, path);
    return true;
}

References database_load_fuzz_file(), eprintf, path, rz_file_exists(), rz_file_is_directory(), rz_list_free(), rz_strbuf_fini(), rz_strbuf_get(), rz_strbuf_init(), rz_strbuf_setf(), RZ_SYS_DIR, and rz_sys_dir().

Referenced by rz_test_main().

rz_test_test_database_new()

RZ_API RzTestDatabase* rz_test_test_database_new

(

void

)

Definition at line 567 of file load.c.

                                                       {
    RzTestDatabase *db = RZ_NEW(RzTestDatabase);
    if (!db) {
        return NULL;
    }
    rz_pvector_init(&db->tests, (RzPVectorFree)rz_test_test_free);
    rz_str_constpool_init(&db->strpool);
    return db;
}

References NULL, RZ_NEW, rz_pvector_init(), rz_str_constpool_init(), rz_test_test_free(), rz_test_test_database_t::strpool, and rz_test_test_database_t::tests.

Referenced by rz_test_main().

rz_test_test_free()

RZ_API void rz_test_test_free

(

RzTest *

test

)

Definition at line 546 of file load.c.

                                            {
    if (!test) {
        return;
    }
    switch (test->type) {
    case RZ_TEST_TYPE_CMD:
        rz_test_cmd_test_free(test->cmd_test);
        break;
    case RZ_TEST_TYPE_ASM:
        rz_test_asm_test_free(test->asm_test);
        break;
    case RZ_TEST_TYPE_JSON:
        rz_test_json_test_free(test->json_test);
        break;
    case RZ_TEST_TYPE_FUZZ:
        rz_test_fuzz_test_free(test->fuzz_test);
        break;
    }
    free(test);
}

References free(), rz_test_asm_test_free(), rz_test_cmd_test_free(), rz_test_fuzz_test_free(), rz_test_json_test_free(), RZ_TEST_TYPE_ASM, RZ_TEST_TYPE_CMD, RZ_TEST_TYPE_FUZZ, and RZ_TEST_TYPE_JSON.

Referenced by rz_test_main(), and rz_test_test_database_new().

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().