747 lines
21 KiB
Rust
747 lines
21 KiB
Rust
use crate::card::{CardValue, PlayingCard};
|
|
use core::fmt;
|
|
use std::collections::HashMap;
|
|
|
|
#[derive(Clone, Copy, PartialEq, Eq, Ord, PartialOrd, Debug)]
|
|
pub enum HandType {
|
|
HighCard,
|
|
OnePair,
|
|
TwoPair,
|
|
ThreeOfAKind,
|
|
Straight,
|
|
Flush,
|
|
FullHouse,
|
|
FourOfAKind,
|
|
StraightFlush,
|
|
}
|
|
|
|
#[derive(PartialEq)]
|
|
pub struct PokerHand {
|
|
cards: Vec<PlayingCard>,
|
|
}
|
|
|
|
impl fmt::Display for PokerHand {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
let s = match self.hand_type() {
|
|
HandType::HighCard => write!(f, "{}", self.card_str()),
|
|
HandType::OnePair => {
|
|
for val in self.hash_map() {
|
|
if val.1 == 2 {
|
|
return write!(f, "{} | Pair of {:?}'s", self.card_str(), val);
|
|
}
|
|
}
|
|
return write!(f, "???");
|
|
}
|
|
HandType::TwoPair => todo!(),
|
|
HandType::ThreeOfAKind => todo!(),
|
|
HandType::Straight => todo!(),
|
|
HandType::Flush => todo!(),
|
|
HandType::FullHouse => todo!(),
|
|
HandType::FourOfAKind => todo!(),
|
|
HandType::StraightFlush => todo!(),
|
|
};
|
|
|
|
s
|
|
}
|
|
}
|
|
|
|
impl PartialOrd for PokerHand {
|
|
fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
|
|
if self.hand_type() != other.hand_type() {
|
|
return self.hand_type().partial_cmp(&other.hand_type());
|
|
}
|
|
let selfmap = self.hash_map();
|
|
let othermap = other.hash_map();
|
|
match self.hand_type() {
|
|
HandType::HighCard => {
|
|
// Compare high cards
|
|
self.cards.partial_cmp(&other.cards)
|
|
}
|
|
HandType::OnePair => {
|
|
let selfpair: Vec<(&CardValue, &u8)> =
|
|
selfmap.iter().filter(|&p| *p.1 == 2).collect();
|
|
let otherpair: Vec<(&CardValue, &u8)> =
|
|
othermap.iter().filter(|&p| *p.1 == 2).collect();
|
|
|
|
let pairvalue = selfpair[0].0;
|
|
let otherpairvalue = otherpair[0].0;
|
|
|
|
if pairvalue != otherpairvalue {
|
|
return pairvalue.partial_cmp(otherpairvalue);
|
|
}
|
|
|
|
self.cards.partial_cmp(&other.cards)
|
|
}
|
|
HandType::TwoPair => {
|
|
let selfpairs: Vec<(&CardValue, &u8)> =
|
|
selfmap.iter().filter(|&p| *p.1 == 2).collect();
|
|
let otherpairs: Vec<(&CardValue, &u8)> =
|
|
othermap.iter().filter(|&p| *p.1 == 2).collect();
|
|
|
|
for i in 0..1 {
|
|
let pairvalue = selfpairs[i].0;
|
|
let otherpairvalue = otherpairs[i].0;
|
|
|
|
if pairvalue != otherpairvalue {
|
|
return pairvalue.partial_cmp(otherpairvalue);
|
|
}
|
|
}
|
|
|
|
self.cards.partial_cmp(&other.cards)
|
|
}
|
|
HandType::ThreeOfAKind => {
|
|
let selfpairs: Vec<(&CardValue, &u8)> =
|
|
selfmap.iter().filter(|&p| *p.1 == 3).collect();
|
|
let otherpairs: Vec<(&CardValue, &u8)> =
|
|
othermap.iter().filter(|&p| *p.1 == 3).collect();
|
|
|
|
let pairvalue = selfpairs[0].0;
|
|
let otherpairvalue = otherpairs[0].0;
|
|
|
|
if pairvalue != otherpairvalue {
|
|
return pairvalue.partial_cmp(otherpairvalue);
|
|
}
|
|
|
|
self.cards.partial_cmp(&other.cards)
|
|
}
|
|
HandType::Straight => self.cards.partial_cmp(&other.cards),
|
|
HandType::Flush => self.cards.partial_cmp(&other.cards),
|
|
HandType::FullHouse => {
|
|
let threes: Vec<(&CardValue, &u8)> =
|
|
selfmap.iter().filter(|&p| *p.1 == 3).collect();
|
|
let otherthrees: Vec<(&CardValue, &u8)> =
|
|
othermap.iter().filter(|&p| *p.1 == 3).collect();
|
|
|
|
if threes[0].0 != otherthrees[0].0 {
|
|
return threes[0].0.partial_cmp(otherthrees[0].0);
|
|
}
|
|
|
|
let twos: Vec<(&CardValue, &u8)> = selfmap.iter().filter(|&p| *p.1 == 2).collect();
|
|
let othertwos: Vec<(&CardValue, &u8)> =
|
|
othermap.iter().filter(|&p| *p.1 == 2).collect();
|
|
|
|
if twos[0].0 != othertwos[0].0 {
|
|
return twos[0].0.partial_cmp(othertwos[0].0);
|
|
}
|
|
|
|
self.cards.partial_cmp(&other.cards)
|
|
}
|
|
HandType::FourOfAKind => {
|
|
let fours: Vec<(&CardValue, &u8)> = selfmap.iter().filter(|&p| *p.1 == 4).collect();
|
|
let otherfours: Vec<(&CardValue, &u8)> =
|
|
othermap.iter().filter(|&p| *p.1 == 4).collect();
|
|
|
|
if fours[0].0 != otherfours[0].0 {
|
|
return fours[0].0.partial_cmp(otherfours[0].0);
|
|
}
|
|
|
|
self.cards.partial_cmp(&other.cards)
|
|
}
|
|
HandType::StraightFlush => self.cards.partial_cmp(&other.cards),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl PokerHand {
|
|
pub fn new(mut cards: Vec<PlayingCard>) -> Self {
|
|
assert!(cards.len() == 5);
|
|
|
|
// Sorted highest card first
|
|
cards.sort_unstable();
|
|
cards.reverse();
|
|
PokerHand { cards }
|
|
}
|
|
|
|
fn card_str(&self) -> String {
|
|
let mut cardstr: String = "".to_owned();
|
|
for card in &self.cards {
|
|
cardstr.push_str(&card.to_string());
|
|
cardstr.push(' ');
|
|
}
|
|
|
|
cardstr
|
|
}
|
|
|
|
fn hash_map(&self) -> HashMap<CardValue, u8> {
|
|
let mut count: HashMap<CardValue, u8> = HashMap::new();
|
|
|
|
for card in &self.cards {
|
|
*count.entry(card.value).or_insert(0) += 1;
|
|
}
|
|
|
|
count
|
|
}
|
|
|
|
pub fn hand_type(&self) -> HandType {
|
|
if is_straight_flush(self) {
|
|
return HandType::StraightFlush;
|
|
}
|
|
|
|
if is_four_of_a_kind(self) {
|
|
return HandType::FourOfAKind;
|
|
}
|
|
|
|
if is_full_house(self) {
|
|
return HandType::FullHouse;
|
|
}
|
|
|
|
if is_flush(self) {
|
|
return HandType::Flush;
|
|
}
|
|
|
|
if is_straight(self) {
|
|
return HandType::Straight;
|
|
}
|
|
|
|
if is_three_of_a_kind(self) {
|
|
return HandType::ThreeOfAKind;
|
|
}
|
|
|
|
if is_two_pair(self) {
|
|
return HandType::TwoPair;
|
|
}
|
|
|
|
if is_one_pair(self) {
|
|
return HandType::OnePair;
|
|
}
|
|
|
|
return HandType::HighCard;
|
|
}
|
|
}
|
|
|
|
fn is_straight_flush(hand: &PokerHand) -> bool {
|
|
let hand = &hand.cards;
|
|
assert!(hand.len() == 5);
|
|
|
|
let suit = hand[0].suit;
|
|
let mut min_val = CardValue::Ace;
|
|
let mut max_val = CardValue::Two;
|
|
|
|
// Must all be the same suit
|
|
for i in 0..5 {
|
|
let card = &hand[i];
|
|
|
|
for k in (i + 1)..5 {
|
|
if hand[k].value == card.value {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if card.value < min_val {
|
|
min_val = card.value;
|
|
};
|
|
|
|
if card.value > max_val {
|
|
max_val = card.value;
|
|
}
|
|
|
|
if card.suit != suit {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
let max_val = max_val as u8;
|
|
let min_val = min_val as u8;
|
|
|
|
if max_val - min_val > 4 {
|
|
return false;
|
|
}
|
|
|
|
true
|
|
}
|
|
|
|
fn is_four_of_a_kind(hand: &PokerHand) -> bool {
|
|
for e in hand.hash_map() {
|
|
if e.1 == 4 {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
false
|
|
}
|
|
|
|
fn is_full_house(hand: &PokerHand) -> bool {
|
|
let map = hand.hash_map();
|
|
if map.len() != 2 {
|
|
return false;
|
|
}
|
|
|
|
let count: Vec<u8> = map.into_values().collect();
|
|
|
|
// https://stackoverflow.com/questions/45353757/how-to-count-the-elements-in-a-vector-with-some-value-without-looping
|
|
if count.iter().filter(|&n| *n == 2).count() != 1 {
|
|
return false;
|
|
}
|
|
|
|
if count.iter().filter(|&n| *n == 2).count() != 1 {
|
|
return false;
|
|
}
|
|
|
|
true
|
|
}
|
|
|
|
fn is_flush(hand: &PokerHand) -> bool {
|
|
let suit = hand.cards[0].suit;
|
|
for card in &hand.cards {
|
|
if card.suit != suit {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
true
|
|
}
|
|
|
|
fn is_straight(hand: &PokerHand) -> bool {
|
|
for i in 1..4 {
|
|
let current_card = hand.cards[i].value as u8;
|
|
let previous_card = hand.cards[i - 1].value as u8;
|
|
if current_card != previous_card - 1 {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
true
|
|
}
|
|
|
|
fn is_three_of_a_kind(hand: &PokerHand) -> bool {
|
|
let map = hand.hash_map();
|
|
let count: Vec<u8> = map.into_values().collect();
|
|
|
|
count.contains(&3)
|
|
}
|
|
|
|
fn is_two_pair(hand: &PokerHand) -> bool {
|
|
let map = hand.hash_map();
|
|
let count: Vec<u8> = map.into_values().collect();
|
|
|
|
// https://stackoverflow.com/questions/45353757/how-to-count-the-elements-in-a-vector-with-some-value-without-looping
|
|
count.iter().filter(|&n| *n == 2).count() == 2
|
|
}
|
|
|
|
fn is_one_pair(hand: &PokerHand) -> bool {
|
|
let map = hand.hash_map();
|
|
let count: Vec<u8> = map.into_values().collect();
|
|
|
|
// https://stackoverflow.com/questions/45353757/how-to-count-the-elements-in-a-vector-with-some-value-without-looping
|
|
count.iter().filter(|&n| *n == 2).count() == 1
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use crate::card::CardSuit;
|
|
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn one_pair_test() {
|
|
let card1 = PlayingCard {
|
|
suit: CardSuit::Clubs,
|
|
value: CardValue::Ace,
|
|
};
|
|
let card2 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Ace,
|
|
};
|
|
let card3 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Two,
|
|
};
|
|
let card4 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Five,
|
|
};
|
|
let card5 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Eight,
|
|
};
|
|
|
|
let pair = vec![card1, card2, card3, card4, card5];
|
|
let hand = PokerHand::new(pair);
|
|
assert_eq!(hand.hand_type(), HandType::OnePair);
|
|
|
|
let card1 = PlayingCard {
|
|
suit: CardSuit::Clubs,
|
|
value: CardValue::Ace,
|
|
};
|
|
let card2 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::King,
|
|
};
|
|
let card3 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Two,
|
|
};
|
|
let card4 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Five,
|
|
};
|
|
let card5 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Eight,
|
|
};
|
|
|
|
let nopair = vec![card1, card2, card3, card4, card5];
|
|
let hand = PokerHand::new(nopair);
|
|
assert_eq!(hand.hand_type(), HandType::HighCard);
|
|
}
|
|
|
|
#[test]
|
|
fn two_pair_test() {
|
|
let card1 = PlayingCard {
|
|
suit: CardSuit::Clubs,
|
|
value: CardValue::Ace,
|
|
};
|
|
let card2 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Ace,
|
|
};
|
|
let card3 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Two,
|
|
};
|
|
let card4 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Five,
|
|
};
|
|
let card5 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Five,
|
|
};
|
|
|
|
let pair = vec![card1, card2, card3, card4, card5];
|
|
let hand = PokerHand::new(pair);
|
|
assert_eq!(hand.hand_type(), HandType::TwoPair);
|
|
}
|
|
|
|
#[test]
|
|
fn three_of_a_kind_tests() {
|
|
let card1 = PlayingCard {
|
|
suit: CardSuit::Clubs,
|
|
value: CardValue::Ace,
|
|
};
|
|
let card2 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Ace,
|
|
};
|
|
let card3 = PlayingCard {
|
|
suit: CardSuit::Spades,
|
|
value: CardValue::Ace,
|
|
};
|
|
let card4 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Five,
|
|
};
|
|
let card5 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Two,
|
|
};
|
|
|
|
let pair = vec![card1, card2, card3, card4, card5];
|
|
let hand = PokerHand::new(pair);
|
|
assert_eq!(hand.hand_type(), HandType::ThreeOfAKind);
|
|
}
|
|
|
|
#[test]
|
|
fn staight_test() {
|
|
let card1 = PlayingCard {
|
|
suit: CardSuit::Clubs,
|
|
value: CardValue::Six,
|
|
};
|
|
let card2 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Eight,
|
|
};
|
|
let card3 = PlayingCard {
|
|
suit: CardSuit::Spades,
|
|
value: CardValue::Seven,
|
|
};
|
|
let card4 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Five,
|
|
};
|
|
let card5 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Nine,
|
|
};
|
|
|
|
let pair = vec![card1, card2, card3, card4, card5];
|
|
let hand = PokerHand::new(pair);
|
|
assert_eq!(hand.hand_type(), HandType::Straight);
|
|
}
|
|
|
|
#[test]
|
|
fn flush_test() {
|
|
let card1 = PlayingCard {
|
|
suit: CardSuit::Clubs,
|
|
value: CardValue::Six,
|
|
};
|
|
let card2 = PlayingCard {
|
|
suit: CardSuit::Clubs,
|
|
value: CardValue::Two,
|
|
};
|
|
let card3 = PlayingCard {
|
|
suit: CardSuit::Clubs,
|
|
value: CardValue::Queen,
|
|
};
|
|
let card4 = PlayingCard {
|
|
suit: CardSuit::Clubs,
|
|
value: CardValue::Jack,
|
|
};
|
|
let card5 = PlayingCard {
|
|
suit: CardSuit::Clubs,
|
|
value: CardValue::Ace,
|
|
};
|
|
|
|
let pair = vec![card1, card2, card3, card4, card5];
|
|
let hand = PokerHand::new(pair);
|
|
assert_eq!(hand.hand_type(), HandType::Flush);
|
|
}
|
|
|
|
#[test]
|
|
fn full_house_test() {
|
|
let card1 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Six,
|
|
};
|
|
let card2 = PlayingCard {
|
|
suit: CardSuit::Clubs,
|
|
value: CardValue::Six,
|
|
};
|
|
let card3 = PlayingCard {
|
|
suit: CardSuit::Spades,
|
|
value: CardValue::Two,
|
|
};
|
|
let card4 = PlayingCard {
|
|
suit: CardSuit::Clubs,
|
|
value: CardValue::Six,
|
|
};
|
|
let card5 = PlayingCard {
|
|
suit: CardSuit::Clubs,
|
|
value: CardValue::Two,
|
|
};
|
|
|
|
let pair = vec![card1, card2, card3, card4, card5];
|
|
let hand = PokerHand::new(pair);
|
|
assert_eq!(hand.hand_type(), HandType::FullHouse);
|
|
}
|
|
|
|
#[test]
|
|
fn four_of_a_kind_test() {
|
|
let card1 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Six,
|
|
};
|
|
let card2 = PlayingCard {
|
|
suit: CardSuit::Clubs,
|
|
value: CardValue::Six,
|
|
};
|
|
let card3 = PlayingCard {
|
|
suit: CardSuit::Spades,
|
|
value: CardValue::Six,
|
|
};
|
|
let card4 = PlayingCard {
|
|
suit: CardSuit::Clubs,
|
|
value: CardValue::Six,
|
|
};
|
|
let card5 = PlayingCard {
|
|
suit: CardSuit::Clubs,
|
|
value: CardValue::Two,
|
|
};
|
|
|
|
let pair = vec![card1, card2, card3, card4, card5];
|
|
let hand = PokerHand::new(pair);
|
|
assert_eq!(hand.hand_type(), HandType::FourOfAKind);
|
|
}
|
|
|
|
#[test]
|
|
fn straight_flush_test() {
|
|
let card1 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Jack,
|
|
};
|
|
let card2 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Ten,
|
|
};
|
|
let card3 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Nine,
|
|
};
|
|
let card4 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Seven,
|
|
};
|
|
let card5 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Eight,
|
|
};
|
|
|
|
let pair = vec![card1, card2, card3, card4, card5];
|
|
let hand = PokerHand::new(pair);
|
|
assert_eq!(hand.hand_type(), HandType::StraightFlush);
|
|
}
|
|
|
|
#[test]
|
|
fn comp_test1() {
|
|
// Hand 1
|
|
let card1 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Jack,
|
|
};
|
|
let card2 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Jack,
|
|
};
|
|
let card3 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Nine,
|
|
};
|
|
let card4 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Ace,
|
|
};
|
|
let card5 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Eight,
|
|
};
|
|
|
|
// Hand 2
|
|
let card6 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Queen,
|
|
};
|
|
let card7 = PlayingCard {
|
|
suit: CardSuit::Clubs,
|
|
value: CardValue::Ten,
|
|
};
|
|
let card8 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Queen,
|
|
};
|
|
let card9 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Two,
|
|
};
|
|
let card10 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Eight,
|
|
};
|
|
|
|
let cardset1 = vec![card1, card2, card3, card4, card5];
|
|
let cardset2 = vec![card6, card7, card8, card9, card10];
|
|
let flush = PokerHand::new(cardset1);
|
|
let onepair = PokerHand::new(cardset2);
|
|
assert!(flush > onepair);
|
|
}
|
|
|
|
#[test]
|
|
fn straight_flush_ord_test() {
|
|
// Hand 1
|
|
let card1 = PlayingCard {
|
|
suit: CardSuit::Clubs,
|
|
value: CardValue::Jack,
|
|
};
|
|
let card2 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Ten,
|
|
};
|
|
let card3 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Nine,
|
|
};
|
|
let card4 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Eight,
|
|
};
|
|
let card5 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Seven,
|
|
};
|
|
|
|
// Hand 2
|
|
let card6 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Queen,
|
|
};
|
|
let card7 = PlayingCard {
|
|
suit: CardSuit::Clubs,
|
|
value: CardValue::Jack,
|
|
};
|
|
let card8 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Ten,
|
|
};
|
|
let card9 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Nine,
|
|
};
|
|
let card10 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Eight,
|
|
};
|
|
|
|
let cardset1 = vec![card1, card2, card3, card4, card5];
|
|
let cardset2 = vec![card6, card7, card8, card9, card10];
|
|
let hand1 = PokerHand::new(cardset1);
|
|
let hand2 = PokerHand::new(cardset2);
|
|
assert!(hand1 < hand2);
|
|
assert!(hand1 >= hand1);
|
|
assert!(hand2 <= hand2);
|
|
}
|
|
|
|
#[test]
|
|
fn four_kind_ord_test() {
|
|
// Hand 1
|
|
let card1 = PlayingCard {
|
|
suit: CardSuit::Clubs,
|
|
value: CardValue::Jack,
|
|
};
|
|
let card2 = PlayingCard {
|
|
suit: CardSuit::Hearts,
|
|
value: CardValue::Jack,
|
|
};
|
|
let card3 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Jack,
|
|
};
|
|
let card4 = PlayingCard {
|
|
suit: CardSuit::Spades,
|
|
value: CardValue::Jack,
|
|
};
|
|
let card5 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Seven,
|
|
};
|
|
|
|
// Hand 2
|
|
let card6 = PlayingCard {
|
|
suit: CardSuit::Spades,
|
|
value: CardValue::Queen,
|
|
};
|
|
let card7 = PlayingCard {
|
|
suit: CardSuit::Hearts,
|
|
value: CardValue::Queen,
|
|
};
|
|
let card8 = PlayingCard {
|
|
suit: CardSuit::Clubs,
|
|
value: CardValue::Queen,
|
|
};
|
|
let card9 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Queen,
|
|
};
|
|
let card10 = PlayingCard {
|
|
suit: CardSuit::Diamonds,
|
|
value: CardValue::Eight,
|
|
};
|
|
|
|
let cardset1 = vec![card1, card2, card3, card4, card5];
|
|
let cardset2 = vec![card6, card7, card8, card9, card10];
|
|
let hand1 = PokerHand::new(cardset1);
|
|
let hand2 = PokerHand::new(cardset2);
|
|
assert!(hand1 < hand2);
|
|
assert!(hand1 >= hand1);
|
|
assert!(hand2 <= hand2);
|
|
}
|
|
}
|