public void TestTask4FindRoutes()
{
var cities = new Cities();
cities.ReadCities(CitiesTestFile);
var expectedLinks = new List<Link>();
expectedLinks.Add(new Link(new City("Zürich", "Switzerland", 7000, 1,2),
new City("Aarau", "Switzerland", 7000, 1,2), 0));
expectedLinks.Add(new Link(new City("Aarau", "Switzerland", 7000, 1, 2),
new City("Liestal", "Switzerland", 7000, 1, 2), 0));
expectedLinks.Add(new Link(new City("Liestal", "Switzerland", 7000, 1, 2),
new City("Basel", "Switzerland", 7000, 1, 2), 0));
var routes = new RoutesDijkstra(cities);
routes.ReadRoutes(LinksTestFile);
Assert.AreEqual(11, cities.Count);
// test available cities
var links = routes.FindShortestRouteBetween("Zürich", "Basel", TransportModes.Rail);
Assert.IsNotNull(links);
Assert.AreEqual(expectedLinks.Count, links.Count);
for (var i = 0; i < links.Count; i++)
{
Assert.IsTrue(
(expectedLinks[i].FromCity.Name == links[i].FromCity.Name &&
expectedLinks[i].ToCity.Name == links[i].ToCity.Name) ||
(expectedLinks[i].FromCity.Name == links[i].ToCity.Name &&
expectedLinks[i].ToCity.Name == links[i].FromCity.Name));
}
links = routes.FindShortestRouteBetween("doesNotExist", "either", TransportModes.Rail);
Assert.IsNull(links);
}
public static IRoutes Create(Cities cities)
{
//Assembly[] temp = AppDomain.CurrentDomain.GetAssemblies();
//foreach (Assembly a in AppDomain.CurrentDomain.GetAssemblies())
//{
// foreach (Type t in a.GetTypes())
// {
// if (t != null)
// {
// //return CallConstructor(t, cities);
// }
// //throw new NotSupportedException();
// }
//}
//return null;
String path = Settings.Default.RouteAlgorithm;
Type type = Assembly.GetExecutingAssembly().GetType(path);
if (type.GetInterface("IRoutes") != null)
{
Object[] param = { cities };
return (IRoutes)Activator.CreateInstance(type, param);
}
throw new NotSupportedException();
}
public void TestRoutesReadLinks()
{
var cities = new Cities();
cities.ReadCities(CitiesTestFile);
Assert.AreEqual(7, new Routes(cities).ReadRoutes(LinksTestFile));
}
public async Task TestFindShortestRouteBetweenAsync()
{
var cities = new Cities();
cities.ReadCities(CitiesTestFile);
var routes = new RoutesDijkstra(cities);
routes.ReadRoutes(LinksTestFile);
// do synchronous execution
linksExpected =
routes.FindShortestRouteBetween("Basel", "Zürich", TransportModes.Rail);
// do asynchronous execution
linksActual =
await routes.FindShortestRouteBetweenAsync("Basel", "Zürich", TransportModes.Rail);
// not test the results
Assert.IsNotNull(linksActual);
Assert.AreEqual(linksExpected.Count, linksActual.Count);
for (int i = 0; i < linksActual.Count; i++)
{
Assert.AreEqual(linksExpected[i].FromCity, linksActual[i].FromCity);
Assert.AreEqual(linksExpected[i].ToCity, linksActual[i].ToCity);
}
}
public async Task TestFindShortestRouteBetweenAsyncProgress()
{
var cities = new Cities();
cities.ReadCities(CitiesTestFile);
var routes = new Routes(cities);
routes.ReadRoutes(LinksTestFile);
// do synchronous execution
var linksExpected = routes.FindShortestRouteBetween("Basel", "Zürich", TransportMode.Rail);
// do asynchronous execution
var messages = new List<string>();
var progress = new Progress<string>(msg => messages.Add(msg));
var linksActual = await routes.FindShortestRouteBetweenAsync("Basel", "Zürich", TransportMode.Rail, progress);
// let pending tasks execute
await Task.Yield();
// ensure that at least 5 progress calls are made
Assert.IsTrue(messages.Distinct().Count()>=5, "Less than 5 distinct progress messages");
// ensure that all progress messages end with " done"
Assert.IsTrue(messages.All(m => m.EndsWith(" done")),
string.Format("Progress message \"{0}\" does not end with \" done\"",
messages.FirstOrDefault(m => !m.EndsWith(" done"))));
}
static void Main(string[] args)
{
var assembly = Assembly.GetExecutingAssembly().FullName;
var version = assembly.Split(',')[1].Split('=')[1];
Console.Out.WriteLine("Welcome to RoutePlanner (Version {0})", arg0: version);
var wayPoint = new WayPoint("Windisch", 47.479319847061966, 8.212966918945312);
Console.WriteLine("{0}: {1}/{2}", wayPoint.Name, wayPoint.Latitude, wayPoint.Longitude);
Console.Out.WriteLine("--------------");
Console.Out.WriteLine(wayPoint);
RoutesFactory.Create(new Cities());
string excelFileName = Directory.GetCurrentDirectory() + @"\ExportTest.xlsx";
ExcelExchange excel = new ExcelExchange();
Console.WriteLine("Export Path is: {0}", excelFileName);
City bern = new City("Bern", "Switzerland", 5000, 46.95, 7.44);
City zuerich = new City("Zürich", "Switzerland", 100000, 32.876174, 13.187507);
City aarau = new City("Aarau", "Switzerland", 10000, 35.876174, 12.187507);
Link link1 = new Link(bern, aarau, 15, TransportModes.Ship);
Link link2 = new Link(aarau, zuerich, 20, TransportModes.Ship);
List<Link> links = new List<Link>();
links.Add(link1);
links.Add(link2);
excel.WriteToFile(excelFileName, bern, zuerich, links);
/* Test Logging */
var cities = new Cities();
Routes routes = new RoutesFloydWarshall(cities);
//cities.ReadCities("adsf");
//routes.ReadRoutes("adsf");
}
public void TestTask1_FindRoutes()
{
Cities cities = new Cities();
cities.ReadCities(@"citiesTestDataLab4.txt");
List<Link> expectedLinks = new List<Link>();
expectedLinks.Add(new Link(new City("Zürich", "Switzerland", 7000, 1, 2),
new City("Aarau", "Switzerland", 7000, 1, 2), 0));
expectedLinks.Add(new Link(new City("Aarau", "Switzerland", 7000, 1, 2),
new City("Liestal", "Switzerland", 7000, 1, 2), 0));
expectedLinks.Add(new Link(new City("Liestal", "Switzerland", 7000, 1, 2),
new City("Basel", "Switzerland", 7000, 1, 2), 0));
Routes routes = new RoutesFloydWarshall(cities);
int count = routes.ReadRoutes(@"linksTestDataLab4.txt");
Assert.AreEqual(11, cities.Count);
// test available cities
routes.ExecuteParallel = true;
List<Link> links = routes.FindShortestRouteBetween("Zürich", "Basel", TransportModes.Rail);
Assert.IsNotNull(links);
Assert.AreEqual(expectedLinks.Count, links.Count);
for (int i = 0; i < links.Count; i++)
{
Assert.AreEqual(expectedLinks[i].FromCity.Name, links[i].FromCity.Name);
Assert.AreEqual(expectedLinks[i].ToCity.Name, links[i].ToCity.Name);
}
links = routes.FindShortestRouteBetween("doesNotExist", "either", TransportModes.Rail);
Assert.IsNull(links);
}
public void TestLoadAndRunDynamic()
{
var cities = new Cities();
cities.ReadCities(CitiesTestFile);
IRoutes routes = RoutesFactory.Create(cities);
routes.ReadRoutes(LinksTestFile);
Assert.AreEqual(11, cities.Count);
// test available cities
List<Link> links = routes.FindShortestRouteBetween("Zürich", "Basel", TransportModes.Rail);
var expectedLinks = new List<Link>();
expectedLinks.Add(new Link(new City("Zürich", "Switzerland", 7000, 1, 2),
new City("Aarau", "Switzerland", 7000, 1, 2), 0));
expectedLinks.Add(new Link(new City("Aarau", "Switzerland", 7000, 1, 2),
new City("Liestal", "Switzerland", 7000, 1, 2), 0));
expectedLinks.Add(new Link(new City("Liestal", "Switzerland", 7000, 1, 2),
new City("Basel", "Switzerland", 7000, 1, 2), 0));
Assert.IsNotNull(links);
Assert.AreEqual(expectedLinks.Count, links.Count);
for (int i = 0; i < links.Count; i++)
{
Assert.AreEqual(expectedLinks[i].FromCity.Name, links[i].FromCity.Name);
Assert.AreEqual(expectedLinks[i].ToCity.Name, links[i].ToCity.Name);
}
links = routes.FindShortestRouteBetween("doesNotExist", "either", TransportModes.Rail);
Assert.IsNull(links);
}
public void TestTask2FindRoutes()
{
Cities cities = new Cities();
cities.ReadCities(@"citiesTestDataLab11.txt");
Assert.AreEqual(6372, cities.Count);
List<Link> expectedLinks = new List<Link>();
Routes routes = new RoutesFloydWarshall(cities);
int count = routes.ReadRoutes(@"linksTestDataLab11.txt");
Assert.AreEqual(112, count);
// test available cities
routes.ExecuteParallel = true;
List<Link> links = routes.FindShortestRouteBetween("Lyon", "Berlin", TransportModes.Rail);
Assert.AreEqual(13, links.Count);
routes.ExecuteParallel = false;
List<Link> links2 = routes.FindShortestRouteBetween("Lyon", "Berlin", TransportModes.Rail);
Assert.IsNotNull(links);
Assert.AreEqual(13, links.Count);
Assert.IsNotNull(links2);
Assert.AreEqual(13, links2.Count);
}
static void Main(string[] args)
{
Console.WriteLine("Welcome to RoutePlanner (Version {0})", Assembly.GetExecutingAssembly().GetName().Version);
var bern = new WayPoint("Bern",46.951081, 7.438637);
var tripolis = new WayPoint("Tripolis",32.883333333333, 13.166666666667);
var wayPoint = new WayPoint("Windisch", 47.479319847061966, 8.212966918945312);
var City = new City("Bern", "Schweiz", 75000, 47.479319847061966, 8.212966918945312);
Console.WriteLine(wayPoint);
Console.WriteLine("Distance Bern to Tripolis: "+bern.Distance(tripolis)+"km");
Cities cities = new Cities();
cities.ReadCities(@"..\..\..\RoutePlannerTest\data\citiesTestDataLab2.txt");
RoutesDijkstra routes = new RoutesDijkstra(cities);
routes.ReadRoutes(@"..\..\..\RoutePlannerTest\data\linksTestDataLab3.txt");
Cities citiesFail = new Cities();
citiesFail.ReadCities(@"irgendeinfile.txt");
Console.WriteLine("Starting parallel test......");
Cities citiesP = new Cities();
cities.ReadCities(@"..\..\..\RoutePlannerTest\data\citiesTestDataLab10.txt");
int warmUpRounds = 100;
int measureRounds = 20;
Routes routesP = new RoutesFloydWarshall(cities);
int count = routesP.ReadRoutes(@"..\..\..\RoutePlannerTest\data\linksTestDataLab10.txt");
Console.WriteLine("doing warmup");
for (int i = 0; i < warmUpRounds; i++)
{
List<Link> links = routesP.FindShortestRouteBetween("Lyon", "Berlin", TransportModes.Rail);
}
Stopwatch watch = new Stopwatch();
watch.Start();
Console.WriteLine("sequential mode: ");
// test short routes in parallel mode
routesP.ExecuteParallel = false;
for (int i = 0; i < measureRounds; i++)
{
List<Link> links = routesP.FindShortestRouteBetween("Lyon", "Berlin", TransportModes.Rail);
}
watch.Stop();
Console.WriteLine("Elapsed Time: " + watch.ElapsedMilliseconds + "ms");
watch.Reset();
watch.Start();
Console.WriteLine("parallel mode: ");
// test short routes in parallel mode
routesP.ExecuteParallel = true;
for (int i = 0; i < measureRounds; i++)
{
List<Link> links2 = routesP.FindShortestRouteBetween("Lyon", "Berlin", TransportModes.Rail);
}
watch.Stop();
Console.WriteLine("Elapsed Time: " + watch.ElapsedMilliseconds + "ms");
Console.WriteLine("Press any key to quit");
Console.ReadKey();
}
public static IRoutes Create(Cities cities, String algo)
{
Console.WriteLine(algo);
Assembly asm = Assembly.LoadFrom("RoutePlannerLib.dll");
Type t = GetTypeFromAssembly(algo ,asm);
if (t == null) return null;
return Activator.CreateInstance(t, cities) as IRoutes;
}
public static IRoutes Create(Cities cities, string algorithmClassName)
{
Type type = Assembly.GetExecutingAssembly().GetType(algorithmClassName);
if (type.GetInterface("IRoutes") != null)
{
Object[] param = { cities };
return (IRoutes)Activator.CreateInstance(type, param);
}
throw new NotSupportedException();
}
public void TestRoutesReadLinks()
{
var cities = new Cities();
cities.ReadCities(CitiesTestFile);
var routes = new RoutesDijkstra(cities);
var count = routes.ReadRoutes(LinksTestFile);
Assert.AreEqual(7, count);
}
public void TestLoadAndRunDynamicSecondImpl()
{
var defaultSettings = Assembly.GetAssembly(typeof(IRoutes))
.GetType("Fhnw.Ecnf.RoutePlanner.RoutePlannerLib.Properties.Settings")
.GetProperty("Default")
.GetValue(null);
defaultSettings.GetType().GetMethod("Reset").Invoke(defaultSettings, new object[] { });
//defaultSettings.GetType().GetMethod("Reload").Invoke(defaultSettings, new object[] { });
var cities = new Cities();
cities.ReadCities(CitiesTestFile);
IRoutes routes = RoutesFactory.Create(cities, "Fhnw.Ecnf.RoutePlanner.RoutePlannerTest.TestRoutesValidConstructor");
Assert.AreEqual(42, routes.ReadRoutes("nonsense"));
IRoutes routes2 = RoutesFactory.Create(cities);
Assert.AreNotEqual(routes.GetType(), routes2.GetType());
try
{
try
{
defaultSettings.GetType().GetProperty("RouteAlgorithm").SetValue(defaultSettings, "Fhnw.Ecnf.RoutePlanner.RoutePlannerTest.TestRoutesValidConstructor");
}
catch
{
Assert.Fail("Make sure there is a String-property called \"RouteAlgorithm\" with User-scope.");
}
IRoutes routes3 = RoutesFactory.Create(cities);
Assert.AreEqual(routes.GetType(), routes3.GetType());
}
finally
{
defaultSettings.GetType().GetMethod("Reset").Invoke(defaultSettings, new object[] { });
}
try
{
RoutesFactory.Create(cities, "Fhnw.Ecnf.RoutePlanner.RoutePlannerTest.Lab5Test.TestRoutesInvalidConstructor");
Assert.Fail("Should throw a NotSupportedException, because it doesn't have the right constructor");
}
catch(NotSupportedException)
{
}
try
{
RoutesFactory.Create(cities, "Fhnw.Ecnf.RoutePlanner.RoutePlannerTest.Lab5Test.TestRoutesNoInterface");
Assert.Fail("Should throw a NotSupportedException, because IRoutes is not implemented");
}
catch (NotSupportedException)
{
}
}
public void TestLoadDynamicInValid()
{
var cities = new Cities();
// pass a name of a class that does not exist
IRoutes routes = RoutesFactory.Create(cities, "Class.Does.Not.Exits");
Assert.IsNull(routes);
// pass a name of a class that exists, but does not implement the inetrface
routes = RoutesFactory.Create(cities, "Cities");
Assert.IsNull(routes);
}
public void TestLoadDynamicValid()
{
var cities = new Cities();
// just test for correct dynamic creation of valid routed class from config
IRoutes routes = RoutesFactory.Create(cities);
Assert.IsInstanceOfType(routes, typeof(IRoutes));
// now test for correct dynamic creation of valid routed class passed as string
routes = RoutesFactory.Create(cities, "Fhnw.Ecnf.RoutePlanner.RoutePlannerLib.RoutesDijkstra");
Assert.IsInstanceOfType(routes, typeof(IRoutes));
}
public void TestFindCitiesByTransportMode()
{
Cities cities = new Cities();
cities.ReadCities(@"citiesTestDataLab3.txt");
var routes = new Routes(cities);
routes.ReadRoutes(@"linksTestDataLab3.txt");
City[] citiesByMode = routes.FindCities(TransportMode.Rail);
Assert.AreEqual(11, citiesByMode.Length);
City[] emptyCitiesByMode = routes.FindCities(TransportMode.Bus);
Assert.AreEqual(0, emptyCitiesByMode.Length);
}
public static IRoutes Create(Cities cities, string algortihmClassName)
{
object o = null;
foreach (Assembly asm in AppDomain.CurrentDomain.GetAssemblies()) {
o = asm.CreateInstance(algortihmClassName, false, BindingFlags.CreateInstance, null, new object[] { cities }, CultureInfo.CurrentCulture, null);
if(o != null && o is IRoutes)
{
return (IRoutes)o;
}
}
throw new NotSupportedException("No class found with name " + algortihmClassName);
}
public void TestDynamicWorld()
{
Cities cities = new Cities();
cities.ReadCities("citiesTestDataLab2.txt");
dynamic world = new World(cities);
dynamic karachi = world.Karachi();
Assert.AreEqual("Karachi", karachi.Name);
string notFound = world.Entenhausen();
Assert.AreEqual("The city <Entenhausen> does not exist!", notFound);
}
static void Main(string[] args)
{
Console.WriteLine("Welcome to RoutePlanner (Version {0})", Assembly.GetExecutingAssembly().GetName().Version);
var wayPointTest = new WayPoint("Windisch", 47.479319847061966, 8.212966918945312);
var wayPointBern = new WayPoint("Bern", 46.947346, 7.447742);
var wayPointTripolis = new WayPoint("Tripolis", 32.885460, 13.190739);
Console.WriteLine(wayPointTest.ToString());
Console.WriteLine("Distance between Bern and Tripoli: " + wayPointBern.Distance(wayPointTripolis) + " km");
var citiesTest = new Cities();
//citiesTest.ReadCities(@"citiesTestDataLab2.txt");
citiesTest.ReadCities("citiesTestDataLab2.txt");
//Console.WriteLine("{0}: {1}/{2}", wayPoint.Name, wayPoint.Latitude, wayPoint.Longitude);
Console.ReadKey();
}
public void TestTask1FindCityInCities()
{
var expectedCity = "Zürich";
Cities cities = new Cities();
cities.ReadCities(CitiesTestFile);
var notFound = cities.FindCity("noCity");
Assert.IsNull(notFound);
var found = cities.FindCity(expectedCity);
Assert.AreEqual(expectedCity, found.Name);
// should work case insensitive
found = cities.FindCity("züRicH");
Assert.AreEqual(expectedCity, found.Name);
}
static public IRoutes Create(Cities cities, string algorithmClassName)
{
IRoutes routeFactory = null;
Assembly assem = Assembly.GetExecutingAssembly();
Type t = assem.GetType(algorithmClassName);
if(t == null)
{
return null;
}
routeFactory = (IRoutes)Activator.CreateInstance(t, cities);
return routeFactory as IRoutes;
}
public void TestRouteParallelSpeed()
{
var cities = new Cities();
cities.ReadCities("citiesTestDataLab12.txt");
var routes = new Routes(cities);
routes.ReadRoutes("linksTestDataLab12.txt");
//warmup
routes.FindAllShortestRoutesParallel();
//execute and measure time
var timeA = DateTime.Now;
List<List<Link>> allRoutesSerial = routes.FindAllShortestRoutes();
var timeB = DateTime.Now;
List<List<Link>> allRoutesParallel = routes.FindAllShortestRoutesParallel();
var timeC = DateTime.Now;
var oldAffinity = Process.GetCurrentProcess().ProcessorAffinity;
Process.GetCurrentProcess().ProcessorAffinity = (IntPtr)1;
routes.FindAllShortestRoutesParallel();
Process.GetCurrentProcess().ProcessorAffinity = oldAffinity;
var timeD = DateTime.Now;
var factor = (timeC - timeB).TotalSeconds / (timeB - timeA).TotalSeconds;
var slowdown = (timeD - timeC).TotalSeconds / (timeB - timeA).TotalSeconds;
Trace.WriteLine($"Factor: {factor:F2}, Slowdown: {slowdown:F2}");
//parallel execution on a single core shouldn't be much slower
Assert.IsTrue(slowdown < 1.1);
switch (Environment.ProcessorCount)
{
case 1:
break;
case 2:
//expect at least 25% reduction with 2 cores
Assert.IsTrue(factor < 0.75);
break;
case 3:
//expect at least 35% reduction with 3 cores
Assert.IsTrue(factor < 0.65);
break;
default:
//expect at least 45% reduction with 4+ cores
Assert.IsTrue(factor < 0.55);
break;
}
}
public void TestTask2FiredEvents()
{
var cities = new Cities();
cities.ReadCities(CitiesTestFile);
var routes = new RoutesDijkstra(cities);
// test available cities
routes.RouteRequestEvent += TestForCorrectEventArgsWithFoundCities;
routes.FindShortestRouteBetween("Bern", "Zürich", TransportModes.Rail);
// test not existing cities
routes.RouteRequestEvent -= TestForCorrectEventArgsWithFoundCities;
routes.RouteRequestEvent += TestForCorrectEventArgsWithNotFoundCities;
routes.FindShortestRouteBetween("doesNotExist", "either", TransportModes.Rail);
}
public void TestFindCitiesByTransportMode()
{
Cities cities = new Cities();
cities.ReadCities(@"citiesTestDataLab3.txt");
var routes = new RoutesDijkstra(cities);
routes.ReadRoutes(@"linksTestDataLab3.txt");
City[] citiesByMode = routes.FindCities(TransportModes.Rail);
Assert.AreEqual(11, citiesByMode.Count());
// there must be no cities
City[] emptyCitiesByMode = routes.FindCities(TransportModes.Bus);
Assert.AreEqual(0, emptyCitiesByMode.Count());
}
static public IRoutes Create(Cities cities, string algorithmClassName)
{
Assembly assembly = Assembly.GetExecutingAssembly();
Module module = assembly.GetModules()[0];
Type type = module.GetType(algorithmClassName);
if (type == null)
{
return null;
}
ConstructorInfo ci = type.GetConstructor(new Type[] { typeof(Cities) });
if(ci == null) {
return null;
}
object factory = ci.Invoke(new object[]{cities});
return factory as IRoutes;
}
static void Main(string[] args)
{
//Lab1 Aufgabe 1
Console.WriteLine("Welcome to RoutePlanner (Version " + Assembly.GetExecutingAssembly().GetName().Version + ")");
//Lab1 Aufgabe 2d
var wayPoint = new WayPoint("Windisch", 47.479319847061966, 8.212966918945312);
Console.WriteLine("{0}: {1}/{2}", wayPoint.Name, wayPoint.Latitude, wayPoint.Longitude);
Console.WriteLine(wayPoint);
//Lab2 Aufgabe 1a
Console.WriteLine(wayPoint);
var wayPoint1 = new WayPoint("", 47.479319847061966, 8.212966918945312);
var wayPoint2 = new WayPoint(null, 47.479319847061966, 8.212966918945312);
Console.WriteLine(wayPoint1);
Console.WriteLine(wayPoint2);
//Lab2 Aufgabe 1b
var bern = new WayPoint("Bern", 46.948342, 7.442935);
var tripolis = new WayPoint("Tripolis", 32.808858, 13.098922);
Console.WriteLine(bern.Distance(tripolis));
Console.WriteLine(tripolis.Distance(bern));
//Lab2 Aufgabe 2b - FunktionsTest - Funktioniert
Cities c = new Cities();
c.ReadCities("citiesTestDataLab2.txt");
Console.WriteLine("Test: {0}", c[5].Location.Latitude);
var target = new WayPoint("Windisch", 0.564, 0.646);
Console.WriteLine(target.ToString() + " vs. " + "WayPoint: Windisch 0.56/0.65");
//Lab3 Aufgabe 2
var reqWatch = new RouteRequestWatcher();
var routeCities = new Cities();
routeCities.ReadCities("citiesTestDataLab2.txt");
var routes = new Routes(routeCities);
routes.RouteRequested += reqWatch.LogRouteRequests;
routes.FindShortestRouteBetween("mumbai", "buenos aires", TransportMode.Rail);
routes.FindShortestRouteBetween("dilli", "mumbai", TransportMode.Rail);
routes.FindShortestRouteBetween("mumbai", "buenos aires", TransportMode.Rail);
Console.ReadLine();
}
public void TestFindNeighbours()
{
var cities = new Cities();
cities.ReadCities(CitiesTestFile);
var loc = cities[0].Location;
var neighbors = cities.FindNeighbours(loc, 2000);
Assert.AreEqual(4, neighbors.Count);
//verifies if the correct cities were found
Assert.IsNotNull(neighbors.First(c=>c.Name == "Mumbai"));
Assert.IsNotNull(neighbors.First(c => c.Name == "Karachi"));
Assert.IsNotNull(neighbors.First(c => c.Name == "Dhaka"));
Assert.IsNotNull(neighbors.First(c => c.Name == "Dilli"));
}
public static IRoutes Create(Cities cities, string algorithmClassName)
{
IRoutes routeFactory = null;
var assemblies = AppDomain.CurrentDomain.GetAssemblies();
Type t = null;
foreach (var assembly in assemblies)
{
t = assembly.GetType(algorithmClassName);
if (t != null)
{
routeFactory = (IRoutes)Activator.CreateInstance(t, cities);
return routeFactory as IRoutes;
}
}
throw new NotSupportedException(algorithmClassName + " is not supported.");
}
public void TestRequestWatcher()
{
var reqWatch = new RouteRequestWatcher();
var cities = new Cities();
cities.ReadCities(CitiesTestFile);
var routes = new RoutesDijkstra(cities);
routes.RouteRequestEvent += reqWatch.LogRouteRequests;
routes.FindShortestRouteBetween("Bern", "Zürich", TransportModes.Rail);
routes.FindShortestRouteBetween("Bern", "Zürich", TransportModes.Rail);
routes.FindShortestRouteBetween("Basel", "Bern", TransportModes.Rail);
Assert.AreEqual(reqWatch.GetCityRequests("Zürich"), 2);
Assert.AreEqual(reqWatch.GetCityRequests("Bern"), 1);
Assert.AreEqual(reqWatch.GetCityRequests("Basel"), 0);
}
static public IRoutes Create(Cities cities, string algorithmClassName)
{
IRoutes algorithm = null;
Assembly asm = Assembly.GetExecutingAssembly();
try
{
Type type = asm.GetType(algorithmClassName);
algorithm = (IRoutes)Activator.CreateInstance(type, cities);
}
catch (Exception e)
{
// added cw after feedback of milestone 3
Console.WriteLine(e.ToString());
}
return(algorithm);
}
static public IRoutes Create(Cities cities, string algorithmClassName)
{
Assembly assembly = Assembly.GetExecutingAssembly();
Module module = assembly.GetModules()[0];
Type type = module.GetType(algorithmClassName);
if (type == null)
{
return(null);
}
ConstructorInfo ci = type.GetConstructor(new Type[] { typeof(Cities) });
if (ci == null)
{
return(null);
}
object factory = ci.Invoke(new object[] { cities });
return(factory as IRoutes);
}
public static IRoutes Create(Cities cities, string algorithmClassName)
{
if (Type.GetType(algorithmClassName) != null)
{
try
{
Assembly a = Assembly.GetExecutingAssembly();
var tOfAssembly = a.GetType(algorithmClassName);
if (tOfAssembly != null)
{
Type type = Type.GetType(algorithmClassName);
ConstructorInfo ctor = type.GetConstructor(new[] { typeof(Cities) });
object instance = ctor.Invoke(new object[] { cities });
return((IRoutes)instance);
}
}
catch (Exception) {}
}
return(null);
}
public override List <Link> FindShortestRouteBetween(string fromCity, string toCity, TransportModes mode,
IProgress <string> reportProgress)
{
NotifyObservers(this, new RouteRequestEventArgs(fromCity, toCity, mode));
ProgressReport(reportProgress, "<notified observers> done");
var citiesBetween = Cities.FindCitiesBetween(Cities.FindCity(fromCity), Cities.FindCity(toCity));
ProgressReport(reportProgress, "<found cities between> done");
if (citiesBetween == null || citiesBetween.Count < 1 || Links == null || Links.Count < 1)
{
return(null);
}
var source = citiesBetween[0];
var target = citiesBetween[citiesBetween.Count - 1];
Dictionary <City, double> dist;
Dictionary <City, City> previous;
var q = FillListOfNodes(citiesBetween, out dist, out previous);
ProgressReport(reportProgress, "<created nodes> done");
dist[source] = 0.0;
// the actual algorithm
previous = SearchShortestPath(mode, q, dist, previous);
ProgressReport(reportProgress, "<search shortest path> done");
// create a list with all cities on the route
var citiesOnRoute = GetCitiesOnRoute(source, target, previous);
ProgressReport(reportProgress, "<got cities on route> done");
// prepare final list if links
return(FindPath(citiesOnRoute, mode));
}
/// <summary>
/// Initializes the Routes with the cities.
/// </summary>
/// <param name="cities"></param>
public Routes(Cities _cities)
{
cities = _cities;
}
/// <summary>
/// Initializes the Links with the cities.
/// </summary>
/// <param name="cities"></param>
public Links(Cities cities)
{
this.cities = cities;
}
public static IRoutes Create(Cities cities)
{
return(Create(cities, Settings.Default.RouteAlgorithm));
}
static public IRoutes Create(Cities cities)
{
var routeAlgorithm = Properties.Settings.Default.RouteAlgorithm;
return(Create(cities, routeAlgorithm));
}
public RoutesDijkstra(Cities cities)
: base(cities)
{
}
static public IRoutes Create(Cities cities)
{
var algorithmName = Fhnw.Ecnf.RoutePlanner.RoutePlannerLib.Properties.Settings.Default.RouteAlgorithm;
return(Create(cities, algorithmName));
}
/// <summary>
/// Initializes the Routes with the cities.
/// </summary>
/// <param name="cities"></param>
protected Routes(Cities cities)
{
this.Cities = cities;
}
public override List <Link> FindShortestRouteBetween(string fromCity, string toCity,
TransportModes mode, IProgress <string> reportProgress)
{
List <City> citiesBetween = Cities.FindCitiesBetween(Cities.FindCity(fromCity), Cities.FindCity(toCity));
if (citiesBetween == null || citiesBetween.Count < 1)
{
return(null);
}
List <Link> links = FindAllLinks(citiesBetween, mode);
if (links == null || links.Count < 1)
{
return(null);
}
/*var stopWatch = new Stopwatch();
* stopWatch.Start();
* long ts0=stopWatch.ElapsedMilliseconds;*/
Setup(citiesBetween, links);
City source = FindCity(fromCity, citiesBetween);
City target = FindCity(toCity, citiesBetween);
if (D[source.Index, target.Index] == Double.MaxValue)
{
return(new List <Link>()); // no path between source and target
}
List <City> path = GetIntermediatePath(source, target);
// must construct route from path
var route = new List <Link>();
route.Add(new Link(source, path.ElementAt(0), D[source.Index, path.ElementAt(0).Index]));
for (var i = 0; i < path.Count - 1; i++)
{
City from = path.ElementAt(i);
City to = path.ElementAt(i + 1);
route.Add(new Link(from, to, D[from.Index, to.Index]));
}
route.Add(new Link(path.ElementAt(path.Count - 1), target,
D[path.ElementAt(path.Count - 1).Index, target.Index]));
return(route);
}
/// <summary>
/// Initializes the Routes with the cities.
/// </summary>
/// <param name="cities"></param>
public Routes(Cities cities)
{
this.cities = cities;
//this.rqw = new RouteRequestWatcher();
}
public RoutesFloydWarshall(Cities cities)
: base(cities)
{
}
/// <summary>
/// Initializes the Routes with the cities.
/// </summary>
/// <param name="cities"></param>
public Routes(Cities cities)
{
this.cities = cities;
}
