diff options
Diffstat (limited to 'vendor/dissimilar/src/tests.rs')
| -rw-r--r-- | vendor/dissimilar/src/tests.rs | 131 |
1 files changed, 71 insertions, 60 deletions
diff --git a/vendor/dissimilar/src/tests.rs b/vendor/dissimilar/src/tests.rs index 450d7f7e4..d2e3fd643 100644 --- a/vendor/dissimilar/src/tests.rs +++ b/vendor/dissimilar/src/tests.rs @@ -1,4 +1,13 @@ use super::*; +use once_cell::sync::OnceCell; + +macro_rules! range { + ($text:expr) => {{ + static CHARS: OnceCell<Vec<char>> = OnceCell::new(); + let chars = CHARS.get_or_init(|| $text.chars().collect()); + Range::new(chars, ..) + }}; +} macro_rules! diff_list { () => { @@ -6,50 +15,52 @@ macro_rules! diff_list { text1: Range::empty(), text2: Range::empty(), diffs: Vec::new(), - utf8: true, } }; ($($kind:ident($text:literal)),+ $(,)?) => {{ + #[allow(unused_macro_rules)] macro_rules! text1 { (Insert, $s:literal) => { "" }; (Delete, $s:literal) => { $s }; (Equal, $s:literal) => { $s }; } + #[allow(unused_macro_rules)] macro_rules! text2 { (Insert, $s:literal) => { $s }; (Delete, $s:literal) => { "" }; (Equal, $s:literal) => { $s }; } - let text1 = concat!($(text1!($kind, $text)),*); - let text2 = concat!($(text2!($kind, $text)),*); + let text1 = range!(concat!($(text1!($kind, $text)),*)); + let text2 = range!(concat!($(text2!($kind, $text)),*)); let (_i, _j) = (&mut 0, &mut 0); + #[allow(unused_macro_rules)] macro_rules! range { (Insert, $s:literal) => { - Diff::Insert(range(text2, _j, $s)) + Diff::Insert(range(text2.doc, _j, $s)) }; (Delete, $s:literal) => { - Diff::Delete(range(text1, _i, $s)) + Diff::Delete(range(text1.doc, _i, $s)) }; (Equal, $s:literal) => { - Diff::Equal(range(text1, _i, $s), range(text2, _j, $s)) + Diff::Equal(range(text1.doc, _i, $s), range(text2.doc, _j, $s)) }; } Solution { - text1: Range::new(text1, ..), - text2: Range::new(text2, ..), + text1, + text2, diffs: vec![$(range!($kind, $text)),*], - utf8: true, } }}; } -fn range<'a>(doc: &'a str, offset: &mut usize, text: &str) -> Range<'a> { +fn range<'a>(doc: &'a [char], offset: &mut usize, text: &str) -> Range<'a> { + let len = text.chars().count(); let range = Range { doc, offset: *offset, - len: text.len(), + len, }; - *offset += text.len(); + *offset += len; range } @@ -65,12 +76,16 @@ macro_rules! assert_diffs { } fn same_diffs(expected: &[Chunk], actual: &[Diff]) -> bool { + fn eq(expected: &str, actual: &Range) -> bool { + expected.chars().eq(slice(*actual).iter().copied()) + } + expected.len() == actual.len() && expected.iter().zip(actual).all(|pair| match pair { - (Chunk::Insert(expected), Diff::Insert(actual)) => *expected == str(*actual), - (Chunk::Delete(expected), Diff::Delete(actual)) => *expected == str(*actual), + (Chunk::Insert(expected), Diff::Insert(actual)) => eq(expected, actual), + (Chunk::Delete(expected), Diff::Delete(actual)) => eq(expected, actual), (Chunk::Equal(expected), Diff::Equal(actual1, actual2)) => { - *expected == str(*actual1) && *expected == str(*actual2) + eq(expected, actual1) && eq(expected, actual2) } (_, _) => false, }) @@ -78,59 +93,56 @@ fn same_diffs(expected: &[Chunk], actual: &[Diff]) -> bool { #[test] fn test_common_prefix() { - let text1 = Range::new("abc", ..); - let text2 = Range::new("xyz", ..); - assert_eq!(0, common_prefix_bytes(text1, text2), "Null case"); + let text1 = range!("abc"); + let text2 = range!("xyz"); + assert_eq!(0, common_prefix(text1, text2), "Null case"); - let text1 = Range::new("1234abcdef", ..); - let text2 = Range::new("1234xyz", ..); - assert_eq!(4, common_prefix_bytes(text1, text2), "Non-null case"); + let text1 = range!("1234abcdef"); + let text2 = range!("1234xyz"); + assert_eq!(4, common_prefix(text1, text2), "Non-null case"); - let text1 = Range::new("1234", ..); - let text2 = Range::new("1234xyz", ..); - assert_eq!(4, common_prefix_bytes(text1, text2), "Whole case"); + let text1 = range!("1234"); + let text2 = range!("1234xyz"); + assert_eq!(4, common_prefix(text1, text2), "Whole case"); } #[test] fn test_common_suffix() { - let text1 = Range::new("abc", ..); - let text2 = Range::new("xyz", ..); + let text1 = range!("abc"); + let text2 = range!("xyz"); assert_eq!(0, common_suffix(text1, text2), "Null case"); - assert_eq!(0, common_suffix_bytes(text1, text2), "Null case"); - let text1 = Range::new("abcdef1234", ..); - let text2 = Range::new("xyz1234", ..); + let text1 = range!("abcdef1234"); + let text2 = range!("xyz1234"); assert_eq!(4, common_suffix(text1, text2), "Non-null case"); - assert_eq!(4, common_suffix_bytes(text1, text2), "Non-null case"); - let text1 = Range::new("1234", ..); - let text2 = Range::new("xyz1234", ..); + let text1 = range!("1234"); + let text2 = range!("xyz1234"); assert_eq!(4, common_suffix(text1, text2), "Whole case"); - assert_eq!(4, common_suffix_bytes(text1, text2), "Whole case"); } #[test] fn test_common_overlap() { let text1 = Range::empty(); - let text2 = Range::new("abcd", ..); + let text2 = range!("abcd"); assert_eq!(0, common_overlap(text1, text2), "Null case"); - let text1 = Range::new("abc", ..); - let text2 = Range::new("abcd", ..); + let text1 = range!("abc"); + let text2 = range!("abcd"); assert_eq!(3, common_overlap(text1, text2), "Whole case"); - let text1 = Range::new("123456", ..); - let text2 = Range::new("abcd", ..); + let text1 = range!("123456"); + let text2 = range!("abcd"); assert_eq!(0, common_overlap(text1, text2), "No overlap"); - let text1 = Range::new("123456xxx", ..); - let text2 = Range::new("xxxabcd", ..); + let text1 = range!("123456xxx"); + let text2 = range!("xxxabcd"); assert_eq!(3, common_overlap(text1, text2), "Overlap"); // Some overly clever languages (C#) may treat ligatures as equal to their // component letters. E.g. U+FB01 == 'fi' - let text1 = Range::new("fi", ..); - let text2 = Range::new("\u{fb01}i", ..); + let text1 = range!("fi"); + let text2 = range!("\u{fb01}i"); assert_eq!(0, common_overlap(text1, text2), "Unicode"); } @@ -420,13 +432,12 @@ fn test_cleanup_semantic() { #[test] fn test_bisect() { - let text1 = Range::new("cat", ..); - let text2 = Range::new("map", ..); + let text1 = range!("cat"); + let text2 = range!("map"); let solution = Solution { text1, text2, diffs: bisect(text1, text2), - utf8: false, }; assert_diffs!( [ @@ -446,24 +457,24 @@ fn test_main() { let solution = main(Range::empty(), Range::empty()); assert_diffs!([], solution, "Null case"); - let solution = main(Range::new("abc", ..), Range::new("abc", ..)); + let solution = main(range!("abc"), range!("abc")); assert_diffs!([Equal("abc")], solution, "Equality"); - let solution = main(Range::new("abc", ..), Range::new("ab123c", ..)); + let solution = main(range!("abc"), range!("ab123c")); assert_diffs!( [Equal("ab"), Insert("123"), Equal("c")], solution, "Simple insertion", ); - let solution = main(Range::new("a123bc", ..), Range::new("abc", ..)); + let solution = main(range!("a123bc"), range!("abc")); assert_diffs!( [Equal("a"), Delete("123"), Equal("bc")], solution, "Simple deletion", ); - let solution = main(Range::new("abc", ..), Range::new("a123b456c", ..)); + let solution = main(range!("abc"), range!("a123b456c")); assert_diffs!( [ Equal("a"), @@ -476,7 +487,7 @@ fn test_main() { "Two insertions", ); - let solution = main(Range::new("a123b456c", ..), Range::new("abc", ..)); + let solution = main(range!("a123b456c"), range!("abc")); assert_diffs!( [ Equal("a"), @@ -489,12 +500,12 @@ fn test_main() { "Two deletions", ); - let solution = main(Range::new("a", ..), Range::new("b", ..)); + let solution = main(range!("a"), range!("b")); assert_diffs!([Delete("a"), Insert("b")], solution, "Simple case #1"); let solution = main( - Range::new("Apples are a fruit.", ..), - Range::new("Bananas are also fruit.", ..), + range!("Apples are a fruit."), + range!("Bananas are also fruit."), ); assert_diffs!( [ @@ -508,7 +519,7 @@ fn test_main() { "Simple case #2", ); - let solution = main(Range::new("ax\t", ..), Range::new("\u{0680}x\000", ..)); + let solution = main(range!("ax\t"), range!("\u{0680}x\000")); assert_diffs!( [ Delete("a"), @@ -521,7 +532,7 @@ fn test_main() { "Simple case #3", ); - let solution = main(Range::new("1ayb2", ..), Range::new("abxab", ..)); + let solution = main(range!("1ayb2"), range!("abxab")); assert_diffs!( [ Delete("1"), @@ -535,7 +546,7 @@ fn test_main() { "Overlap #1", ); - let solution = main(Range::new("abcy", ..), Range::new("xaxcxabc", ..)); + let solution = main(range!("abcy"), range!("xaxcxabc")); assert_diffs!( [Insert("xaxcx"), Equal("abc"), Delete("y")], solution, @@ -543,8 +554,8 @@ fn test_main() { ); let solution = main( - Range::new("ABCDa=bcd=efghijklmnopqrsEFGHIJKLMNOefg", ..), - Range::new("a-bcd-efghijklmnopqrs", ..), + range!("ABCDa=bcd=efghijklmnopqrsEFGHIJKLMNOefg"), + range!("a-bcd-efghijklmnopqrs"), ); assert_diffs!( [ @@ -563,8 +574,8 @@ fn test_main() { ); let solution = main( - Range::new("a [[Pennsylvania]] and [[New", ..), - Range::new(" and [[Pennsylvania]]", ..), + range!("a [[Pennsylvania]] and [[New"), + range!(" and [[Pennsylvania]]"), ); assert_diffs!( [ |