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