コード例 #1
0
ファイル: spell.test.c プロジェクト: ennorehling/eressea
static void test_create_duplicate_spell(CuTest * tc)
{
    spell *sp;
    struct log_t *log;
    strlist *sl = 0;

    test_setup();
    test_log_stderr(0); /* suppress the "duplicate spell" error message */
    log = test_log_start(LOG_CPERROR, &sl);

    CuAssertPtrEquals(tc, NULL, find_spell("testspell"));

    sp = create_spell("testspell");
    CuAssertPtrEquals(tc, NULL, create_spell("testspell"));
    CuAssertPtrNotNull(tc, sl);
    CuAssertStrEquals(tc, "create_spell: duplicate name '%s'", sl->s);
    CuAssertPtrEquals(tc, NULL, sl->next);
    CuAssertPtrEquals(tc, sp, find_spell("testspell"));
    test_log_stop(log, sl);
    test_log_stderr(1); /* or teardown complains that stderr logging is off */
    test_teardown();
}
コード例 #2
0
static void test_group_readwrite_dead_faction(CuTest *tc) {
    gamedata data;
    storage store;
    faction *f, *f2;
    unit * u;
    group *g;
    ally *al;
    int fno;

    test_cleanup();
    f = test_create_faction(0);
    fno = f->no;
    CuAssertPtrEquals(tc, f, factions);
    CuAssertPtrEquals(tc, 0, f->next);
    f2 = test_create_faction(0);
    CuAssertPtrEquals(tc, f2, factions->next);
    u = test_create_unit(f2, test_create_region(0, 0, 0));
    CuAssertPtrNotNull(tc, u);
    g = join_group(u, "group");
    CuAssertPtrNotNull(tc, g);
    al = ally_add(&g->allies, f);
    CuAssertPtrNotNull(tc, al);

    CuAssertPtrEquals(tc, f, factions);
    destroyfaction(&factions);
    CuAssertTrue(tc, !f->_alive);
    CuAssertPtrEquals(tc, f2, factions);
    mstream_init(&data.strm);
    gamedata_init(&data, &store, RELEASE_VERSION);
    write_game(&data);
    free_gamedata();
    f = f2 = NULL;
    data.strm.api->rewind(data.strm.handle);
    read_game(&data);
    mstream_done(&data.strm);
    gamedata_done(&data);
    CuAssertPtrEquals(tc, 0, findfaction(fno));
    f2 = factions;
    CuAssertPtrNotNull(tc, f2);
    u = f2->units;
    CuAssertPtrNotNull(tc, u);
    g = get_group(u);
    CuAssertPtrNotNull(tc, g);
    CuAssertPtrEquals(tc, 0, g->allies);
    test_cleanup();
}
コード例 #3
0
ファイル: test_sip-utils.c プロジェクト: Carl4/astrometry.net
void test_compute_inverse(CuTest* tc) {
	double x,y, dx, dy;
	sip_t* wcs = sip_from_string(wcsfile, 0, NULL);
	CuAssertPtrNotNull(tc, wcs);
	printf("Read:\n");
	sip_print_to(wcs, stdout);

	CuAssertIntEquals(tc, 4, wcs->a_order);
	CuAssertIntEquals(tc, 4, wcs->b_order);
	CuAssertIntEquals(tc, 0, wcs->ap_order);
	CuAssertIntEquals(tc, 0, wcs->bp_order);
	CuAssertIntEquals(tc, 0, sip_ensure_inverse_polynomials(wcs));

	printf("After ensuring inverse:\n");
	sip_print_to(wcs, stdout);

	CuAssertIntEquals(tc, 4, wcs->a_order);
	CuAssertIntEquals(tc, 4, wcs->b_order);
	CuAssertIntEquals(tc, 5, wcs->ap_order);
	CuAssertIntEquals(tc, 5, wcs->bp_order);

	dx = dy = 100;
	for (y=0; y<=sip_imageh(wcs); y+=dy) {
		for (x=0; x<=sip_imagew(wcs); x+=dx) {
			double ra,dec;
			double x2, y2;
            anbool ok;
			sip_pixelxy2radec(wcs, x, y, &ra, &dec);
			ok = sip_radec2pixelxy(wcs, ra, dec, &x2, &y2);
            CuAssertTrue(tc, ok);
			CuAssertDblEquals(tc, x, x2, 1e-2);
			CuAssertDblEquals(tc, y, y2, 1e-2);
			printf("x,y %g,%g --> error %g,%g\n", x,y, x2-x, y2-y);
		}
	}

	sip_free(wcs);
}
コード例 #4
0
ファイル: jsonconf.test.c プロジェクト: hochl/server
static void test_skills(CuTest * tc)
{
    const char * data = "{\"skills\": { \"de\" : { \"alchemy\" : \"ALCHEMIE\", \"crossbow\" : [ \"ARMBRUST\", \"KREUZBOGEN\" ] }}}";
    const struct locale * lang;

    cJSON *json = cJSON_Parse(data);

    test_cleanup();
    lang = get_or_create_locale("de");
    CuAssertPtrNotNull(tc, json);
    CuAssertIntEquals(tc, NOSKILL, get_skill("potato", lang));

    json_config(json);
    CuAssertIntEquals(tc, NOSKILL, get_skill("potato", lang));
    CuAssertIntEquals(tc, SK_CROSSBOW, get_skill("armbrust", lang));
    CuAssertIntEquals(tc, SK_CROSSBOW, get_skill("kreuz", lang));
    CuAssertIntEquals(tc, SK_ALCHEMY, get_skill("alchemie", lang));

    CuAssertStrEquals(tc, "ALCHEMIE", locale_string(lang, "skill::alchemy"));
    CuAssertStrEquals(tc, "ARMBRUST", locale_string(lang, "skill::crossbow"));

    test_cleanup();
}
コード例 #5
0
ファイル: hashmapunit.c プロジェクト: Ezbob/C_hashmap
void test_mapDropBucket(CuTest *tc) {

	HM_HASHMAP *new_map = HM_initialize_hashmap(HASHMAP_SIZE);

	char *key = strdup("Hello world");
	int values[] = { 42, 37, 65 };

	HM_putValue(new_map, key, ( (void *) &values[0] ) );
	HM_putValue(new_map, key, ( (void *) &values[1] ) );
	HM_putValue(new_map, key, ( (void *) &values[2] ) );

	CuAssertPtrNotNull(tc, new_map);
	CuAssertTrue(tc, new_map->entries_used == 1);
	CuAssertTrue(tc, HM_getChainLength(new_map, "Hello world") == 3);

	int wasDropped = HM_dropBucket(new_map, "Hello world");

	CuAssertTrue(tc, wasDropped);
	CuAssertTrue(tc, new_map->entries_used == 0);
	CuAssertTrue(tc, HM_getValue(new_map, "Hello world") == NULL);
	HM_destroyHashmap( &new_map );
	free(key);
}
コード例 #6
0
ファイル: test-save.c プロジェクト: Azendale/augeas
static void testMtime(CuTest *tc) {
    const char *s, *mtime2;
    char *mtime1;
    int r;

    r = aug_set(aug, "/files/etc/hosts/1/alias[last() + 1]", "new");
    CuAssertIntEquals(tc, 0, r);

    r = aug_get(aug, "/augeas/files/etc/hosts/mtime", &s);
    CuAssertIntEquals(tc, 1, r);
    mtime1 = strdup(s);
    CuAssertPtrNotNull(tc, mtime1);


    r = aug_save(aug);
    CuAssertIntEquals(tc, 0, r);

    r = aug_get(aug, "/augeas/files/etc/hosts/mtime", &mtime2);
    CuAssertIntEquals(tc, 1, r);

    CuAssertStrNotEqual(tc, mtime1, mtime2);
    CuAssertStrNotEqual(tc, "0", mtime2);
}
コード例 #7
0
ファイル: messages.test.c プロジェクト: ennorehling/eressea
void test_message(CuTest *tc) {
    message *msg;
    message_type *mtype;

    test_setup();
    mtype = mt_create(mt_new("custom", NULL), NULL, 0);
    CuAssertPtrEquals(tc, mtype, (void *)mt_find("custom"));
    CuAssertIntEquals(tc, 0, mtype->nparameters);
    CuAssertPtrEquals(tc, NULL, (void *)mtype->pnames);
    CuAssertPtrEquals(tc, NULL, (void *)mtype->types);
    msg = msg_message("custom", "");
    CuAssertPtrNotNull(tc, msg);
    CuAssertIntEquals(tc, 1, msg->refcount);
    CuAssertPtrEquals(tc, NULL, msg->parameters);
    CuAssertPtrEquals(tc, mtype, (void *)msg->type);

    CuAssertPtrEquals(tc, msg, msg_addref(msg));
    CuAssertIntEquals(tc, 2, msg->refcount);
    msg_release(msg);
    CuAssertIntEquals(tc, 1, msg->refcount);
    msg_release(msg);
    test_teardown();
}
コード例 #8
0
static void test_remove_dead_factions(CuTest *tc) {
    faction *f, *fm;
    region *r;
    int fno;

    test_cleanup();
    r = test_create_region(0, 0, 0);
    fm = get_or_create_monsters();
    f = test_create_faction(0);
    assert(fm && r && f);
    test_create_unit(f, r);
    test_create_unit(fm, r);
    remove_empty_factions();
    CuAssertPtrEquals(tc, f, findfaction(f->no));
    CuAssertPtrNotNull(tc, get_monsters());
    fm->units = 0;
    f->_alive = false;
    fno = f->no;
    remove_empty_factions();
    CuAssertPtrEquals(tc, 0, findfaction(fno));
    CuAssertPtrEquals(tc, fm, get_monsters());
    test_cleanup();
}
コード例 #9
0
ファイル: building.test.c プロジェクト: ennorehling/eressea
static void test_buildingtype_exists(CuTest * tc)
{
    region *r;
    building *b;
    building_type *btype, *btype2;

    test_setup();

    btype2 = test_create_buildingtype("castle");
    assert(btype2);
    btype = test_create_buildingtype("lighhouse");
    btype->maxsize = 10;

    r = test_create_plain(0, 0);
    b = test_create_building(r, btype);
    CuAssertPtrNotNull(tc, b);
    b->size = 10;

    CuAssertTrue(tc, !buildingtype_exists(r, NULL, false));
    CuAssertTrue(tc, !buildingtype_exists(r, btype2, false));

    CuAssertTrue(tc, buildingtype_exists(r, btype, false));
    b->size = 9;
    fset(b, BLD_MAINTAINED);
    CuAssertTrue(tc, !buildingtype_exists(r, btype, false));
    btype->maxsize = 0;
    freset(b, BLD_MAINTAINED);
    CuAssertTrue(tc, buildingtype_exists(r, btype, false));
    btype->maxsize = 10;
    b->size = 10;

    fset(b, BLD_MAINTAINED);
    CuAssertTrue(tc, buildingtype_exists(r, btype, true));
    freset(b, BLD_MAINTAINED);
    CuAssertTrue(tc, !buildingtype_exists(r, btype, true));
    test_teardown();
}
コード例 #10
0
ファイル: hashmapunit.c プロジェクト: Ezbob/C_hashmap
void test_mapPollCollision(CuTest *tc) {

	HM_HASHMAP *new_map = HM_initialize_hashmap(HASHMAP_SIZE);

	char *key = strdup("Hello world");
	int values[] = { 42, 37, 65 };

	HM_putValue(new_map, key, ( (void *) &values[0] ) );
	HM_putValue(new_map, key, ( (void *) &values[1] ) );
	HM_putValue(new_map, key, ( (void *) &values[2] ) );

	CuAssertPtrNotNull(tc, new_map);
	CuAssertTrue(tc, new_map->entries_used == 1);
	CuAssertTrue(tc, HM_getChainLength(new_map, "Hello world") == 3);

	CuAssertTrue(tc, *( ( int *) HM_poll(new_map, key) ) == values[0] );
	CuAssertTrue(tc, *( ( int *) HM_poll(new_map, key) ) == values[1] );
	CuAssertTrue(tc, *( ( int *) HM_poll(new_map, key) ) == values[2] );

	CuAssertTrue(tc, new_map->entries_used == 0);
	
	HM_destroyHashmap( &new_map );
	free(key);
}
コード例 #11
0
ファイル: ship.test.c プロジェクト: eressea/server
static void test_stype_defaults(CuTest *tc) {
    ship_type *stype;
    test_setup();
    stype = st_get_or_create("hodor");
    CuAssertPtrNotNull(tc, stype);
    CuAssertStrEquals(tc, "hodor", stype->_name);
    CuAssertPtrEquals(tc, NULL, stype->construction);
    CuAssertPtrEquals(tc, NULL, stype->coasts);
    CuAssertDblEquals(tc, 0.0, stype->damage, 0.0);
    CuAssertDblEquals(tc, 1.0, stype->storm, 0.0);
    CuAssertDblEquals(tc, 1.0, stype->tac_bonus, 0.01);
    CuAssertIntEquals(tc, 0, stype->cabins);
    CuAssertIntEquals(tc, 0, stype->cargo);
    CuAssertIntEquals(tc, 0, stype->combat);
    CuAssertIntEquals(tc, 0, stype->fishing);
    CuAssertIntEquals(tc, 0, stype->range);
    CuAssertIntEquals(tc, 0, stype->cptskill);
    CuAssertIntEquals(tc, 0, stype->minskill);
    CuAssertIntEquals(tc, 0, stype->sumskill);
    CuAssertIntEquals(tc, 0, stype->at_bonus);
    CuAssertIntEquals(tc, 0, stype->df_bonus);
    CuAssertIntEquals(tc, 0, stype->flags);
    test_teardown();
}
コード例 #12
0
void TestMultiHandler(CuTest *tc) {
	struct Handler *handlers[THREAD_NUM];
	struct TestObj obj[THREAD_NUM];
	int i = 0;
	for (i = 0; i < THREAD_NUM; i ++) {
		handlers[i] = NewHandler();
		CuAssertPtrNotNull(tc, handlers[i]);
		handlers[i]->HandleMessage = MultiHandleMessageImpl;
		obj[i].context = tc;
		obj[i].handler = handlers[i];
		obj[i].i = i;
	}

	StartTime();
	for (i = 0; i < THREAD_NUM; i ++) {
		pthread_create(&t[i], NULL, MultiHandlerSub, &obj[i]);
	}
	
	pthread_t ct;
	pthread_create(&ct, NULL, CollectThread, handlers[0]);
	
	LoopStart(handlers[0]->loop);

}
コード例 #13
0
void TestBencodeDictGetNext(
    CuTest * tc
)
{
    bencode_t ben;

    bencode_t ben2;

    char *str = strdup("d3:foo3:bare");

    const char *ren;

    int len, ret;

    bencode_init(&ben, str, strlen(str));

    ret = bencode_dict_get_next(&ben, &ben2, &ren, &len);
    CuAssertTrue(tc, 1 == ret);
    CuAssertTrue(tc, !strncmp("foo", ren, len));
    bencode_string_value(&ben2, &ren, &len);
    CuAssertPtrNotNull(tc, ren);
    CuAssertTrue(tc, !strncmp("bar", ren, len));
    free(str);
}
コード例 #14
0
ファイル: give.test.c プロジェクト: ennorehling/eressea
static void test_give_men_requires_contact(CuTest * tc) {
    struct give env = { 0 };
    message * msg;
    order *ord;

    test_setup_ex(tc);
    env.f1 = test_create_faction(NULL);
    env.f2 = test_create_faction(NULL);
    setup_give(&env);
    msg = give_men(1, env.src, env.dst, NULL);
    CuAssertStrEquals(tc, "feedback_no_contact", test_get_messagetype(msg));
    CuAssertIntEquals(tc, 1, env.dst->number);
    CuAssertIntEquals(tc, 1, env.src->number);

    ord = create_order(K_GIVE, env.f1->locale, "%s ALLES PERSONEN", itoa36(env.dst->no));
    test_clear_messages(env.f1);
    give_cmd(env.src, ord);
    CuAssertPtrEquals(tc, NULL, test_find_messagetype(env.f1->msgs, "give_person"));
    CuAssertPtrNotNull(tc, test_find_messagetype(env.f1->msgs, "feedback_no_contact"));

    msg_release(msg);
    free_order(ord);
    test_teardown();
}
コード例 #15
0
ファイル: cstring_import.c プロジェクト: wgm/cerb2-cparser
void Test__cstring_import(CuTest* tc)
{
  CSTRING* a=NULL;
  char *str=NULL;

  // passing NULL, 0
  a = cstring_import(NULL, 0);
  CuAssertPtrEquals(tc, NULL, a);

  // passing static string 'abcde', length 5
  a = cstring_import("abcde", 5);
  CuAssertPtrNotNull(tc, a);
  CuAssertTrue(tc, 0!=a->memsize);
  CuAssertIntEquals(tc, 1, a->canfree);
  CuAssertIntEquals(tc, 5, a->length);
  CuAssertPtrNotNull(tc, a->string);
  CuAssertStrEquals(tc, "abcde", a->string);
  cstring_free(&a);

  // passing strdup'd string 'abc...xyz', strlen(strdup'd string)
  str = strdup("abcdefghijklmnopqrstuvwxyz");
  a = cstring_import(str, strlen(str));
  CuAssertPtrNotNull(tc, a);
  CuAssertTrue(tc, 0!=a->memsize);
  CuAssertIntEquals(tc, 1, a->canfree);
  CuAssertIntEquals(tc, 26, a->length);
  CuAssertPtrNotNull(tc, a->string);
  CuAssertStrEquals(tc, str, a->string);
  free(str);
  cstring_free(&a);

  // passing strdup'd string 'abc...xyz', length 5
  str = strdup("abcdefghijklmnopqrstuvwxyz");
  a = cstring_import(str, 5);
  CuAssertPtrNotNull(tc, a);
  CuAssertTrue(tc, 0!=a->memsize);
  CuAssertIntEquals(tc, 1, a->canfree);
  CuAssertIntEquals(tc, 5, a->length);
  CuAssertPtrNotNull(tc, a->string);
  CuAssertStrEquals(tc, "abcde", a->string);
  free(str);
  cstring_free(&a);
}
コード例 #16
0
/** 
 * see https://bugs.eressea.de/view.php?id=2234
 */
static void test_maintain_buildings(CuTest *tc) {
    region *r;
    building *b;
    building_type *btype;
    unit *u;
    faction *f;
    maintenance *req;
    item_type *itype;

    test_cleanup();
    btype = test_create_buildingtype("Hort");
    btype->maxsize = 10;
    r = test_create_region(0, 0, 0);
    f = test_create_faction(0);
    u = test_create_unit(f, r);
    b = test_create_building(r, btype);
    itype = test_create_itemtype("money");
    b->size = btype->maxsize;
    u_set_building(u, b);

    // this building has no upkeep, it just works:
    b->flags = 0;
    maintain_buildings(r);
    CuAssertIntEquals(tc, BLD_MAINTAINED, fval(b, BLD_MAINTAINED));
    CuAssertPtrEquals(tc, 0, f->msgs);
    CuAssertPtrEquals(tc, 0, r->msgs);

    req = calloc(2, sizeof(maintenance));
    req[0].number = 100;
    req[0].rtype = itype->rtype;
    btype->maintenance = req;

    // we cannot afford to pay:
    b->flags = 0;
    maintain_buildings(r);
    CuAssertIntEquals(tc, 0, fval(b, BLD_MAINTAINED));
    CuAssertPtrNotNull(tc, test_find_messagetype(f->msgs, "maintenancefail"));
    CuAssertPtrNotNull(tc, test_find_messagetype(r->msgs, "maintenance_nowork"));
    test_clear_messagelist(&f->msgs);
    test_clear_messagelist(&r->msgs);
    
    // we can afford to pay:
    i_change(&u->items, itype, 100);
    b->flags = 0;
    maintain_buildings(r);
    CuAssertIntEquals(tc, BLD_MAINTAINED, fval(b, BLD_MAINTAINED));
    CuAssertIntEquals(tc, 0, i_get(u->items, itype));
    CuAssertPtrEquals(tc, 0, r->msgs);
    CuAssertPtrEquals(tc, 0, test_find_messagetype(f->msgs, "maintenance_nowork"));
    CuAssertPtrNotNull(tc, test_find_messagetype(f->msgs, "maintenance"));
    test_clear_messagelist(&f->msgs);

    // this building has no owner, it doesn't work:
    u_set_building(u, NULL);
    b->flags = 0;
    maintain_buildings(r);
    CuAssertIntEquals(tc, 0, fval(b, BLD_MAINTAINED));
    CuAssertPtrEquals(tc, 0, f->msgs);
    CuAssertPtrNotNull(tc, test_find_messagetype(r->msgs, "maintenance_noowner"));
    test_clear_messagelist(&r->msgs);

    test_cleanup();
}
コード例 #17
0
void test_inmemory_fitsbin_2(CuTest* ct) {
    fitsbin_t* fb;
    int i;
    int N = 6;
    double outdata[6];
    double* indata;
    fitsbin_chunk_t chunk;
    fitsbin_chunk_t* ch;

    fb = fitsbin_open_in_memory();
    CuAssertPtrNotNull(ct, fb);

    CuAssertIntEquals(ct, 0, fitsbin_write_primary_header(fb));

    for (i=0; i<N; i++) {
        outdata[i] = i*i;
    }

    fitsbin_chunk_init(&chunk);
    chunk.tablename = "test2";
    chunk.itemsize = 1;
    //chunk.nrows = N * sizeof(double);
    chunk.data = outdata;

    CuAssertIntEquals(ct, 0, fitsbin_write_chunk_header(fb, &chunk));
    for (i=0; i<N; i++) {
        CuAssertIntEquals(ct, 0, fitsbin_write_items(fb, &chunk, &outdata[i], sizeof(double)));
    }
    CuAssertIntEquals(ct, 0, fitsbin_fix_chunk_header(fb, &chunk));

    fitsbin_chunk_reset(&chunk);
    chunk.tablename = "test2B";
    chunk.itemsize = sizeof(double);
    //chunk.nrows = N;
    chunk.data = outdata;

    CuAssertIntEquals(ct, 0, fitsbin_write_chunk_header(fb, &chunk));
    for (i=0; i<N; i++) {
        CuAssertIntEquals(ct, 0, fitsbin_write_items(fb, &chunk, outdata + (N-1) - i, 1));
    }
    CuAssertIntEquals(ct, 0, fitsbin_fix_chunk_header(fb, &chunk));

    fitsbin_chunk_clean(&chunk);

    // writing shouldn't affect the data values
    for (i=0; i<N; i++) {
        CuAssertIntEquals(ct, outdata[i], i*i);
    }

    CuAssertIntEquals(ct, 0, fitsbin_switch_to_reading(fb));

    fitsbin_chunk_init(&chunk);
    chunk.tablename = "test2";
    fitsbin_add_chunk(fb, &chunk);
    chunk.tablename = "test2B";
    fitsbin_add_chunk(fb, &chunk);

    CuAssertIntEquals(ct, 0, fitsbin_read(fb));

    ch = fitsbin_get_chunk(fb, 0);
    CuAssertIntEquals(ct, 1, ch->itemsize);
    CuAssertIntEquals(ct, N * sizeof(double), ch->nrows);
    indata = ch->data;
    CuAssertPtrNotNull(ct, indata);
    CuAssertIntEquals(ct, 0, memcmp(outdata, indata, sizeof(outdata)));
 
    ch = fitsbin_get_chunk(fb, 1);
    CuAssertIntEquals(ct, sizeof(double), ch->itemsize);
    CuAssertIntEquals(ct, N, ch->nrows);
    indata = ch->data;
    CuAssertPtrNotNull(ct, indata);
    for (i=0; i<N; i++) {
        CuAssertDblEquals(ct, outdata[N-1 - i], indata[i], 1e-10);
    }

    CuAssertIntEquals(ct, 0, fitsbin_close(fb));
}
コード例 #18
0
ファイル: testhacf_param.c プロジェクト: gertux/HACFmodule
static void hacf_param_list_add_test(CuTest *tc) {
	hacf_param_list_t *list = create_hacf_param_list(p);
	hacf_param_t *key1 = create_hacf_param(p, KEY1, HASH1);
	CuAssertIntEquals(tc, 0, add_hacf_param(list, key1));
	CuAssertPtrNotNull(tc, list->first);
}
コード例 #19
0
ファイル: test_plotstuff.c プロジェクト: Carl4/astrometry.net
void test_plot_wcs1(CuTest* tc) {
	plot_args_t myargs;
	plot_args_t* pargs = &myargs;
	int W, H;
	plotxy_t* xy;
	//plotimage_t* img;


	log_init(LOG_VERB);

	W = H = 5;
	plotstuff_init(pargs);
	plotstuff_set_size(pargs, W, H);
	pargs->outformat = PLOTSTUFF_FORMAT_PNG;
	pargs->outfn = "test-out1.png";
	plotstuff_set_color(pargs, "black");
	plotstuff_run_command(pargs, "fill");
	plotstuff_output(pargs);
	plotstuff_free(pargs);

	// perfectly centered circle.
	plotstuff_init(pargs);
	plotstuff_set_size(pargs, W, H);
	pargs->outformat = PLOTSTUFF_FORMAT_PNG;
	pargs->outfn = "test-out2.png";
	plotstuff_set_color(pargs, "black");
	plotstuff_run_command(pargs, "fill");
	xy = plotstuff_get_config(pargs, "xy");
	plot_xy_vals(xy, 3, 3);
	plotstuff_set_color(pargs, "white");
	plotstuff_set_marker(pargs, "circle");
	plotstuff_set_markersize(pargs, 1);
	plotstuff_run_command(pargs, "xy");
	plotstuff_output(pargs);
	plotstuff_free(pargs);

	// perfectly centered circle.
	plotstuff_init(pargs);
	plotstuff_set_size(pargs, W, H);
	pargs->outformat = PLOTSTUFF_FORMAT_PNG;
	pargs->outfn = "test-out3.png";
	plotstuff_set_color(pargs, "black");
	plotstuff_run_command(pargs, "fill");
	xy = plotstuff_get_config(pargs, "xy");
	plot_xy_vals(xy, 2, 2);
	plot_xy_set_offsets(xy, 0, 0);
	plotstuff_set_color(pargs, "white");
	plotstuff_set_marker(pargs, "circle");
	plotstuff_set_markersize(pargs, 1);
	plotstuff_run_command(pargs, "xy");
	plotstuff_output(pargs);
	plotstuff_free(pargs);

	{
		unsigned char* img;
		int ww, hh;
		int i;

		img = cairoutils_read_png("test-out2.png", &ww, &hh);
		CuAssertPtrNotNull(tc, img);
		CuAssertIntEquals(tc, W, ww);
		CuAssertIntEquals(tc, H, hh);

		printf("image:\n");
		for (i=0; i<W*H; i++) {
			printf("%02x  ", (int)img[i*4]);
			if (i%W == (W-1))
				printf("\n");
		}
		printf("\n");

		/*
		 00  00  00  00  00  
		 00  80  e8  80  00  
		 00  f3  44  f3  00  
		 00  7c  e8  7c  00  
		 00  00  00  00  00  
		 */

	}

}
コード例 #20
0
void test_read_raw(CuTest* tc) {
    char* line1 = "0001 00008 1| |"
        "  2.31750494|  2.23184345|  -16.3|   -9.0|"
        " 68| 73| 1.7| 1.8|"
        "1958.89|1951.94| 4|"
        "1.0|1.0|0.9|1.0|"
        "12.146|0.158|12.146|0.223|"
        "999| |         |"
        "  2.31754222|  2.23186444|1.67|1.54|"
        " 88.0|100.8|"
        " |-0.2\r\n";

    char* line2 = "0001 00013 1| |"
        "  1.12558209|  2.26739400|   27.7|   -0.5|"
        "  9| 12| 1.2| 1.2|"
        "1990.76|1989.25| 8|"
        "1.0|0.8|1.0|0.7|"
        "10.488|0.038| 8.670|0.015|"
        "999|T|         |"
        "  1.12551889|  2.26739556|1.81|1.52|"
        "  9.3| 12.7|"
        " |-0.2\r\n";
    // not the third line in the file...
    char* line3 = "0005 01505 1| |"
        "  3.25200241|  2.94960582|   47.8|  -13.6|"
        "  8| 11| 1.0| 1.0|"
        "1990.57|1989.33|11|"
        "0.6|1.2|0.7|1.2|"
        " 9.275|0.020| 8.738|0.015|"
        "999|T|  1040AB |"
        "  3.25189250|  2.94963750|1.76|1.45|"
        "  8.2| 10.5|"
        "P|-0.2\r\n";

    // line 3 from suppl_1.dat
    char* supp1 = "0002 01127 2|H|"
        "004.36837051|+00.31948829|  -32.1|   -9.1|"
        " 13.6|  8.3|  8.2|  5.0|"
        "H|      |     |"
        "10.279|0.041|"
        " 75| |  1397B\r\n";

    char* fn = "/tmp/test-tycho2-0";

    tycho2_entry entry1;
    tycho2_entry entry2;
    tycho2_entry entry3;
    tycho2_entry entry4;
    tycho2_fits* out;
    tycho2_fits* in;
    tycho2_entry* ein1;
    tycho2_entry* ein2;
    tycho2_entry* ein3;
    tycho2_entry* ein4;

    memset(&entry1, 0, sizeof(tycho2_entry));
    memset(&entry2, 0, sizeof(tycho2_entry));
    memset(&entry3, 0, sizeof(tycho2_entry));
    memset(&entry4, 0, sizeof(tycho2_entry));

    CuAssertIntEquals(tc, 0, tycho2_guess_is_supplement(line1));
    CuAssertIntEquals(tc, 0, tycho2_parse_entry(line1, &entry1));
    check_line1(tc, &entry1);

    CuAssertIntEquals(tc, 0, tycho2_guess_is_supplement(line2));
    CuAssertIntEquals(tc, 0, tycho2_parse_entry(line2, &entry2));
    check_line2(tc, &entry2);

    CuAssertIntEquals(tc, 0, tycho2_guess_is_supplement(line3));
    CuAssertIntEquals(tc, 0, tycho2_parse_entry(line3, &entry3));
    check_line3(tc, &entry3);

    CuAssertIntEquals(tc, 1, tycho2_guess_is_supplement(supp1));
    CuAssertIntEquals(tc, 0, tycho2_supplement_parse_entry(supp1, &entry4));
    check_supp1(tc, &entry4);

    out = tycho2_fits_open_for_writing(fn);
    CuAssertPtrNotNull(tc, out);
    CuAssertIntEquals(tc, 0, tycho2_fits_count_entries(out));
    CuAssertIntEquals(tc, 0, tycho2_fits_write_headers(out));
    CuAssertIntEquals(tc, 0, tycho2_fits_write_entry(out, &entry1));
    CuAssertIntEquals(tc, 0, tycho2_fits_write_entry(out, &entry2));
    CuAssertIntEquals(tc, 0, tycho2_fits_write_entry(out, &entry3));
    CuAssertIntEquals(tc, 0, tycho2_fits_write_entry(out, &entry4));
    CuAssertIntEquals(tc, 4, tycho2_fits_count_entries(out));
    CuAssertIntEquals(tc, 0, tycho2_fits_fix_headers(out));
    CuAssertIntEquals(tc, 0, tycho2_fits_close(out));
    out = NULL;

    memset(&entry1, 0, sizeof(tycho2_entry));
    memset(&entry2, 0, sizeof(tycho2_entry));
    memset(&entry3, 0, sizeof(tycho2_entry));
    memset(&entry4, 0, sizeof(tycho2_entry));

    in = tycho2_fits_open(fn);
    CuAssertPtrNotNull(tc, in);
    CuAssertIntEquals(tc, 4, tycho2_fits_count_entries(in));

    ein1 = tycho2_fits_read_entry(in);
    CuAssertPtrNotNull(tc, ein1);
    check_line1(tc, ein1);

    ein2 = tycho2_fits_read_entry(in);
    CuAssertPtrNotNull(tc, ein2);
    check_line2(tc, ein2);

    ein3 = tycho2_fits_read_entry(in);
    CuAssertPtrNotNull(tc, ein3);
    check_line3(tc, ein3);

    ein4 = tycho2_fits_read_entry(in);
    CuAssertPtrNotNull(tc, ein4);
    check_supp1(tc, ein4);

    CuAssertIntEquals(tc, 0, tycho2_fits_close(in));
    in = NULL;
}
コード例 #21
0
ファイル: test_hits.c プロジェクト: okey/aduana
/* Checks the accuracy of the HITS computation */
void
test_hits(CuTest *tc) {
     /* Compute the HITS score of the following graph
      *        +-->2---+
      *        |   |   |
      *        |   v   v
      *        1-->5<--3
      *        ^   ^   |
      *        |   |   |
      *        +---4<--+
      *
      * The link matrix L[i,j], where L[i,j] = 1 means 'i' links to 'j' is:
      *
      *        +-         -+
      *        | 0 1 0 0 1 |
      *        | 0 0 1 0 1 |
      *    L = | 0 0 0 1 1 |
      *        | 1 0 0 0 1 |
      *        | 0 0 0 0 0 |
      *        +-         -+
      */
     char test_dir[] = "test-pagedb-XXXXXX";
     mkdtemp(test_dir);

     PageDB *db;
     int ret = page_db_new(&db, test_dir);
     CuAssert(tc,
              db!=0? db->error->message: "NULL",
              ret == 0);
     db->persist = 0;

     char *urls[5] = {"1", "2", "3", "4", "5" };
     LinkInfo links_1[] = {{"2", 0.1}, {"5", 0.1}};
     LinkInfo links_2[] = {{"3", 0.1}, {"5", 0.1}};
     LinkInfo links_3[] = {{"4", 0.1}, {"5", 0.1}};
     LinkInfo links_4[] = {{"1", 0.1}, {"5", 0.1}};
     LinkInfo *links[5] = {
          links_1, links_2, links_3, links_4, 0
     };
     int n_links[5] = {2, 2, 2, 2, 0};

     for (int i=0; i<5; ++i) {
          CrawledPage *cp = crawled_page_new(urls[i]);
          for (int j=0; j<n_links[i]; ++j)
               crawled_page_add_link(cp, links[i][j].url, links[i][j].score);
          cp->score = i/5.0;
          crawled_page_set_hash64(cp, i);

          PageInfoList *pil;
          CuAssert(tc,
                   db->error->message,
                   page_db_add(db, cp, &pil) == 0);
          page_info_list_delete(pil);
          crawled_page_delete(cp);
     }

     PageDBLinkStream *st;
     CuAssert(tc,
              db->error->message,
              page_db_link_stream_new(&st, db) == 0);
     st->only_diff_domain = 0;

     Hits *hits;
     ret = hits_new(&hits, test_dir, 5);
     CuAssert(tc,
              hits!=0? hits->error->message: "NULL",
              ret == 0);

     hits->precision = 1e-8;
     CuAssert(tc,
              hits->error->message,
              hits_compute(hits,
                           st,
                           page_db_link_stream_next,
                           page_db_link_stream_reset) == 0);
     page_db_link_stream_delete(st);

     uint64_t idx;
     float *h_score;
     float *a_score;
     float h_scores[5] = {0.250, 0.250, 0.250, 0.250, 0.000};
     float a_scores[5] = {0.125, 0.125, 0.125, 0.125, 0.500};

     for (int i=0; i<5; ++i) {
          CuAssert(tc,
                   db->error->message,
                   page_db_get_idx(db, page_db_hash(urls[i]), &idx) == 0);

          CuAssertPtrNotNull(tc,
                             h_score = mmap_array_idx(hits->h1, idx));
          CuAssertPtrNotNull(tc,
                             a_score = mmap_array_idx(hits->a1, idx));

          CuAssertDblEquals(tc, h_scores[i], *h_score, 1e-6);
          CuAssertDblEquals(tc, a_scores[i], *a_score, 1e-6);
     }
     CuAssert(tc,
              hits->error->message,
              hits_delete(hits) == 0);

     page_db_delete(db);
}
コード例 #22
0
ファイル: tests.c プロジェクト: ammiranda/CS261
/**
 * Tests all hash map functions after adding and removing all of the given keys
 * and values.
 * @param test
 * @param links The key-value pairs to be added and removed.
 * @param notKeys Some keys not in the table to test contains and get.
 * @param numLinks The number of key-value pairs to be added and removed.
 * @param numNotKeys The number of keys not in the table.
 * @param numBuckets The initial number of buckets (capacity) in the table.
 */
void testCase(CuTest* test, HashLink* links, const char** notKeys, int numLinks,
              int numNotKeys, int numBuckets)
{
    HashMap* map = hashMapNew(numBuckets);
    Histogram hist;
    
    // Add links
    for (int i = 0; i < numLinks; i++)
    {
        hashMapPut(map, links[i].key, links[i].value);
    }
    
    // Print table
    printf("\nAfter adding all key-value pairs:");
    hashMapPrint(map);
    
    // Check size
    CuAssertIntEquals(test, numLinks, hashMapSize(map));
    
    // Check capacity
    CuAssertIntEquals(test, map->capacity, hashMapCapacity(map));
    
    // Check empty buckets
    int sum = 0;
    for (int i = 0; i < map->capacity; i++)
    {
        if (map->table[i] == NULL)
        {
            sum++;
        }
    }
    CuAssertIntEquals(test, sum, hashMapEmptyBuckets(map));
    
    // Check table load
    CuAssertIntEquals(test, (float)numLinks / map->capacity, hashMapTableLoad(map));
    
    // Check contains and get on valid keys.
    for (int i = 0; i < numLinks; i++)
    {
        CuAssertIntEquals(test, 1, hashMapContainsKey(map, links[i].key));
        int* value = hashMapGet(map, links[i].key);
        CuAssertPtrNotNull(test, value);
        CuAssertIntEquals(test, links[i].value, *value);
    }
    
    // Check contains and get on invalid keys.
    for (int i = 0; i < numNotKeys; i++)
    {
        CuAssertIntEquals(test, 0, hashMapContainsKey(map, notKeys[i]));
        CuAssertPtrEquals(test, NULL, hashMapGet(map, notKeys[i]));
    }
    
    // Check that all links are present and have a unique key.
    histFromTable(&hist, map);
    CuAssertIntEquals(test, numLinks, hist.size);
    assertHistCounts(test, &hist);
    histCleanUp(&hist);
    
    // Remove keys
    for (int i = 0; i < numLinks; i++)
    {
        hashMapRemove(map, links[i].key);
    }
    
    // Print table
    printf("\nAfter removing all key-value pairs:");
    hashMapPrint(map);
    
    // Check size
    CuAssertIntEquals(test, 0, hashMapSize(map));
    
    // Check capacity
    CuAssertIntEquals(test, map->capacity, hashMapCapacity(map));
    
    // Check empty buckets
    CuAssertIntEquals(test, map->capacity, hashMapEmptyBuckets(map));
    
    // Check table load
    CuAssertIntEquals(test, 0, hashMapTableLoad(map));
    
    // Check contains and get on valid keys.
    for (int i = 0; i < numLinks; i++)
    {
        CuAssertIntEquals(test, 0, hashMapContainsKey(map, links[i].key));
        CuAssertPtrEquals(test, NULL, hashMapGet(map, links[i].key));
    }
    
    // Check contains and get on invalid keys.
    for (int i = 0; i < numNotKeys; i++)
    {
        CuAssertIntEquals(test, 0, hashMapContainsKey(map, notKeys[i]));
        CuAssertPtrEquals(test, NULL, hashMapGet(map, notKeys[i]));
    }
    
    // Check that there are no links in the table.
    histFromTable(&hist, map);
    CuAssertIntEquals(test, 0, hist.size);
    assertHistCounts(test, &hist);
    histCleanUp(&hist);
    
    hashMapDelete(map);
}
コード例 #23
0
void test_interface(CuTest * tc)
{
  CuAssertPtrNotNull(tc, svc.reset);
  CuAssertPtrNotNull(tc, svc.get_regions);
  CuAssertPtrNotNull(tc, svc.add_event);
  CuAssertTrue(tc, 0!=svc.max_directions);

  CuAssertPtrNotNull(tc, svc.regions);
  CuAssertPtrNotNull(tc, svc.regions->create);
  CuAssertPtrNotNull(tc, svc.regions->destroy);
  CuAssertPtrNotNull(tc, svc.regions->get_xy);
  CuAssertPtrNotNull(tc, svc.regions->get_units);

  CuAssertPtrNotNull(tc, svc.units);
  CuAssertPtrNotNull(tc, svc.units->create);
  CuAssertPtrNotNull(tc, svc.units->destroy);
  CuAssertPtrNotNull(tc, svc.units->get_uid);
  CuAssertPtrNotNull(tc, svc.units->get_region);
  CuAssertPtrNotNull(tc, svc.units->get);
  CuAssertPtrNotNull(tc, svc.units->get_moves);
  CuAssertPtrNotNull(tc, svc.units->get_movement_speed);
}
コード例 #24
0
ファイル: test_pagedb.c プロジェクト: plafl/aduana
/* Tests the loading/dumping of PageInfo from and into LMDB values */
void
test_page_info_serialization(CuTest *tc) {
     printf("%s\n", __func__);
     MDB_val val;
     PageInfo pi1 = {
          .url                 = "test_url_123",
          .first_crawl         = 123,
          .last_crawl          = 456,
          .n_changes           = 100,
          .n_crawls            = 20,
          .score               = 0.7,
          .content_hash_length = 8,
          .content_hash        = "1234567"
     };

     CuAssertTrue(tc, page_info_dump(&pi1, &val) == 0);
     CuAssertDblEquals(tc, 0.7, page_info_dump_get_score(&val), 1e-6);

     PageInfo *pi2 = page_info_load(&val);
     CuAssertPtrNotNull(tc, pi2);

     free(val.mv_data);

     CuAssertStrEquals(tc, pi1.url, pi2->url);
     CuAssertTrue(tc, pi1.first_crawl == pi2->first_crawl);
     CuAssertTrue(tc, pi1.last_crawl == pi2->last_crawl);
     CuAssertTrue(tc, pi1.n_changes == pi2->n_changes);
     CuAssertTrue(tc, pi1.n_crawls == pi2->n_crawls);
     CuAssertTrue(tc, pi1.score == pi2->score);
     CuAssertTrue(tc, pi1.content_hash_length == pi2->content_hash_length);
     CuAssertStrEquals(tc, pi1.content_hash, pi2->content_hash);

     page_info_delete(pi2);
}

/* Tests all the database operations on a very simple crawl of just two pages */
void
test_page_db_simple(CuTest *tc) {
     printf("%s\n", __func__);

     char test_dir[] = "test-pagedb-XXXXXX";
     mkdtemp(test_dir);

     PageDB *db;
     int ret = page_db_new(&db, test_dir);
     CuAssert(tc,
              db!=0? db->error->message: "NULL",
              ret == 0);
     db->persist = 0;

     CrawledPage *cp1 = crawled_page_new("www.yahoo.com");
     crawled_page_add_link(cp1, "a", 0.1);
     crawled_page_add_link(cp1, "b", 0.2);
     crawled_page_add_link(cp1, "www.google.com", 0.3);
     crawled_page_set_hash64(cp1, 1000);
     cp1->score = 0.5;

     CrawledPage *cp2 = crawled_page_new("www.bing.com");
     crawled_page_add_link(cp2, "x", 1.1);
     crawled_page_add_link(cp2, "y", 1.2);
     crawled_page_set_hash64(cp2, 2000);
     cp2->score = 0.2;

     PageInfoList *pil;
     CuAssert(tc,
              db->error->message,
              page_db_add(db, cp1, &pil) == 0);
     page_info_list_delete(pil);

     CuAssert(tc,
              db->error->message,
              page_db_add(db, cp2, &pil) == 0);
     page_info_list_delete(pil);

     crawled_page_set_hash64(cp2, 3000);
     CuAssert(tc,
              db->error->message,
              page_db_add(db, cp2, &pil) == 0);
     page_info_list_delete(pil);

     MMapArray *scores = 0;
     CuAssert(tc,
              db->error->message,
              page_db_get_scores(db, &scores) == 0);

     size_t idx;
     CuAssert(tc,
              db->error->message,
              page_db_get_idx(db, page_db_hash("www.yahoo.com"), &idx) == 0);
     CuAssertDblEquals(
          tc,
          0.5,
          *(float*)mmap_array_idx(scores, idx),
          1e-6);
     CuAssert(tc,
              db->error->message,
              page_db_get_idx(db, page_db_hash("x"), &idx) == 0);
     CuAssertDblEquals(
          tc,
          1.1,
          *(float*)mmap_array_idx(scores, idx),
          1e-6);

     CHECK_DELETE(tc, scores->error->message, mmap_array_delete(scores));

     crawled_page_delete(cp1);
     crawled_page_delete(cp2);

     char pi_out[1000];
     char *print_pages[] = {"www.yahoo.com", "www.google.com", "www.bing.com"};
     for (size_t i=0; i<3; ++i) {
          PageInfo *pi;
          CuAssert(tc,
                   db->error->message,
                   page_db_get_info(db, page_db_hash(print_pages[i]), &pi) == 0);

          CuAssertPtrNotNull(tc, pi);

          switch(i) {
          case 0:
               CuAssertIntEquals(tc, 1, pi->n_crawls);
               CuAssertIntEquals(tc, 0, pi->n_changes);
               break;
          case 1:
               CuAssertIntEquals(tc, 0, pi->n_crawls);
               break;
          case 2:
               CuAssertIntEquals(tc, 2, pi->n_crawls);
               CuAssertIntEquals(tc, 1, pi->n_changes);
               break;
          }
          page_info_print(pi, pi_out);
          page_info_delete(pi);
/* show on screen the page info:
 *
 * Mon Apr  6 15:34:50 2015|Mon Apr  6 15:34:50 2015|1.00e+00|0.00e+00|www.yahoo.com
 * Thu Jan  1 01:00:00 1970|Thu Jan  1 01:00:00 1970|0.00e+00|0.00e+00|www.google.com
 * Mon Apr  6 15:34:50 2015|Mon Apr  6 15:34:50 2015|2.00e+00|1.00e+00|www.bing.com
 */
#if 0
          printf("%s\n", pi_out);
#endif
     }

     PageDBLinkStream *es;
     CuAssert(tc,
              db->error->message,
              page_db_link_stream_new(&es, db) == 0);
     es->only_diff_domain = 0;

     if (es->state == stream_state_init) {
          Link link;
          int i=0;
          while (page_db_link_stream_next(es, &link) == stream_state_next) {
               switch(i++) {
               case 0:
                    CuAssertIntEquals(tc, 0, link.from);
                    CuAssertIntEquals(tc, 1, link.to);
                    break;
               case 1:
                    CuAssertIntEquals(tc, 0, link.from);
                    CuAssertIntEquals(tc, 2, link.to);
                    break;
               case 2:
                    CuAssertIntEquals(tc, 0, link.from);
                    CuAssertIntEquals(tc, 3, link.to);
                    break;
               case 3:
                    CuAssertIntEquals(tc, 4, link.from);
                    CuAssertIntEquals(tc, 5, link.to);
                    break;
               case 4:
                    CuAssertIntEquals(tc, 4, link.from);
                    CuAssertIntEquals(tc, 6, link.to);
                    break;
               default:
                    CuFail(tc, "too many links");
                    break;
               }
          }
          CuAssertTrue(tc, es->state != stream_state_error);
     }
     page_db_link_stream_delete(es);

     page_db_delete(db);
}
コード例 #25
0
ファイル: jsonconf.test.c プロジェクト: hochl/server
static void check_flag(CuTest *tc, const char *name, int flag) {
    const struct race *rc = race_with_flag(name);
    CuAssertPtrNotNull(tc, rc);
    CuAssertIntEquals(tc, flag, rc->flags);
}
コード例 #26
0
ファイル: tests.test.c プロジェクト: TomBraun/server
static void test_recreate_world(CuTest * tc)
{
  test_cleanup();
  CuAssertPtrEquals(tc, 0, get_locale("de"));
  CuAssertPtrEquals(tc, 0, (void *)rt_find("horse"));
  CuAssertPtrNotNull(tc, get_resourcetype(R_LIFE));
  CuAssertPtrNotNull(tc, get_resourcetype(R_PERMAURA));
  CuAssertPtrNotNull(tc, get_resourcetype(R_AURA));
  CuAssertPtrNotNull(tc, (void *)rt_find("money"));

  test_create_world();
  CuAssertPtrEquals(tc, default_locale, get_locale("de"));
  CuAssertPtrNotNull(tc, default_locale);
  CuAssertPtrNotNull(tc, findregion(0, 0));
  CuAssertPtrNotNull(tc, (void *)rt_find("horse"));
  CuAssertPtrNotNull(tc, get_resourcetype(R_HORSE));
  CuAssertPtrNotNull(tc, (void *)rt_find("money"));
  CuAssertPtrNotNull(tc, get_resourcetype(R_LIFE));
  CuAssertPtrNotNull(tc, get_resourcetype(R_SILVER));
  CuAssertPtrNotNull(tc, get_resourcetype(R_AURA));
  CuAssertPtrNotNull(tc, get_resourcetype(R_PERMAURA));
  CuAssertPtrNotNull(tc, get_resourcetype(R_PEASANT));
  CuAssertPtrNotNull(tc, get_resourcetype(R_UNIT));

  test_cleanup();
  CuAssertPtrEquals(tc, 0, get_locale("de"));
  CuAssertPtrEquals(tc, 0, (void*)rt_find("horse"));
  CuAssertPtrEquals(tc, 0, (void*)get_resourcetype(R_HORSE));
  CuAssertPtrNotNull(tc, (void *)rt_find("money"));
  CuAssertPtrNotNull(tc, get_resourcetype(R_LIFE));
  CuAssertPtrNotNull(tc, get_resourcetype(R_SILVER));
  CuAssertPtrNotNull(tc, get_resourcetype(R_AURA));
  CuAssertPtrNotNull(tc, get_resourcetype(R_PERMAURA));
  CuAssertPtrNotNull(tc, get_resourcetype(R_PEASANT));
  CuAssertPtrNotNull(tc, get_resourcetype(R_UNIT));
  CuAssertPtrEquals(tc, 0, findregion(0, 0));
}
コード例 #27
0
ファイル: jsonconf.test.c プロジェクト: hochl/server
static void test_buildings(CuTest * tc)
{
    const char * data = "{\"buildings\": { "
        "\"house\" : { "
        "\"maintenance\" : "
        "{ \"type\" : \"iron\", \"amount\" : 1, \"flags\" : [ \"required\", \"variable\" ] }"
        ","
        "\"construction\" : {"
        "\"maxsize\" : 20,"
        "\"reqsize\" : 10,"
        "\"minskill\" : 1,"
        "\"materials\" : {"
        "\"stone\" : 2,"
        "\"iron\" : 1"
        "}}},"
        "\"shed\" : {"
        "\"maintenance\" : ["
        "{ \"type\" : \"iron\", \"amount\" : 1 },"
        "{ \"type\" : \"stone\", \"amount\" : 2 }"
        "]}"
        "}}";

    cJSON *json = cJSON_Parse(data);
    const building_type *bt;

    test_cleanup();

    CuAssertPtrNotNull(tc, json);
    CuAssertPtrEquals(tc, 0, buildingtypes);
    json_config(json);

    CuAssertPtrNotNull(tc, buildingtypes);
    bt = bt_find("shed");
    CuAssertPtrNotNull(tc, bt);
    CuAssertPtrNotNull(tc, bt->maintenance);
    CuAssertPtrEquals(tc, (void *)get_resourcetype(R_IRON), (void *)bt->maintenance[0].rtype);
    CuAssertPtrEquals(tc, (void *)get_resourcetype(R_STONE), (void *)bt->maintenance[1].rtype);
    CuAssertIntEquals(tc, 1, bt->maintenance[0].number);
    CuAssertIntEquals(tc, 2, bt->maintenance[1].number);
    CuAssertIntEquals(tc, 0, bt->maintenance[2].number);

    bt = bt_find("house");
    CuAssertPtrNotNull(tc, bt);

    CuAssertPtrNotNull(tc, bt->maintenance);
    CuAssertIntEquals(tc, 1, bt->maintenance[0].number);
    CuAssertPtrEquals(tc, (void *)get_resourcetype(R_IRON), (void *)bt->maintenance[0].rtype);
    CuAssertIntEquals(tc, MTF_VARIABLE|MTF_VITAL, bt->maintenance[0].flags);
    CuAssertIntEquals(tc, 0, bt->maintenance[1].number);

    CuAssertPtrNotNull(tc, bt->construction);
    CuAssertPtrNotNull(tc, bt->construction->materials);
    CuAssertIntEquals(tc, 2, bt->construction->materials[0].number);
    CuAssertPtrEquals(tc, (void *)get_resourcetype(R_STONE), (void *)bt->construction->materials[0].rtype);
    CuAssertIntEquals(tc, 1, bt->construction->materials[1].number);
    CuAssertPtrEquals(tc, (void *)get_resourcetype(R_IRON), (void *)bt->construction->materials[1].rtype);
    CuAssertIntEquals(tc, 0, bt->construction->materials[2].number);
    CuAssertIntEquals(tc, 10, bt->construction->reqsize);
    CuAssertIntEquals(tc, 20, bt->construction->maxsize);
    CuAssertIntEquals(tc, 1, bt->construction->minskill);
    CuAssertPtrEquals(tc, 0, bt->construction->improvement);
    test_cleanup();
}
コード例 #28
0
void Testredblack_tree_walk_postorder(CuTest *tc)
  {
 	test_redblack_tree_t *root;
    test_redblack_tree_t *elem;
    void		*pret;
    bool		ret;

	root = NULL;
    elem = malloc(sizeof(*elem));
    elem->key = 8;
    ret = redblack_tree_insert(root, elem, redblack_tree, BTREE_COMPARE);
    CuAssertTrue(tc, ret);

    elem = malloc(sizeof(*elem));
    elem->key = 6;
    ret = redblack_tree_insert(root, elem, redblack_tree, BTREE_COMPARE);
    CuAssertTrue(tc, ret);

    elem = malloc(sizeof(*elem));
    elem->key = 5;
    ret = redblack_tree_insert(root, elem, redblack_tree, BTREE_COMPARE);
    CuAssertTrue(tc, ret);

    elem = malloc(sizeof(*elem));
    elem->key = 7;
    ret = redblack_tree_insert(root, elem, redblack_tree, BTREE_COMPARE);
    CuAssertTrue(tc, ret);

    elem = malloc(sizeof(*elem));
    elem->key = 10;
    ret = redblack_tree_insert(root, elem, redblack_tree, BTREE_COMPARE);
    CuAssertTrue(tc, ret);

    elem = malloc(sizeof(*elem));
    elem->key = 9;
    ret = redblack_tree_insert(root, elem, redblack_tree, BTREE_COMPARE);
    CuAssertTrue(tc, ret);

    elem = malloc(sizeof(*elem));
    elem->key = 11;
    ret = redblack_tree_insert(root, elem, redblack_tree, BTREE_COMPARE);
    CuAssertTrue(tc, ret);

    walk_state = true;
	prev_value = -1;
	redblack_tree_walk_postorder(root, redblack_tree, redblack_tree_walk_postorder_cb, NULL);
	CuAssertIntEquals(tc,true, walk_state);

    pret = redblack_tree_remove(root, 8, redblack_tree, BTREE_COMPARE, BTREE_COMPARE_KEY);
    CuAssertPtrNotNull(tc, pret);

    pret = redblack_tree_remove(root, 6, redblack_tree, BTREE_COMPARE, BTREE_COMPARE_KEY);
    CuAssertPtrNotNull(tc, pret);

    pret = redblack_tree_remove(root, 5, redblack_tree, BTREE_COMPARE, BTREE_COMPARE_KEY);
    CuAssertPtrNotNull(tc, pret);

    pret = redblack_tree_remove(root, 7, redblack_tree, BTREE_COMPARE, BTREE_COMPARE_KEY);
    CuAssertPtrNotNull(tc, pret);

    pret = redblack_tree_remove(root, 10, redblack_tree, BTREE_COMPARE, BTREE_COMPARE_KEY);
    CuAssertPtrNotNull(tc, pret);

    pret = redblack_tree_remove(root, 9, redblack_tree, BTREE_COMPARE, BTREE_COMPARE_KEY);
    CuAssertPtrNotNull(tc, pret);

    pret = redblack_tree_remove(root, 11, redblack_tree, BTREE_COMPARE, BTREE_COMPARE_KEY);
    CuAssertPtrNotNull(tc, pret);

    CuAssertPtrEquals(tc, NULL, root);
  }
コード例 #29
0
ファイル: test-api.c プロジェクト: flebel/augeas
static void testGet(CuTest *tc) {
    int r;
    const char *value;
    struct augeas *aug;

    aug = aug_init(root, loadpath, AUG_NO_STDINC|AUG_NO_LOAD);
    CuAssertPtrNotNull(tc, aug);
    CuAssertIntEquals(tc, AUG_NOERROR, aug_error(aug));

    /* Make sure we're looking at the right thing */
    r = aug_match(aug, "/augeas/version/save/*", NULL);
    CuAssertTrue(tc, r > 1);
    CuAssertIntEquals(tc, AUG_NOERROR, aug_error(aug));

    /* aug_get returns 1 and the value if exactly one node matches */
    r = aug_get(aug, "/augeas/version/save/*[1]", &value);
    CuAssertIntEquals(tc, 1, r);
    CuAssertPtrNotNull(tc, value);
    CuAssertIntEquals(tc, AUG_NOERROR, aug_error(aug));

    /* aug_get returns 0 and no value when no node matches */
    r = aug_get(aug, "/augeas/version/save/*[ last() + 1 ]", &value);
    CuAssertIntEquals(tc, 0, r);
    CuAssertPtrEquals(tc, NULL, value);
    CuAssertIntEquals(tc, AUG_NOERROR, aug_error(aug));

    /* aug_get should return an error when multiple nodes match */
    r = aug_get(aug, "/augeas/version/save/*", &value);
    CuAssertIntEquals(tc, -1, r);
    CuAssertPtrEquals(tc, NULL, value);
    CuAssertIntEquals(tc, AUG_EMMATCH, aug_error(aug));

    /* augeas should prepend context if relative path given */
    r = aug_set(aug, "/augeas/context", "/augeas/version");
    r = aug_get(aug, "save/*[1]", &value);
    CuAssertIntEquals(tc, 1, r);
    CuAssertPtrNotNull(tc, value);
    CuAssertIntEquals(tc, AUG_NOERROR, aug_error(aug));

    /* augeas should still work with an empty context */
    r = aug_set(aug, "/augeas/context", "");
    r = aug_get(aug, "/augeas/version", &value);
    CuAssertIntEquals(tc, 1, r);
    CuAssertPtrNotNull(tc, value);
    CuAssertIntEquals(tc, AUG_NOERROR, aug_error(aug));

    /* augeas should ignore trailing slashes in context */
    r = aug_set(aug, "/augeas/context", "/augeas/version/");
    r = aug_get(aug, "save/*[1]", &value);
    CuAssertIntEquals(tc, 1, r);
    CuAssertPtrNotNull(tc, value);
    CuAssertIntEquals(tc, AUG_NOERROR, aug_error(aug));

    /* augeas should create non-existent context path */
    r = aug_set(aug, "/augeas/context", "/context/foo");
    r = aug_set(aug, "bar", "value");
    r = aug_get(aug, "/context/foo/bar", &value);
    CuAssertIntEquals(tc, 1, r);
    CuAssertPtrNotNull(tc, value);
    CuAssertIntEquals(tc, AUG_NOERROR, aug_error(aug));

    aug_close(aug);
}
コード例 #30
0
void test_fitsbin_2(CuTest* ct) {
    fitsbin_t* in, *out;
    int i;
    int N = 6;
    double outdata[6];
    double* indata;
    char* fn;
    fitsbin_chunk_t chunk;
    fitsbin_chunk_t* ch;

    fn = get_tmpfile(0);
    printf("Writing to %s\n", fn);
    out = fitsbin_open_for_writing(fn);
    CuAssertPtrNotNull(ct, out);

    CuAssertIntEquals(ct, 0, fitsbin_write_primary_header(out));

    for (i=0; i<N; i++) {
        outdata[i] = i*i;
    }

    fitsbin_chunk_init(&chunk);
    chunk.tablename = "test2";
    chunk.itemsize = 1;
    //chunk.nrows = N * sizeof(double);
    chunk.data = outdata;

    CuAssertIntEquals(ct, 0, fitsbin_write_chunk_header(out, &chunk));
    for (i=0; i<N; i++) {
        CuAssertIntEquals(ct, 0, fitsbin_write_items(out, &chunk, &outdata[i], sizeof(double)));
    }
    CuAssertIntEquals(ct, 0, fitsbin_fix_chunk_header(out, &chunk));

    fitsbin_chunk_reset(&chunk);
    chunk.tablename = "test2B";
    chunk.itemsize = sizeof(double);
    //chunk.nrows = N;
    chunk.data = outdata;

    CuAssertIntEquals(ct, 0, fitsbin_write_chunk_header(out, &chunk));
    for (i=0; i<N; i++) {
        CuAssertIntEquals(ct, 0, fitsbin_write_items(out, &chunk, outdata + (N-1) - i, 1));
    }
    CuAssertIntEquals(ct, 0, fitsbin_fix_chunk_header(out, &chunk));

    CuAssertIntEquals(ct, fitsbin_close(out), 0);

    fitsbin_chunk_clean(&chunk);

    // writing shouldn't affect the data values
    for (i=0; i<N; i++) {
        CuAssertIntEquals(ct, outdata[i], i*i);
    }

    in = fitsbin_open(fn);
    CuAssertPtrNotNull(ct, in);

    fitsbin_chunk_init(&chunk);
    chunk.tablename = "test2";
    fitsbin_add_chunk(in, &chunk);
    chunk.tablename = "test2B";
    fitsbin_add_chunk(in, &chunk);

    CuAssertIntEquals(ct, 0, fitsbin_read(in));

    ch = fitsbin_get_chunk(in, 0);
    CuAssertIntEquals(ct, 1, ch->itemsize);
    CuAssertIntEquals(ct, N * sizeof(double), ch->nrows);
    indata = ch->data;
    CuAssertPtrNotNull(ct, indata);
    CuAssertIntEquals(ct, 0, memcmp(outdata, indata, sizeof(outdata)));
 
    ch = fitsbin_get_chunk(in, 1);
    CuAssertIntEquals(ct, sizeof(double), ch->itemsize);
    CuAssertIntEquals(ct, N, ch->nrows);
    indata = ch->data;
    CuAssertPtrNotNull(ct, indata);
    for (i=0; i<N; i++) {
        CuAssertDblEquals(ct, outdata[N-1 - i], indata[i], 1e-10);
    }

    CuAssertIntEquals(ct, 0, fitsbin_close(in));
}