if (type(v) == 'string') then

return string.format('%q', v):gsub('\\\n', '\\n')

elseif (type(v) == 'table') then

local str = {}

local next_i = 1

for i, v in pairs(v) do

if (i == next_i) then

next_i = next_i + 1

str[#str + 1] = pretty(v)

else

str[#str + 1] = '[' .. pretty(i) .. ']=' .. pretty(v)

end

end

return '{' .. table.concat(str, ',') .. '}'

else

return tostring(v)

end

local msg, expected, actual

if (select('#', ...) == 2) then

expected, actual = ...

msg = 'Expected: \'' .. pretty(expected)

.. '\' Actual: \'' .. pretty(actual) .. '\''

else

msg, expected, actual = ...

end

assert(expected == actual, msg)

local msg, actual

if (select('#', ...) == 1) then

actual = ...

assertEquals(true, actual)

else

msg, actual = ...

assertEquals(msg, true, actual)

end

local msg, actual

if (select('#', ...) == 1) then

actual = ...

assertEquals(flase, actual)

else

msg, actual = ...

assertEquals(msg, false, actual)

end

local msg, expected, actual

expected, actual = ...

msg = 'Expected: \'' .. pretty(expected)

.. '\' Actual: \'' .. pretty(actual) .. '\''

if (_equivalent(expected, actual)) then

assertEquals(msg, pretty(expected), pretty(actual))

else

assertEquals(msg, expected, actual)

end

if (a == b) then

return true

end

if (type(a) == 'table') and (type(b) == 'table') then

for k, v in pairs(a) do

if not _equivalent(v, b[k]) then

return false

end

end

for k, v in pairs(b) do

if not _equivalent(v, a[k]) then

return false

end

end

return true

end

return false

-- Construct the two texts which made up the diff originally.

local text1, text2 = {}, {}

for x, diff in ipairs(diffs) do

local op, data = diff[1], diff[2]

if (op ~= DIFF_INSERT) then

text1[#text1 + 1] = data

end

if (op ~= DIFF_DELETE) then

text2[#text2 + 1] = data

end

end

return table.concat(text1), table.concat(text2)

-- Detect any common prefix.

-- Null case.

assertEquals(0, dmp.diff_commonPrefix('abc', 'xyz'))

-- Non-null case.

assertEquals(4, dmp.diff_commonPrefix('1234abcdef', '1234xyz'))

-- Whole case.

assertEquals(4, dmp.diff_commonPrefix('1234', '1234xyz'))

-- Detect any common suffix.

-- Null case.

assertEquals(0, dmp.diff_commonSuffix('abc', 'xyz'))

-- Non-null case.

assertEquals(4, dmp.diff_commonSuffix('abcdef1234', 'xyz1234'))

-- Whole case.

assertEquals(4, dmp.diff_commonSuffix('1234', 'xyz1234'))

-- Detect any suffix/prefix overlap.

-- Null case.

assertEquals(0, dmp.diff_commonOverlap('', 'abcd'));

-- Whole case.

assertEquals(3, dmp.diff_commonOverlap('abc', 'abcd'));

-- No overlap.

assertEquals(0, dmp.diff_commonOverlap('123456', 'abcd'));

-- Overlap.

assertEquals(3, dmp.diff_commonOverlap('123456xxx', 'xxxabcd'));

--[[

-- Detect a halfmatch.

dmp.settings{Diff_Timeout = 1}

-- No match.

assertEquivalent({nil}, {dmp.diff_halfMatch('1234567890', 'abcdef')})

assertEquivalent({nil}, {dmp.diff_halfMatch('12345', '23')})

-- Single Match.

assertEquivalent({'12', '90', 'a', 'z', '345678'},

{dmp.diff_halfMatch('1234567890', 'a345678z')})

assertEquivalent({'a', 'z', '12', '90', '345678'},

{dmp.diff_halfMatch('a345678z', '1234567890')})

assertEquivalent({'abc', 'z', '1234', '0', '56789'},

{dmp.diff_halfMatch('abc56789z', '1234567890')})

assertEquivalent({'a', 'xyz', '1', '7890', '23456'},

{dmp.diff_halfMatch('a23456xyz', '1234567890')})

-- Multiple Matches.

assertEquivalent({'12123', '123121', 'a', 'z', '1234123451234'},

{dmp.diff_halfMatch('121231234123451234123121', 'a1234123451234z')})

assertEquivalent({'', '-=-=-=-=-=', 'x', '', 'x-=-=-=-=-=-=-='},

{dmp.diff_halfMatch('x-=-=-=-=-=-=-=-=-=-=-=-=', 'xx-=-=-=-=-=-=-=')})

assertEquivalent({'-=-=-=-=-=', '', '', 'y', '-=-=-=-=-=-=-=y'},

{dmp.diff_halfMatch('-=-=-=-=-=-=-=-=-=-=-=-=y', '-=-=-=-=-=-=-=yy')})

-- Non-optimal halfmatch.

-- Optimal diff would be -q+x=H-i+e=lloHe+Hu=llo-Hew+y not -qHillo+x=HelloHe-w+Hulloy

assertEquivalent({'qHillo', 'w', 'x', 'Hulloy', 'HelloHe'},

{dmp.diff_halfMatch('qHilloHelloHew', 'xHelloHeHulloy')})

-- Optimal no halfmatch.

dmp.settings{Diff_Timeout = 0}

assertEquivalent({nill}, {dmp.diff_halfMatch('qHilloHelloHew', 'xHelloHeHulloy')})

-- Cleanup a messy diff.

-- Null case.

local diffs = {}

dmp.diff_cleanupMerge(diffs)

assertEquivalent({}, diffs)

-- No change case.

diffs = {{DIFF_EQUAL, 'a'}, {DIFF_DELETE, 'b'}, {DIFF_INSERT, 'c'}}

dmp.diff_cleanupMerge(diffs)

assertEquivalent({{DIFF_EQUAL, 'a'}, {DIFF_DELETE, 'b'}, {DIFF_INSERT, 'c'}},

diffs)

-- Merge equalities.

diffs = {{DIFF_EQUAL, 'a'}, {DIFF_EQUAL, 'b'}, {DIFF_EQUAL, 'c'}}

dmp.diff_cleanupMerge(diffs)

assertEquivalent({{DIFF_EQUAL, 'abc'}}, diffs)

-- Merge deletions.

diffs = {{DIFF_DELETE, 'a'}, {DIFF_DELETE, 'b'}, {DIFF_DELETE, 'c'}}

dmp.diff_cleanupMerge(diffs)

assertEquivalent({{DIFF_DELETE, 'abc'}}, diffs)

-- Merge insertions.

diffs = {{DIFF_INSERT, 'a'}, {DIFF_INSERT, 'b'}, {DIFF_INSERT, 'c'}}

dmp.diff_cleanupMerge(diffs)

assertEquivalent({{DIFF_INSERT, 'abc'}}, diffs)

-- Merge interweave.

diffs = {{DIFF_DELETE, 'a'}, {DIFF_INSERT, 'b'}, {DIFF_DELETE, 'c'},

{DIFF_INSERT, 'd'}, {DIFF_EQUAL, 'e'}, {DIFF_EQUAL, 'f'}}

dmp.diff_cleanupMerge(diffs)

assertEquivalent({{DIFF_DELETE, 'ac'}, {DIFF_INSERT, 'bd'}, {DIFF_EQUAL, 'ef'}},

diffs)

-- Prefix and suffix detection.

diffs = {{DIFF_DELETE, 'a'}, {DIFF_INSERT, 'abc'}, {DIFF_DELETE, 'dc'}}

dmp.diff_cleanupMerge(diffs)

assertEquivalent({{DIFF_EQUAL, 'a'}, {DIFF_DELETE, 'd'},

{DIFF_INSERT, 'b'}, {DIFF_EQUAL, 'c'}}, diffs)

-- Prefix and suffix detection with equalities.

diffs = {{DIFF_EQUAL, 'x'}, {DIFF_DELETE, 'a'}, {DIFF_INSERT, 'abc'},

{DIFF_DELETE, 'dc'}, {DIFF_EQUAL, 'y'}}

dmp.diff_cleanupMerge(diffs)

assertEquivalent({{DIFF_EQUAL, 'xa'}, {DIFF_DELETE, 'd'},

{DIFF_INSERT, 'b'}, {DIFF_EQUAL, 'cy'}}, diffs)

-- Slide edit left.

diffs = {{DIFF_EQUAL, 'a'}, {DIFF_INSERT, 'ba'}, {DIFF_EQUAL, 'c'}}

dmp.diff_cleanupMerge(diffs)

assertEquivalent({{DIFF_INSERT, 'ab'}, {DIFF_EQUAL, 'ac'}}, diffs)

-- Slide edit right.

diffs = {{DIFF_EQUAL, 'c'}, {DIFF_INSERT, 'ab'}, {DIFF_EQUAL, 'a'}}

dmp.diff_cleanupMerge(diffs)

assertEquivalent({{DIFF_EQUAL, 'ca'}, {DIFF_INSERT, 'ba'}}, diffs)

-- Slide edit left recursive.

diffs = {{DIFF_EQUAL, 'a'}, {DIFF_DELETE, 'b'}, {DIFF_EQUAL, 'c'},

{DIFF_DELETE, 'ac'}, {DIFF_EQUAL, 'x'}}

dmp.diff_cleanupMerge(diffs)

assertEquivalent({{DIFF_DELETE, 'abc'}, {DIFF_EQUAL, 'acx'}}, diffs)

-- Slide edit right recursive.

diffs = {{DIFF_EQUAL, 'x'}, {DIFF_DELETE, 'ca'}, {DIFF_EQUAL, 'c'},

{DIFF_DELETE, 'b'}, {DIFF_EQUAL, 'a'}}

dmp.diff_cleanupMerge(diffs)

assertEquivalent({{DIFF_EQUAL, 'xca'}, {DIFF_DELETE, 'cba'}}, diffs)

-- Empty merge.

diffs = {{DIFF_DELETE, 'b'}, {DIFF_INSERT, 'ab'}, {DIFF_EQUAL, 'c'}}

dmp.diff_cleanupMerge(diffs)

assertEquivalent({{DIFF_INSERT, 'a'}, {DIFF_EQUAL, 'bc'}}, diffs)

-- Empty equality.

diffs = {{DIFF_EQUAL, ''}, {DIFF_INSERT, 'a'}, {DIFF_EQUAL, 'b'}}

dmp.diff_cleanupMerge(diffs)

assertEquivalent({{DIFF_INSERT, 'a'}, {DIFF_EQUAL, 'b'}}, diffs)

-- Slide diffs to match logical boundaries.

-- Null case.

local diffs = {}

dmp.diff_cleanupSemanticLossless(diffs)

assertEquivalent({}, diffs)

-- Blank lines.

diffs = {{DIFF_EQUAL, 'AAA\r\n\r\nBBB'}, {DIFF_INSERT, '\r\nDDD\r\n\r\nBBB'},

{DIFF_EQUAL, '\r\nEEE'}}

dmp.diff_cleanupSemanticLossless(diffs)

assertEquivalent({{DIFF_EQUAL, 'AAA\r\n\r\n'},

{DIFF_INSERT, 'BBB\r\nDDD\r\n\r\n'}, {DIFF_EQUAL, 'BBB\r\nEEE'}}, diffs)

-- Line boundaries.

diffs = {{DIFF_EQUAL, 'AAA\r\nBBB'}, {DIFF_INSERT, ' DDD\r\nBBB'},

{DIFF_EQUAL, ' EEE'}}

dmp.diff_cleanupSemanticLossless(diffs)

assertEquivalent({{DIFF_EQUAL, 'AAA\r\n'}, {DIFF_INSERT, 'BBB DDD\r\n'},

{DIFF_EQUAL, 'BBB EEE'}}, diffs)

-- Word boundaries.

diffs = {{DIFF_EQUAL, 'The c'}, {DIFF_INSERT, 'ow and the c'},

{DIFF_EQUAL, 'at.'}}

dmp.diff_cleanupSemanticLossless(diffs)

assertEquivalent({{DIFF_EQUAL, 'The '}, {DIFF_INSERT, 'cow and the '},

{DIFF_EQUAL, 'cat.'}}, diffs)

-- Alphanumeric boundaries.

diffs = {{DIFF_EQUAL, 'The-c'}, {DIFF_INSERT, 'ow-and-the-c'},

{DIFF_EQUAL, 'at.'}}

dmp.diff_cleanupSemanticLossless(diffs)

assertEquivalent({{DIFF_EQUAL, 'The-'}, {DIFF_INSERT, 'cow-and-the-'},

{DIFF_EQUAL, 'cat.'}}, diffs)

-- Hitting the start.

diffs = {{DIFF_EQUAL, 'a'}, {DIFF_DELETE, 'a'}, {DIFF_EQUAL, 'ax'}}

dmp.diff_cleanupSemanticLossless(diffs)

assertEquivalent({{DIFF_DELETE, 'a'}, {DIFF_EQUAL, 'aax'}}, diffs)

-- Hitting the end.

diffs = {{DIFF_EQUAL, 'xa'}, {DIFF_DELETE, 'a'}, {DIFF_EQUAL, 'a'}}

dmp.diff_cleanupSemanticLossless(diffs)

assertEquivalent({{DIFF_EQUAL, 'xaa'}, {DIFF_DELETE, 'a'}}, diffs)

-- Sentence boundaries.

diffs = {{DIFF_EQUAL, 'The xxx. The '}, {DIFF_INSERT, 'zzz. The '},

{DIFF_EQUAL, 'yyy.'}}

dmp.diff_cleanupSemanticLossless(diffs)

assertEquivalent({{DIFF_EQUAL, 'The xxx.'}, {DIFF_INSERT, ' The zzz.'},

{DIFF_EQUAL, ' The yyy.'}}, diffs)

-- Cleanup semantically trivial equalities.

-- Null case.

local diffs = {}

dmp.diff_cleanupSemantic(diffs)

assertEquivalent({}, diffs)

-- No elimination #1.

diffs = {{DIFF_DELETE, 'ab'}, {DIFF_INSERT, 'cd'}, {DIFF_EQUAL, '12'},

{DIFF_DELETE, 'e'}}

dmp.diff_cleanupSemantic(diffs)

assertEquivalent({{DIFF_DELETE, 'ab'}, {DIFF_INSERT, 'cd'}, {DIFF_EQUAL, '12'},

{DIFF_DELETE, 'e'}}, diffs)

-- No elimination #2.

diffs = {{DIFF_DELETE, 'abc'}, {DIFF_INSERT, 'ABC'}, {DIFF_EQUAL, '1234'},

{DIFF_DELETE, 'wxyz'}}

dmp.diff_cleanupSemantic(diffs)

assertEquivalent({{DIFF_DELETE, 'abc'}, {DIFF_INSERT, 'ABC'}, {DIFF_EQUAL, '1234'},

{DIFF_DELETE, 'wxyz'}}, diffs)

-- Simple elimination.

diffs = {{DIFF_DELETE, 'a'}, {DIFF_EQUAL, 'b'}, {DIFF_DELETE, 'c'}}

dmp.diff_cleanupSemantic(diffs)

assertEquivalent({{DIFF_DELETE, 'abc'}, {DIFF_INSERT, 'b'}}, diffs)

-- Backpass elimination.

diffs = {{DIFF_DELETE, 'ab'}, {DIFF_EQUAL, 'cd'}, {DIFF_DELETE, 'e'},

{DIFF_EQUAL, 'f'}, {DIFF_INSERT, 'g'}}

dmp.diff_cleanupSemantic(diffs)

assertEquivalent({{DIFF_DELETE, 'abcdef'}, {DIFF_INSERT, 'cdfg'}}, diffs)

-- Multiple eliminations.

diffs = {{DIFF_INSERT, '1'}, {DIFF_EQUAL, 'A'}, {DIFF_DELETE, 'B'},

{DIFF_INSERT, '2'}, {DIFF_EQUAL, '_'}, {DIFF_INSERT, '1'},

{DIFF_EQUAL, 'A'}, {DIFF_DELETE, 'B'}, {DIFF_INSERT, '2'}}

dmp.diff_cleanupSemantic(diffs)

assertEquivalent({{DIFF_DELETE, 'AB_AB'}, {DIFF_INSERT, '1A2_1A2'}}, diffs)

-- Word boundaries.

diffs = {{DIFF_EQUAL, 'The c'}, {DIFF_DELETE, 'ow and the c'},

{DIFF_EQUAL, 'at.'}}

dmp.diff_cleanupSemantic(diffs)

assertEquivalent({{DIFF_EQUAL, 'The '}, {DIFF_DELETE, 'cow and the '},

{DIFF_EQUAL, 'cat.'}}, diffs)

-- No overlap elimination.

diffs = {{DIFF_DELETE, 'abcxx'}, {DIFF_INSERT, 'xxdef'}}

dmp.diff_cleanupSemantic(diffs)

assertEquivalent({{DIFF_DELETE, 'abcxx'}, {DIFF_INSERT, 'xxdef'}}, diffs)

-- Overlap elimination.

diffs = {{DIFF_DELETE, 'abcxxx'}, {DIFF_INSERT, 'xxxdef'}}

dmp.diff_cleanupSemantic(diffs)

assertEquivalent({{DIFF_DELETE, 'abc'}, {DIFF_EQUAL, 'xxx'}, {DIFF_INSERT, 'def'}}, diffs)

-- Reverse overlap elimination.

diffs = {{DIFF_DELETE, 'xxxabc'}, {DIFF_INSERT, 'defxxx'}}

dmp.diff_cleanupSemantic(diffs)

assertEquivalent({{DIFF_INSERT, 'def'}, {DIFF_EQUAL, 'xxx'}, {DIFF_DELETE, 'abc'}}, diffs)

-- Two overlap eliminations.

diffs = {{DIFF_DELETE, 'abcd1212'}, {DIFF_INSERT, '1212efghi'}, {DIFF_EQUAL, '----'}, {DIFF_DELETE, 'A3'}, {DIFF_INSERT, '3BC'}}

dmp.diff_cleanupSemantic(diffs)

assertEquivalent({{DIFF_DELETE, 'abcd'}, {DIFF_EQUAL, '1212'}, {DIFF_INSERT, 'efghi'}, {DIFF_EQUAL, '----'}, {DIFF_DELETE, 'A'}, {DIFF_EQUAL, '3'}, {DIFF_INSERT, 'BC'}}, diffs)

-- Cleanup operationally trivial equalities.

local diffs

dmp.settings{Diff_EditCost = 4}

-- Null case.

diffs = {}

dmp.diff_cleanupEfficiency(diffs)

assertEquivalent({}, diffs)

-- No elimination.

diffs = {{DIFF_DELETE, 'ab'}, {DIFF_INSERT, '12'}, {DIFF_EQUAL, 'wxyz'},

{DIFF_DELETE, 'cd'}, {DIFF_INSERT, '34'}}

dmp.diff_cleanupEfficiency(diffs)

assertEquivalent({{DIFF_DELETE, 'ab'}, {DIFF_INSERT, '12'},

{DIFF_EQUAL, 'wxyz'}, {DIFF_DELETE, 'cd'}, {DIFF_INSERT, '34'}}, diffs)

-- Four-edit elimination.

diffs = {{DIFF_DELETE, 'ab'}, {DIFF_INSERT, '12'}, {DIFF_EQUAL, 'xyz'},

{DIFF_DELETE, 'cd'}, {DIFF_INSERT, '34'}}

dmp.diff_cleanupEfficiency(diffs)

assertEquivalent({

{DIFF_DELETE, 'abxyzcd'},

{DIFF_INSERT, '12xyz34'}

}, diffs)

-- Three-edit elimination.

diffs = {

{DIFF_INSERT, '12'},

{DIFF_EQUAL, 'x'},

{DIFF_DELETE, 'cd'},

{DIFF_INSERT, '34'}

}

dmp.diff_cleanupEfficiency(diffs)

assertEquivalent({

{DIFF_DELETE, 'xcd'},

{DIFF_INSERT, '12x34'}

}, diffs)

-- Backpass elimination.

diffs = {

{DIFF_DELETE, 'ab'},

{DIFF_INSERT, '12'},

{DIFF_EQUAL, 'xy'},

{DIFF_INSERT, '34'},

{DIFF_EQUAL, 'z'},

{DIFF_DELETE, 'cd'},

{DIFF_INSERT, '56'}

}

dmp.diff_cleanupEfficiency(diffs)

assertEquivalent({

{DIFF_DELETE, 'abxyzcd'},

{DIFF_INSERT, '12xy34z56'}

}, diffs)

-- High cost elimination.

dmp.settings{Diff_EditCost = 5}

diffs = {

{DIFF_DELETE, 'ab'},

{DIFF_INSERT, '12'},

{DIFF_EQUAL, 'wxyz'},

{DIFF_DELETE, 'cd'},

{DIFF_INSERT, '34'}

}

dmp.diff_cleanupEfficiency(diffs)

assertEquivalent({

{DIFF_DELETE, 'abwxyzcd'},

{DIFF_INSERT, '12wxyz34'}

}, diffs)

dmp.settings{Diff_EditCost = 4}

-- Pretty print.

local diffs = {

{DIFF_EQUAL, 'a\n'},

{DIFF_DELETE, '<B>b</B>'},

{DIFF_INSERT, 'c&d'}

}

assertEquals(

'<span>a&para;<br></span>'

.. '<del style="background:#ffe6e6;">&lt;B&gt;b&lt;/B&gt;'

.. '</del><ins style="background:#e6ffe6;">c&amp;d</ins>',

dmp.diff_prettyHtml(diffs)

)

-- Compute the source and destination texts.

local diffs = {

{DIFF_EQUAL, 'jump'},

{DIFF_DELETE, 's'},

{DIFF_INSERT, 'ed'},

{DIFF_EQUAL, ' over '},

{DIFF_DELETE, 'the'},

{DIFF_INSERT, 'a'},

{DIFF_EQUAL, ' lazy'}

}

assertEquals('jumps over the lazy', dmp.diff_text1(diffs))

assertEquals('jumped over a lazy', dmp.diff_text2(diffs))

-- Convert a diff into delta string.

local diffs = {

{DIFF_EQUAL, 'jump'},

{DIFF_DELETE, 's'},

{DIFF_INSERT, 'ed'},

{DIFF_EQUAL, ' over '},

{DIFF_DELETE, 'the'},

{DIFF_INSERT, 'a'},

{DIFF_EQUAL, ' lazy'},

{DIFF_INSERT, 'old dog'}

}

local text1 = dmp.diff_text1(diffs)

assertEquals('jumps over the lazy', text1)

local delta = dmp.diff_toDelta(diffs)

assertEquals('=4\t-1\t+ed\t=6\t-3\t+a\t=5\t+old dog', delta)

-- Convert delta string into a diff.

assertEquivalent(diffs, dmp.diff_fromDelta(text1, delta))

-- Generates error (19 ~= 20).

success, result = pcall(dmp.diff_fromDelta, text1 .. 'x', delta)

assertEquals(false, success)

-- Generates error (19 ~= 18).

success, result = pcall(dmp.diff_fromDelta, string.sub(text1, 2), delta)

assertEquals(false, success)

-- Generates error (%c3%xy invalid Unicode).

success, result = pcall(dmp.patch_fromDelta, '', '+%c3%xy')

assertEquals(false, success)

--[[

-- Convert delta string into a diff.

assertEquivalent(diffs, dmp.diff_fromDelta(text1, delta))

-- Verify pool of unchanged characters.

diffs = {

{DIFF_INSERT, 'A-Z a-z 0-9 - _ . ! ~ * \' ( ) ; / ? = @ & = + $ , # '}

}

local text2 = dmp.diff_text2(diffs)

assertEquals(

'A-Z a-z 0-9 - _ . ! ~ * \' ( ) ; / ? = @ & = + $ , # ',

text2

)

delta = dmp.diff_toDelta(diffs)

assertEquals(

'+A-Z a-z 0-9 - _ . ! ~ * \' ( ) ; / ? = @ & = + $ , # ',

delta

)

-- Convert delta string into a diff.

assertEquivalent(diffs, dmp.diff_fromDelta('', delta))

-- 160 kb string.

local a = string.rep('abcdefghij', 16384)

diffs = {{DIFF_INSERT, a}};

delta = dmp.diff_toDelta(diffs);

assertEquals('+' .. a, delta);

-- Convert delta string into a diff.

assertEquivalent(diffs, dmp.diff_fromDelta('', delta));

-- Translate a location in text1 to text2.

-- Translation on equality.

assertEquals(6, dmp.diff_xIndex({

{DIFF_DELETE, 'a'},

{DIFF_INSERT, '1234'},

{DIFF_EQUAL, 'xyz'}

}, 3))

-- Translation on deletion.

assertEquals(2, dmp.diff_xIndex({

{DIFF_EQUAL, 'a'},

{DIFF_DELETE, '1234'},

{DIFF_EQUAL, 'xyz'}

}, 4))

-- Levenshtein with trailing equality.

assertEquals(4, dmp.diff_levenshtein({

{DIFF_DELETE, 'abc'},

{DIFF_INSERT, '1234'},

{DIFF_EQUAL, 'xyz'}

}))

-- Levenshtein with leading equality.

assertEquals(4, dmp.diff_levenshtein({

{DIFF_EQUAL, 'xyz'},

{DIFF_DELETE, 'abc'},

{DIFF_INSERT, '1234'}

}))

-- Levenshtein with middle equality.

assertEquals(7, dmp.diff_levenshtein({

{DIFF_DELETE, 'abc'},

{DIFF_EQUAL, 'xyz'},

{DIFF_INSERT, '1234'}

}))

-- Normal.

local a = 'cat'

local b = 'map'

-- Since the resulting diff hasn't been normalized, it would be ok if

-- the insertion and deletion pairs are swapped.

-- If the order changes, tweak this test as required.

assertEquivalent({

{DIFF_DELETE, 'c'},

{DIFF_INSERT, 'm'},

{DIFF_EQUAL, 'a'},

{DIFF_DELETE, 't'},

{DIFF_INSERT, 'p'}

}, dmp.diff_bisect(a, b, 2 ^ 31))

-- Timeout.

assertEquivalent({

{DIFF_DELETE, 'cat'},

{DIFF_INSERT, 'map'}

}, dmp.diff_bisect(a, b, 0))

-- Perform a trivial diff.

local a,b

-- Null case.

assertEquivalent({}, dmp.diff_main('', '', false))

-- Equality.

assertEquivalent({

{DIFF_EQUAL, 'abc'}

}, dmp.diff_main('abc', 'abc', false))

-- Simple insertion.

assertEquivalent({

{DIFF_EQUAL, 'ab'},

{DIFF_INSERT, '123'},

{DIFF_EQUAL, 'c'}

}, dmp.diff_main('abc', 'ab123c', false))

-- Simple deletion.

assertEquivalent({

{DIFF_EQUAL, 'a'},

{DIFF_DELETE, '123'},

{DIFF_EQUAL, 'bc'}

}, dmp.diff_main('a123bc', 'abc', false))

-- Two insertions.

assertEquivalent({

{DIFF_EQUAL, 'a'},

{DIFF_INSERT, '123'},

{DIFF_EQUAL, 'b'},

{DIFF_INSERT, '456'},

{DIFF_EQUAL, 'c'}

}, dmp.diff_main('abc', 'a123b456c', false))

-- Two deletions.

assertEquivalent({

{DIFF_EQUAL, 'a'},

{DIFF_DELETE, '123'},

{DIFF_EQUAL, 'b'},

{DIFF_DELETE, '456'},

{DIFF_EQUAL, 'c'}

}, dmp.diff_main('a123b456c', 'abc', false))

-- Perform a real diff.

-- Switch off the timeout.

dmp.settings{ Diff_Timeout=0 }

-- Simple cases.

assertEquivalent({

{DIFF_DELETE, 'a'},

{DIFF_INSERT, 'b'}

}, dmp.diff_main('a', 'b', false))

assertEquivalent({

{DIFF_DELETE, 'Apple'},

{DIFF_INSERT, 'Banana'},

{DIFF_EQUAL, 's are a'},

{DIFF_INSERT, 'lso'},

{DIFF_EQUAL, ' fruit.'}

}, dmp.diff_main('Apples are a fruit.', 'Bananas are also fruit.', false))

--[[

-- Overlaps.

assertEquivalent({

{DIFF_DELETE, '1'},

{DIFF_EQUAL, 'a'},

{DIFF_DELETE, 'y'},

{DIFF_EQUAL, 'b'},

{DIFF_DELETE, '2'},

{DIFF_INSERT, 'xab'}

}, dmp.diff_main('1ayb2', 'abxab', false))

assertEquivalent({

{DIFF_INSERT, 'xaxcx'},

{DIFF_EQUAL, 'abc'},

{DIFF_DELETE, 'y'}

}, dmp.diff_main('abcy', 'xaxcxabc', false))

assertEquivalent({

{DIFF_DELETE, 'ABCD'},

{DIFF_EQUAL, 'a'},

{DIFF_DELETE, '='},

{DIFF_INSERT, '-'},

{DIFF_EQUAL, 'bcd'},

{DIFF_DELETE, '='},

{DIFF_INSERT, '-'},

{DIFF_EQUAL, 'efghijklmnopqrs'},

{DIFF_DELETE, 'EFGHIJKLMNOefg'}

}, dmp.diff_main('ABCDa=bcd=efghijklmnopqrsEFGHIJKLMNOefg',

'a-bcd-efghijklmnopqrs', false))

-- Large equality.

assertEquivalent({

{DIFF_INSERT, ' '},

{DIFF_EQUAL, 'a'},

{DIFF_INSERT, 'nd'},

{DIFF_EQUAL, ' [[Pennsylvania]]'},

{DIFF_DELETE, ' and [[New'}

}, dmp.diff_main('a [[Pennsylvania]] and [[New',

' and [[Pennsylvania]]', false))

-- Timeout.

dmp.settings{Diff_Timeout = 0.1} -- 100ms

-- Increase the text lengths by 1024 times to ensure a timeout.

a = string.rep([[

]], 1024)

b = string.rep([[

]], 1024)

local startTime = os.clock()

dmp.diff_main(a, b)

local endTime = os.clock()

-- Test that we took at least the timeout period.

assertTrue(0.1 <= endTime - startTime)

-- Test that we didn't take forever (be forgiving).

-- Theoretically this test could fail very occasionally if the

-- OS task swaps or locks up for a second at the wrong moment.

assertTrue(0.1 * 2 > endTime - startTime)

dmp.settings{Diff_Timeout = 0}

-- Test the linemode speedup.

-- Must be long to pass the 100 char cutoff.

-- Simple line-mode.

a = string.rep('1234567890\n', 13)

b = string.rep('abcdefghij\n', 13)

assertEquivalent(dmp.diff_main(a, b, false), dmp.diff_main(a, b, true))

-- Single line-mode.

a = string.rep('1234567890', 13)

b = string.rep('abcdefghij', 13)

assertEquivalent(dmp.diff_main(a, b, false), dmp.diff_main(a, b, true))

-- Overlap line-mode.

a = string.rep('1234567890\n', 13)

b = [[

local texts_linemode = diff_rebuildtexts(dmp.diff_main(a, b, true))

local texts_textmode = diff_rebuildtexts(dmp.diff_main(a, b, false))

assertEquivalent(texts_textmode, texts_linemode)

-- Test null inputs.

success, result = pcall(dmp.diff_main, nil, nil)

assertEquals(false, success)

-- Initialise the bitmasks for Bitap.

-- Unique.

assertEquivalent({a=4, b=2, c=1}, dmp.match_alphabet('abc'))

-- Duplicates.

assertEquivalent({a=37, b=18, c=8}, dmp.match_alphabet('abcaba'))

-- Bitap algorithm.

dmp.settings{Match_Distance=100, Match_Threshold=0.5}

-- Exact matches.

assertEquals(6, dmp.match_bitap('abcdefghijk', 'fgh', 6))

assertEquals(6, dmp.match_bitap('abcdefghijk', 'fgh', 1))

-- Fuzzy matches.

assertEquals(5, dmp.match_bitap('abcdefghijk', 'efxhi', 1))

assertEquals(3, dmp.match_bitap('abcdefghijk', 'cdefxyhijk', 6))

assertEquals(-1, dmp.match_bitap('abcdefghijk', 'bxy', 2))

-- Overflow.

assertEquals(3, dmp.match_bitap('123456789xx0', '3456789x0', 3))

-- Threshold test.

dmp.settings{Match_Threshold = 0.4}

assertEquals(5, dmp.match_bitap('abcdefghijk', 'efxyhi', 2))

dmp.settings{Match_Threshold = 0.3}

assertEquals(-1, dmp.match_bitap('abcdefghijk', 'efxyhi', 2))

dmp.settings{Match_Threshold = 0.0}

assertEquals(2, dmp.match_bitap('abcdefghijk', 'bcdef', 2))

dmp.settings{Match_Threshold = 0.5}

-- Multiple select.

assertEquals(1, dmp.match_bitap('abcdexyzabcde', 'abccde', 4))

assertEquals(9, dmp.match_bitap('abcdexyzabcde', 'abccde', 6))

-- Distance test.

dmp.settings{Match_Distance = 10} -- Strict location.

assertEquals(-1,

dmp.match_bitap('abcdefghijklmnopqrstuvwxyz', 'abcdefg', 25))

assertEquals(1,

dmp.match_bitap('abcdefghijklmnopqrstuvwxyz', 'abcdxxefg', 2))

dmp.settings{Match_Distance = 1000} -- Loose location.

assertEquals(1,

dmp.match_bitap('abcdefghijklmnopqrstuvwxyz', 'abcdefg', 25))

-- Full match.

-- Shortcut matches.

assertEquals(1, dmp.match_main('abcdef', 'abcdef', 1000))

assertEquals(-1, dmp.match_main('', 'abcdef', 2))

assertEquals(4, dmp.match_main('abcdef', '', 4))

assertEquals(4, dmp.match_main('abcdef', 'de', 4))

-- Beyond end match.

assertEquals(4, dmp.match_main("abcdef", "defy", 5))

-- Oversized pattern.

assertEquals(1, dmp.match_main("abcdef", "abcdefy", 1))

-- Complex match.

assertEquals(5, dmp.match_main(

'I am the very model of a modern major general.',

' that berry ',

6

))

-- Test null inputs.

success, result = pcall(dmp.match_main, nil, nil, 0)

assertEquals(false, success)

-- Patch Object.

local p = dmp.new_patch_obj()

p.start1 = 21

p.start2 = 22

p.length1 = 18

p.length2 = 17

p.diffs = {

{DIFF_EQUAL, 'jump'},

{DIFF_DELETE, 's'},

{DIFF_INSERT, 'ed'},

{DIFF_EQUAL, ' over '},

{DIFF_DELETE, 'the'},

{DIFF_INSERT, 'a'},

{DIFF_EQUAL, '\nlaz'}

}

local strp = tostring(p)

assertEquals(

'@@ -21,18 +22,17 @@\n jump\n-s\n+ed\n over \n-the\n+a\n %0Alaz\n',

strp

)

local strp

strp = ''

assertEquivalent({}, dmp.patch_fromText(strp))

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

assertEquals(strp, tostring(dmp.patch_fromText(strp)[1]))

assertEquals(

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

tostring(dmp.patch_fromText('@@ -1 +1 @@\n-a\n+b\n')[1])

)

assertEquals(

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

tostring(dmp.patch_fromText('@@ -1,3 +0,0 @@\n-abc\n')[1])

)

assertEquals(

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

tostring(dmp.patch_fromText('@@ -0,0 +1,3 @@\n+abc\n')[1])

)

-- Generates error.

success, result = pcall(dmp.patch_fromText, 'Bad\nPatch\n')

assertEquals(false, success)

local strp, p

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

p = dmp.patch_fromText(strp)