void test_upkeep_from_pool(CuTest * tc)
{
region *r;
unit *u1, *u2;
const item_type *i_silver;
test_cleanup();
test_create_world();
i_silver = it_find("money");
assert(i_silver);
r = findregion(0, 0);
u1 = test_create_unit(test_create_faction(test_create_race("human")), r);
assert(u1);
u2 = test_create_unit(u1->faction, 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_ships(CuTest * tc)
{
const char * data = "{\"ships\": { \"boat\" : { "
"\"construction\" : { \"maxsize\" : 20, \"reqsize\" : 10, \"minskill\" : 1 },"
"\"coasts\" : [ \"plain\" ]"
"}}}";
cJSON *json = cJSON_Parse(data);
const ship_type *st;
const terrain_type *ter;
test_cleanup();
CuAssertPtrNotNull(tc, json);
CuAssertPtrEquals(tc, 0, shiptypes);
json_config(json);
CuAssertPtrNotNull(tc, shiptypes);
st = st_find("boat");
CuAssertPtrNotNull(tc, st);
CuAssertPtrNotNull(tc, st->construction);
CuAssertIntEquals(tc, 10, st->construction->reqsize);
CuAssertIntEquals(tc, 20, st->construction->maxsize);
CuAssertIntEquals(tc, 1, st->construction->minskill);
ter = get_terrain("plain");
CuAssertPtrNotNull(tc, ter);
CuAssertPtrNotNull(tc, st->coasts);
CuAssertPtrEquals(tc, (void *)ter, (void *)st->coasts[0]);
CuAssertPtrEquals(tc, 0, (void *)st->coasts[1]);
test_cleanup();
}
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();
}
void test_upkeep_hunger_damage(CuTest * tc)
{
region *r;
unit *u1;
faction *f1;
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"));
u1 = test_create_unit(f1, r);
assert(r && u1);
set_param(&global.parameters, "rules.food.flags", "0");
u1->hp = 100;
get_food(r);
// since u1 and u2 are not allied, u1 should not help u2 with upkeep
CuAssertTrue(tc, u1->hp < 100);
test_cleanup();
}
static void test_addfaction(CuTest *tc) {
faction *f = 0;
const struct race *rc;
const struct locale *lang;
test_cleanup();
rc = rc_get_or_create("human");
lang = test_create_locale();
f = addfaction("*****@*****.**", "hurrdurr", rc, lang, 1234);
CuAssertPtrNotNull(tc, f);
CuAssertPtrNotNull(tc, f->name);
CuAssertPtrEquals(tc, NULL, (void *)f->units);
CuAssertPtrEquals(tc, NULL, (void *)f->next);
CuAssertPtrEquals(tc, NULL, (void *)f->banner);
CuAssertPtrEquals(tc, NULL, (void *)f->spellbook);
CuAssertPtrEquals(tc, NULL, (void *)f->ursprung);
CuAssertPtrEquals(tc, (void *)factions, (void *)f);
CuAssertStrEquals(tc, "*****@*****.**", f->email);
CuAssertTrue(tc, checkpasswd(f, "hurrdurr"));
CuAssertPtrEquals(tc, (void *)lang, (void *)f->locale);
CuAssertIntEquals(tc, 1234, f->subscription);
CuAssertIntEquals(tc, FFL_ISNEW, f->flags);
CuAssertIntEquals(tc, 0, f->age);
CuAssertTrue(tc, faction_alive(f));
CuAssertIntEquals(tc, M_GRAY, f->magiegebiet);
CuAssertIntEquals(tc, turn, f->lastorders);
CuAssertPtrEquals(tc, f, findfaction(f->no));
test_cleanup();
}
void test_spellbooks(CuTest * tc)
{
spell *sp;
spellbook *herp, *derp;
spellbook_entry *entry;
const char * sname = "herpderp";
test_cleanup();
herp = get_spellbook("herp");
derp = get_spellbook("derp");
CuAssertPtrNotNull(tc, herp);
CuAssertPtrNotNull(tc, derp);
CuAssertTrue(tc, derp!=herp);
CuAssertStrEquals(tc, "herp", herp->name);
CuAssertStrEquals(tc, "derp", derp->name);
sp = create_spell(sname, 0);
spellbook_add(herp, sp, 1);
CuAssertPtrNotNull(tc, sp);
entry = spellbook_get(herp, sp);
CuAssertPtrNotNull(tc, entry);
CuAssertPtrEquals(tc, sp, entry->sp);
/* CuAssertPtrEquals(tc, 0, spellbook_get(derp, sname)); */
test_cleanup();
herp = get_spellbook("herp");
CuAssertPtrNotNull(tc, herp);
/* CuAssertPtrEquals(tc, 0, spellbook_get(herp, sname)); */
}
static void test_set_origin(CuTest *tc) {
faction *f;
int x = 0, y = 0;
plane *pl;
test_cleanup();
test_create_world();
pl = create_new_plane(0, "", 0, 19, 0, 19, 0);
f = test_create_faction(0);
CuAssertPtrEquals(tc, 0, f->ursprung);
faction_setorigin(f, 0, 1, 1);
CuAssertIntEquals(tc, 0, f->ursprung->id);
CuAssertIntEquals(tc, 1, f->ursprung->x);
CuAssertIntEquals(tc, 1, f->ursprung->y);
faction_getorigin(f, 0, &x, &y);
CuAssertIntEquals(tc, 1, x);
CuAssertIntEquals(tc, 1, y);
adjust_coordinates(f, &x, &y, pl);
CuAssertIntEquals(tc, -9, x);
CuAssertIntEquals(tc, -9, y);
adjust_coordinates(f, &x, &y, 0);
CuAssertIntEquals(tc, -10, x);
CuAssertIntEquals(tc, -10, y);
test_cleanup();
}
static void test_shipspeed_max_range(CuTest *tc) {
ship *sh;
ship_type *stype;
region *r;
struct faction *f;
unit *cap, *crew;
test_cleanup();
sh = setup_ship();
setup_crew(sh, 0, &cap, &crew);
set_param(&global.parameters, "movement.shipspeed.skillbonus", "5");
r = sh->region;
f = test_create_faction(0);
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);
set_level(crew, SK_SAILING, (stype->sumskill - stype->cptskill) * 15);
CuAssertIntEquals_Msg(tc, "skill-bonus cannot exceed max_range", 4, shipspeed(sh, cap));
test_cleanup();
}
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();
}
static void test_tax_cmd(CuTest *tc) {
order *ord;
faction *f;
region *r;
unit *u;
item_type *sword, *silver;
request *taxorders = 0;
test_cleanup();
config_set("taxing.perlevel", "20");
test_create_world();
f = test_create_faction(NULL);
r = findregion(0, 0);
assert(r && f);
u = test_create_unit(f, r);
ord = create_order(K_TAX, f->locale, "");
assert(ord);
tax_cmd(u, ord, &taxorders);
CuAssertPtrNotNull(tc, test_find_messagetype(u->faction->msgs, "error48"));
test_clear_messages(u->faction);
silver = get_resourcetype(R_SILVER)->itype;
sword = it_get_or_create(rt_get_or_create("sword"));
new_weapontype(sword, 0, 0.0, NULL, 0, 0, 0, SK_MELEE, 1);
i_change(&u->items, sword, 1);
set_level(u, SK_MELEE, 1);
tax_cmd(u, ord, &taxorders);
CuAssertPtrNotNull(tc, test_find_messagetype(u->faction->msgs, "error_no_tax_skill"));
test_clear_messages(u->faction);
set_level(u, SK_TAXING, 1);
tax_cmd(u, ord, &taxorders);
CuAssertPtrEquals(tc, 0, test_find_messagetype(u->faction->msgs, "error_no_tax_skill"));
CuAssertPtrNotNull(tc, taxorders);
rsetmoney(r, 11);
expandtax(r, taxorders);
CuAssertPtrNotNull(tc, test_find_messagetype(u->faction->msgs, "income"));
/* taxing is in multiples of 10 */
CuAssertIntEquals(tc, 10, i_get(u->items, silver));
test_clear_messages(u->faction);
i_change(&u->items, silver, -i_get(u->items, silver));
rsetmoney(r, 1000);
taxorders = 0;
tax_cmd(u, ord, &taxorders);
expandtax(r, taxorders);
CuAssertIntEquals(tc, 20, i_get(u->items, silver));
test_clear_messages(u->faction);
free_order(ord);
test_cleanup();
}
static void test_export_ocean_region(CuTest * tc) {
struct terrain_type *terrain;
cJSON *json;
test_cleanup();
terrain = test_create_terrain("ocean", SEA_REGION);
json = export_a_region(tc, terrain, 0);
CuAssertPtrEquals(tc, 0, cJSON_GetObjectItem(json, "name"));
cJSON_Delete(json);
test_cleanup();
}
static void test_init_directions(CuTest *tc) {
struct locale *lang;
test_cleanup();
lang = get_or_create_locale("en");
locale_setstring(lang, "dir_nw", "NW");
init_directions(lang);
CuAssertIntEquals(tc, D_NORTHWEST, get_direction("nw", lang));
test_cleanup();
}
static void test_param_flt(CuTest * tc)
{
struct param *par = 0;
test_cleanup();
CuAssertDblEquals(tc, 13, get_param_flt(par, "foo", 13), 0.01);
set_param(&par, "foo", "23.0");
set_param(&par, "bar", "42.0");
CuAssertDblEquals(tc, 23.0, get_param_flt(par, "foo", 0.0), 0.01);
CuAssertDblEquals(tc, 42.0, get_param_flt(par, "bar", 0.0), 0.01);
free_params(&par);
test_cleanup();
}
static void test_export_land_region(CuTest * tc) {
region *r;
struct terrain_type *terrain;
cJSON *json, *attr;
test_cleanup();
terrain = test_create_terrain("plain", LAND_REGION);
json = export_a_region(tc, terrain, &r);
CuAssertPtrNotNull(tc, attr = cJSON_GetObjectItem(json, "name"));
CuAssertStrEquals(tc, r->land->name, attr->valuestring);
cJSON_Delete(json);
test_cleanup();
}
static void test_param_int(CuTest * tc)
{
struct param *par = 0;
test_cleanup();
CuAssertIntEquals(tc, 13, get_param_int(par, "foo", 13));
set_param(&par, "foo", "23");
set_param(&par, "bar", "42");
CuAssertIntEquals(tc, 23, get_param_int(par, "foo", 0));
CuAssertIntEquals(tc, 42, get_param_int(par, "bar", 0));
free_params(&par);
test_cleanup();
}
static void test_init_direction(CuTest *tc) {
struct locale *lang;
test_cleanup();
lang = get_or_create_locale("de");
init_direction(lang, D_NORTHWEST, "NW");
init_direction(lang, D_EAST, "OST");
CuAssertIntEquals(tc, D_NORTHWEST, get_direction("nw", lang));
CuAssertIntEquals(tc, D_EAST, get_direction("ost", lang));
CuAssertIntEquals(tc, NODIRECTION, get_direction("east", lang));
test_cleanup();
}
static void test_steal_okay(CuTest * tc) {
struct steal env;
race *rc;
struct terrain_type *ter;
test_cleanup();
ter = test_create_terrain("plain", LAND_REGION);
rc = test_create_race("human");
rc->flags = 0;
setup_steal(&env, ter, rc);
CuAssertPtrEquals(tc, 0, check_steal(env.u, 0));
test_cleanup();
}
static void test_resourcename_with_appearance(CuTest *tc) {
item_type *itype;
test_cleanup();
itype = it_get_or_create(rt_get_or_create("foo"));
assert(itype && itype->rtype);
it_set_appearance(itype, "bar");
CuAssertStrEquals(tc, "foo", resourcename(itype->rtype, 0));
CuAssertStrEquals(tc, "foo_p", resourcename(itype->rtype, NMF_PLURAL));
CuAssertStrEquals(tc, "bar", resourcename(itype->rtype, NMF_APPEARANCE));
CuAssertStrEquals(tc, "bar_p", resourcename(itype->rtype, NMF_APPEARANCE | NMF_PLURAL));
test_cleanup();
}
static void test_give_okay(CuTest * tc) {
struct give env;
struct race * rc;
test_cleanup();
rc = test_create_race("human");
env.f2 = env.f1 = test_create_faction(rc);
setup_give(&env);
set_param(&global.parameters, "rules.give", "0");
CuAssertPtrEquals(tc, 0, check_give(env.src, env.dst, 0));
test_cleanup();
}
static void test_normals_recruit(CuTest * tc) {
unit *u;
test_cleanup();
u = create_recruiter();
unit_addorder(u, create_order(K_RECRUIT, default_locale, "1"));
economics(u->region);
CuAssertIntEquals(tc, 2, u->number);
test_cleanup();
}
static void test_steal_ocean(CuTest * tc) {
struct steal env;
race *rc;
terrain_type *ter;
message *msg;
test_cleanup();
ter = test_create_terrain("ocean", SEA_REGION);
rc = test_create_race("human");
setup_steal(&env, ter, rc);
CuAssertPtrNotNull(tc, msg = check_steal(env.u, 0));
msg_release(msg);
test_cleanup();
}
static void test_shipspeed_shipspeedup(CuTest *tc) {
ship *sh;
unit *cap, *crew;
test_cleanup();
sh = setup_ship();
setup_crew(sh, 0, &cap, &crew);
register_shipcurse();
assert(sh && cap && crew);
create_curse(0, &sh->attribs, ct_find("shipspeedup"), 1, 1, 3, 0);
CuAssertIntEquals_Msg(tc, "shipspeedup adds effect to range", sh->type->range + 3, shipspeed(sh, cap));
test_cleanup();
}
static void test_steal_nosteal(CuTest * tc) {
struct steal env;
race *rc;
terrain_type *ter;
message *msg;
test_cleanup();
ter = test_create_terrain("plain", LAND_REGION);
rc = test_create_race("human");
rc->flags = RCF_NOSTEAL;
setup_steal(&env, ter, rc);
CuAssertPtrNotNull(tc, msg = check_steal(env.u, 0));
msg_release(msg);
test_cleanup();
}
static void test_spawn_seaserpent(CuTest *tc) {
region *r;
unit *u;
faction *f;
race *rc;
test_cleanup();
rc = test_create_race("seaserpent");
rc->flags |= RCF_NPC;
r = test_create_region(0, 0, 0);
f = test_create_faction(0);
u = spawn_seaserpent(r, f);
CuAssertPtrNotNull(tc, u);
CuAssertPtrEquals(tc, 0, u->_name);
test_cleanup();
}
static void test_remove_empty_factions_alliance(CuTest *tc) {
faction *f;
struct alliance *al;
test_cleanup();
f = test_create_faction(0);
al = makealliance(0, "Hodor");
setalliance(f, al);
CuAssertPtrEquals(tc, f, alliance_get_leader(al));
CuAssertIntEquals(tc, 1, ql_length(al->members));
remove_empty_factions();
CuAssertPtrEquals(tc, 0, al->_leader);
CuAssertIntEquals(tc, 0, ql_length(al->members));
test_cleanup();
}
static void test_shipspeed_race_bonus(CuTest *tc) {
ship *sh;
unit *cap, *crew;
race *rc;
test_cleanup();
sh = setup_ship();
setup_crew(sh, 0, &cap, &crew);
assert(sh && cap && crew);
rc = rc_get_or_create(cap->_race->_name);
rc->flags |= RCF_SHIPSPEED;
CuAssertIntEquals_Msg(tc, "captain with RCF_SHIPSPEED adds +1 to range", sh->type->range + 1, shipspeed(sh, cap));
test_cleanup();
}
static void test_add_prefix(CuTest *tc) {
test_cleanup();
CuAssertPtrEquals(tc, 0, race_prefixes);
add_raceprefix("sea");
CuAssertPtrNotNull(tc, race_prefixes);
CuAssertStrEquals(tc, "sea", race_prefixes[0]);
CuAssertPtrEquals(tc, 0, race_prefixes[1]);
add_raceprefix("moon");
CuAssertStrEquals(tc, "sea", race_prefixes[0]);
CuAssertStrEquals(tc, "moon", race_prefixes[1]);
CuAssertPtrEquals(tc, 0, race_prefixes[2]);
free_prefixes();
CuAssertPtrEquals(tc, 0, race_prefixes);
test_cleanup();
}
static void test_resourcename_no_appearance(CuTest *tc) {
const resource_type *rtype;
test_cleanup();
init_resources(); // creates R_SILVER
rtype = get_resourcetype(R_SILVER);
assert(rtype && rtype->itype);
assert(rtype->itype->_appearance[0] == 0);
assert(rtype->itype->_appearance[1] == 0);
CuAssertStrEquals(tc, "money", resourcename(rtype, 0));
CuAssertStrEquals(tc, "money_p", resourcename(rtype, NMF_PLURAL));
CuAssertStrEquals(tc, "money", resourcename(rtype, NMF_APPEARANCE));
CuAssertStrEquals(tc, "money_p", resourcename(rtype, NMF_APPEARANCE | NMF_PLURAL));
test_cleanup();
}
/**
* Verify that eglClientWaitSyncKHR() emits correct error when given an invalid
* sync object.
*
* From the EGL_KHR_fence_sync:
*
* * If <sync> is not a valid sync object for <dpy>, EGL_FALSE is
* returned and an EGL_BAD_PARAMETER error is generated.
*/
static enum piglit_result
test_eglClientWaitSyncKHR_invalid_sync(void *test_data)
{
enum piglit_result result = PIGLIT_PASS;
EGLint wait_status = 0;
EGLSyncKHR invalid_sync = (EGLSyncKHR) &canary;
result = test_setup();
if (result != PIGLIT_PASS) {
return result;
}
wait_status = peglClientWaitSyncKHR(g_dpy, invalid_sync, 0, 0);
if (wait_status != EGL_FALSE) {
piglit_loge("Given an invalid sync object, eglClientWaitSyncKHR() "
"should return EGL_FALSE, but returned 0x%x",
wait_status);
result = PIGLIT_FAIL;
}
if (!piglit_check_egl_error(EGL_BAD_PARAMETER)) {
piglit_loge("Given an invalid sync object, eglClientWaitSyncKHR() "
"did not emit EGL_BAD_PARAMETER");
result = PIGLIT_FAIL;
}
test_cleanup(EGL_NO_SYNC_KHR, &result);
return result;
}
/**
* Verify that eglClientWaitSyncKHR() accepts the
* EGL_SYNC_FLUSH_COMMANDS_BIT_KHR flag.
*
* From the EGL_KHR_fence_sync:
*
* Accepted in the <flags> parameter of eglClientWaitSyncKHR:
* EGL_SYNC_FLUSH_COMMANDS_BIT_KHR 0x0001
*/
static enum piglit_result
test_eglClientWaitSyncKHR_flag_sync_flush(void *test_data)
{
enum piglit_result result = PIGLIT_PASS;
EGLSyncKHR sync = 0;
EGLint wait_status = 0;
result = test_setup();
if (result != PIGLIT_PASS) {
return result;
}
glClear(GL_COLOR_BUFFER_BIT);
sync = peglCreateSyncKHR(g_dpy, EGL_SYNC_FENCE_KHR, NULL);
if (!sync) {
piglit_loge("eglCreateSyncKHR(EGL_SYNC_FENCE_KHR) failed");
result = PIGLIT_FAIL;
goto cleanup;
}
wait_status = peglClientWaitSyncKHR(g_dpy, sync,
EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, 0);
if (wait_status != EGL_TIMEOUT_EXPIRED_KHR &&
wait_status != EGL_CONDITION_SATISFIED_KHR) {
piglit_loge("eglClientWaitSyncKHR() before glFinish:\n"
" Expected status: EGL_TIMEOUT_EXPIRED_KHR or "
" EGL_CONDITION_SATISFIED_KHR\n"
" Actual status: 0x%x\n", wait_status);
result = PIGLIT_FAIL;
}
cleanup:
test_cleanup(sync, &result);
return result;
}
