compiletest: Do not run debuginfo tests with gdb on msvc targets

[rust.git] / src / libgraphviz / tests.rs

diff --git a/src/libgraphviz/tests.rs b/src/libgraphviz/tests.rs
index 2f713579b17fa0416204f8b0d5abc971d1494f91..055e13156ae84e3cb682d3caaa656e66cbd2b9b9 100644 (file)
--- a/src/libgraphviz/tests.rs
+++ b/src/libgraphviz/tests.rs
@@ -1,8 +1,8 @@
-use NodeLabels::*;
-use super::{Id, Labeller, Nodes, Edges, GraphWalk, render, Style};
-use super::LabelText::{self, LabelStr, EscStr, HtmlStr};
+use super::LabelText::{self, EscStr, HtmlStr, LabelStr};
+use super::{render, Edges, GraphWalk, Id, Labeller, Nodes, Style};
 use std::io;
 use std::io::prelude::*;
+use NodeLabels::*;
 
 /// each node is an index in a vector in the graph.
 type Node = usize;
@@ -14,12 +14,7 @@ struct Edge {
 }
 
 fn edge(from: usize, to: usize, label: &'static str, style: Style) -> Edge {
-    Edge {
-        from,
-        to,
-        label,
-        style,
-    }
+    Edge { from, to, label, style }
 }
 
 struct LabelledGraph {
@@ -75,11 +70,12 @@ fn len(&self) -> usize {
 }
 
 impl LabelledGraph {
-    fn new(name: &'static str,
-           node_labels: Trivial,
-           edges: Vec<Edge>,
-           node_styles: Option<Vec<Style>>)
-           -> LabelledGraph {
+    fn new(
+        name: &'static str,
+        node_labels: Trivial,
+        edges: Vec<Edge>,
+        node_styles: Option<Vec<Style>>,
+    ) -> LabelledGraph {
         let count = node_labels.len();
         LabelledGraph {
             name,
@@ -94,10 +90,7 @@ fn new(name: &'static str,
 }
 
 impl LabelledGraphWithEscStrs {
-    fn new(name: &'static str,
-           node_labels: Trivial,
-           edges: Vec<Edge>)
-           -> LabelledGraphWithEscStrs {
+    fn new(name: &'static str, node_labels: Trivial, edges: Vec<Edge>) -> LabelledGraphWithEscStrs {
         LabelledGraphWithEscStrs { graph: LabelledGraph::new(name, node_labels, edges, None) }
     }
 }
@@ -203,21 +196,25 @@ fn test_input(g: LabelledGraph) -> io::Result<String> {
 fn empty_graph() {
     let labels: Trivial = UnlabelledNodes(0);
     let r = test_input(LabelledGraph::new("empty_graph", labels, vec![], None));
-    assert_eq!(r.unwrap(),
-r#"digraph empty_graph {
+    assert_eq!(
+        r.unwrap(),
+        r#"digraph empty_graph {
 }
-"#);
+"#
+    );
 }
 
 #[test]
 fn single_node() {
     let labels: Trivial = UnlabelledNodes(1);
     let r = test_input(LabelledGraph::new("single_node", labels, vec![], None));
-    assert_eq!(r.unwrap(),
-r#"digraph single_node {
+    assert_eq!(
+        r.unwrap(),
+        r#"digraph single_node {
     N0[label="N0"];
 }
-"#);
+"#
+    );
 }
 
 #[test]
@@ -225,89 +222,112 @@ fn single_node_with_style() {
     let labels: Trivial = UnlabelledNodes(1);
     let styles = Some(vec![Style::Dashed]);
     let r = test_input(LabelledGraph::new("single_node", labels, vec![], styles));
-    assert_eq!(r.unwrap(),
-r#"digraph single_node {
+    assert_eq!(
+        r.unwrap(),
+        r#"digraph single_node {
     N0[label="N0"][style="dashed"];
 }
-"#);
+"#
+    );
 }
 
 #[test]
 fn single_edge() {
     let labels: Trivial = UnlabelledNodes(2);
-    let result = test_input(LabelledGraph::new("single_edge",
-                                               labels,
-                                               vec![edge(0, 1, "E", Style::None)],
-                                               None));
-    assert_eq!(result.unwrap(),
-r#"digraph single_edge {
+    let result = test_input(LabelledGraph::new(
+        "single_edge",
+        labels,
+        vec![edge(0, 1, "E", Style::None)],
+        None,
+    ));
+    assert_eq!(
+        result.unwrap(),
+        r#"digraph single_edge {
     N0[label="N0"];
     N1[label="N1"];
     N0 -> N1[label="E"];
 }
-"#);
+"#
+    );
 }
 
 #[test]
 fn single_edge_with_style() {
     let labels: Trivial = UnlabelledNodes(2);
-    let result = test_input(LabelledGraph::new("single_edge",
-                                               labels,
-                                               vec![edge(0, 1, "E", Style::Bold)],
-                                               None));
-    assert_eq!(result.unwrap(),
-r#"digraph single_edge {
+    let result = test_input(LabelledGraph::new(
+        "single_edge",
+        labels,
+        vec![edge(0, 1, "E", Style::Bold)],
+        None,
+    ));
+    assert_eq!(
+        result.unwrap(),
+        r#"digraph single_edge {
     N0[label="N0"];
     N1[label="N1"];
     N0 -> N1[label="E"][style="bold"];
 }
-"#);
+"#
+    );
 }
 
 #[test]
 fn test_some_labelled() {
     let labels: Trivial = SomeNodesLabelled(vec![Some("A"), None]);
     let styles = Some(vec![Style::None, Style::Dotted]);
-    let result = test_input(LabelledGraph::new("test_some_labelled",
-                                               labels,
-                                               vec![edge(0, 1, "A-1", Style::None)],
-                                               styles));
-    assert_eq!(result.unwrap(),
-r#"digraph test_some_labelled {
+    let result = test_input(LabelledGraph::new(
+        "test_some_labelled",
+        labels,
+        vec![edge(0, 1, "A-1", Style::None)],
+        styles,
+    ));
+    assert_eq!(
+        result.unwrap(),
+        r#"digraph test_some_labelled {
     N0[label="A"];
     N1[label="N1"][style="dotted"];
     N0 -> N1[label="A-1"];
 }
-"#);
+"#
+    );
 }
 
 #[test]
 fn single_cyclic_node() {
     let labels: Trivial = UnlabelledNodes(1);
-    let r = test_input(LabelledGraph::new("single_cyclic_node",
-                                          labels,
-                                          vec![edge(0, 0, "E", Style::None)],
-                                          None));
-    assert_eq!(r.unwrap(),
-r#"digraph single_cyclic_node {
+    let r = test_input(LabelledGraph::new(
+        "single_cyclic_node",
+        labels,
+        vec![edge(0, 0, "E", Style::None)],
+        None,
+    ));
+    assert_eq!(
+        r.unwrap(),
+        r#"digraph single_cyclic_node {
     N0[label="N0"];
     N0 -> N0[label="E"];
 }
-"#);
+"#
+    );
 }
 
 #[test]
 fn hasse_diagram() {
     let labels = AllNodesLabelled(vec!["{x,y}", "{x}", "{y}", "{}"]);
-    let r = test_input(LabelledGraph::new("hasse_diagram",
-                                          labels,
-                                          vec![edge(0, 1, "", Style::None),
-                                               edge(0, 2, "", Style::None),
-                                               edge(1, 3, "", Style::None),
-                                               edge(2, 3, "", Style::None)],
-                                          None));
-    assert_eq!(r.unwrap(),
-r#"digraph hasse_diagram {
+    let r = test_input(LabelledGraph::new(
+        "hasse_diagram",
+        labels,
+        vec![
+            edge(0, 1, "", Style::None),
+            edge(0, 2, "", Style::None),
+            edge(1, 3, "", Style::None),
+            edge(2, 3, "", Style::None),
+        ],
+        None,
+    ));
+    assert_eq!(
+        r.unwrap(),
+        r#"digraph hasse_diagram {
     N0[label="{x,y}"];
     N1[label="{x}"];
     N2[label="{y}"];
@@ -317,7 +337,8 @@ fn hasse_diagram() {
     N1 -> N3[label=""];
     N2 -> N3[label=""];
 }
-"#);
+"#
+    );
 }
 
 #[test]
@@ -332,23 +353,29 @@ fn left_aligned_text() {
        \\l",
         "branch1",
         "branch2",
-        "afterward"]);
+        "afterward",
+    ]);
 
     let mut writer = Vec::new();
 
-    let g = LabelledGraphWithEscStrs::new("syntax_tree",
-                                          labels,
-                                          vec![edge(0, 1, "then", Style::None),
-                                               edge(0, 2, "else", Style::None),
-                                               edge(1, 3, ";", Style::None),
-                                               edge(2, 3, ";", Style::None)]);
+    let g = LabelledGraphWithEscStrs::new(
+        "syntax_tree",
+        labels,
+        vec![
+            edge(0, 1, "then", Style::None),
+            edge(0, 2, "else", Style::None),
+            edge(1, 3, ";", Style::None),
+            edge(2, 3, ";", Style::None),
+        ],
+    );
 
     render(&g, &mut writer).unwrap();
     let mut r = String::new();
     Read::read_to_string(&mut &*writer, &mut r).unwrap();
 
-    assert_eq!(r,
-r#"digraph syntax_tree {
+    assert_eq!(
+        r,
+        r#"digraph syntax_tree {
     N0[label="if test {\l    branch1\l} else {\l    branch2\l}\lafterward\l"];
     N1[label="branch1"];
     N2[label="branch2"];
@@ -358,7 +385,8 @@ fn left_aligned_text() {
     N1 -> N3[label=";"];
     N2 -> N3[label=";"];
 }
-"#);
+"#
+    );
 }
 
 #[test]