rummy 0.2.0

a crate for the card game Rummy
Documentation 
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

#[cfg(test)]
mod tests {
    use super::super::*;

    #[test]
    fn test_set_properties() {
        let cfg = basic_config();
        let mut cards = create_set_cards(
            Rank::King,
            &[Suit::Clubs, Suit::Diamonds, Suit::Hearts],
            cfg.clone(),
        );
        let indices = vec![0, 1, 2];

        let set = Set::new(&mut cards, &indices).unwrap();

        assert_eq!(set.rank(), Rank::King);
        assert_eq!(set.cards().len(), 3);

        // Verify all cards in the set have the correct rank
        for card in set.cards() {
            assert!(card.rank == Rank::King || card.is_wildcard());
        }
    }

    #[test]
    fn test_run_properties() {
        let cfg = basic_config();
        let mut cards = vec![
            create_card(Rank::Seven, Suit::Hearts, cfg.clone()),
            create_card(Rank::Eight, Suit::Hearts, cfg.clone()),
            create_card(Rank::Nine, Suit::Hearts, cfg.clone()),
        ];
        let indices = vec![0, 1, 2];

        let run = Run::new(&mut cards, &indices).unwrap();

        assert_eq!(run.suit(), Suit::Hearts);
        assert_eq!(run.cards().len(), 3);

        // Verify all cards in the run have the correct suit (excluding wildcards)
        for card in run.cards() {
            assert!(card.suit == Suit::Hearts || card.is_wildcard());
        }
    }

    #[test]
    fn test_meld_type_identification() {
        let cfg = basic_config();

        // Test set identification
        let mut set_cards = create_set_cards(
            Rank::Ten,
            &[Suit::Clubs, Suit::Diamonds, Suit::Hearts],
            cfg.clone(),
        );
        let indices = vec![0, 1, 2];
        let set_meld = Meld::new(&mut set_cards, &indices).unwrap();

        assert!(set_meld.is_set());
        assert!(!set_meld.is_run());

        // Test run identification
        let mut run_cards = vec![
            create_card(Rank::Jack, Suit::Spades, cfg.clone()),
            create_card(Rank::Queen, Suit::Spades, cfg.clone()),
            create_card(Rank::King, Suit::Spades, cfg.clone()),
        ];
        let indices = vec![0, 1, 2];
        let run_meld = Meld::new(&mut run_cards, &indices).unwrap();

        assert!(run_meld.is_run());
        assert!(!run_meld.is_set());
    }

    #[test]
    fn test_set_cards_immutable_reference() {
        let cfg = basic_config();
        let mut cards = create_set_cards(
            Rank::Nine,
            &[Suit::Clubs, Suit::Diamonds, Suit::Hearts],
            cfg.clone(),
        );
        let indices = vec![0, 1, 2];

        let set = Set::new(&mut cards, &indices).unwrap();
        let set_cards = set.cards();

        // Verify we get an immutable reference
        assert_eq!(set_cards.len(), 3);
        // This shouldn't compile if we tried: set_cards.push(...)
    }

    #[test]
    fn test_run_cards_immutable_reference() {
        let cfg = basic_config();
        let mut cards = vec![
            create_card(Rank::Three, Suit::Diamonds, cfg.clone()),
            create_card(Rank::Four, Suit::Diamonds, cfg.clone()),
            create_card(Rank::Five, Suit::Diamonds, cfg.clone()),
        ];
        let indices = vec![0, 1, 2];

        let run = Run::new(&mut cards, &indices).unwrap();
        let run_cards = run.cards();

        // Verify we get an immutable reference
        assert_eq!(run_cards.len(), 3);
        // This shouldn't compile if we tried: run_cards.push(...)
    }

    #[test]
    fn test_meld_preserves_card_properties() {
        let cfg = basic_config();
        let mut cards = vec![
            create_card(Rank::Ace, Suit::Clubs, cfg.clone()),
            create_card(Rank::Ace, Suit::Diamonds, cfg.clone()),
            create_card(Rank::Ace, Suit::Hearts, cfg.clone()),
        ];
        let indices = vec![0, 1, 2];

        // Store original card properties
        let original_suits: Vec<Suit> = cards.iter().map(|c| c.suit).collect();

        let set = Set::new(&mut cards, &indices).unwrap();

        // Verify cards in meld maintain their original properties
        let meld_suits: Vec<Suit> = set.cards().iter().map(|c| c.suit).collect();

        // Note: order might be different due to removal/insertion logic
        for suit in original_suits {
            assert!(meld_suits.contains(&suit));
        }
    }

    #[test]
    fn test_layoff_increases_meld_size() {
        let cfg = basic_config();
        let mut cards = create_set_cards(
            Rank::Seven,
            &[Suit::Clubs, Suit::Diamonds, Suit::Hearts],
            cfg.clone(),
        );
        let indices = vec![0, 1, 2];
        let mut set = Set::new(&mut cards, &indices).unwrap();

        let original_size = set.cards().len();

        let mut layoff_hand = vec![create_card(Rank::Seven, Suit::Spades, cfg.clone())];
        set.layoff_card(&mut layoff_hand, 0).unwrap();

        assert_eq!(set.cards().len(), original_size + 1);
    }

    #[test]
    fn test_meld_debug_representation() {
        let cfg = basic_config();
        let mut cards = create_set_cards(
            Rank::Queen,
            &[Suit::Clubs, Suit::Diamonds, Suit::Hearts],
            cfg.clone(),
        );
        let indices = vec![0, 1, 2];

        let meld = Meld::new(&mut cards, &indices).unwrap();

        // Verify that Debug is implemented (this will compile-fail if not)
        let debug_str = format!("{meld:?}");
        assert!(!debug_str.is_empty());
    }
}