int
main(int argc, char** argv)
{
// default arguments
autopilot_parms.ideal();
if (!parse_args(argc, argv)) {
return 0;
}
const char hc_path[] = "tmp/terrain";
TCHAR jp2_path[4096];
_tcscpy(jp2_path, PathName(hc_path));
_tcscat(jp2_path, _T(DIR_SEPARATOR_S) _T("terrain.jp2"));
TCHAR j2w_path[4096];
_tcscpy(j2w_path, PathName(hc_path));
_tcscat(j2w_path, _T(DIR_SEPARATOR_S) _T("terrain.j2w"));
NullOperationEnvironment operation;
RasterMap map(jp2_path, j2w_path, NULL, operation);
do {
map.SetViewCenter(map.GetMapCenter(), fixed(100000));
} while (map.IsDirty());
plan_tests(4 + NUM_SOL);
ok(test_route(28, map), "route 28", 0);
return exit_status();
}
void move_result::do_check_before()
{
LOG_AI_ACTIONS << " check_before " << *this << std::endl;
const game_info& s_info = get_subjective_info();
const game_info& info = get_info();
const unit_map& s_units = s_info.units;
const unit_map& units = info.units;
const gamemap& s_map = s_info.map;
const team& s_my_team = get_my_team(s_info);
const std::vector<team> &s_teams = s_info.teams;
const std::vector<team> &teams = info.teams;
const unit *s_unit = get_unit(s_units, s_teams);
if (!s_unit || (is_execution() && using_subjective_info() && !get_unit(units, teams, true)))
{
return;
}
if (!test_route(*s_unit, s_my_team, s_units, s_teams, s_map)) {
//impossible to test using real info without revealing anything
//prematurely, since moves are done 'in steps'
return;
}
}
int main(void) {
sd_rtnl *rtnl;
sd_rtnl_message *m;
sd_rtnl_message *r;
char *string_data;
int if_loopback;
uint16_t type;
test_match();
test_multiple();
test_route();
test_container();
assert_se(sd_rtnl_open(&rtnl, 0) >= 0);
assert_se(rtnl);
if_loopback = (int) if_nametoindex("lo");
assert_se(if_loopback > 0);
test_async(if_loopback);
test_pipe(if_loopback);
test_event_loop(if_loopback);
test_link_configure(rtnl, if_loopback);
test_get_addresses(rtnl);
assert_se(sd_rtnl_message_new_link(rtnl, &m, RTM_GETLINK, if_loopback) >= 0);
assert_se(m);
assert_se(sd_rtnl_message_get_type(m, &type) >= 0);
assert_se(type == RTM_GETLINK);
assert_se(sd_rtnl_message_read_string(m, IFLA_IFNAME, &string_data) == -EPERM);
assert_se(sd_rtnl_call(rtnl, m, 0, &r) == 1);
assert_se(sd_rtnl_message_get_type(r, &type) >= 0);
assert_se(type == RTM_NEWLINK);
assert_se((r = sd_rtnl_message_unref(r)) == NULL);
assert_se(sd_rtnl_call(rtnl, m, -1, &r) == -EPERM);
assert_se((m = sd_rtnl_message_unref(m)) == NULL);
assert_se((r = sd_rtnl_message_unref(r)) == NULL);
test_link_get(rtnl, if_loopback);
test_address_get(rtnl, if_loopback);
assert_se(sd_rtnl_flush(rtnl) >= 0);
assert_se((m = sd_rtnl_message_unref(m)) == NULL);
assert_se((r = sd_rtnl_message_unref(r)) == NULL);
assert_se((rtnl = sd_rtnl_unref(rtnl)) == NULL);
return EXIT_SUCCESS;
}
int
main(int argc, char** argv)
{
static const char map_path[] = "tmp/map.xcm";
ZZIP_DIR *dir = zzip_dir_open(map_path, nullptr);
if (dir == nullptr) {
fprintf(stderr, "Failed to open %s\n", map_path);
return EXIT_FAILURE;
}
RasterMap map;
NullOperationEnvironment operation;
if (!LoadTerrainOverview(dir, map.GetTileCache(), operation)) {
fprintf(stderr, "failed to load map\n");
zzip_dir_close(dir);
return EXIT_FAILURE;
}
map.UpdateProjection();
SharedMutex mutex;
do {
UpdateTerrainTiles(dir, map.GetTileCache(), mutex,
map.GetProjection(),
map.GetMapCenter(), 100000);
} while (map.IsDirty());
zzip_dir_close(dir);
plan_tests(4 + NUM_SOL);
ok(test_route(28, map), "route 28", 0);
return exit_status();
}
void move_result::do_check_before()
{
LOG_AI_ACTIONS << " check_before " << *this << std::endl;
const unit *u = get_unit();
if (!u) {
return;
}
if (!test_route(*u)) {
return;
}
}
int main(void) {
sd_rtnl *rtnl;
sd_rtnl_message *m;
sd_rtnl_message *r;
void *data;
int if_loopback;
uint16_t type;
unsigned int mtu = 0;
unsigned int *mtu_reply;
test_multiple();
test_route();
test_container();
assert(sd_rtnl_open(0, &rtnl) >= 0);
assert(rtnl);
if_loopback = (int) if_nametoindex("lo");
assert(if_loopback > 0);
test_async(if_loopback);
test_pipe(if_loopback);
test_event_loop(if_loopback);
test_link_configure(rtnl, if_loopback);
assert(sd_rtnl_message_link_new(RTM_GETLINK, if_loopback, 0, 0, &m) >= 0);
assert(m);
assert(sd_rtnl_message_get_type(m, &type) >= 0);
assert(type == RTM_GETLINK);
assert(sd_rtnl_message_read(m, &type, &data) == 0);
assert(sd_rtnl_call(rtnl, m, 0, &r) == 1);
assert(sd_rtnl_message_get_type(r, &type) >= 0);
assert(type == RTM_NEWLINK);
assert(sd_rtnl_message_read(m, &type, &data) == 0);
assert((r = sd_rtnl_message_unref(r)) == NULL);
assert(sd_rtnl_call(rtnl, m, -1, &r) == -EPERM);
assert((m = sd_rtnl_message_unref(m)) == NULL);
assert((r = sd_rtnl_message_unref(r)) == NULL);
assert(sd_rtnl_message_link_new(RTM_GETLINK, if_loopback, 0, 0, &m) >= 0);
assert(m);
assert(sd_rtnl_message_append(m, IFLA_MTU, &mtu) >= 0);
assert(sd_rtnl_message_read(m, &type, (void **) &mtu_reply) == 1);
assert(type == IFLA_MTU);
assert(*mtu_reply == 0);
assert(sd_rtnl_message_read(m, &type, &data) == 0);
assert(sd_rtnl_call(rtnl, m, -1, &r) == 1);
while (sd_rtnl_message_read(r, &type, &data) > 0) {
switch (type) {
// case IFLA_MTU:
// assert(*(unsigned int *) data == 65536);
// break;
// case IFLA_QDISC:
// assert(streq((char *) data, "noqueue"));
// break;
case IFLA_IFNAME:
assert(streq((char *) data, "lo"));
break;
}
}
assert(sd_rtnl_flush(rtnl) >= 0);
assert((m = sd_rtnl_message_unref(m)) == NULL);
assert((r = sd_rtnl_message_unref(r)) == NULL);
assert((rtnl = sd_rtnl_unref(rtnl)) == NULL);
return EXIT_SUCCESS;
}