private void RegisterFirstTwoPlayers()
{
firstPlayerReference = tournament.RegisterPlayerReference(firstPlayerName);
secondPlayerReference = tournament.RegisterPlayerReference(secondPlayerName);
bracketGroup = bracketRound.Groups.First() as BracketGroup;
match = bracketGroup.Matches.First();
}
public void IssueIsReportedWhenStartDateTimeForMatchIsSetEarlierThanAnyMatchInPreviousRound()
{
List <string> playerNames = new List <string>()
{
"Maru", "Stork", "Taeja", "Rain", "Bomber", "FanTaSy", "Stephano", "Thorzain"
};
bracketRound.SetPlayersPerGroupCount(4);
BracketRound secondBracketRound = tournament.AddBracketRound() as BracketRound;
foreach (string playerName in playerNames)
{
tournament.RegisterPlayerReference(playerName);
}
BracketGroup bracketGroup = bracketRound.Groups.First() as BracketGroup;
BracketNode finalNodeFromFirstRound = bracketGroup.BracketNodeSystem.FinalNode;
BracketGroup bracketGroupFromSecondRound = secondBracketRound.Groups.First() as BracketGroup;
BracketNode finalNodeFromSecondRound = bracketGroupFromSecondRound.BracketNodeSystem.FinalNode;
Match finalFromFirstRound = finalNodeFromFirstRound.Match;
Match finalFromSecondRound = finalNodeFromSecondRound.Match;
DateTime oneHourBeforeFinalFromFirstRound = finalFromFirstRound.StartDateTime.AddHours(-1);
bool validationResult = MatchStartDateTimeValidator.Validate(finalFromSecondRound, oneHourBeforeFinalFromFirstRound);
validationResult.Should().BeTrue();
tournamentIssueReporter.Issues.Should().HaveCount(1);
}
public void NoIssueIsReportedWhenStartDateTimeOnMatchesWithinATierIsUnordered()
{
List <string> playerNames = new List <string>()
{
"Maru", "Stork", "Taeja", "Rain", "Bomber", "FanTaSy", "Stephano", "Thorzain"
};
bracketRound.SetPlayersPerGroupCount(playerNames.Count);
foreach (string playerName in playerNames)
{
tournament.RegisterPlayerReference(playerName);
}
BracketGroup bracketGroup = bracketRound.Groups.First() as BracketGroup;
List <BracketNode> quarterfinalTier = bracketGroup.BracketNodeSystem.GetBracketNodesInTier(2);
DateTime twoHoursEarlier = quarterfinalTier[0].Match.StartDateTime.AddHours(-2);
DateTime threeHoursEarlier = quarterfinalTier[1].Match.StartDateTime.AddHours(-3);
DateTime oneHourEarlier = quarterfinalTier[2].Match.StartDateTime.AddHours(-1);
DateTime twoHoursLater = quarterfinalTier[3].Match.StartDateTime.AddHours(2);
quarterfinalTier[0].Match.SetStartDateTime(twoHoursEarlier);
quarterfinalTier[1].Match.SetStartDateTime(threeHoursEarlier);
quarterfinalTier[2].Match.SetStartDateTime(oneHourEarlier);
quarterfinalTier[3].Match.SetStartDateTime(twoHoursLater);
quarterfinalTier[0].Match.StartDateTime.Should().Be(twoHoursEarlier);
quarterfinalTier[1].Match.StartDateTime.Should().Be(threeHoursEarlier);
quarterfinalTier[2].Match.StartDateTime.Should().Be(oneHourEarlier);
quarterfinalTier[3].Match.StartDateTime.Should().Be(twoHoursLater);
tournamentIssueReporter.Issues.Should().BeEmpty();
}
public void CreatesMatchTierListWhenBracketMatchesAreAdded()
{
List <string> playerNames = new List <string>()
{
"Maru", "Stork", "Taeja", "Rain", "Bomber", "FanTaSy", "Stephano"
};
bracketRound.SetPlayersPerGroupCount(playerNames.Count);
foreach (string playerName in playerNames)
{
tournament.RegisterPlayerReference(playerName);
}
bracketGroup = bracketRound.Groups.First() as BracketGroup;
bracketGroup.BracketNodeSystem.TierCount.Should().Be(3);
List <BracketNode> finalTier = bracketGroup.BracketNodeSystem.GetBracketNodesInTier(0);
List <BracketNode> semifinalTier = bracketGroup.BracketNodeSystem.GetBracketNodesInTier(1);
List <BracketNode> quarterfinalTier = bracketGroup.BracketNodeSystem.GetBracketNodesInTier(2);
finalTier.Count.Should().Be(1);
finalTier[0].Match.Should().Be(bracketGroup.Matches[5]);
semifinalTier.Count.Should().Be(2);
semifinalTier[0].Match.Should().Be(bracketGroup.Matches[4]);
semifinalTier[1].Match.Should().Be(bracketGroup.Matches[3]);
quarterfinalTier.Count.Should().Be(3);
quarterfinalTier[0].Match.Should().Be(bracketGroup.Matches[2]);
quarterfinalTier[1].Match.Should().Be(bracketGroup.Matches[1]);
quarterfinalTier[2].Match.Should().Be(bracketGroup.Matches[0]);
}
public void IssueIsReportedWhenStartDateTimeForMatchIsEarlierThanAnyParentMatch()
{
List <string> playerNames = new List <string>()
{
"Maru", "Stork", "Taeja", "Rain", "Bomber", "FanTaSy", "Stephano", "Thorzain"
};
bracketRound.SetPlayersPerGroupCount(playerNames.Count);
foreach (string playerName in playerNames)
{
tournament.RegisterPlayerReference(playerName);
}
BracketGroup bracketGroup = bracketRound.Groups.First() as BracketGroup;
BracketNode finalNode = bracketGroup.BracketNodeSystem.FinalNode;
Match final = finalNode.Match;
Match firstSemifinal = finalNode.Children[0].Match;
Match secondSemifinal = finalNode.Children[1].Match;
DateTime oneHourBeforeFirstSemifinal = firstSemifinal.StartDateTime.AddHours(-1);
DateTime oneHourBeforeSecondSemifinal = secondSemifinal.StartDateTime.AddHours(-1);
final.SetStartDateTime(oneHourBeforeFirstSemifinal);
final.StartDateTime.Should().Be(oneHourBeforeFirstSemifinal);
final.SetStartDateTime(oneHourBeforeSecondSemifinal);
final.StartDateTime.Should().Be(oneHourBeforeSecondSemifinal);
tournamentIssueReporter.Issues.Should().HaveCount(2);
}
public MatchTests()
{
tournament = Tournament.Create("GSL 2019");
bracketRound = tournament.AddBracketRound() as BracketRound;
tournament.RegisterPlayerReference(firstPlayerName);
tournament.RegisterPlayerReference(secondPlayerName);
bracketGroup = bracketRound.Groups.First() as BracketGroup;
match = bracketGroup.Matches.First();
}
public MatchBetTests()
{
user = User.Create("Stålberto");
tournament = Tournament.Create("GSL 2019");
better = tournament.AddBetter(user);
round = tournament.AddBracketRound() as BracketRound;
tournament.RegisterPlayerReference("Maru");
tournament.RegisterPlayerReference("Stork");
group = round.Groups.First() as BracketGroup;
firstMatch = group.Matches.First();
}
public void MatchStartDateTimeCannotBeChangedToSometimeInThePast()
{
BracketGroup bracketGroup = bracketRound.Groups.First() as BracketGroup;
Match match = bracketGroup.Matches.First();
DateTime oneHourInThePast = SystemTime.Now.AddSeconds(-1);
bool validationResult = MatchStartDateTimeValidator.Validate(match, oneHourInThePast);
validationResult.Should().BeFalse();
tournamentIssueReporter.Issues.Should().HaveCount(1);
}
public void CanCreateGroup()
{
BracketGroup bracketGroup = BracketGroup.Create(bracketRound);
bracketGroup.Should().NotBeNull();
bracketGroup.Id.Should().NotBeEmpty();
bracketGroup.Matches.Should().BeEmpty();
bracketGroup.RoundId.Should().Be(bracketRound.Id);
bracketGroup.Round.Should().Be(bracketRound);
bracketGroup.BracketNodeSystem.Should().BeNull();
}
public PlayerInBracketGroupTests()
{
tournament = Tournament.Create("GSL 2019");
round = tournament.AddBracketRound();
round.SetAdvancingPerGroupCount(1);
round.SetPlayersPerGroupCount(4);
foreach (string playerName in playerNames)
{
tournament.RegisterPlayerReference(playerName);
}
group = round.Groups.First() as BracketGroup;
match = group.Matches.First();
match.SetBestOf(5);
player = match.Player1;
}
public void CanConstructBracketLayoutWithEvenPlayers()
{
List <string> playerNames = new List <string>()
{
"Maru", "Stork", "Taeja", "Rain", "Bomber", "FanTaSy", "Stephano", "Thorzain"
};
bracketRound.SetPlayersPerGroupCount(playerNames.Count);
foreach (string playerName in playerNames)
{
tournament.RegisterPlayerReference(playerName);
}
BracketGroup bracketGroup = bracketRound.Groups.First() as BracketGroup;
bracketGroup.Matches.Should().HaveCount(playerNames.Count - 1);
foreach (Match match in bracketGroup.Matches)
{
match.Should().NotBeNull();
}
bracketGroup.Matches[0].Player1.GetName().Should().Be(playerNames[0]);
bracketGroup.Matches[0].Player2.GetName().Should().Be(playerNames[1]);
bracketGroup.Matches[1].Player1.GetName().Should().Be(playerNames[2]);
bracketGroup.Matches[1].Player2.GetName().Should().Be(playerNames[3]);
bracketGroup.Matches[2].Player1.GetName().Should().Be(playerNames[4]);
bracketGroup.Matches[2].Player2.GetName().Should().Be(playerNames[5]);
bracketGroup.Matches[3].Player1.GetName().Should().Be(playerNames[6]);
bracketGroup.Matches[3].Player2.GetName().Should().Be(playerNames[7]);
bracketGroup.Matches[4].Player1.PlayerReferenceId.Should().BeEmpty();
bracketGroup.Matches[4].Player2.PlayerReferenceId.Should().BeEmpty();
bracketGroup.Matches[5].Player1.PlayerReferenceId.Should().BeEmpty();
bracketGroup.Matches[5].Player2.PlayerReferenceId.Should().BeEmpty();
bracketGroup.Matches[6].Player1.PlayerReferenceId.Should().BeEmpty();
bracketGroup.Matches[6].Player2.PlayerReferenceId.Should().BeEmpty();
}
public void CannotSwitchPlacesOnPlayerReferenceWhenAnyPlayerIsNull()
{
bracketRound.SetPlayersPerGroupCount(4);
PlayerReference maruPlayerReference = tournament.RegisterPlayerReference("Maru");
PlayerReference storkPlayerReference = tournament.RegisterPlayerReference("Stork");
PlayerReference taejaPlayerReference = tournament.RegisterPlayerReference("Taeja");
BracketGroup group = bracketRound.Groups.First() as BracketGroup;
Match firstMatch = group.Matches[0];
Match secondMatch = group.Matches[1];
bool result = PlayerSwitcher.SwitchMatchesOn(firstMatch.Player1, secondMatch.Player2);
result.Should().BeFalse();
firstMatch.Player1.PlayerReferenceId.Should().Be(maruPlayerReference.Id);
firstMatch.Player2.PlayerReferenceId.Should().Be(storkPlayerReference.Id);
secondMatch.Player1.PlayerReferenceId.Should().Be(taejaPlayerReference.Id);
secondMatch.Player2.PlayerReferenceId.Should().BeEmpty();
}
public void CanConstructBracketNodeSystemWithUnevenPlayers()
{
List <string> playerNames = new List <string>()
{
"Maru", "Stork", "Taeja", "Rain", "Bomber", "FanTaSy", "Stephano"
};
bracketRound.SetPlayersPerGroupCount(playerNames.Count);
foreach (string playerName in playerNames)
{
tournament.RegisterPlayerReference(playerName);
}
bracketGroup = bracketRound.Groups.First() as BracketGroup;
BracketNode finalNode = bracketGroup.BracketNodeSystem.FinalNode;
ValidateBracketNodeConnections(finalNode, null, bracketGroup.Matches[4], bracketGroup.Matches[3]);
BracketNode semifinalNode1 = finalNode.Children[0];
BracketNode semifinalNode2 = finalNode.Children[1];
ValidateBracketNodeConnections(semifinalNode1, bracketGroup.Matches[5], bracketGroup.Matches[2], bracketGroup.Matches[1]);
ValidateBracketNodeConnections(semifinalNode2, bracketGroup.Matches[5], bracketGroup.Matches[0], null);
BracketNode quarterfinalNode1 = semifinalNode1.Children[0];
BracketNode quarterfinalNode2 = semifinalNode1.Children[1];
BracketNode quarterfinalNode3 = semifinalNode2.Children[0];
BracketNode quarterfinalNode4 = semifinalNode2.Children[1];
ValidateBracketNodeConnections(quarterfinalNode1, bracketGroup.Matches[4], null, null);
ValidateBracketNodeConnections(quarterfinalNode2, bracketGroup.Matches[4], null, null);
ValidateBracketNodeConnections(quarterfinalNode3, bracketGroup.Matches[3], null, null);
quarterfinalNode4.Should().BeNull();
}
protected override GroupBase AddGroup()
{
return(BracketGroup.Create(this));
}
private IEnumerable <ITagSpan <TextMarkerTag> > MatchBackward(BracketGroup group, SnapshotPoint startPoint)
{
ITextSnapshotLine line = startPoint.GetContainingLine();
int lineLength = startPoint.Position - line.Start.Position;
int lineNumber = line.LineNumber;
int nest = 0;
Stack <IMappingTagSpan <LexTag> > tags = new Stack <IMappingTagSpan <LexTag> >();
while (true)
{
var span = new SnapshotSpan(line.Start, lineLength);
if (lineLength > 0)
{
foreach (var tagSpan in _aggregator.GetTags(span))
{
tags.Push(tagSpan);
}
}
while (tags.Count > 0)
{
var tagSpan = tags.Pop();
var tagType = tagSpan.Tag.type;
if (_bracketTokens.ContainsKey(tagType))
{
Tuple <BracketSide, BracketGroup> bracket = _bracketTokens[tagType];
if (bracket.Item2 == group)
{
switch (bracket.Item1)
{
case BracketSide.Start:
if (nest == 0)
{
yield return(Mark(tagSpan, span));
yield break;
}
nest--;
break;
case BracketSide.Intermediate:
if (nest == 0)
{
yield return(Mark(tagSpan, span));
}
break;
case BracketSide.End:
nest++;
break;
}
}
}
}
if (lineNumber == 0)
{
yield break;
}
lineNumber--;
line = line.Snapshot.GetLineFromLineNumber(lineNumber);
lineLength = line.Length;
tags.Clear();
}
}
private IEnumerable <ITagSpan <TextMarkerTag> > MatchForward(BracketSide side, BracketGroup group, SnapshotPoint startPoint)
{
ITextSnapshotLine line = startPoint.GetContainingLine();
int lineOffset = startPoint.Position - line.Start.Position;
int nest = (side == BracketSide.Start) ? -1 : 0;
for (int lineNumber = line.LineNumber; lineNumber < _buffer.CurrentSnapshot.LineCount; lineNumber++)
{
line = line.Snapshot.GetLineFromLineNumber(lineNumber);
var span = new SnapshotSpan(line.Start + lineOffset, line.Length - lineOffset);
foreach (var tagSpan in _aggregator.GetTags(span))
{
var tagType = tagSpan.Tag.type;
if (_bracketTokens.ContainsKey(tagType))
{
Tuple <BracketSide, BracketGroup> bracket = _bracketTokens[tagType];
if (bracket.Item2 == group)
{
switch (bracket.Item1)
{
case BracketSide.Start:
if (nest < 0)
{
yield return(Mark(tagSpan, span));
}
nest++;
break;
case BracketSide.Intermediate:
if (nest == 0)
{
yield return(Mark(tagSpan, span));
}
break;
case BracketSide.End:
if (nest == 0)
{
yield return(Mark(tagSpan, span));
yield break;
}
nest--;
break;
}
}
}
}
lineOffset = 0;
}
}
