1
exercism fetch csharp poker

PokerTest.cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
// This file was auto-generated based on version 1.0.0 of the canonical data.

using Xunit;

public class PokerTest
{
    [Fact]
    public void Single_hand_always_wins()
    {
        var actual = Poker.BestHands(new[] { "4S 5S 7H 8D JC" });
        var expected = new[] { "4S 5S 7H 8D JC" };
        Assert.Equal(expected, actual);
    }

    [Fact(Skip = "Remove to run test")]
    public void Highest_card_out_of_all_hands_wins()
    {
        var actual = Poker.BestHands(new[] { "4D 5S 6S 8D 3C", "2S 4C 7S 9H 10H", "3S 4S 5D 6H JH" });
        var expected = new[] { "3S 4S 5D 6H JH" };
        Assert.Equal(expected, actual);
    }

    [Fact(Skip = "Remove to run test")]
    public void A_tie_has_multiple_winners()
    {
        var actual = Poker.BestHands(new[] { "4D 5S 6S 8D 3C", "2S 4C 7S 9H 10H", "3S 4S 5D 6H JH", "3H 4H 5C 6C JD" });
        var expected = new[] { "3S 4S 5D 6H JH", "3H 4H 5C 6C JD" };
        Assert.Equal(expected, actual);
    }

    [Fact(Skip = "Remove to run test")]
    public void Multiple_hands_with_the_same_high_cards_tie_compares_next_highest_ranked_down_to_last_card()
    {
        var actual = Poker.BestHands(new[] { "3S 5H 6S 8D 7H", "2S 5D 6D 8C 7S" });
        var expected = new[] { "3S 5H 6S 8D 7H" };
        Assert.Equal(expected, actual);
    }

    [Fact(Skip = "Remove to run test")]
    public void One_pair_beats_high_card()
    {
        var actual = Poker.BestHands(new[] { "4S 5H 6C 8D KH", "2S 4H 6S 4D JH" });
        var expected = new[] { "2S 4H 6S 4D JH" };
        Assert.Equal(expected, actual);
    }

    [Fact(Skip = "Remove to run test")]
    public void Highest_pair_wins()
    {
        var actual = Poker.BestHands(new[] { "4S 2H 6S 2D JH", "2S 4H 6C 4D JD" });
        var expected = new[] { "2S 4H 6C 4D JD" };
        Assert.Equal(expected, actual);
    }

    [Fact(Skip = "Remove to run test")]
    public void Two_pairs_beats_one_pair()
    {
        var actual = Poker.BestHands(new[] { "2S 8H 6S 8D JH", "4S 5H 4C 8C 5C" });
        var expected = new[] { "4S 5H 4C 8C 5C" };
        Assert.Equal(expected, actual);
    }

    [Fact(Skip = "Remove to run test")]
    public void Both_hands_have_two_pairs_highest_ranked_pair_wins()
    {
        var actual = Poker.BestHands(new[] { "2S 8H 2D 8D 3H", "4S 5H 4C 8S 5D" });
        var expected = new[] { "2S 8H 2D 8D 3H" };
        Assert.Equal(expected, actual);
    }

    [Fact(Skip = "Remove to run test")]
    public void Both_hands_have_two_pairs_with_the_same_highest_ranked_pair_tie_goes_to_low_pair()
    {
        var actual = Poker.BestHands(new[] { "2S QS 2C QD JH", "JD QH JS 8D QC" });
        var expected = new[] { "JD QH JS 8D QC" };
        Assert.Equal(expected, actual);
    }

    [Fact(Skip = "Remove to run test")]
    public void Both_hands_have_two_identically_ranked_pairs_tie_goes_to_remaining_card_kicker_()
    {
        var actual = Poker.BestHands(new[] { "JD QH JS 8D QC", "JS QS JC 2D QD" });
        var expected = new[] { "JD QH JS 8D QC" };
        Assert.Equal(expected, actual);
    }

    [Fact(Skip = "Remove to run test")]
    public void Three_of_a_kind_beats_two_pair()
    {
        var actual = Poker.BestHands(new[] { "2S 8H 2H 8D JH", "4S 5H 4C 8S 4H" });
        var expected = new[] { "4S 5H 4C 8S 4H" };
        Assert.Equal(expected, actual);
    }

    [Fact(Skip = "Remove to run test")]
    public void Both_hands_have_three_of_a_kind_tie_goes_to_highest_ranked_triplet()
    {
        var actual = Poker.BestHands(new[] { "2S 2H 2C 8D JH", "4S AH AS 8C AD" });
        var expected = new[] { "4S AH AS 8C AD" };
        Assert.Equal(expected, actual);
    }

    [Fact(Skip = "Remove to run test")]
    public void With_multiple_decks_two_players_can_have_same_three_of_a_kind_ties_go_to_highest_remaining_cards()
    {
        var actual = Poker.BestHands(new[] { "4S AH AS 7C AD", "4S AH AS 8C AD" });
        var expected = new[] { "4S AH AS 8C AD" };
        Assert.Equal(expected, actual);
    }

    [Fact(Skip = "Remove to run test")]
    public void A_straight_beats_three_of_a_kind()
    {
        var actual = Poker.BestHands(new[] { "4S 5H 4C 8D 4H", "3S 4D 2S 6D 5C" });
        var expected = new[] { "3S 4D 2S 6D 5C" };
        Assert.Equal(expected, actual);
    }

    [Fact(Skip = "Remove to run test")]
    public void Aces_can_end_a_straight_10_j_q_k_a_()
    {
        var actual = Poker.BestHands(new[] { "4S 5H 4C 8D 4H", "10D JH QS KD AC" });
        var expected = new[] { "10D JH QS KD AC" };
        Assert.Equal(expected, actual);
    }

    [Fact(Skip = "Remove to run test")]
    public void Aces_can_start_a_straight_a_2_3_4_5_()
    {
        var actual = Poker.BestHands(new[] { "4S 5H 4C 8D 4H", "4D AH 3S 2D 5C" });
        var expected = new[] { "4D AH 3S 2D 5C" };
        Assert.Equal(expected, actual);
    }

    [Fact(Skip = "Remove to run test")]
    public void Both_hands_with_a_straight_tie_goes_to_highest_ranked_card()
    {
        var actual = Poker.BestHands(new[] { "4S 6C 7S 8D 5H", "5S 7H 8S 9D 6H" });
        var expected = new[] { "5S 7H 8S 9D 6H" };
        Assert.Equal(expected, actual);
    }

    [Fact(Skip = "Remove to run test")]
    public void Even_though_an_ace_is_usually_high_a_5_high_straight_is_the_lowest_scoring_straight()
    {
        var actual = Poker.BestHands(new[] { "2H 3C 4D 5D 6H", "4S AH 3S 2D 5H" });
        var expected = new[] { "2H 3C 4D 5D 6H" };
        Assert.Equal(expected, actual);
    }

    [Fact(Skip = "Remove to run test")]
    public void Flush_beats_a_straight()
    {
        var actual = Poker.BestHands(new[] { "4C 6H 7D 8D 5H", "2S 4S 5S 6S 7S" });
        var expected = new[] { "2S 4S 5S 6S 7S" };
        Assert.Equal(expected, actual);
    }

    [Fact(Skip = "Remove to run test")]
    public void Both_hands_have_a_flush_tie_goes_to_high_card_down_to_the_last_one_if_necessary()
    {
        var actual = Poker.BestHands(new[] { "4H 7H 8H 9H 6H", "2S 4S 5S 6S 7S" });
        var expected = new[] { "4H 7H 8H 9H 6H" };
        Assert.Equal(expected, actual);
    }

    [Fact(Skip = "Remove to run test")]
    public void Full_house_beats_a_flush()
    {
        var actual = Poker.BestHands(new[] { "3H 6H 7H 8H 5H", "4S 5H 4C 5D 4H" });
        var expected = new[] { "4S 5H 4C 5D 4H" };
        Assert.Equal(expected, actual);
    }

    [Fact(Skip = "Remove to run test")]
    public void Both_hands_have_a_full_house_tie_goes_to_highest_ranked_triplet()
    {
        var actual = Poker.BestHands(new[] { "4H 4S 4D 9S 9D", "5H 5S 5D 8S 8D" });
        var expected = new[] { "5H 5S 5D 8S 8D" };
        Assert.Equal(expected, actual);
    }

    [Fact(Skip = "Remove to run test")]
    public void With_multiple_decks_both_hands_have_a_full_house_with_the_same_triplet_tie_goes_to_the_pair()
    {
        var actual = Poker.BestHands(new[] { "5H 5S 5D 9S 9D", "5H 5S 5D 8S 8D" });
        var expected = new[] { "5H 5S 5D 9S 9D" };
        Assert.Equal(expected, actual);
    }

    [Fact(Skip = "Remove to run test")]
    public void Four_of_a_kind_beats_a_full_house()
    {
        var actual = Poker.BestHands(new[] { "4S 5H 4D 5D 4H", "3S 3H 2S 3D 3C" });
        var expected = new[] { "3S 3H 2S 3D 3C" };
        Assert.Equal(expected, actual);
    }

    [Fact(Skip = "Remove to run test")]
    public void Both_hands_have_four_of_a_kind_tie_goes_to_high_quad()
    {
        var actual = Poker.BestHands(new[] { "2S 2H 2C 8D 2D", "4S 5H 5S 5D 5C" });
        var expected = new[] { "4S 5H 5S 5D 5C" };
        Assert.Equal(expected, actual);
    }

    [Fact(Skip = "Remove to run test")]
    public void With_multiple_decks_both_hands_with_identical_four_of_a_kind_tie_determined_by_kicker()
    {
        var actual = Poker.BestHands(new[] { "3S 3H 2S 3D 3C", "3S 3H 4S 3D 3C" });
        var expected = new[] { "3S 3H 4S 3D 3C" };
        Assert.Equal(expected, actual);
    }

    [Fact(Skip = "Remove to run test")]
    public void Straight_flush_beats_four_of_a_kind()
    {
        var actual = Poker.BestHands(new[] { "4S 5H 5S 5D 5C", "7S 8S 9S 6S 10S" });
        var expected = new[] { "7S 8S 9S 6S 10S" };
        Assert.Equal(expected, actual);
    }

    [Fact(Skip = "Remove to run test")]
    public void Both_hands_have_straight_flush_tie_goes_to_highest_ranked_card()
    {
        var actual = Poker.BestHands(new[] { "4H 6H 7H 8H 5H", "5S 7S 8S 9S 6S" });
        var expected = new[] { "5S 7S 8S 9S 6S" };
        Assert.Equal(expected, actual);
    }
}