public CompetitorAssessmentCalculator(CompetitionRunResult competitor, CompetitionClassModel modelSnapshot)
{
Guard.NotNull(competitor, nameof(competitor));
Guard.NotNull(modelSnapshot, nameof(modelSnapshot));
this.competitor = competitor;
this.modelSnapshot = modelSnapshot;
}
public static IEnumerable <VisualizationChange> ForExistingRun(CompetitionRunResult existingRunResult, RecordedTime?latestIntermediateTimeOrNull)
{
Guard.NotNull(existingRunResult, nameof(existingRunResult));
TimeSpanWithAccuracy?finishTimeElapsed = null;
TimeSpanWithAccuracy?intermediateTimeElapsed = null;
if (existingRunResult.Timings != null)
{
if (existingRunResult.Timings.FinishTime != null)
{
finishTimeElapsed = existingRunResult.Timings.FinishTime.ElapsedSince(existingRunResult.Timings.StartTime);
}
if (latestIntermediateTimeOrNull != null)
{
intermediateTimeElapsed = latestIntermediateTimeOrNull.ElapsedSince(existingRunResult.Timings.StartTime);
}
}
return(new List <VisualizationChange>
{
new EliminationUpdate(existingRunResult.IsEliminated),
new FaultCountUpdate(existingRunResult.FaultCount),
new RefusalCountUpdate(existingRunResult.RefusalCount),
PrimaryTimeStopAndSet.FromTimeSpanWithAccuracy(finishTimeElapsed),
SecondaryTimeUpdate.FromTimeSpanWithAccuracy(intermediateTimeElapsed, false)
});
}
private void AcceptButton_Click(object?sender, EventArgs e)
{
if (ParentForm == null || HasValidationErrors)
{
return;
}
Assertions.IsNotNull(originalRunVersion, nameof(originalRunVersion));
// @formatter:keep_existing_linebreaks true
CompetitionRunResult newRunVersion = originalRunVersion
.ChangeTimings(ConvertFinishTimeFromScreen(true))
.ChangeFaultCount(ConvertFaultCountFromScreen())
.ChangeRefusalCount(ConvertRefusalCountFromScreen())
.ChangeIsEliminated(ConvertEliminatedFromScreen());
// @formatter:keep_existing_linebreaks restore
var changingEventArgs = new RunResultChangingEventArgs(originalRunVersion, newRunVersion);
RunResultChanging?.Invoke(this, changingEventArgs);
if (changingEventArgs.ErrorMessage == null)
{
ShowAnimatedSuccess("Competitor updated.");
originalRunVersion = CacheManager.DefaultInstance.ActiveModel.GetRunResultFor(newRunVersion.Competitor.Number);
RunResultChanged?.Invoke(this, EventArgs.Empty);
}
else
{
ShowAnimatedFailure(changingEventArgs.ErrorMessage);
}
}
public RunResultChangingEventArgs(CompetitionRunResult originalRunResult, CompetitionRunResult newRunResult)
{
Guard.NotNull(originalRunResult, nameof(originalRunResult));
Guard.NotNull(newRunResult, nameof(newRunResult));
OriginalRunResult = originalRunResult;
NewRunResult = newRunResult;
}
public int CompareWithoutNumberTo(CompetitionRunResultRankingComparable?other)
{
if (other != null && CompetitionRunResult.AreEquivalentRun(runResult, other.runResult))
{
return(NoDifference);
}
return(CompareTo(other));
}
public CompetitionRunResultRankingComparable(CompetitionRunResult runResult, CompetitionClassModel model, RankingComparisonMode comparisonMode)
{
Guard.NotNull(runResult, nameof(runResult));
Guard.NotNull(model, nameof(model));
this.runResult = runResult;
this.comparisonMode = comparisonMode;
calculator = new CompetitorAssessmentCalculator(runResult, model);
}
private string GetErrorForRefusalCountOnScreen()
{
try
{
CompetitionRunResult.AssertRefusalCountIsValid((int)refusalsUpDown.Value);
}
catch (ArgumentException ex)
{
return(ex.Message);
}
return(string.Empty);
}
public static CompetitionRunResultXml ToXmlObject(CompetitionRunResult source)
{
Guard.NotNull(source, nameof(source));
return(new CompetitionRunResultXml
{
Competitor = CompetitorXml.ToXmlObject(source.Competitor),
Timings = CompetitionRunTimingsXml.ToXmlObject(source.Timings),
FaultCount = source.FaultCount,
RefusalCount = source.RefusalCount,
IsEliminated = source.IsEliminated
});
}
private static CompetitionRunResult CreateCompetitorForFinishWithNumber(bool finishTimeIsGreater, bool competitorNumberIsGreater)
{
int competitorNumber = competitorNumberIsGreater ? HighCompetitorNumber : LowCompetitorNumber;
TimeSpan finishTime = TimeSpan.FromSeconds(finishTimeIsGreater ? 50 : 25);
var result = new CompetitionRunResult(new Competitor(competitorNumber, "A", "A"));
TimeSpan startTime = TimeSpan.FromSeconds(10);
result = result
.ChangeTimings(new CompetitionRunTimings(new RecordedTimeBuilder()
.At(startTime).Build())
.ChangeFinishTime(new RecordedTimeBuilder()
.At(startTime + finishTime).Build()));
return(result);
}
public void PenaltyOverrun2()
{
// Arrange
var scenarios = new List <OrderingScenario>
{
// Bits: PenaltyTime X > Y, OverrunTime X > Y, PenaltyTime Y > X, OverrunTime Y > X
new(4, OrderingScenario.FromBits(0, 0, 0, 0), OrderExpect.IsEven),
new(4, OrderingScenario.FromBits(0, 0, 0, 1), OrderExpect.WinnerIsY),
new(4, OrderingScenario.FromBits(0, 0, 1, 0), OrderExpect.WinnerIsX),
new(4, OrderingScenario.FromBits(0, 0, 1, 1), OrderExpect.WinnerIsX),
new(4, OrderingScenario.FromBits(0, 1, 0, 0), OrderExpect.WinnerIsX),
new(4, OrderingScenario.FromBits(0, 1, 0, 1), OrderExpect.DoNotCare),
new(4, OrderingScenario.FromBits(0, 1, 1, 0), OrderExpect.WinnerIsX),
new(4, OrderingScenario.FromBits(0, 1, 1, 1), OrderExpect.DoNotCare),
new(4, OrderingScenario.FromBits(1, 0, 0, 0), OrderExpect.WinnerIsY),
new(4, OrderingScenario.FromBits(1, 0, 0, 1), OrderExpect.WinnerIsY),
new(4, OrderingScenario.FromBits(1, 0, 1, 0), OrderExpect.DoNotCare),
new(4, OrderingScenario.FromBits(1, 0, 1, 1), OrderExpect.DoNotCare),
new(4, OrderingScenario.FromBits(1, 1, 0, 0), OrderExpect.WinnerIsY),
new(4, OrderingScenario.FromBits(1, 1, 0, 1), OrderExpect.DoNotCare),
new(4, OrderingScenario.FromBits(1, 1, 1, 0), OrderExpect.DoNotCare),
new(4, OrderingScenario.FromBits(1, 1, 1, 1), OrderExpect.DoNotCare)
};
CompetitionClassModel model = new CompetitionClassModel()
.ChangeClassInfo(new CompetitionClassInfo()
.ChangeStandardCourseTime(StandardCourseTime));
var comparer = new CompetitionRunResultRankingComparer(model, RankingComparisonMode.OnlyPhasePenaltyOverrun);
foreach (OrderingScenario scenario in scenarios.Where(s => s.Result != OrderExpect.DoNotCare))
{
CompetitionRunResult xCompetitor = CreateCompetitorForPenaltyOverrun(scenario[0], scenario[1]);
CompetitionRunResult yCompetitor = CreateCompetitorForPenaltyOverrun(scenario[2], scenario[3]);
AssertCompetitorsAreCompatibleWithProposedScenario(xCompetitor, yCompetitor, scenario, model);
// Act
int result = comparer.Compare(xCompetitor, yCompetitor);
// Assert
OrderExpect actual = TranslateComparerResult(result);
actual.Should().Be(scenario.Result, scenario.ToString());
}
}
public IEnumerable <CompetitionRunResult> Recalculate(IEnumerable <CompetitionRunResult> runResults)
{
Guard.NotNull(runResults, nameof(runResults));
using (new CodeTimer("Recalculate rankings"))
{
var sorted = new SortedSet <CompetitionRunResult>(runResults, comparer);
var newResults = new List <CompetitionRunResult>();
int placementCounter = 0;
CompetitionRunResult?previousResult = null;
foreach (CompetitionRunResult runResult in sorted)
{
if (runResult.HasFinished && !runResult.IsEliminated)
{
int placement;
if (previousResult != null && comparer.IsPlacementEqual(runResult, previousResult))
{
placement = previousResult.Placement;
}
else
{
placementCounter++;
placement = placementCounter;
}
CompetitionRunResult runResultWithPlacement = runResult.ChangePlacement(placement);
newResults.Add(runResultWithPlacement);
previousResult = runResultWithPlacement;
}
else
{
CompetitionRunResult runResultWithoutPlacement = runResult.ChangePlacement(0);
newResults.Add(runResultWithoutPlacement);
}
}
return(newResults);
}
}
private static void AssertCompetitorsAreCompatibleWithProposedScenario(CompetitionRunResult xCompetitor, CompetitionRunResult yCompetitor,
OrderingScenario scenario, CompetitionClassModel model)
{
var xCalculator = new CompetitorAssessmentCalculator(xCompetitor, model);
var yCalculator = new CompetitorAssessmentCalculator(yCompetitor, model);
if (scenario[0])
{
xCalculator.PenaltyTime.Should().BeGreaterThan(yCalculator.PenaltyTime);
}
else
{
xCalculator.PenaltyTime.Should().BeLessOrEqualTo(yCalculator.PenaltyTime);
}
if (scenario[1])
{
xCalculator.OverrunTime.Should().BeGreaterThan(yCalculator.OverrunTime);
}
else
{
xCalculator.OverrunTime.Should().BeLessOrEqualTo(yCalculator.OverrunTime);
}
if (scenario[2])
{
yCalculator.PenaltyTime.Should().BeGreaterThan(xCalculator.PenaltyTime);
}
else
{
yCalculator.PenaltyTime.Should().BeLessOrEqualTo(xCalculator.PenaltyTime);
}
if (scenario[3])
{
yCalculator.OverrunTime.Should().BeGreaterThan(xCalculator.OverrunTime);
}
else
{
yCalculator.OverrunTime.Should().BeLessOrEqualTo(xCalculator.OverrunTime);
}
}
private static CompetitionRunResult CreateCompetitorForCompletion(bool hasFinished, bool isEliminated)
{
var result = new CompetitionRunResult(new Competitor(1, "A", "A"));
if (isEliminated)
{
result = result.ChangeIsEliminated(true);
}
if (hasFinished)
{
result = result
.ChangeTimings(new CompetitionRunTimings(new RecordedTimeBuilder()
.At(TimeSpan.FromSeconds(10)).Build())
.ChangeFinishTime(new RecordedTimeBuilder()
.At(TimeSpan.FromSeconds(25)).Build()));
}
return(result);
}
private static CompetitionRunResult CreateCompetitorForPenaltyOverrun(bool penaltyTimeIsGreater, bool overrunTimeIsGreater)
{
TimeSpan overrunTime = overrunTimeIsGreater ? HighOverrunTime : LowOverrunTime;
TimeSpan penaltyTime = penaltyTimeIsGreater ? HighPenaltyTime : LowPenaltyTime;
var result = new CompetitionRunResult(new Competitor(1, "A", "A"));
TimeSpan startTime = TimeSpan.FromSeconds(10);
result = result
.ChangeTimings(new CompetitionRunTimings(new RecordedTimeBuilder()
.At(startTime).Build())
.ChangeFinishTime(new RecordedTimeBuilder()
.At(startTime + overrunTime + StandardCourseTime).Build()));
int fr = (int)(penaltyTime - overrunTime).TotalSeconds;
result = result.ChangeFaultCount(fr);
return(result);
}
public void UpdateRankings(IReadOnlyCollection <CompetitionRunResult> rankings)
{
Guard.NotNull(rankings, nameof(rankings));
if (Visible)
{
RunHistoryLine[] firstThreeControls =
{
runHistoryLine0001,
runHistoryLine0002,
runHistoryLine0003
};
for (int index = 0; index < firstThreeControls.Length; index++)
{
if (index < rankings.Count)
{
CompetitionRunResult runResult = rankings.ElementAt(index);
firstThreeControls[index].SetCompetitionRunResult(runResult);
}
else
{
firstThreeControls[index].ClearCompetitionRunResult();
}
}
IEnumerable <CompetitionRunResult> remainingRunResults = rankings.Skip(3);
// Performance optimization: prevents seconds delay and
// Win32 crash caused by creating too many child controls.
remainingRunResults = remainingRunResults.Take(100);
RecreateScrollableRunHistoryLines(remainingRunResults.ToList());
}
else
{
pendingRefreshOfRankings = rankings;
}
}
public void RunCompletion1()
{
// Arrange
var scenarios = new List <OrderingScenario>
{
// Bits: X HasFinished, X IsEliminated, Y HasFinished, Y IsEliminated
new(4, OrderingScenario.FromBits(0, 0, 0, 0), OrderExpect.IsEven),
new(4, OrderingScenario.FromBits(0, 0, 0, 1), OrderExpect.WinnerIsY),
new(4, OrderingScenario.FromBits(0, 0, 1, 0), OrderExpect.WinnerIsY),
new(4, OrderingScenario.FromBits(0, 0, 1, 1), OrderExpect.WinnerIsY),
new(4, OrderingScenario.FromBits(0, 1, 0, 0), OrderExpect.WinnerIsX),
new(4, OrderingScenario.FromBits(0, 1, 0, 1), OrderExpect.IsEven),
new(4, OrderingScenario.FromBits(0, 1, 1, 0), OrderExpect.WinnerIsY),
new(4, OrderingScenario.FromBits(0, 1, 1, 1), OrderExpect.WinnerIsY),
new(4, OrderingScenario.FromBits(1, 0, 0, 0), OrderExpect.WinnerIsX),
new(4, OrderingScenario.FromBits(1, 0, 0, 1), OrderExpect.WinnerIsX),
new(4, OrderingScenario.FromBits(1, 0, 1, 0), OrderExpect.IsEven),
new(4, OrderingScenario.FromBits(1, 0, 1, 1), OrderExpect.WinnerIsX),
new(4, OrderingScenario.FromBits(1, 1, 0, 0), OrderExpect.WinnerIsX),
new(4, OrderingScenario.FromBits(1, 1, 0, 1), OrderExpect.WinnerIsX),
new(4, OrderingScenario.FromBits(1, 1, 1, 0), OrderExpect.WinnerIsY),
new(4, OrderingScenario.FromBits(1, 1, 1, 1), OrderExpect.IsEven)
};
var comparer = new CompetitionRunResultRankingComparer(new CompetitionClassModel(), RankingComparisonMode.OnlyPhaseCompletion);
foreach (OrderingScenario scenario in scenarios.Where(s => s.Result != OrderExpect.DoNotCare))
{
CompetitionRunResult xCompetitor = CreateCompetitorForCompletion(scenario[0], scenario[1]);
CompetitionRunResult yCompetitor = CreateCompetitorForCompletion(scenario[2], scenario[3]);
// Act
int result = comparer.Compare(xCompetitor, yCompetitor);
// Assert
OrderExpect actual = TranslateComparerResult(result);
actual.Should().Be(scenario.Result, scenario.ToString());
}
}
public void FinishNumber3()
{
// Arrange
var scenarios = new List <OrderingScenario>
{
// Bits: FinishTime X > Y, CompetitorNumber X > Y, FinishTime Y > X, CompetitorNumber Y > X
new(4, OrderingScenario.FromBits(0, 0, 0, 0), OrderExpect.DoNotCare),
new(4, OrderingScenario.FromBits(0, 0, 0, 1), OrderExpect.WinnerIsX),
new(4, OrderingScenario.FromBits(0, 0, 1, 0), OrderExpect.DoNotCare),
new(4, OrderingScenario.FromBits(0, 0, 1, 1), OrderExpect.WinnerIsX),
new(4, OrderingScenario.FromBits(0, 1, 0, 0), OrderExpect.WinnerIsY),
new(4, OrderingScenario.FromBits(0, 1, 0, 1), OrderExpect.DoNotCare),
new(4, OrderingScenario.FromBits(0, 1, 1, 0), OrderExpect.WinnerIsX),
new(4, OrderingScenario.FromBits(0, 1, 1, 1), OrderExpect.DoNotCare),
new(4, OrderingScenario.FromBits(1, 0, 0, 0), OrderExpect.DoNotCare),
new(4, OrderingScenario.FromBits(1, 0, 0, 1), OrderExpect.WinnerIsY),
new(4, OrderingScenario.FromBits(1, 0, 1, 0), OrderExpect.DoNotCare),
new(4, OrderingScenario.FromBits(1, 0, 1, 1), OrderExpect.DoNotCare),
new(4, OrderingScenario.FromBits(1, 1, 0, 0), OrderExpect.WinnerIsY),
new(4, OrderingScenario.FromBits(1, 1, 0, 1), OrderExpect.DoNotCare),
new(4, OrderingScenario.FromBits(1, 1, 1, 0), OrderExpect.DoNotCare),
new(4, OrderingScenario.FromBits(1, 1, 1, 1), OrderExpect.DoNotCare)
};
var comparer = new CompetitionRunResultRankingComparer(new CompetitionClassModel(), RankingComparisonMode.OnlyPhaseFinishNumber);
foreach (OrderingScenario scenario in scenarios.Where(s => s.Result != OrderExpect.DoNotCare))
{
CompetitionRunResult xCompetitor = CreateCompetitorForFinishWithNumber(scenario[0], scenario[1]);
CompetitionRunResult yCompetitor = CreateCompetitorForFinishWithNumber(scenario[2], scenario[3]);
// Act
int result = comparer.Compare(xCompetitor, yCompetitor);
// Assert
OrderExpect actual = TranslateComparerResult(result);
actual.Should().Be(scenario.Result, scenario.ToString());
}
}
private static CompetitionRunResult CreateCompetitorFor(string name, bool hasFinished, bool isEliminated, bool otherHasFinished,
bool penaltyTimeIsGreater, bool overrunTimeIsGreater, bool otherPenaltyTimeIsGreater, bool otherOverrunTimeIsGreater, bool finishTimeIsGreater,
bool competitorNumberIsGreater, bool otherFinishTimeIsGreater, bool otherCompetitorNumberIsGreater)
{
int competitorNumber = !competitorNumberIsGreater && !otherCompetitorNumberIsGreater
? LowOrSameCompetitorNumber
: competitorNumberIsGreater
? HighCompetitorNumber
: LowOrSameCompetitorNumber;
var result = new CompetitionRunResult(new Competitor(competitorNumber, name, name));
if (isEliminated)
{
result = result.ChangeIsEliminated(true);
}
if (hasFinished)
{
bool requireSameOverrunTime = !overrunTimeIsGreater && !otherOverrunTimeIsGreater;
TimeSpan overrunTime = requireSameOverrunTime
? !otherHasFinished ? TimeSpan.Zero : LowOrSameOverrunTime
: overrunTimeIsGreater
? HighOverrunTime
: LowOrSameOverrunTime;
bool requireSamePenaltyTime = !penaltyTimeIsGreater && !otherPenaltyTimeIsGreater;
TimeSpan penaltyTime = requireSamePenaltyTime
? !otherHasFinished ? TimeSpan.Zero : LowOrSamePenaltyTime
: penaltyTimeIsGreater
? HighPenaltyTime
: LowOrSamePenaltyTime;
bool requireSameFinishTime = !finishTimeIsGreater && !otherFinishTimeIsGreater;
TimeSpan extraFinishTime = requireSameFinishTime
? !otherHasFinished ? TimeSpan.Zero : LowOrSameExtraFinishTime
: finishTimeIsGreater
? HighExtraFinishTime
: LowOrSameExtraFinishTime;
TimeSpan startTime = TimeSpan.FromSeconds(10);
TimeSpan finishTimeAbsolute = startTime + overrunTime + extraFinishTime;
if (!otherHasFinished && (requireSameFinishTime || requireSameOverrunTime) && !overrunTimeIsGreater)
{
// Other has not finished, but finish times must be the same.
}
else if (otherHasFinished && (finishTimeIsGreater || otherFinishTimeIsGreater) && requireSameOverrunTime)
{
// Both finished, but overrun times must be the same.
}
else
{
finishTimeAbsolute += StandardCourseTime;
}
result = result
.ChangeTimings(new CompetitionRunTimings(new RecordedTimeBuilder()
.At(startTime).Build())
.ChangeFinishTime(new RecordedTimeBuilder()
.At(finishTimeAbsolute).Build()));
TimeSpan finishTimeElapsed = finishTimeAbsolute - startTime;
TimeSpan actualOverrunTime = finishTimeElapsed > StandardCourseTime ? finishTimeElapsed - StandardCourseTime : TimeSpan.Zero;
int fr = (int)(penaltyTime - actualOverrunTime).TotalSeconds;
int refusals = GetRefusalsFor(fr, isEliminated);
result = result.ChangeRefusalCount(refusals);
int faults = fr - refusals;
result = new FakeCompetitionRunResult(result, faults);
}
return(result);
}
private static void AssertCompetitorsAreCompatibleWithProposedScenario(CompetitionRunResult xCompetitor, CompetitionRunResult yCompetitor,
OrderingScenario scenario, CompetitionClassModel model)
{
var xCalculator = new CompetitorAssessmentCalculator(xCompetitor, model);
var yCalculator = new CompetitorAssessmentCalculator(yCompetitor, model);
if (scenario[0])
{
xCompetitor.HasFinished.Should().BeTrue();
}
else
{
xCompetitor.HasFinished.Should().BeFalse();
}
if (scenario[1])
{
xCompetitor.IsEliminated.Should().BeTrue();
}
else
{
xCompetitor.IsEliminated.Should().BeFalse();
}
if (scenario[2])
{
yCompetitor.HasFinished.Should().BeTrue();
}
else
{
yCompetitor.HasFinished.Should().BeFalse();
}
if (scenario[3])
{
yCompetitor.IsEliminated.Should().BeTrue();
}
else
{
yCompetitor.IsEliminated.Should().BeFalse();
}
if (scenario[4])
{
xCalculator.PenaltyTime.Should().BeGreaterThan(yCalculator.PenaltyTime);
}
else
{
xCalculator.PenaltyTime.Should().BeLessOrEqualTo(yCalculator.PenaltyTime);
}
if (scenario[5])
{
xCalculator.OverrunTime.Should().BeGreaterThan(yCalculator.OverrunTime);
}
else
{
xCalculator.OverrunTime.Should().BeLessOrEqualTo(yCalculator.OverrunTime);
}
if (scenario[6])
{
yCalculator.PenaltyTime.Should().BeGreaterThan(xCalculator.PenaltyTime);
}
else
{
yCalculator.PenaltyTime.Should().BeLessOrEqualTo(xCalculator.PenaltyTime);
}
if (scenario[7])
{
yCalculator.OverrunTime.Should().BeGreaterThan(xCalculator.OverrunTime);
}
else
{
yCalculator.OverrunTime.Should().BeLessOrEqualTo(xCalculator.OverrunTime);
}
if (scenario[8])
{
xCalculator.FinishTime.Should().BeGreaterThan(yCalculator.FinishTime);
}
else
{
xCalculator.FinishTime.Should().BeLessOrEqualTo(yCalculator.FinishTime);
}
if (scenario[9])
{
xCompetitor.Competitor.Number.Should().BeGreaterThan(yCompetitor.Competitor.Number);
}
else
{
xCompetitor.Competitor.Number.Should().BeLessOrEqualTo(yCompetitor.Competitor.Number);
}
if (scenario[10])
{
yCalculator.FinishTime.Should().BeGreaterThan(xCalculator.FinishTime);
}
else
{
yCalculator.FinishTime.Should().BeLessOrEqualTo(xCalculator.FinishTime);
}
if (scenario[11])
{
yCompetitor.Competitor.Number.Should().BeGreaterThan(xCompetitor.Competitor.Number);
}
else
{
yCompetitor.Competitor.Number.Should().BeLessOrEqualTo(xCompetitor.Competitor.Number);
}
}
public FakeCompetitionRunResult(CompetitionRunResult source, int fakeFaultCount)
: base(source.Competitor, source.Timings, fakeFaultCount, source.RefusalCount, source.IsEliminated, source.Placement)
{
}
public void RunExploded()
{
// Arrange
var runCompletionScenarios = new List <OrderingScenario>
{
// Bits: X HasFinished, X IsEliminated, Y HasFinished, Y IsEliminated
new(4, OrderingScenario.FromBits(0, 0, 0, 0), OrderExpect.IsEven),
new(4, OrderingScenario.FromBits(0, 0, 0, 1), OrderExpect.WinnerIsY),
new(4, OrderingScenario.FromBits(0, 0, 1, 0), OrderExpect.WinnerIsY),
new(4, OrderingScenario.FromBits(0, 0, 1, 1), OrderExpect.WinnerIsY),
new(4, OrderingScenario.FromBits(0, 1, 0, 0), OrderExpect.WinnerIsX),
new(4, OrderingScenario.FromBits(0, 1, 0, 1), OrderExpect.IsEven),
new(4, OrderingScenario.FromBits(0, 1, 1, 0), OrderExpect.WinnerIsY),
new(4, OrderingScenario.FromBits(0, 1, 1, 1), OrderExpect.WinnerIsY),
new(4, OrderingScenario.FromBits(1, 0, 0, 0), OrderExpect.WinnerIsX),
new(4, OrderingScenario.FromBits(1, 0, 0, 1), OrderExpect.WinnerIsX),
new(4, OrderingScenario.FromBits(1, 0, 1, 0), OrderExpect.IsEven),
new(4, OrderingScenario.FromBits(1, 0, 1, 1), OrderExpect.WinnerIsX),
new(4, OrderingScenario.FromBits(1, 1, 0, 0), OrderExpect.WinnerIsX),
new(4, OrderingScenario.FromBits(1, 1, 0, 1), OrderExpect.WinnerIsX),
new(4, OrderingScenario.FromBits(1, 1, 1, 0), OrderExpect.WinnerIsY),
new(4, OrderingScenario.FromBits(1, 1, 1, 1), OrderExpect.IsEven)
};
var penaltyOverrunScenarios = new List <OrderingScenario>
{
// Bits: PenaltyTime X > Y, OverrunTime X > Y, PenaltyTime Y > X, OverrunTime Y > X
new(4, OrderingScenario.FromBits(0, 0, 0, 0), OrderExpect.IsEven),
new(4, OrderingScenario.FromBits(0, 0, 0, 1), OrderExpect.WinnerIsY),
new(4, OrderingScenario.FromBits(0, 0, 1, 0), OrderExpect.WinnerIsX),
new(4, OrderingScenario.FromBits(0, 0, 1, 1), OrderExpect.WinnerIsX),
new(4, OrderingScenario.FromBits(0, 1, 0, 0), OrderExpect.WinnerIsX),
new(4, OrderingScenario.FromBits(0, 1, 0, 1), OrderExpect.DoNotCare),
new(4, OrderingScenario.FromBits(0, 1, 1, 0), OrderExpect.WinnerIsX),
new(4, OrderingScenario.FromBits(0, 1, 1, 1), OrderExpect.DoNotCare),
new(4, OrderingScenario.FromBits(1, 0, 0, 0), OrderExpect.WinnerIsY),
new(4, OrderingScenario.FromBits(1, 0, 0, 1), OrderExpect.WinnerIsY),
new(4, OrderingScenario.FromBits(1, 0, 1, 0), OrderExpect.DoNotCare),
new(4, OrderingScenario.FromBits(1, 0, 1, 1), OrderExpect.DoNotCare),
new(4, OrderingScenario.FromBits(1, 1, 0, 0), OrderExpect.WinnerIsY),
new(4, OrderingScenario.FromBits(1, 1, 0, 1), OrderExpect.DoNotCare),
new(4, OrderingScenario.FromBits(1, 1, 1, 0), OrderExpect.DoNotCare),
new(4, OrderingScenario.FromBits(1, 1, 1, 1), OrderExpect.DoNotCare)
};
var finishNumberScenarios = new List <OrderingScenario>
{
// Bits: FinishTime X > Y, CompetitorNumber X > Y, FinishTime Y > X, CompetitorNumber Y > X
new(4, OrderingScenario.FromBits(0, 0, 0, 0), OrderExpect.DoNotCare),
new(4, OrderingScenario.FromBits(0, 0, 0, 1), OrderExpect.WinnerIsX),
new(4, OrderingScenario.FromBits(0, 0, 1, 0), OrderExpect.DoNotCare),
new(4, OrderingScenario.FromBits(0, 0, 1, 1), OrderExpect.WinnerIsX),
new(4, OrderingScenario.FromBits(0, 1, 0, 0), OrderExpect.WinnerIsY),
new(4, OrderingScenario.FromBits(0, 1, 0, 1), OrderExpect.DoNotCare),
new(4, OrderingScenario.FromBits(0, 1, 1, 0), OrderExpect.WinnerIsX),
new(4, OrderingScenario.FromBits(0, 1, 1, 1), OrderExpect.DoNotCare),
new(4, OrderingScenario.FromBits(1, 0, 0, 0), OrderExpect.DoNotCare),
new(4, OrderingScenario.FromBits(1, 0, 0, 1), OrderExpect.WinnerIsY),
new(4, OrderingScenario.FromBits(1, 0, 1, 0), OrderExpect.DoNotCare),
new(4, OrderingScenario.FromBits(1, 0, 1, 1), OrderExpect.DoNotCare),
new(4, OrderingScenario.FromBits(1, 1, 0, 0), OrderExpect.WinnerIsY),
new(4, OrderingScenario.FromBits(1, 1, 0, 1), OrderExpect.DoNotCare),
new(4, OrderingScenario.FromBits(1, 1, 1, 0), OrderExpect.DoNotCare),
new(4, OrderingScenario.FromBits(1, 1, 1, 1), OrderExpect.DoNotCare)
};
IEnumerable <OrderingScenario> exploded = ExplodeCombinations(runCompletionScenarios, penaltyOverrunScenarios, finishNumberScenarios);
CompetitionClassModel model = new CompetitionClassModel()
.ChangeClassInfo(new CompetitionClassInfo()
.ChangeStandardCourseTime(StandardCourseTime));
var comparer = new CompetitionRunResultRankingComparer(model, RankingComparisonMode.Regular);
foreach (OrderingScenario scenario in exploded)
{
bool xHasFinished = scenario[0];
bool xIsEliminated = scenario[1];
bool yHasFinished = scenario[2];
bool yIsEliminated = scenario[3];
bool xPenaltyTimeIsGreater = scenario[4];
bool xOverrunTimeIsGreater = scenario[5];
bool yPenaltyTimeIsGreater = scenario[6];
bool yOverrunTimeIsGreater = scenario[7];
bool xFinishTimeIsGreater = scenario[8];
bool xCompetitorNumberIsGreater = scenario[9];
bool yFinishTimeIsGreater = scenario[10];
bool yCompetitorNumberIsGreater = scenario[11];
CompetitionRunResult xCompetitor = CreateCompetitorFor("X", xHasFinished, xIsEliminated, yHasFinished, xPenaltyTimeIsGreater,
xOverrunTimeIsGreater, yPenaltyTimeIsGreater, yOverrunTimeIsGreater, xFinishTimeIsGreater, xCompetitorNumberIsGreater, yFinishTimeIsGreater,
yCompetitorNumberIsGreater);
CompetitionRunResult yCompetitor = CreateCompetitorFor("Y", yHasFinished, yIsEliminated, xHasFinished, yPenaltyTimeIsGreater,
yOverrunTimeIsGreater, xPenaltyTimeIsGreater, xOverrunTimeIsGreater, yFinishTimeIsGreater, yCompetitorNumberIsGreater, xFinishTimeIsGreater,
xCompetitorNumberIsGreater);
AssertCompetitorsAreCompatibleWithProposedScenario(xCompetitor, yCompetitor, scenario, model);
// Act
int result = comparer.Compare(xCompetitor, yCompetitor);
// Assert
OrderExpect actual = TranslateComparerResult(result);
actual.Should().Be(scenario.Result, scenario.ToString());
}
}
