public void RaceRun_IsComplete_ParticipantNotInStartlist()
        {
            TestDataGenerator tg = new TestDataGenerator();

            var race = tg.Model.GetRace(0);
            var run1 = race.GetRun(0);
            var run2 = race.GetRun(1);

            var frslVP = new FirstRunStartListViewProvider();

            frslVP.Init(race.GetParticipants());
            run1.SetStartListProvider(frslVP);

            var rVP = new RaceRunResultViewProvider();

            rVP.Init(run1, tg.Model);
            run1.SetResultViewProvider(rVP);

            var srslVP = new BasedOnResultsFirstRunStartListViewProvider(0, false);

            srslVP.Init(run1);
            run2.SetStartListProvider(srslVP);

            tg.createRaceParticipants(2);

            Assert.IsFalse(run1.IsComplete);
            //Assert.IsFalse(run2.IsComplete);

            // Run 1
            run1.SetRunTime(race.GetParticipant(1), new TimeSpan(0, 0, 0, 10, 0));
            Assert.IsFalse(run1.IsComplete);
            run1.SetResultCode(race.GetParticipant(2), RunResult.EResultCode.NaS);
            Assert.IsTrue(run1.IsComplete);

            // Run 2
            Assert.IsFalse(RaceRunUtil.IsComplete(run2));
            Assert.IsFalse(run2.IsComplete);
            run2.SetRunTime(race.GetParticipant(1), new TimeSpan(0, 0, 0, 10, 0));
            Assert.IsTrue(run2.IsComplete);
        }
        public void RaceRun_RunResult()
        {
            TestDataGenerator tg = new TestDataGenerator();

            tg.createRaceParticipants(5);

            var race = tg.Model.GetRace(0);
            var run  = race.GetRun(0);

            // Initially, there aren't any results
            Assert.AreEqual(0, run.GetResultList().Count);
            Assert.IsFalse(run.IsOrWasOnTrack(race.GetParticipant(1)));
            Assert.IsFalse(run.HasResults());
            Assert.IsFalse(RaceRunUtil.IsComplete(run));
            Assert.IsFalse(run.IsComplete);

            run.SetStartTime(race.GetParticipant(1), new TimeSpan(8, 0, 0));
            Assert.AreEqual(1, run.GetResultList().Count);
            Assert.AreEqual(1U, run.GetOnTrackList()[0].StartNumber);

            Assert.IsFalse(run.HasResults());
            Assert.IsFalse(RaceRunUtil.IsComplete(run));
            Assert.IsFalse(run.IsComplete);

            run.SetFinishTime(race.GetParticipant(1), new TimeSpan(8, 1, 1));
            Assert.AreEqual(1, run.GetResultList().Count);
            Assert.AreEqual(0, run.GetOnTrackList().Count);
            Assert.IsFalse(RaceRunUtil.IsComplete(run));
            Assert.IsFalse(run.IsComplete);

            run.SetFinishTime(race.GetParticipant(1), null);
            Assert.AreEqual(1, run.GetResultList().Count);
            Assert.AreEqual(1U, run.GetOnTrackList()[0].StartNumber);
            Assert.IsFalse(RaceRunUtil.IsComplete(run));
            Assert.IsFalse(run.IsComplete);

            run.SetFinishTime(race.GetParticipant(1), new TimeSpan(8, 1, 1));
            Assert.AreEqual(1, run.GetResultList().Count);
            Assert.AreEqual(new TimeSpan(0, 1, 1), run.GetResultList()[0].Runtime);
            Assert.AreEqual(0, run.GetOnTrackList().Count);
            Assert.IsTrue(run.IsOrWasOnTrack(race.GetParticipant(1)));
            Assert.IsFalse(RaceRunUtil.IsComplete(run));
            Assert.IsFalse(run.IsComplete);

            Assert.IsFalse(run.IsOrWasOnTrack(race.GetParticipant(2)));
            run.SetStartFinishTime(race.GetParticipant(2), new TimeSpan(8, 2, 0), new TimeSpan(8, 3, 2));
            Assert.AreEqual(2, run.GetResultList().Count);
            Assert.AreEqual(new TimeSpan(0, 1, 2), run.GetResultList()[1].Runtime);
            Assert.AreEqual(0, run.GetOnTrackList().Count);
            Assert.IsTrue(run.IsOrWasOnTrack(race.GetParticipant(2)));
            Assert.IsFalse(RaceRunUtil.IsComplete(run));
            Assert.IsFalse(run.IsComplete);


            run.SetRunTime(race.GetParticipant(3), new TimeSpan(0, 1, 3));
            Assert.AreEqual(3, run.GetResultList().Count);
            Assert.AreEqual(new TimeSpan(0, 1, 3), run.GetResultList()[2].Runtime);
            Assert.AreEqual(0, run.GetOnTrackList().Count);
            Assert.IsFalse(RaceRunUtil.IsComplete(run));
            Assert.IsFalse(RaceRunUtil.IsComplete(run));
            Assert.IsFalse(run.IsComplete);


            run.SetResultCode(race.GetParticipant(4), RunResult.EResultCode.NaS);
            Assert.AreEqual(4, run.GetResultList().Count);
            Assert.AreEqual(null, run.GetResultList()[3].Runtime);
            Assert.AreEqual(RunResult.EResultCode.NaS, run.GetResultList()[3].ResultCode);
            Assert.AreEqual(0, run.GetOnTrackList().Count);
            Assert.IsFalse(RaceRunUtil.IsComplete(run));
            Assert.IsFalse(run.IsComplete);

            run.SetResultCode(race.GetParticipant(5), RunResult.EResultCode.DIS, "Tor 5");
            Assert.AreEqual(5, run.GetResultList().Count);
            Assert.AreEqual(null, run.GetResultList()[4].Runtime);
            Assert.AreEqual(RunResult.EResultCode.DIS, run.GetResultList()[4].ResultCode);
            Assert.AreEqual("Tor 5", run.GetResultList()[4].DisqualText);
            Assert.AreEqual(0, run.GetOnTrackList().Count);
            Assert.IsTrue(RaceRunUtil.IsComplete(run));
            Assert.IsTrue(run.IsComplete);


            var tmp1 = run.DeleteRunResult(race.GetParticipant(1));

            Assert.AreEqual(1U, tmp1.StartNumber);
            Assert.AreEqual(4, run.GetResultList().Count);
            Assert.AreNotEqual(1U, run.GetResultList()[0].StartNumber);
            Assert.AreEqual(2U, run.GetResultList()[0].StartNumber);
            Assert.IsFalse(RaceRunUtil.IsComplete(run));
            Assert.IsFalse(run.IsComplete);


            Assert.IsTrue(run.HasResults());
            run.DeleteRunResults();
            Assert.IsFalse(run.HasResults());
            Assert.AreEqual(0, run.GetResultList().Count);
            Assert.IsFalse(RaceRunUtil.IsComplete(run));
            Assert.IsFalse(run.IsComplete);
        }
        public void RaceRun_Timing_SpecialHandling_ResultCode()
        {
            TestDataGenerator tg = new TestDataGenerator();

            tg.createRaceParticipants(2);

            var race = tg.Model.GetRace(0);
            var run  = race.GetRun(0);

            // Initially, there aren't any results
            Assert.AreEqual(0, run.GetResultList().Count);
            Assert.AreEqual(0, run.GetOnTrackList().Count);
            Assert.IsFalse(run.IsOrWasOnTrack(race.GetParticipant(1)));
            Assert.IsFalse(run.HasResults());
            Assert.IsFalse(RaceRunUtil.IsComplete(run));
            Assert.IsFalse(run.IsComplete);

            // NiZ
            run.SetStartTime(race.GetParticipant(1), new TimeSpan(8, 0, 0));
            Assert.AreEqual(1, run.GetResultList().Count);
            Assert.AreEqual(1U, run.GetResultList()[0].StartNumber);
            Assert.AreEqual(1, run.GetOnTrackList().Count);
            Assert.AreEqual(1U, run.GetOnTrackList()[0].StartNumber);
            Assert.IsFalse(RaceRunUtil.IsComplete(run));
            Assert.IsFalse(run.IsComplete);

            run.SetResultCode(race.GetParticipant(1), RunResult.EResultCode.NiZ);
            Assert.AreEqual(1, run.GetResultList().Count);
            Assert.AreEqual(1U, run.GetResultList()[0].StartNumber);
            Assert.AreEqual(0, run.GetOnTrackList().Count);
            Assert.IsFalse(RaceRunUtil.IsComplete(run));
            Assert.IsFalse(run.IsComplete);

            // ... and came later to the finish
            Assert.AreEqual(RunResult.EResultCode.NiZ, run.GetResultList().FirstOrDefault(p => p.StartNumber == 1).ResultCode);
            run.SetFinishTime(race.GetParticipant(1), new TimeSpan(8, 1, 0));
            Assert.AreEqual(RunResult.EResultCode.Normal, run.GetResultList().FirstOrDefault(p => p.StartNumber == 1).ResultCode);
            // Set NiZ again for later test
            run.SetResultCode(race.GetParticipant(1), RunResult.EResultCode.NiZ);
            Assert.AreEqual(RunResult.EResultCode.NiZ, run.GetResultList().FirstOrDefault(p => p.StartNumber == 1).ResultCode);
            Assert.IsFalse(RaceRunUtil.IsComplete(run));
            Assert.IsFalse(run.IsComplete);


            // NaS
            run.SetResultCode(race.GetParticipant(2), RunResult.EResultCode.NaS);
            Assert.AreEqual(2, run.GetResultList().Count);
            Assert.AreEqual(1U, run.GetResultList()[0].StartNumber);
            Assert.AreEqual(2U, run.GetResultList()[1].StartNumber);
            Assert.AreEqual(0, run.GetOnTrackList().Count);
            Assert.IsTrue(RaceRunUtil.IsComplete(run));
            Assert.IsTrue(run.IsComplete);


            // Special handling: Participant is allowed to restart and gets a new time => ResultCode shall be deleted
            Assert.AreEqual(RunResult.EResultCode.NiZ, run.GetResultList().FirstOrDefault(p => p.StartNumber == 1).ResultCode);
            run.SetStartTime(race.GetParticipant(1), new TimeSpan(9, 0, 0));
            Assert.IsNotNull(run.GetResultList().FirstOrDefault(p => p.StartNumber == 1));
            Assert.AreEqual(RunResult.EResultCode.Normal, run.GetResultList().FirstOrDefault(p => p.StartNumber == 1).ResultCode);
            Assert.IsNotNull(run.GetOnTrackList().FirstOrDefault(p => p.StartNumber == 1));
            Assert.IsFalse(RaceRunUtil.IsComplete(run));
            Assert.IsFalse(run.IsComplete);

            run.SetFinishTime(race.GetParticipant(1), new TimeSpan(9, 1, 0));
            Assert.IsNotNull(run.GetResultList().FirstOrDefault(p => p.StartNumber == 1));
            Assert.IsNull(run.GetOnTrackList().FirstOrDefault(p => p.StartNumber == 1));
            Assert.IsTrue(RaceRunUtil.IsComplete(run));
            Assert.IsTrue(run.IsComplete);

            Assert.AreEqual(RunResult.EResultCode.NaS, run.GetResultList().FirstOrDefault(p => p.StartNumber == 2).ResultCode);
            run.SetRunTime(race.GetParticipant(2), new TimeSpan(0, 1, 0));
            Assert.AreEqual(RunResult.EResultCode.Normal, run.GetResultList().FirstOrDefault(p => p.StartNumber == 2).ResultCode);
            Assert.IsTrue(RaceRunUtil.IsComplete(run));
            Assert.IsTrue(run.IsComplete);
        }