自学教程：C++ test_create_faction函数代码示例

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_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")));}