static void test_give_unit(CuTest * tc) {
struct give env = { 0 };
test_setup_ex(tc);
env.f1 = test_create_faction(NULL);
env.f2 = test_create_faction(NULL);
setup_give(&env);
CuAssertIntEquals(tc, 1, env.f1->num_units);
CuAssertIntEquals(tc, 1, env.f2->num_units);
join_group(env.src, "group");
config_set("rules.give.max_men", "0");
give_unit(env.src, env.dst, NULL);
CuAssertPtrEquals(tc, env.f1, env.src->faction);
CuAssertIntEquals(tc, 0, env.f2->newbies);
config_set("rules.give.max_men", "-1");
give_unit(env.src, env.dst, NULL);
CuAssertPtrEquals(tc, env.f2, env.src->faction);
CuAssertPtrEquals(tc, NULL, get_group(env.src));
CuAssertIntEquals(tc, 1, env.f2->newbies);
CuAssertPtrEquals(tc, NULL, env.f1->units);
CuAssertPtrNotNull(tc, test_find_messagetype(env.f1->msgs, "give_person"));
CuAssertPtrNotNull(tc, test_find_messagetype(env.f2->msgs, "receive_person"));
test_teardown();
}
static void test_piracy_cmd(CuTest * tc) {
faction *f;
region *r;
unit *u, *u2;
terrain_type *t_ocean;
ship_type *st_boat;
test_setup();
setup_piracy();
t_ocean = get_or_create_terrain("ocean");
st_boat = st_get_or_create("boat");
u2 = test_create_unit(test_create_faction(NULL), test_create_region(1, 0, t_ocean));
assert(u2);
u_set_ship(u2, test_create_ship(u2->region, st_boat));
u = test_create_unit(f = test_create_faction(NULL), r = test_create_region(0, 0, t_ocean));
assert(f && u);
set_level(u, SK_SAILING, st_boat->sumskill);
u_set_ship(u, test_create_ship(u->region, st_boat));
f->locale = get_or_create_locale("de");
u->thisorder = create_order(K_PIRACY, f->locale, "%s", itoa36(u2->faction->no));
piracy_cmd(u);
CuAssertPtrEquals(tc, NULL, u->thisorder);
CuAssertTrue(tc, u->region != r);
CuAssertPtrEquals(tc, u2->region, u->region);
CuAssertPtrEquals(tc, u2->region, u->ship->region);
CuAssertPtrNotNullMsg(tc, "successful PIRACY sets attribute", r->attribs); /* FIXME: this is testing implementation, not interface */
CuAssertPtrNotNullMsg(tc, "successful PIRACY message", test_find_messagetype(f->msgs, "piratesawvictim"));
CuAssertPtrNotNullMsg(tc, "successful PIRACY movement", test_find_messagetype(f->msgs, "shipsail"));
test_teardown();
}
static void test_give_men_limit(CuTest * tc) {
struct give env = { 0 };
message *msg;
test_setup_ex(tc);
env.f2 = test_create_faction(NULL);
env.f1 = test_create_faction(NULL);
setup_give(&env);
config_set("rules.give.max_men", "1");
/* below the limit, give men, increase newbies counter */
contact_unit(env.dst, env.src);
msg = give_men(1, env.src, env.dst, NULL);
CuAssertStrEquals(tc, "give_person", test_get_messagetype(msg));
CuAssertIntEquals(tc, 2, env.dst->number);
CuAssertIntEquals(tc, 0, env.src->number);
CuAssertIntEquals(tc, 1, env.f2->newbies);
msg_release(msg);
/* beyond the limit, do nothing */
contact_unit(env.src, env.dst);
msg = give_men(2, env.dst, env.src, NULL);
CuAssertStrEquals(tc, "error129", test_get_messagetype(msg));
CuAssertIntEquals(tc, 2, env.dst->number);
CuAssertIntEquals(tc, 0, env.src->number);
CuAssertIntEquals(tc, 0, env.f1->newbies);
msg_release(msg);
test_teardown();
}
void test_upkeep_from_friend(CuTest * tc)
{
region *r;
unit *u1, *u2;
faction *f1, *f2;
const item_type *i_silver;
test_cleanup();
test_create_world();
i_silver = it_find("money");
assert(i_silver);
r = findregion(0, 0);
f1 = test_create_faction(test_create_race("human"));
f2 = test_create_faction(test_create_race("human"));
assert(f1 && f2);
set_alliance(f1, f2, HELP_MONEY);
u1 = test_create_unit(f1, r);
u2 = test_create_unit(f2, r);
assert(r && u1 && u2);
set_param(&global.parameters, "rules.food.flags", "0");
i_change(&u1->items, i_silver, 30);
get_food(r);
CuAssertIntEquals(tc, 10, i_get(u1->items, i_silver));
CuAssertIntEquals(tc, 0, fval(u1, UFL_HUNGER));
CuAssertIntEquals(tc, 0, fval(u2, UFL_HUNGER));
get_food(r);
CuAssertIntEquals(tc, 0, i_get(u1->items, i_silver));
CuAssertIntEquals(tc, 0, fval(u1, UFL_HUNGER));
CuAssertIntEquals(tc, UFL_HUNGER, fval(u2, UFL_HUNGER));
test_cleanup();
}
static void test_cmp_current_owner(CuTest *tc) {
region *r;
building *b1, *b2;
building_type *btype;
unit *u1, *u2;
test_setup();
config_set("rules.region_owners", "1");
r = test_create_region(0, 0, NULL);
btype = test_create_buildingtype("watch");
btype->stages->construction->maxsize = 1;
btype->taxes = 200;
b1 = test_create_building(r, btype);
btype = test_create_buildingtype("castle");
btype->stages->construction->maxsize = 1;
btype->taxes = 100;
b2 = test_create_building(r, btype);
b1->size = 1;
CuAssertIntEquals(tc, 1, buildingeffsize(b1, false));
b2->size = 1;
CuAssertIntEquals(tc, 1, buildingeffsize(b2, false));
u1 = test_create_unit(test_create_faction(NULL), r);
u_set_building(u1, b1);
u2 = test_create_unit(test_create_faction(NULL), r);
u_set_building(u2, b2);
region_set_owner(r, u1->faction, turn);
CuAssertPtrEquals(tc, b1, largestbuilding(r, cmp_current_owner, false));
CuAssertTrue(tc, cmp_current_owner(b2, b1) < 0);
CuAssertTrue(tc, cmp_current_owner(b1, b2) > 0);
CuAssertTrue(tc, cmp_current_owner(b1, b1) == 0);
test_teardown();
}
static void test_buildingowner_goes_to_same_faction_after_leave(CuTest * tc)
{
struct region *r;
struct building *bld;
struct unit *u, *u2, *u3;
struct faction *f1, *f2;
test_setup();
f1 = test_create_faction(NULL);
f2 = test_create_faction(NULL);
r = test_create_plain(0, 0);
bld = test_create_building(r, NULL);
CuAssertPtrNotNull(tc, bld);
u2 = test_create_unit(f2, r);
u3 = test_create_unit(f1, r);
u = test_create_unit(f1, r);
CuAssertPtrNotNull(tc, u);
u_set_building(u, bld);
u_set_building(u2, bld);
u_set_building(u3, bld);
CuAssertPtrEquals(tc, u, building_owner(bld));
leave_building(u);
CuAssertPtrEquals(tc, u3, building_owner(bld));
leave_building(u3);
CuAssertPtrEquals(tc, u2, building_owner(bld));
leave_building(u2);
CuAssertPtrEquals(tc, NULL, building_owner(bld));
test_teardown();
}
void test_upkeep_default(CuTest * tc)
{
region *r;
unit *u1, *u2;
faction *f1, *f2;
const item_type *i_silver;
test_cleanup();
test_create_world();
i_silver = it_find("money");
assert(i_silver);
r = findregion(0, 0);
f1 = test_create_faction(test_create_race("human"));
f2 = test_create_faction(test_create_race("human"));
assert(f1 && f2);
u1 = test_create_unit(f1, r);
u2 = test_create_unit(f2, r);
assert(r && u1 && u2);
set_param(&global.parameters, "rules.food.flags", "0");
i_change(&u1->items, i_silver, 20);
get_food(r);
// since u1 and u2 are not allied, u1 should not help u2 with upkeep
CuAssertIntEquals(tc, 10, i_get(u1->items, i_silver));
CuAssertIntEquals(tc, 0, fval(u1, UFL_HUNGER));
CuAssertIntEquals(tc, UFL_HUNGER, fval(u2, UFL_HUNGER));
test_cleanup();
}
static void test_piracy_cmd_land_to_land(CuTest * tc) {
unit *u;
region *r;
faction *f;
int target;
const terrain_type *t_plain;
const ship_type *stype;
test_setup();
setup_piracy();
t_plain = get_or_create_terrain("plain");
stype = test_create_shiptype("boat");
/* create a target: */
r = test_create_region(0, 0, t_plain);
f = test_create_faction(NULL);
u = test_create_unit(f, r);
u->ship = test_create_ship(r, stype);
target = f->no;
/* create a pirate: */
r = test_create_region(1, 0, t_plain);
f = test_create_faction(NULL);
u = test_create_unit(f, r);
u->ship = test_create_ship(r, stype);
set_level(u, SK_SAILING, u->ship->type->sumskill);
u->thisorder = create_order(K_PIRACY, f->locale, "%s", itoa36(target));
piracy_cmd(u);
CuAssertPtrEquals(tc, NULL, u->thisorder);
CuAssertPtrEquals(tc, r, u->region);
test_teardown();
}
static void test_sabotage_other_fail(CuTest *tc) {
unit *u, *u2;
region *r;
order *ord;
message *msg;
setup_sabotage();
r = test_create_region(0, 0, 0);
assert(r);
u = test_create_unit(test_create_faction(NULL), r);
u2 = test_create_unit(test_create_faction(NULL), r);
assert(u && u2);
u2->ship = test_create_ship(r, test_create_shiptype("boat"));
assert(u2->ship);
u->ship = u2->ship;
ship_update_owner(u->ship);
assert(ship_owner(u->ship) == u);
ord = create_order(K_SABOTAGE, u->faction->locale, "SCHIFF");
assert(ord);
CuAssertIntEquals(tc, 0, sabotage_cmd(u2, ord));
msg = test_get_last_message(u2->faction->msgs);
CuAssertStrEquals(tc, "destroy_ship_1", test_get_messagetype(msg));
msg = test_get_last_message(u->faction->msgs);
CuAssertStrEquals(tc, "destroy_ship_3", test_get_messagetype(msg));
CuAssertPtrNotNull(tc, r->ships);
free_order(ord);
test_cleanup();
}
static void test_give_new_unit(CuTest * tc) {
struct give env = { 0 };
test_setup_ex(tc);
env.f1 = test_create_faction(NULL);
env.f2 = test_create_faction(NULL);
setup_give(&env);
env.dst->number = 0;
fset(env.dst, UFL_ISNEW);
CuAssertPtrEquals(tc, NULL, check_give(env.src, env.dst, NULL));
test_teardown();
}
static void test_give_unit_other_race(CuTest * tc) {
struct give env = { 0 };
test_setup_ex(tc);
env.f1 = test_create_faction(test_create_race("elf"));
env.f2 = test_create_faction(test_create_race("orc"));
setup_give(&env);
scale_number(env.dst, 57);
CuAssertIntEquals(tc, 0, count_maxmigrants(env.f2));
give_unit(env.src, env.dst, NULL);
CuAssertIntEquals(tc, 0, env.f2->newbies);
CuAssertPtrNotNull(tc, test_find_messagetype(env.f1->msgs, "error120"));
test_teardown();
}
static void test_give_denied_by_rules(CuTest * tc) {
struct give env = { 0 };
struct message *msg;
test_setup_ex(tc);
env.f1 = test_create_faction(NULL);
env.f2 = test_create_faction(NULL);
setup_give(&env);
config_set("rules.give.flags", "0");
CuAssertPtrNotNull(tc, msg = check_give(env.src, env.dst, NULL));
msg_release(msg);
test_teardown();
}
static void test_give_dead_unit(CuTest * tc) {
struct give env = { 0 };
struct message *msg;
test_setup_ex(tc);
env.f1 = test_create_faction(NULL);
env.f2 = test_create_faction(NULL);
setup_give(&env);
env.dst->number = 0;
freset(env.dst, UFL_ISNEW);
CuAssertPtrNotNull(tc, msg = check_give(env.src, env.dst, NULL));
msg_release(msg);
test_teardown();
}
static void test_otherfaction(CuTest *tc) {
unit *u;
faction *f;
test_setup();
u = test_create_unit(test_create_faction(NULL), test_create_region(0, 0, NULL));
f = test_create_faction(NULL);
config_set("stealth.faction.other", "1");
CuAssertIntEquals(tc, true, rule_stealth_other());
CuAssertPtrEquals(tc, u->faction, visible_faction(f, u));
a_add(&u->attribs, make_otherfaction(f));
CuAssertPtrEquals(tc, f, visible_faction(f, u));
test_teardown();
}
static void test_give_men_other_faction(CuTest * tc) {
struct give env = { 0 };
message * msg;
test_setup_ex(tc);
env.f1 = test_create_faction(NULL);
env.f2 = test_create_faction(NULL);
setup_give(&env);
contact_unit(env.dst, env.src);
msg = give_men(1, env.src, env.dst, NULL);
CuAssertStrEquals(tc, "give_person", test_get_messagetype(msg));
CuAssertIntEquals(tc, 2, env.dst->number);
CuAssertIntEquals(tc, 0, env.src->number);
msg_release(msg);
test_teardown();
}
void test_change_resource(CuTest * tc)
{
struct unit * u;
struct faction * f;
struct region * r;
const char * names[] = { "money", "aura", "permaura", "horse", "hp", 0 };
int i;
test_cleanup();
test_create_world();
skill_enabled[SK_MAGIC] = 1;
r = findregion(0, 0);
f = test_create_faction(0);
u = test_create_unit(f, r);
CuAssertPtrNotNull(tc, u);
set_level(u, SK_MAGIC, 5);
create_mage(u, M_DRAIG);
for (i=0;names[i];++i) {
const struct resource_type *rtype = rt_find(names[i]);
int have = get_resource(u, rtype);
CuAssertIntEquals(tc, have+1, change_resource(u, rtype, 1));
CuAssertIntEquals(tc, have+1, get_resource(u, rtype));
}
}
static void test_give_men_magicians(CuTest * tc) {
struct give env = { 0 };
int p;
message * msg;
test_setup_ex(tc);
mt_create_error(158);
env.f2 = env.f1 = test_create_faction(NULL);
setup_give(&env);
set_level(env.src, SK_MAGIC, 1);
CuAssertPtrNotNull(tc, msg = give_men(1, env.src, env.dst, NULL));
CuAssertStrEquals(tc, "error158", test_get_messagetype(msg));
CuAssertIntEquals(tc, 1, env.dst->number);
CuAssertIntEquals(tc, 1, env.src->number);
msg_release(msg);
p = rpeasants(env.r);
CuAssertPtrNotNull(tc, msg = disband_men(1, env.dst, NULL));
CuAssertStrEquals(tc, "give_person_peasants", test_get_messagetype(msg));
CuAssertIntEquals(tc, 0, env.dst->number);
CuAssertIntEquals(tc, p+1, rpeasants(env.r));
msg_release(msg);
test_teardown();
}
static void test_give_unit_limits(CuTest * tc) {
struct give env = { 0 };
test_setup_ex(tc);
env.f1 = test_create_faction(NULL);
env.f2 = test_create_faction(NULL);
setup_give(&env);
config_set("rules.limit.faction", "1");
give_unit(env.src, env.dst, NULL);
CuAssertPtrEquals(tc, env.f1, env.src->faction);
CuAssertIntEquals(tc, 0, env.f2->newbies);
CuAssertIntEquals(tc, 1, env.f1->num_units);
CuAssertIntEquals(tc, 1, env.f2->num_units);
CuAssertPtrNotNull(tc, test_find_messagetype(env.f1->msgs, "too_many_units_in_faction"));
test_teardown();
}
void test_getspell_unit(CuTest * tc)
{
spell *sp;
struct unit * u;
struct faction * f;
struct region * r;
struct locale * lang;
test_cleanup();
test_create_world();
r = findregion(0, 0);
f = test_create_faction(0);
u = test_create_unit(f, r);
create_mage(u, M_GRAY);
skill_enabled[SK_MAGIC] = 1;
set_level(u, SK_MAGIC, 1);
lang = find_locale("de");
sp = create_spell("testspell", 0);
locale_setstring(lang, mkname("spell", sp->sname), "Herp-a-derp");
CuAssertPtrEquals(tc, 0, unit_getspell(u, "Herp-a-derp", lang));
unit_add_spell(u, 0, sp, 1);
CuAssertPtrNotNull(tc, unit_getspell(u, "Herp-a-derp", lang));
}
static void test_shipspeed_max_range(CuTest *tc) {
ship *sh;
ship_type *stype;
region *r;
struct faction *f;
unit *cap, *crew;
test_setup();
sh = setup_ship();
setup_crew(sh, 0, &cap, &crew);
config_set("movement.shipspeed.skillbonus", "5");
r = sh->region;
f = test_create_faction(NULL);
assert(r && f);
stype = st_get_or_create(sh->type->_name);
set_level(cap, SK_SAILING, stype->cptskill + 4);
set_level(crew, SK_SAILING, (stype->sumskill - stype->cptskill) * 4);
CuAssertIntEquals_Msg(tc, "skill bonus requires at least movement.shipspeed.skillbonus points", 2, shipspeed(sh, cap));
set_level(cap, SK_SAILING, stype->cptskill + 5);
set_level(crew, SK_SAILING, (stype->sumskill - stype->cptskill) * 5);
CuAssertIntEquals_Msg(tc, "skill bonus from movement.shipspeed.skillbonus", 3, shipspeed(sh, cap));
set_level(cap, SK_SAILING, stype->cptskill + 15);
scale_number(crew, 15);
set_level(crew, SK_SAILING, stype->sumskill - stype->cptskill);
CuAssertIntEquals_Msg(tc, "skill-bonus cannot exceed max_range", 4, shipspeed(sh, cap));
test_teardown();
}
static void test_shipspeed_speedy(CuTest *tc) {
ship_type *stype;
ship *sh;
unit *cap, *crw;
test_setup();
stype = test_create_shiptype("dragonship");
stype->range = 5;
stype->range_max = -1;
stype->flags |= SFL_SPEEDY;
cap = test_create_unit(test_create_faction(NULL), test_create_region(0, 0, NULL));
crw = test_create_unit(cap->faction, cap->region);
sh = test_create_ship(cap->region, stype);
cap->ship = sh;
crw->ship = sh;
set_level(cap, SK_SAILING, stype->cptskill);
set_level(crw, SK_SAILING, stype->sumskill - stype->cptskill);
CuAssertPtrEquals(tc, cap, ship_owner(sh));
CuAssertIntEquals(tc, 5, shipspeed(sh, cap));
set_level(cap, SK_SAILING, stype->cptskill * 3 - 1);
CuAssertIntEquals(tc, 5, shipspeed(sh, cap));
set_level(cap, SK_SAILING, stype->cptskill * 3);
CuAssertIntEquals(tc, 6, shipspeed(sh, cap));
set_level(cap, SK_SAILING, stype->cptskill * 3 * 3 - 1);
CuAssertIntEquals(tc, 6, shipspeed(sh, cap));
set_level(cap, SK_SAILING, stype->cptskill * 3 * 3);
CuAssertIntEquals(tc, 7, shipspeed(sh, cap));
test_teardown();
}
static void test_ship_set_owner(CuTest * tc)
{
struct region *r;
struct ship *sh;
struct unit *u1, *u2;
struct faction *f;
const struct ship_type *stype;
const struct race *human;
test_setup();
test_create_world();
human = rc_find("human");
stype = st_find("boat");
f = test_create_faction(human);
r = findregion(0, 0);
sh = test_create_ship(r, stype);
u1 = test_create_unit(f, r);
u_set_ship(u1, sh);
CuAssertPtrEquals(tc, u1, ship_owner(sh));
u2 = test_create_unit(f, r);
u_set_ship(u2, sh);
CuAssertPtrEquals(tc, u1, ship_owner(sh));
ship_set_owner(u2);
CuAssertPtrEquals(tc, u2, ship_owner(sh));
test_teardown();
}
static void test_rename_building_twice(CuTest * tc)
{
region *r;
building *b;
unit *u;
faction *f;
building_type *btype;
test_cleanup();
test_create_world();
btype = bt_get_or_create("castle");
r = findregion(-1, 0);
b = new_building(btype, r, default_locale);
f = test_create_faction(rc_find("human"));
u = test_create_unit(f, r);
u_set_building(u, b);
rename_building(u, NULL, b, "Villa Nagel");
CuAssertStrEquals(tc, "Villa Nagel", b->name);
rename_building(u, NULL, b, "Villa Kunterbunt");
CuAssertStrEquals(tc, "Villa Kunterbunt", b->name);
}
static void test_fishing_feeds_2_people(CuTest * tc)
{
const resource_type *rtype;
region *r;
faction *f;
unit *u;
ship *sh;
test_cleanup();
test_create_world();
r = findregion(-1, 0);
CuAssertStrEquals(tc, "ocean", r->terrain->_name); /* test_create_world needs coverage */
f = test_create_faction(rc_find("human"));
u = test_create_unit(f, r);
sh = new_ship(st_find("boat"), r, 0);
u_set_ship(u, sh);
rtype = get_resourcetype(R_SILVER);
i_change(&u->items, rtype->itype, 42);
scale_number(u, 1);
sh->flags |= SF_FISHING;
get_food(r);
CuAssertIntEquals(tc, 42, i_get(u->items, rtype->itype));
scale_number(u, 2);
sh->flags |= SF_FISHING;
get_food(r);
CuAssertIntEquals(tc, 42, i_get(u->items, rtype->itype));
scale_number(u, 3);
sh->flags |= SF_FISHING;
get_food(r);
CuAssertIntEquals(tc, 32, i_get(u->items, rtype->itype));
}
void test_set_post_combatspell(CuTest * tc)
{
spell *sp;
struct unit * u;
struct faction * f;
struct region * r;
const int index = 2;
test_cleanup();
test_create_world();
r = findregion(0, 0);
f = test_create_faction(0);
f->magiegebiet = M_TYBIED;
u = test_create_unit(f, r);
skill_enabled[SK_MAGIC] = 1;
set_level(u, SK_MAGIC, 1);
sp = create_spell("testspell", 0);
sp->sptyp |= POSTCOMBATSPELL;
unit_add_spell(u, 0, sp, 1);
set_combatspell(u, sp, 0, 2);
CuAssertPtrEquals(tc, sp, (spell *)get_combatspell(u, index));
set_level(u, SK_MAGIC, 2);
CuAssertIntEquals(tc, 2, get_combatspelllevel(u, index));
set_level(u, SK_MAGIC, 1);
CuAssertIntEquals(tc, 1, get_combatspelllevel(u, index));
unset_combatspell(u, sp);
CuAssertIntEquals(tc, 0, get_combatspelllevel(u, index));
CuAssertPtrEquals(tc, 0, (spell *)get_combatspell(u, index));
}
void test_getspell_school(CuTest * tc)
{
spell *sp;
struct unit * u;
struct faction * f;
struct region * r;
struct locale * lang;
struct spellbook * book;
test_cleanup();
test_create_world();
r = findregion(0, 0);
f = test_create_faction(0);
f->magiegebiet = M_TYBIED;
u = test_create_unit(f, r);
create_mage(u, f->magiegebiet);
skill_enabled[SK_MAGIC] = 1;
set_level(u, SK_MAGIC, 1);
lang = find_locale("de");
sp = create_spell("testspell", 0);
locale_setstring(lang, mkname("spell", sp->sname), "Herp-a-derp");
CuAssertPtrEquals(tc, 0, unit_getspell(u, "Herp-a-derp", lang));
book = faction_get_spellbook(f);
CuAssertPtrNotNull(tc, book);
spellbook_add(book, sp, 1);
CuAssertPtrEquals(tc, sp, unit_getspell(u, "Herp-a-derp", lang));
}
void test_hasspell(CuTest * tc)
{
spell *sp;
struct unit * u;
struct faction * f;
struct region * r;
test_cleanup();
test_create_world();
r = findregion(0, 0);
f = test_create_faction(0);
f->magiegebiet = M_TYBIED;
u = test_create_unit(f, r);
skill_enabled[SK_MAGIC] = 1;
sp = create_spell("testspell", 0);
sp->sptyp |= POSTCOMBATSPELL;
unit_add_spell(u, 0, sp, 2);
set_level(u, SK_MAGIC, 1);
CuAssertTrue(tc, !u_hasspell(u, sp));
set_level(u, SK_MAGIC, 2);
CuAssertTrue(tc, u_hasspell(u, sp));
set_level(u, SK_MAGIC, 1);
CuAssertTrue(tc, !u_hasspell(u, sp));
}
static void test_shipowner_goes_to_other_when_empty(CuTest * tc)
{
struct region *r;
struct ship *sh;
struct unit *u, *u2;
struct faction *f;
const struct ship_type *stype;
const struct race *human;
test_setup();
test_create_world();
human = rc_find("human");
CuAssertPtrNotNull(tc, human);
stype = st_find("boat");
CuAssertPtrNotNull(tc, stype);
f = test_create_faction(human);
r = findregion(0, 0);
sh = test_create_ship(r, stype);
CuAssertPtrNotNull(tc, sh);
u2 = test_create_unit(f, r);
u = test_create_unit(f, r);
CuAssertPtrNotNull(tc, u);
u_set_ship(u, sh);
u_set_ship(u2, sh);
CuAssertPtrEquals(tc, u, ship_owner(sh));
u->number = 0;
CuAssertPtrEquals(tc, u2, ship_owner(sh));
test_teardown();
}
static void test_group(CuTest * tc)
{
unit *u;
region *r;
faction *f;
group *g;
test_cleanup();
test_create_world();
r = findregion(0, 0);
f = test_create_faction(0);
assert(r && f);
u = test_create_unit(f, r);
assert(u);
CuAssertTrue(tc, join_group(u, "hodor"));
CuAssertPtrNotNull(tc, (g = get_group(u)));
CuAssertStrEquals(tc, "hodor", g->name);
CuAssertIntEquals(tc, 1, g->members);
set_group(u, 0);
CuAssertIntEquals(tc, 0, g->members);
CuAssertPtrEquals(tc, 0, get_group(u));
set_group(u, g);
CuAssertIntEquals(tc, 1, g->members);
CuAssertPtrEquals(tc, g, get_group(u));
test_cleanup();
}
void test_pay_spell(CuTest * tc)
{
spell *sp;
unit * u;
faction * f;
region * r;
int level;
test_cleanup();
test_create_world();
r = findregion(0, 0);
f = test_create_faction(0);
u = test_create_unit(f, r);
CuAssertPtrNotNull(tc, u);
sp = test_magic_create_spell();
CuAssertPtrNotNull(tc, sp);
set_level(u, SK_MAGIC, 5);
unit_add_spell(u, 0, sp, 1);
change_resource(u, rt_find("money"), 1);
change_resource(u, rt_find("aura"), 3);
change_resource(u, rt_find("horse"), 3);
level = eff_spelllevel(u, sp, 3, 1);
CuAssertIntEquals(tc, 3, level);
pay_spell(u, sp, level, 1);
CuAssertIntEquals(tc, 0, get_resource(u, rt_find("money")));
CuAssertIntEquals(tc, 0, get_resource(u, rt_find("aura")));
CuAssertIntEquals(tc, 0, get_resource(u, rt_find("horse")));
}