Marc/server
1
0
Fork 0
forked from github/server
Code Issues Pull requests Projects Releases Wiki Activity
server/src/tests.c
Enno Rehling 007721991d Bug 2606: DRY, share code between buy and sell.
2019-09-08 13:29:10 +02:00

649 lines
19 KiB
C
Raw Blame History

#include <platform.h>
#include "tests.h"
#include "prefix.h"
#include "creport.h"
#include "report.h"
#include "reports.h"
#include "vortex.h"
#include "kernel/calendar.h"
#include "kernel/callbacks.h"
#include "kernel/config.h"
#include "kernel/alliance.h"
#include <kernel/equipment.h>
#include <kernel/messages.h>
#include <kernel/plane.h>
#include <kernel/region.h>
#include <kernel/terrain.h>
#include <kernel/terrainid.h>
#include <kernel/item.h>
#include <kernel/unit.h>
#include <kernel/order.h>
#include <kernel/race.h>
#include <kernel/faction.h>
#include <kernel/building.h>
#include <kernel/ship.h>
#include <kernel/spell.h>
#include <kernel/spellbook.h>
#include <kernel/terrain.h>
#include <util/functions.h>
#include "util/keyword.h"
#include <util/language.h>
#include <util/lists.h>
#include <util/message.h>
#include <util/log.h>
#include "util/param.h"
#include <util/rand.h>
#include <util/assert.h>
#include <CuTest.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
int test_set_item(unit * u, const item_type *itype, int value)
{
item *i;
assert(itype);
i = *i_find(&u->items, itype);
if (!i) {
i = i_add(&u->items, i_new(itype, value));
}
else {
i->number = value;
assert(i->number >= 0);
}
return value;
}
struct race *test_create_race(const char *name)
{
race *rc = rc_get_or_create(name ? name : "smurf");
rc->maintenance = 10;
rc->hitpoints = 20;
rc->maxaura = 100;
rc->flags |= (RCF_WALK|RCF_PLAYABLE);
rc->ec_flags |= ECF_GETITEM;
rc->battle_flags = BF_EQUIPMENT;
return rc;
}
struct region *test_create_region(int x, int y, const terrain_type *terrain)
{
region *r = findregion(x, y);
if (!r) {
r = new_region(x, y, findplane(x, y), 0);
}
if (!terrain) {
terrain_type *t = test_create_terrain("plain", LAND_REGION | CAVALRY_REGION | FOREST_REGION | FLY_INTO | WALK_INTO);
terraform_region(r, t);
}
else {
terraform_region(r, terrain);
}
r->flags &= ~RF_MALLORN;
rsettrees(r, 0, 0);
rsettrees(r, 1, 0);
rsettrees(r, 2, 0);
rsethorses(r, 0);
rsetpeasants(r, r->terrain->size);
return r;
}
region *test_create_ocean(int x, int y)
{
terrain_type *ter = test_create_terrain("ocean", SEA_REGION | FLY_INTO | SWIM_INTO);
return test_create_region(x, y, ter);
}
region *test_create_plain(int x, int y) {
return test_create_region(x, y, NULL);
}
struct locale * test_create_locale(void) {
struct locale *loc = get_locale("test");
if (!loc) {
int i;
loc = get_or_create_locale("test");
locale_setstring(loc, "factiondefault", parameters[P_FACTION]);
locale_setstring(loc, "unitdefault", parameters[P_UNIT]);
locale_setstring(loc, "money", "Silber");
locale_setstring(loc, "money_p", "Silber");
locale_setstring(loc, "cart", "Wagen");
locale_setstring(loc, "cart_p", "Wagen");
locale_setstring(loc, "horse", "Pferd");
locale_setstring(loc, "horse_p", "Pferde");
locale_setstring(loc, "iron", "Eisen");
locale_setstring(loc, "iron_p", "Eisen");
locale_setstring(loc, "stone", "Stein");
locale_setstring(loc, "stone_p", "Steine");
locale_setstring(loc, "plain", "Ebene");
locale_setstring(loc, "ocean", "Ozean");
for (i = 0; i < MAXRACES; ++i) {
if (racenames[i]) {
char name[64];
rc_key(racenames[i], NAME_PLURAL, name, sizeof(name));
if (!locale_getstring(loc, name)) {
locale_setstring(loc, name, name + 6);
}
rc_key(racenames[i], NAME_SINGULAR, name, sizeof(name));
if (!locale_getstring(loc, name)) {
locale_setstring(loc, name, name + 6);
}
}
}
for (i = 0; i < MAXSKILLS; ++i) {
if (!locale_getstring(loc, mkname("skill", skillnames[i])))
locale_setstring(loc, mkname("skill", skillnames[i]), skillnames[i]);
}
for (i = 0; i != ALLIANCE_MAX; ++i) {
locale_setstring(loc, alliance_kwd[i], alliance_kwd[i]);
}
for (i = 0; i != MAXDIRECTIONS; ++i) {
locale_setstring(loc, shortdirections[i], shortdirections[i] + 4);
locale_setstring(loc, directions[i], directions[i]);
init_direction(loc, i, directions[i]);
init_direction(loc, i, coasts[i] + 7);
}
for (i = 0; i <= ST_FLEE; ++i) {
locale_setstring(loc, combatstatus[i], combatstatus[i] + 7);
}
for (i = 0; i != MAXKEYWORDS; ++i) {
if (keywords[i]) {
locale_setstring(loc, mkname("keyword", keywords[i]), keywords[i]);
}
}
for (i = 0; i != MAXPARAMS; ++i) {
locale_setstring(loc, parameters[i], parameters[i]);
test_translate_param(loc, i, parameters[i]);
}
for (i = 0; i != MAXMAGIETYP; ++i) {
locale_setstring(loc, mkname("school", magic_school[i]), magic_school[i]);
}
init_locale(loc);
}
return loc;
}
struct faction *test_create_faction(const struct race *rc)
{
struct locale * loc = test_create_locale();
faction *f = addfaction("nobody@eressea.de", NULL, rc ? rc : test_create_race("human"), loc);
test_clear_messages(f);
return f;
}
struct unit *test_create_unit(struct faction *f, struct region *r)
{
const struct race * rc = f ? f->race : 0;
assert(f && r);
if (!rc) rc = rc_get_or_create("human");
return create_unit(r, f, 1, rc ? rc : rc_get_or_create("human"), 0, 0, 0);
}
static void log_list(void *udata, int flags, const char *module, const char *format, va_list args) {
strlist **slp = (strlist **)udata;
addstrlist(slp, format);
}
struct log_t * test_log_start(int flags, strlist **slist) {
return log_create(flags, slist, log_list);
}
void test_log_stop(struct log_t *log, struct strlist *slist) {
freestrlist(slist);
log_destroy(log);
}
void test_log_stderr(int flags) {
static struct log_t *stderrlog;
if (flags) {
if (stderrlog) {
log_error("stderr logging is still active. did you call test_teardown?");
log_destroy(stderrlog);
}
stderrlog = log_to_file(flags, stderr);
}
else {
if (stderrlog) {
log_destroy(stderrlog);
}
else {
log_warning("stderr logging is inactive. did you call test_teardown twice?");
}
stderrlog = 0;
}
}
static void test_reset(void) {
int i;
turn = 1;
default_locale = 0;
if (errno) {
int error = errno;
errno = 0;
log_error("errno: %d (%s)", error, strerror(error));
}
memset(&callbacks, 0, sizeof(callbacks));
free_gamedata();
free_terrains();
free_resources();
free_functions();
free_config();
default_locale = 0;
calendar_cleanup();
creport_cleanup();
report_cleanup();
close_orders();
log_close();
stats_close();
free_special_directions();
free_locales();
free_spells();
free_buildingtypes();
free_shiptypes();
free_races();
free_spellbooks();
free_prefixes();
mt_clear();
for (i = 0; i != MAXSKILLS; ++i) {
enable_skill(i, true);
}
for (i = 0; i != MAXKEYWORDS; ++i) {
enable_keyword(i, true);
}
random_source_reset();
mt_create_va(mt_new("changepasswd", NULL),
"value:string", MT_NEW_END);
mt_create_va(mt_new("starvation", NULL),
"unit:unit", "region:region", "dead:int", "live:int", MT_NEW_END);
mt_create_va(mt_new("malnourish", NULL),
"unit:unit", "region:region", MT_NEW_END);
if (errno) {
int error = errno;
errno = 0;
log_error("errno: %d (%s)", error, strerror(error));
}
}
void test_create_calendar(void) {
config_set_int("game.start", 184);
months_per_year = 9;
month_season = malloc(sizeof(season_t) * months_per_year);
if (!month_season) abort();
month_season[0] = SEASON_SUMMER;
month_season[1] = SEASON_AUTUMN;
month_season[2] = SEASON_AUTUMN;
month_season[3] = SEASON_WINTER;
month_season[4] = SEASON_WINTER;
month_season[5] = SEASON_WINTER;
month_season[6] = SEASON_SPRING;
month_season[7] = SEASON_SPRING;
month_season[8] = SEASON_SUMMER;
}
void test_setup_test(CuTest *tc, const char *file, int line) {
test_log_stderr(LOG_CPERROR);
test_reset();
message_handle_missing(MESSAGE_MISSING_REPLACE);
if (tc) {
log_debug("start test: %s", tc->name);
}
else {
log_debug("start test in %s:%d", file, line);
}
errno = 0;
}
void test_teardown(void)
{
message_handle_missing(MESSAGE_MISSING_IGNORE);
test_reset();
test_log_stderr(0);
}
terrain_type *
test_create_terrain(const char * name, int flags)
{
terrain_type * t = get_or_create_terrain(name);
if (flags < 0) {
/* sensible defaults for most terrains */
flags = LAND_REGION | WALK_INTO | FLY_INTO;
}
if (flags & LAND_REGION) {
t->size = 1000;
}
t->flags = flags;
return t;
}
building * test_create_building(region * r, const building_type * btype)
{
building * b;
assert(r);
if (!btype) {
building_type *bt_castle = test_create_buildingtype("castle");
bt_castle->flags |= BTF_FORTIFICATION;
btype = bt_castle;
}
b = new_building(btype, r, default_locale);
b->size = btype->maxsize > 0 ? btype->maxsize : 1;
return b;
}
ship * test_create_ship(region * r, const ship_type * stype)
{
ship * s = new_ship(stype ? stype : test_create_shiptype("boat"), r, default_locale);
s->size = s->type->construction ? s->type->construction->maxsize : 1;
return s;
}
ship_type * test_create_shiptype(const char * name)
{
ship_type * stype = st_get_or_create(name);
stype->cptskill = 1;
stype->sumskill = 1;
stype->minskill = 1;
stype->range = 2;
stype->cargo = 1000;
stype->damage = 1;
if (!stype->construction) {
stype->construction = calloc(1, sizeof(construction));
assert_alloc(stype->construction);
stype->construction->maxsize = 5;
stype->construction->minskill = 1;
stype->construction->reqsize = 1;
stype->construction->skill = SK_SHIPBUILDING;
}
if (stype->coasts) {
free(stype->coasts);
}
stype->coasts =
(terrain_type **)malloc(sizeof(terrain_type *) * 3);
stype->coasts[0] = test_create_terrain("plain", LAND_REGION | FOREST_REGION | WALK_INTO | CAVALRY_REGION | FLY_INTO);
stype->coasts[1] = test_create_terrain("ocean", SEA_REGION | SWIM_INTO | FLY_INTO);
stype->coasts[2] = NULL;
if (default_locale) {
locale_setstring(default_locale, name, name);
}
return stype;
}
building_type * test_create_buildingtype(const char * name)
{
construction *con;
building_type *btype = bt_get_or_create(name);
if (btype->stages) {
con = btype->stages->construction;
} else {
btype->stages = calloc(1, sizeof(building_stage));
con = (construction *)calloc(1, sizeof(construction));
if (con) {
con->skill = SK_BUILDING;
con->maxsize = -1;
con->minskill = 1;
con->reqsize = 1;
btype->stages->construction = con;
}
}
if (con && !con->materials) {
con->materials = (requirement *)calloc(2, sizeof(requirement));
con->materials[1].number = 0;
con->materials[0].number = 1;
con->materials[0].rtype = get_resourcetype(R_STONE);
}
if (default_locale) {
if (locale_getstring(default_locale, name) == NULL) {
locale_setstring(default_locale, name, name);
}
}
return btype;
}
item_type * test_create_itemtype(const char * name) {
resource_type * rtype;
item_type * itype;
rtype = rt_get_or_create(name);
itype = it_get_or_create(rtype);
return itype;
}
void test_create_castorder(castorder *co, unit *u, int level, float force, int range, spellparameter *par) {
struct locale * lang;
order *ord;
lang = test_create_locale();
create_castorder(co, u, NULL, NULL, u->region, level, force, range, ord = create_order(K_CAST, lang, ""), par);
free_order(ord);
}
spell * test_create_spell(void)
{
spell *sp;
sp = create_spell("testspell");
sp->components = (spell_component *)calloc(4, sizeof(spell_component));
assert_alloc(sp->components);
sp->components[0].amount = 1;
sp->components[0].type = get_resourcetype(R_SILVER);
sp->components[0].cost = SPC_FIX;
sp->components[1].amount = 1;
sp->components[1].type = get_resourcetype(R_AURA);
sp->components[1].cost = SPC_LEVEL;
sp->components[2].amount = 1;
sp->components[2].type = get_resourcetype(R_HORSE);
sp->components[2].cost = SPC_LINEAR;
sp->syntax = 0;
sp->parameter = 0;
return sp;
}
void test_translate_param(const struct locale *lang, param_t param, const char *text) {
struct critbit_tree **cb;
assert(lang && text);
cb = (struct critbit_tree **)get_translations(lang, UT_PARAMS);
add_translation(cb, text, param);
}
item_type *test_create_silver(void) {
item_type * itype;
itype = test_create_itemtype("money");
itype->weight = 1;
return itype;
}
item_type *test_create_horse(void) {
item_type * itype;
itype = test_create_itemtype("horse");
itype->flags |= ITF_BIG | ITF_ANIMAL;
itype->weight = 5000;
itype->capacity = 7000;
return itype;
}
/** creates a small world and some stuff in it.
* two terrains: 'plain' and 'ocean'
* one race: 'human'
* one ship_type: 'boat'
* one building_type: 'castle'
* in 0.0 and 1.0 is an island of two plains, around it is ocean.
*/
void test_create_world(void)
{
terrain_type *t_plain, *t_ocean;
region *island[2];
int i;
item_type * itype;
struct locale * loc;
loc = test_create_locale();
locale_setstring(loc, parameters[P_SHIP], "SCHIFF");
locale_setstring(loc, parameters[P_ANY], "ALLE");
init_parameters(loc);
locale_setstring(loc, "status_aggressive", "aggressiv");
locale_setstring(loc, keyword(K_RESERVE), "RESERVIEREN");
locale_setstring(loc, "money", "Silber");
locale_setstring(loc, "money_p", "Silber");
locale_setstring(loc, "cart", "Wagen");
locale_setstring(loc, "cart_p", "Wagen");
locale_setstring(loc, "horse", "Pferd");
locale_setstring(loc, "horse_p", "Pferde");
locale_setstring(loc, "iron", "Eisen");
locale_setstring(loc, "iron_p", "Eisen");
locale_setstring(loc, "stone", "Stein");
locale_setstring(loc, "stone_p", "Steine");
locale_setstring(loc, "plain", "Ebene");
locale_setstring(loc, "ocean", "Ozean");
init_resources();
get_resourcetype(R_SILVER)->itype->weight = 1;
test_create_horse();
itype = test_create_itemtype("cart");
itype->flags |= ITF_BIG | ITF_VEHICLE;
itype->weight = 4000;
itype->capacity = 14000;
test_create_itemtype("iron");
test_create_itemtype("stone");
t_plain = test_create_terrain("plain", LAND_REGION | FOREST_REGION | WALK_INTO | CAVALRY_REGION | FLY_INTO);
t_plain->size = 1000;
t_plain->max_road = 100;
t_ocean = test_create_terrain("ocean", SEA_REGION | SWIM_INTO | FLY_INTO);
t_ocean->size = 0;
island[0] = test_create_region(0, 0, t_plain);
island[1] = test_create_region(1, 0, t_plain);
for (i = 0; i != 2; ++i) {
int j;
region *r = island[i];
for (j = 0; j != MAXDIRECTIONS; ++j) {
region *rn = r_connect(r, (direction_t)j);
if (!rn) {
rn = test_create_region(r->x + delta_x[j], r->y + delta_y[j], t_ocean);
}
}
}
test_create_race("human");
test_create_buildingtype("castle");
test_create_shiptype("boat");
}
message * test_get_last_message(message_list *msgs) {
if (msgs) {
struct mlist *iter = msgs->begin;
while (iter->next) {
iter = iter->next;
}
return iter->msg;
}
return 0;
}
const char * test_get_messagetype(const message *msg) {
const char * name;
assert(msg);
name = msg->type->name;
if (strcmp(name, "missing_message") == 0) {
name = (const char *)msg->parameters[0].v;
}
else if (strcmp(name, "missing_feedback") == 0) {
name = (const char *)msg->parameters[3].v;
}
return name;
}
struct message * test_find_messagetype_ex(struct message_list *msgs, const char *name, struct message *prev)
{
struct mlist *ml;
if (!msgs) return 0;
for (ml = msgs->begin; ml; ml = ml->next) {
if (prev && ml->msg == prev) {
prev = NULL;
}
else if (strcmp(name, test_get_messagetype(ml->msg)) == 0) {
return ml->msg;
}
}
return NULL;
}
struct message * test_find_messagetype(struct message_list *msgs, const char *name)
{
return test_find_messagetype_ex(msgs, name, NULL);
}
int test_count_messagetype(struct message_list *msgs, const char *name)
{
int count = 0;
struct mlist *ml;
if (!msgs) return 0;
for (ml = msgs->begin; ml; ml = ml->next) {
if (strcmp(name, test_get_messagetype(ml->msg)) == 0) {
++count;
}
}
return count;
}
void test_clear_messagelist(message_list **msgs) {
if (*msgs) {
free_messagelist((*msgs)->begin);
free(*msgs);
*msgs = NULL;
}
}
void test_clear_messages(faction *f) {
if (f->msgs) {
free_messagelist(f->msgs->begin);
free(f->msgs);
f->msgs = NULL;
}
}
void assert_message(CuTest * tc, message *msg, char *name, int numpar) {
const message_type *mtype = msg->type;
assert(mtype);
CuAssertStrEquals(tc, name, mtype->name);
CuAssertIntEquals(tc, numpar, mtype->nparameters);
}
void assert_pointer_parameter(CuTest * tc, message *msg, int index, void *arg) {
const message_type *mtype = (msg)->type;
CuAssertIntEquals((tc), VAR_VOIDPTR, mtype->types[(index)]->vtype); CuAssertPtrEquals((tc), (arg), msg->parameters[(index)].v);
}
void assert_int_parameter(CuTest * tc, message *msg, int index, int arg) {
const message_type *mtype = (msg)->type;
CuAssertIntEquals((tc), VAR_INT, mtype->types[(index)]->vtype); CuAssertIntEquals((tc), (arg), msg->parameters[(index)].i);
}
void assert_string_parameter(CuTest * tc, message *msg, int index, const char *arg) {
const message_type *mtype = (msg)->type;
CuAssertIntEquals((tc), VAR_VOIDPTR, mtype->types[(index)]->vtype); CuAssertStrEquals((tc), (arg), msg->parameters[(index)].v);
}
void disabled_test(void *suite, void(*test)(CuTest *), const char *name) {
(void)test;
fprintf(stderr, "%s: SKIP\n", name);
}
Reference in a new issue View git blame Copy permalink