tests.c File Reference

#include "shared/shared.h"
#include "common/bsp.h"
#include "common/cmd.h"
#include "common/common.h"
#include "common/files.h"
#include "common/tests.h"
#include "refresh/refresh.h"
#include "system/system.h"

Go to the source code of this file.

Classes
struct	wildtest_t
struct	normtest_t
struct	info_validate_test_t
struct	info_remove_test_t
struct	info_set_test_t
struct	snprintf_test_t

Macros
#define	OV   SIZE_MAX

Functions
static void	Com_Error_f (void)
static void	Com_ErrorDrop_f (void)
static void	Com_Freeze_f (void)
static void	Com_Crash_f (void)
static void	Com_PrintJunk_f (void)
static void	BSP_Test_f (void)
static void	Com_TestWild_f (void)
static void	Com_TestNorm_f (void)
static void	Com_TestInfo_f (void)
static void	Com_TestSnprintf_f (void)
void	TST_Init (void)

Variables
static const wildtest_t	wildtests []
static const int	numwildtests = q_countof(wildtests)
static const normtest_t	normtests []
static const int	numnormtests = q_countof(normtests)
static const info_validate_test_t	info_validate_tests []
static const int	num_info_validate_tests = q_countof(info_validate_tests)
static const info_remove_test_t	info_remove_tests []
static const int	num_info_remove_tests = q_countof(info_remove_tests)
static const info_set_test_t	info_set_tests []
static const int	num_info_set_tests = q_countof(info_set_tests)
static const snprintf_test_t	snprintf_tests []
static const int	num_snprintf_tests = q_countof(snprintf_tests)

Macro Definition Documentation

OV

#define OV   SIZE_MAX

Definition at line 445 of file tests.c.

Function Documentation

BSP_Test_f()

static void BSP_Test_f ( void  )

static

Definition at line 119 of file tests.c.

{
    void **list;
    char *name;
    int i, count, errors;
    bsp_t *bsp;
    qerror_t ret;
    unsigned start, end;
 
    list = FS_ListFiles("maps", ".bsp", FS_SEARCH_SAVEPATH, &count);
    if (!list) {
        Com_Printf("No maps found\n");
        return;
    }
 
    start = Sys_Milliseconds();
 
    errors = 0;
    for (i = 0; i < count; i++) {
        name = list[i];
        ret = BSP_Load(name, &bsp);
        if (!bsp) {
            Com_EPrintf("%s: %s\n", name, Q_ErrorString(ret));
            errors++;
            continue;
        }
 
        Com_DPrintf("%s: success\n", name);
        BSP_Free(bsp);
    }
 
    end = Sys_Milliseconds();
 
    Com_Printf("%d msec, %d failures, %d maps tested\n",
               end - start, errors, count);
 
    FS_FreeList(list);
}

Referenced by TST_Init().

Com_Crash_f()

static void Com_Crash_f ( void  )

static

Definition at line 61 of file tests.c.

{
    static byte buf1[16];
    byte buf2[16], *buf3;
    int i = atoi(Cmd_Argv(1));
 
    switch (i) {
    case 1:
        // data
        memset(buf1, 0xcc, 16);
        buf1[0] = 0xc3;
        ((void (*)(void))buf1)();
        break;
    case 2:
        // stack
        memset(buf2, 0xcc, 16);
        buf2[0] = 0xc3;
        ((void (*)(void))buf2)();
        break;
    case 3:
        // heap
        buf3 = Z_Malloc(16);
        memset(buf3, 0xcc, 16);
        buf3[0] = 0xc3;
        ((void (*)(void))buf3)();
        Z_Free(buf3);
        break;
    default:
        *(uint32_t *)1024 = 0x123456;
        break;
    }
}

Referenced by TST_Init().

Com_Error_f()

static void Com_Error_f ( void  )

static

Definition at line 29 of file tests.c.

{
    Com_Error(ERR_FATAL, "%s", Cmd_Argv(1));
}

Referenced by TST_Init().

Com_ErrorDrop_f()

static void Com_ErrorDrop_f ( void  )

static

Definition at line 34 of file tests.c.

{
    Com_Error(ERR_DROP, "%s", Cmd_Argv(1));
}

Referenced by TST_Init().

Com_Freeze_f()

static void Com_Freeze_f ( void  )

static

Definition at line 39 of file tests.c.

{
    unsigned time, msec;
    float seconds;
 
    if (Cmd_Argc() < 2) {
        Com_Printf("Usage: %s <seconds>\n", Cmd_Argv(0));
        return;
    }
 
    seconds = atof(Cmd_Argv(1));
    if (seconds < 0) {
        return;
    }
 
    time = Sys_Milliseconds();
    msec = seconds * 1000;
    while (Sys_Milliseconds() - time < msec)
        ;
}

Referenced by TST_Init().

Com_PrintJunk_f()

static void Com_PrintJunk_f ( void  )

static

Definition at line 95 of file tests.c.

{
    char buf[MAXPRINTMSG * 2];
    int i, count;
 
    // generate some junk
    for (i = 0; i < sizeof(buf) - 1; i++)
        buf[i] = 'a' + i % ('z' - 'a' + 1);
    buf[i] = 0;
 
    // randomly break into words
    for (i = 0; i < 64; i++)
        buf[rand() % (sizeof(buf) - 1)] = ' ';
 
    if (Cmd_Argc() > 1)
        count = atoi(Cmd_Argv(1));
    else
        count = 1;
 
    for (i = 0; i < count; i++)
        Com_Printf("%s", buf);
    Com_Printf("\n");
}

Referenced by TST_Init().

Com_TestInfo_f()

static void Com_TestInfo_f ( void  )

static

Definition at line 389 of file tests.c.

{
    const info_validate_test_t *v;
    const info_remove_test_t *r;
    const info_set_test_t *s;
    char buffer[MAX_INFO_STRING];
    int i, errors;
    qboolean result;
 
    errors = 0;
    for (i = 0; i < num_info_validate_tests; i++) {
        v = &info_validate_tests[i];
        result = Info_Validate(v->string);
        if (result != v->result) {
            Com_EPrintf("Info_Validate( \"%s\" ) == %d, expected %d\n",
                        v->string, result, v->result);
            errors++;
        }
    }
 
    for (i = 0; i < num_info_remove_tests; i++) {
        r = &info_remove_tests[i];
        Q_strlcpy(buffer, r->string, sizeof(buffer));
        Info_RemoveKey(buffer, r->key);
        if (strcmp(buffer, r->result)) {
            Com_EPrintf("Info_RemoveKey( \"%s\", \"%s\" ) == \"%s\", expected \"%s\"\n",
                        r->string, r->key, buffer, r->result);
            errors++;
        }
    }
 
    for (i = 0; i < num_info_set_tests; i++) {
        s = &info_set_tests[i];
        Q_strlcpy(buffer, s->string, sizeof(buffer));
        result = Info_SetValueForKey(buffer, s->key, s->value);
        if (result != s->result_b || strcmp(buffer, s->result_s)) {
            Com_EPrintf("Info_SetValueForKey( \"%s\", \"%s\", \"%s\" ) == \"%s\" (%d), expected \"%s\" (%d)\n",
                        s->string, s->key, s->value, buffer, result, s->result_s, s->result_b);
            errors++;
        }
    }
 
    Com_Printf("%d failures, %d strings tested\n", errors,
               num_info_validate_tests +
               num_info_remove_tests +
               num_info_set_tests);
}

Referenced by TST_Init().

Com_TestNorm_f()

static void Com_TestNorm_f ( void  )

static

Definition at line 260 of file tests.c.

{
    const normtest_t *n;
    char buffer[MAX_QPATH];
    int i, errors, pass;
 
    for (pass = 0; pass < 2; pass++) {
        errors = 0;
        for (i = 0; i < numnormtests; i++) {
            n = &normtests[i];
            if (pass == 0) {
                FS_NormalizePath(buffer, n->in);
            } else {
                // test in place operation
                strcpy(buffer, n->in);
                FS_NormalizePath(buffer, buffer);
            }
            if (strcmp(n->out, buffer)) {
                Com_EPrintf(
                    "FS_NormalizePath( \"%s\" ) == \"%s\", expected \"%s\" (pass %d)\n",
                    n->in, buffer, n->out, pass);
                errors++;
            }
        }
        if (errors)
            break;
    }
 
    Com_Printf("%d failures, %d paths tested (%d passes)\n",
               errors, numnormtests, pass);
}

Referenced by TST_Init().

Com_TestSnprintf_f()

static void Com_TestSnprintf_f ( void  )

static

Definition at line 459 of file tests.c.

{
    const snprintf_test_t *t;
    char buf[16], *ptr;
    size_t len;
    int i, errors;
    qboolean overflow;
 
    errors = 0;
    for (i = 0; i < num_snprintf_tests; i++) {
        t = &snprintf_tests[i];
 
        ptr = t->size ? buf : NULL;
 
        memset(buf, 'x', 15); buf[15] = 0;
        len = Q_snprintf(ptr, t->size, "hello world");
        overflow = len >= t->size;
        if (t->len1 != len || strcmp(buf, t->res) || overflow != t->overflow1) {
            Com_EPrintf("%s( %p, %"PRIz" ) == \"%s\" (%"PRIz") [%d], expected \"%s\" (%"PRIz") [%d]\n",
                        "Q_snprintf", ptr, t->size, buf, len, overflow, t->res, t->len1, t->overflow1);
            errors++;
        }
 
        memset(buf, 'x', 15); buf[15] = 0;
        len = Q_scnprintf(ptr, t->size, "hello world");
        overflow = len >= t->size;
        if (t->len2 != len || strcmp(buf, t->res) || overflow != t->overflow2) {
            Com_EPrintf("%s( %p, %"PRIz" ) == \"%s\" (%"PRIz") [%d], expected \"%s\" (%"PRIz") [%d]\n",
                        "Q_scnprintf", ptr, t->size, buf, len, overflow, t->res, t->len2, t->overflow2);
            errors++;
        }
    }
 
    Com_Printf("%d failures, %d strings tested\n", errors, num_snprintf_tests * 2);
}

Referenced by TST_Init().

Com_TestWild_f()

static void Com_TestWild_f ( void  )

static

Definition at line 185 of file tests.c.

{
    const wildtest_t *w;
    qboolean match;
    int i, errors;
 
    errors = 0;
    for (i = 0; i < numwildtests; i++) {
        w = &wildtests[i];
        match = Com_WildCmp(w->filter, w->string);
        if (match != w->result) {
            Com_EPrintf(
                "Com_WildCmp( \"%s\", \"%s\" ) == %d, expected %d\n",
                w->filter, w->string, match, w->result);
            errors++;
        }
    }
 
    Com_Printf("%d failures, %d patterns tested\n",
               errors, numwildtests);
}

Referenced by TST_Init().

TST_Init()

void TST_Init

(

void

)

Definition at line 527 of file tests.c.

{
    Cmd_AddCommand("error", Com_Error_f);
    Cmd_AddCommand("errordrop", Com_ErrorDrop_f);
    Cmd_AddCommand("freeze", Com_Freeze_f);
    Cmd_AddCommand("crash", Com_Crash_f);
    Cmd_AddCommand("printjunk", Com_PrintJunk_f);
    Cmd_AddCommand("bsptest", BSP_Test_f);
    Cmd_AddCommand("wildtest", Com_TestWild_f);
    Cmd_AddCommand("normtest", Com_TestNorm_f);
    Cmd_AddCommand("infotest", Com_TestInfo_f);
    Cmd_AddCommand("snprintftest", Com_TestSnprintf_f);
#if USE_REF
    Cmd_AddCommand("modeltest", Com_TestModels_f);
#endif
}

Referenced by Qcommon_Init().

Variable Documentation

info_remove_tests

const info_remove_test_t info_remove_tests[]

static

Initial value:

= {
    { "",                                           "",     ""               },
    { "\\key\\value",                               "key",  ""               },
    { "key\\value",                                 "key",  ""               },
    { "\\key1\\value1\\key2\\value2",               "key1", "\\key2\\value2" },
    { "\\key1\\value1\\key2\\value2",               "key2", "\\key1\\value1" },
    { "\\key1\\value1\\key2\\value2\\key1\\value3", "key1", "\\key2\\value2" },
    { "\\key\\value",                               "",     "\\key\\value"   },
    { "\\\\value",                                  "",     ""               },
}

Definition at line 341 of file tests.c.

Referenced by Com_TestInfo_f().

info_set_tests

const info_set_test_t info_set_tests[]

static

Initial value:

= {
    { "",                                           "",         "",             1,  ""                              },
    { "\\key\\value1",                              "key",      "value2",       1,  "\\key\\value2"                 },
    { "\\key\\value1",                              "key",      "",             1,  ""                              },
    { "\\key\\value1",                              "",         "value2",       1,  "\\key\\value1\\\\value2"       },
    { "\\key\\value1",                              "ke\"y",    "value2",       0,  "\\key\\value1"                 },
    { "\\key\\value1",                              "ke\\y",    "value2",       0,  "\\key\\value1"                 },
    { "\\key\\value1",                              "ke;y",     "value2",       0,  "\\key\\value1"                 },
    { "\\key\\value1",                              "ke\xa2y",  "value2",       0,  "\\key\\value1"                 },
    { "\\key\\value1",                              "ke\xdcy",  "value2",       0,  "\\key\\value1"                 },
    { "\\key\\value1",                              "ke\xbby",  "value2",       0,  "\\key\\value1"                 },
    { "\\key\\value1",                              "key",      "val\"ue2",     0,  "\\key\\value1"                 },
    { "\\key\\value1",                              "key",      "val\\ue2",     0,  "\\key\\value1"                 },
    { "\\key\\value1",                              "key",      "val;ue2",      0,  "\\key\\value1"                 },
    { "\\key\\value1",                              "key",      "val\xa2ue2",   0,  "\\key\\value1"                 },
    { "\\key\\value1",                              "key",      "val\xdcue2",   0,  "\\key\\value1"                 },
    { "\\key\\value1",                              "key",      "val\xbbue2",   0,  "\\key\\value1"                 },
    { "\\key1\\value1\\key2\\value2",               "key1",     "value3",       1,  "\\key2\\value2\\key1\\value3"  },
    { "\\key1\\value1\\key2\\value2",               "key1",     "",             1,  "\\key2\\value2"                },
    { "\\key1\\value1\\key2\\value2\\key1\\value3", "key1",     "value4",       1,  "\\key2\\value2\\key1\\value4"  },
    { "\\key1\\value1\\key2\\value2",               "key1",     "v\xe1lue3",    1,  "\\key2\\value2\\key1\\value3"  },
    { "\\key\\value",                               "key",      "\r\n",         1,  "\\key\\"                       },
    { "\\key1\\value1\\key2\\value2",               "key1",     "\r\n",         1,  "\\key2\\value2\\key1\\"        },
}

Definition at line 362 of file tests.c.

Referenced by Com_TestInfo_f().

info_validate_tests

const info_validate_test_t info_validate_tests[]

static

Definition at line 297 of file tests.c.

Referenced by Com_TestInfo_f().

normtests

const normtest_t normtests[]

static

Definition at line 212 of file tests.c.

Referenced by Com_TestNorm_f().

num_info_remove_tests

const int num_info_remove_tests = q_countof(info_remove_tests)

static

Definition at line 352 of file tests.c.

Referenced by Com_TestInfo_f().

num_info_set_tests

const int num_info_set_tests = q_countof(info_set_tests)

static

Definition at line 387 of file tests.c.

Referenced by Com_TestInfo_f().

num_info_validate_tests

const int num_info_validate_tests = q_countof(info_validate_tests)

static

Definition at line 333 of file tests.c.

Referenced by Com_TestInfo_f().

num_snprintf_tests

const int num_snprintf_tests = q_countof(snprintf_tests)

static

Definition at line 457 of file tests.c.

Referenced by Com_TestSnprintf_f().

numnormtests

const int numnormtests = q_countof(normtests)

static

Definition at line 258 of file tests.c.

Referenced by Com_TestNorm_f().

numwildtests

const int numwildtests = q_countof(wildtests)

static

Definition at line 183 of file tests.c.

Referenced by Com_TestWild_f().

snprintf_tests

const snprintf_test_t snprintf_tests[]

static

Initial value:

= {
    { 12, 11, 11, 0, 0, "hello world"     },
    { 11, OV, 10, 1, 0, "hello worl"      },
    { 10, OV,  9, 1, 0, "hello wor"       },
    { 0,  11,  0, 1, 1, "xxxxxxxxxxxxxxx" },
}

Definition at line 450 of file tests.c.

Referenced by Com_TestSnprintf_f().

wildtests

const wildtest_t wildtests[]

static

Initial value:

= {
    { "",               "",                 1 },
    { "*",              "foo",              1 },
    { "***",            "foo",              1 },
    { "foo*bar",        "foobar",           1 },
    { "foo*bar*baz",    "foobaz",           0 },
    { "bar*",           "bar",              1 },
    { "bar*",           "barfoo",           1 },
    { "???*",           "barfoo",           1 },
    { "???\\*",         "bar*",             1 },
    { "???\\*",         "bar*bar",          0 },
    { "???\\*",         "bar?",             0 },
    { "*\\?",           "bar?",             1 },
    { "\\\\",           "\\",               1 },
    { "\\",             "\\",               0 },
    { "foo*bar\\*baz",  "foo*abcbar*baz",   1 },
    { "\\a\\b\\c",      "abc",              1 },
}

Definition at line 164 of file tests.c.

Referenced by Com_TestWild_f().