int
main(int argc, char** argv)
{
if (!ParseArgs(argc, argv))
return 0;
plan_tests(52);
Waypoints waypoints;
GeoPoint center(Angle::Degrees(51.4), Angle::Degrees(7.85));
// AddSpiralWaypoints creates 151 waypoints from
// 0km to 150km distance in 1km steps
AddSpiralWaypoints(waypoints, center);
ok1(!waypoints.IsEmpty());
ok1(waypoints.size() == 151);
TestLookups(waypoints, center);
TestNamePrefixVisitor(waypoints);
TestRangeVisitor(waypoints, center);
TestGetNearest(waypoints, center);
TestIterator(waypoints);
ok(TestCopy(waypoints), "waypoint copy", 0);
ok(TestErase(waypoints, 3), "waypoint erase", 0);
ok(TestReplace(waypoints, 4), "waypoint replace", 0);
// test clear
waypoints.Clear();
ok1(waypoints.IsEmpty());
ok1(waypoints.size() == 0);
return exit_status();
}
unsigned test_copy(Waypoints& waypoints)
{
const Waypoint *r = waypoints.lookup_id(5);
if (!r) {
return false;
}
unsigned size_old = waypoints.size();
Waypoint wp = *r;
wp.id = waypoints.size()+1;
waypoints.append(wp);
waypoints.optimise();
unsigned size_new = waypoints.size();
return (size_new == size_old+1);
}
void
CAI302WaypointUploader::Run(OperationEnvironment &env)
{
Waypoints waypoints;
env.SetText(_("Loading Waypoints..."));
if (!reader.Parse(waypoints, env)) {
env.SetErrorMessage(_("Failed to load file."));
return;
}
if (waypoints.size() > 9999) {
env.SetErrorMessage(_("Too many waypoints."));
return;
}
env.SetText(_("Uploading Waypoints"));
env.SetProgressRange(waypoints.size() + 1);
env.SetProgressPosition(0);
if (!device.ClearPoints(env)) {
if (!env.IsCancelled())
env.SetErrorMessage(_("Failed to erase waypoints."));
return;
}
if (!device.EnableBulkMode(env)) {
if (!env.IsCancelled())
env.SetErrorMessage(_("Failed to switch baud rate."));
return;
}
unsigned id = 1;
for (auto i = waypoints.begin(), end = waypoints.end();
i != end; ++i, ++id) {
if (env.IsCancelled())
break;
env.SetProgressPosition(id);
if (!device.WriteNavpoint(id, *i, env)) {
if (!env.IsCancelled())
env.SetErrorMessage(_("Failed to write waypoint."));
break;
}
}
device.DisableBulkMode(env);
}
static unsigned
TestCopy(Waypoints& waypoints)
{
const WaypointPtr wp = waypoints.LookupId(5);
if (!wp)
return false;
unsigned size_old = waypoints.size();
Waypoint wp_copy = *wp;
wp_copy.id = waypoints.size() + 1;
waypoints.Append(std::move(wp_copy));
waypoints.Optimise();
unsigned size_new = waypoints.size();
return (size_new == size_old + 1);
}
WaypointPtr
random_waypoint(const Waypoints &waypoints)
{
static unsigned id_last = 0;
unsigned id = 0;
do {
id = rand() % waypoints.size()+1;
} while (id==id_last);
id_last = id;
return waypoints.LookupId(id);
}
int main(int argc, char** argv)
{
if (!parse_args(argc,argv)) {
return 0;
}
plan_tests(16);
Waypoints waypoints;
ok(setup_waypoints(waypoints),"waypoint setup",0);
unsigned size = waypoints.size();
ok(test_lookup(waypoints,3),"waypoint lookup",0);
ok(!test_lookup(waypoints,5000),"waypoint bad lookup",0);
ok(test_nearest(waypoints),"waypoint nearest",0);
ok(test_nearest_landable(waypoints),"waypoint nearest landable",0);
ok(test_location(waypoints,true),"waypoint location good",0);
ok(test_location(waypoints,false),"waypoint location bad",0);
ok(test_range(waypoints,100)==1,"waypoint visit range 100m",0);
ok(test_radius(waypoints,100)==1,"waypoint radius 100m",0);
ok(test_range(waypoints,500000)== waypoints.size(),"waypoint range 500000m",0);
ok(test_radius(waypoints,25000)<= test_range(waypoints,25000),"waypoint radius<range",0);
// test clear
waypoints.clear();
ok(waypoints.size()==0,"waypoint clear",0);
setup_waypoints(waypoints);
ok(size == waypoints.size(),"waypoint setup after clear",0);
ok(test_copy(waypoints),"waypoint copy",0);
ok(test_erase(waypoints,3),"waypoint erase",0);
ok(test_replace(waypoints,4),"waypoint replace",0);
return exit_status();
}
static void
FillList(WaypointList &list, const Waypoints &src,
GeoPoint location, Angle heading, const WaypointListDialogState &state)
{
if (!state.IsDefined() && src.size() >= 500)
return;
WaypointFilter filter;
state.ToFilter(filter, heading);
WaypointListBuilder builder(filter, location, list,
ordered_task, ordered_task_index);
builder.Visit(src);
if (positive(filter.distance) || !negative(filter.direction.Native()))
list.SortByDistance(location);
}
static bool
TestWaypointFile(const TCHAR* filename, Waypoints &way_points, unsigned num_wps)
{
NullOperationEnvironment operation;
if (!ok1(ReadWaypointFile(filename, way_points,
WaypointFactory(WaypointOrigin::NONE),
operation))) {
skip(2, 0, "parsing waypoint file failed");
return false;
}
way_points.Optimise();
ok1(!way_points.IsEmpty());
ok1(way_points.size() == num_wps);
return true;
}
static void
FillList(WaypointSelectInfoVector &dest, const Waypoints &src,
GeoPoint location, Angle heading, const WayPointFilterData &filter)
{
dest.clear();
if (!filter.defined() && src.size() >= 500)
return;
FilterWaypointVisitor visitor(filter, location, heading, dest);
if (filter.distance_index > 0)
src.visit_within_radius(location, Units::ToSysDistance(
DistanceFilter[filter.distance_index]), visitor);
else
src.visit_name_prefix(filter.name, visitor);
if (filter.distance_index > 0 || filter.direction_index > 0)
std::sort(dest.begin(), dest.end(), WaypointDistanceCompare);
}
static void
FillList(WaypointList &list, const Waypoints &src,
GeoPoint location, Angle heading, const WaypointFilterData &filter)
{
list.clear();
if (!filter.IsDefined() && src.size() >= 500)
return;
FilterWaypointVisitor visitor(filter, location, heading, list);
if (filter.distance_index > 0)
src.VisitWithinRange(location, Units::ToSysDistance(
distance_filter_items[filter.distance_index]), visitor);
else
src.VisitNamePrefix(filter.name, visitor);
if (filter.distance_index > 0 || filter.direction_index > 0)
std::sort(list.begin(), list.end(), WaypointDistanceCompare(location));
}
static bool
TestWaypointFile(const TCHAR* filename, Waypoints &way_points, unsigned num_wps)
{
WaypointReader f(filename, 0);
if (!ok1(!f.Error())) {
skip(3, 0, "opening waypoint file failed");
return false;
}
NullOperationEnvironment operation;
if(!ok1(f.Parse(way_points, operation))) {
skip(2, 0, "parsing waypoint file failed");
return false;
}
way_points.optimise();
ok1(!way_points.empty());
ok1(way_points.size() == num_wps);
return true;
}
static bool
TestWayPointFile(const TCHAR* filename, Waypoints &way_points, unsigned num_wps)
{
WayPointFile *f = WayPointFile::create(filename, 0);
if (!ok1(f != NULL)) {
skip(3, 0, "opening waypoint file failed");
return false;
}
if(!ok1(f->Parse(way_points, NULL))) {
delete f;
skip(2, 0, "parsing waypoint file failed");
}
delete f;
way_points.optimise();
ok1(!way_points.empty());
ok1(way_points.size() == num_wps);
return true;
}
/**
* Initialises waypoints with random and non-random waypoints
* for testing
*
* @param waypoints waypoints class to add waypoints to
*/
bool setup_waypoints(Waypoints &waypoints, const unsigned n)
{
Waypoint wp = waypoints.Create(GeoPoint(Angle::Degrees(fixed_zero),
Angle::Degrees(fixed_zero)));
wp.type = Waypoint::Type::AIRFIELD;
wp.elevation = fixed(0.25);
waypoints.Append(wp);
wp = waypoints.Create(GeoPoint(Angle::Degrees(fixed_zero),
Angle::Degrees(fixed_one)));
wp.type = Waypoint::Type::AIRFIELD;
wp.elevation = fixed(0.25);
waypoints.Append(wp);
wp = waypoints.Create(GeoPoint(Angle::Degrees(fixed_one),
Angle::Degrees(fixed_one)));
wp.name = _T("Hello");
wp.type = Waypoint::Type::AIRFIELD;
wp.elevation = fixed_half;
waypoints.Append(wp);
wp = waypoints.Create(GeoPoint(Angle::Degrees(fixed(0.8)),
Angle::Degrees(fixed(0.5))));
wp.name = _T("Unk");
wp.type = Waypoint::Type::AIRFIELD;
wp.elevation = fixed(0.25);
waypoints.Append(wp);
wp = waypoints.Create(GeoPoint(Angle::Degrees(fixed_one),
Angle::Degrees(fixed_zero)));
wp.type = Waypoint::Type::AIRFIELD;
wp.elevation = fixed(0.25);
waypoints.Append(wp);
wp = waypoints.Create(GeoPoint(Angle::Degrees(fixed_zero),
Angle::Degrees(fixed(0.23))));
wp.type = Waypoint::Type::AIRFIELD;
wp.elevation = fixed(0.25);
waypoints.Append(wp);
for (unsigned i=0; i<(unsigned)std::max((int)n-6,0); i++) {
int x = rand()%1200-100;
int y = rand()%1200-100;
double z = rand()% std::max(terrain_height,1);
wp = waypoints.Create(GeoPoint(Angle::Degrees(fixed(x/1000.0)),
Angle::Degrees(fixed(y/1000.0))));
wp.type = Waypoint::Type::NORMAL;
wp.elevation = fixed(z);
waypoints.Append(wp);
}
waypoints.Optimise();
if (verbose) {
std::ofstream fin("results/res-wp-in.txt");
for (unsigned i=1; i<=waypoints.size(); i++) {
const Waypoint *wp = waypoints.LookupId(i);
if (wp != NULL)
fin << *wp;
}
}
return true;
}
/**
* Initialises waypoints with random and non-random waypoints
* for testing
*
* @param waypoints waypoints class to add waypoints to
*/
bool setup_waypoints(Waypoints &waypoints, const unsigned n)
{
Waypoint wp = waypoints.create(GeoPoint(Angle::degrees(fixed_zero),
Angle::degrees(fixed_zero)));
wp.Flags.Airport = true;
wp.Altitude = fixed(0.25);
waypoints.append(wp);
wp = waypoints.create(GeoPoint(Angle::degrees(fixed_zero),
Angle::degrees(fixed_one)));
wp.Flags.Airport = true;
wp.Altitude = fixed(0.25);
waypoints.append(wp);
wp = waypoints.create(GeoPoint(Angle::degrees(fixed_one),
Angle::degrees(fixed_one)));
wp.Name = _T("Hello");
wp.Flags.Airport = true;
wp.Altitude = fixed_half;
waypoints.append(wp);
wp = waypoints.create(GeoPoint(Angle::degrees(fixed(0.8)),
Angle::degrees(fixed(0.5))));
wp.Name = _T("Unk");
wp.Flags.Airport = true;
wp.Altitude = fixed(0.25);
waypoints.append(wp);
wp = waypoints.create(GeoPoint(Angle::degrees(fixed_one),
Angle::degrees(fixed_zero)));
wp.Flags.Airport = true;
wp.Altitude = fixed(0.25);
waypoints.append(wp);
wp = waypoints.create(GeoPoint(Angle::degrees(fixed_zero),
Angle::degrees(fixed(0.23))));
wp.Flags.Airport = true;
wp.Altitude = fixed(0.25);
waypoints.append(wp);
for (unsigned i=0; i<(unsigned)std::max((int)n-6,0); i++) {
int x = rand()%1200-100;
int y = rand()%1200-100;
double z = rand()% std::max(terrain_height,1);
wp = waypoints.create(GeoPoint(Angle::degrees(fixed(x/1000.0)),
Angle::degrees(fixed(y/1000.0))));
wp.Flags.Airport = false;
wp.Altitude = fixed(z);
waypoints.append(wp);
}
waypoints.optimise();
if (verbose) {
std::ofstream fin("results/res-wp-in.txt");
for (unsigned i=1; i<=waypoints.size(); i++) {
Waypoints::WaypointTree::const_iterator it = waypoints.find_id(i);
if (it != waypoints.end()) {
#ifdef DO_PRINT
fin << it->get_waypoint();
#endif
}
}
}
return true;
}
/**
* Initialises waypoints with random and non-random waypoints
* for testing
*
* @param waypoints waypoints class to add waypoints to
*/
bool SetupWaypoints(Waypoints &waypoints, const unsigned n)
{
Waypoint wp = waypoints.Create(GeoPoint(Angle::Zero(),
Angle::Zero()));
wp.type = Waypoint::Type::AIRFIELD;
wp.elevation = fixed(0.25);
waypoints.Append(std::move(wp));
wp = waypoints.Create(GeoPoint(Angle::Zero(),
Angle::Degrees(1)));
wp.type = Waypoint::Type::AIRFIELD;
wp.elevation = fixed(0.25);
waypoints.Append(std::move(wp));
wp = waypoints.Create(GeoPoint(Angle::Degrees(1),
Angle::Degrees(1)));
wp.name = _T("Hello");
wp.type = Waypoint::Type::AIRFIELD;
wp.elevation = fixed(0.5);
waypoints.Append(std::move(wp));
wp = waypoints.Create(GeoPoint(Angle::Degrees(0.8),
Angle::Degrees(0.5)));
wp.name = _T("Unk");
wp.type = Waypoint::Type::AIRFIELD;
wp.elevation = fixed(0.25);
waypoints.Append(std::move(wp));
wp = waypoints.Create(GeoPoint(Angle::Degrees(1),
Angle::Zero()));
wp.type = Waypoint::Type::AIRFIELD;
wp.elevation = fixed(0.25);
waypoints.Append(std::move(wp));
wp = waypoints.Create(GeoPoint(Angle::Zero(),
Angle::Degrees(0.23)));
wp.type = Waypoint::Type::AIRFIELD;
wp.elevation = fixed(0.25);
waypoints.Append(std::move(wp));
for (unsigned i=0; i<(unsigned)std::max((int)n-6,0); i++) {
int x = rand()%1200-100;
int y = rand()%1200-100;
double z = rand()% std::max(terrain_height,1);
wp = waypoints.Create(GeoPoint(Angle::Degrees(x / 1000.0),
Angle::Degrees(y / 1000.0)));
wp.type = Waypoint::Type::NORMAL;
wp.elevation = fixed(z);
waypoints.Append(std::move(wp));
}
waypoints.Optimise();
if (verbose) {
Directory::Create(Path(_T("output/results")));
std::ofstream fin("output/results/res-wp-in.txt");
for (unsigned i=1; i<=waypoints.size(); i++) {
const Waypoint *wpt = waypoints.LookupId(i);
if (wpt != NULL)
fin << *wpt;
}
}
return true;
}
