snark-tool 0.4.0

snark-tool library contains structures and algorithm for (mainly) cubic graph analysis
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

use crate::graph::edge::EdgeConstructor;
use crate::graph::graph::{Graph, GraphConstructor};
use crate::graph::undirected::edge::UndirectedEdge;
use crate::graph::undirected::simple_graph::graph::SimpleGraph;
use crate::graph::vertex::Vertex;

fn get_graph() -> SimpleGraph {
    let mut graph = SimpleGraph::with_capacity(3, 3);
    graph.add_vertex();
    graph.add_vertex();
    graph.add_vertex();

    graph.add_edge(2, 0);
    graph.add_edge(2, 1);
    graph.add_edge(0, 1);
    graph
}

#[test]
fn simple_graph() {
    let mut graph = SimpleGraph::with_vertices_capacity(10);

    graph.add_edge(0, 1);
    graph.add_edge(2, 5);
    graph.add_edge(2, 4);

    let mut edges = graph.edges();
    let _edge = edges.next();
    // assert_eq!(edge, Some(UndirectedEdge::new(0, 1)));

    assert_eq!(graph.has_edge(0, 1), true);
    assert_eq!(graph.has_edge(2, 4), true);
    assert_eq!(graph.has_edge(2, 5), true);
    assert_eq!(graph.has_edge(1, 4), false);
    assert_eq!(graph.has_edge(2, 6), false);

    assert_eq!(graph.size(), 6);
}

#[test]
fn should_iter_edges() {
    let graph = get_graph();
    let mut edges = vec![];
    edges.push(UndirectedEdge::new(0, 1));
    edges.push(UndirectedEdge::new(0, 2));
    edges.push(UndirectedEdge::new(1, 2));

    let mut index = 0;
    for edge in graph.edges() {
        edges.retain(|edge_temp| edge_temp != edge);
        index += 1;
    }
    assert_eq!(index, 3);
    assert_eq!(edges.len(), 0);
}

#[test]
fn should_iter_edges_of_vertex() {
    let graph = get_graph();
    let mut edges = vec![];
    edges.push(UndirectedEdge::new(0, 1));
    edges.push(UndirectedEdge::new(1, 2));
    let mut index = 0;
    for edge in graph.edges_of_vertex(1) {
        edges.retain(|edge_temp| edge_temp != edge);
        index += 1;
    }
    assert_eq!(index, 2);
    assert_eq!(edges.len(), 0);
}

#[test]
fn should_remove_edges_of_vertex() {
    let mut graph = get_graph();
    assert_eq!(graph.vertices[0].edges.len(), 2);
    assert_eq!(graph.vertices[1].edges.len(), 2);
    assert_eq!(graph.vertices[2].edges.len(), 2);
    graph.remove_edges_of_vertex(0);
    assert_eq!(graph.vertices[0].edges.len(), 0);
    assert_eq!(graph.vertices[1].edges.len(), 1);
    assert_eq!(graph.vertices[2].edges.len(), 1);
}

#[test]
fn should_have_first_vertex() {
    let graph = get_graph();
    let first_vertex = graph.first_vertex();
    assert_eq!(first_vertex.is_some(), true);
    assert_eq!(first_vertex.unwrap().index(), 0);

    let mut graph = SimpleGraph::new();
    let first_vertex = graph.first_vertex();
    assert_eq!(first_vertex.is_none(), true);

    graph.add_vertex();
    let first_vertex = graph.first_vertex();
    assert_eq!(first_vertex.is_some(), true);
    assert_eq!(first_vertex.unwrap().index(), 0);
    graph.remove_vertex(0);
    let first_vertex = graph.first_vertex();
    assert_eq!(first_vertex.is_none(), true);

    graph.add_vertex();
    let first_vertex = graph.first_vertex();
    assert_eq!(first_vertex.is_some(), true);
    assert_eq!(first_vertex.unwrap().index(), 1);
}

#[test]
fn should_add_vertex_with_index() {
    let mut graph = SimpleGraph::new();
    graph.add_vertex_with_index(1);
    assert_eq!(graph.size(), 2);
    graph.add_vertex();
    assert_eq!(graph.size(), 3);
    assert_eq!(graph.has_vertex(0), false);
    assert_eq!(graph.has_vertex(1), true);
    graph.add_vertex_with_index(2);
    assert_eq!(graph.size(), 3);
    graph.add_vertex_with_index(3);
    assert_eq!(graph.size(), 4);
    graph.add_vertex_with_index(5);
    assert_eq!(graph.size(), 6);
    assert_eq!(graph.has_vertex(4), false);
    assert_eq!(graph.has_vertex(5), true);
}