data-structures 0.1.0

A simple data structures crate in rust, WIP
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

use super::linked_list::*;

fn get_new_linked_list_with_values<T: Copy>(vec: &Vec<T>) -> LinkedList<T> {
    let mut linked_list = LinkedList::<T>::new();

    for element in vec.iter() {
        linked_list.append(*element);
    }

    return linked_list;
}

#[test]
fn iter_mut_test() {
    let test_vector = vec![1, 2, 3, 4, 5];

    let mut linked_list = get_new_linked_list_with_values(&test_vector);

    let mut iter_mut = linked_list.iter_mut();

    for element in test_vector.iter() {
        let next = iter_mut.next().unwrap();
        *next += 1;
        assert_eq!(*element + 1, *next);
    }
}

#[test]
fn iter_test() {
    let test_vector = vec![1, 2, 3, 4, 5];

    let linked_list = get_new_linked_list_with_values(&test_vector);

    let mut iter = linked_list.iter();

    for element in test_vector.iter() {
        let next = iter.next().unwrap();
        assert_eq!(*element, *next);
    }
}

#[test]
fn into_iter_test() {
    let test_vector = vec![1, 2, 3, 4, 5];

    let linked_list = get_new_linked_list_with_values(&test_vector);

    let mut into_iter = linked_list.into_iter();

    for element in test_vector.iter() {
        let next = into_iter.next().unwrap();
        assert_eq!(*element, next);
    }
}

#[test]
fn fmt_display_test() {
    let test_vector = vec![1, 2, 3, 4, 5];

    let linked_list = get_new_linked_list_with_values(&test_vector);

    assert_eq!(
        format!("{}", linked_list),
        "HEAD -> 1 -> 2 -> 3 -> 4 -> 5 -> None"
    );
}

#[test]
fn delete_at_posn_test() {
    let test_vector = vec![1, 2, 3, 4, 5];

    let mut linked_list = get_new_linked_list_with_values(&test_vector);

    linked_list
        .delete_at_posn(2)
        .expect("Error while deleting from 2nd posn");

    assert_eq!(
        format!("{}", linked_list),
        "HEAD -> 1 -> 2 -> 4 -> 5 -> None"
    );

    linked_list
        .delete_at_posn(2)
        .expect("Error while deleting from 2nd posn");
    assert_eq!(format!("{}", linked_list), "HEAD -> 1 -> 2 -> 5 -> None");

    if let Ok(_) = linked_list.delete_at_posn(3) {
        panic!("Should have caused error as we are trying to delete at a posn greater than length");
    }

    assert_eq!(linked_list.length, 3);
}

#[test]
fn delete_where_test() {
    let test_vector = vec![1, 2, 3, 4, 5];

    let mut linked_list = get_new_linked_list_with_values(&test_vector);

    let mut counter = 3;
    linked_list
        .delete_where(move |_element| {
            counter -= 1;
            counter > -1
        })
        .expect("Unexpected error");

    assert_eq!(format!("{}", linked_list), "HEAD -> 4 -> 5 -> None");
}

#[test]
fn reverse_test() {
    let test_vector = vec![1, 2, 3, 4, 5];

    let linked_list = get_new_linked_list_with_values(&test_vector);

    let reversed_linked_list = linked_list.reverse();

    assert_eq!(
        format!("{}", reversed_linked_list),
        "HEAD -> 5 -> 4 -> 3 -> 2 -> 1 -> None"
    );
}