static void test_piracy_cmd(CuTest * tc) {
faction *f;
region *r;
unit *u, *u2;
terrain_type *t_ocean;
ship_type *st_boat;
test_setup();
setup_piracy();
t_ocean = get_or_create_terrain("ocean");
st_boat = st_get_or_create("boat");
u2 = test_create_unit(test_create_faction(NULL), test_create_region(1, 0, t_ocean));
assert(u2);
u_set_ship(u2, test_create_ship(u2->region, st_boat));
u = test_create_unit(f = test_create_faction(NULL), r = test_create_region(0, 0, t_ocean));
assert(f && u);
set_level(u, SK_SAILING, st_boat->sumskill);
u_set_ship(u, test_create_ship(u->region, st_boat));
f->locale = get_or_create_locale("de");
u->thisorder = create_order(K_PIRACY, f->locale, "%s", itoa36(u2->faction->no));
piracy_cmd(u);
CuAssertPtrEquals(tc, NULL, u->thisorder);
CuAssertTrue(tc, u->region != r);
CuAssertPtrEquals(tc, u2->region, u->region);
CuAssertPtrEquals(tc, u2->region, u->ship->region);
CuAssertPtrNotNullMsg(tc, "successful PIRACY sets attribute", r->attribs); /* FIXME: this is testing implementation, not interface */
CuAssertPtrNotNullMsg(tc, "successful PIRACY message", test_find_messagetype(f->msgs, "piratesawvictim"));
CuAssertPtrNotNullMsg(tc, "successful PIRACY movement", test_find_messagetype(f->msgs, "shipsail"));
test_teardown();
}
static void
check_path(CuTest *tc, struct altera_syscons_parser *parser,
const char *input, const char *cable,
int expected_result, const char *expected_path)
{
const char *begin, *end;
CuAssertPtrNotNull(tc, parser);
CuAssertPtrNotNull(tc, parser->parse_service_path);
int ret = parser->parse_service_path(input, strlen(input), cable,
&begin, &end);
CuAssertIntEquals_Msg(tc, cable, expected_result, ret);
if (expected_result == BERI_DEBUG_SUCCESS) {
CuAssertPtrNotNullMsg(tc, "parsed NULL 'begin'", begin);
CuAssertPtrNotNullMsg(tc, "parsed NULL 'end'", end);
CuAssert(tc, "begin > end", (begin <= end));
char result[end - begin + 1];
strncpy(result, begin, end - begin);
result[end - begin] = '\0';
CuAssertStrEquals_Msg(tc, "unexpected path",
expected_path, result);
}
}
static void
parse_response(CuTest *tc, struct altera_syscons_parser *parser,
const char *input, const char *expected_result)
{
CuAssertPtrNotNull(tc, parser);
CuAssertPtrNotNull(tc, parser->parse_response);
const char *begin, *end;
int ret = parser->parse_response(input, strlen(input),
&begin, &end);
CuAssertIntEquals_Msg(tc, "parse error",
BERI_DEBUG_SUCCESS, ret);
CuAssertPtrNotNullMsg(tc, "parsed NULL 'begin'", begin);
CuAssertPtrNotNullMsg(tc, "parsed NULL 'end'", end);
CuAssert(tc, "begin > end", (begin <= end));
char result[end - begin + 1];
strncpy(result, begin, end - begin);
result[end - begin] = '\0';
CuAssertStrEquals_Msg(tc, "unexpected result",
expected_result, result);
}
void jsonapi_profileMessageToJson_test(mm_logger* logger, CuTest*tc) {
pool*p = logger->pool;
jsonSession* jsonSess = jsonapiunittest_createMockJsonSession(p);
CuAssertPtrNotNullMsg(tc,"jsonSess is null", jsonSess);
char* responseBody=jsonapi_profileMessageToJson(p, jsonSess->profileMsg);
CuAssertPtrNotNullMsg(tc,"statusMsg is null", responseBody);
}
// Create a bunch of objects as demonstration.
void JSON_AddItemToArray_test(mm_logger* logger, CuTest*tc) {
pool*p = logger->pool;
Value *root,*fmt,*img,*thm,*fld;char *out;int i; // declare a few.
// Our array of "records":
struct record fields[2]={
{"zip",37.7668,-1.223959e+2,"","SAN FRANCISCO","CA","94107","US"},
{"zip",37.371991,-1.22026e+2,"","SUNNYVALE","CA","94085","US"}};
root=JSON_CreateArray(p);
for (i=0;i<2;i++)
{
JSON_AddItemToArray(p,root,fld=JSON_CreateObject(p));
JSON_AddStringToObject(p,fld, "precision", fields[i].precision);
JSON_AddNumberToObject(p,fld, "Latitude", fields[i].lat);
JSON_AddNumberToObject(p,fld, "Longitude", fields[i].lon);
JSON_AddStringToObject(p,fld, "Address", fields[i].address);
JSON_AddStringToObject(p,fld, "City", fields[i].city);
JSON_AddStringToObject(p,fld, "State", fields[i].state);
JSON_AddStringToObject(p,fld, "Zip", fields[i].zip);
JSON_AddStringToObject(p,fld, "Country", fields[i].country);
}
out=JSON_Serialize(p,root);
CuAssertPtrNotNullMsg(tc,"Failed to serialize data from JSON_AddItemToArray_test", out);
}
void test_get_user_input(CuTest *tc) {
printf("Type something and hit return (testing user input): ");
char * user_input = get_user_input(-1);
CuAssertPtrNotNullMsg(tc, "user input pointer is null", user_input);
int equal_strings = strcmp("", user_input);
CuAssertTrue(tc, equal_strings != 0);
}
static void test_piracy_cmd_errors(CuTest * tc) {
race *r;
faction *f;
unit *u, *u2;
ship_type *st_boat;
test_setup();
setup_piracy();
st_boat = st_get_or_create("boat");
r = test_create_race("pirates");
u = test_create_unit(f = test_create_faction(r), test_create_region(0, 0, get_or_create_terrain("ocean")));
f->locale = test_create_locale();
u->thisorder = create_order(K_PIRACY, f->locale, "");
assert(u && u->thisorder);
piracy_cmd(u);
CuAssertPtrNotNullMsg(tc, "must be on a ship for PIRACY", test_find_messagetype(f->msgs, "error144"));
test_clear_messages(f);
fset(r, RCF_SWIM);
piracy_cmd(u);
CuAssertPtrEquals_Msg(tc, "swimmers are pirates", 0, test_find_messagetype(f->msgs, "error144"));
CuAssertPtrEquals_Msg(tc, "swimmers are pirates", 0, test_find_messagetype(f->msgs, "error146"));
freset(r, RCF_SWIM);
fset(r, RCF_FLY);
CuAssertPtrEquals_Msg(tc, "flyers are pirates", 0, test_find_messagetype(f->msgs, "error144"));
freset(r, RCF_FLY);
test_clear_messages(f);
u_set_ship(u, test_create_ship(u->region, st_boat));
u2 = test_create_unit(u->faction, u->region);
u2->thisorder = create_order(K_PIRACY, f->locale, "");
u_set_ship(u2, u->ship);
test_clear_messages(f);
piracy_cmd(u2);
CuAssertPtrNotNullMsg(tc, "must be owner for PIRACY", test_find_messagetype(f->msgs, "error146"));
test_clear_messages(f);
piracy_cmd(u);
CuAssertPtrNotNullMsg(tc, "must specify target for PIRACY", test_find_messagetype(f->msgs, "piratenovictim"));
CuAssertPtrNotNull(tc, u->thisorder);
test_teardown();
}
static void test_piracy_cmd_swimmer(CuTest * tc) {
unit *pirate, *victim;
region *r;
test_setup();
setup_pirate(&pirate, 0, RCF_SWIM, NULL, &victim, SWIM_INTO | SEA_REGION, "boat");
r = pirate->region;
piracy_cmd(pirate);
CuAssertPtrEquals(tc, NULL, pirate->thisorder);
CuAssertTrue(tc, pirate->region != r);
CuAssertPtrEquals(tc, victim->region, pirate->region);
CuAssertPtrNotNullMsg(tc, "successful PIRACY message", test_find_messagetype(pirate->faction->msgs, "piratesawvictim"));
CuAssertPtrNotNullMsg(tc, "successful PIRACY movement", test_find_messagetype(pirate->faction->msgs, "travel"));
test_teardown();
}
void jsonapi_deserializeJsonStringMap_test(mm_logger* logger, CuTest*tc) {
pool*p = logger->pool;
const char* requestBody = "{\"username\":\"testuser\",\"password\":\"password1\",\"savelogin\":\"true\",\"template\":\"default\", \"realm\":\"test\", \"url\":\"http%3A%2F%2Fonline.s.dev.wsj.com%2Fmyaccount\"}\r\n";
apr_hash_t* params=jsonapi_deserializeJsonStringMap(p, requestBody);
CuAssertPtrNotNullMsg(tc,"Unable to desrializeString map using jsonapi_deserializeJsonStringMap", params);
}
void jsonapi_statusMessageToJson_test(mm_logger* logger, CuTest*tc) {
pool*p = logger->pool;
const char* requestBody = "{\"username_missing\":\"testuser\",\"password_missing\":\"password1\",\"savelogin\":\"true\",\"template_missing\":\"default\", \"realm_missing\":\"test\", \"url_missing\":\"http%3A%2F%2Fonline.s.dev.wsj.com%2Fmyaccount\"}\r\n";
apr_hash_t* params=jsonapi_deserializeJsonStringMap(p, requestBody);
CuAssertPtrNotNullMsg(tc,"Unable to desrializeString map in jsonapi_statusMessageToJson_test", params);
jsonIdentity* identity=jsonapi_getJsonIdentityFromParams(p, params);
//preconditions
statusMessage* statusMsg=jsonapi_preconditionFailureStatus(p,identity);
CuAssertPtrNotNullMsg(tc,"statusMsg is null", statusMsg);
char* responseBody=jsonapi_statusMessageToJson(p, statusMsg);
CuAssertPtrNotNullMsg(tc,"statusMsg is null", responseBody);
}
void Test_iniparser_load(CuTest *tc)
{
DIR *dir;
struct dirent *curr;
struct stat curr_stat;
dictionary *dic;
char ini_path[256];
/* Dummy tests */
dic = iniparser_load("/you/shall/not/path");
CuAssertPtrEquals(tc, NULL, dic);
/* Test all the good .ini files */
dir = opendir(GOOD_INI_PATH);
CuAssertPtrNotNullMsg(tc, "Cannot open good .ini conf directory", dir);
for (curr = readdir(dir); curr != NULL; curr = readdir(dir)) {
sprintf(ini_path, "%s/%s", GOOD_INI_PATH, curr->d_name);
stat(ini_path, &curr_stat);
if (S_ISREG(curr_stat.st_mode)) {
dic = iniparser_load(ini_path);
CuAssertPtrNotNullMsg(tc, ini_path, dic);
dictionary_del(dic);
}
}
closedir(dir);
/* Test all the bad .ini files */
dir = opendir(BAD_INI_PATH);
CuAssertPtrNotNullMsg(tc, "Cannot open bad .ini conf directory", dir);
for (curr = readdir(dir); curr != NULL; curr = readdir(dir)) {
sprintf(ini_path, "%s/%s", BAD_INI_PATH, curr->d_name);
stat(ini_path, &curr_stat);
if (S_ISREG(curr_stat.st_mode)) {
dic = iniparser_load(ini_path);
CuAssertPtrEquals_Msg(tc, ini_path, NULL, dic);
dictionary_del(dic);
}
}
closedir(dir);
}
void jsonapi_getJsonIdentityFromParams_test(mm_logger* logger, CuTest*tc) {
pool*p = logger->pool;
const char* requestBody = "{\"username\":\"testuser\",\"password\":\"password1\",\"savelogin\":\"true\",\"template\":\"default\", \"realm\":\"test\", \"url\":\"http%3A%2F%2Fonline.s.dev.wsj.com%2Fmyaccount\"}\r\n";
apr_hash_t* params=jsonapi_deserializeJsonStringMap(p, requestBody);
CuAssertPtrNotNullMsg(tc,"Unable to desrializeString map using jsonapi_deserializeJsonStringMap", params);
jsonIdentity* identity=jsonapi_getJsonIdentityFromParams(p, params);
CuAssertPtrNotNullMsg(tc,"Unable to build json_identity in jsonapi_getJsonIdentityFromParams", params);
//preconditions
statusMessage* statusMsg=jsonapi_preconditionFailureStatus(p,identity);
CuAssertPtrNotNullMsg(tc,"statusMsg is null", statusMsg);
jsonapi_statusMessageAddEntry(p,statusMsg,"username","parameter","The user does not exist or password does not match.","invalid-credentials");
int count = jsonapi_getStatusErrorCount(p,statusMsg->entries);
CuAssertIntEquals(tc,1,count);
}
// Create a bunch of objects as demonstration.
void JSON_CreateStringArray_test(mm_logger* logger, CuTest*tc) {
pool*p = logger->pool;
Value *root,*fmt,*img,*thm,*fld;char *out;int i; // declare a few.
// Our "days of the week" array:
const char *strings[7]={"Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"};
root=JSON_CreateStringArray(p,strings,7);
out=JSON_Serialize(p,root);
CuAssertPtrNotNullMsg(tc,"Failed to serialize data from JSON_CreateStringArray_test", out);
}
// Create a bunch of objects as demonstration.
void JSON_CreateArray_test(mm_logger* logger, CuTest*tc) {
pool*p = logger->pool;
Value *root,*fmt,*img,*thm,*fld;char *out;int i; // declare a few.
// Our matrix:
int numbers[3][3]={{0,-1,0},{1,0,0},{0,0,1}};
root=JSON_CreateArray(p);
for (i=0;i<3;i++) JSON_AddItemToArray(p,root,JSON_CreateIntArray(p,numbers[i],3));
out=JSON_Serialize(p,root);
CuAssertPtrNotNullMsg(tc,"Failed to serialize data from JSON_CreateArray_test", out);
}
static void test_piracy_cmd_walking(CuTest * tc) {
unit *pirate, *victim;
region *r;
test_setup();
setup_pirate(&pirate, 0, 0, NULL, &victim, SWIM_INTO | SEA_REGION, "boat");
/* fset(rc, RCF_SWIM); */
r = pirate->region;
piracy_cmd(pirate);
CuAssertPtrNotNull(tc, pirate->thisorder);
CuAssertTrue(tc, pirate->region == r);
CuAssertPtrNotNullMsg(tc, "successful PIRACY message", test_find_messagetype(pirate->faction->msgs, "error144"));
test_teardown();
}
// Create a bunch of objects as demonstration.
void JSON_AddItemToObject_test(mm_logger* logger, CuTest*tc) {
pool*p = logger->pool;
Value *root,*fmt,*img,*thm,*fld;char *out;int i; // declare a few.
// Our "gallery" item:
int ids[4]={116,943,234,38793};
root=JSON_CreateObject(p);
JSON_AddItemToObject(p,root, "Image", img=JSON_CreateObject(p));
JSON_AddNumberToObject(p,img,"Width",800);
JSON_AddNumberToObject(p,img,"Height",600);
JSON_AddStringToObject(p,img,"Title","View from 15th Floor");
JSON_AddItemToObject(p,img, "Thumbnail", thm=JSON_CreateObject(p));
JSON_AddStringToObject(p,thm, "Url", "http://www.example.com/image/481989943");
JSON_AddNumberToObject(p,thm,"Height",125);
JSON_AddStringToObject(p,thm,"Width","100");
JSON_AddItemToObject(p,img,"IDs", JSON_CreateIntArray(p,ids,4));
out=JSON_Serialize(p,root);
CuAssertPtrNotNullMsg(tc,"Failed to serialize data from JSON_AddItemToObject_test", out);
}
// Create a bunch of objects as demonstration.
void JSON_CreateObject_test(mm_logger* logger, CuTest*tc) {
pool*p = logger->pool;
Value *root,*fmt,*img,*thm,*fld;char *out;int i; // declare a few.
// Here we construct some JSON standards, from the JSON site.
// Our "Video" datatype:
root=JSON_CreateObject(p);
JSON_AddItemToObject(p,root, "name", JSON_CreateString(p,"Jack (\"Bee\") Nimble"));
JSON_AddItemToObject(p,root, "format", fmt=JSON_CreateObject(p));
JSON_AddStringToObject(p,fmt,"type", "rect");
JSON_AddNumberToObject(p,fmt,"width", 1920);
JSON_AddNumberToObject(p,fmt,"height", 1080);
JSON_AddFalseToObject (p,fmt,"interlace");
JSON_AddNumberToObject(p,fmt,"frame rate", 24);
out=JSON_Serialize(p,root);
CuAssertPtrNotNullMsg(tc,"Failed to serialize data from JSON_CreateObject_test", out);
}
