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

use std::fs::OpenOptions;

use crate::graph::undirected::simple_graph::graph::SimpleGraph;
use crate::service::io::reader::GraphFileReader;
use crate::service::io::reader_ba::BaReader;
use crate::service::io::reader_g6::G6Reader;
use crate::service::io::reader_s6::S6Reader;
//use crate::service::io::writer_adj::AdjWriter;
use crate::service::io::writer_ba::BaWriter;
use crate::service::io::writer_g6::G6Writer;
use crate::service::io::writer_s6::S6Writer;
use crate::tests::test_data::test_data;

/// READERS
#[test]
fn should_read_g6() {
    let graph = G6Reader::<SimpleGraph>::read_graph(test_data::SNARK_IN_G6_10_PETERSEN);
    assert_eq!(graph.unwrap(), test_data::get_petersen_graph());
}

#[test]
fn should_read_s6() {
    let graph = S6Reader::<SimpleGraph>::read_graph(test_data::SNARK_IN_S6_10_PETERSEN);
    assert_eq!(graph.unwrap(), test_data::get_petersen_graph());
}

#[test]
fn should_read_ba() {
    let file = OpenOptions::new()
        .read(true)
        .open("resources/graphs/petersen.10")
        .unwrap();
    let mut reader = BaReader::<SimpleGraph>::new(&file);
    let graph = reader.next().unwrap().unwrap();
    assert_eq!(graph, test_data::get_petersen_graph());
}

#[test]
fn should_compare_readers() {
    let g6 = G6Reader::<SimpleGraph>::read_graph(test_data::SNARK_IN_G6_10_PETERSEN).unwrap();
    let s6 = S6Reader::<SimpleGraph>::read_graph(test_data::SNARK_IN_S6_10_PETERSEN).unwrap();
    let file = OpenOptions::new()
        .read(true)
        .open("resources/graphs/petersen.10")
        .unwrap();
    let mut reader = BaReader::<SimpleGraph>::new(&file);
    let ba = reader.next().unwrap().unwrap();
    assert_eq!(g6, s6);
    assert_eq!(g6, ba);
    assert_eq!(s6, ba);
}

/// WRITERS
#[test]
fn should_write_g6() {
    let mut target = Vec::new();
    let result = G6Writer::write_graph(&test_data::get_petersen_graph(), &mut target);
    let graph_string = String::from_utf8(target).unwrap();
    assert_eq!(result.is_ok(), true);
    assert_eq!(
        graph_string,
        format!("{}\n", test_data::SNARK_IN_G6_10_PETERSEN)
    );
}

#[test]
fn should_write_s6() {
    let mut target = Vec::new();
    let result = S6Writer::write_graph(&test_data::get_petersen_graph(), &mut target);
    let graph_string = String::from_utf8(target).unwrap();
    assert_eq!(result.is_ok(), true);
    assert_eq!(
        graph_string,
        format!("{}\n", test_data::SNARK_IN_S6_10_PETERSEN)
    );
}

#[test]
fn should_write_ba() {
    let mut target = Vec::new();
    let result = BaWriter::write_graph_ba(&test_data::get_petersen_graph(), 1, &mut target);
    let graph_string = String::from_utf8(target).unwrap();
    assert_eq!(result.is_ok(), true);
    assert_eq!(graph_string, test_data::SNARK_IN_BA_10_PETERSEN);
}

// #[test]
// fn should_write_adj_matrix() {
//     let mut target = Vec::new();
//     let result = AdjWriter::write_graph(&test_data::get_petersen_graph(), &mut target);
//     let graph_string = String::from_utf8(target).unwrap();
//     assert_eq!(result.is_ok(), true);
//     assert_eq!(graph_string, test_data::SNARK_IN_ADJ_10_PETERSEN);
// }

#[test]
fn should_read_g6_write_s6() {
    let mut target = Vec::new();
    let graph = G6Reader::<SimpleGraph>::read_graph(test_data::NO_SNARK_IN_G6_112);
    let result = S6Writer::write_graph(&graph.unwrap(), &mut target);
    let graph_string = String::from_utf8(target).unwrap();
    assert_eq!(result.is_ok(), true);
    assert_eq!(
        graph_string,
        format!("{}{}", test_data::NO_SNARK_IN_S6_112, "\n")
    );
}

#[test]
fn should_read_g6_s6_same_graph() {
    let graph_s6 = S6Reader::<SimpleGraph>::read_graph(test_data::NO_SNARK_IN_S6_112);
    let graph_g6 = G6Reader::<SimpleGraph>::read_graph(test_data::NO_SNARK_IN_G6_112);
    assert_eq!(graph_s6.unwrap(), graph_g6.unwrap());
}

// #[test]
// fn should_read_json() {
//     let file = OpenOptions::new().read(true).open("output").unwrap();
//
//     let mut reader = JsonReader::<SimpleGraph>::new(&file);
//     reader.next();
// }