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

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

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

        let result = Meld::new(&mut cards, &indices);
        assert!(matches!(
            result,
            Err(MeldError::InsufficientCards {
                provided: 2,
                minimum: 3
            })
        ));
    }

    #[test]
    fn test_invalid_index_error() {
        let cfg = basic_config();
        let mut cards = vec![create_card(Rank::Ace, Suit::Clubs, cfg.clone())];
        let indices = vec![0, 1, 5]; // Index 5 is out of bounds

        let result = Meld::new(&mut cards, &indices);
        assert!(matches!(result, Err(MeldError::InvalidCardIndex)));
    }

    #[test]
    fn test_empty_indices() {
        let cfg = basic_config();
        let mut cards = vec![create_card(Rank::Ace, Suit::Clubs, cfg.clone())];
        let indices = vec![];

        let result = Meld::new(&mut cards, &indices);
        assert!(matches!(
            result,
            Err(MeldError::InsufficientCards {
                provided: 0,
                minimum: 3
            })
        ));
    }

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

        let mut layoff_hand = vec![create_card(Rank::Ace, Suit::Spades, cfg.clone())];

        let result = set.layoff_card(&mut layoff_hand, 5); // Invalid index
        assert!(matches!(result, Err(MeldError::InvalidCardIndex)));
    }

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

        let result = Set::new(&mut cards, &indices);
        assert!(matches!(result, Err(MeldError::InvalidSet)));
    }

    #[test]
    fn test_invalid_run_error() {
        let cfg = basic_config();
        let mut cards = vec![
            create_card(Rank::Ace, Suit::Clubs, cfg.clone()),
            create_card(Rank::Two, Suit::Clubs, cfg.clone()),
            create_card(Rank::Three, Suit::Spades, cfg.clone()), // Wrong suit
        ];
        let indices = vec![0, 1, 2];

        let result = Run::new(&mut cards, &indices);
        assert!(matches!(result, Err(MeldError::InvalidRun)));
    }

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

        let mut layoff_card = vec![create_card(Rank::Two, Suit::Clubs, cfg.clone())];

        let result = meld.layoff_card(&mut layoff_card, 0);
        assert!(matches!(result, Err(MeldError::InvalidLayoff)));
    }

    #[test]
    fn test_invalid_run_layoff() {
        let cfg = basic_config();
        let mut cards = vec![
            create_card(Rank::Ace, Suit::Clubs, cfg.clone()),
            create_card(Rank::Two, Suit::Clubs, cfg.clone()),
            create_card(Rank::Three, Suit::Clubs, cfg.clone()),
        ];
        let indices = vec![0, 1, 2];
        let mut meld = Meld::new(&mut cards, &indices).unwrap();

        let mut layoff_cards = vec![
            create_card(Rank::Five, Suit::Clubs, cfg.clone()), // Gap in sequence
            create_card(Rank::Four, Suit::Spades, cfg.clone()), // Wrong suit
        ];

        assert!(matches!(
            meld.layoff_card(&mut layoff_cards, 0),
            Err(MeldError::InvalidLayoff)
        ));
        assert!(matches!(
            meld.layoff_card(&mut layoff_cards, 1),
            Err(MeldError::InvalidLayoff)
        ));
    }
}