public void Decode_MatrixWithOne1AndMany0_ReturnsListWithOneElement()
{
var deckMatrixProvider = new FakeGameProvider
{
Colors = new List <Color> {
Color.Blue, Color.Green, Color.Red
},
Ranks = new List <Rank> {
Rank.One, Rank.Two, Rank.Three
},
};
Matrix input = deckMatrixProvider.CreateEmptyMatrix();
input[new Card(Color.Green, Rank.Three)] = 1;
CardsToMatrixConverter converter = new CardsToMatrixConverter(deckMatrixProvider);
IReadOnlyList <Card> actual = converter.Decode(input);
Assert.AreEqual(1, actual.Count);
Card greenThree = new Card(Rank.Three, Color.Green);
Assert.AreEqual(greenThree, actual[0]);
}
public void Encode_WhiteOneCard_ReturnsMatrixWithOne()
{
// arrange
var deckMatrixProvider = new FakeGameProvider
{
Colors = new List <Color> {
Color.Yellow, Color.White
},
Ranks = new List <Rank> {
Rank.One, Rank.Two, Rank.Three
}
};
List <Card> list = new List <Card> {
new Card(Rank.One, Color.White)
};
CardsToMatrixConverter converter = new CardsToMatrixConverter(deckMatrixProvider);
// act
Matrix result = converter.Encode(list);
Matrix expected = deckMatrixProvider.CreateEmptyMatrix();
expected[new Card(Color.White, Rank.One)] = 1;
TestHelper.AreMatrixEqual(expected, result, deckMatrixProvider);
}
public void AddCard_AddWhiteTwoCardToWhiteFireworkWithLastTwo_ReturnsFalse()
{
IGameProvider provider = new FakeGameProvider()
{
Colors = new List <Color> {
Color.Green, Color.White
},
Ranks = new List <Rank> {
Rank.One, Rank.Two, Rank.Three
}
};
var firework = new FireworkPile(provider);
var whiteOneCard = new Card(Color.White, Rank.One);
var whiteTwoCard = new Card(Color.White, Rank.Two);
firework.AddCard(whiteOneCard);
firework.AddCard(whiteTwoCard);
var otherWhiteTwoCard = new Card(Color.White, Rank.Two);
var added = firework.AddCard(otherWhiteTwoCard);
Assert.IsFalse(added);
}
public void GetExpectedCards_FullFireworkPile_ReturnsEmptyList()
{
IGameProvider provider = new FakeGameProvider()
{
Colors = new List <Color> {
Color.Blue, Color.Green
},
Ranks = new List <Rank> {
Rank.One, Rank.Two
},
};
var fireworkPile = new FireworkPile(provider);
var blueOneCard = new Card(Color.Blue, Rank.One);
fireworkPile.AddCard(blueOneCard);
var blueTwoCard = new Card(Color.Blue, Rank.Two);
fireworkPile.AddCard(blueTwoCard);
var greenOneCard = new Card(Color.Green, Rank.One);
fireworkPile.AddCard(greenOneCard);
var greenTwoCard = new Card(Color.Green, Rank.Two);
fireworkPile.AddCard(greenTwoCard);
IReadOnlyList <Card> actual = fireworkPile.GetExpectedCards();
Assert.IsEmpty(actual);
}
public void AddCard_AddBlueFourCardToBlueFireworkWithLastThree_ReturnsTrue()
{
IGameProvider provider = new FakeGameProvider()
{
Colors = new List <Color> {
Color.Blue, Color.Red,
},
Ranks = new List <Rank> {
Rank.One, Rank.Two, Rank.Three, Rank.Four
}
};
var firework = new FireworkPile(provider);
var blueOneCard = new Card(Color.Blue, Rank.One);
var blueTwoCard = new Card(Color.Blue, Rank.Two);
var blueThreeCard = new Card(Color.Blue, Rank.Three);
firework.AddCard(blueOneCard);
firework.AddCard(blueTwoCard);
firework.AddCard(blueThreeCard);
var blueFourCard = new Card(Color.Blue, Rank.Four);
var isAdded = firework.AddCard(blueFourCard);
Assert.IsTrue(isAdded);
}
public void GetThrownCards_FireworkPileWithBlueOneAndDiscardPileWithBlueOne_ReturnsListWith2Elements()
{
//// arrange
// create fake deck that contains blue one cards only
FakeGameProvider provider = GameProviderFabric.Create(Color.Blue);
// play blue one card
var fireworkPile = new FireworkPile(provider);
fireworkPile.AddCard(new Card(Color.Blue, Rank.One));
// discard blue one card
var discardPile = new DiscardPile(provider);
discardPile.AddCard(new Card(Color.Blue, Rank.One));
GameProvider gameProvider = new GameProvider();
var pileAnalyzer = new PilesAnalyzer(gameProvider);
//// act
IReadOnlyList <Card> actual = pileAnalyzer.GetThrownCards(fireworkPile, discardPile);
Assert.AreEqual(2, actual.Count);
}
public void Encode_TwoRedFourCard_ReturnsMatrixWithZerosAndTwo()
{
// arrange
var deckMatrixProvider = new FakeGameProvider()
{
Colors = new List <Color>()
{
Color.Yellow, Color.Red
},
Ranks = new List <Rank>()
{
Rank.One, Rank.Two, Rank.Three, Rank.Four
},
};
List <Card> list = new List <Card>
{
new Card(Rank.Four, Color.Red),
new Card(Rank.Four, Color.Red),
};
CardsToMatrixConverter converter = new CardsToMatrixConverter(deckMatrixProvider);
// act
Matrix result = converter.Encode(list);
// assert
Matrix expected = deckMatrixProvider.CreateEmptyMatrix();
expected[new Card(Rank.Four, Color.Red)] = 2;
TestHelper.AreMatrixEqual(expected, result, deckMatrixProvider);
}
public void GetThrownCards_FireworkPileWithBlueOneAndDiscardPileWithBlueOne_ReturnsListWithBlueOnesOnly()
{
//// arrange
FakeGameProvider gameProvider =
GameProviderFabric.Create(new List <Color> {
Color.Blue, Color.Red
}.AsReadOnly());
// play blue one card
var fireworkPile = new FireworkPile(gameProvider);
fireworkPile.AddCard(new Card(Color.Blue, Rank.One));
// discard blue one card
var discardPile = new DiscardPile(gameProvider);
discardPile.AddCard(new Card(Color.Blue, Rank.One));
var pileAnalyzer = new PilesAnalyzer(gameProvider);
//// act
IReadOnlyList <Card> actual = pileAnalyzer.GetThrownCards(fireworkPile, discardPile);
Assert.IsTrue(actual.Count > 0 &&
actual.All(card => Equals(card, new Card(Color.Blue, Rank.One))));
}
public void Game_MoreThen5Players_ThrowsArgumentOutOfRangeException(int playersCount)
{
IGameProvider provider = new FakeGameProvider();
var exception = Assert.Throws <ArgumentOutOfRangeException>(
() => new Game(provider, playersCount));
StringAssert.Contains("Too many players", exception.Message);
}
public void GetProbability_EmptyCardsToSearch_ReturnsZero()
{
FakeGameProvider gameProvider = GameProviderFabric.Create(Color.Red);
Guess guess = new Guess(gameProvider,
CreateCardInHand(gameProvider, new Card(Color.Red, Rank.One)));
List <Card> excludedCards = new List <Card>();
List <Card> cardsToSearch = new List <Card>();
Probability result = guess.GetProbability(cardsToSearch, excludedCards);
Assert.AreEqual(0, result.Value);
}
public void Game_CorrectNumberOfPlayers_NotThrowsException(int playersCount)
{
FakeGameProvider provider = new FakeGameProvider
{
Colors = new List <Color> {
Color.Blue
},
Ranks = new List <Rank> {
Rank.One
}
};
provider.FullDeckMatrix = provider.CreateEmptyMatrix();
new Game(provider, playersCount);
Assert.Pass();
}
public void Game_Default_ZeroScore()
{
FakeGameProvider provider = new FakeGameProvider
{
Colors = new List <Color> {
Color.Blue
},
Ranks = new List <Rank> {
Rank.One
}
};
provider.FullDeckMatrix = provider.CreateEmptyMatrix();
Game game = new Game(provider, 2);
Assert.AreEqual(0, game.Score);
}
public void AddCard_AddGreenOneToEmptyFireworkPile_ReturnsTrue()
{
IGameProvider provider = new FakeGameProvider()
{
Colors = new List <Color> {
Color.Green, Color.Red
},
Ranks = new List <Rank> {
Rank.One, Rank.Two
}
};
var pile = new FireworkPile(provider);
var greenOneCard = new Card(Color.Green, Rank.One);
var added = pile.AddCard(greenOneCard);
Assert.IsTrue(added);
}
public void GetLastCards_Default_ReturnsEmptyList()
{
IGameProvider provider = new FakeGameProvider()
{
Colors = new List <Color> {
Color.Blue, Color.Green, Color.Red, Color.White, Color.Yellow
},
Ranks = new List <Rank> {
Rank.One, Rank.Two
},
};
var pile = new FireworkPile(provider);
var nextCards = pile.GetLastCards();
Assert.IsEmpty(nextCards);
}
public void AddCard_AddWhiteTwoToEmptyFireworkPile_ReturnsFalse()
{
IGameProvider provider = new FakeGameProvider()
{
Colors = new List <Color> {
Color.Green, Color.Red, Color.White
},
Ranks = new List <Rank> {
Rank.One, Rank.Two
}
};
var pile = new FireworkPile(provider);
var whiteTwoCard = new Card(Color.White, Rank.Two);
var added = pile.AddCard(whiteTwoCard);
Assert.IsFalse(added);
}
public void GetExpectedCards_EmptyFireworkPile_ReturnsListWithFiveElements()
{
IGameProvider provider = new FakeGameProvider()
{
Colors = new List <Color> {
Color.Blue, Color.Green, Color.Red, Color.White, Color.Yellow
},
Ranks = new List <Rank> {
Rank.One
}
};
var fireworkPile = new FireworkPile(provider);
IReadOnlyList <Card> actual = fireworkPile.GetExpectedCards();
Assert.AreEqual(5, actual.Count);
}
public void AddCard_Always_ReturnsTrue()
{
IGameProvider provider = new FakeGameProvider()
{
Colors = new List <Color>()
{
Color.Blue, Color.Green, Color.Red, Color.White
},
Ranks = new List <Rank> {
Rank.One, Rank.Two, Rank.Three, Rank.Four
},
};
var discardPile = new DiscardPile(provider);
var blueThreeCard = new Card(Color.Blue, Rank.Three);
bool added = discardPile.AddCard(blueThreeCard);
Assert.IsTrue(added);
}
public void Encode_ZeroCards_ReturnsZeroMatrix()
{
var deckMatrixProvider = new FakeGameProvider
{
Colors = new List <Color> {
Color.Blue, Color.Green, Color.Red
},
Ranks = new List <Rank> {
Rank.One, Rank.Two, Rank.Three,
}
};
Matrix emptyMatrix = deckMatrixProvider.CreateEmptyMatrix();
CardsToMatrixConverter converter = new CardsToMatrixConverter(deckMatrixProvider);
Matrix result = converter.Encode(new List <Card>());
TestHelper.AreMatrixEqual(emptyMatrix, result, deckMatrixProvider);
}
public void GetCardsWhateverToPlay_DiscardedAllWhiteOne_DoesNotContainWhiteCards()
{
FakeGameProvider provider = GameProviderFabric.Create(new List <Color> {
Color.White, Color.Red
});
var fireworkPile = new FireworkPile(provider);
var discardPile = new DiscardPile(provider);
discardPile.AddCard(new Card(Color.White, Rank.One));
discardPile.AddCard(new Card(Color.White, Rank.One));
discardPile.AddCard(new Card(Color.White, Rank.One));
GameProvider gameProvider = new GameProvider();
var pileAnalyzer = new PilesAnalyzer(gameProvider);
IReadOnlyList <Card> actual = pileAnalyzer.GetCardsWhateverToPlay(fireworkPile, discardPile);
Assert.IsTrue(actual.All(card => card.Color != Color.White));
}
public void Decode_ZeroMatrix_ReturnsEmptyList()
{
var deckMatrixProvider = new FakeGameProvider
{
Colors = new List <Color> {
Color.Blue, Color.Red, Color.Green
},
Ranks = new List <Rank> {
Rank.One, Rank.Two, Rank.Three
}
};
Matrix zeroMatrix = deckMatrixProvider.CreateEmptyMatrix();
CardsToMatrixConverter converter = new CardsToMatrixConverter(deckMatrixProvider);
IReadOnlyList <Card> actual = converter.Decode(zeroMatrix);
Assert.IsEmpty(actual);
}
public void GetProbability_ExcludeAllRedTwoCards_ReturnsZeroForRedTwoCard()
{
FakeGameProvider gameProvider = GameProviderFabric.Create(Color.Red);
Guess guess = new Guess(gameProvider,
CreateCardInHand(gameProvider, new Card(Color.Red, Rank.Three)));
List <Card> excludedCards = new List <Card>
{
new Card(Color.Red, Rank.Two),
new Card(Color.Red, Rank.Two),
};
List <Card> cardsToSearch = new List <Card> {
new Card(Color.Red, Rank.Two)
};
Probability result = guess.GetProbability(cardsToSearch, excludedCards);
Assert.AreEqual(0, result.Value);
}
public static FakeGameProvider Create(IEnumerable <Color> colors)
{
FakeGameProvider gameProvider = new FakeGameProvider
{
Colors = colors.ToList(),
Ranks = new List <Rank> {
Rank.One, Rank.Two, Rank.Three, Rank.Four, Rank.Five
}
};
gameProvider.FullDeckMatrix = gameProvider.CreateEmptyMatrix();
foreach (var color in colors)
{
gameProvider.FullDeckMatrix[Rank.One, color] = 3;
gameProvider.FullDeckMatrix[Rank.Two, color] = 2;
gameProvider.FullDeckMatrix[Rank.Three, color] = 2;
gameProvider.FullDeckMatrix[Rank.Four, color] = 2;
gameProvider.FullDeckMatrix[Rank.Five, color] = 1;
}
return(gameProvider);
}
public void GetLastCards_FireworkWithGreenOneCard_ReturnsOneForGreenColor()
{
IGameProvider provider = new FakeGameProvider()
{
Colors = new List <Color> {
Color.Green, Color.Blue
},
Ranks = new List <Rank> {
Rank.One, Rank.Two
},
};
var pile = new FireworkPile(provider);
var greenOneCard = new Card(Color.Green, Rank.One);
pile.AddCard(greenOneCard);
var lastCards = pile.GetLastCards();
var otherGreenOneCard = new Card(Color.Green, Rank.One);
Assert.Greater(lastCards.Count, 0);
Assert.That(lastCards.Any(card => card.Equals(otherGreenOneCard)));
}
public void GetExpectedCards_FireworkPileWithFullRedFirework_ReturnsListWithoutRedCards()
{
IGameProvider provider = new FakeGameProvider()
{
Colors = new List <Color> {
Color.Red, Color.Blue
},
Ranks = new List <Rank> {
Rank.One, Rank.Two, Rank.Three, Rank.Four, Rank.Five
},
};
var fireworkPile = new FireworkPile(provider);
fireworkPile.AddCard(new Card(Color.Red, Rank.One));
fireworkPile.AddCard(new Card(Color.Red, Rank.Two));
fireworkPile.AddCard(new Card(Color.Red, Rank.Three));
fireworkPile.AddCard(new Card(Color.Red, Rank.Four));
fireworkPile.AddCard(new Card(Color.Red, Rank.Five));
IReadOnlyList <Card> actual = fireworkPile.GetExpectedCards();
Assert.IsTrue(actual.All(card => card.Color != Color.Red));
}
public void GetExpectedCards_BlueFireworkWithLastFour_ReturnsListWithBlueFive()
{
IGameProvider provider = new FakeGameProvider()
{
Colors = new List <Color> {
Color.Blue
},
Ranks = new List <Rank> {
Rank.One, Rank.Two, Rank.Three, Rank.Four, Rank.Five
}
};
var fireworkPile = new FireworkPile(provider);
fireworkPile.AddCard(new Card(Color.Blue, Rank.One));
fireworkPile.AddCard(new Card(Color.Blue, Rank.Two));
fireworkPile.AddCard(new Card(Color.Blue, Rank.Three));
fireworkPile.AddCard(new Card(Color.Blue, Rank.Four));
var expectedCards = fireworkPile.GetExpectedCards();
var blueFiveCard = new Card(Color.Blue, Rank.Five);
Assert.That(expectedCards.Any(card => card.Equals(blueFiveCard)));
}
public void GetExpectedCards_FullBlueFirework_ReturnsNullForBlueColor()
{
IGameProvider provider = new FakeGameProvider()
{
Colors = new List <Color> {
Color.Blue, Color.White
},
Ranks = new List <Rank> {
Rank.One, Rank.Two, Rank.Three, Rank.Four, Rank.Five
},
};
var pile = new FireworkPile(provider);
pile.AddCard(new Card(Color.Blue, Rank.One));
pile.AddCard(new Card(Color.Blue, Rank.Two));
pile.AddCard(new Card(Color.Blue, Rank.Three));
pile.AddCard(new Card(Color.Blue, Rank.Four));
pile.AddCard(new Card(Color.Blue, Rank.Five));
var nextCards = pile.GetExpectedCards();
Assert.That(nextCards.All(card => card.Color != Color.Blue));
}
