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

void test_buildingowner_goes_to_empty_unit_after_leave(CuTest * tc){    struct region *r;    struct building *bld;    struct unit *u1, *u2, *u3;    struct faction *f1;    test_setup();    f1 = test_create_faction(NULL);    r = test_create_plain(0, 0);    bld = test_create_building(r, NULL);    CuAssertPtrNotNull(tc, bld);    u1 = test_create_unit(f1, r);    u2 = test_create_unit(f1, r);    u3 = test_create_unit(f1, r);    u_set_building(u1, bld);    u_set_building(u2, bld);    u_set_building(u3, bld);    CuAssertPtrEquals(tc, u1, building_owner(bld));    u2->number = 0;    leave_building(u1);    CuAssertPtrEquals(tc, u3, building_owner(bld));    leave_building(u3);    CuAssertPtrEquals(tc, NULL, building_owner(bld));    u2->number = 1;    CuAssertPtrEquals(tc, u2, building_owner(bld));    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();}

static void test_active_building(CuTest *tc) {    building *b;    region *r;    unit *u;    building_type *btype;    test_setup();    btype = test_create_buildingtype("castle");    assert(btype && btype->maxsize == -1);    b = test_create_building(r = test_create_region(0, 0, NULL), btype);    u = test_create_unit(test_create_faction(NULL), r);    CuAssertIntEquals(tc, false, building_is_active(b));    CuAssertPtrEquals(tc, NULL, active_building(u, btype));    b->flags |= BLD_MAINTAINED;    CuAssertIntEquals(tc, true, building_is_active(b));    CuAssertPtrEquals(tc, NULL, active_building(u, btype));    u_set_building(u, b);    CuAssertIntEquals(tc, true, building_is_active(b));    CuAssertPtrNotNull(tc, active_building(u, btype) );    btype->maxsize = 10;    b->size = btype->maxsize;    CuAssertIntEquals(tc, true, building_is_active(b));    CuAssertPtrNotNull(tc, active_building(u, btype) );    b->size = 9;    CuAssertIntEquals(tc, false, building_is_active(b));    CuAssertPtrEquals(tc, NULL, active_building(u, btype));    btype->maxsize = -1;    b->flags &= ~BLD_MAINTAINED;    CuAssertIntEquals(tc, false, building_is_active(b));    CuAssertPtrEquals(tc, NULL, active_building(u, btype));    test_teardown();}

static void setup_resources(void) {    struct locale *lang;    item_type *itype;    test_setup();    itype = it_get_or_create(rt_get_or_create("stone"));    itype->rtype->flags = RTF_LIMITED | RTF_POOLED;    itype->construction = calloc(1, sizeof(construction));    itype->construction->skill = SK_QUARRYING;    itype->construction->minskill = 1;    rmt_create(itype->rtype);    init_resources();    lang = get_or_create_locale("de"); /* CR tags are translated from this */    locale_setstring(lang, "money", "Silber");    locale_setstring(lang, "money_p", "Silber");    locale_setstring(lang, "horse", "Pferd");    locale_setstring(lang, "horse_p", "Pferde");    locale_setstring(lang, "peasant", "Bauer");    locale_setstring(lang, "peasant_p", "Bauern");    locale_setstring(lang, "stone", "Stein");    locale_setstring(lang, "stone_p", "Steine");    locale_setstring(lang, "tree", "Blume");    locale_setstring(lang, "tree_p", "Blumen");    locale_setstring(lang, "sapling", "Schoessling");    locale_setstring(lang, "sapling_p", "Schoesslinge");    locale_setstring(lang, "mallornsapling", "Mallornschoessling");    locale_setstring(lang, "mallornsapling_p", "Mallornschoesslinge");    locale_setstring(lang, "mallorntree", "Mallorn");    locale_setstring(lang, "mallorntree_p", "Mallorn");}

int main(int argc, char **argv, char **env) {	if (apr_app_initialize(&argc, (const char * const **) argv,			(const char * const **) env) != APR_SUCCESS) {		printf("apr_app_initialize failed/n");		return -1;	}	apr_pool_t *pool = NULL;	apr_pool_create(&pool, NULL);	request_rec *r = test_setup(pool);	OpenSSL_add_all_digests();	char *result = all_tests(pool, r);	if (result != 0) {		printf("Failed: %s/n", result);	} else {		printf("All %d tests passed!/n", test_nr_run);	}	EVP_cleanup();	apr_pool_destroy(pool);	apr_terminate();	return result != 0;}

/** * 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;}

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_shipspeed(CuTest *tc) {    ship *sh;    const ship_type *stype;    unit *cap, *crew;    test_setup();    sh = setup_ship();    stype = sh->type;    CuAssertIntEquals_Msg(tc, "ship without a captain cannot move", 0, shipspeed(sh, NULL));    setup_crew(sh, 0, &cap, &crew);    CuAssertPtrEquals(tc, cap, ship_owner(sh));    CuAssertIntEquals_Msg(tc, "ship with fully skilled crew can sail at max speed", 2, shipspeed(sh, cap));    CuAssertIntEquals_Msg(tc, "shipspeed without a hint defaults to captain", 2, shipspeed(sh, NULL));    set_level(cap, SK_SAILING, stype->cptskill + 5);    set_level(crew, SK_SAILING, (stype->sumskill - stype->cptskill) * 10);    CuAssertIntEquals_Msg(tc, "higher skills should not affect top speed", 2, shipspeed(sh, cap));    set_level(cap, SK_SAILING, stype->cptskill);    set_level(crew, SK_SAILING, stype->sumskill - stype->cptskill);    CuAssertIntEquals(tc, 2, shipspeed(sh, cap));    set_level(crew, SK_SAILING, (stype->sumskill - stype->cptskill) * 11);    set_level(cap, SK_SAILING, stype->cptskill + 10);    CuAssertIntEquals_Msg(tc, "regular skills should not exceed sh.range", 2, shipspeed(sh, cap));    test_teardown();}

/** * 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;}

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

/** * Verify that eglCreateSyncKHR emits correct error when given an invalid * attribute list. * * From the EGL_KHR_fence_sync spec: * *     If <attrib_list> is neither NULL nor empty (containing only *     EGL_NONE), EGL_NO_SYNC_KHR is returned and an EGL_BAD_ATTRIBUTE *     error is generated. */static enum piglit_resulttest_eglCreateSyncKHR_invalid_attrib_list(void *test_data){	enum piglit_result result = PIGLIT_PASS;	EGLSyncKHR sync = 0;	const EGLint attrib_list[] = {		EGL_CONTEXT_CLIENT_VERSION, 2,		EGL_NONE,	};	result = test_setup();	if (result != PIGLIT_PASS) {		return result;	}	sync = peglCreateSyncKHR(g_dpy, EGL_SYNC_FENCE_KHR, attrib_list);	if (sync) {		piglit_loge("eglCreateSyncKHR() succeeded with invalid "			  "attrib list");		result = PIGLIT_FAIL;	}	if (!piglit_check_egl_error(EGL_BAD_ATTRIBUTE)) {		piglit_loge("eglCreateSyncKHR emitted wrong error");		result = PIGLIT_FAIL;	}	test_cleanup(sync, &result);	return result;}

/** * Verify that eglCreateSyncKHR emits correct error when no context is current. * * From the EGL_KHR_fence_sync spec: * *     If <type> is EGL_SYNC_FENCE_KHR and no context is current for *     the bound API (i.e., eglGetCurrentContext returns *     EGL_NO_CONTEXT), EGL_NO_SYNC_KHR is returned and an *     EGL_BAD_MATCH error is generated. */static enum piglit_resulttest_eglCreateSyncKHR_no_current_context(void *test_data){	enum piglit_result result = PIGLIT_PASS;	EGLSyncKHR sync = 0;	result = test_setup();	if (result != PIGLIT_PASS) {		return result;	}	eglMakeCurrent(g_dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);	sync = peglCreateSyncKHR(g_dpy, EGL_SYNC_TYPE_KHR, NULL);	if (sync) {		piglit_loge("eglCreateSyncKHR() succeeded when no context was "			  "current");		peglDestroySyncKHR(g_dpy, sync);		result = PIGLIT_FAIL;	}	if (!piglit_check_egl_error(EGL_BAD_MATCH)) {		piglit_loge("eglCreateSyncKHR emitted wrong error");		result = PIGLIT_FAIL;	}	test_cleanup(sync, &result);	return result;}

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

END_TEST/* * test suite */static Suite *cuckoo_suite(void){    Suite *s = suite_create(SUITE_NAME);    /* basic requests */    TCase *tc_basic_req = tcase_create("basic item api");    suite_add_tcase(s, tc_basic_req);    test_setup(CUCKOO_POLICY_RANDOM, true);    tcase_add_test(tc_basic_req, test_insert_basic_random_true);    tcase_add_test(tc_basic_req, test_insert_basic_random_false);    tcase_add_test(tc_basic_req, test_insert_collision_random_true);    tcase_add_test(tc_basic_req, test_insert_collision_random_false);    tcase_add_test(tc_basic_req, test_insert_collision_expire_true);    tcase_add_test(tc_basic_req, test_insert_collision_expire_false);    tcase_add_test(tc_basic_req, test_cas_random);    tcase_add_test(tc_basic_req, test_cas_expire);    tcase_add_test(tc_basic_req, test_delete_basic_random_true);    tcase_add_test(tc_basic_req, test_delete_basic_random_false);    tcase_add_test(tc_basic_req, test_expire_basic_random_true);    tcase_add_test(tc_basic_req, test_expire_basic_random_false);    tcase_add_test(tc_basic_req, test_insert_replace_expired);    tcase_add_test(tc_basic_req, test_insert_insert_expire_swap);    return s;}

int main() {  test_setup();  perf_start();  for (int i = 0; i < NUM_ITER; ++i) {    test_clear();    reset_timer();    start_timer();    test_run(i);    stop_timer();    samples[i] = get_time();  }  perf_stop();  int check = test_check();  printf("Correct: %d/n", check);  for (int i = 0; i < NUM_ITER; ++i)    printf("TS[%d]: %d/n", i, samples[i]);  perf_print_all();  return 0;}

int main(int ac, char **av){	int lc, i;	tst_parse_opts(ac, av, NULL, NULL);	setup();	for (lc = 0; TEST_LOOPING(lc); lc++) {		tst_count = 0;		for (i = 0; i < TST_TOTAL; ++i) {			test_setup(i);			TEST(ltp_syscall(__NR_capget, test_cases[i].headerp,				     test_cases[i].datap));			if (TEST_RETURN == -1 &&			    TEST_ERRNO == test_cases[i].exp_errno) {				tst_resm(TPASS | TTERRNO,					 "capget failed as expected");			} else {				tst_resm(TFAIL | TTERRNO,					 "capget failed unexpectedly (%ld)",					 TEST_RETURN);			}		}	}	cleanup();	tst_exit();}

static void test_buildingowner_goes_to_other_when_empty(CuTest * tc){    struct region *r;    struct building *bld;    struct unit *u, *u2;    struct faction *f;    test_setup();    f = test_create_faction(NULL);    r = test_create_plain(0, 0);    bld = test_create_building(r, NULL);    CuAssertPtrNotNull(tc, bld);    u2 = test_create_unit(f, r);    u = test_create_unit(f, r);    CuAssertPtrNotNull(tc, u);    u_set_building(u, bld);    CuAssertPtrEquals(tc, u, building_owner(bld));    u_set_building(u2, bld);    CuAssertPtrEquals(tc, u, building_owner(bld));    u->number = 0;    CuAssertPtrEquals(tc, u2, building_owner(bld));    test_teardown();}

static void test_building_effsize(CuTest *tc) {    building *b;    building_type *btype;    building_stage *stage;    construction *cons;    test_setup();    btype = test_create_buildingtype("castle");    stage = btype->stages;    assert(stage && stage->construction);    cons = stage->construction;    cons->maxsize = 5;    stage->next = calloc(1, sizeof(building_stage));    stage = stage->next;    cons = stage->construction = calloc(1, sizeof(construction));    cons->maxsize = 5;    stage->next = calloc(1, sizeof(building_stage));    stage = stage->next;    cons = stage->construction = calloc(1, sizeof(construction));    cons->maxsize = -1;    b = test_create_building(test_create_region(0,0,0), btype);    b->size = 1;    CuAssertIntEquals(tc, 0, buildingeffsize(b, false));    b->size = 5;    CuAssertIntEquals(tc, 1, buildingeffsize(b, false));    b->size = 10;    CuAssertIntEquals(tc, 2, buildingeffsize(b, false));    b->size = 20;    CuAssertIntEquals(tc, 2, buildingeffsize(b, false));    test_teardown();}

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_merge_split(CuTest *tc) {    message_list *mlist = 0, *append = 0;    struct mlist **split; /* TODO: why is this a double asterisk? */    message_type *mtype;    message *msg;    test_setup();    mtype = mt_create(mt_new("custom", NULL), NULL, 0);    add_message(&mlist, msg = msg_message(mtype->name, ""));    msg_release(msg);    add_message(&append, msg = msg_message(mtype->name, ""));    msg_release(msg);    CuAssertPtrEquals(tc, NULL, mlist->begin->next);    CuAssertPtrEquals(tc, &mlist->begin->next, mlist->end);    split = merge_messages(mlist, append);    CuAssertPtrNotNull(tc, split);    CuAssertPtrEquals(tc, &mlist->begin->next, split);    CuAssertPtrEquals(tc, append->end, mlist->end);    CuAssertPtrNotNull(tc, mlist->begin->next);    CuAssertPtrEquals(tc, append->begin, mlist->begin->next);    split_messages(mlist, split);    CuAssertPtrEquals(tc, NULL, mlist->begin->next);    free_messagelist(*split);    free_messagelist(mlist->begin);    free(mlist);    free_messagelist(append->begin);    free(append);    test_teardown();}

/** * Verify that eglDestroySyncKHR() emits the correct error when given an * invalid sync object. * * From the EGL_KHR_fence_sync spec: * *      * 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_eglDestroySyncKHR_invalid_sync(void *test_data){	enum piglit_result result = PIGLIT_PASS;	bool ok = false;	EGLSyncKHR invalid_sync = (EGLSyncKHR) &canary;	result = test_setup();	if (result != PIGLIT_PASS) {		return result;	}	ok = peglDestroySyncKHR(g_dpy, invalid_sync);	if (ok) {		piglit_loge("eglDestroySyncKHR() succeeded when given invalid "			  "sync object");		result = PIGLIT_FAIL;	}	if (!piglit_check_egl_error(EGL_BAD_PARAMETER)) {		piglit_loge("eglGetSyncAttribKHR(EGL_SYNC_TYPE_KHR) emitted "			  "an incorrect error");		result = PIGLIT_FAIL;	}	test_cleanup(EGL_NO_SYNC_KHR, &result);	return result;}

static void test_plane(CuTest *tc) {    struct region *r;    plane *pl;    test_setup();    r = test_create_region(0, 0, NULL);    CuAssertPtrEquals(tc, NULL, findplane(0, 0));    CuAssertPtrEquals(tc, NULL, getplane(r));    CuAssertIntEquals(tc, 0, getplaneid(r));    CuAssertPtrEquals(tc, NULL, getplanebyid(0));    CuAssertIntEquals(tc, 0, plane_center_x(0));    CuAssertIntEquals(tc, 0, plane_center_y(0));    CuAssertIntEquals(tc, 0, plane_width(0));    CuAssertIntEquals(tc, 0, plane_height(0));    CuAssertPtrEquals(tc, NULL, get_homeplane());    pl = create_new_plane(1, "Hell", 4, 8, 40, 80, 15);    r = test_create_region(4, 40, 0);    CuAssertIntEquals(tc, 15, pl->flags);    CuAssertIntEquals(tc, 4, pl->minx);    CuAssertIntEquals(tc, 8, pl->maxx);    CuAssertIntEquals(tc, 40, pl->miny);    CuAssertIntEquals(tc, 80, pl->maxy);    CuAssertPtrEquals(tc, NULL, pl->attribs);    CuAssertStrEquals(tc, "Hell", pl->name);    CuAssertPtrEquals(tc, pl, findplane(4, 40));    CuAssertPtrEquals(tc, pl, getplane(r));    CuAssertPtrEquals(tc, pl, getplanebyid(1));    CuAssertIntEquals(tc, 1, getplaneid(r));    CuAssertIntEquals(tc, 6, plane_center_x(pl));    CuAssertIntEquals(tc, 60, plane_center_y(pl));    CuAssertIntEquals(tc, 5, plane_width(pl));    CuAssertIntEquals(tc, 41, plane_height(pl));    test_teardown();}

/** * Verify that eglCreateSyncKHR emits correct error when given an invalid * sync type. * * From the EGL_KHR_fence_sync spec: * *     If <type> is not a supported type of sync object, *     EGL_NO_SYNC_KHR is returned and an EGL_BAD_ATTRIBUTE error is *     generated. * * TODO(chadv,joshtriplett): eglCreateSyncKHR should generate EGL_BAD_PARAMETER * TODO: on bad sync types, not EGL_BAD_ATTRIBUTE. Bug filed in Khronos private * TODO: Bugzilla; update the test when resolved. */static enum piglit_resulttest_eglCreateSyncKHR_invalid_sync_type(void *test_data){	enum piglit_result result = PIGLIT_PASS;	EGLSyncKHR sync = 0;	EGLenum bad_sync_type = EGL_SYNC_TYPE_KHR;	result = test_setup();	if (result != PIGLIT_PASS) {		return result;	}	sync = peglCreateSyncKHR(g_dpy, bad_sync_type, NULL);	if (sync) {		piglit_loge("eglCreateSyncKHR() succeeded with invalid "			  "sync type");		result = PIGLIT_FAIL;	}	if (!piglit_check_egl_error(EGL_BAD_ATTRIBUTE)) {		piglit_loge("eglCreateSyncKHR emitted wrong error");		result = PIGLIT_FAIL;	}	test_cleanup(sync, &result);	return result;}

/* Test that reading a custom CA certificate file works. */static void test_ssl_cert_subject(CuTest *tc){    apr_hash_t *subject;    serf_ssl_certificate_t *cert = NULL;    apr_status_t status;    apr_pool_t *test_pool = test_setup();    status = serf_ssl_load_cert_file(        &cert, get_ca_file(test_pool, "test/serftestca.pem"), test_pool);    CuAssertIntEquals(tc, APR_SUCCESS, status);    CuAssertPtrNotNull(tc, cert);    subject = serf_ssl_cert_subject(cert, test_pool);    CuAssertStrEquals(tc, "Test Suite",                       apr_hash_get(subject, "OU", APR_HASH_KEY_STRING));    CuAssertStrEquals(tc, "In Serf we trust, Inc.",                       apr_hash_get(subject, "O", APR_HASH_KEY_STRING));    CuAssertStrEquals(tc, "Mechelen",                       apr_hash_get(subject, "L", APR_HASH_KEY_STRING));    CuAssertStrEquals(tc, "Antwerp",                       apr_hash_get(subject, "ST", APR_HASH_KEY_STRING));    CuAssertStrEquals(tc, "BE",                       apr_hash_get(subject, "C", APR_HASH_KEY_STRING));    CuAssertStrEquals(tc, "[email
C++ test_skip函数代码示例
C++ test_set_step函数代码示例