graphific 0.1.1

Graphific is a graph data structure library.
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

#[cfg(test)]
#[macro_use]
extern crate pretty_assertions;

#[cfg(test)]
mod vertex_tests {
    use graphific::Vertex;

    #[test]
    fn new_vertex_test() {
        let v1: Vertex<i32, i32> = Vertex::new(0);
        let v2: Vertex<i32, i32> = Vertex::new(1);
        let v3: Vertex<i32, f32> = Vertex::new(2);

        assert_eq!(0, *v1.key());
        assert_eq!(0, *v1.value());
        assert_eq!(i32::default(), *v1.value());
        assert_eq!(1, *v2.key());
        assert_eq!(0, *v2.value());
        assert_eq!(i32::default(), *v2.value());
        assert_eq!(2, *v3.key());
        assert_eq!(0.0, *v3.value());
        assert_eq!(f32::default(), *v3.value());
    }

    #[test]
    fn with_value_test() {
        let v1: Vertex<i32, i32> = Vertex::with_value(0, 10);
        let v2: Vertex<i32, i32> = Vertex::with_value(1, 11);
        let v3: Vertex<i32, f32> = Vertex::with_value(2, 12.0);

        assert_eq!(0, *v1.key());
        assert_eq!(10, *v1.value());
        assert_ne!(i32::default(), *v1.value());
        assert_eq!(1, *v2.key());
        assert_eq!(11, *v2.value());
        assert_ne!(i32::default(), *v2.value());
        assert_eq!(2, *v3.key());
        assert_eq!(12.0, *v3.value());
        assert_ne!(f32::default(), *v3.value());
    }

    #[test]
    fn set_value_test() {
        let mut v1: Vertex<i32, i32> = Vertex::new(0);
        let mut v2: Vertex<i32, f32> = Vertex::new(1);

        assert_eq!(0, *v1.key());
        assert_eq!(0, *v1.value());
        assert_eq!(i32::default(), *v1.value());
        assert_eq!(1, *v2.key());
        assert_eq!(0.0, *v2.value());
        assert_eq!(f32::default(), *v2.value());

        v1.set_value(10);
        v2.set_value(11.0);

        assert_eq!(10, *v1.value());
        assert_ne!(i32::default(), *v1.value());
        assert_eq!(11.0, *v2.value());
        assert_ne!(f32::default(), *v2.value());
    }
}

#[cfg(test)]
mod edges_tests {
    use graphific::{Edge, Vertex};

    #[test]
    fn new_edge_test() {
        let v1: Vertex<i32, i32> = Vertex::with_value(0, 10);
        let v2: Vertex<i32, i32> = Vertex::with_value(1, 11);
        let v3: Vertex<i32, f32> = Vertex::with_value(2, 12.0);

        let e1: Edge<&i32> = Edge::new(v1.key(), v2.key());
        let e2: Edge<&i32> = Edge::new(v2.key(), v1.key());
        let e3: Edge<i32> = Edge::new(*v1.key(), *v3.key());
        let e4: Edge<i32> = Edge::new(*v3.key(), *v2.key());

        // test with borrow
        assert_eq!(0, **e1.from());
        assert_eq!(v1.key(), *e1.from());
        assert_eq!(1, **e1.to());
        assert_eq!(v2.key(), *e1.to());
        assert_eq!(1, **e2.from());
        assert_eq!(v2.key(), *e2.from());
        assert_eq!(0, **e2.to());
        assert_eq!(v1.key(), *e2.to());

        // test with direct value
        assert_eq!(0, *e3.from());
        assert_eq!(v1.key(), e3.from());
        assert_eq!(2, *e3.to());
        assert_eq!(v3.key(), e3.to());
        assert_eq!(2, *e4.from());
        assert_eq!(v3.key(), e4.from());
        assert_eq!(1, *e4.to());
        assert_eq!(v2.key(), e4.to());
    }
}