| //! Minimalistic snapshot testing for Rust. | |
| //! | |
| //! # Introduction | |
| //! | |
| //! `expect_test` is a small addition over plain `assert_eq!` testing approach, | |
| //! which allows to automatically update tests results. | |
| //! | |
| //! The core of the library is the `expect!` macro. It can be though of as a | |
| //! super-charged string literal, which can update itself. | |
| //! | |
| //! Let's see an example: | |
| //! | |
| //! ```no_run | |
| //! use expect_test::expect; | |
| //! | |
| //! let actual = 2 + 2; | |
| //! let expected = expect!["5"]; // or expect![["5"]] | |
| //! expected.assert_eq(&actual.to_string()) | |
| //! ``` | |
| //! | |
| //! Running this code will produce a test failure, as `"5"` is indeed not equal | |
| //! to `"4"`. Running the test with `UPDATE_EXPECT=1` env variable however would | |
| //! "magically" update the code to: | |
| //! | |
| //! ```no_run | |
| //! # use expect_test::expect; | |
| //! let actual = 2 + 2; | |
| //! let expected = expect!["4"]; | |
| //! expected.assert_eq(&actual.to_string()) | |
| //! ``` | |
| //! | |
| //! This becomes very useful when you have a lot of tests with verbose and | |
| //! potentially changing expected output. | |
| //! | |
| //! Under the hood, the `expect!` macro uses `file!`, `line!` and `column!` to | |
| //! record source position at compile time. At runtime, this position is used | |
| //! to patch the file in-place, if `UPDATE_EXPECT` is set. | |
| //! | |
| //! # Guide | |
| //! | |
| //! `expect!` returns an instance of `Expect` struct, which holds position | |
| //! information and a string literal. Use `Expect::assert_eq` for string | |
| //! comparison. Use `Expect::assert_debug_eq` for verbose debug comparison. Note | |
| //! that leading indentation is automatically removed. | |
| //! | |
| //! ``` | |
| //! use expect_test::expect; | |
| //! | |
| //! #[derive(Debug)] | |
| //! struct Foo { | |
| //! value: i32, | |
| //! } | |
| //! | |
| //! let actual = Foo { value: 92 }; | |
| //! let expected = expect![[" | |
| //! Foo { | |
| //! value: 92, | |
| //! } | |
| //! "]]; | |
| //! expected.assert_debug_eq(&actual); | |
| //! ``` | |
| //! | |
| //! Be careful with `assert_debug_eq` - in general, stability of the debug | |
| //! representation is not guaranteed. However, even if it changes, you can | |
| //! quickly update all the tests by running the test suite with `UPDATE_EXPECT` | |
| //! environmental variable set. | |
| //! | |
| //! If the expected data is too verbose to include inline, you can store it in | |
| //! an external file using the `expect_file!` macro: | |
| //! | |
| //! ```no_run | |
| //! use expect_test::expect_file; | |
| //! | |
| //! let actual = 42; | |
| //! let expected = expect_file!["./the-answer.txt"]; | |
| //! expected.assert_eq(&actual.to_string()); | |
| //! ``` | |
| //! | |
| //! File path is relative to the current file. | |
| //! | |
| //! # Suggested Workflows | |
| //! | |
| //! I like to use data-driven tests with `expect_test`. I usually define a | |
| //! single driver function `check` and then call it from individual tests: | |
| //! | |
| //! ``` | |
| //! use expect_test::{expect, Expect}; | |
| //! | |
| //! fn check(actual: i32, expect: Expect) { | |
| //! let actual = actual.to_string(); | |
| //! expect.assert_eq(&actual); | |
| //! } | |
| //! | |
| //! #[test] | |
| //! fn test_addition() { | |
| //! check(90 + 2, expect![["92"]]); | |
| //! } | |
| //! | |
| //! #[test] | |
| //! fn test_multiplication() { | |
| //! check(46 * 2, expect![["92"]]); | |
| //! } | |
| //! ``` | |
| //! | |
| //! Each test's body is a single call to `check`. All the variation in tests | |
| //! comes from the input data. | |
| //! | |
| //! When writing a new test, I usually copy-paste an old one, leave the `expect` | |
| //! blank and use `UPDATE_EXPECT` to fill the value for me: | |
| //! | |
| //! ``` | |
| //! # use expect_test::{expect, Expect}; | |
| //! # fn check(_: i32, _: Expect) {} | |
| //! #[test] | |
| //! fn test_division() { | |
| //! check(92 / 2, expect![[""]]) | |
| //! } | |
| //! ``` | |
| //! | |
| //! See | |
| //! <https://blog.janestreet.com/using-ascii-waveforms-to-test-hardware-designs/> | |
| //! for a cool example of snapshot testing in the wild! | |
| //! | |
| //! # Alternatives | |
| //! | |
| //! * [insta](https://crates.io/crates/insta) - a more feature full snapshot | |
| //! testing library. | |
| //! * [k9](https://crates.io/crates/k9) - a testing library which includes | |
| //! support for snapshot testing among other things. | |
| //! | |
| //! # Maintenance status | |
| //! | |
| //! The main customer of this library is rust-analyzer. The library is stable, | |
| //! it is planned to not release any major versions past 1.0. | |
| //! | |
| //! ## Minimal Supported Rust Version | |
| //! | |
| //! This crate's minimum supported `rustc` version is `1.60.0`. MSRV is updated | |
| //! conservatively, supporting roughly 10 minor versions of `rustc`. MSRV bump | |
| //! is not considered semver breaking, but will require at least minor version | |
| //! bump. | |
| // FIXME: fix the lints | |
| #![expect(mismatched_lifetime_syntaxes)] | |
| #![expect(elided_lifetimes_in_paths)] | |
| #![expect( | |
| clippy::disallowed_types, | |
| clippy::print_stdout, | |
| clippy::test_attr_in_doctest, | |
| clippy::skip_while_next, | |
| clippy::str_to_string | |
| )] | |
| use std::{ | |
| collections::HashMap, | |
| convert::TryInto, | |
| env, fmt, fs, mem, | |
| ops::Range, | |
| panic, | |
| path::{Path, PathBuf}, | |
| sync::Mutex, | |
| }; | |
| use once_cell::sync::{Lazy, OnceCell}; | |
| const HELP: &str = " | |
| You can update all `expect!` tests by running: | |
| env UPDATE_EXPECT=1 cargo test | |
| To update a single test, place the cursor on `expect` token and use `run` feature of rust-analyzer. | |
| "; | |
| fn update_expect() -> bool { | |
| env::var("UPDATE_EXPECT").is_ok() | |
| } | |
| /// Creates an instance of `Expect` from string literal: | |
| /// | |
| /// ``` | |
| /// # use expect_test::expect; | |
| /// expect![[" | |
| /// Foo { value: 92 } | |
| /// "]]; | |
| /// expect![r#"{"Foo": 92}"#]; | |
| /// ``` | |
| /// | |
| /// Leading indentation is stripped. | |
| #[macro_export] | |
| macro_rules! expect { | |
| [$data:literal] => { $crate::expect![[$data]] }; | |
| [[$data:literal]] => {$crate::Expect { | |
| position: $crate::Position { | |
| file: file!(), | |
| line: line!(), | |
| column: column!(), | |
| }, | |
| data: $data, | |
| indent: true, | |
| }}; | |
| [] => { $crate::expect![[""]] }; | |
| [[]] => { $crate::expect![[""]] }; | |
| } | |
| /// Creates an instance of `ExpectFile` from relative or absolute path: | |
| /// | |
| /// ``` | |
| /// # use expect_test::expect_file; | |
| /// expect_file!["./test_data/bar.html"]; | |
| /// ``` | |
| #[macro_export] | |
| macro_rules! expect_file { | |
| [$path:expr] => {$crate::ExpectFile { | |
| path: std::path::PathBuf::from($path), | |
| position: file!(), | |
| }}; | |
| } | |
| /// Self-updating string literal. | |
| #[derive(Debug)] | |
| pub struct Expect { | |
| #[doc(hidden)] | |
| pub position: Position, | |
| #[doc(hidden)] | |
| pub data: &'static str, | |
| #[doc(hidden)] | |
| pub indent: bool, | |
| } | |
| /// Self-updating file. | |
| #[derive(Debug)] | |
| pub struct ExpectFile { | |
| #[doc(hidden)] | |
| pub path: PathBuf, | |
| #[doc(hidden)] | |
| pub position: &'static str, | |
| } | |
| /// Position of original `expect!` in the source file. | |
| #[derive(Debug)] | |
| pub struct Position { | |
| #[doc(hidden)] | |
| pub file: &'static str, | |
| #[doc(hidden)] | |
| pub line: u32, | |
| #[doc(hidden)] | |
| pub column: u32, | |
| } | |
| impl fmt::Display for Position { | |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { | |
| write!(f, "{}:{}:{}", self.file, self.line, self.column) | |
| } | |
| } | |
| #[derive(Clone, Copy)] | |
| enum StrLitKind { | |
| Normal, | |
| Raw(usize), | |
| } | |
| impl StrLitKind { | |
| fn write_start(self, w: &mut impl std::fmt::Write) -> std::fmt::Result { | |
| match self { | |
| Self::Normal => write!(w, "\""), | |
| Self::Raw(n) => { | |
| write!(w, "r")?; | |
| for _ in 0..n { | |
| write!(w, "#")?; | |
| } | |
| write!(w, "\"") | |
| } | |
| } | |
| } | |
| fn write_end(self, w: &mut impl std::fmt::Write) -> std::fmt::Result { | |
| match self { | |
| Self::Normal => write!(w, "\""), | |
| Self::Raw(n) => { | |
| write!(w, "\"")?; | |
| for _ in 0..n { | |
| write!(w, "#")?; | |
| } | |
| Ok(()) | |
| } | |
| } | |
| } | |
| } | |
| impl Expect { | |
| /// Checks if this expect is equal to `actual`. | |
| pub fn assert_eq(&self, actual: &str) { | |
| let trimmed = self.trimmed(); | |
| if trimmed == actual { | |
| return; | |
| } | |
| Runtime::fail_expect(self, &trimmed, actual); | |
| } | |
| /// Checks if this expect is equal to `format!("{:#?}", actual)`. | |
| pub fn assert_debug_eq(&self, actual: &impl fmt::Debug) { | |
| let actual = format!("{:#?}\n", actual); | |
| self.assert_eq(&actual) | |
| } | |
| /// If `true` (default), in-place update will indent the string literal. | |
| pub fn indent(&mut self, yes: bool) { | |
| self.indent = yes; | |
| } | |
| /// Returns the content of this expect. | |
| pub fn data(&self) -> &str { | |
| self.data | |
| } | |
| fn trimmed(&self) -> String { | |
| if !self.data.contains('\n') { | |
| return self.data.to_string(); | |
| } | |
| trim_indent(self.data) | |
| } | |
| fn locate(&self, file: &str) -> Location { | |
| let mut target_line = None; | |
| let mut line_start = 0; | |
| for (i, line) in lines_with_ends(file).enumerate() { | |
| if i == self.position.line as usize - 1 { | |
| // `column` points to the first character of the macro invocation: | |
| // | |
| // expect![[r#""#]] expect![""] | |
| // ^ ^ ^ ^ | |
| // column offset offset | |
| // | |
| // Seek past the exclam, then skip any whitespace and | |
| // the macro delimiter to get to our argument. | |
| let byte_offset = line | |
| .char_indices() | |
| .skip((self.position.column - 1).try_into().unwrap()) | |
| .skip_while(|&(_, c)| c != '!') | |
| .skip(1) // ! | |
| .skip_while(|&(_, c)| c.is_whitespace()) | |
| .skip(1) // [({ | |
| .skip_while(|&(_, c)| c.is_whitespace()) | |
| .next() | |
| .expect("Failed to parse macro invocation") | |
| .0; | |
| let literal_start = line_start + byte_offset; | |
| let indent = line.chars().take_while(|&it| it == ' ').count(); | |
| target_line = Some((literal_start, indent)); | |
| break; | |
| } | |
| line_start += line.len(); | |
| } | |
| let (literal_start, line_indent) = target_line.unwrap(); | |
| let lit_to_eof = &file[literal_start..]; | |
| let lit_to_eof_trimmed = lit_to_eof.trim_start(); | |
| let literal_start = literal_start + (lit_to_eof.len() - lit_to_eof_trimmed.len()); | |
| let literal_len = | |
| locate_end(lit_to_eof_trimmed).expect("Couldn't find closing delimiter for `expect!`."); | |
| let literal_range = literal_start..literal_start + literal_len; | |
| Location { line_indent, literal_range } | |
| } | |
| } | |
| fn locate_end(arg_start_to_eof: &str) -> Option<usize> { | |
| match arg_start_to_eof.chars().next()? { | |
| c if c.is_whitespace() => panic!("skip whitespace before calling `locate_end`"), | |
| // expect![[]] | |
| '[' => { | |
| let str_start_to_eof = arg_start_to_eof[1..].trim_start(); | |
| let str_len = find_str_lit_len(str_start_to_eof)?; | |
| let str_end_to_eof = &str_start_to_eof[str_len..]; | |
| let closing_brace_offset = str_end_to_eof.find(']')?; | |
| Some((arg_start_to_eof.len() - str_end_to_eof.len()) + closing_brace_offset + 1) | |
| } | |
| // expect![] | expect!{} | expect!() | |
| ']' | '}' | ')' => Some(0), | |
| // expect!["..."] | expect![r#"..."#] | |
| _ => find_str_lit_len(arg_start_to_eof), | |
| } | |
| } | |
| /// Parses a string literal, returning the byte index of its last character | |
| /// (either a quote or a hash). | |
| fn find_str_lit_len(str_lit_to_eof: &str) -> Option<usize> { | |
| use StrLitKind::*; | |
| fn try_find_n_hashes( | |
| s: &mut impl Iterator<Item = char>, | |
| desired_hashes: usize, | |
| ) -> Option<(usize, Option<char>)> { | |
| let mut n = 0; | |
| loop { | |
| match s.next()? { | |
| '#' => n += 1, | |
| c => return Some((n, Some(c))), | |
| } | |
| if n == desired_hashes { | |
| return Some((n, None)); | |
| } | |
| } | |
| } | |
| let mut s = str_lit_to_eof.chars(); | |
| let kind = match s.next()? { | |
| '"' => Normal, | |
| 'r' => { | |
| let (n, c) = try_find_n_hashes(&mut s, usize::MAX)?; | |
| if c != Some('"') { | |
| return None; | |
| } | |
| Raw(n) | |
| } | |
| _ => return None, | |
| }; | |
| let mut oldc = None; | |
| loop { | |
| let c = oldc.take().or_else(|| s.next())?; | |
| match (c, kind) { | |
| ('\\', Normal) => { | |
| let _escaped = s.next()?; | |
| } | |
| ('"', Normal) => break, | |
| ('"', Raw(0)) => break, | |
| ('"', Raw(n)) => { | |
| let (seen, c) = try_find_n_hashes(&mut s, n)?; | |
| if seen == n { | |
| break; | |
| } | |
| oldc = c; | |
| } | |
| _ => {} | |
| } | |
| } | |
| Some(str_lit_to_eof.len() - s.as_str().len()) | |
| } | |
| impl ExpectFile { | |
| /// Checks if file contents is equal to `actual`. | |
| pub fn assert_eq(&self, actual: &str) { | |
| let expected = self.data(); | |
| if actual == expected { | |
| return; | |
| } | |
| Runtime::fail_file(self, &expected, actual); | |
| } | |
| /// Checks if file contents is equal to `format!("{:#?}", actual)`. | |
| pub fn assert_debug_eq(&self, actual: &impl fmt::Debug) { | |
| let actual = format!("{:#?}\n", actual); | |
| self.assert_eq(&actual) | |
| } | |
| /// Returns the content of this expect. | |
| pub fn data(&self) -> String { | |
| fs::read_to_string(self.abs_path()).unwrap_or_default().replace("\r\n", "\n") | |
| } | |
| fn write(&self, contents: &str) { | |
| fs::write(self.abs_path(), contents).unwrap() | |
| } | |
| fn abs_path(&self) -> PathBuf { | |
| if self.path.is_absolute() { | |
| self.path.to_owned() | |
| } else { | |
| let dir = Path::new(self.position).parent().unwrap(); | |
| to_abs_ws_path(&dir.join(&self.path)) | |
| } | |
| } | |
| } | |
| #[derive(Default)] | |
| struct Runtime { | |
| help_printed: bool, | |
| per_file: HashMap<&'static str, FileRuntime>, | |
| } | |
| static RT: Lazy<Mutex<Runtime>> = Lazy::new(Default::default); | |
| impl Runtime { | |
| fn fail_expect(expect: &Expect, expected: &str, actual: &str) { | |
| let mut rt = RT.lock().unwrap_or_else(|poisoned| poisoned.into_inner()); | |
| if update_expect() { | |
| println!("\x1b[1m\x1b[92mupdating\x1b[0m: {}", expect.position); | |
| rt.per_file | |
| .entry(expect.position.file) | |
| .or_insert_with(|| FileRuntime::new(expect)) | |
| .update(expect, actual); | |
| return; | |
| } | |
| rt.panic(expect.position.to_string(), expected, actual); | |
| } | |
| fn fail_file(expect: &ExpectFile, expected: &str, actual: &str) { | |
| let mut rt = RT.lock().unwrap_or_else(|poisoned| poisoned.into_inner()); | |
| if update_expect() { | |
| println!("\x1b[1m\x1b[92mupdating\x1b[0m: {}", expect.path.display()); | |
| expect.write(actual); | |
| return; | |
| } | |
| rt.panic(expect.path.display().to_string(), expected, actual); | |
| } | |
| fn panic(&mut self, position: String, expected: &str, actual: &str) { | |
| let print_help = !mem::replace(&mut self.help_printed, true); | |
| let help = if print_help { HELP } else { "" }; | |
| let diff = dissimilar::diff(expected, actual); | |
| println!( | |
| "\n | |
| \x1b[1m\x1b[91merror\x1b[97m: expect test failed\x1b[0m | |
| \x1b[1m\x1b[34m-->\x1b[0m {} | |
| {} | |
| \x1b[1mExpect\x1b[0m: | |
| ---- | |
| {} | |
| ---- | |
| \x1b[1mActual\x1b[0m: | |
| ---- | |
| {} | |
| ---- | |
| \x1b[1mDiff\x1b[0m: | |
| ---- | |
| {} | |
| ---- | |
| ", | |
| position, | |
| help, | |
| expected, | |
| actual, | |
| format_chunks(diff) | |
| ); | |
| // Use resume_unwind instead of panic!() to prevent a backtrace, which is unnecessary noise. | |
| panic::resume_unwind(Box::new(())); | |
| } | |
| } | |
| struct FileRuntime { | |
| path: PathBuf, | |
| original_text: String, | |
| patchwork: Patchwork, | |
| } | |
| impl FileRuntime { | |
| fn new(expect: &Expect) -> FileRuntime { | |
| let path = to_abs_ws_path(Path::new(expect.position.file)); | |
| let original_text = fs::read_to_string(&path).unwrap(); | |
| let patchwork = Patchwork::new(original_text.clone()); | |
| FileRuntime { path, original_text, patchwork } | |
| } | |
| fn update(&mut self, expect: &Expect, actual: &str) { | |
| let loc = expect.locate(&self.original_text); | |
| let desired_indent = if expect.indent { Some(loc.line_indent) } else { None }; | |
| let patch = format_patch(desired_indent, actual); | |
| self.patchwork.patch(loc.literal_range, &patch); | |
| fs::write(&self.path, &self.patchwork.text).unwrap() | |
| } | |
| } | |
| #[derive(Debug)] | |
| struct Location { | |
| line_indent: usize, | |
| /// The byte range of the argument to `expect!`, including the inner `[]` if it exists. | |
| literal_range: Range<usize>, | |
| } | |
| #[derive(Debug)] | |
| struct Patchwork { | |
| text: String, | |
| indels: Vec<(Range<usize>, usize)>, | |
| } | |
| impl Patchwork { | |
| fn new(text: String) -> Patchwork { | |
| Patchwork { text, indels: Vec::new() } | |
| } | |
| fn patch(&mut self, mut range: Range<usize>, patch: &str) { | |
| self.indels.push((range.clone(), patch.len())); | |
| self.indels.sort_by_key(|(delete, _insert)| delete.start); | |
| let (delete, insert) = self | |
| .indels | |
| .iter() | |
| .take_while(|(delete, _)| delete.start < range.start) | |
| .map(|(delete, insert)| (delete.end - delete.start, insert)) | |
| .fold((0usize, 0usize), |(x1, y1), (x2, y2)| (x1 + x2, y1 + y2)); | |
| for pos in &mut [&mut range.start, &mut range.end] { | |
| **pos -= delete; | |
| **pos += insert; | |
| } | |
| self.text.replace_range(range, patch); | |
| } | |
| } | |
| fn lit_kind_for_patch(patch: &str) -> StrLitKind { | |
| let has_dquote = patch.chars().any(|c| c == '"'); | |
| if !has_dquote { | |
| let has_bslash_or_newline = patch.chars().any(|c| matches!(c, '\\' | '\n')); | |
| return if has_bslash_or_newline { StrLitKind::Raw(1) } else { StrLitKind::Normal }; | |
| } | |
| // Find the maximum number of hashes that follow a double quote in the string. | |
| // We need to use one more than that to delimit the string. | |
| let leading_hashes = |s: &str| s.chars().take_while(|&c| c == '#').count(); | |
| let max_hashes = patch.split('"').map(leading_hashes).max().unwrap(); | |
| StrLitKind::Raw(max_hashes + 1) | |
| } | |
| fn format_patch(desired_indent: Option<usize>, patch: &str) -> String { | |
| let lit_kind = lit_kind_for_patch(patch); | |
| let indent = desired_indent.map(|it| " ".repeat(it)); | |
| let is_multiline = patch.contains('\n'); | |
| let mut buf = String::new(); | |
| if matches!(lit_kind, StrLitKind::Raw(_)) { | |
| buf.push('['); | |
| } | |
| lit_kind.write_start(&mut buf).unwrap(); | |
| if is_multiline { | |
| buf.push('\n'); | |
| } | |
| let mut final_newline = false; | |
| for line in lines_with_ends(patch) { | |
| if is_multiline && !line.trim().is_empty() { | |
| if let Some(indent) = &indent { | |
| buf.push_str(indent); | |
| buf.push_str(" "); | |
| } | |
| } | |
| buf.push_str(line); | |
| final_newline = line.ends_with('\n'); | |
| } | |
| if final_newline { | |
| if let Some(indent) = &indent { | |
| buf.push_str(indent); | |
| } | |
| } | |
| lit_kind.write_end(&mut buf).unwrap(); | |
| if matches!(lit_kind, StrLitKind::Raw(_)) { | |
| buf.push(']'); | |
| } | |
| buf | |
| } | |
| fn to_abs_ws_path(path: &Path) -> PathBuf { | |
| if path.is_absolute() { | |
| return path.to_owned(); | |
| } | |
| static WORKSPACE_ROOT: OnceCell<PathBuf> = OnceCell::new(); | |
| WORKSPACE_ROOT | |
| .get_or_try_init(|| { | |
| // Until https://github.com/rust-lang/cargo/issues/3946 is resolved, this | |
| // is set with a hack like https://github.com/rust-lang/cargo/issues/3946#issuecomment-973132993 | |
| if let Ok(workspace_root) = env::var("CARGO_WORKSPACE_DIR") { | |
| return Ok(workspace_root.into()); | |
| } | |
| // If a hack isn't used, we use a heuristic to find the "top-level" workspace. | |
| // This fails in some cases, see https://github.com/rust-analyzer/expect-test/issues/33 | |
| let my_manifest = env::var("CARGO_MANIFEST_DIR")?; | |
| let workspace_root = Path::new(&my_manifest) | |
| .ancestors() | |
| .filter(|it| it.join("Cargo.toml").exists()) | |
| .last() | |
| .unwrap() | |
| .to_path_buf(); | |
| Ok(workspace_root) | |
| }) | |
| .unwrap_or_else(|_: env::VarError| { | |
| panic!("No CARGO_MANIFEST_DIR env var and the path is relative: {}", path.display()) | |
| }) | |
| .join(path) | |
| } | |
| fn trim_indent(mut text: &str) -> String { | |
| if text.starts_with('\n') { | |
| text = &text[1..]; | |
| } | |
| let indent = text | |
| .lines() | |
| .filter(|it| !it.trim().is_empty()) | |
| .map(|it| it.len() - it.trim_start().len()) | |
| .min() | |
| .unwrap_or(0); | |
| lines_with_ends(text) | |
| .map( | |
| |line| { | |
| if line.len() <= indent { | |
| line.trim_start_matches(' ') | |
| } else { | |
| &line[indent..] | |
| } | |
| }, | |
| ) | |
| .collect() | |
| } | |
| fn lines_with_ends(text: &str) -> LinesWithEnds { | |
| LinesWithEnds { text } | |
| } | |
| struct LinesWithEnds<'a> { | |
| text: &'a str, | |
| } | |
| impl<'a> Iterator for LinesWithEnds<'a> { | |
| type Item = &'a str; | |
| fn next(&mut self) -> Option<&'a str> { | |
| if self.text.is_empty() { | |
| return None; | |
| } | |
| let idx = self.text.find('\n').map_or(self.text.len(), |it| it + 1); | |
| let (res, next) = self.text.split_at(idx); | |
| self.text = next; | |
| Some(res) | |
| } | |
| } | |
| fn format_chunks(chunks: Vec<dissimilar::Chunk>) -> String { | |
| let mut buf = String::new(); | |
| for chunk in chunks { | |
| let formatted = match chunk { | |
| dissimilar::Chunk::Equal(text) => text.into(), | |
| dissimilar::Chunk::Delete(text) => format!("\x1b[4m\x1b[31m{}\x1b[0m", text), | |
| dissimilar::Chunk::Insert(text) => format!("\x1b[4m\x1b[32m{}\x1b[0m", text), | |
| }; | |
| buf.push_str(&formatted); | |
| } | |
| buf | |
| } | |
| #[cfg(test)] | |
| mod tests { | |
| use super::*; | |
| #[test] | |
| fn test_trivial_assert() { | |
| expect!["5"].assert_eq("5"); | |
| } | |
| #[test] | |
| fn test_format_patch() { | |
| let patch = format_patch(None, "hello\nworld\n"); | |
| expect![[r##" | |
| [r#" | |
| hello | |
| world | |
| "#]"##]] | |
| .assert_eq(&patch); | |
| let patch = format_patch(None, r"hello\tworld"); | |
| expect![[r##"[r#"hello\tworld"#]"##]].assert_eq(&patch); | |
| let patch = format_patch(None, "{\"foo\": 42}"); | |
| expect![[r##"[r#"{"foo": 42}"#]"##]].assert_eq(&patch); | |
| let patch = format_patch(Some(0), "hello\nworld\n"); | |
| expect![[r##" | |
| [r#" | |
| hello | |
| world | |
| "#]"##]] | |
| .assert_eq(&patch); | |
| let patch = format_patch(Some(4), "single line"); | |
| expect![[r#""single line""#]].assert_eq(&patch); | |
| } | |
| #[test] | |
| fn test_patchwork() { | |
| let mut patchwork = Patchwork::new("one two three".to_string()); | |
| patchwork.patch(4..7, "zwei"); | |
| patchwork.patch(0..3, "один"); | |
| patchwork.patch(8..13, "3"); | |
| expect![[r#" | |
| Patchwork { | |
| text: "один zwei 3", | |
| indels: [ | |
| ( | |
| 0..3, | |
| 8, | |
| ), | |
| ( | |
| 4..7, | |
| 4, | |
| ), | |
| ( | |
| 8..13, | |
| 1, | |
| ), | |
| ], | |
| } | |
| "#]] | |
| .assert_debug_eq(&patchwork); | |
| } | |
| #[test] | |
| fn test_expect_file() { | |
| expect_file!["./lib.rs"].assert_eq(include_str!("./lib.rs")) | |
| } | |
| #[test] | |
| fn smoke_test_indent() { | |
| fn check_indented(input: &str, mut expect: Expect) { | |
| expect.indent(true); | |
| expect.assert_eq(input); | |
| } | |
| fn check_not_indented(input: &str, mut expect: Expect) { | |
| expect.indent(false); | |
| expect.assert_eq(input); | |
| } | |
| check_indented( | |
| "\ | |
| line1 | |
| line2 | |
| ", | |
| expect![[r#" | |
| line1 | |
| line2 | |
| "#]], | |
| ); | |
| check_not_indented( | |
| "\ | |
| line1 | |
| line2 | |
| ", | |
| expect![[r#" | |
| line1 | |
| line2 | |
| "#]], | |
| ); | |
| } | |
| #[test] | |
| fn test_locate() { | |
| macro_rules! check_locate { | |
| ($( [[$s:literal]] ),* $(,)?) => {$({ | |
| let lit = stringify!($s); | |
| let with_trailer = format!("{} \t]]\n", lit); | |
| assert_eq!(locate_end(&with_trailer), Some(lit.len())); | |
| })*}; | |
| } | |
| // Check that we handle string literals containing "]]" correctly. | |
| check_locate!( | |
| [[r#"{ arr: [[1, 2], [3, 4]], other: "foo" } "#]], | |
| [["]]"]], | |
| [["\"]]"]], | |
| [[r#""]]"#]], | |
| ); | |
| // Check `expect![[ ]]` as well. | |
| assert_eq!(locate_end("]]"), Some(0)); | |
| } | |
| #[test] | |
| fn test_find_str_lit_len() { | |
| macro_rules! check_str_lit_len { | |
| ($( $s:literal ),* $(,)?) => {$({ | |
| let lit = stringify!($s); | |
| assert_eq!(find_str_lit_len(lit), Some(lit.len())); | |
| })*} | |
| } | |
| check_str_lit_len![ | |
| r##"foa\""#"##, | |
| r##" | |
| asdf][]]""""# | |
| "##, | |
| "", | |
| "\"", | |
| "\"\"", | |
| "#\"#\"#", | |
| ]; | |
| } | |
| } |