private static ulong CreateBitSequenceFor(OrderingScenario primaryScenario, OrderingScenario secondaryScenario, OrderingScenario tertiaryScenario)
{
ulong leftNibble = primaryScenario.Value << (tertiaryScenario.BitCount + secondaryScenario.BitCount);
ulong middleNibble = secondaryScenario.Value << tertiaryScenario.BitCount;
ulong rightNibble = tertiaryScenario.Value;
return(leftNibble | middleNibble | rightNibble);
}
private static bool IsImpossibleCombination(OrderingScenario scenario)
{
bool xHasFinished = scenario[0];
bool yHasFinished = scenario[2];
bool xPenaltyTimeIsGreater = scenario[4];
bool xOverrunTimeIsGreater = scenario[5];
bool yPenaltyTimeIsGreater = scenario[6];
bool yOverrunTimeIsGreater = scenario[7];
bool xFinishTimeIsGreater = scenario[8];
bool yFinishTimeIsGreater = scenario[10];
// Two competitors can never both have the same input greater than the other.
if ((xPenaltyTimeIsGreater && yPenaltyTimeIsGreater) || (xOverrunTimeIsGreater && yOverrunTimeIsGreater) ||
(xFinishTimeIsGreater && yFinishTimeIsGreater))
{
return(true);
}
// An unfinished competitor has finish time 0, so it cannot have a higher finish time.
if ((!yHasFinished && yFinishTimeIsGreater) || (!xHasFinished && xFinishTimeIsGreater))
{
return(true);
}
// An unfinished competitor has overrun time 0, so it cannot have a higher overrun time.
if ((!yHasFinished && yOverrunTimeIsGreater) || (!xHasFinished && xOverrunTimeIsGreater))
{
return(true);
}
// An unfinished competitor has penalty time 0, so it cannot have a higher penalty time.
if ((!yHasFinished && yPenaltyTimeIsGreater) || (!xHasFinished && xPenaltyTimeIsGreater))
{
return(true);
}
// Formula: OverrunTime = ( FinishTime - StandardCourseTime ) ranged [0, ->>
// Because StandardCourseTime is a constant, same finish time implies same overrun time.
bool hasSameFinishTime = !xFinishTimeIsGreater && !yFinishTimeIsGreater;
if (hasSameFinishTime && (yOverrunTimeIsGreater || xOverrunTimeIsGreater))
{
return(true);
}
if ((xFinishTimeIsGreater && yOverrunTimeIsGreater) || (yFinishTimeIsGreater && xOverrunTimeIsGreater))
{
// Because StandardCourseTime is a constant, greater finish time implies
// greater overrun time (or same when zero; lower is not possible).
return(true);
}
return(false);
}
private static OrderExpect CombineResult(OrderingScenario primaryScenario, OrderingScenario secondaryScenario, OrderingScenario tertiaryScenario)
{
if (primaryScenario.Result == OrderExpect.DoNotCare || secondaryScenario.Result == OrderExpect.DoNotCare ||
tertiaryScenario.Result == OrderExpect.DoNotCare)
{
return(OrderExpect.DoNotCare);
}
return(primaryScenario.Result != OrderExpect.IsEven
? primaryScenario.Result
: secondaryScenario.Result != OrderExpect.IsEven
? secondaryScenario.Result
: tertiaryScenario.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());
}
}
private static OrderingScenario?CreateCombinedScenario(OrderingScenario primaryScenario, OrderingScenario secondaryScenario,
OrderingScenario tertiaryScenario)
{
OrderExpect result = CombineResult(primaryScenario, secondaryScenario, tertiaryScenario);
if (result != OrderExpect.DoNotCare)
{
ulong sequence = CreateBitSequenceFor(primaryScenario, secondaryScenario, tertiaryScenario);
var combined = new OrderingScenario(12, sequence, result);
if (!IsImpossibleCombination(combined))
{
return(combined);
}
}
return(null);
}
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);
}
}
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 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 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());
}
}