public void Clone_SingleHandWithSeed_ShouldReturnExactHand()
{
OmahaHiLoHand hand = new OmahaHiLoHand();
hand.Seed = 1;
var mock1 = new Mock<OmahaPlayer>();
mock1.Setup(p => p.Act()).Returns(PokerAction.CreateCallAction());
var mock2 = new Mock<OmahaPlayer>();
mock2.Setup(p => p.Act()).Returns(PokerAction.CreateCallAction());
hand.Sit(mock1.Object, 3, 1000);
hand.Sit(mock2.Object, 4, 1000);
OmahaHiLoHand cloned = (OmahaHiLoHand)hand.Clone();
HandResult hr1 = hand.RunToEnd();
HandResult hr2 = cloned.RunToEnd();
Assert.AreEqual(hr1.Winners[0].Player.HoleCards, hr2.Winners[0].Player.HoleCards);
}
public void Stand_TwoPlayersSeated_StandupTwoPlayersPlayerCountIsZero()
{
OmahaHiLoHand hand = new OmahaHiLoHand();
var mock1 = new Mock<OmahaPlayer>();
var mock2 = new Mock<OmahaPlayer>();
mock1.Setup(p => p.Act()).Returns(PokerAction.CreateCallAction());
mock2.Setup(p => p.Act()).Returns(PokerAction.CreateCallAction());
hand.Sit(mock1.Object, 0, 1000);
hand.Sit(mock2.Object, 1, 1000);
hand.Stand(mock1.Object);
hand.Stand(mock2.Object);
Assert.AreEqual(0, hand.PlayerCount);
}
public void Sit_SitMaxPlayers_VerifyPlayerCoundEqualsMaxPlayers()
{
OmahaHiLoHand hand = new OmahaHiLoHand();
int maxPlayers = 10;
var mock = new Mock<OmahaPlayer>();
mock.Setup(p => p.Act()).Returns(PokerAction.CreateCallAction());
for (int i = 0; i < maxPlayers; i++)
{
hand.Sit(mock.Object, i, 1000);
}
Assert.AreEqual(maxPlayers, hand.PlayerCount);
}
public void Sit_SitDifferentPlayersAtSameSeat_VerifiesThrowsException()
{
OmahaHiLoHand hand = new OmahaHiLoHand();
var mock1 = new Mock<OmahaPlayer>();
var mock2 = new Mock<OmahaPlayer>();
mock1.Setup(p => p.Act()).Returns(PokerAction.CreateCallAction());
mock2.Setup(p => p.Act()).Returns(PokerAction.CreateFoldAction());
hand.Sit(mock1.Object, 0, 1000);
hand.Sit(mock2.Object, 0, 1000);
}
public void RunToEnd_TwoPlayers_PlayerShouldReceiveShowdownEvent()
{
OmahaHiLoHand hand = new OmahaHiLoHand();
var mock1 = new Mock<OmahaPlayer>();
var mock2 = new Mock<OmahaPlayer>();
mock1.Setup(p => p.Act()).Returns(PokerAction.CreateCallAction()).Verifiable();
mock1.Setup(p => p.ShowdownEvent(0, It.Is<Card[]>(c => IsValidHand(c)))).Verifiable();
mock1.Setup(p => p.ShowdownEvent(1, It.Is<Card[]>(c => IsValidHand(c)))).Verifiable();
mock2.Setup(p => p.Act()).Returns(PokerAction.CreateCallAction()).Verifiable();
mock2.Setup(p => p.ShowdownEvent(0, It.Is<Card[]>(c => IsValidHand(c)))).Verifiable();
mock2.Setup(p => p.ShowdownEvent(1, It.Is<Card[]>(c => IsValidHand(c)))).Verifiable();
hand.Sit(mock1.Object, 0, 1000);
hand.Sit(mock2.Object, 1, 1000);
hand.RunToEnd();
mock1.Verify();
mock2.Verify();
}
public void RunToEnd_TwoPlayers_PlayerShouldReceiveWinEvent()
{
OmahaHiLoHand hand = new OmahaHiLoHand();
var mock1 = new Mock<OmahaPlayer>();
var mock2 = new Mock<OmahaPlayer>();
mock1.Setup(p => p.Act()).Returns(PokerAction.CreateCallAction()).Verifiable();
mock1.Setup(p => p.WinEvent(0, It.Is<long>(w => w > 0))).Verifiable();
mock2.Setup(p => p.Act()).Returns(PokerAction.CreateFoldAction()).Verifiable();
mock2.Setup(p => p.WinEvent(0, It.Is<long>(w => w > 0))).Verifiable();
hand.Sit(mock1.Object, 0, 1000);
hand.Sit(mock2.Object, 1, 1000);
hand.RunToEnd();
mock1.Verify();
mock2.Verify();
}
public void RunToEnd_TwoPlayers_PlayerShouldReceiveGameInfoWithTwoPlayers()
{
OmahaHiLoHand hand = new OmahaHiLoHand();
var mock1 = new Mock<OmahaPlayer>();
var mock2 = new Mock<OmahaPlayer>();
mock1.Setup(p => p.Act()).Returns(PokerAction.CreateCallAction()).Verifiable();
mock1.Setup(p => p.GameStartEvent(It.Is<IGameInfo>(g => g.NumberOfLivePlayersHand == 2))).Verifiable();
mock2.Setup(p => p.Act()).Returns(PokerAction.CreateCallAction()).Verifiable();
mock2.Setup(p => p.GameStartEvent(It.Is<IGameInfo>(g => g.NumberOfLivePlayersHand == 2))).Verifiable();
hand.Sit(mock1.Object, 0, 1000);
hand.Sit(mock2.Object, 1, 1000);
hand.RunToEnd();
mock1.Verify();
mock2.Verify();
}
public void RunToEnd_TwoPlayers_PlayerShouldReceiveRoundChanged()
{
OmahaHiLoHand hand = new OmahaHiLoHand();
var mock1 = new Mock<OmahaPlayer>();
var mock2 = new Mock<OmahaPlayer>();
mock1.Setup(p => p.Act()).Returns(PokerAction.CreateCallAction()).Verifiable();
mock1.Setup(p => p.RoundChanged(1)).Verifiable();
mock1.Setup(p => p.RoundChanged(2)).Verifiable();
mock1.Setup(p => p.RoundChanged(3)).Verifiable();
mock2.Setup(p => p.Act()).Returns(PokerAction.CreateCallAction()).Verifiable();
mock2.Setup(p => p.RoundChanged(1)).Verifiable();
mock2.Setup(p => p.RoundChanged(2)).Verifiable();
mock2.Setup(p => p.RoundChanged(3)).Verifiable();
hand.Sit(mock1.Object, 0, 1000);
hand.Sit(mock2.Object, 1, 1000);
hand.RunToEnd();
mock1.Verify();
mock2.Verify();
}
public void RunToEnd_TwoPlayers_CanDeclareWinner()
{
OmahaHiLoHand hand = new OmahaHiLoHand();
int numPlayers = 2;
OmahaPlayer[] players = new OmahaPlayer[2];
for (int i = 0; i < numPlayers; i++)
{
var mock = new Mock<OmahaPlayer>();
mock.Setup(p => p.Act()).Returns(PokerAction.CreateCallAction()).Verifiable();
players[i] = mock.Object;
hand.Sit(mock.Object, i, 1000);
}
HandResult result = hand.RunToEnd();
Assert.GreaterOrEqual(result.Winners.Count, 1);
}
public void RunToEnd_TwoPlayersRaisePlayerAndFoldPlayer_VerifyRaisePlayerIsWinner()
{
OmahaHiLoHand hand = new OmahaHiLoHand();
long amountToBet = 1000;
var raise = new Mock<OmahaPlayer>();
var fold = new Mock<OmahaPlayer>();
raise.Setup(p => p.Act()).Returns(PokerAction.CreateRaiseAction(amountToBet)).Callback(() => amountToBet += 1000).Verifiable();
fold.Setup(p => p.Act()).Returns(PokerAction.CreateFoldAction()).Verifiable();
hand.Sit(raise.Object, 0, 1000);
hand.Sit(fold.Object, 1, 1000);
HandResult result = hand.RunToEnd();
Assert.AreEqual(1, result.Winners.Count);
Assert.AreEqual(raise.Object, result.Winners[0].Player);
}
public void RunToEnd_TwoPlayersCallPlayerAndFoldPlayer_VerifyCallPlayerIsWinner()
{
OmahaHiLoHand hand = new OmahaHiLoHand();
var call = new Mock<OmahaPlayer>();
var fold = new Mock<OmahaPlayer>();
call.Setup(p => p.Act()).Returns(PokerAction.CreateCallAction()).Verifiable();
fold.Setup(p => p.Act()).Returns(PokerAction.CreateFoldAction()).Verifiable();
hand.Sit(call.Object, 0, 1000);
hand.Sit(fold.Object, 1, 1000);
HandResult result = hand.RunToEnd();
Assert.AreEqual(1, result.Winners.Count);
Assert.AreEqual(call.Object, result.Winners[0].Player);
call.Verify();
fold.Verify();
}
public void RunToEnd_ThreeCallPlayers_RunThreeHands()
{
OmahaHiLoHand hand = new OmahaHiLoHand();
int numPlayers = 3;
OmahaPlayer[] players = new OmahaPlayer[numPlayers];
for (int i = 0; i < numPlayers; i++)
{
var mock = new Mock<OmahaPlayer>();
mock.Setup(p => p.Act()).Returns(PokerAction.CreateCallAction());
players[i] = mock.Object;
hand.Sit(mock.Object, i, 1000);
}
List<HandResult> results = new List<HandResult>();
for (int i = 0; i < 3; i++)
{
HandResult result = hand.RunToEnd();
Assert.IsFalse(results.Contains(result));
results.Add(result);
}
}
public void RunToEnd_SeededDeck_Players2ShouldWin()
{
OmahaHiLoHand hand = new OmahaHiLoHand();
hand.Seed = 1;
var player1 = new Mock<OmahaPlayer>(); //// AAT7 (AA669)
var player2 = new Mock<OmahaPlayer>(); //// 73JQ (333JQ) -- should be winner
//// 69336 (common)
player1.Setup(p => p.Act()).Returns(PokerAction.CreateCallAction()).Verifiable();
player2.Setup(p => p.Act()).Returns(PokerAction.CreateCallAction()).Verifiable();
hand.Sit(player1.Object, 0, 1000);
hand.Sit(player2.Object, 1, 1000);
HandResult result = hand.RunToEnd();
Assert.AreEqual(1, result.Winners.Count);
Assert.AreEqual(player2.Object, result.Winners[0].Player);
player1.Verify();
player2.Verify();
}