rust/crates/test_utils/src/lib.rs

390 lines
13 KiB
Rust
Raw Normal View History

2019-10-26 11:58:18 -05:00
//! Assorted testing utilities.
//!
//! Most notable things are:
//!
//! * Rich text comparison, which outputs a diff.
2021-01-06 14:15:48 -06:00
//! * Extracting markup (mainly, `$0` markers) out of fixture strings.
2019-10-26 11:58:18 -05:00
//! * marks (see the eponymous module).
2021-02-09 10:29:40 -06:00
pub mod bench_fixture;
2020-06-23 10:59:56 -05:00
mod fixture;
2019-01-23 06:36:29 -06:00
use std::{
2020-06-30 11:04:25 -05:00
convert::{TryFrom, TryInto},
2020-06-15 04:02:17 -05:00
env, fs,
path::{Path, PathBuf},
2019-01-23 06:36:29 -06:00
};
2018-08-17 08:04:34 -05:00
2021-02-09 10:29:40 -06:00
use profile::StopWatch;
use stdx::{is_ci, lines_with_ends};
2020-06-15 04:02:17 -05:00
use text_size::{TextRange, TextSize};
2020-05-16 03:16:32 -05:00
pub use dissimilar::diff as __diff;
2020-05-16 03:16:32 -05:00
pub use rustc_hash::FxHashMap;
2018-08-17 08:04:34 -05:00
2020-06-23 11:46:56 -05:00
pub use crate::fixture::Fixture;
2018-08-12 10:50:16 -05:00
2021-01-06 14:15:48 -06:00
pub const CURSOR_MARKER: &str = "$0";
2021-01-07 09:21:00 -06:00
pub const ESCAPED_CURSOR_MARKER: &str = "\\$0";
/// Asserts that two strings are equal, otherwise displays a rich diff between them.
///
/// The diff shows changes from the "original" left string to the "actual" right string.
///
/// All arguments starting from and including the 3rd one are passed to
/// `eprintln!()` macro in case of text inequality.
2018-08-12 10:50:16 -05:00
#[macro_export]
macro_rules! assert_eq_text {
2019-01-13 09:21:23 -06:00
($left:expr, $right:expr) => {
assert_eq_text!($left, $right,)
2018-12-21 09:13:21 -06:00
};
2019-01-13 09:21:23 -06:00
($left:expr, $right:expr, $($tt:tt)*) => {{
let left = $left;
let right = $right;
if left != right {
if left.trim() == right.trim() {
std::eprintln!("Left:\n{:?}\n\nRight:\n{:?}\n\nWhitespace difference\n", left, right);
2018-12-21 09:13:21 -06:00
} else {
let diff = $crate::__diff(left, right);
std::eprintln!("Left:\n{}\n\nRight:\n{}\n\nDiff:\n{}\n", left, right, $crate::format_diff(diff));
2018-12-21 09:13:21 -06:00
}
std::eprintln!($($tt)*);
2018-08-12 10:50:16 -05:00
panic!("text differs");
}
}};
}
2018-08-17 08:04:34 -05:00
/// Infallible version of `try_extract_offset()`.
2020-04-24 16:40:41 -05:00
pub fn extract_offset(text: &str) -> (TextSize, String) {
2018-10-13 14:33:15 -05:00
match try_extract_offset(text) {
2018-08-25 06:30:54 -05:00
None => panic!("text should contain cursor marker"),
2018-10-13 14:33:15 -05:00
Some(result) => result,
}
}
2021-01-08 08:46:48 -06:00
/// Returns the offset of the first occurrence of `$0` marker and the copy of `text`
/// without the marker.
2020-04-24 16:40:41 -05:00
fn try_extract_offset(text: &str) -> Option<(TextSize, String)> {
let cursor_pos = text.find(CURSOR_MARKER)?;
let mut new_text = String::with_capacity(text.len() - CURSOR_MARKER.len());
2018-08-25 06:30:54 -05:00
new_text.push_str(&text[..cursor_pos]);
new_text.push_str(&text[cursor_pos + CURSOR_MARKER.len()..]);
2020-04-24 16:40:41 -05:00
let cursor_pos = TextSize::from(cursor_pos as u32);
2018-10-13 14:33:15 -05:00
Some((cursor_pos, new_text))
2018-08-25 06:30:54 -05:00
}
/// Infallible version of `try_extract_range()`.
2018-08-25 06:30:54 -05:00
pub fn extract_range(text: &str) -> (TextRange, String) {
2018-10-13 14:33:15 -05:00
match try_extract_range(text) {
None => panic!("text should contain cursor marker"),
Some(result) => result,
}
}
2021-01-06 14:15:48 -06:00
/// Returns `TextRange` between the first two markers `$0...$0` and the copy
/// of `text` without both of these markers.
2019-10-26 11:58:18 -05:00
fn try_extract_range(text: &str) -> Option<(TextRange, String)> {
2018-10-13 14:33:15 -05:00
let (start, text) = try_extract_offset(text)?;
let (end, text) = try_extract_offset(&text)?;
2020-04-24 16:40:41 -05:00
Some((TextRange::new(start, end), text))
2018-10-13 14:33:15 -05:00
}
2020-02-25 11:57:47 -06:00
#[derive(Clone, Copy)]
2019-10-26 11:58:18 -05:00
pub enum RangeOrOffset {
Range(TextRange),
2020-04-24 16:40:41 -05:00
Offset(TextSize),
2019-10-26 11:58:18 -05:00
}
impl From<RangeOrOffset> for TextRange {
fn from(selection: RangeOrOffset) -> Self {
match selection {
RangeOrOffset::Range(it) => it,
2020-06-23 10:59:56 -05:00
RangeOrOffset::Offset(it) => TextRange::empty(it),
2019-10-26 11:58:18 -05:00
}
}
}
2021-01-06 14:15:48 -06:00
/// Extracts `TextRange` or `TextSize` depending on the amount of `$0` markers
/// found in `text`.
///
/// # Panics
2021-01-06 14:15:48 -06:00
/// Panics if no `$0` marker is present in the `text`.
2019-10-26 11:58:18 -05:00
pub fn extract_range_or_offset(text: &str) -> (RangeOrOffset, String) {
if let Some((range, text)) = try_extract_range(text) {
return (RangeOrOffset::Range(range), text);
}
let (offset, text) = extract_offset(text);
(RangeOrOffset::Offset(offset), text)
}
/// Extracts ranges, marked with `<tag> </tag>` pairs from the `text`
2020-07-01 11:17:08 -05:00
pub fn extract_tags(mut text: &str, tag: &str) -> (Vec<(TextRange, Option<String>)>, String) {
let open = format!("<{}", tag);
let close = format!("</{}>", tag);
2018-10-13 14:33:15 -05:00
let mut ranges = Vec::new();
let mut res = String::new();
let mut stack = Vec::new();
loop {
match text.find('<') {
None => {
res.push_str(text);
break;
}
Some(i) => {
res.push_str(&text[..i]);
text = &text[i..];
if text.starts_with(&open) {
2020-07-01 11:17:08 -05:00
let close_open = text.find('>').unwrap();
let attr = text[open.len()..close_open].trim();
let attr = if attr.is_empty() { None } else { Some(attr.to_string()) };
text = &text[close_open + '>'.len_utf8()..];
2020-04-24 16:40:41 -05:00
let from = TextSize::of(&res);
2020-07-01 11:17:08 -05:00
stack.push((from, attr));
} else if text.starts_with(&close) {
text = &text[close.len()..];
2020-07-01 11:17:08 -05:00
let (from, attr) =
stack.pop().unwrap_or_else(|| panic!("unmatched </{}>", tag));
2020-04-24 16:40:41 -05:00
let to = TextSize::of(&res);
2020-07-01 11:17:08 -05:00
ranges.push((TextRange::new(from, to), attr));
} else {
res.push('<');
text = &text['<'.len_utf8()..];
}
}
}
2018-10-13 14:33:15 -05:00
}
assert!(stack.is_empty(), "unmatched <{}>", tag);
2020-07-01 11:17:08 -05:00
ranges.sort_by_key(|r| (r.0.start(), r.0.end()));
(ranges, res)
2018-08-25 06:30:54 -05:00
}
2020-07-01 11:17:08 -05:00
#[test]
fn test_extract_tags() {
let (tags, text) = extract_tags(r#"<tag fn>fn <tag>main</tag>() {}</tag>"#, "tag");
let actual = tags.into_iter().map(|(range, attr)| (&text[range], attr)).collect::<Vec<_>>();
assert_eq!(actual, vec![("fn main() {}", Some("fn".into())), ("main", None),]);
}
2018-08-25 06:30:54 -05:00
2021-01-06 14:15:48 -06:00
/// Inserts `$0` marker into the `text` at `offset`.
2020-04-24 16:40:41 -05:00
pub fn add_cursor(text: &str, offset: TextSize) -> String {
let offset: usize = offset.into();
2018-08-25 06:30:54 -05:00
let mut res = String::new();
res.push_str(&text[..offset]);
2021-01-06 14:15:48 -06:00
res.push_str("$0");
2018-08-25 06:30:54 -05:00
res.push_str(&text[offset..]);
res
}
2018-10-31 13:37:32 -05:00
/// Extracts `//^ some text` annotations
2020-06-29 10:22:47 -05:00
pub fn extract_annotations(text: &str) -> Vec<(TextRange, String)> {
let mut res = Vec::new();
let mut prev_line_start: Option<TextSize> = None;
let mut line_start: TextSize = 0.into();
2020-07-14 07:57:33 -05:00
let mut prev_line_annotations: Vec<(TextSize, usize)> = Vec::new();
for line in lines_with_ends(text) {
2020-07-14 07:57:33 -05:00
let mut this_line_annotations = Vec::new();
2020-07-14 07:01:54 -05:00
if let Some(idx) = line.find("//") {
2020-07-14 07:57:33 -05:00
let annotation_offset = TextSize::of(&line[..idx + "//".len()]);
for annotation in extract_line_annotations(&line[idx + "//".len()..]) {
match annotation {
LineAnnotation::Annotation { mut range, content } => {
range += annotation_offset;
this_line_annotations.push((range.end(), res.len()));
res.push((range + prev_line_start.unwrap(), content))
}
LineAnnotation::Continuation { mut offset, content } => {
offset += annotation_offset;
let &(_, idx) = prev_line_annotations
.iter()
.find(|&&(off, _idx)| off == offset)
.unwrap();
res[idx].1.push('\n');
res[idx].1.push_str(&content);
res[idx].1.push('\n');
}
}
2020-06-30 11:04:25 -05:00
}
}
2020-07-14 07:57:33 -05:00
prev_line_start = Some(line_start);
line_start += TextSize::of(line);
2020-07-14 07:57:33 -05:00
prev_line_annotations = this_line_annotations;
}
res
}
2020-07-14 07:57:33 -05:00
enum LineAnnotation {
Annotation { range: TextRange, content: String },
Continuation { offset: TextSize, content: String },
}
fn extract_line_annotations(mut line: &str) -> Vec<LineAnnotation> {
2020-06-30 11:04:25 -05:00
let mut res = Vec::new();
let mut offset: TextSize = 0.into();
2020-07-14 07:57:33 -05:00
let marker: fn(char) -> bool = if line.contains('^') { |c| c == '^' } else { |c| c == '|' };
2020-07-14 07:01:54 -05:00
loop {
2020-07-14 07:57:33 -05:00
match line.find(marker) {
2020-07-14 07:01:54 -05:00
Some(idx) => {
offset += TextSize::try_from(idx).unwrap();
line = &line[idx..];
}
None => break,
};
2020-07-14 07:57:33 -05:00
let mut len = line.chars().take_while(|&it| it == '^').count();
let mut continuation = false;
if len == 0 {
assert!(line.starts_with('|'));
continuation = true;
len = 1;
}
2020-06-30 11:04:25 -05:00
let range = TextRange::at(offset, len.try_into().unwrap());
2020-07-14 07:57:33 -05:00
let next = line[len..].find(marker).map_or(line.len(), |it| it + len);
let content = line[len..][..next - len].trim().to_string();
let annotation = if continuation {
LineAnnotation::Continuation { offset: range.end(), content }
} else {
LineAnnotation::Annotation { range, content }
};
res.push(annotation);
2020-06-30 11:04:25 -05:00
line = &line[next..];
offset += TextSize::try_from(next).unwrap();
}
2020-07-14 07:57:33 -05:00
2020-06-30 11:04:25 -05:00
res
}
#[test]
fn test_extract_annotations() {
2020-06-29 10:22:47 -05:00
let text = stdx::trim_indent(
r#"
fn main() {
2020-06-30 11:04:25 -05:00
let (x, y) = (9, 2);
//^ def ^ def
2020-06-30 05:13:08 -05:00
zoo + 1
2020-07-14 07:57:33 -05:00
} //^^^ type:
// | i32
"#,
2020-06-29 10:22:47 -05:00
);
let res = extract_annotations(&text)
.into_iter()
.map(|(range, ann)| (&text[range], ann))
.collect::<Vec<_>>();
2020-07-14 07:57:33 -05:00
assert_eq!(
res,
vec![("x", "def".into()), ("y", "def".into()), ("zoo", "type:\ni32\n".into()),]
);
}
/// Returns `false` if slow tests should not run, otherwise returns `true` and
/// also creates a file at `./target/.slow_tests_cookie` which serves as a flag
/// that slow tests did run.
2019-12-07 05:46:36 -06:00
pub fn skip_slow_tests() -> bool {
let should_skip = std::env::var("CI").is_err() && std::env::var("RUN_SLOW_TESTS").is_err();
if should_skip {
eprintln!("ignoring slow test")
} else {
let path = project_root().join("./target/.slow_tests_cookie");
2019-12-07 05:46:36 -06:00
fs::write(&path, ".").unwrap();
}
should_skip
}
/// Returns the path to the root directory of `rust-analyzer` project.
pub fn project_root() -> PathBuf {
let dir = env!("CARGO_MANIFEST_DIR");
PathBuf::from(dir).parent().unwrap().parent().unwrap().to_owned()
}
pub fn format_diff(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[41m{}\x1b[0m", text),
dissimilar::Chunk::Insert(text) => format!("\x1b[42m{}\x1b[0m", text),
};
buf.push_str(&formatted);
}
buf
}
2021-02-09 10:29:40 -06:00
/// Utility for writing benchmark tests.
///
/// A benchmark test looks like this:
///
/// ```
/// #[test]
/// fn benchmark_foo() {
/// if skip_slow_tests() { return; }
///
/// let data = bench_fixture::some_fixture();
/// let analysis = some_setup();
///
/// let hash = {
/// let _b = bench("foo");
/// actual_work(analysis)
/// };
/// assert_eq!(hash, 92);
/// }
/// ```
///
/// * We skip benchmarks by default, to save time.
/// Ideal benchmark time is 800 -- 1500 ms in debug.
/// * We don't count preparation as part of the benchmark
/// * The benchmark itself returns some kind of numeric hash.
/// The hash is used as a sanity check that some code is actually run.
/// Otherwise, it's too easy to win the benchmark by just doing nothing.
pub fn bench(label: &'static str) -> impl Drop {
struct Bencher {
sw: StopWatch,
label: &'static str,
}
impl Drop for Bencher {
fn drop(&mut self) {
eprintln!("{}: {}", self.label, self.sw.elapsed())
}
}
Bencher { sw: StopWatch::start(), label }
}
/// Checks that the `file` has the specified `contents`. If that is not the
/// case, updates the file and then fails the test.
pub fn ensure_file_contents(file: &Path, contents: &str) {
if let Err(()) = try_ensure_file_contents(file, contents) {
panic!("Some files were not up-to-date");
}
}
/// Checks that the `file` has the specified `contents`. If that is not the
/// case, updates the file and return an Error.
pub fn try_ensure_file_contents(file: &Path, contents: &str) -> Result<(), ()> {
match std::fs::read_to_string(file) {
Ok(old_contents) if normalize_newlines(&old_contents) == normalize_newlines(contents) => {
return Ok(())
}
_ => (),
}
let display_path = file.strip_prefix(&project_root()).unwrap_or(file);
eprintln!(
"\n\x1b[31;1merror\x1b[0m: {} was not up-to-date, updating\n",
display_path.display()
);
if is_ci() {
2021-03-08 12:41:45 -06:00
eprintln!(" NOTE: run `cargo test` locally and commit the updated files\n");
}
if let Some(parent) = file.parent() {
let _ = std::fs::create_dir_all(parent);
}
std::fs::write(file, contents).unwrap();
Err(())
}
fn normalize_newlines(s: &str) -> String {
s.replace("\r\n", "\n")
}