static int test_n0(void *state) {
enum parser_error r = parser_parse(state, "N:1:Detect Monsters");
struct spell *s;
eq(r, PARSE_ERROR_NONE);
s = parser_priv(state);
require(s);
eq(s->sidx, 1);
require(streq(s->name, "Detect Monsters"));
ok;
}
static enum parser_error parse_r_w(struct parser *p) {
struct monster_race *r = parser_priv(p);
if (!r)
return PARSE_ERROR_MISSING_RECORD_HEADER;
r->level = parser_getint(p, "level");
r->rarity = parser_getint(p, "rarity");
r->power = parser_getint(p, "power");
r->mexp = parser_getint(p, "mexp");
return PARSE_ERROR_NONE;
}
static enum parser_error parse_prefs_x(struct parser *p)
{
struct prefs_data *d = parser_priv(p);
assert(d != NULL);
if (d->bypass) return PARSE_ERROR_NONE;
/* XXX check for valid option */
option_set(parser_getstr(p, "option"), FALSE);
return PARSE_ERROR_NONE;
}
int test_time0(void *state) {
enum parser_error r = parser_parse(state, "time:20+d30");
struct artifact *a;
eq(r, PARSE_ERROR_NONE);
a = parser_priv(state);
require(a);
eq(a->time.base, 20);
eq(a->time.sides, 30);
ok;
}
int test_base_object0(void *state) {
enum parser_error r = parser_parse(state, "base-object:light:6");
struct artifact *a;
eq(r, PARSE_ERROR_NONE);
a = parser_priv(state);
require(a);
eq(a->tval, TV_LIGHT);
eq(a->sval, 6);
ok;
}
static int test_g1(void *state) {
errr r = parser_parse(state, "G:!:W");
struct object_kind *k;
eq(r, 0);
k = parser_priv(state);
require(k);
eq(k->d_char, '!');
eq(k->d_attr, TERM_L_WHITE);
ok;
}
static int test_n0(void *state) {
enum parser_error r = parser_parse(state, "N:544:Carcharoth, the Jaws of Thirst");
struct monster_race *mr;
eq(r, PARSE_ERROR_NONE);
mr = parser_priv(state);
require(mr);
eq(mr->ridx, 544);
require(streq(mr->name, "Carcharoth, the Jaws of Thirst"));
ok;
}
int test_slots0(void *state) {
enum parser_error r = parser_parse(state, "slots:2:33");
struct store *s;
eq(r, PARSE_ERROR_NONE);
s = parser_priv(state);
require(s);
eq(s->normal_stock_min, 2);
eq(s->normal_stock_max, 33);
ok;
}
/* Causes segfault: lookup_name() requires z_info/k_info */
int test_i0(void *state) {
enum parser_error r = parser_parse(state, "normal:3:5");
struct store *s;
eq(r, PARSE_ERROR_NONE);
s = parser_priv(state);
require(s);
require(s->normal_table[0]);
require(s->normal_table[1]);
ok;
}
static int test_g0(void *state) {
enum parser_error r = parser_parse(state, "G:C:v");
struct monster_race *mr;
eq(r, PARSE_ERROR_NONE);
mr = parser_priv(state);
require(mr);
eq(mr->d_attr, TERM_VIOLET);
eq(mr->d_char, 'C');
ok;
}
int test_store0(void *state) {
enum parser_error r = parser_parse(state, "store:1:foobar");
struct store *s;
eq(r, PARSE_ERROR_NONE);
s = parser_priv(state);
require(s);
eq(s->sidx, 0);
streq(s->name, "foobar");
ok;
}
static enum parser_error parse_prefs_y(struct parser *p)
{
struct prefs_data *d = parser_priv(p);
assert(d != NULL);
if (d->bypass)
return PARSE_ERROR_NONE;
option_set(parser_getstr(p, "option"), TRUE);
return PARSE_ERROR_NONE;
}
int test_info0(void *state) {
enum parser_error r = parser_parse(state, "info:9:2");
struct feature *f;
eq(r, PARSE_ERROR_NONE);
f = parser_priv(state);
require(f);
eq(f->shopnum, 9);
eq(f->dig, 2);
ok;
}
int test_graphics0(void *state) {
enum parser_error r = parser_parse(state, "graphics:::red");
struct feature *f;
eq(r, PARSE_ERROR_NONE);
f = parser_priv(state);
require(f);
eq(f->d_char, L':');
eq(f->d_attr, COLOUR_RED);
ok;
}
static int test_n0(void *state) {
errr r = parser_parse(state, "N:3:Test Object Kind");
struct object_kind *k;
eq(r, 0);
k = parser_priv(state);
require(k);
eq(k->kidx, 3);
require(streq(k->name, "Test Object Kind"));
ok;
}
int test_weight0(void *state) {
enum parser_error r = parser_parse(state, "weight:80:10");
struct player_race *pr;
eq(r, PARSE_ERROR_NONE);
pr = parser_priv(state);
require(pr);
eq(pr->base_wgt, 80);
eq(pr->mod_wgt, 10);
ok;
}
static int test_g0(void *state) {
errr r = parser_parse(state, "G:~:red");
struct object_kind *k;
eq(r, 0);
k = parser_priv(state);
require(k);
eq(k->d_char, '~');
eq(k->d_attr, TERM_RED);
ok;
}
/**
* Parsing functions for quest.txt
*/
static enum parser_error parse_quest_name(struct parser *p) {
const char *name = parser_getstr(p, "name");
struct quest *h = parser_priv(p);
struct quest *q = mem_zalloc(sizeof(*q));
q->next = h;
parser_setpriv(p, q);
q->name = string_make(name);
return PARSE_ERROR_NONE;
}
static int test_i1(void *state) {
errr r = parser_parse(state, "I:food:2");
struct object_kind *k;
eq(r, 0);
k = parser_priv(state);
require(k);
eq(k->tval, TV_FOOD);
eq(k->sval, 2);
ok;
}
static enum parser_error parse_quest_race(struct parser *p) {
struct quest *q = parser_priv(p);
const char *name = parser_getstr(p, "race");
assert(q);
q->race = lookup_monster(name);
if (!q->race)
return PARSE_ERROR_INVALID_MONSTER;
return PARSE_ERROR_NONE;
}
static enum parser_error parse_profile_params(struct parser *p) {
struct cave_profile *c = parser_priv(p);
if (!c)
return PARSE_ERROR_MISSING_RECORD_HEADER;
c->block_size = parser_getint(p, "block");
c->dun_rooms = parser_getint(p, "rooms");
c->dun_unusual = parser_getint(p, "unusual");
c->max_rarity = parser_getint(p, "rarity");
return PARSE_ERROR_NONE;
}
int test_info0(void *state) {
enum parser_error r = parser_parse(state, "info:6:8");
struct ego_item *e;
eq(r, PARSE_ERROR_NONE);
e = parser_priv(state);
require(e);
eq(e->cost, 6);
eq(e->rating, 8);
ok;
}
int test_name0(void *state) {
enum parser_error r = parser_parse(state, "name:3:of Thrain");
struct artifact *a;
eq(r, PARSE_ERROR_NONE);
a = parser_priv(state);
require(a);
eq(a->aidx, 3);
require(streq(a->name, "of Thrain"));
ok;
}
static int test_c0(void *state) {
errr r = parser_parse(state, "C:2d8");
struct object_kind *k;
eq(r, 0);
k = parser_priv(state);
require(k);
eq(k->charge.dice, 2);
eq(k->charge.sides, 8);
ok;
}
int test_i0(void *state) {
errr r = parser_parse(state, "I:4:2");
struct object_kind *k;
eq(r, 0);
k = parser_priv(state);
require(k);
eq(k->tval, 4);
eq(k->sval, 2);
ok;
}
int test_height0(void *state) {
enum parser_error r = parser_parse(state, "height:10:2");
struct player_race *pr;
eq(r, PARSE_ERROR_NONE);
pr = parser_priv(state);
require(pr);
eq(pr->base_hgt, 10);
eq(pr->mod_hgt, 2);
ok;
}
int test_name0(void *state) {
enum parser_error r = parser_parse(state, "name:1:Half-Elf");
struct player_race *pr;
eq(r, PARSE_ERROR_NONE);
pr = parser_priv(state);
require(pr);
eq(pr->ridx, 1);
require(streq(pr->name, "Half-Elf"));
ok;
}
static enum parser_error helper_char1(struct parser *p) {
char c0 = parser_getchar(p, "c0");
char c1 = parser_getchar(p, "c1");
int i0 = parser_getint(p, "i0");
const char *s = parser_getstr(p, "s");
int *wasok = parser_priv(p);
if (c0 != ':' || c1 != ':' || i0 != 34 || !streq(s, "lala"))
return PARSE_ERROR_GENERIC;
*wasok = 1;
return PARSE_ERROR_NONE;
}
static enum parser_error helper_opt0(struct parser *p) {
const char *s0 = parser_getsym(p, "s0");
const char *s1 = parser_hasval(p, "s1") ? parser_getsym(p, "s1") : NULL;
int *wasok = parser_priv(p);
if (!s0 || strcmp(s0, "foo"))
return PARSE_ERROR_GENERIC;
if (s1 && !strcmp(s1, "bar"))
*wasok = 2;
else
*wasok = 1;
return PARSE_ERROR_NONE;
}
int test_history0(void *state) {
enum parser_error r = parser_parse(state, "history:0:10:3");
struct player_race *pr;
eq(r, PARSE_ERROR_NONE);
pr = parser_priv(state);
require(pr);
null(pr->history);
eq(pr->b_age, 10);
eq(pr->m_age, 3);
ok;
}
