use std::path::Path;

use criterion::{criterion_group, criterion_main, Criterion};

fn diff_main(c: &mut Criterion) {

let basedir = Path::new("testdata");

let dmp = DiffMatchPatch::default();

c.bench_function("diff-match-patch", |bencher| {

});

}

use std::{char, collections::HashMap, fmt::Display};

use chrono::{NaiveTime, TimeDelta, Utc};

/// Enum representing the different ops of diff

#[derive(Debug, PartialEq, Eq, Clone, Copy)]

/// (Ops::Insert, String::new("Goodbye")) means add `Goodbye`

/// (Ops::Equal, String::new("World")) means keep world

#[derive(Debug, Clone, PartialEq, Eq)]

impl Display for Diff<u8> {

fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

}

}

/// Create a new diff object

pub fn new(op: Ops, data: &[T]) -> Self {

Self(op, data.to_vec())

/// 1.0 to the score (0.0 is a perfect match).

/// int Match_Distance;

match_distance: usize,

/// When deleting a large block of text (over ~64 characters), how close does

/// the contents have to match the expected contents. (0.0 = perfection,

/// 1.0 = very loose). Note that `match_threshold` controls how closely the

/// end points of a delete need to match.

delete_threshold: f32,

/// Chunk size for context length.

}

impl Default for DiffMatchPatch {

}

#[derive(Debug, PartialEq, Eq)]

prefix_long: &'a [T],

suffix_long: &'a [T],

prefix_short: &'a [T],

}

// returns the current patch margin

self.patch_margin

}

self.match_distance = distance

}

&self,

linemode: bool,

deadline: Option<NaiveTime>,

// First, check if lhs and rhs are equal

if old_bytes == new_bytes {

if old_bytes.is_empty() {

Ok(diffs)

}

&self,

linemode: bool,

deadline: Option<NaiveTime>,

// returning all of the new part

if old.is_empty() {

return Ok(vec![Diff::insert(new)]);

}

}

// Don't risk returning a suboptimal diff when we have unlimited time

self.timeout()?;

// Quick line-level diff on both strings, then rediff the parts for greater accuracy

// This speedup can produce non-minimal diffs

&self,

deadline: Option<NaiveTime>,

let mut diffs = {

let to_chars = Self::lines_to_chars(old, new);

let diffs =

// Find the 'middle snake' of a diff, split the problem in two

// and return the recursively constructed diff.

// See Myers 1986 paper: An O(ND) Difference Algorithm and Its Variations.

&self,

old: &'a [T],

new: &'a [T],

// is at least half the length of longtext?

//idx Start index of quarter length substring within longtext.

#[inline]

long: &'a [T],

short: &'a [T],

idx: usize,

// Reverse prefix is suffix

// TODO: investigate this further

#[inline]

if lhs.is_empty()

|| rhs.is_empty()

|| (!reverse && (lhs.first() != rhs.first()))

}

#[inline]

if lhs.is_empty() || rhs.is_empty() {

return 0;

}

// Reduce the number of edits by eliminating semantically trivial equalities

#[inline]

let mut changes = false;

let mut pointer = 0_usize;

// Look for single edits surrounded on both sides by equalities

// e.g: The c<ins>at c</ins>ame. -> The <ins>cat </ins>came.

#[inline]

let mut pointer = 1_usize;

let mut difflen = diffs.len();

// boundary falls on logical boundaries

// Scores range from 6 (best) to 0 (worst)

#[inline]

} else {

return 6;

};

let linebreak_1 = whitespace_1 && (char1 == '\n' || char1 == '\r');

let linebreak_2 = whitespace_2 && (char2 == '\n' || char2 == '\r');

if blankline_1 || blankline_2 {

// 5 for blank lines

// Reorder and merge like edit sections. Merge equalities.

// Any edit section can move as long as it doesn't cross an equality.

#[inline]

// Push a dummy diff ... this triggers the equality as a last step

diffs.push(Diff::equal(&[]));

}

}

let mut data = diffs

.iter()

.map(|diff| {

match diff.op() {

Ops::Insert => {

// format!("+{encoded}")

}

}

})

.collect::<Vec<_>>()

data

}

let mut pointer = 0; // cursor to text

let mut diffs = vec![];

if token.is_empty() {

continue;

}

let opcode = token.first();

let param = &token[1..];

diffs.push(Diff::insert(&param));

if n < 0 {

return Err(crate::errors::Error::InvalidInput);

}

let txt = &old[pointer..new_pointer];

pointer = new_pointer;

diffs.push(Diff::equal(txt))

} else {

diffs.push(Diff::delete(txt))

}

#[inline]

let mut char1 = 0;

let mut char2 = 0;

}

#[inline]

diffs

.iter()

.filter_map(|diff| {

.concat()

}

diffs

.iter()

.filter_map(|diff| {

// limit of the match algorithm.

// Intended to be called only from within patch_apply.

#[inline]

let max_bit = self.match_max_bits();

let patch_margin = self.patch_margin() as usize;

}

#[derive(Debug, Eq, PartialEq)]

chars_old: Vec<usize>,

chars_new: Vec<usize>,

}

impl DiffMatchPatch {

#[inline]

// Allocate 2/3rds of the UTF16::MAX (65535) value space for text1, the rest for text2.

// let mut maxlines = 5;

}

#[inline]

maxlines: usize,

) -> Vec<usize> {

let take = maxlines - array.len();

let mut broke = false;

let mut cursor = 0;

.enumerate()

.take(take)

.for_each(|(idx, line)| {

}

#[inline]

diffs

.iter()

.map(|d| {

// Match methods

impl DiffMatchPatch {

// Check for null inputs.

// Nothing to match.

if text.is_empty() {

}

}

if pattern.len() > self.match_max_bits() {

todo!("Throw error");

}

best_loc

}

let mut map = HashMap::with_capacity(pattern.len());

pattern.iter().enumerate().for_each(|(i, &p)| {

}

// Patch Methods

start1: usize,

start2: usize,

length1: usize,

length2: usize,

}

fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

let coord1 = if self.length1 == 0 {

format!("{},0", self.start1)

coord2,

" @@\n".to_string(),

];

let sign = match diff.op() {

Ops::Insert => '+',

Ops::Delete => '-',

Ops::Equal => ' ',

};

segments.push(segment)

write!(f, "{}", segments.join(""))

}

}

&self.diffs[..]

}

}

Texts(&'a str, &'a str),

}

impl DiffMatchPatch {

let mut section = Vec::with_capacity(64);

let mut current_sect = 0;

let mut new_cols = None;

for &c in s.iter() {

match current_sect {

0 => {

return None;

}

}

return None;

}

let ol = splits.first()?;

if let Some(&oc) = splits.get(1) {

}

}

2 => {

.collect::<Vec<_>>();

let nl = splits.first()?;

if let Some(&nc) = splits.get(1) {

}

}

_ => {

continue;

}

return None;

}

section.push(c);

}

return None;

}

Some((old_line, old_cols, new_line, new_cols))

}

&self,

// No diffs -> no patches

if diffs.is_empty() {

return Ok(Vec::new());

let mut char_n1 = 0;

let mut char_n2 = 0;

diffs.iter().enumerate().for_each(|(idx, diff)| {

// a new patch starts here

Ok(patches)

}

if text.is_empty() {

return;

}

patch.length2 += prefix.len() + suffix.len();

}

&self,

if patches.is_empty() {

return Ok((source.to_vec(), vec![]));

}

Ok((source, results))

}

.collect::<Vec<_>>();

// Bump all the patches forward.

patches.iter_mut().for_each(|p| {

p.start1 += pad_len;

/// Create a new instance of the struct with default settings

/// # Example

/// ```

///

/// # fn main() -> Result<(), Error> {

/// let mut dmp = DiffMatchPatch::new();

/// // change some settings, e.g. set `line mode` optimization to `false` because you know you have a small text and not many lines

/// dmp.set_checklines(false);

/// // do the diffing

/// # Ok(())

/// # }

/// ```

/// Vec of changes (Diff).

/// # Example

/// ```

///

/// # fn main() -> Result<(), Error> {

/// let mut dmp = DiffMatchPatch::new();

/// // change some settings, e.g. set `line mode` optimization to `false` because you know you have a small text and not many lines

/// dmp.set_checklines(false);

/// // do the diffing

/// println!("{}", diffs.iter().map(|d| format!("d")).collect::<Vec<_>>().join("\n"));

/// // You should see the following output

/// // (Delete, F)

/// # Ok(())

/// # }

/// ```

}

/// A diff of two unrelated texts can be filled with coincidental matches.

/// Given a diff, measure its Levenshtein distance in terms of the number of inserted, deleted or substituted characters.

/// The minimum distance is 0 which means equality, the maximum distance is the length of the longer string.

let mut levenshtein = 0;

let mut insert = 0;

let mut delete = 0;

/// Given two texts, or an already computed list of differences, return an array of patch objects.

/// The third form PatchInput::TextDiffs(...) is preferred, use it if you happen to have that data available, otherwise this function will compute the missing pieces.

/// TODO: add example

let mut diff_input;

let txt_old;

let (txt, diffs) = match input {

// No diffs provided, lets make our own

PatchInput::Texts(txt1, txt2) => {

if diff_input.len() > 2 {

Self::cleanup_semantic(&mut diff_input);

}

}

PatchInput::Diffs(diffs) => {

// No origin string provided, compute our own.

}

};

}

/// Reduces an array of patch objects to a block of text which looks extremely similar to the standard GNU diff/patch format. This text may be stored or transmitted.

/// TODO: add example

patches.iter().map(|p| p.to_string()).collect::<String>()

}

/// Parses a block of text (which was presumably created by the patch_toText function) and returns an array of patch objects.

/// TODO: add example

if text.is_empty() {

return Ok(vec![]);

}

let mut patches = vec![];

};

// Should never panic, already checked for `empty`

}

text.remove(0);

/// If patch_delete_threshold is closer to 1, then the deleted text may contain anything.

/// In most use cases Patch_DeleteThreshold should just be set to the same value as match_threshold.

/// TODO: add example

&self,

source_txt: &str,

) -> Result<(String, Vec<bool>), crate::errors::Error> {

Ok((

results,

))

}

use crate::{

dmp::{Diff, HalfMatch, LineToChars},

};

#[test]

fn test_patch_add_padding() -> Result<(), Error> {

let dmp = DiffMatchPatch::default();

// Both edges full.

assert_eq!("@@ -0,0 +1,4 @@\n+test\n", dmp.patch_to_text(&patches));

dmp.patch_add_padding(&mut patches);

assert_eq!(

"@@ -1,8 +1,12 @@\n %01%02%03%04\n+test\n %01%02%03%04\n",

);

// Both edges partial.

assert_eq!(

"@@ -1,2 +1,6 @@\n X\n+test\n Y\n",

dmp.patch_to_text(&patches)

);

// Both edges none.

assert_eq!(

"@@ -1,8 +1,12 @@\n XXXX\n+test\n YYYY\n",

dmp.patch_to_text(&patches)

let dmp = DiffMatchPatch::default();

// Assumes that dmp.Match_MaxBits is 32.

"abcdefghijklmnopqrstuvwxyz01234567890",

"XabXcdXefXghXijXklXmnXopXqrXstXuvXwxXyzX01X23X45X67X89X0",

))?;

dmp.patch_to_text(&patches)

);

"abcdef1234567890123456789012345678901234567890123456789012345678901234567890uvwxyz",

"abcdefuvwxyz",

))?;

dmp.split_max(&mut patches);

assert_eq!(p2t, dmp.patch_to_text(&patches));

"1234567890123456789012345678901234567890123456789012345678901234567890",

"abc",

))?;

dmp.patch_to_text(&patches)

);

"abcdefghij , h : 0 , t : 1 abcdefghij , h : 0 , t : 1 abcdefghij , h : 0 , t : 1",

"abcdefghij , h : 1 , t : 1 abcdefghij , h : 1 , t : 1 abcdefghij , h : 0 , t : 1",

))?;

pub mod dmp;

pub mod errors;

pub mod traits;

pub use dmp::{DiffMatchPatch, Ops, Patch, PatchInput, Patches};

pub use errors::Error;

use chrono::NaiveTime;

use crate::dmp::{Diff, DiffMatchPatch};

fn bisect_split(

dmp: &DiffMatchPatch,

old: &[Self],

y: usize,

deadline: Option<NaiveTime>,

) -> Result<Vec<Diff<Self>>, crate::errors::Error>;

}

fn bisect_split(

dmp: &DiffMatchPatch,

old: &[u8],

Ok(diffs_a)

}

}

fn bisect_split(

dmp: &DiffMatchPatch,

old: &[usize],

Ok(diffs_a)

}

}

use diff_match_patch_rs::dmp::Diff;

// const tests = [

// 'testDiffIsDestructurable',

// Which means the the diff should an equality block of 3 bytes folloed by insert and delete

let old = "🤪"; // [240, 159, 164, 170]

let new = "🤔"; // [240, 159, 164, 148]

assert_eq!(

"<span></span><del style=\"background:#ffe6e6;\">🤪</del><ins style=\"background:#e6ffe6;\">🤔</ins>",

dmp.diff_pretty_html(&diffs)?

// Now Case 1. but with some text before and after

let old = "I'm puzzled🤪 or am I?";

let new = "I'm puzzled🤔 or thinking I guess!";

assert_eq!(

"<span>I'm puzzled</span><del style=\"background:#ffe6e6;\">🤪</del><ins style=\"background:#e6ffe6;\">🤔</ins><span> or </span><del style=\"background:#ffe6e6;\">am I?</del><ins style=\"background:#e6ffe6;\">thinking I guess!</ins>",

dmp.diff_pretty_html(&diffs)?

// Case 2. Emoticons with the third position different

let old = "🍊"; // [240, 159, 141, 138]

let new = "🌊"; // [240, 159, 140, 138]

assert_eq!(

"<span></span><del style=\"background:#ffe6e6;\">🍊</del><ins style=\"background:#e6ffe6;\">🌊</ins>",

dmp.diff_pretty_html(&diffs)?

// Now Case 2. but with some text, lets complicate this

let old = "🍊, aah orange is the new black!"; // [240, 159, 141, 138]

let new = "Aah orange!🌊is the new 🌊"; // [240, 159, 140, 138]

assert_eq!(

"<del style=\"background:#ffe6e6;\">🍊, a</del><ins style=\"background:#e6ffe6;\">A</ins><span>ah orange</span><del style=\"background:#ffe6e6;\"> </del><ins style=\"background:#e6ffe6;\">!🌊</ins><span>is the new </span><del style=\"background:#ffe6e6;\">black!</del><ins style=\"background:#e6ffe6;\">🌊</ins>",

dmp.diff_pretty_html(&diffs)?

// Case 3. with second and third different, but lets complicate this with an equality

let old = "𠌊"; // [240, 160, 140, 138]

let new = "𖠊"; // [240, 150, 160, 138]

assert_eq!(

"<span></span><ins style=\"background:#e6ffe6;\">𖠊</ins><del style=\"background:#ffe6e6;\">𠌊</del>",

dmp.diff_pretty_html(&diffs)?

// Case 3. but let there be a swap

let old = "𞠄"; // [240, 158, 160, 132]

let new = std::str::from_utf8(&[240, 160, 158, 132]).unwrap(); // basically an undefined element `𠞄`. Should still work

assert_eq!(

"<span></span><del style=\"background:#ffe6e6;\">𞠄</del><ins style=\"background:#e6ffe6;\">𠞄</ins>",

dmp.diff_pretty_html(&diffs)?

// Case 4. swap at the last 2 positions

let old = "🍌"; // [240, 159, 141, 140] -- FINALLY A BANANA

let new = "🌍"; // [240, 159, 140, 141] -- interesting revelation - last 2 bytes swapped and 🍌 becomes 🌍. Guess the world is going `Bananas!!`

assert_eq!(

"<span></span><del style=\"background:#ffe6e6;\">🍌</del><ins style=\"background:#e6ffe6;\">🌍</ins>",

dmp.diff_pretty_html(&diffs)?

// Let's do this with a slightly longish string

let old = "Now, let's explore some emotional extremes 🌊.\nWe've got your ecstatic face 🤩, your devastated face 😭, and your utterly confused face 🤯. But that's not all! 🤔 We've also got some subtle emotions like 😐, 🙃, and 👀.";

let new = "Let's start with some basics 😊.\nWe've got your standard smiley face 🙂, your sad face ☹️, and your angry face 😠. But wait, there's more! 🤩 We've also got some more complex emotions like 😍, 🤤, and 🚀. And let's not forget about the classics: 😉, 👍, and 👏.";

assert_eq!(

"<del style=\"background:#ffe6e6;\">Now, let's explore some emotional extreme</del><ins style=\"background:#e6ffe6;\">Let's start with some basic</ins><span>s </span><del style=\"background:#ffe6e6;\">🌊</del><ins style=\"background:#e6ffe6;\">😊</ins><span>.&para;<br>We've got your </span><del style=\"background:#ffe6e6;\">ec</del><span>sta</span><del style=\"background:#ffe6e6;\">tic</del><ins style=\"background:#e6ffe6;\">ndard smiley</ins><span> face </span><del style=\"background:#ffe6e6;\">🤩</del><ins style=\"background:#e6ffe6;\">🙂</ins><span>, your </span><del style=\"background:#ffe6e6;\">devastate</del><ins style=\"background:#e6ffe6;\">sa</ins><span>d face </span><del style=\"background:#ffe6e6;\">😭</del><ins style=\"background:#e6ffe6;\">☹️</ins><span>, and your </span><del style=\"background:#ffe6e6;\">utterly confused</del><ins style=\"background:#e6ffe6;\">angry</ins><span> face </span><del style=\"background:#ffe6e6;\">🤯</del><ins style=\"background:#e6ffe6;\">😠</ins><span>. But </span><del style=\"background:#ffe6e6;\">that's not all</del><ins style=\"background:#e6ffe6;\">wait, there's more</ins><span>! </span><del style=\"background:#ffe6e6;\">🤔</del><ins style=\"background:#e6ffe6;\">🤩</ins><span> We've also got some </span><del style=\"background:#ffe6e6;\">subt</del><ins style=\"background:#e6ffe6;\">more comp</ins><span>le</span><ins style=\"background:#e6ffe6;\">x</ins><span> emotions like </span><del style=\"background:#ffe6e6;\">😐</del><ins style=\"background:#e6ffe6;\">😍, 🤤, and 🚀. And let's not forget about the classics: 😉</ins><span>, </span><del style=\"background:#ffe6e6;\">🙃</del><ins style=\"background:#e6ffe6;\">👍</ins><span>, and </span><del style=\"background:#ffe6e6;\">👀</del><ins style=\"background:#e6ffe6;\">👏</ins><span>.</span>",

// Perform a trivial diff.

// Null case.

// Equality

// Simple insert

assert_eq!(

vec![Diff::equal(b"ab"), Diff::insert(b"123"), Diff::equal(b"c")],

);

// Simple delete

assert_eq!(

vec![Diff::equal(b"a"), Diff::delete(b"123"), Diff::equal(b"bc")],

);

// Two insertions

Diff::insert(b"456"),

Diff::equal(b"c"),

],

);

// Two deletions.

Diff::delete(b"456"),

Diff::equal(b"c"),

],

);

// Perform a real diff.

// Simple cases.

assert_eq!(

vec![Diff::delete(b"a"), Diff::insert(b"b"),],

);

assert_eq!(

Diff::insert(b"lso"),

Diff::equal(b" fruit.")

],

);

assert_eq!(

Diff::delete(b"\t"),

Diff::insert(b"\0")

],

);

// Overlaps.

Diff::delete(b"2"),

Diff::insert(b"xab"),

],

);

assert_eq!(

Diff::equal(b"abc"),

Diff::delete(b"y"),

],

);

assert_eq!(

Diff::equal(b"efghijklmnopqrs"),

Diff::delete(b"EFGHIJKLMNOefg"),

],

"ABCDa=bcd=efghijklmnopqrsEFGHIJKLMNOefg",

"a-bcd-efghijklmnopqrs"

)?

Diff::equal(b" [[Hepatopancreatic]]"),

Diff::delete(b" and [[New"),

],

"a [[Hepatopancreatic]] and [[New",

" and [[Hepatopancreatic]]"

)?

let b = vec!["I am the very model of a modern major general,\nI\'ve information vegetable, animal, and mineral,\nI know the kings of England, and I quote the fights historical,\nFrom Marathon to Waterloo, in order categorical.\n"; 2048].join("");

let start = Utc::now().time();

let end = Utc::now().time();

// Test that we took at least the timeout period (+ 5ms being generous).

assert!((end - start).num_milliseconds() <= LOW_TIMEOUT as i64 + 5);

let a = "12345678901234567890123456789 0123456 78901234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n";

let b = "abcdefghij abcdefghij abcdefghij abcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\n";

dmp.set_checklines(false);

dmp.set_checklines(true);

// Now, we'll run 2 checks - one for result equality

assert_eq!(res_no_lm, res_yes_lm);

let a = "1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890";

let b = "abcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghij";

dmp.set_checklines(false);

dmp.set_checklines(true);

assert_eq!(no_lm, yes_lm);

// Overlap line-mode.

let a = "1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n";

let b = "abcdefghij\n1234567890\n1234567890\n1234567890\nabcdefghij\n1234567890\n1234567890\n1234567890\nabcdefghij\n1234567890\n1234567890\n1234567890\nabcdefghij\n";

dmp.set_checklines(false);

dmp.set_checklines(true);

assert_eq!(rebuild_text(&yes_lm[..])?, rebuild_text(&no_lm[..])?);

// Benefits of checklines can only be realized in text with many lines

let new = std::fs::read_to_string("testdata/txt_new.txt").unwrap();

let start = Instant::now();

let yes_lm_dur = Instant::now() - start;

assert!(diff_yes_lm.is_ok());

dmp.set_checklines(false);

let start = Instant::now();

let no_lm_dur = Instant::now() - start;

assert!(diff_no_lm.is_ok());

fn test_patch_from_text() -> Result<(), Error> {

let dmp = DiffMatchPatch::new();

let strp = "@@ -21,18 +22,17 @@\n jump\n-s\n+ed\n over \n-the\n+a\n %0Alaz\n";

assert_eq!(

"@@ -1 +1 @@\n-a\n+b\n",

);

assert_eq!(

"@@ -1,3 +0,0 @@\n-abc\n",

);

assert_eq!(

"@@ -0,0 +1,3 @@\n+abc\n",

);

// Generates error.

Ok(())

}

let dmp = DiffMatchPatch::new();

let strp = "@@ -21,18 +22,17 @@\n jump\n-s\n+ed\n over \n-the\n+a\n laz\n";

assert_eq!(strp, dmp.patch_to_text(&patches));

let strp = "@@ -1,9 +1,9 @@\n-f\n+F\n oo+fooba\n@@ -7,9 +7,9 @@\n obar\n-,\n+.\n tes\n";

assert_eq!(strp, dmp.patch_to_text(&patches));

Ok(())

#[test]

fn test_patch_make() -> Result<(), Error> {

let dmp = DiffMatchPatch::default();

assert!(patches.is_empty());

let txt1 = "The quick brown fox jumps over the lazy dog.";

let txt2 = "That quick brown fox jumped over a lazy dog.";

// The second patch must be "-21,17 +21,18", not "-22,17 +21,18" due to rolling context.

assert_eq!("@@ -1,8 +1,7 @@\n Th\n-at\n+e\n qui\n@@ -21,17 +21,18 @@\n jump\n-ed\n+s\n over \n-a\n+the\n laz\n", dmp.patch_to_text(&patches));

// Text1+Text2 inputs.

assert_eq!("@@ -1,11 +1,12 @@\n Th\n-e\n+at\n quick b\n@@ -22,18 +22,17 @@\n jump\n-s\n+ed\n over \n-the\n+a\n laz\n", dmp.patch_to_text(&patches));

// Diff input.

let patches = dmp.patch_make(PatchInput::Diffs(&diffs[..]))?;

assert_eq!("@@ -1,11 +1,12 @@\n Th\n-e\n+at\n quick b\n@@ -22,18 +22,17 @@\n jump\n-s\n+ed\n over \n-the\n+a\n laz\n", dmp.patch_to_text(&patches));

assert_eq!("@@ -1,11 +1,12 @@\n Th\n-e\n+at\n quick b\n@@ -22,18 +22,17 @@\n jump\n-s\n+ed\n over \n-the\n+a\n laz\n", dmp.patch_to_text(&patches));

// Character encoding.

"`1234567890-=[]\\;',./",

"~!@#$%^&*()_+{}|:\"<>?",

))?;

// Long string with repeats.

let txt1 = vec!["abcdef"; 100].join("");

let txt2 = [&txt1, "123"].join("");

assert_eq!(

"@@ -573,28 +573,31 @@\n cdefabcdefabcdefabcdefabcdef\n+123\n",

dmp.patch_to_text(&patches)

fn test_patch_apply() -> Result<(), Error> {

let mut dmp = DiffMatchPatch::default();

let (txt, results) = dmp.patch_apply(&patches, "Hello world.")?;

assert_eq!(format!("{}\t{}", txt, results.len()), "Hello world.\t0");

"The quick brown fox jumps over the lazy dog.",

"That quick brown fox jumped over a lazy dog.",

))?;

);

// Big delete, small change

"x1234567890123456789012345678901234567890123456789012345678901234567890y",

"xabcy",

))?;

);

// Big delete, large change

"x1234567890123456789012345678901234567890123456789012345678901234567890y",

"xabcy",

))?;

);

dmp.set_delete_threshold(0.6);

"x1234567890123456789012345678901234567890123456789012345678901234567890y",

"xabcy",

))?;

// Compesate for failed patch

dmp.set_match_threshold(0.);

dmp.set_match_distance(0);

"abcdefghijklmnopqrstuvwxyz--------------------1234567890",

"abcXXXXXXXXXXdefghijklmnopqrstuvwxyz--------------------1234567YYYYYYYYYY890",

))?;

dmp.set_match_distance(1000);

// No side-effects - kinds useless cos patches is not mutable in rust

let srcstr = dmp.patch_to_text(&patches);

dmp.patch_apply(&patches, "")?;

assert_eq!(srcstr, dmp.patch_to_text(&patches));

"The quick brown fox jumps over the lazy dog.",

"Woof",

))?;

assert_eq!(srcstr, dmp.patch_to_text(&patches));

// Edge exact match

assert_eq!(

("test".to_string(), vec![true]),

dmp.patch_apply(&patches, "")?

);

// Near edge exact match

assert_eq!(

("XtestY".to_string(), vec![true]),

dmp.patch_apply(&patches, "XY")?

);

// Edge partial match

assert_eq!(

("x123".to_string(), vec![true]),

dmp.patch_apply(&patches, "x")?