Return to test-symbols.c CVS log

Up to [HATARI the Atari ST Emulator] / hatari / tests

Annotation of hatari/tests/test-symbols.c, revision 1.1.1.1

1.1       root        1: /* 
                      2:  * Code to test Hatari symbol/address (re-)loading in src/debug/symbols.c
                      3:  */
                      4: #include <stdio.h>
                      5: #include <SDL_types.h>
                      6: #include <stdbool.h>
                      7: #include "debug_priv.h"
                      8: #include "symbols.h"
                      9: #include "main.h"
                     10: #include "log.h"
                     11: 
                     12: /* dummy variable for debugcpu.c */
                     13: Uint32 LogTraceFlags = TRACE_CPU_DISASM;
                     14: 
                     15: /* dummy symbols.c dep function */
                     16: void DebugUI_PrintCmdHelp(const char *cmd)
                     17: {
                     18:        fprintf(stderr, "Help!\n");
                     19: }
                     20: 
                     21: int main(int argc, const char *argv[])
                     22: {
                     23:        /* expected to fail */
                     24:        const char *fail_name[] = {
                     25:                "afoo",
                     26:                "zbar",
                     27:        };
                     28:        Uint32 fail_addr[] = {
                     29:                0x10,
                     30:                0x30,
                     31:        };
                     32:        /* expected to succeed */
                     33:        const char *success_name[] = {
                     34:                "os_magic",
                     35:                "p_root"
                     36:        };
                     37:        Uint32 success_addr[] = {
                     38:                0x14,
                     39:                0x28,
                     40:        };
                     41: 
                     42: #define DO_CMD(cmd) Symbols_Command(ARRAYSIZE(cmd), cmd)
                     43:        char symbols[] = "symbols";
                     44:        char fname[] = "os-header.sym";
                     45:        char sname[] = "name";
                     46:        char saddr[] = "addr";
                     47:        char sfree[] = "free";
                     48:        char *cmd_load[] = { symbols, fname };
                     49:        char *cmd_free[] = { symbols, sfree };
                     50:        char *cmd_show_byname[] = { symbols, sname };
                     51:        char *cmd_show_byaddr[] = { symbols, saddr };
                     52: 
                     53:        int i, tests = 0, errors = 0;
                     54:        const char *name;
                     55:        Uint32 addr;
                     56: 
                     57:        DO_CMD(cmd_load);
                     58:        DO_CMD(cmd_show_byaddr);
                     59:        fprintf(stderr, "\n");
                     60:        DO_CMD(cmd_show_byname);
                     61:        DO_CMD(cmd_load);       /* free + reload */
                     62: 
                     63:        fprintf(stderr, "\nStuff that should FAIL:\n");
                     64:        for (i = 0; i < ARRAYSIZE(fail_name); i++) {
                     65:                name = fail_name[i];
                     66:                if (Symbols_GetCpuAddress(SYMTYPE_ALL, name, &addr)) {
                     67:                        fprintf(stderr, "*** Unexpected SUCCESS from '%s' (0x%08x) ***\n", name, addr);
                     68:                        errors++;
                     69:                } else {
                     70:                        fprintf(stderr, "- '%s'\n", name);
                     71:                }
                     72:        }
                     73:        tests += i;
                     74:        for (i = 0; i < ARRAYSIZE(fail_addr); i++) {
                     75:                addr = fail_addr[i];
                     76:                name = Symbols_GetByCpuAddress(addr);
                     77:                if (name) {
                     78:                        fprintf(stderr, "*** Unexpected SUCCESS from 0x%08x (%s) ***\n", addr, name);
                     79:                        errors++;
                     80:                } else {
                     81:                        fprintf(stderr, "- 0x%08x\n", addr);
                     82:                }
                     83:        }
                     84:        tests += i;
                     85: 
                     86:        fprintf(stderr, "\nStuff that should SUCCEED:\n");
                     87:        for (i = 0; i < ARRAYSIZE(success_name); i++) {
                     88:                name = success_name[i];
                     89:                if (Symbols_GetCpuAddress(SYMTYPE_ALL, name, &addr)) {
                     90:                        fprintf(stderr, "- '%s'\n", name);
                     91:                } else {
                     92:                        fprintf(stderr, "*** Unexpected FAIL from '%s' ***\n", name);
                     93:                        errors++;
                     94:                }
                     95:        }
                     96:        tests += i;
                     97:        for (i = 0; i < ARRAYSIZE(success_addr); i++) {
                     98:                addr = success_addr[i];
                     99:                name = Symbols_GetByCpuAddress(addr);
                    100:                if (name) {
                    101:                        fprintf(stderr, "- 0x%08x: %s\n", addr, name);
                    102:                } else {
                    103:                        fprintf(stderr, "*** Unexpected FAIL from 0x%08x ***\n", addr);
                    104:                        errors++;
                    105:                }
                    106:        }
                    107:        tests += i;
                    108: 
                    109:        DO_CMD(cmd_free);
                    110:        if (errors) {
                    111:                fprintf(stderr, "\n***Detected %d ERRORs in %d automated tests!***\n\n",
                    112:                        errors, tests);
                    113:        } else {
                    114:                fprintf(stderr, "\nFinished without any errors!\n\n");
                    115:        }
                    116:        return errors;
                    117: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.