public void CalculateSpeed_Test_If_Speed_Calculation_Is_Correct()
{
var uut_speedtest = new TrackCalculator();
uut_speedtest.calculateSpeed(fakeA, fakeB);
Assert.AreEqual(333.33333333333331d, fakeB.Velocity);
}
public void CalculateSpeed_Test_If_Speed_Calculation_Is_Not_Correct()
{
TrackCalculator calculateSpeedTest = new TrackCalculator();
calculateSpeedTest.calculateSpeed(fakeA, fakeB);
Assert.AreNotEqual(133.33333333333331d, fakeB.Velocity);
}
public void CalculateCompassCourse_Test_If_Compass_Course_Calculation_Is_not_Correct()
{
TrackCalculator calculateCompassCourseTest = new TrackCalculator();
calculateCompassCourseTest.calculateCompassCourse(fakeACompassCourse, fakeBCompassCourse);
Assert.AreNotEqual(255, fakeBCompassCourse.CompassCourse);
}
public void SetUp()
{
_fakeTrackCalculator = Substitute.For <ITrackCalculator>();
_uut = new TrackCalculator(_fakeTrackCalculator);
_testTracksOld = new List <Track>();
_testTracksNew = new List <Track>();
_testTracks = new List <Track>();
_testTracksOld.Add(new Track {
Tag = "JYG338", X = 5258, Y = 57189, Z = 5000, Timestamp = DateTime.ParseExact("20191024155401709", "yyyyMMddHHmmssfff", null), CompassCourse = 0, Velocity = 0
});
_testTracksOld.Add(new Track {
Tag = "GVC241", X = 38594, Y = 77966, Z = 10900, Timestamp = DateTime.ParseExact("20191024155401709", "yyyyMMddHHmmssfff", null), CompassCourse = 0, Velocity = 0
});
_testTracksOld.Add(new Track {
Tag = "WIA512", X = 17357, Y = 24364, Z = 2100, Timestamp = DateTime.ParseExact("20191024155401709", "yyyyMMddHHmmssfff", null), CompassCourse = 0, Velocity = 0
});
_testTracksNew.Add(new Track {
Tag = "JYG338", X = 5387, Y = 57076, Z = 5000, Timestamp = DateTime.ParseExact("20191024155402397", "yyyyMMddHHmmssfff", null), CompassCourse = 0, Velocity = 0
});
_testTracksNew.Add(new Track {
Tag = "GVC241", X = 38794, Y = 78066, Z = 10800, Timestamp = DateTime.ParseExact("20191024155402397", "yyyyMMddHHmmssfff", null), CompassCourse = 0, Velocity = 0
});
_testTracksNew.Add(new Track {
Tag = "WIA512", X = 18357, Y = 25364, Z = 2000, Timestamp = DateTime.ParseExact("20191024155402397", "yyyyMMddHHmmssfff", null), CompassCourse = 0, Velocity = 0
});
}
public void TestHorizontalVelocity(int Last_x, int Last_y, int New_x, int New_y, string dt1, string dt2,
double result)
{
DateTime dt1DateTime = DateTime.ParseExact(dt1, "mm:ss", null);
DateTime dt2DateTime = DateTime.ParseExact(dt2, "mm:ss", null);
_uut = new TrackCalculator(Last_x, Last_y, New_x, New_y, dt1DateTime, dt2DateTime);
Assert.That(_uut.CalculateHorizontalVelocity(), Is.EqualTo(result));
}
public void TestCalcAngle(int Last_x, int Last_y, int New_x, int New_y, string dt1, string dt2, double result)
{
DateTime dt1DateTime = DateTime.ParseExact(dt1, "mm:ss", null);
DateTime dt2DateTime = DateTime.ParseExact(dt2, "mm:ss", null);
_uut = new TrackCalculator(Last_x, Last_y, New_x, New_y, dt1DateTime, dt2DateTime);
Assert.That(_uut.CalculateCompassCourse(), Is.EqualTo(result));
}
public void GetAnySectionsFlat()
{
TrackCalculator trackCalculator = new TrackCalculator();
var range = 1.4;
var tracks = trackCalculator.GetSections(this.trackPoints, (previous, current) =>
{
return(Math.Abs(current.Altitude - previous.Altitude) <= range);
}).ToList();
PrintTracks(tracks);
}
static void Main(string[] args)
{
ConsoleLogger consoleLogger = new ConsoleLogger();
var transponderReceiver = TransponderReceiver.TransponderReceiverFactory.CreateTransponderDataReceiver();
var splitter = new Splitter();
transponderReceiver.TransponderDataReady += splitter.OnTransponderData;
var airspace = new Airspace
{
X = 0,
Y = 0,
Z = 500,
width = 80000,
depth = 80000,
height = 20000
};
var tracker = new TrackCalculator();
var airspace_monitor = new AirspaceMonitor(airspace, tracker);
airspace_monitor.NewTrackInTairSpaceEvent += consoleLogger.LogTrackEntered;
airspace_monitor.TrackLeavesAirSpaceEvent += consoleLogger.LogTrackLeft;
//splitter.newTrack += delegate(object sender, NewTrackArgs trackArgs)
//{
// Console.WriteLine("Nyt Track Event\n=====================");
// foreach (var track in trackArgs.Tracks)
// {
// Console.WriteLine(track);
// }
//};
splitter.NewTracks += airspace_monitor.OnTrackRecieved;
//airspace_monitor.TracksInAirspaceEvent += delegate(object sender, TracksInAirspaceArgs airspaceArgs)
//{
// Console.WriteLine("Current In Airspace");
// foreach (var track in airspaceArgs.Tracks)
// {
// Console.WriteLine(track);
// }
//};
var seperation_moniotr = new SeparationMonitor();
airspace_monitor.TracksInAirspaceEvent += seperation_moniotr.OnTrackRecieved;
while (true)
{
System.Threading.Thread.Sleep(1000);
}
}
public void AirspaceMonitorEmptyTest()
{
// Out uut
var airspace = new Airspace
{
X = 10,
Y = 10,
Z = 10,
depth = 1000,
width = 2000,
height = 500
};
var trackCalculator = new TrackCalculator();
var uut = new AirspaceMonitor(airspace, trackCalculator);
// To keep result(s) after the event(s) has fired
List <List <Track> > results = new List <List <Track> >();
// Our test handler
// This validates that the events arguments are correct
// Here we verify that the event indeed had 42 as expected
// And we save the value to results, such that we can verify how many times
// the event fired and they all were correct
EventHandler <TracksInAirspaceArgs> tracksInAirspaceHandler = (object sender, TracksInAirspaceArgs e) =>
{
int numInList = e.Tracks.Count; // Number of tracks in airspace
Assert.That(numInList, Is.EqualTo(0));
results.Add(e.Tracks);
};
// Register the test event handler
uut.TracksInAirspaceEvent += tracksInAirspaceHandler;
// Do stuff that trickers event
List <Track> tracksEmptyList = new List <Track>(); // opret liste
// Evt tilføj ting på listen
NewTrackArgs newTrack = new NewTrackArgs(); // opret taske
newTrack.Tracks = tracksEmptyList; // Putter listen ned i tasken
uut.OnTrackRecieved(this, newTrack); // Giv tasken til Caro
// Verify the amount of events
Assert.That(results.Count, Is.EqualTo(1)); // Only one event must be fired in this test
// and their value(s)
Assert.That(results.ElementAt(0).Count, Is.EqualTo(0));
// deregister the event because we are good boys and girls
uut.TracksInAirspaceEvent -= tracksInAirspaceHandler;
}
public void CalculateVelocity_CorrectVelocityFrom2Points_CalcCallsDistanceToInPointsCorrect()
{
var time1 = DateTime.Now;
var time2 = time1.AddSeconds(5);
var length = Math.Sqrt(Math.Pow(_point2.X - _point1.X, 2) + Math.Pow(_point2.Y - _point1.Y, 2));
var deltaTime = time2 - time1;
var correctVelocity = Math.Round(length / deltaTime.TotalSeconds, 3);
var result = TrackCalculator.CalculateVelocity(_point1.X, _point1.Y, _point2.X, _point2.Y, time1, time2);
// If asserts is true, calculator most call and use point.distanceTo() correct.
Assert.That(result, Is.EqualTo(correctVelocity));
}
public void CompassCourse_Return_Span(double X_coor1, double X_coor2, double Y_coor1, double Y_coor2,
double span)
{
track1.X_coor = X_coor1;
track2.X_coor = X_coor2;
track1.Y_coor = Y_coor1;
track2.Y_coor = Y_coor2;
TrackCalculator track = new TrackCalculator(track1, track2);
double difference = track.Span(X_coor1, X_coor2, Y_coor1, Y_coor2);
Assert.That(difference, Is.EqualTo(span));
}
public void SetUp()
{
_uut = new Track
{
Tag = "AAA111",
Altitude = 1900,
Course = 180,
PositionX = 28756,
PositionY = 78562,
Timestamp = DateTime.Now,
Velocity = 218
};
_newDataTrack = Substitute.For <ITrack>();
_newDataTrack.Tag = _uut.Tag;
_trackCalculator = Substitute.For <TrackCalculator>();
}
public void CompassCourse_Return_DateVelocity()
{
DateTime dateTime1 = DateTime.ParseExact("20191101220012345", "yyyyMMddHHmmssfff", System.Globalization.CultureInfo.InvariantCulture);
DateTime dateTime2 = DateTime.ParseExact("20191101220023456", "yyyyMMddHHmmssfff", System.Globalization.CultureInfo.InvariantCulture);
track1.timestamp = dateTime1;
track1.X_coor = 0;
track1.Y_coor = 0;
track2.timestamp = dateTime2;
track2.X_coor = 100;
track2.Y_coor = 200;
TrackCalculator track = new TrackCalculator(track1, track2);
double velocity = track.VelocityCalculation(400, 0, 300, 0, dateTime1, dateTime2);
Assert.That(velocity, Is.EqualTo(500));
}
public void AirspaceMonitor_IsInside_z_smaller_than_Z()
{
// Out uut
var airspace = new Airspace
{
X = 20,
Y = 20,
Z = 500,
depth = 80000,
width = 80000,
height = 20000
};
var trackCalculator = new TrackCalculator();
var uut = new AirspaceMonitor(airspace, trackCalculator);
// To keep result(s) after the event(s) has fired
List <List <Track> > results = new List <List <Track> >(); //Antal lister modtaget med tracks
// Our test handler
// This validates that the events arguments are correct
// Here we verify that the event indeed had 42 as expected
// And we save the value to results, such that we can verify how many times
// the event fired and they all were correct
EventHandler <TracksInAirspaceArgs> tracksInAirspaceHandler = (object sender, TracksInAirspaceArgs e) =>
{
//int numInList = e.Tracks.Count; // Number of tracks in airspace
//Assert.That(numInList, Is.EqualTo(0));
var l = new List <Track>(); //Kopi af listen
foreach (var t in e.Tracks)
{
l.Add(t);
}
results.Add(l);
};
// Register the test event handler
uut.TracksInAirspaceEvent += tracksInAirspaceHandler;
// Do stuff that trickers event
Track outsideTrack_z_greather_than_Z_plus_height = new Track
{
X = 1000,
Y = 1000,
Altitude = 70,
TagId = "BER207"
};
List <Track> tracksOutsideXList = new List <Track>
{
outsideTrack_z_greather_than_Z_plus_height
}; // opret liste
NewTrackArgs newTrack1 = new NewTrackArgs
{
Tracks = tracksOutsideXList // Putter listen ned i tasken
}; // opret taske
uut.OnTrackRecieved(this, newTrack1);
// Verify the amount of events
Assert.That(results.Count, Is.EqualTo(1)); // Only one event must be fired in this test
// and their value(s)
Assert.That(results.ElementAt(0).Count, Is.EqualTo(0));
// deregister the event because we are good boys and girls
uut.TracksInAirspaceEvent -= tracksInAirspaceHandler;
}
public void AirspaceMonitor_Replace_Track_With_Same_TagID()
{
// Out uut
var airspace = new Airspace
{
X = 10,
Y = 10,
Z = 10,
depth = 1000,
width = 2000,
height = 500
};
var trackCalculator = new TrackCalculator();
var uut = new AirspaceMonitor(airspace, trackCalculator);
// To keep result(s) after the event(s) has fired
List <List <Track> > results = new List <List <Track> >(); //Antal lister modtaget med tracks
// Our test handler
// This validates that the events arguments are correct
// Here we verify that the event indeed had 42 as expected
// And we save the value to results, such that we can verify how many times
// the event fired and they all were correct
EventHandler <TracksInAirspaceArgs> tracksInAirspaceHandler = (object sender, TracksInAirspaceArgs e) =>
{
//int numInList = e.Tracks.Count; // Number of tracks in airspace
//Assert.That(numInList, Is.EqualTo(0));
var l = new List <Track>(); //Kopi af listen
foreach (var t in e.Tracks)
{
l.Add(t);
}
results.Add(l);
};
// Register the test event handler
uut.TracksInAirspaceEvent += tracksInAirspaceHandler;
// Do stuff that trickers event
Track insideTrack = new Track
{
X = 15,
Y = 15,
Altitude = 15,
TagId = "DEF456"
};
List <Track> tracksSingleInsideList = new List <Track>
{
insideTrack
}; // opret liste
Track outsideTrack = new Track
{
X = 8,
Y = 8,
Altitude = 8,
TagId = "AAA111"
};
List <Track> trackSingleOutsideList = new List <Track>
{
outsideTrack
};
Track outsideTrackSameTagIDasInsideTrack = new Track
{
X = 2,
Y = 2,
Altitude = 2,
TagId = "DEF456"
};
List <Track> tracksOutsideListSameTagID = new List <Track>
{
outsideTrackSameTagIDasInsideTrack
};
NewTrackArgs newTrack = new NewTrackArgs
{
Tracks = tracksSingleInsideList // Putter listen ned i tasken
}; // opret taske
NewTrackArgs newTrackOutside = new NewTrackArgs
{
Tracks = trackSingleOutsideList
};
NewTrackArgs newTrackOutsideSameTagID = new NewTrackArgs
{
Tracks = tracksOutsideListSameTagID
};
uut.OnTrackRecieved(this, newTrack); // Giv tasken til Caro
uut.OnTrackRecieved(this, newTrackOutside);
uut.OnTrackRecieved(this, newTrackOutsideSameTagID);
// Verify the amount of events
Assert.That(results.Count, Is.EqualTo(3)); // Only one event must be fired in this test
// and their value(s)
Assert.That(results.ElementAt(0).Count, Is.EqualTo(1));
Assert.That(results.ElementAt(1).Count, Is.EqualTo(1));
Assert.That(results.ElementAt(2).Count, Is.EqualTo(0));
// deregister the event because we are good boys and girls
uut.TracksInAirspaceEvent -= tracksInAirspaceHandler;
}
public void CalculateCourse_IsEqualTo()
{
var Course = TrackCalculator.CalculateCourse(5, 5, 10, 10);
Assert.That(Course, Is.EqualTo(45));
}
public void CalculateVelocity_IsEqualTo07()
{
var Velocity = Math.Round(TrackCalculator.CalculateVelocity(5, 5, 10, 10, DateTime.Now - TimeSpan.FromSeconds(10), DateTime.Now), 1);
Assert.That(Velocity, Is.EqualTo(0.7));
}
public void CalculateCourseTest(int x1, int x2, int y1, int y2, double result)
{
TrackCalculator tc = new TrackCalculator();
Assert.That(tc.CalculateCourse(x1, x2, y1, y2), Is.EqualTo(result).Within(0.1));
}
public void CalculateVelocityTest(int x1, int x2, int y1, int y2, int z1, int z2, double time1, double time2, double result)
{
TrackCalculator tc = new TrackCalculator();
Assert.That(tc.CalculateVelocity(x1, x2, y1, y2, z1, z2, time1, time2), Is.EqualTo(result));
}
