Return to test-symbols.c CVS log

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

Annotation of hatari/tests/debugger/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: int main(int argc, const char *argv[])
                     13: {
                     14:        /* expected to fail */
                     15:        const char *fail_name[] = {
                     16:                "afoo",
                     17:                "zbar",
                     18:        };
                     19:        Uint32 fail_addr[] = {
                     20:                0x10,
                     21:                0x30,
                     22:        };
                     23:        /* expected to succeed */
                     24:        const char *success_name[] = {
                     25:                "os_magic",
                     26:                "p_root"
                     27:        };
                     28:        Uint32 success_addr[] = {
                     29:                0x14,
                     30:                0x28,
                     31:        };
                     32: 
                     33: #define DO_CMD(cmd) Symbols_Command(ARRAYSIZE(cmd), cmd)
                     34:        char symbols[] = "symbols";
                     35:        char fname[] = "data/os-header.sym";
                     36:        char sname[] = "name";
                     37:        char saddr[] = "addr";
                     38:        char sfree[] = "free";
                     39:        char *cmd_load[] = { symbols, fname };
                     40:        char *cmd_free[] = { symbols, sfree };
                     41:        char *cmd_show_byname[] = { symbols, sname };
                     42:        char *cmd_show_byaddr[] = { symbols, saddr };
                     43: 
                     44:        int i, tests = 0, errors = 0;
                     45:        const char *name;
                     46:        Uint32 addr;
                     47: 
                     48:        DO_CMD(cmd_load);
                     49:        DO_CMD(cmd_show_byaddr);
                     50:        fprintf(stderr, "\n");
                     51:        DO_CMD(cmd_show_byname);
                     52:        DO_CMD(cmd_load);       /* free + reload */
                     53: 
                     54:        fprintf(stderr, "\nStuff that should FAIL:\n");
                     55:        for (i = 0; i < ARRAYSIZE(fail_name); i++) {
                     56:                name = fail_name[i];
                     57:                if (Symbols_GetCpuAddress(SYMTYPE_ALL, name, &addr)) {
                     58:                        fprintf(stderr, "*** Unexpected SUCCESS from '%s' (0x%08x) ***\n", name, addr);
                     59:                        errors++;
                     60:                } else {
                     61:                        fprintf(stderr, "- '%s'\n", name);
                     62:                }
                     63:        }
                     64:        tests += i;
                     65:        for (i = 0; i < ARRAYSIZE(fail_addr); i++) {
                     66:                addr = fail_addr[i];
                     67:                name = Symbols_GetByCpuAddress(addr);
                     68:                if (name) {
                     69:                        fprintf(stderr, "*** Unexpected SUCCESS from 0x%08x (%s) ***\n", addr, name);
                     70:                        errors++;
                     71:                } else {
                     72:                        fprintf(stderr, "- 0x%08x\n", addr);
                     73:                }
                     74:        }
                     75:        tests += i;
                     76: 
                     77:        fprintf(stderr, "\nStuff that should SUCCEED:\n");
                     78:        for (i = 0; i < ARRAYSIZE(success_name); i++) {
                     79:                name = success_name[i];
                     80:                if (Symbols_GetCpuAddress(SYMTYPE_ALL, name, &addr)) {
                     81:                        fprintf(stderr, "- '%s'\n", name);
                     82:                } else {
                     83:                        fprintf(stderr, "*** Unexpected FAIL from '%s' ***\n", name);
                     84:                        errors++;
                     85:                }
                     86:        }
                     87:        tests += i;
                     88:        for (i = 0; i < ARRAYSIZE(success_addr); i++) {
                     89:                addr = success_addr[i];
                     90:                name = Symbols_GetByCpuAddress(addr);
                     91:                if (name) {
                     92:                        fprintf(stderr, "- 0x%08x: %s\n", addr, name);
                     93:                } else {
                     94:                        fprintf(stderr, "*** Unexpected FAIL from 0x%08x ***\n", addr);
                     95:                        errors++;
                     96:                }
                     97:        }
                     98:        tests += i;
                     99: 
                    100:        DO_CMD(cmd_free);
                    101:        if (errors) {
                    102:                fprintf(stderr, "\n***Detected %d ERRORs in %d automated tests!***\n\n",
                    103:                        errors, tests);
                    104:        } else {
                    105:                fprintf(stderr, "\nFinished without any errors!\n\n");
                    106:        }
                    107:        return errors;
                    108: }

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