load.c File Reference

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

Go to the source code of this file.

Macros
#define	LINEFMT   "%s, line %" PFMT64u ": "
#define	DO_KEY_STR(key, field)   free(test->field.value);
#define	DO_KEY_STR(key, field)
#define	DO_KEY_BOOL(key, field)
#define	DO_KEY_NUM(key, field)

Functions
RZ_API RzCmdTest *	rz_test_cmd_test_new (void)
RZ_API void	rz_test_cmd_test_free (RzCmdTest *test)
static char *	readline (char *buf, size_t *linesz)
static char *	read_string_val (char **nextline, const char *val, ut64 *linenum)
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)
static bool	parse_asm_path (const char *path, RzStrConstPool *strpool, const char **arch_out, const char **cpuout, int *bitsout)
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 void	rz_test_fuzz_test_free (RzFuzzTest *test)
RZ_API void	rz_test_test_free (RzTest *test)
RZ_API RzTestDatabase *	rz_test_test_database_new (void)
RZ_API void	rz_test_test_database_free (RzTestDatabase *db)
static RzTestType	test_type_for_path (const char *path, bool *load_plugins)
static bool	skip_archos (const char *subname)
static bool	database_load (RzTestDatabase *db, const char *path, int depth)
RZ_API bool	rz_test_test_database_load (RzTestDatabase *db, const char *path)
static void	database_load_fuzz_file (RzTestDatabase *db, const char *path, const char *file)
RZ_API bool	rz_test_test_database_load_fuzz (RzTestDatabase *db, const char *path)

Macro Definition Documentation

DO_KEY_BOOL

#define DO_KEY_BOOL	(		key,
			field
	)

Value:

    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; \
    }

DO_KEY_NUM

#define DO_KEY_NUM	(		key,
			field
	)

Value:

    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; \
    }

DO_KEY_STR [1/2]

#define DO_KEY_STR	(		key,
			field
	)		free(test->field.value);

DO_KEY_STR [2/2]

#define DO_KEY_STR	(		key,
			field
	)

Value:

    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; \
    }

LINEFMT

#define LINEFMT   "%s, line %" PFMT64u ": "

Definition at line 8 of file load.c.

Function Documentation

database_load()

static bool database_load ( RzTestDatabase *  db, const char *  path, int  depth  )

static

Definition at line 640 of file load.c.

                                                                           {
    if (depth <= 0) {
        eprintf("Directories for loading tests too deep: %s\n", path);
        return false;
    }
    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;
            }
            if (!strcmp(subname, "extras")) {
                // Only load "extras" dirs if explicitly specified
                eprintf("Skipping %s" RZ_SYS_DIR "%s because it requires additional dependencies.\n", path, subname);
                continue;
            }
            if ((!strcmp(path, "archos") || rz_str_endswith(path, RZ_SYS_DIR "archos")) && skip_archos(subname)) {
                eprintf("Skipping %s" RZ_SYS_DIR "%s because it does not match the current platform.\n", path, subname);
                continue;
            }
            rz_strbuf_setf(&subpath, "%s%s%s", path, RZ_SYS_DIR, subname);
            if (!database_load(db, rz_strbuf_get(&subpath), depth - 1)) {
                ret = false;
                break;
            }
        }
        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;
    }
 
    // Not a directory but exists, load a file
    const char *pooled_path = rz_str_constpool_get(&db->strpool, path);
    bool load_plugins = false;
    RzTestType test_type = test_type_for_path(path, &load_plugins);
    switch (test_type) {
    case RZ_TEST_TYPE_CMD: {
        RzPVector *cmd_tests = rz_test_load_cmd_test_file(path);
        if (!cmd_tests) {
            return false;
        }
        void **it;
        rz_pvector_foreach (cmd_tests, it) {
            RzTest *test = RZ_NEW(RzTest);
            if (!test) {
                continue;
            }
            test->type = RZ_TEST_TYPE_CMD;
            test->path = pooled_path;
            test->cmd_test = *it;
            test->cmd_test->load_plugins = load_plugins;
            rz_pvector_push(&db->tests, test);
        }
        rz_pvector_free(cmd_tests);
        break;
    }
    case RZ_TEST_TYPE_ASM: {
        RzPVector *asm_tests = rz_test_load_asm_test_file(&db->strpool, path);
        if (!asm_tests) {
            return false;
        }
        void **it;
        rz_pvector_foreach (asm_tests, it) {
            RzTest *test = RZ_NEW(RzTest);
            if (!test) {
                continue;
            }
            test->type = RZ_TEST_TYPE_ASM;
            test->path = pooled_path;
            test->asm_test = *it;
            rz_pvector_push(&db->tests, test);
        }
        rz_pvector_free(asm_tests);
        break;
    }
    case RZ_TEST_TYPE_JSON: {
        RzPVector *json_tests = rz_test_load_json_test_file(path);
        if (!json_tests) {
            return false;
        }
        void **it;
        rz_pvector_foreach (json_tests, it) {
            RzTest *test = RZ_NEW(RzTest);
            if (!test) {
                continue;
            }
            test->type = RZ_TEST_TYPE_JSON;
            test->path = pooled_path;
            test->json_test = *it;
            test->json_test->load_plugins = load_plugins;
            rz_pvector_push(&db->tests, test);
        }
        rz_pvector_free(json_tests);
        break;
    }
    case RZ_TEST_TYPE_FUZZ:
        // shouldn't come here, fuzz tests are loaded differently
        break;
    }
 
    return true;
}

References eprintf, path, rz_file_exists(), rz_file_is_directory(), rz_list_free(), RZ_NEW, rz_pvector_foreach, rz_pvector_free(), rz_pvector_push(), rz_str_constpool_get(), rz_str_endswith(), rz_strbuf_fini(), rz_strbuf_get(), rz_strbuf_init(), rz_strbuf_setf(), RZ_SYS_DIR, rz_sys_dir(), rz_test_load_asm_test_file(), rz_test_load_cmd_test_file(), rz_test_load_json_test_file(), RZ_TEST_TYPE_ASM, RZ_TEST_TYPE_CMD, RZ_TEST_TYPE_FUZZ, RZ_TEST_TYPE_JSON, skip_archos(), rz_test_test_database_t::strpool, test_type_for_path(), and rz_test_test_database_t::tests.

Referenced by rz_test_test_database_load().

database_load_fuzz_file()

static void database_load_fuzz_file ( RzTestDatabase *  db, const char *  path, const char *  file  )

static

Definition at line 760 of file load.c.

                                                                                            {
    RzFuzzTest *fuzz_test = RZ_NEW(RzFuzzTest);
    if (!fuzz_test) {
        return;
    }
    fuzz_test->file = strdup(file);
    if (!fuzz_test->file) {
        free(fuzz_test);
        return;
    }
    RzTest *test = RZ_NEW(RzTest);
    if (!test) {
        free(fuzz_test->file);
        free(fuzz_test);
        return;
    }
    test->type = RZ_TEST_TYPE_FUZZ;
    test->fuzz_test = fuzz_test;
    test->path = rz_str_constpool_get(&db->strpool, path);
    rz_pvector_push(&db->tests, test);
}

References rz_test_fuzz_test_t::file, free(), path, RZ_NEW, rz_pvector_push(), rz_str_constpool_get(), RZ_TEST_TYPE_FUZZ, strdup(), rz_test_test_database_t::strpool, and rz_test_test_database_t::tests.

Referenced by rz_test_test_database_load_fuzz().

parse_asm_path()

static bool parse_asm_path ( const char *  path, RzStrConstPool *  strpool, const char **  arch_out, const char **  cpuout, int *  bitsout  )

static

Definition at line 273 of file load.c.

                                                                                                                                {
    RzList *file_tokens = rz_str_split_duplist(path, RZ_SYS_DIR, true);
    if (!file_tokens || rz_list_empty(file_tokens)) {
        rz_list_free(file_tokens);
        return false;
    }
 
    // Possibilities:
    // arm
    // arm_32
    // arm_cortex_32
 
    char *arch = rz_list_last(file_tokens);
    if (!*arch) {
        rz_list_free(file_tokens);
        return false;
    }
    char *second = strchr(arch, '_');
    if (second) {
        *second = '\0';
        second++;
        char *third = strchr(second, '_');
        if (third) {
            *third = '\0';
            third++;
            *cpuout = rz_str_constpool_get(strpool, second);
            *bitsout = atoi(third);
        } else {
            *cpuout = NULL;
            *bitsout = atoi(second);
        }
    } else {
        *cpuout = NULL;
        *bitsout = 0;
    }
    *arch_out = rz_str_constpool_get(strpool, arch);
    rz_list_free(file_tokens);
    return true;
}

References arch, NULL, path, rz_list_free(), rz_list_last(), rz_str_constpool_get(), rz_str_split_duplist(), and RZ_SYS_DIR.

Referenced by rz_test_load_asm_test_file().

read_string_val()

static char* read_string_val ( char **  nextline, const char *  val, ut64 *  linenum  )

static

Definition at line 53 of file load.c.

                                                                              {
    if (val[0] == '\'') {
        size_t len = strlen(val);
        if (len > 1 && val[len - 1] == '\'') {
            eprintf("Error: Invalid string syntax, use <<EOF instead of '...'\n");
            return NULL;
        }
    }
    if (val[0] == '<' && val[1] == '<') {
        // <<EOF syntax
        const char *endtoken = val + 2;
        if (!*endtoken) {
            eprintf("Error: Missing opening end token after <<\n");
            return NULL;
        }
        if (strcmp(endtoken, "EOF") != 0) {
            // In case there will be strings containing "EOF" inside of them, this requirement
            // can be weakened to only apply for strings which do not contain "EOF".
            eprintf("Error: End token must be \"EOF\", got \"%s\" instead.", endtoken);
            return NULL;
        }
        RzStrBuf *buf = rz_strbuf_new("");
        char *line = *nextline;
        size_t linesz = 0;
        do {
            *nextline = readline(line, &linesz);
            (*linenum)++;
            char *end = strstr(line, endtoken);
            if (end != line) {
                // Require the EOF to be at the beginning of the line.
                // This means makes it impossible to write multiline tests without a trailing newline.
                // This requirement could be lifted later if necessary.
                end = NULL;
            }
            if (end) {
                *end = '\0';
            }
            rz_strbuf_append(buf, line);
            if (end) {
                return rz_strbuf_drain(buf);
            } else {
                rz_strbuf_append(buf, "\n");
            }
        } while ((line = *nextline));
        eprintf("Error: Missing closing end token %s\n", endtoken);
        rz_strbuf_free(buf);
        return NULL;
    }
 
    return strdup(val);
}

References test_evm::end, eprintf, len, setup::line, NULL, readline(), rz_strbuf_append(), rz_strbuf_drain(), rz_strbuf_free(), rz_strbuf_new(), strdup(), and val.

readline()

static char* readline ( char *  buf, size_t *  linesz  )

static

Definition at line 24 of file load.c.

                                                 {
    char *end = strchr(buf, '\n');
    if (end) {
        size_t len = end - buf;
        *end = '\0';
        if (len > 0 && buf[len - 1] == '\r') {
            buf[len - 1] = '\0';
            len--;
        }
        *linesz = len;
        return end + 1;
    } else {
        *linesz = strlen(buf);
        return NULL;
    }
}

References test_evm::end, len, and NULL.

Referenced by read_string_val(), rz_test_load_asm_test_file(), rz_test_load_cmd_test_file(), and rz_test_load_json_test_file().

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

RZ_API void rz_test_fuzz_test_free

(

RzFuzzTest *

test

)

Definition at line 538 of file load.c.

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

References free().

Referenced by rz_test_test_free().

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

skip_archos()

static bool skip_archos ( const char *  subname )

inlinestatic

Definition at line 617 of file load.c.

                                                    {
    rz_return_val_if_fail(subname, true);
    if (!strcmp(subname, RZ_TEST_ARCH_OS)) {
        return false;
    }
    if (rz_str_startswith(subname, "not-")) {
        const char *neg_subname = subname + strlen("not-");
        const char *second_dash = strchr(neg_subname, '-');
        rz_return_val_if_fail(second_dash, true);
        if (strncmp(neg_subname, RZ_TEST_ARCH_OS, second_dash - neg_subname) &&
            (rz_str_endswith(RZ_TEST_ARCH_OS, strrchr(subname, '-')) || rz_str_endswith(subname, "-any"))) {
            return false;
        }
    } else {
        if (rz_str_endswith(subname, "-any")) {
            if (!strncmp(subname, RZ_TEST_ARCH_OS, strlen(subname) - strlen("-any"))) {
                return false;
            }
        }
    }
    return true;
}

References rz_return_val_if_fail, rz_str_endswith(), rz_str_startswith(), and RZ_TEST_ARCH_OS.

Referenced by database_load().

test_type_for_path()

static RzTestType test_type_for_path ( const char *  path, bool *  load_plugins  )

static

Definition at line 586 of file load.c.

                                                                           {
    RzTestType ret = RZ_TEST_TYPE_CMD;
    char *pathdup = strdup(path);
    RzList *tokens = rz_str_split_list(pathdup, RZ_SYS_DIR, 0);
    if (!tokens) {
        return ret;
    }
    if (!rz_list_empty(tokens)) {
        rz_list_pop(tokens);
    }
    RzListIter *it;
    char *token;
    *load_plugins = false;
    rz_list_foreach (tokens, it, token) {
        if (!strcmp(token, "asm")) {
            ret = RZ_TEST_TYPE_ASM;
            continue;
        }
        if (!strcmp(token, "json")) {
            ret = RZ_TEST_TYPE_JSON;
            continue;
        }
        if (!strcmp(token, "extras")) {
            *load_plugins = true;
        }
    }
    rz_list_free(tokens);
    free(pathdup);
    return ret;
}

References free(), path, rz_list_free(), rz_list_pop(), rz_str_split_list(), RZ_SYS_DIR, RZ_TEST_TYPE_ASM, RZ_TEST_TYPE_CMD, RZ_TEST_TYPE_JSON, and strdup().

Referenced by database_load().