rusted-mem 0.1.0

pub struct Nodes<T> {
     data: Vec<Node<T>>
}

impl<T> Nodes<T> {
    pub fn new() -> Nodes<T> {
        Nodes {
            data: Vec::new()
        }
    }

    pub fn add_node(&mut self, member: Node<T>) {
        self.data.push(member)
    }

    pub fn is_empty(&mut self) -> bool {
        self.data.len() == 0
    }

    pub fn pop_node(&mut self) -> Option<Node<T>>{
        self.data.pop()
    }
}

pub struct Node<T> {
    key: String,
    value: Option<T>
}

impl<T> Node<T> {
    pub fn new(t_key: &str, t_value: Option<T>) -> Node<T>{
        Node {
            key: String::from(t_key),
            value: Option::from(t_value)
        }
    }
}





#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]    
    fn add_node_to_nodes() {
        let mut n: Nodes<&str> = Nodes::new();
        let d = Node::new("Key1", Option::from("Hello"));
        n.add_node(d);
        let dd = n.pop_node();
        assert!(dd.is_some());
        match dd {
            Some(node) => match node.value {
                Some(value) => {
                    assert_eq!(node.key, "Key1");
                    assert_eq!(value, "Hello")
                },
                None => {}
            },
            None => {}
        }
    }

    #[test]
    fn pop_empty_nodes(){
        let mut n: Nodes<&str> = Nodes::new();
        let dd = n.pop_node();
        assert!(dd.is_none())
    }
    #[test]
    fn nodes_is_empty(){
        let mut n: Nodes<&str> = Nodes::new();
        assert!(n.is_empty())
    }
}