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

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();}

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_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_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_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_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_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_resulttest_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_resulttest_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;}