Migrate fixture tests

Cargo.toml

@@ -123,22 +123,13 @@ unicode-width = "0.2.0"
 [dev-dependencies]
 annotate-snippets = { path = ".", features = ["testing-colors"] }
 anstream = "0.6.13"
-difference = "2.0.0"
 divan = "0.1.14"
-glob = "0.3.1"
-serde = { version = "1.0.199", features = ["derive"] }
 snapbox = { version = "0.6.0", features = ["diff", "term-svg", "cmd", "examples"] }
-toml = "0.8.0"
-tryfn = "0.2.1"
 
 [[bench]]
 name = "bench"
 harness = false
 
-[[test]]
-name = "fixtures"
-harness = false
-
 [features]
 default = []
 simd = ["memchr"]

tests/color/ann_eof.rs

@@ -0,0 +1,18 @@
+use annotate_snippets::{AnnotationKind, Group, Level, Renderer, Snippet};
+
+use snapbox::{assert_data_eq, file};
+
+#[test]
+fn case() {
+    let input = Level::ERROR.header("expected `.`, `=`").group(
+        Group::new().element(
+            Snippet::source("asdf")
+                .origin("Cargo.toml")
+                .line_start(1)
+                .annotation(AnnotationKind::Primary.span(4..4).label("")),
+        ),
+    );
+    let expected = file!["ann_eof.term.svg"];
+    let renderer = Renderer::styled();
+    assert_data_eq!(renderer.render(input), expected);
+}

tests/color/ann_insertion.rs

@@ -0,0 +1,18 @@
+use annotate_snippets::{AnnotationKind, Group, Level, Renderer, Snippet};
+
+use snapbox::{assert_data_eq, file};
+
+#[test]
+fn case() {
+    let input = Level::ERROR.header("expected `.`, `=`").group(
+        Group::new().element(
+            Snippet::source("asf")
+                .origin("Cargo.toml")
+                .line_start(1)
+                .annotation(AnnotationKind::Primary.span(2..2).label("'d' belongs here")),
+        ),
+    );
+    let expected = file!["ann_insertion.term.svg"];
+    let renderer = Renderer::styled();
+    assert_data_eq!(renderer.render(input), expected);
+}

tests/color/ann_multiline.rs

@@ -0,0 +1,31 @@
+use annotate_snippets::{AnnotationKind, Group, Level, Renderer, Snippet};
+
+use snapbox::{assert_data_eq, file};
+
+#[test]
+fn case() {
+    let source = r#"                        if let DisplayLine::Source {
+                            ref mut inline_marks,
+                        } = body[body_idx]
+"#;
+
+    let input = Level::ERROR
+        .header("pattern does not mention fields `lineno`, `content`")
+        .id("E0027")
+        .group(
+            Group::new().element(
+                Snippet::source(source)
+                    .origin("src/display_list.rs")
+                    .line_start(139)
+                    .fold(false)
+                    .annotation(
+                        AnnotationKind::Primary
+                            .span(31..128)
+                            .label("missing fields `lineno`, `content`"),
+                    ),
+            ),
+        );
+    let expected = file!["ann_multiline.term.svg"];
+    let renderer = Renderer::styled();
+    assert_data_eq!(renderer.render(input), expected);
+}

tests/color/ann_multiline2.rs

@@ -0,0 +1,31 @@
+use annotate_snippets::{AnnotationKind, Group, Level, Renderer, Snippet};
+
+use snapbox::{assert_data_eq, file};
+
+#[test]
+fn case() {
+    let source = r#"This is an example
+of an edge case of an annotation overflowing
+to exactly one character on next line.
+"#;
+
+    let input = Level::ERROR
+        .header("spacing error found")
+        .id("E####")
+        .group(
+            Group::new().element(
+                Snippet::source(source)
+                    .origin("foo.txt")
+                    .line_start(26)
+                    .fold(false)
+                    .annotation(
+                        AnnotationKind::Primary
+                            .span(11..19)
+                            .label("this should not be on separate lines"),
+                    ),
+            ),
+        );
+    let expected = file!["ann_multiline2.term.svg"];
+    let renderer = Renderer::styled();
+    assert_data_eq!(renderer.render(input), expected);
+}

tests/color/ann_removed_nl.rs

@@ -0,0 +1,18 @@
+use annotate_snippets::{AnnotationKind, Group, Level, Renderer, Snippet};
+
+use snapbox::{assert_data_eq, file};
+
+#[test]
+fn case() {
+    let input = Level::ERROR.header("expected `.`, `=`").group(
+        Group::new().element(
+            Snippet::source("asdf")
+                .origin("Cargo.toml")
+                .line_start(1)
+                .annotation(AnnotationKind::Primary.span(4..5).label("")),
+        ),
+    );
+    let expected = file!["ann_removed_nl.term.svg"];
+    let renderer = Renderer::styled();
+    assert_data_eq!(renderer.render(input), expected);
+}

tests/color/ensure_emoji_highlight_width.rs

@@ -0,0 +1,24 @@
+use annotate_snippets::{AnnotationKind, Group, Level, Renderer, Snippet};
+
+use snapbox::{assert_data_eq, file};
+
+#[test]
+fn case() {
+    let source = r#""haha this isn't a valid name 🐛" = { package = "libc", version = "0.1" }
+"#;
+
+    let input = Level::ERROR.header("invalid character ` ` in package name: `haha this isn't a valid name 🐛`, characters must be Unicode XID characters (numbers, `-`, `_`, or most letters)")
+        .group(
+            Group::new()
+                .element(
+                    Snippet::source(source)
+                        .origin("<file>")
+                        .line_start(7)
+                        .annotation(AnnotationKind::Primary.span(0..35).label(""))
+                )
+            )
+;
+    let expected = file!["ensure_emoji_highlight_width.term.svg"];
+    let renderer = Renderer::styled();
+    assert_data_eq!(renderer.render(input), expected);
+}

tests/color/fold_ann_multiline.rs

@@ -0,0 +1,50 @@
+use annotate_snippets::{AnnotationKind, Group, Level, Renderer, Snippet};
+
+use snapbox::{assert_data_eq, file};
+
+#[test]
+fn case() {
+    let source = r#") -> Option<String> {
+    for ann in annotations {
+        match (ann.range.0, ann.range.1) {
+            (None, None) => continue,
+            (Some(start), Some(end)) if start > end_index || end < start_index => continue,
+            (Some(start), Some(end)) if start >= start_index && end <= end_index => {
+                let label = if let Some(ref label) = ann.label {
+                    format!(" {}", label)
+                } else {
+                    String::from("")
+                };
+
+                return Some(format!(
+                    "{}{}{}",
+                    " ".repeat(start - start_index),
+                    "^".repeat(end - start),
+                    label
+                ));
+            }
+            _ => continue,
+        }
+    }
+"#;
+
+    let input = Level::ERROR.header("mismatched types").id("E0308").group(
+        Group::new().element(
+            Snippet::source(source)
+                .origin("src/format.rs")
+                .line_start(51)
+                .fold(true)
+                .annotation(AnnotationKind::Context.span(5..19).label(
+                    "expected `std::option::Option<std::string::String>` because of return type",
+                ))
+                .annotation(
+                    AnnotationKind::Primary
+                        .span(22..766)
+                        .label("expected enum `std::option::Option`, found ()"),
+                ),
+        ),
+    );
+    let expected = file!["fold_ann_multiline.term.svg"];
+    let renderer = Renderer::styled();
+    assert_data_eq!(renderer.render(input), expected);
+}

tests/color/fold_bad_origin_line.rs

@@ -0,0 +1,24 @@
+use annotate_snippets::{AnnotationKind, Group, Level, Renderer, Snippet};
+
+use snapbox::{assert_data_eq, file};
+
+#[test]
+fn case() {
+    let source = r#"
+
+invalid syntax
+"#;
+
+    let input = Level::ERROR.header("").group(
+        Group::new().element(
+            Snippet::source(source)
+                .origin("path/to/error.rs")
+                .line_start(1)
+                .fold(true)
+                .annotation(AnnotationKind::Context.span(2..16).label("error here")),
+        ),
+    );
+    let expected = file!["fold_bad_origin_line.term.svg"];
+    let renderer = Renderer::styled();
+    assert_data_eq!(renderer.render(input), expected);
+}

tests/color/fold_leading.rs

@@ -0,0 +1,35 @@
+use annotate_snippets::{AnnotationKind, Group, Level, Renderer, Snippet};
+
+use snapbox::{assert_data_eq, file};
+
+#[test]
+fn case() {
+    let source = r#"[workspace]
+
+[package]
+name = "hello"
+version = "1.0.0"
+license = "MIT"
+rust-version = "1.70"
+edition = "2021"
+
+[lints]
+workspace = 20
+"#;
+
+    let input = Level::ERROR
+        .header("invalid type: integer `20`, expected a bool")
+        .id("E0308")
+        .group(
+            Group::new().element(
+                Snippet::source(source)
+                    .origin("Cargo.toml")
+                    .line_start(1)
+                    .fold(true)
+                    .annotation(AnnotationKind::Primary.span(132..134).label("")),
+            ),
+        );
+    let expected = file!["fold_leading.term.svg"];
+    let renderer = Renderer::styled();
+    assert_data_eq!(renderer.render(input), expected);
+}

tests/color/fold_trailing.rs

@@ -0,0 +1,34 @@
+use annotate_snippets::{AnnotationKind, Group, Level, Renderer, Snippet};
+
+use snapbox::{assert_data_eq, file};
+
+#[test]
+fn case() {
+    let source = r#"lints = 20
+
+[workspace]
+
+[package]
+name = "hello"
+version = "1.0.0"
+license = "MIT"
+rust-version = "1.70"
+edition = "2021"
+"#;
+
+    let input = Level::ERROR
+        .header("invalid type: integer `20`, expected a lints table")
+        .id("E0308")
+        .group(
+            Group::new().element(
+                Snippet::source(source)
+                    .origin("Cargo.toml")
+                    .line_start(1)
+                    .fold(true)
+                    .annotation(AnnotationKind::Primary.span(8..10).label("")),
+            ),
+        );
+    let expected = file!["fold_trailing.term.svg"];
+    let renderer = Renderer::styled();
+    assert_data_eq!(renderer.render(input), expected);
+}

tests/color/issue_9.rs

@@ -0,0 +1,31 @@
+use annotate_snippets::{AnnotationKind, Group, Level, Renderer, Snippet};
+
+use snapbox::{assert_data_eq, file};
+
+#[test]
+fn case() {
+    let input = Level::ERROR.header("expected one of `.`, `;`, `?`, or an operator, found `for`")
+        .group(
+            Group::new()
+                .element(
+                    Snippet::source("let x = vec![1];")
+                        .origin("/code/rust/src/test/ui/annotate-snippet/suggestion.rs")
+                        .line_start(4)
+                        .annotation(AnnotationKind::Context.span(4..5).label("move occurs because `x` has type `std::vec::Vec<i32>`, which does not implement the `Copy` trait"))
+                )
+                .element(
+                    Snippet::source("let y = x;")
+                        .line_start(7)
+                        .annotation(AnnotationKind::Context.span(8..9).label("value moved here"))
+                )
+                .element(
+                    Snippet::source("x;")
+                        .line_start(9)
+                        .annotation(AnnotationKind::Primary.span(0..1).label("value used here after move"))
+                )
+            )
+;
+    let expected = file!["issue_9.term.svg"];
+    let renderer = Renderer::styled();
+    assert_data_eq!(renderer.render(input), expected);
+}

tests/color/main.rs

@@ -0,0 +1,16 @@
+mod ann_eof;
+mod ann_insertion;
+mod ann_multiline;
+mod ann_multiline2;
+mod ann_removed_nl;
+mod ensure_emoji_highlight_width;
+mod fold_ann_multiline;
+mod fold_bad_origin_line;
+mod fold_leading;
+mod fold_trailing;
+mod issue_9;
+mod multiple_annotations;
+mod simple;
+mod strip_line;
+mod strip_line_char;
+mod strip_line_non_ws;