static void test_getunit(CuTest *tc) {
unit *u, *u2;
order *ord;
attrib *a;
struct region *r;
struct locale *lang;
struct terrain_type *t_plain;
test_cleanup();
lang = get_or_create_locale("de");
test_translate_param(lang, P_TEMP, "TEMP");
/* note that the english order is FIGHT, not COMBAT, so this is a poor example */
t_plain = test_create_terrain("plain", LAND_REGION);
u = test_create_unit(test_create_faction(0), test_create_region(0, 0, t_plain));
a = a_add(&u->attribs, a_new(&at_alias));
a->data.i = atoi36("42"); /* this unit is also TEMP 42 */
r = test_create_region(1, 0, t_plain);
ord = create_order(K_GIVE, lang, itoa36(u->no));
init_order(ord);
CuAssertIntEquals(tc, GET_UNIT, getunit(u->region, u->faction, &u2));
CuAssertPtrEquals(tc, u, u2);
init_order(ord);
CuAssertIntEquals(tc, GET_NOTFOUND, getunit(r, u->faction, &u2));
CuAssertPtrEquals(tc, NULL, u2);
free_order(ord);
ord = create_order(K_GIVE, lang, itoa36(u->no + 1));
init_order(ord);
CuAssertIntEquals(tc, GET_NOTFOUND, getunit(u->region, u->faction, &u2));
CuAssertPtrEquals(tc, NULL, u2);
free_order(ord);
ord = create_order(K_GIVE, lang, "0");
init_order(ord);
CuAssertIntEquals(tc, GET_PEASANTS, getunit(u->region, u->faction, &u2));
CuAssertPtrEquals(tc, NULL, u2);
free_order(ord);
// bug https://bugs.eressea.de/view.php?id=1685
ord = create_order(K_GIVE, lang, "TEMP ##");
init_order(ord);
CuAssertIntEquals(tc, GET_NOTFOUND, getunit(u->region, u->faction, &u2));
CuAssertPtrEquals(tc, NULL, u2);
free_order(ord);
// bug https://bugs.eressea.de/view.php?id=1685
ord = create_order(K_GIVE, lang, "##");
init_order(ord);
CuAssertIntEquals(tc, GET_NOTFOUND, getunit(u->region, u->faction, &u2));
CuAssertPtrEquals(tc, NULL, u2);
free_order(ord);
ord = create_order(K_GIVE, lang, "TEMP 42");
init_order(ord);
CuAssertIntEquals(tc, GET_UNIT, getunit(u->region, u->faction, &u2));
CuAssertPtrEquals(tc, u, u2);
free_order(ord);
test_cleanup();
}
void Test_iniparser_getseckeys(CuTest *tc)
{
unsigned i;
char key_name[64];
dictionary *dic;
int nkeys;
const char * keys[10]; /* At most 10 elements per section */
/* NULL test */
CuAssertPtrEquals(tc, NULL, iniparser_getseckeys(NULL, NULL, NULL));
CuAssertPtrEquals(tc, NULL, iniparser_getseckeys(NULL, "dummy", NULL));
CuAssertPtrEquals(tc, NULL, iniparser_getseckeys(NULL, "dummy", keys));
/* Empty dictionary */
dic = dictionary_new(10);
CuAssertPtrEquals(tc, NULL, iniparser_getseckeys(dic, NULL, keys));
CuAssertPtrEquals(tc, NULL, iniparser_getseckeys(dic, "dummy", keys));
dictionary_del(dic);
/* Generic dictionary */
dic = generate_dictionary(100, 10);
CuAssertPtrEquals(tc, NULL, iniparser_getseckeys(dic, NULL, keys));
CuAssertPtrEquals(tc, NULL, iniparser_getseckeys(dic, "dummy", keys));
CuAssertPtrEquals(tc, NULL, iniparser_getseckeys(dic, "sec0", NULL));
nkeys = iniparser_getsecnkeys(dic, "sec42");
CuAssertIntEquals(tc, nkeys, 10);
CuAssertPtrEquals(tc, keys, iniparser_getseckeys(dic, "sec42", keys));
for (i = 0; i < 10; ++i) {
sprintf(key_name, "sec42:key%d", i);
CuAssertStrEquals(tc, key_name, keys[i]);
}
/* Remove some keys to make the dictionary more real */
dictionary_unset(dic, "sec42");
dictionary_unset(dic, "sec99:key9");
dictionary_unset(dic, "sec0:key0");
dictionary_unset(dic, "sec0:key1");
dictionary_unset(dic, "sec0:key2");
CuAssertPtrEquals(tc, NULL, iniparser_getseckeys(dic, "sec42", keys));
nkeys = iniparser_getsecnkeys(dic, "sec99");
CuAssertIntEquals(tc, nkeys, 9);
CuAssertPtrEquals(tc, keys, iniparser_getseckeys(dic, "sec99", keys));
for (i = 0; i < 9; ++i) {
sprintf(key_name, "sec99:key%d", i);
CuAssertStrEquals(tc, key_name, keys[i]);
}
nkeys = iniparser_getsecnkeys(dic, "sec0");
CuAssertIntEquals(tc, nkeys, 7);
CuAssertPtrEquals(tc, keys, iniparser_getseckeys(dic, "sec0", keys));
for (i = 0; i < 7; ++i) {
sprintf(key_name, "sec0:key%d", i + 3);
CuAssertStrEquals(tc, key_name, keys[i]);
}
dictionary_del(dic);
}
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();
}
/**
* 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);
}
static void pollset_remove(CuTest *tc)
{
apr_status_t rv;
apr_pollset_t *pollset;
const apr_pollfd_t *hot_files;
apr_pollfd_t pfd;
apr_int32_t num;
rv = apr_pollset_create(&pollset, 5, p, 0);
CuAssertIntEquals(tc, APR_SUCCESS, rv);
pfd.p = p;
pfd.desc_type = APR_POLL_SOCKET;
pfd.reqevents = APR_POLLOUT;
pfd.desc.s = s[0];
pfd.client_data = (void *)1;
rv = apr_pollset_add(pollset, &pfd);
CuAssertIntEquals(tc, APR_SUCCESS, rv);
pfd.desc.s = s[1];
pfd.client_data = (void *)2;
rv = apr_pollset_add(pollset, &pfd);
CuAssertIntEquals(tc, APR_SUCCESS, rv);
pfd.desc.s = s[2];
pfd.client_data = (void *)3;
rv = apr_pollset_add(pollset, &pfd);
CuAssertIntEquals(tc, APR_SUCCESS, rv);
pfd.desc.s = s[1];
pfd.client_data = (void *)4;
rv = apr_pollset_add(pollset, &pfd);
CuAssertIntEquals(tc, APR_SUCCESS, rv);
pfd.desc.s = s[3];
pfd.client_data = (void *)5;
rv = apr_pollset_add(pollset, &pfd);
CuAssertIntEquals(tc, APR_SUCCESS, rv);
rv = apr_pollset_poll(pollset, 1000, &num, &hot_files);
CuAssertIntEquals(tc, APR_SUCCESS, rv);
CuAssertIntEquals(tc, 5, num);
/* now remove the pollset elements referring to desc s[1] */
pfd.desc.s = s[1];
pfd.client_data = (void *)999; /* not used on this call */
rv = apr_pollset_remove(pollset, &pfd);
CuAssertIntEquals(tc, APR_SUCCESS, rv);
/* this time only three should match */
rv = apr_pollset_poll(pollset, 1000, &num, &hot_files);
CuAssertIntEquals(tc, APR_SUCCESS, rv);
CuAssertIntEquals(tc, 3, num);
CuAssertPtrEquals(tc, (void *)1, hot_files[0].client_data);
CuAssertPtrEquals(tc, s[0], hot_files[0].desc.s);
CuAssertPtrEquals(tc, (void *)3, hot_files[1].client_data);
CuAssertPtrEquals(tc, s[2], hot_files[1].desc.s);
CuAssertPtrEquals(tc, (void *)5, hot_files[2].client_data);
CuAssertPtrEquals(tc, s[3], hot_files[2].desc.s);
/* now remove the pollset elements referring to desc s[2] */
pfd.desc.s = s[2];
pfd.client_data = (void *)999; /* not used on this call */
rv = apr_pollset_remove(pollset, &pfd);
CuAssertIntEquals(tc, APR_SUCCESS, rv);
/* this time only two should match */
rv = apr_pollset_poll(pollset, 1000, &num, &hot_files);
CuAssertIntEquals(tc, APR_SUCCESS, rv);
CuAssertIntEquals(tc, 2, num);
CuAssertPtrEquals(tc, (void *)1, hot_files[0].client_data);
CuAssertPtrEquals(tc, s[0], hot_files[0].desc.s);
CuAssertPtrEquals(tc, (void *)5, hot_files[1].client_data);
CuAssertPtrEquals(tc, s[3], hot_files[1].desc.s);
}
void TestCreateTextProperty(CuTest* tc) {
TextProperty* pro = createTextProperty();
CuAssertPtrEquals(tc, NULL, getTextProperty(pro));
deleteTextProperty(pro);
}
void Test__cstring_strcat_imp(CuTest* tc)
{
CSTRING* a = NULL;
// pass all nulls
a = cstring_strcat_imp(NULL, NULL, 0);
CuAssertPtrEquals(tc, NULL, a);
// pass a null first param
a = cstring_strcat_imp(NULL, "abcde", 5);
CuAssertPtrEquals(tc, NULL, a);
// pass a NULL second parameter
a = cstring_new(0);
a = cstring_strcat_imp(a, NULL, 0);
CuAssertPtrNotNull(tc, a);
CuAssertTrue(tc, 0!=a->memsize);
CuAssertIntEquals(tc, 1, a->canfree);
CuAssertIntEquals(tc, 0, a->length);
CuAssertPtrNotNull(tc, a->string);
CuAssertStrEquals(tc, "", a->string);
cstring_free(&a);
// pass good both, second zero length
a = cstring_new(0);
a = cstring_strcat_imp(a, "", 0);
CuAssertPtrNotNull(tc, a);
CuAssertTrue(tc, 0!=a->memsize);
CuAssertIntEquals(tc, 1, a->canfree);
CuAssertIntEquals(tc, 0, a->length);
CuAssertPtrNotNull(tc, a->string);
CuAssertStrEquals(tc, "", a->string);
cstring_free(&a);
// pass good both, "abcde" for second and length zero
a = cstring_new(0);
a = cstring_strcat_imp(a, "abcde", 0);
CuAssertPtrNotNull(tc, a);
CuAssertTrue(tc, 0!=a->memsize);
CuAssertIntEquals(tc, 1, a->canfree);
CuAssertIntEquals(tc, 0, a->length);
CuAssertPtrNotNull(tc, a->string);
CuAssertStrEquals(tc, "", a->string);
cstring_free(&a);
// pass good both, "abcde" for second and length 3
a = cstring_new(0);
a = cstring_strcat_imp(a, "abcde", 3);
CuAssertPtrNotNull(tc, a);
CuAssertTrue(tc, 0!=a->memsize);
CuAssertIntEquals(tc, 1, a->canfree);
CuAssertIntEquals(tc, 3, a->length);
CuAssertPtrNotNull(tc, a->string);
CuAssertStrEquals(tc, "abc", a->string);
cstring_free(&a);
// pass good both, "abcde" for second and length 5
a = cstring_new(0);
a = cstring_strcat_imp(a, "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);
}
/**
* 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();
}
void testCuAllocGetDataAddr(CuTest_t* tc){
CuAlloc_t allocObj;
CuAssertPtrEquals(tc, &allocObj.array, CuAlloc_getDataAddr(&allocObj));
}
void testCuAllocGetHeaderAddr(CuTest_t* tc){
CuAlloc_t allocObj;
CuAssertPtrEquals(tc, &allocObj, CuAlloc_getHeaderAddr(&allocObj.array));
}
void Testbst_tree_walk_postorder(CuTest *tc)
{
test_bst_tree_t *root;
test_bst_tree_t *elem;
void *pret;
bool ret;
root = NULL;
elem = malloc(sizeof(*elem));
elem->key = 8;
ret = bst_tree_insert(root, elem, btree, BTREE_COMPARE);
CuAssertTrue(tc, ret);
elem = malloc(sizeof(*elem));
elem->key = 6;
ret = bst_tree_insert(root, elem, btree, BTREE_COMPARE);
CuAssertTrue(tc, ret);
elem = malloc(sizeof(*elem));
elem->key = 5;
ret = bst_tree_insert(root, elem, btree, BTREE_COMPARE);
CuAssertTrue(tc, ret);
elem = malloc(sizeof(*elem));
elem->key = 7;
ret = bst_tree_insert(root, elem, btree, BTREE_COMPARE);
CuAssertTrue(tc, ret);
elem = malloc(sizeof(*elem));
elem->key = 10;
ret = bst_tree_insert(root, elem, btree, BTREE_COMPARE);
CuAssertTrue(tc, ret);
elem = malloc(sizeof(*elem));
elem->key = 9;
ret = bst_tree_insert(root, elem, btree, BTREE_COMPARE);
CuAssertTrue(tc, ret);
elem = malloc(sizeof(*elem));
elem->key = 11;
ret = bst_tree_insert(root, elem, btree, BTREE_COMPARE);
CuAssertTrue(tc, ret);
walk_state = true;
prev_value = -1;
bst_tree_walk_postorder(root, btree, btree_walk_postorder_cb, NULL);
CuAssertIntEquals(tc,true, walk_state);
pret = bst_tree_remove(root, 8, btree, BTREE_COMPARE, BTREE_COMPARE_KEY);
CuAssertPtrNotNull(tc, pret);
pret = bst_tree_remove(root, 6, btree, BTREE_COMPARE, BTREE_COMPARE_KEY);
CuAssertPtrNotNull(tc, pret);
pret = bst_tree_remove(root, 5, btree, BTREE_COMPARE, BTREE_COMPARE_KEY);
CuAssertPtrNotNull(tc, pret);
pret = bst_tree_remove(root, 7, btree, BTREE_COMPARE, BTREE_COMPARE_KEY);
CuAssertPtrNotNull(tc, pret);
pret = bst_tree_remove(root, 10, btree, BTREE_COMPARE, BTREE_COMPARE_KEY);
CuAssertPtrNotNull(tc, pret);
pret = bst_tree_remove(root, 9, btree, BTREE_COMPARE, BTREE_COMPARE_KEY);
CuAssertPtrNotNull(tc, pret);
pret = bst_tree_remove(root, 11, btree, BTREE_COMPARE, BTREE_COMPARE_KEY);
CuAssertPtrNotNull(tc, pret);
CuAssertPtrEquals(tc, NULL, root);
}
static void string_strtoi64(CuTest *tc)
{
static const struct {
int errnum, base;
const char *in, *end;
apr_int64_t result;
} ts[] = {
/* base 10 tests */
{ 0, 10, "123545", NULL, APR_INT64_C(123545) },
{ 0, 10, " 123545", NULL, APR_INT64_C(123545) },
{ 0, 10, " +123545", NULL, APR_INT64_C(123545) },
{ 0, 10, "-123545", NULL, APR_INT64_C(-123545) },
{ 0, 10, " 00000123545", NULL, APR_INT64_C(123545) },
{ 0, 10, "123545ZZZ", "ZZZ", APR_INT64_C(123545) },
{ 0, 10, " 123545 ", " ", APR_INT64_C(123545) },
/* base 16 tests */
{ 0, 16, "1E299", NULL, APR_INT64_C(123545) },
{ 0, 16, "1e299", NULL, APR_INT64_C(123545) },
{ 0, 16, "0x1e299", NULL, APR_INT64_C(123545) },
{ 0, 16, "0X1E299", NULL, APR_INT64_C(123545) },
{ 0, 16, "+1e299", NULL, APR_INT64_C(123545) },
{ 0, 16, "-1e299", NULL, APR_INT64_C(-123545) },
{ 0, 16, " -1e299", NULL, APR_INT64_C(-123545) },
/* automatic base detection tests */
{ 0, 0, "123545", NULL, APR_INT64_C(123545) },
{ 0, 0, "0x1e299", NULL, APR_INT64_C(123545) },
{ 0, 0, " 0x1e299", NULL, APR_INT64_C(123545) },
{ 0, 0, "+0x1e299", NULL, APR_INT64_C(123545) },
{ 0, 0, "-0x1e299", NULL, APR_INT64_C(-123545) },
/* large number tests */
{ 0, 10, "8589934605", NULL, APR_INT64_C(8589934605) },
{ 0, 10, "-8589934605", NULL, APR_INT64_C(-8589934605) },
{ 0, 16, "0x20000000D", NULL, APR_INT64_C(8589934605) },
{ 0, 16, "-0x20000000D", NULL, APR_INT64_C(-8589934605) },
{ 0, 16, " 0x20000000D", NULL, APR_INT64_C(8589934605) },
{ 0, 16, " 0x20000000D", NULL, APR_INT64_C(8589934605) },
/* error cases */
{ ERANGE, 10, "999999999999999999999999999999999", "", MY_LLONG_MAX },
{ ERANGE, 10, "-999999999999999999999999999999999", "", MY_LLONG_MIN },
#if 0
/* C99 doesn't require EINVAL for an invalid range. */
{ EINVAL, 99, "", (void *)-1 /* don't care */, 0 },
#endif
/* some strtoll implementations give EINVAL when no conversion
* is performed. */
{ -1 /* don't care */, 10, "zzz", "zzz", APR_INT64_C(0) },
{ -1 /* don't care */, 10, "", NULL, APR_INT64_C(0) }
};
int n;
for (n = 0; n < sizeof(ts)/sizeof(ts[0]); n++) {
char *end = "end ptr not changed";
apr_int64_t result;
int errnum;
errno = 0;
result = apr_strtoi64(ts[n].in, &end, ts[n].base);
errnum = errno;
CuAssert(tc,
apr_psprintf(p, "for '%s': result was %" APR_INT64_T_FMT
" not %" APR_INT64_T_FMT, ts[n].in,
result, ts[n].result),
result == ts[n].result);
if (ts[n].errnum != -1) {
CuAssert(tc,
apr_psprintf(p, "for '%s': errno was %d not %d", ts[n].in,
errnum, ts[n].errnum),
ts[n].errnum == errnum);
}
if (ts[n].end == NULL) {
/* end must point to NUL terminator of .in */
CuAssertPtrEquals(tc, ts[n].in + strlen(ts[n].in), end);
} else if (ts[n].end != (void *)-1) {
CuAssert(tc,
apr_psprintf(p, "for '%s', end was '%s' not '%s'",
ts[n].in, end, ts[n].end),
strcmp(ts[n].end, end) == 0);
}
}
}
void TestReverseWithNullString(CuTest *tc) {
DHString *string = dhstring_new(NULL);
void *actual = string;
void *expected = NULL;
CuAssertPtrEquals(tc, expected, actual);
}
