r_collections/list/
stack.rs

1use crate::traits::{list::{ListResults, List}, collection::Collection};
2
3use super::linked_list::LinkedList;
4
5#[derive(Debug, Clone)]
6pub struct Stack<T: Clone + PartialEq> {
7    list: LinkedList<T>,
8}
9
10impl<T: Clone + PartialEq> Stack<T> {
11    pub fn new() -> Self {
12        Self {list: LinkedList::<T>::new(),}
13    }
14
15    pub fn pop(&mut self) -> Result<T, ListResults> {
16        let result = self.list.remove(0);
17
18        match result {
19            Err(err) => return Err(err),
20            Ok(item) => {
21                return Ok(item);
22            }
23        }
24    }
25}
26
27impl<T: Clone + PartialEq> Collection<T> for Stack<T> {
28    fn contains(&self, data: T) -> bool {
29        self.list.contains(data)
30    }
31
32    fn insert(&mut self, data: T) {
33        self.list.insert(data);
34    }
35
36    fn is_empty(&self) -> bool {
37        self.list.is_empty()
38    }
39
40    fn len(&self) -> usize {
41        self.list.len()
42    }
43}
44
45#[cfg(test)]
46mod stack_tests {
47    use crate::{list::stack::Stack, traits::collection::Collection};
48
49    
50    #[test]
51    fn create_stack() {
52        let stack = Stack::<i8>::new();
53
54        assert!(stack.is_empty());
55        assert_eq!(stack.len(), 0);
56    }
57
58    #[test]
59    fn test_insert() {
60        let data = 1i8;
61        let mut stack = Stack::<i8>::new();
62        assert!(stack.is_empty());
63
64        stack.insert(data);
65
66        assert_eq!(stack.len(), 1);
67    }
68
69    #[test]
70    fn pop_test_if_stack_is_empty() {
71        let mut stack = Stack::<i8>::new();
72        assert!(stack.is_empty());
73        match stack.pop() {
74            Ok(_) => panic!("Must be return error"),
75            Err(_) => (),
76        }
77
78        assert!(stack.is_empty());
79    }
80
81    #[test]
82    fn pop_if_stack_is_not_empty() {
83        let data = 1i8;
84        let mut stack = Stack::<i8>::new();
85
86        assert!(stack.is_empty());
87
88        stack.insert(data);
89        assert!(!stack.is_empty());
90        assert!(stack.contains(data));
91
92        match stack.pop() {
93            Err(_) => panic!("Must return with a value"),
94            Ok(item) => assert_eq!(item, data),
95        }
96
97        assert!(stack.is_empty());
98    }
99}