diff --git a/.gitignore b/.gitignore
index 41779de8..65503677 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,3 +9,4 @@ xcuserdata
dart/tests/Speedtest.dart.js.deps
dart/tests/Speedtest.dart.js.map
+.vscode/launch.json
diff --git a/dart/DMPClass.dart b/dart/DMPClass.dart
index 7be14226..01c2dad8 100644
--- a/dart/DMPClass.dart
+++ b/dart/DMPClass.dart
@@ -91,8 +91,7 @@ class DiffMatchPatch {
* internally for recursive calls. Users should set DiffTimeout instead.
* Returns a List of Diff objects.
*/
- List<Diff> diff_main(String text1, String text2,
- [bool checklines = true, DateTime deadline]) {
+ List<Diff> diff_main(String? text1, String? text2, [bool checklines = true, DateTime? deadline]) {
// Set a deadline by which time the diff must be complete.
if (deadline == null) {
deadline = new DateTime.now();
@@ -100,8 +99,7 @@ class DiffMatchPatch {
// One year should be sufficient for 'infinity'.
deadline = deadline.add(new Duration(days: 365));
} else {
- deadline = deadline
- .add(new Duration(milliseconds: (Diff_Timeout * 1000).toInt()));
+ deadline = deadline.add(new Duration(milliseconds: (Diff_Timeout * 1000).toInt()));
}
}
// Check for null inputs.
@@ -157,8 +155,7 @@ class DiffMatchPatch {
* [deadline] is the time when the diff should be complete by.
* Returns a List of Diff objects.
*/
- List<Diff> _diff_compute(
- String text1, String text2, bool checklines, DateTime deadline) {
+ List<Diff> _diff_compute(String text1, String text2, bool checklines, DateTime deadline) {
List<Diff> diffs = <Diff>[];
if (text1.length == 0) {
@@ -178,8 +175,7 @@ class DiffMatchPatch {
int i = longtext.indexOf(shorttext);
if (i != -1) {
// Shorter text is inside the longer text (speedup).
- Operation op =
- (text1.length > text2.length) ? Operation.delete : Operation.insert;
+ Operation op = (text1.length > text2.length) ? Operation.delete : Operation.insert;
diffs.add(new Diff(op, longtext.substring(0, i)));
diffs.add(new Diff(Operation.equal, shorttext));
diffs.add(new Diff(op, longtext.substring(i + shorttext.length)));
@@ -267,8 +263,7 @@ class DiffMatchPatch {
// Delete the offending records and add the merged ones.
diffs.removeRange(pointer - count_delete - count_insert, pointer);
pointer = pointer - count_delete - count_insert;
- final subDiff = diff_main(text_delete.toString(),
- text_insert.toString(), false, deadline);
+ final subDiff = diff_main(text_delete.toString(), text_insert.toString(), false, deadline);
for (int j = subDiff.length - 1; j >= 0; j--) {
diffs.insert(pointer, subDiff[j]);
}
@@ -303,12 +298,8 @@ class DiffMatchPatch {
final max_d = (text1_length + text2_length + 1) ~/ 2;
final v_offset = max_d;
final v_length = 2 * max_d;
- final v1 = new List<int>(v_length);
- final v2 = new List<int>(v_length);
- for (int x = 0; x < v_length; x++) {
- v1[x] = -1;
- v2[x] = -1;
- }
+ final v1 = new List<int>.filled(v_length, -1);
+ final v2 = new List<int>.filled(v_length, -1);
v1[v_offset + 1] = 0;
v2[v_offset + 1] = 0;
final delta = text1_length - text2_length;
@@ -337,8 +328,7 @@ class DiffMatchPatch {
x1 = v1[k1_offset - 1] + 1;
}
int y1 = x1 - k1;
- while (
- x1 < text1_length && y1 < text2_length && text1[x1] == text2[y1]) {
+ while (x1 < text1_length && y1 < text2_length && text1[x1] == text2[y1]) {
x1++;
y1++;
}
@@ -372,9 +362,7 @@ class DiffMatchPatch {
x2 = v2[k2_offset - 1] + 1;
}
int y2 = x2 - k2;
- while (x2 < text1_length &&
- y2 < text2_length &&
- text1[text1_length - x2 - 1] == text2[text2_length - y2 - 1]) {
+ while (x2 < text1_length && y2 < text2_length && text1[text1_length - x2 - 1] == text2[text2_length - y2 - 1]) {
x2++;
y2++;
}
@@ -402,10 +390,7 @@ class DiffMatchPatch {
}
// Diff took too long and hit the deadline or
// number of diffs equals number of characters, no commonality at all.
- return [
- new Diff(Operation.delete, text1),
- new Diff(Operation.insert, text2)
- ];
+ return [new Diff(Operation.delete, text1), new Diff(Operation.insert, text2)];
}
/**
@@ -425,8 +410,7 @@ class DiffMatchPatch {
* [deadline] is the time at which to bail if not yet complete.
* Returns a List of Diff objects.
*/
- List<Diff> _diff_bisectSplit(
- String text1, String text2, int x, int y, DateTime deadline) {
+ List<Diff> _diff_bisectSplit(String text1, String text2, int x, int y, DateTime deadline) {
final text1a = text1.substring(0, x);
final text2a = text2.substring(0, y);
final text1b = text1.substring(x);
@@ -481,8 +465,7 @@ class DiffMatchPatch {
* [maxLines] is the maximum length for lineArray.
* Returns an encoded string.
*/
- String _diff_linesToCharsMunge(String text, List<String> lineArray,
- Map<String, int> lineHash, int maxLines) {
+ String _diff_linesToCharsMunge(String text, List<String> lineArray, Map<String, int> lineHash, int maxLines) {
int lineStart = 0;
int lineEnd = -1;
String line;
@@ -498,7 +481,7 @@ class DiffMatchPatch {
line = text.substring(lineStart, lineEnd + 1);
if (lineHash.containsKey(line)) {
- chars.writeCharCode(lineHash[line]);
+ chars.writeCharCode(lineHash[line]!);
} else {
if (lineArray.length == maxLines) {
// Bail out at 65535 because
@@ -538,7 +521,7 @@ class DiffMatchPatch {
* Hack to allow unit tests to call private method. Do not use.
*/
void test_diff_charsToLines(List<Diff> diffs, List<String> lineArray) {
- _diff_charsToLines(diffs, lineArray);
+ _diff_charsToLines(diffs, lineArray);
}
/**
@@ -620,8 +603,7 @@ class DiffMatchPatch {
return best;
}
length += found;
- if (found == 0 ||
- text1.substring(text_length - length) == text2.substring(0, length)) {
+ if (found == 0 || text1.substring(text_length - length) == text2.substring(0, length)) {
best = length;
length++;
}
@@ -645,7 +627,7 @@ class DiffMatchPatch {
* the suffix of text1, the prefix of text2, the suffix of text2 and the
* common middle. Or null if there was no match.
*/
- List<String> _diff_halfMatch(String text1, String text2) {
+ List<String>? _diff_halfMatch(String text1, String text2) {
if (Diff_Timeout <= 0) {
// Don't risk returning a non-optimal diff if we have unlimited time.
return null;
@@ -657,16 +639,14 @@ class DiffMatchPatch {
}
// First check if the second quarter is the seed for a half-match.
- final hm1 = _diff_halfMatchI(
- longtext, shorttext, ((longtext.length + 3) / 4).ceil().toInt());
+ final hm1 = _diff_halfMatchI(longtext, shorttext, ((longtext.length + 3) / 4).ceil().toInt());
// Check again based on the third quarter.
- final hm2 = _diff_halfMatchI(
- longtext, shorttext, ((longtext.length + 1) / 2).ceil().toInt());
+ final hm2 = _diff_halfMatchI(longtext, shorttext, ((longtext.length + 1) / 2).ceil().toInt());
List<String> hm;
if (hm1 == null && hm2 == null) {
return null;
} else if (hm2 == null) {
- hm = hm1;
+ hm = hm1!;
} else if (hm1 == null) {
hm = hm2;
} else {
@@ -686,7 +666,7 @@ class DiffMatchPatch {
/**
* Hack to allow unit tests to call private method. Do not use.
*/
- List<String> test_diff_halfMatch(String text1, String text2) {
+ List<String>? test_diff_halfMatch(String text1, String text2) {
return _diff_halfMatch(text1, text2);
}
@@ -700,22 +680,18 @@ class DiffMatchPatch {
* the suffix of longtext, the prefix of shorttext, the suffix of
* shorttext and the common middle. Or null if there was no match.
*/
- List<String> _diff_halfMatchI(String longtext, String shorttext, int i) {
+ List<String>? _diff_halfMatchI(String longtext, String shorttext, int i) {
// Start with a 1/4 length substring at position i as a seed.
- final seed =
- longtext.substring(i, i + (longtext.length / 4).floor().toInt());
+ final seed = longtext.substring(i, i + (longtext.length / 4).floor().toInt());
int j = -1;
String best_common = '';
String best_longtext_a = '', best_longtext_b = '';
String best_shorttext_a = '', best_shorttext_b = '';
while ((j = shorttext.indexOf(seed, j + 1)) != -1) {
- int prefixLength =
- diff_commonPrefix(longtext.substring(i), shorttext.substring(j));
- int suffixLength = diff_commonSuffix(
- longtext.substring(0, i), shorttext.substring(0, j));
+ int prefixLength = diff_commonPrefix(longtext.substring(i), shorttext.substring(j));
+ int suffixLength = diff_commonSuffix(longtext.substring(0, i), shorttext.substring(0, j));
if (best_common.length < suffixLength + prefixLength) {
- best_common = shorttext.substring(j - suffixLength, j) +
- shorttext.substring(j, j + prefixLength);
+ best_common = shorttext.substring(j - suffixLength, j) + shorttext.substring(j, j + prefixLength);
best_longtext_a = longtext.substring(0, i - suffixLength);
best_longtext_b = longtext.substring(i + prefixLength);
best_shorttext_a = shorttext.substring(0, j - suffixLength);
@@ -723,13 +699,7 @@ class DiffMatchPatch {
}
}
if (best_common.length * 2 >= longtext.length) {
- return [
- best_longtext_a,
- best_longtext_b,
- best_shorttext_a,
- best_shorttext_b,
- best_common
- ];
+ return [best_longtext_a, best_longtext_b, best_shorttext_a, best_shorttext_b, best_common];
} else {
return null;
}
@@ -744,7 +714,7 @@ class DiffMatchPatch {
// Stack of indices where equalities are found.
final equalities = <int>[];
// Always equal to diffs[equalities.last()].text
- String lastEquality = null;
+ String? lastEquality;
int pointer = 0; // Index of current position.
// Number of characters that changed prior to the equality.
int length_insertions1 = 0;
@@ -771,13 +741,10 @@ class DiffMatchPatch {
// Eliminate an equality that is smaller or equal to the edits on both
// sides of it.
if (lastEquality != null &&
- (lastEquality.length <=
- max(length_insertions1, length_deletions1)) &&
- (lastEquality.length <=
- max(length_insertions2, length_deletions2))) {
+ (lastEquality.length <= max(length_insertions1, length_deletions1)) &&
+ (lastEquality.length <= max(length_insertions2, length_deletions2))) {
// Duplicate record.
- diffs.insert(
- equalities.last, new Diff(Operation.delete, lastEquality));
+ diffs.insert(equalities.last, new Diff(Operation.delete, lastEquality));
// Change second copy to insert.
diffs[equalities.last + 1].operation = Operation.insert;
// Throw away the equality we just deleted.
@@ -812,39 +779,27 @@ class DiffMatchPatch {
// Only extract an overlap if it is as big as the edit ahead or behind it.
pointer = 1;
while (pointer < diffs.length) {
- if (diffs[pointer - 1].operation == Operation.delete &&
- diffs[pointer].operation == Operation.insert) {
+ if (diffs[pointer - 1].operation == Operation.delete && diffs[pointer].operation == Operation.insert) {
String deletion = diffs[pointer - 1].text;
String insertion = diffs[pointer].text;
int overlap_length1 = _diff_commonOverlap(deletion, insertion);
int overlap_length2 = _diff_commonOverlap(insertion, deletion);
if (overlap_length1 >= overlap_length2) {
- if (overlap_length1 >= deletion.length / 2 ||
- overlap_length1 >= insertion.length / 2) {
+ if (overlap_length1 >= deletion.length / 2 || overlap_length1 >= insertion.length / 2) {
// Overlap found.
// Insert an equality and trim the surrounding edits.
- diffs.insert(
- pointer,
- new Diff(
- Operation.equal, insertion.substring(0, overlap_length1)));
- diffs[pointer - 1].text =
- deletion.substring(0, deletion.length - overlap_length1);
+ diffs.insert(pointer, new Diff(Operation.equal, insertion.substring(0, overlap_length1)));
+ diffs[pointer - 1].text = deletion.substring(0, deletion.length - overlap_length1);
diffs[pointer + 1].text = insertion.substring(overlap_length1);
pointer++;
}
} else {
- if (overlap_length2 >= deletion.length / 2 ||
- overlap_length2 >= insertion.length / 2) {
+ if (overlap_length2 >= deletion.length / 2 || overlap_length2 >= insertion.length / 2) {
// Reverse overlap found.
// Insert an equality and swap and trim the surrounding edits.
- diffs.insert(
- pointer,
- new Diff(
- Operation.equal, deletion.substring(0, overlap_length2)));
- diffs[pointer - 1] = new Diff(Operation.insert,
- insertion.substring(0, insertion.length - overlap_length2));
- diffs[pointer + 1] =
- new Diff(Operation.delete, deletion.substring(overlap_length2));
+ diffs.insert(pointer, new Diff(Operation.equal, deletion.substring(0, overlap_length2)));
+ diffs[pointer - 1] = new Diff(Operation.insert, insertion.substring(0, insertion.length - overlap_length2));
+ diffs[pointer + 1] = new Diff(Operation.delete, deletion.substring(overlap_length2));
pointer++;
}
}
@@ -914,8 +869,7 @@ class DiffMatchPatch {
int pointer = 1;
// Intentionally ignore the first and last element (don't need checking).
while (pointer < diffs.length - 1) {
- if (diffs[pointer - 1].operation == Operation.equal &&
- diffs[pointer + 1].operation == Operation.equal) {
+ if (diffs[pointer - 1].operation == Operation.equal && diffs[pointer + 1].operation == Operation.equal) {
// This is a single edit surrounded by equalities.
String equality1 = diffs[pointer - 1].text;
String edit = diffs[pointer].text;
@@ -934,14 +888,12 @@ class DiffMatchPatch {
String bestEquality1 = equality1;
String bestEdit = edit;
String bestEquality2 = equality2;
- int bestScore = _diff_cleanupSemanticScore(equality1, edit) +
- _diff_cleanupSemanticScore(edit, equality2);
+ int bestScore = _diff_cleanupSemanticScore(equality1, edit) + _diff_cleanupSemanticScore(edit, equality2);
while (!edit.isEmpty && !equality2.isEmpty && edit[0] == equality2[0]) {
equality1 = equality1 + edit[0];
edit = edit.substring(1) + equality2[0];
equality2 = equality2.substring(1);
- int score = _diff_cleanupSemanticScore(equality1, edit) +
- _diff_cleanupSemanticScore(edit, equality2);
+ int score = _diff_cleanupSemanticScore(equality1, edit) + _diff_cleanupSemanticScore(edit, equality2);
// The >= encourages trailing rather than leading whitespace on edits.
if (score >= bestScore) {
bestScore = score;
@@ -995,7 +947,7 @@ class DiffMatchPatch {
// Stack of indices where equalities are found.
final equalities = <int>[];
// Always equal to diffs[equalities.last()].text
- String lastEquality = null;
+ String? lastEquality;
int pointer = 0; // Index of current position.
// Is there an insertion operation before the last equality.
bool pre_ins = false;
@@ -1008,8 +960,7 @@ class DiffMatchPatch {
while (pointer < diffs.length) {
if (diffs[pointer].operation == Operation.equal) {
// Equality found.
- if (diffs[pointer].text.length < Diff_EditCost &&
- (post_ins || post_del)) {
+ if (diffs[pointer].text.length < Diff_EditCost && (post_ins || post_del)) {
// Candidate found.
equalities.add(pointer);
pre_ins = post_ins;
@@ -1039,14 +990,9 @@ class DiffMatchPatch {
if (lastEquality != null &&
((pre_ins && pre_del && post_ins && post_del) ||
((lastEquality.length < Diff_EditCost / 2) &&
- ((pre_ins ? 1 : 0) +
- (pre_del ? 1 : 0) +
- (post_ins ? 1 : 0) +
- (post_del ? 1 : 0)) ==
- 3))) {
+ ((pre_ins ? 1 : 0) + (pre_del ? 1 : 0) + (post_ins ? 1 : 0) + (post_del ? 1 : 0)) == 3))) {
// Duplicate record.
- diffs.insert(
- equalities.last, new Diff(Operation.delete, lastEquality));
+ diffs.insert(equalities.last, new Diff(Operation.delete, lastEquality));
// Change second copy to insert.
diffs[equalities.last + 1].operation = Operation.insert;
equalities.removeLast(); // Throw away the equality we just deleted.
@@ -1106,17 +1052,11 @@ class DiffMatchPatch {
commonlength = diff_commonPrefix(text_insert, text_delete);
if (commonlength != 0) {
if ((pointer - count_delete - count_insert) > 0 &&
- diffs[pointer - count_delete - count_insert - 1]
- .operation ==
- Operation.equal) {
+ diffs[pointer - count_delete - count_insert - 1].operation == Operation.equal) {
final i = pointer - count_delete - count_insert - 1;
- diffs[i].text =
- diffs[i].text + text_insert.substring(0, commonlength);
+ diffs[i].text = diffs[i].text + text_insert.substring(0, commonlength);
} else {
- diffs.insert(
- 0,
- new Diff(Operation.equal,
- text_insert.substring(0, commonlength)));
+ diffs.insert(0, new Diff(Operation.equal, text_insert.substring(0, commonlength)));
pointer++;
}
text_insert = text_insert.substring(commonlength);
@@ -1126,13 +1066,9 @@ class DiffMatchPatch {
// Factor out any common suffixies.
commonlength = diff_commonSuffix(text_insert, text_delete);
if (commonlength != 0) {
- diffs[pointer].text =
- text_insert.substring(text_insert.length - commonlength) +
- diffs[pointer].text;
- text_insert =
- text_insert.substring(0, text_insert.length - commonlength);
- text_delete =
- text_delete.substring(0, text_delete.length - commonlength);
+ diffs[pointer].text = text_insert.substring(text_insert.length - commonlength) + diffs[pointer].text;
+ text_insert = text_insert.substring(0, text_insert.length - commonlength);
+ text_delete = text_delete.substring(0, text_delete.length - commonlength);
}
}
// Delete the offending records and add the merged ones.
@@ -1147,11 +1083,9 @@ class DiffMatchPatch {
pointer++;
}
pointer++;
- } else if (pointer != 0 &&
- diffs[pointer - 1].operation == Operation.equal) {
+ } else if (pointer != 0 && diffs[pointer - 1].operation == Operation.equal) {
// Merge this equality with the previous one.
- diffs[pointer - 1].text =
- diffs[pointer - 1].text + diffs[pointer].text;
+ diffs[pointer - 1].text = diffs[pointer - 1].text + diffs[pointer].text;
diffs.removeAt(pointer);
} else {
pointer++;
@@ -1174,25 +1108,19 @@ class DiffMatchPatch {
pointer = 1;
// Intentionally ignore the first and last element (don't need checking).
while (pointer < diffs.length - 1) {
- if (diffs[pointer - 1].operation == Operation.equal &&
- diffs[pointer + 1].operation == Operation.equal) {
+ if (diffs[pointer - 1].operation == Operation.equal && diffs[pointer + 1].operation == Operation.equal) {
// This is a single edit surrounded by equalities.
if (diffs[pointer].text.endsWith(diffs[pointer - 1].text)) {
// Shift the edit over the previous equality.
diffs[pointer].text = diffs[pointer - 1].text +
- diffs[pointer].text.substring(0,
- diffs[pointer].text.length - diffs[pointer - 1].text.length);
- diffs[pointer + 1].text =
- diffs[pointer - 1].text + diffs[pointer + 1].text;
+ diffs[pointer].text.substring(0, diffs[pointer].text.length - diffs[pointer - 1].text.length);
+ diffs[pointer + 1].text = diffs[pointer - 1].text + diffs[pointer + 1].text;
diffs.removeAt(pointer - 1);
changes = true;
} else if (diffs[pointer].text.startsWith(diffs[pointer + 1].text)) {
// Shift the edit over the next equality.
- diffs[pointer - 1].text =
- diffs[pointer - 1].text + diffs[pointer + 1].text;
- diffs[pointer].text =
- diffs[pointer].text.substring(diffs[pointer + 1].text.length) +
- diffs[pointer + 1].text;
+ diffs[pointer - 1].text = diffs[pointer - 1].text + diffs[pointer + 1].text;
+ diffs[pointer].text = diffs[pointer].text.substring(diffs[pointer + 1].text.length) + diffs[pointer + 1].text;
diffs.removeAt(pointer + 1);
changes = true;
}
@@ -1218,7 +1146,7 @@ class DiffMatchPatch {
int chars2 = 0;
int last_chars1 = 0;
int last_chars2 = 0;
- Diff lastDiff = null;
+ Diff? lastDiff;
for (Diff aDiff in diffs) {
if (aDiff.operation != Operation.insert) {
// Equality or deletion.
@@ -1417,8 +1345,7 @@ class DiffMatchPatch {
throw new ArgumentError('Invalid number in diff_fromDelta: $param');
}
if (n < 0) {
- throw new ArgumentError(
- 'Negative number in diff_fromDelta: $param');
+ throw new ArgumentError('Negative number in diff_fromDelta: $param');
}
String text;
try {
@@ -1435,8 +1362,7 @@ class DiffMatchPatch {
break;
default:
// Anything else is an error.
- throw new ArgumentError(
- 'Invalid diff operation in diff_fromDelta: ${token[0]}');
+ throw new ArgumentError('Invalid diff operation in diff_fromDelta: ${token[0]}');
}
}
if (pointer != text1.length) {
@@ -1456,7 +1382,7 @@ class DiffMatchPatch {
* [loc] is the location to search around.
* Returns the best match index or -1.
*/
- int match_main(String text, String pattern, int loc) {
+ int match_main(String? text, String? pattern, int loc) {
// Check for null inputs.
if (text == null || pattern == null) {
throw new ArgumentError('Null inputs. (match_main)');
@@ -1469,8 +1395,7 @@ class DiffMatchPatch {
} else if (text.length == 0) {
// Nothing to match.
return -1;
- } else if (loc + pattern.length <= text.length &&
- text.substring(loc, loc + pattern.length) == pattern) {
+ } else if (loc + pattern.length <= text.length && text.substring(loc, loc + pattern.length) == pattern) {
// Perfect match at the perfect spot! (Includes case of null pattern)
return loc;
} else {
@@ -1499,13 +1424,11 @@ class DiffMatchPatch {
// Is there a nearby exact match? (speedup)
int best_loc = text.indexOf(pattern, loc);
if (best_loc != -1) {
- score_threshold =
- min(_match_bitapScore(0, best_loc, loc, pattern), score_threshold);
+ score_threshold = min(_match_bitapScore(0, best_loc, loc, pattern), score_threshold);
// What about in the other direction? (speedup)
best_loc = text.lastIndexOf(pattern, loc + pattern.length);
if (best_loc != -1) {
- score_threshold =
- min(_match_bitapScore(0, best_loc, loc, pattern), score_threshold);
+ score_threshold = min(_match_bitapScore(0, best_loc, loc, pattern), score_threshold);
}
}
@@ -1515,7 +1438,7 @@ class DiffMatchPatch {
int bin_min, bin_mid;
int bin_max = pattern.length + text.length;
- List<int> last_rd;
+ List<int>? last_rd;
for (int d = 0; d < pattern.length; d++) {
// Scan for the best match; each iteration allows for one more error.
// Run a binary search to determine how far from 'loc' we can stray at
@@ -1523,8 +1446,7 @@ class DiffMatchPatch {
bin_min = 0;
bin_mid = bin_max;
while (bin_min < bin_mid) {
- if (_match_bitapScore(d, loc + bin_mid, loc, pattern) <=
- score_threshold) {
+ if (_match_bitapScore(d, loc + bin_mid, loc, pattern) <= score_threshold) {
bin_min = bin_mid;
} else {
bin_max = bin_mid;
@@ -1536,7 +1458,7 @@ class DiffMatchPatch {
int start = max(1, loc - bin_mid + 1);
int finish = min(loc + bin_mid, text.length) + pattern.length;
- final rd = new List<int>(finish + 2);
+ final rd = new List<int>.filled(finish + 2, 0);
rd[finish + 1] = (1 << d) - 1;
for (int j = finish; j >= start; j--) {
int charMatch;
@@ -1544,16 +1466,14 @@ class DiffMatchPatch {
// Out of range.
charMatch = 0;
} else {
- charMatch = s[text[j - 1]];
+ charMatch = s[text[j - 1]]!;
}
if (d == 0) {
// First pass: exact match.
rd[j] = ((rd[j + 1] << 1) | 1) & charMatch;
} else {
// Subsequent passes: fuzzy match.
- rd[j] = ((rd[j + 1] << 1) | 1) & charMatch |
- (((last_rd[j + 1] | last_rd[j]) << 1) | 1) |
- last_rd[j + 1];
+ rd[j] = ((rd[j + 1] << 1) | 1) & charMatch | (((last_rd![j + 1] | last_rd[j]) << 1) | 1) | last_rd[j + 1];
}
if ((rd[j] & matchmask) != 0) {
double score = _match_bitapScore(d, j - 1, loc, pattern);
@@ -1618,7 +1538,7 @@ class DiffMatchPatch {
s[pattern[i]] = 0;
}
for (int i = 0; i < pattern.length; i++) {
- s[pattern[i]] = s[pattern[i]] | (1 << (pattern.length - i - 1));
+ s[pattern[i]] = s[pattern[i]]! | (1 << (pattern.length - i - 1));
}
return s;
}
@@ -1650,8 +1570,8 @@ class DiffMatchPatch {
while (text.indexOf(pattern) != text.lastIndexOf(pattern) &&
pattern.length < Match_MaxBits - Patch_Margin - Patch_Margin) {
padding += Patch_Margin;
- pattern = text.substring(max(0, patch.start2 - padding),
- min(text.length, patch.start2 + patch.length1 + padding));
+ pattern =
+ text.substring(max(0, patch.start2 - padding), min(text.length, patch.start2 + patch.length1 + padding));
}
// Add one chunk for good luck.
padding += Patch_Margin;
@@ -1662,8 +1582,8 @@ class DiffMatchPatch {
patch.diffs.insert(0, new Diff(Operation.equal, prefix));
}
// Add the suffix.
- final suffix = text.substring(patch.start2 + patch.length1,
- min(text.length, patch.start2 + patch.length1 + padding));
+ final suffix =
+ text.substring(patch.start2 + patch.length1, min(text.length, patch.start2 + patch.length1 + padding));
if (!suffix.isEmpty) {
patch.diffs.add(new Diff(Operation.equal, suffix));
}
@@ -1713,17 +1633,17 @@ class DiffMatchPatch {
} else if (a is List && opt_b == null && opt_c == null) {
// Method 2: diffs
// Compute text1 from diffs.
- diffs = a;
+ diffs = a as List<Diff>;
text1 = diff_text1(diffs);
} else if (a is String && opt_b is List && opt_c == null) {
// Method 3: text1, diffs
text1 = a;
- diffs = opt_b;
+ diffs = opt_b as List<Diff>;
} else if (a is String && opt_b is String && opt_c is List) {
// Method 4: text1, text2, diffs
// text2 is not used.
text1 = a;
- diffs = opt_c;
+ diffs = opt_c as List<Diff>;
} else {
throw new ArgumentError('Unknown call format to patch_make.');
}
@@ -1751,20 +1671,17 @@ class DiffMatchPatch {
case Operation.insert:
patch.diffs.add(aDiff);
patch.length2 += aDiff.text.length;
- postpatch_text = postpatch_text.substring(0, char_count2) +
- aDiff.text +
- postpatch_text.substring(char_count2);
+ postpatch_text =
+ postpatch_text.substring(0, char_count2) + aDiff.text + postpatch_text.substring(char_count2);
break;
case Operation.delete:
patch.length1 += aDiff.text.length;
patch.diffs.add(aDiff);
- postpatch_text = postpatch_text.substring(0, char_count2) +
- postpatch_text.substring(char_count2 + aDiff.text.length);
+ postpatch_text =
+ postpatch_text.substring(0, char_count2) + postpatch_text.substring(char_count2 + aDiff.text.length);
break;
case Operation.equal:
- if (aDiff.text.length <= 2 * Patch_Margin &&
- !patch.diffs.isEmpty &&
- aDiff != diffs.last) {
+ if (aDiff.text.length <= 2 * Patch_Margin && !patch.diffs.isEmpty && aDiff != diffs.last) {
// Small equality inside a patch.
patch.diffs.add(aDiff);
patch.length1 += aDiff.text.length;
@@ -1852,7 +1769,7 @@ class DiffMatchPatch {
// 20, but the first patch was found at 12, delta is 2 and the second patch
// has an effective expected position of 22.
int delta = 0;
- final results = new List<bool>(patches.length);
+ final results = new List<bool>.filled(patches.length, false);
for (Patch aPatch in patches) {
int expected_loc = aPatch.start2 + delta;
String text1 = diff_text1(aPatch.diffs);
@@ -1861,13 +1778,10 @@ class DiffMatchPatch {
if (text1.length > Match_MaxBits) {
// patch_splitMax will only provide an oversized pattern in the case of
// a monster delete.
- start_loc =
- match_main(text, text1.substring(0, Match_MaxBits), expected_loc);
+ start_loc = match_main(text, text1.substring(0, Match_MaxBits), expected_loc);
if (start_loc != -1) {
end_loc = match_main(
- text,
- text1.substring(text1.length - Match_MaxBits),
- expected_loc + text1.length - Match_MaxBits);
+ text, text1.substring(text1.length - Match_MaxBits), expected_loc + text1.length - Match_MaxBits);
if (end_loc == -1 || start_loc >= end_loc) {
// Can't find valid trailing context. Drop this patch.
start_loc = -1;
@@ -1887,23 +1801,18 @@ class DiffMatchPatch {
delta = start_loc - expected_loc;
String text2;
if (end_loc == -1) {
- text2 = text.substring(
- start_loc, min(start_loc + text1.length, text.length));
+ text2 = text.substring(start_loc, min(start_loc + text1.length, text.length));
} else {
- text2 = text.substring(
- start_loc, min(end_loc + Match_MaxBits, text.length));
+ text2 = text.substring(start_loc, min(end_loc + Match_MaxBits, text.length));
}
if (text1 == text2) {
// Perfect match, just shove the replacement text in.
- text = text.substring(0, start_loc) +
- diff_text2(aPatch.diffs) +
- text.substring(start_loc + text1.length);
+ text = text.substring(0, start_loc) + diff_text2(aPatch.diffs) + text.substring(start_loc + text1.length);
} else {
// Imperfect match. Run a diff to get a framework of equivalent
// indices.
final diffs = diff_main(text1, text2, false);
- if (text1.length > Match_MaxBits &&
- diff_levenshtein(diffs) / text1.length > Patch_DeleteThreshold) {
+ if (text1.length > Match_MaxBits && diff_levenshtein(diffs) / text1.length > Patch_DeleteThreshold) {
// The end points match, but the content is unacceptably bad.
results[x] = false;
} else {
@@ -1914,14 +1823,11 @@ class DiffMatchPatch {
int index2 = diff_xIndex(diffs, index1);
if (aDiff.operation == Operation.insert) {
// Insertion
- text = text.substring(0, start_loc + index2) +
- aDiff.text +
- text.substring(start_loc + index2);
+ text = text.substring(0, start_loc + index2) + aDiff.text + text.substring(start_loc + index2);
} else if (aDiff.operation == Operation.delete) {
// Deletion
text = text.substring(0, start_loc + index2) +
- text.substring(start_loc +
- diff_xIndex(diffs, index1 + aDiff.text.length));
+ text.substring(start_loc + diff_xIndex(diffs, index1 + aDiff.text.length));
}
}
if (aDiff.operation != Operation.delete) {
@@ -1972,8 +1878,7 @@ class DiffMatchPatch {
// Grow first equality.
Diff firstDiff = diffs[0];
int extraLength = paddingLength - firstDiff.text.length;
- firstDiff.text =
- nullPadding.substring(firstDiff.text.length) + firstDiff.text;
+ firstDiff.text = nullPadding.substring(firstDiff.text.length) + firstDiff.text;
patch.start1 -= extraLength;
patch.start2 -= extraLength;
patch.length1 += extraLength;
@@ -2028,8 +1933,7 @@ class DiffMatchPatch {
patch.length1 = patch.length2 = precontext.length;
patch.diffs.add(new Diff(Operation.equal, precontext));
}
- while (!bigpatch.diffs.isEmpty &&
- patch.length1 < patch_size - Patch_Margin) {
+ while (!bigpatch.diffs.isEmpty && patch.length1 < patch_size - Patch_Margin) {
Operation diff_type = bigpatch.diffs[0].operation;
String diff_text = bigpatch.diffs[0].text;
if (diff_type == Operation.insert) {
@@ -2051,10 +1955,7 @@ class DiffMatchPatch {
bigpatch.diffs.removeAt(0);
} else {
// Deletion or equality. Only take as much as we can stomach.
- diff_text = diff_text.substring(
- 0,
- min(diff_text.length,
- patch_size - patch.length1 - Patch_Margin));
+ diff_text = diff_text.substring(0, min(diff_text.length, patch_size - patch.length1 - Patch_Margin));
patch.length1 += diff_text.length;
start1 += diff_text.length;
if (diff_type == Operation.equal) {
@@ -2067,15 +1968,13 @@ class DiffMatchPatch {
if (diff_text == bigpatch.diffs[0].text) {
bigpatch.diffs.removeAt(0);
} else {
- bigpatch.diffs[0].text =
- bigpatch.diffs[0].text.substring(diff_text.length);
+ bigpatch.diffs[0].text = bigpatch.diffs[0].text.substring(diff_text.length);
}
}
}
// Compute the head context for the next patch.
precontext = diff_text2(patch.diffs);
- precontext =
- precontext.substring(max(0, precontext.length - Patch_Margin));
+ precontext = precontext.substring(max(0, precontext.length - Patch_Margin));
// Append the end context for this patch.
String postcontext;
if (diff_text1(bigpatch.diffs).length > Patch_Margin) {
@@ -2086,8 +1985,7 @@ class DiffMatchPatch {
if (!postcontext.isEmpty) {
patch.length1 += postcontext.length;
patch.length2 += postcontext.length;
- if (!patch.diffs.isEmpty &&
- patch.diffs.last.operation == Operation.equal) {
+ if (!patch.diffs.isEmpty && patch.diffs.last.operation == Operation.equal) {
patch.diffs.last.text = patch.diffs.last.text + postcontext;
} else {
patch.diffs.add(new Diff(Operation.equal, postcontext));
@@ -2125,42 +2023,41 @@ class DiffMatchPatch {
}
final text = textline.split('\n');
int textPointer = 0;
- final patchHeader =
- new RegExp('^@@ -(\\d+),?(\\d*) \\+(\\d+),?(\\d*) @@\$');
+ final patchHeader = new RegExp('^@@ -(\\d+),?(\\d*) \\+(\\d+),?(\\d*) @@\$');
while (textPointer < text.length) {
- Match m = patchHeader.firstMatch(text[textPointer]);
+ Match? m = patchHeader.firstMatch(text[textPointer]);
if (m == null) {
throw new ArgumentError('Invalid patch string: ${text[textPointer]}');
}
final patch = new Patch();
patches.add(patch);
- patch.start1 = int.parse(m.group(1));
- if (m.group(2).isEmpty) {
+ patch.start1 = int.parse(m.group(1)!);
+ if (m.group(2)!.isEmpty) {
patch.start1--;
patch.length1 = 1;
} else if (m.group(2) == '0') {
patch.length1 = 0;
} else {
patch.start1--;
- patch.length1 = int.parse(m.group(2));
+ patch.length1 = int.parse(m.group(2)!);
}
- patch.start2 = int.parse(m.group(3));
- if (m.group(4).isEmpty) {
+ patch.start2 = int.parse(m.group(3)!);
+ if (m.group(4)!.isEmpty) {
patch.start2--;
patch.length2 = 1;
} else if (m.group(4) == '0') {
patch.length2 = 0;
} else {
patch.start2--;
- patch.length2 = int.parse(m.group(4));
+ patch.length2 = int.parse(m.group(4)!);
}
textPointer++;
while (textPointer < text.length) {
if (!text[textPointer].isEmpty) {
final sign = text[textPointer][0];
- String line;
+ String? line;
try {
line = Uri.decodeFull(text[textPointer].substring(1));
} on ArgumentError {
diff --git a/dart/PatchClass.dart b/dart/PatchClass.dart
index 4544e4b8..dbdb5857 100644
--- a/dart/PatchClass.dart
+++ b/dart/PatchClass.dart
@@ -22,18 +22,16 @@ part of DiffMatchPatch;
* Class representing one patch operation.
*/
class Patch {
- List<Diff> diffs;
- int start1;
- int start2;
+ List<Diff> diffs = List.empty(growable: true);
+ int start1 = 0;
+ int start2 = 0;
int length1 = 0;
int length2 = 0;
/**
* Constructor. Initializes with an empty list of diffs.
*/
- Patch() {
- this.diffs = <Diff>[];
- }
+ Patch();
/**
* Emulate GNU diff's format.
diff --git a/dart/tests/DiffMatchPatchTest.dart b/dart/tests/DiffMatchPatchTest.dart
index d808cd86..9f25be72 100644
--- a/dart/tests/DiffMatchPatchTest.dart
+++ b/dart/tests/DiffMatchPatchTest.dart
@@ -22,8 +22,7 @@ import '../DiffMatchPatch.dart';
class Expect {
static void equals(var expected, var actual, String msg) {
if (expected == actual) return;
- throw new Exception(
- 'Expect.equals(expected: <$expected>, actual: <$actual> $msg) fails.');
+ throw new Exception('Expect.equals(expected: <$expected>, actual: <$actual> $msg) fails.');
}
static void isNull(actual, String msg) {
@@ -57,9 +56,9 @@ class Expect {
// messages when an unexpected item is inserted in a list.
if (expected.length != actual.length) {
throw new Exception('Expect.listEquals(list length, '
- 'expected: <${expected.length}>, actual: <${actual.length}> $msg) '
- 'fails: Next element <'
- '${expected.length > n ? expected[n] : actual[n]}>');
+ 'expected: <${expected.length}>, actual: <${actual.length}> $msg) '
+ 'fails: Next element <'
+ '${expected.length > n ? expected[n] : actual[n]}>');
}
}
@@ -95,11 +94,10 @@ List<String> _diff_rebuildtexts(diffs) {
return [text1.toString(), text2.toString()];
}
-DiffMatchPatch dmp;
+DiffMatchPatch dmp = DiffMatchPatch();
// DIFF TEST FUNCTIONS
-
void testDiffCommonPrefix() {
// Detect any common prefix.
Expect.equals(0, dmp.diff_commonPrefix('abc', 'xyz'), 'diff_commonPrefix: Null case.');
@@ -140,22 +138,34 @@ void testDiffHalfmatch() {
Expect.isNull(dmp.test_diff_halfMatch('12345', '23'), 'diff_halfMatch: No match #2.');
- Expect.listEquals(['12', '90', 'a', 'z', '345678'], dmp.test_diff_halfMatch('1234567890', 'a345678z'), 'diff_halfMatch: Single Match #1.');
+ Expect.listEquals(['12', '90', 'a', 'z', '345678'], dmp.test_diff_halfMatch('1234567890', 'a345678z')!,
+ 'diff_halfMatch: Single Match #1.');
- Expect.listEquals(['a', 'z', '12', '90', '345678'], dmp.test_diff_halfMatch('a345678z', '1234567890'), 'diff_halfMatch: Single Match #2.');
+ Expect.listEquals(['a', 'z', '12', '90', '345678'], dmp.test_diff_halfMatch('a345678z', '1234567890')!,
+ 'diff_halfMatch: Single Match #2.');
- Expect.listEquals(['abc', 'z', '1234', '0', '56789'], dmp.test_diff_halfMatch('abc56789z', '1234567890'), 'diff_halfMatch: Single Match #3.');
+ Expect.listEquals(['abc', 'z', '1234', '0', '56789'], dmp.test_diff_halfMatch('abc56789z', '1234567890')!,
+ 'diff_halfMatch: Single Match #3.');
- Expect.listEquals(['a', 'xyz', '1', '7890', '23456'], dmp.test_diff_halfMatch('a23456xyz', '1234567890'), 'diff_halfMatch: Single Match #4.');
+ Expect.listEquals(['a', 'xyz', '1', '7890', '23456'], dmp.test_diff_halfMatch('a23456xyz', '1234567890')!,
+ 'diff_halfMatch: Single Match #4.');
- Expect.listEquals(['12123', '123121', 'a', 'z', '1234123451234'], dmp.test_diff_halfMatch('121231234123451234123121', 'a1234123451234z'), 'diff_halfMatch: Multiple Matches #1.');
+ Expect.listEquals(['12123', '123121', 'a', 'z', '1234123451234'],
+ dmp.test_diff_halfMatch('121231234123451234123121', 'a1234123451234z')!, 'diff_halfMatch: Multiple Matches #1.');
- Expect.listEquals(['', '-=-=-=-=-=', 'x', '', 'x-=-=-=-=-=-=-='], dmp.test_diff_halfMatch('x-=-=-=-=-=-=-=-=-=-=-=-=', 'xx-=-=-=-=-=-=-='), 'diff_halfMatch: Multiple Matches #2.');
+ Expect.listEquals(
+ ['', '-=-=-=-=-=', 'x', '', 'x-=-=-=-=-=-=-='],
+ dmp.test_diff_halfMatch('x-=-=-=-=-=-=-=-=-=-=-=-=', 'xx-=-=-=-=-=-=-=')!,
+ 'diff_halfMatch: Multiple Matches #2.');
- Expect.listEquals(['-=-=-=-=-=', '', '', 'y', '-=-=-=-=-=-=-=y'], dmp.test_diff_halfMatch('-=-=-=-=-=-=-=-=-=-=-=-=y', '-=-=-=-=-=-=-=yy'), 'diff_halfMatch: Multiple Matches #3.');
+ Expect.listEquals(
+ ['-=-=-=-=-=', '', '', 'y', '-=-=-=-=-=-=-=y'],
+ dmp.test_diff_halfMatch('-=-=-=-=-=-=-=-=-=-=-=-=y', '-=-=-=-=-=-=-=yy')!,
+ 'diff_halfMatch: Multiple Matches #3.');
// Optimal diff would be -q+x=H-i+e=lloHe+Hu=llo-Hew+y not -qHillo+x=HelloHe-w+Hulloy
- Expect.listEquals(['qHillo', 'w', 'x', 'Hulloy', 'HelloHe'], dmp.test_diff_halfMatch('qHilloHelloHew', 'xHelloHeHulloy'), 'diff_halfMatch: Non-optimal halfmatch.');
+ Expect.listEquals(['qHillo', 'w', 'x', 'Hulloy', 'HelloHe'],
+ dmp.test_diff_halfMatch('qHilloHelloHew', 'xHelloHeHulloy')!, 'diff_halfMatch: Non-optimal halfmatch.');
dmp.Diff_Timeout = 0.0;
Expect.isNull(dmp.test_diff_halfMatch('qHilloHelloHew', 'xHelloHeHulloy'), 'diff_halfMatch: Optimal no halfmatch.');
@@ -169,11 +179,23 @@ void testDiffLinesToChars() {
}
// Convert lines down to characters.
- assertLinesToCharsResultEquals({'chars1': '\u0001\u0002\u0001', 'chars2': '\u0002\u0001\u0002', 'lineArray': ['', 'alpha\n', 'beta\n']}, dmp.test_diff_linesToChars('alpha\nbeta\nalpha\n', 'beta\nalpha\nbeta\n'), 'diff_linesToChars: Shared lines.');
-
- assertLinesToCharsResultEquals({'chars1': '', 'chars2': '\u0001\u0002\u0003\u0003', 'lineArray': ['', 'alpha\r\n', 'beta\r\n', '\r\n']}, dmp.test_diff_linesToChars('', 'alpha\r\nbeta\r\n\r\n\r\n'), 'diff_linesToChars: Empty string and blank lines.');
-
- assertLinesToCharsResultEquals({'chars1': '\u0001', 'chars2': '\u0002', 'lineArray': ['', 'a', 'b']}, dmp.test_diff_linesToChars('a', 'b'), 'diff_linesToChars: No linebreaks.');
+ assertLinesToCharsResultEquals({
+ 'chars1': '\u0001\u0002\u0001',
+ 'chars2': '\u0002\u0001\u0002',
+ 'lineArray': ['', 'alpha\n', 'beta\n']
+ }, dmp.test_diff_linesToChars('alpha\nbeta\nalpha\n', 'beta\nalpha\nbeta\n'), 'diff_linesToChars: Shared lines.');
+
+ assertLinesToCharsResultEquals({
+ 'chars1': '',
+ 'chars2': '\u0001\u0002\u0003\u0003',
+ 'lineArray': ['', 'alpha\r\n', 'beta\r\n', '\r\n']
+ }, dmp.test_diff_linesToChars('', 'alpha\r\nbeta\r\n\r\n\r\n'), 'diff_linesToChars: Empty string and blank lines.');
+
+ assertLinesToCharsResultEquals({
+ 'chars1': '\u0001',
+ 'chars2': '\u0002',
+ 'lineArray': ['', 'a', 'b']
+ }, dmp.test_diff_linesToChars('a', 'b'), 'diff_linesToChars: No linebreaks.');
// More than 256 to reveal any 8-bit limitations.
int n = 300;
@@ -188,7 +210,8 @@ void testDiffLinesToChars() {
String chars = charList.toString();
Expect.equals(n, chars.length, 'Test initialization fail #2.');
lineList.insert(0, '');
- assertLinesToCharsResultEquals({'chars1': chars, 'chars2': '', 'lineArray': lineList}, dmp.test_diff_linesToChars(lines, ''), 'diff_linesToChars: More than 256.');
+ assertLinesToCharsResultEquals({'chars1': chars, 'chars2': '', 'lineArray': lineList},
+ dmp.test_diff_linesToChars(lines, ''), 'diff_linesToChars: More than 256.');
}
void testDiffCharsToLines() {
@@ -198,9 +221,15 @@ void testDiffCharsToLines() {
Expect.equals(new Diff(Operation.equal, 'a'), new Diff(Operation.equal, 'a'), 'diff_charsToLines: Equality #2.');
// Convert chars up to lines.
- List<Diff> diffs = [new Diff(Operation.equal, '\u0001\u0002\u0001'), new Diff(Operation.insert, '\u0002\u0001\u0002')];
+ List<Diff> diffs = [
+ new Diff(Operation.equal, '\u0001\u0002\u0001'),
+ new Diff(Operation.insert, '\u0002\u0001\u0002')
+ ];
dmp.test_diff_charsToLines(diffs, ['', 'alpha\n', 'beta\n']);
- Expect.listEquals([new Diff(Operation.equal, 'alpha\nbeta\nalpha\n'), new Diff(Operation.insert, 'beta\nalpha\nbeta\n')], diffs, 'diff_charsToLines: Shared lines.');
+ Expect.listEquals(
+ [new Diff(Operation.equal, 'alpha\nbeta\nalpha\n'), new Diff(Operation.insert, 'beta\nalpha\nbeta\n')],
+ diffs,
+ 'diff_charsToLines: Shared lines.');
// More than 256 to reveal any 8-bit limitations.
int n = 300;
@@ -239,7 +268,8 @@ void testDiffCleanupMerge() {
diffs = [new Diff(Operation.equal, 'a'), new Diff(Operation.delete, 'b'), new Diff(Operation.insert, 'c')];
dmp.diff_cleanupMerge(diffs);
- Expect.listEquals([new Diff(Operation.equal, 'a'), new Diff(Operation.delete, 'b'), new Diff(Operation.insert, 'c')], diffs, 'diff_cleanupMerge: No change case.');
+ Expect.listEquals([new Diff(Operation.equal, 'a'), new Diff(Operation.delete, 'b'), new Diff(Operation.insert, 'c')],
+ diffs, 'diff_cleanupMerge: No change case.');
diffs = [new Diff(Operation.equal, 'a'), new Diff(Operation.equal, 'b'), new Diff(Operation.equal, 'c')];
dmp.diff_cleanupMerge(diffs);
@@ -253,41 +283,85 @@ void testDiffCleanupMerge() {
dmp.diff_cleanupMerge(diffs);
Expect.listEquals([new Diff(Operation.insert, 'abc')], diffs, 'diff_cleanupMerge: Merge insertions.');
- diffs = [new Diff(Operation.delete, 'a'), new Diff(Operation.insert, 'b'), new Diff(Operation.delete, 'c'), new Diff(Operation.insert, 'd'), new Diff(Operation.equal, 'e'), new Diff(Operation.equal, 'f')];
+ diffs = [
+ new Diff(Operation.delete, 'a'),
+ new Diff(Operation.insert, 'b'),
+ new Diff(Operation.delete, 'c'),
+ new Diff(Operation.insert, 'd'),
+ new Diff(Operation.equal, 'e'),
+ new Diff(Operation.equal, 'f')
+ ];
dmp.diff_cleanupMerge(diffs);
- Expect.listEquals([new Diff(Operation.delete, 'ac'), new Diff(Operation.insert, 'bd'), new Diff(Operation.equal, 'ef')], diffs, 'diff_cleanupMerge: Merge interweave.');
+ Expect.listEquals(
+ [new Diff(Operation.delete, 'ac'), new Diff(Operation.insert, 'bd'), new Diff(Operation.equal, 'ef')],
+ diffs,
+ 'diff_cleanupMerge: Merge interweave.');
diffs = [new Diff(Operation.delete, 'a'), new Diff(Operation.insert, 'abc'), new Diff(Operation.delete, 'dc')];
dmp.diff_cleanupMerge(diffs);
- Expect.listEquals([new Diff(Operation.equal, 'a'), new Diff(Operation.delete, 'd'), new Diff(Operation.insert, 'b'), new Diff(Operation.equal, 'c')], diffs, 'diff_cleanupMerge: Prefix and suffix detection.');
-
- diffs = [new Diff(Operation.equal, 'x'), new Diff(Operation.delete, 'a'), new Diff(Operation.insert, 'abc'), new Diff(Operation.delete, 'dc'), new Diff(Operation.equal, 'y')];
+ Expect.listEquals([
+ new Diff(Operation.equal, 'a'),
+ new Diff(Operation.delete, 'd'),
+ new Diff(Operation.insert, 'b'),
+ new Diff(Operation.equal, 'c')
+ ], diffs, 'diff_cleanupMerge: Prefix and suffix detection.');
+
+ diffs = [
+ new Diff(Operation.equal, 'x'),
+ new Diff(Operation.delete, 'a'),
+ new Diff(Operation.insert, 'abc'),
+ new Diff(Operation.delete, 'dc'),
+ new Diff(Operation.equal, 'y')
+ ];
dmp.diff_cleanupMerge(diffs);
- Expect.listEquals([new Diff(Operation.equal, 'xa'), new Diff(Operation.delete, 'd'), new Diff(Operation.insert, 'b'), new Diff(Operation.equal, 'cy')], diffs, 'diff_cleanupMerge: Prefix and suffix detection with equalities.');
+ Expect.listEquals([
+ new Diff(Operation.equal, 'xa'),
+ new Diff(Operation.delete, 'd'),
+ new Diff(Operation.insert, 'b'),
+ new Diff(Operation.equal, 'cy')
+ ], diffs, 'diff_cleanupMerge: Prefix and suffix detection with equalities.');
diffs = [new Diff(Operation.equal, 'a'), new Diff(Operation.insert, 'ba'), new Diff(Operation.equal, 'c')];
dmp.diff_cleanupMerge(diffs);
- Expect.listEquals([new Diff(Operation.insert, 'ab'), new Diff(Operation.equal, 'ac')], diffs, 'diff_cleanupMerge: Slide edit left.');
+ Expect.listEquals([new Diff(Operation.insert, 'ab'), new Diff(Operation.equal, 'ac')], diffs,
+ 'diff_cleanupMerge: Slide edit left.');
diffs = [new Diff(Operation.equal, 'c'), new Diff(Operation.insert, 'ab'), new Diff(Operation.equal, 'a')];
dmp.diff_cleanupMerge(diffs);
- Expect.listEquals([new Diff(Operation.equal, 'ca'), new Diff(Operation.insert, 'ba')], diffs, 'diff_cleanupMerge: Slide edit right.');
-
- diffs = [new Diff(Operation.equal, 'a'), new Diff(Operation.delete, 'b'), new Diff(Operation.equal, 'c'), new Diff(Operation.delete, 'ac'), new Diff(Operation.equal, 'x')];
+ Expect.listEquals([new Diff(Operation.equal, 'ca'), new Diff(Operation.insert, 'ba')], diffs,
+ 'diff_cleanupMerge: Slide edit right.');
+
+ diffs = [
+ new Diff(Operation.equal, 'a'),
+ new Diff(Operation.delete, 'b'),
+ new Diff(Operation.equal, 'c'),
+ new Diff(Operation.delete, 'ac'),
+ new Diff(Operation.equal, 'x')
+ ];
dmp.diff_cleanupMerge(diffs);
- Expect.listEquals([new Diff(Operation.delete, 'abc'), new Diff(Operation.equal, 'acx')], diffs, 'diff_cleanupMerge: Slide edit left recursive.');
-
- diffs = [new Diff(Operation.equal, 'x'), new Diff(Operation.delete, 'ca'), new Diff(Operation.equal, 'c'), new Diff(Operation.delete, 'b'), new Diff(Operation.equal, 'a')];
+ Expect.listEquals([new Diff(Operation.delete, 'abc'), new Diff(Operation.equal, 'acx')], diffs,
+ 'diff_cleanupMerge: Slide edit left recursive.');
+
+ diffs = [
+ new Diff(Operation.equal, 'x'),
+ new Diff(Operation.delete, 'ca'),
+ new Diff(Operation.equal, 'c'),
+ new Diff(Operation.delete, 'b'),
+ new Diff(Operation.equal, 'a')
+ ];
dmp.diff_cleanupMerge(diffs);
- Expect.listEquals([new Diff(Operation.equal, 'xca'), new Diff(Operation.delete, 'cba')], diffs, 'diff_cleanupMerge: Slide edit right recursive.');
+ Expect.listEquals([new Diff(Operation.equal, 'xca'), new Diff(Operation.delete, 'cba')], diffs,
+ 'diff_cleanupMerge: Slide edit right recursive.');
diffs = [new Diff(Operation.delete, 'b'), new Diff(Operation.insert, 'ab'), new Diff(Operation.equal, 'c')];
dmp.diff_cleanupMerge(diffs);
- Expect.listEquals([new Diff(Operation.insert, 'a'), new Diff(Operation.equal, 'bc')], diffs, 'diff_cleanupMerge: Empty merge.');
+ Expect.listEquals(
+ [new Diff(Operation.insert, 'a'), new Diff(Operation.equal, 'bc')], diffs, 'diff_cleanupMerge: Empty merge.');
diffs = [new Diff(Operation.equal, ''), new Diff(Operation.insert, 'a'), new Diff(Operation.equal, 'b')];
dmp.diff_cleanupMerge(diffs);
- Expect.listEquals([new Diff(Operation.insert, 'a'), new Diff(Operation.equal, 'b')], diffs, 'diff_cleanupMerge: Empty equality.');
+ Expect.listEquals(
+ [new Diff(Operation.insert, 'a'), new Diff(Operation.equal, 'b')], diffs, 'diff_cleanupMerge: Empty equality.');
}
void testDiffCleanupSemanticLossless() {
@@ -296,33 +370,75 @@ void testDiffCleanupSemanticLossless() {
dmp.test_diff_cleanupSemanticLossless(diffs);
Expect.listEquals([], diffs, 'diff_cleanupSemanticLossless: Null case.');
- diffs = [new Diff(Operation.equal, 'AAA\r\n\r\nBBB'), new Diff(Operation.insert, '\r\nDDD\r\n\r\nBBB'), new Diff(Operation.equal, '\r\nEEE')];
+ diffs = [
+ new Diff(Operation.equal, 'AAA\r\n\r\nBBB'),
+ new Diff(Operation.insert, '\r\nDDD\r\n\r\nBBB'),
+ new Diff(Operation.equal, '\r\nEEE')
+ ];
dmp.test_diff_cleanupSemanticLossless(diffs);
- Expect.listEquals([new Diff(Operation.equal, 'AAA\r\n\r\n'), new Diff(Operation.insert, 'BBB\r\nDDD\r\n\r\n'), new Diff(Operation.equal, 'BBB\r\nEEE')], diffs, 'diff_cleanupSemanticLossless: Blank lines.');
-
- diffs = [new Diff(Operation.equal, 'AAA\r\nBBB'), new Diff(Operation.insert, ' DDD\r\nBBB'), new Diff(Operation.equal, ' EEE')];
+ Expect.listEquals([
+ new Diff(Operation.equal, 'AAA\r\n\r\n'),
+ new Diff(Operation.insert, 'BBB\r\nDDD\r\n\r\n'),
+ new Diff(Operation.equal, 'BBB\r\nEEE')
+ ], diffs, 'diff_cleanupSemanticLossless: Blank lines.');
+
+ diffs = [
+ new Diff(Operation.equal, 'AAA\r\nBBB'),
+ new Diff(Operation.insert, ' DDD\r\nBBB'),
+ new Diff(Operation.equal, ' EEE')
+ ];
dmp.test_diff_cleanupSemanticLossless(diffs);
- Expect.listEquals([new Diff(Operation.equal, 'AAA\r\n'), new Diff(Operation.insert, 'BBB DDD\r\n'), new Diff(Operation.equal, 'BBB EEE')], diffs, 'diff_cleanupSemanticLossless: Line boundaries.');
-
- diffs = [new Diff(Operation.equal, 'The c'), new Diff(Operation.insert, 'ow and the c'), new Diff(Operation.equal, 'at.')];
+ Expect.listEquals([
+ new Diff(Operation.equal, 'AAA\r\n'),
+ new Diff(Operation.insert, 'BBB DDD\r\n'),
+ new Diff(Operation.equal, 'BBB EEE')
+ ], diffs, 'diff_cleanupSemanticLossless: Line boundaries.');
+
+ diffs = [
+ new Diff(Operation.equal, 'The c'),
+ new Diff(Operation.insert, 'ow and the c'),
+ new Diff(Operation.equal, 'at.')
+ ];
dmp.test_diff_cleanupSemanticLossless(diffs);
- Expect.listEquals([new Diff(Operation.equal, 'The '), new Diff(Operation.insert, 'cow and the '), new Diff(Operation.equal, 'cat.')], diffs, 'diff_cleanupSemanticLossless: Word boundaries.');
-
- diffs = [new Diff(Operation.equal, 'The-c'), new Diff(Operation.insert, 'ow-and-the-c'), new Diff(Operation.equal, 'at.')];
+ Expect.listEquals([
+ new Diff(Operation.equal, 'The '),
+ new Diff(Operation.insert, 'cow and the '),
+ new Diff(Operation.equal, 'cat.')
+ ], diffs, 'diff_cleanupSemanticLossless: Word boundaries.');
+
+ diffs = [
+ new Diff(Operation.equal, 'The-c'),
+ new Diff(Operation.insert, 'ow-and-the-c'),
+ new Diff(Operation.equal, 'at.')
+ ];
dmp.test_diff_cleanupSemanticLossless(diffs);
- Expect.listEquals([new Diff(Operation.equal, 'The-'), new Diff(Operation.insert, 'cow-and-the-'), new Diff(Operation.equal, 'cat.')], diffs, 'diff_cleanupSemanticLossless: Alphanumeric boundaries.');
+ Expect.listEquals([
+ new Diff(Operation.equal, 'The-'),
+ new Diff(Operation.insert, 'cow-and-the-'),
+ new Diff(Operation.equal, 'cat.')
+ ], diffs, 'diff_cleanupSemanticLossless: Alphanumeric boundaries.');
diffs = [new Diff(Operation.equal, 'a'), new Diff(Operation.delete, 'a'), new Diff(Operation.equal, 'ax')];
dmp.test_diff_cleanupSemanticLossless(diffs);
- Expect.listEquals([new Diff(Operation.delete, 'a'), new Diff(Operation.equal, 'aax')], diffs, 'diff_cleanupSemanticLossless: Hitting the start.');
+ Expect.listEquals([new Diff(Operation.delete, 'a'), new Diff(Operation.equal, 'aax')], diffs,
+ 'diff_cleanupSemanticLossless: Hitting the start.');
diffs = [new Diff(Operation.equal, 'xa'), new Diff(Operation.delete, 'a'), new Diff(Operation.equal, 'a')];
dmp.test_diff_cleanupSemanticLossless(diffs);
- Expect.listEquals([new Diff(Operation.equal, 'xaa'), new Diff(Operation.delete, 'a')], diffs, 'diff_cleanupSemanticLossless: Hitting the end.');
-
- diffs = [new Diff(Operation.equal, 'The xxx. The '), new Diff(Operation.insert, 'zzz. The '), new Diff(Operation.equal, 'yyy.')];
+ Expect.listEquals([new Diff(Operation.equal, 'xaa'), new Diff(Operation.delete, 'a')], diffs,
+ 'diff_cleanupSemanticLossless: Hitting the end.');
+
+ diffs = [
+ new Diff(Operation.equal, 'The xxx. The '),
+ new Diff(Operation.insert, 'zzz. The '),
+ new Diff(Operation.equal, 'yyy.')
+ ];
dmp.test_diff_cleanupSemanticLossless(diffs);
- Expect.listEquals([new Diff(Operation.equal, 'The xxx.'), new Diff(Operation.insert, ' The zzz.'), new Diff(Operation.equal, ' The yyy.')], diffs, 'diff_cleanupSemanticLossless: Sentence boundaries.');
+ Expect.listEquals([
+ new Diff(Operation.equal, 'The xxx.'),
+ new Diff(Operation.insert, ' The zzz.'),
+ new Diff(Operation.equal, ' The yyy.')
+ ], diffs, 'diff_cleanupSemanticLossless: Sentence boundaries.');
}
void testDiffCleanupSemantic() {
@@ -331,45 +447,113 @@ void testDiffCleanupSemantic() {
dmp.diff_cleanupSemantic(diffs);
Expect.listEquals([], diffs, 'diff_cleanupSemantic: Null case.');
- diffs = [new Diff(Operation.delete, 'ab'), new Diff(Operation.insert, 'cd'), new Diff(Operation.equal, '12'), new Diff(Operation.delete, 'e')];
+ diffs = [
+ new Diff(Operation.delete, 'ab'),
+ new Diff(Operation.insert, 'cd'),
+ new Diff(Operation.equal, '12'),
+ new Diff(Operation.delete, 'e')
+ ];
dmp.diff_cleanupSemantic(diffs);
- Expect.listEquals([new Diff(Operation.delete, 'ab'), new Diff(Operation.insert, 'cd'), new Diff(Operation.equal, '12'), new Diff(Operation.delete, 'e')], diffs, 'diff_cleanupSemantic: No elimination #1.');
-
- diffs = [new Diff(Operation.delete, 'abc'), new Diff(Operation.insert, 'ABC'), new Diff(Operation.equal, '1234'), new Diff(Operation.delete, 'wxyz')];
+ Expect.listEquals([
+ new Diff(Operation.delete, 'ab'),
+ new Diff(Operation.insert, 'cd'),
+ new Diff(Operation.equal, '12'),
+ new Diff(Operation.delete, 'e')
+ ], diffs, 'diff_cleanupSemantic: No elimination #1.');
+
+ diffs = [
+ new Diff(Operation.delete, 'abc'),
+ new Diff(Operation.insert, 'ABC'),
+ new Diff(Operation.equal, '1234'),
+ new Diff(Operation.delete, 'wxyz')
+ ];
dmp.diff_cleanupSemantic(diffs);
- Expect.listEquals([new Diff(Operation.delete, 'abc'), new Diff(Operation.insert, 'ABC'), new Diff(Operation.equal, '1234'), new Diff(Operation.delete, 'wxyz')], diffs, 'diff_cleanupSemantic: No elimination #2.');
+ Expect.listEquals([
+ new Diff(Operation.delete, 'abc'),
+ new Diff(Operation.insert, 'ABC'),
+ new Diff(Operation.equal, '1234'),
+ new Diff(Operation.delete, 'wxyz')
+ ], diffs, 'diff_cleanupSemantic: No elimination #2.');
diffs = [new Diff(Operation.delete, 'a'), new Diff(Operation.equal, 'b'), new Diff(Operation.delete, 'c')];
dmp.diff_cleanupSemantic(diffs);
- Expect.listEquals([new Diff(Operation.delete, 'abc'), new Diff(Operation.insert, 'b')], diffs, 'diff_cleanupSemantic: Simple elimination.');
-
- diffs = [new Diff(Operation.delete, 'ab'), new Diff(Operation.equal, 'cd'), new Diff(Operation.delete, 'e'), new Diff(Operation.equal, 'f'), new Diff(Operation.insert, 'g')];
+ Expect.listEquals([new Diff(Operation.delete, 'abc'), new Diff(Operation.insert, 'b')], diffs,
+ 'diff_cleanupSemantic: Simple elimination.');
+
+ diffs = [
+ new Diff(Operation.delete, 'ab'),
+ new Diff(Operation.equal, 'cd'),
+ new Diff(Operation.delete, 'e'),
+ new Diff(Operation.equal, 'f'),
+ new Diff(Operation.insert, 'g')
+ ];
dmp.diff_cleanupSemantic(diffs);
- Expect.listEquals([new Diff(Operation.delete, 'abcdef'), new Diff(Operation.insert, 'cdfg')], diffs, 'diff_cleanupSemantic: Backpass elimination.');
-
- diffs = [new Diff(Operation.insert, '1'), new Diff(Operation.equal, 'A'), new Diff(Operation.delete, 'B'), new Diff(Operation.insert, '2'), new Diff(Operation.equal, '_'), new Diff(Operation.insert, '1'), new Diff(Operation.equal, 'A'), new Diff(Operation.delete, 'B'), new Diff(Operation.insert, '2')];
+ Expect.listEquals([new Diff(Operation.delete, 'abcdef'), new Diff(Operation.insert, 'cdfg')], diffs,
+ 'diff_cleanupSemantic: Backpass elimination.');
+
+ diffs = [
+ new Diff(Operation.insert, '1'),
+ new Diff(Operation.equal, 'A'),
+ new Diff(Operation.delete, 'B'),
+ new Diff(Operation.insert, '2'),
+ new Diff(Operation.equal, '_'),
+ new Diff(Operation.insert, '1'),
+ new Diff(Operation.equal, 'A'),
+ new Diff(Operation.delete, 'B'),
+ new Diff(Operation.insert, '2')
+ ];
dmp.diff_cleanupSemantic(diffs);
- Expect.listEquals([new Diff(Operation.delete, 'AB_AB'), new Diff(Operation.insert, '1A2_1A2')], diffs, 'diff_cleanupSemantic: Multiple elimination.');
-
- diffs = [new Diff(Operation.equal, 'The c'), new Diff(Operation.delete, 'ow and the c'), new Diff(Operation.equal, 'at.')];
+ Expect.listEquals([new Diff(Operation.delete, 'AB_AB'), new Diff(Operation.insert, '1A2_1A2')], diffs,
+ 'diff_cleanupSemantic: Multiple elimination.');
+
+ diffs = [
+ new Diff(Operation.equal, 'The c'),
+ new Diff(Operation.delete, 'ow and the c'),
+ new Diff(Operation.equal, 'at.')
+ ];
dmp.diff_cleanupSemantic(diffs);
- Expect.listEquals([new Diff(Operation.equal, 'The '), new Diff(Operation.delete, 'cow and the '), new Diff(Operation.equal, 'cat.')], diffs, 'diff_cleanupSemantic: Word boundaries.');
+ Expect.listEquals([
+ new Diff(Operation.equal, 'The '),
+ new Diff(Operation.delete, 'cow and the '),
+ new Diff(Operation.equal, 'cat.')
+ ], diffs, 'diff_cleanupSemantic: Word boundaries.');
diffs = [new Diff(Operation.delete, 'abcxx'), new Diff(Operation.insert, 'xxdef')];
dmp.diff_cleanupSemantic(diffs);
- Expect.listEquals([new Diff(Operation.delete, 'abcxx'), new Diff(Operation.insert, 'xxdef')], diffs, 'diff_cleanupSemantic: No overlap elimination.');
+ Expect.listEquals([new Diff(Operation.delete, 'abcxx'), new Diff(Operation.insert, 'xxdef')], diffs,
+ 'diff_cleanupSemantic: No overlap elimination.');
diffs = [new Diff(Operation.delete, 'abcxxx'), new Diff(Operation.insert, 'xxxdef')];
dmp.diff_cleanupSemantic(diffs);
- Expect.listEquals([new Diff(Operation.delete, 'abc'), new Diff(Operation.equal, 'xxx'), new Diff(Operation.insert, 'def')], diffs, 'diff_cleanupSemantic: Overlap elimination.');
+ Expect.listEquals(
+ [new Diff(Operation.delete, 'abc'), new Diff(Operation.equal, 'xxx'), new Diff(Operation.insert, 'def')],
+ diffs,
+ 'diff_cleanupSemantic: Overlap elimination.');
diffs = [new Diff(Operation.delete, 'xxxabc'), new Diff(Operation.insert, 'defxxx')];
dmp.diff_cleanupSemantic(diffs);
- Expect.listEquals([new Diff(Operation.insert, 'def'), new Diff(Operation.equal, 'xxx'), new Diff(Operation.delete, 'abc')], diffs, 'diff_cleanupSemantic: Reverse overlap elimination.');
-
- diffs = [new Diff(Operation.delete, 'abcd1212'), new Diff(Operation.insert, '1212efghi'), new Diff(Operation.equal, '----'), new Diff(Operation.delete, 'A3'), new Diff(Operation.insert, '3BC')];
+ Expect.listEquals(
+ [new Diff(Operation.insert, 'def'), new Diff(Operation.equal, 'xxx'), new Diff(Operation.delete, 'abc')],
+ diffs,
+ 'diff_cleanupSemantic: Reverse overlap elimination.');
+
+ diffs = [
+ new Diff(Operation.delete, 'abcd1212'),
+ new Diff(Operation.insert, '1212efghi'),
+ new Diff(Operation.equal, '----'),
+ new Diff(Operation.delete, 'A3'),
+ new Diff(Operation.insert, '3BC')
+ ];
dmp.diff_cleanupSemantic(diffs);
- Expect.listEquals([new Diff(Operation.delete, 'abcd'), new Diff(Operation.equal, '1212'), new Diff(Operation.insert, 'efghi'), new Diff(Operation.equal, '----'), new Diff(Operation.delete, 'A'), new Diff(Operation.equal, '3'), new Diff(Operation.insert, 'BC')], diffs, 'diff_cleanupSemantic: Two overlap eliminations.');
+ Expect.listEquals([
+ new Diff(Operation.delete, 'abcd'),
+ new Diff(Operation.equal, '1212'),
+ new Diff(Operation.insert, 'efghi'),
+ new Diff(Operation.equal, '----'),
+ new Diff(Operation.delete, 'A'),
+ new Diff(Operation.equal, '3'),
+ new Diff(Operation.insert, 'BC')
+ ], diffs, 'diff_cleanupSemantic: Two overlap eliminations.');
}
void testDiffCleanupEfficiency() {
@@ -379,45 +563,110 @@ void testDiffCleanupEfficiency() {
dmp.diff_cleanupEfficiency(diffs);
Expect.listEquals([], diffs, 'diff_cleanupEfficiency: Null case.');
- diffs = [new Diff(Operation.delete, 'ab'), new Diff(Operation.insert, '12'), new Diff(Operation.equal, 'wxyz'), new Diff(Operation.delete, 'cd'), new Diff(Operation.insert, '34')];
+ diffs = [
+ new Diff(Operation.delete, 'ab'),
+ new Diff(Operation.insert, '12'),
+ new Diff(Operation.equal, 'wxyz'),
+ new Diff(Operation.delete, 'cd'),
+ new Diff(Operation.insert, '34')
+ ];
dmp.diff_cleanupEfficiency(diffs);
- Expect.listEquals([new Diff(Operation.delete, 'ab'), new Diff(Operation.insert, '12'), new Diff(Operation.equal, 'wxyz'), new Diff(Operation.delete, 'cd'), new Diff(Operation.insert, '34')], diffs, 'diff_cleanupEfficiency: No elimination.');
-
- diffs = [new Diff(Operation.delete, 'ab'), new Diff(Operation.insert, '12'), new Diff(Operation.equal, 'xyz'), new Diff(Operation.delete, 'cd'), new Diff(Operation.insert, '34')];
+ Expect.listEquals([
+ new Diff(Operation.delete, 'ab'),
+ new Diff(Operation.insert, '12'),
+ new Diff(Operation.equal, 'wxyz'),
+ new Diff(Operation.delete, 'cd'),
+ new Diff(Operation.insert, '34')
+ ], diffs, 'diff_cleanupEfficiency: No elimination.');
+
+ diffs = [
+ new Diff(Operation.delete, 'ab'),
+ new Diff(Operation.insert, '12'),
+ new Diff(Operation.equal, 'xyz'),
+ new Diff(Operation.delete, 'cd'),
+ new Diff(Operation.insert, '34')
+ ];
dmp.diff_cleanupEfficiency(diffs);
- Expect.listEquals([new Diff(Operation.delete, 'abxyzcd'), new Diff(Operation.insert, '12xyz34')], diffs, 'diff_cleanupEfficiency: Four-edit elimination.');
-
- diffs = [new Diff(Operation.insert, '12'), new Diff(Operation.equal, 'x'), new Diff(Operation.delete, 'cd'), new Diff(Operation.insert, '34')];
+ Expect.listEquals([new Diff(Operation.delete, 'abxyzcd'), new Diff(Operation.insert, '12xyz34')], diffs,
+ 'diff_cleanupEfficiency: Four-edit elimination.');
+
+ diffs = [
+ new Diff(Operation.insert, '12'),
+ new Diff(Operation.equal, 'x'),
+ new Diff(Operation.delete, 'cd'),
+ new Diff(Operation.insert, '34')
+ ];
dmp.diff_cleanupEfficiency(diffs);
- Expect.listEquals([new Diff(Operation.delete, 'xcd'), new Diff(Operation.insert, '12x34')], diffs, 'diff_cleanupEfficiency: Three-edit elimination.');
-
- diffs = [new Diff(Operation.delete, 'ab'), new Diff(Operation.insert, '12'), new Diff(Operation.equal, 'xy'), new Diff(Operation.insert, '34'), new Diff(Operation.equal, 'z'), new Diff(Operation.delete, 'cd'), new Diff(Operation.insert, '56')];
+ Expect.listEquals([new Diff(Operation.delete, 'xcd'), new Diff(Operation.insert, '12x34')], diffs,
+ 'diff_cleanupEfficiency: Three-edit elimination.');
+
+ diffs = [
+ new Diff(Operation.delete, 'ab'),
+ new Diff(Operation.insert, '12'),
+ new Diff(Operation.equal, 'xy'),
+ new Diff(Operation.insert, '34'),
+ new Diff(Operation.equal, 'z'),
+ new Diff(Operation.delete, 'cd'),
+ new Diff(Operation.insert, '56')
+ ];
dmp.diff_cleanupEfficiency(diffs);
- Expect.listEquals([new Diff(Operation.delete, 'abxyzcd'), new Diff(Operation.insert, '12xy34z56')], diffs, 'diff_cleanupEfficiency: Backpass elimination.');
+ Expect.listEquals([new Diff(Operation.delete, 'abxyzcd'), new Diff(Operation.insert, '12xy34z56')], diffs,
+ 'diff_cleanupEfficiency: Backpass elimination.');
dmp.Diff_EditCost = 5;
- diffs = [new Diff(Operation.delete, 'ab'), new Diff(Operation.insert, '12'), new Diff(Operation.equal, 'wxyz'), new Diff(Operation.delete, 'cd'), new Diff(Operation.insert, '34')];
+ diffs = [
+ new Diff(Operation.delete, 'ab'),
+ new Diff(Operation.insert, '12'),
+ new Diff(Operation.equal, 'wxyz'),
+ new Diff(Operation.delete, 'cd'),
+ new Diff(Operation.insert, '34')
+ ];
dmp.diff_cleanupEfficiency(diffs);
- Expect.listEquals([new Diff(Operation.delete, 'abwxyzcd'), new Diff(Operation.insert, '12wxyz34')], diffs, 'diff_cleanupEfficiency: High cost elimination.');
+ Expect.listEquals([new Diff(Operation.delete, 'abwxyzcd'), new Diff(Operation.insert, '12wxyz34')], diffs,
+ 'diff_cleanupEfficiency: High cost elimination.');
dmp.Diff_EditCost = 4;
}
void testDiffPrettyHtml() {
// Pretty print.
- List<Diff> diffs = [new Diff(Operation.equal, 'a\n'), new Diff(Operation.delete, '<B>b</B>'), new Diff(Operation.insert, 'c&d')];
- Expect.equals('<span>a¶<br></span><del style="background:#ffe6e6;"><B>b</B></del><ins style="background:#e6ffe6;">c&d</ins>', dmp.diff_prettyHtml(diffs), 'diff_prettyHtml:');
+ List<Diff> diffs = [
+ new Diff(Operation.equal, 'a\n'),
+ new Diff(Operation.delete, '<B>b</B>'),
+ new Diff(Operation.insert, 'c&d')
+ ];
+ Expect.equals(
+ '<span>a¶<br></span><del style="background:#ffe6e6;"><B>b</B></del><ins style="background:#e6ffe6;">c&d</ins>',
+ dmp.diff_prettyHtml(diffs),
+ 'diff_prettyHtml:');
}
void testDiffText() {
// Compute the source and destination texts.
- List<Diff> diffs = [new Diff(Operation.equal, 'jump'), new Diff(Operation.delete, 's'), new Diff(Operation.insert, 'ed'), new Diff(Operation.equal, ' over '), new Diff(Operation.delete, 'the'), new Diff(Operation.insert, 'a'), new Diff(Operation.equal, ' lazy')];
+ List<Diff> diffs = [
+ new Diff(Operation.equal, 'jump'),
+ new Diff(Operation.delete, 's'),
+ new Diff(Operation.insert, 'ed'),
+ new Diff(Operation.equal, ' over '),
+ new Diff(Operation.delete, 'the'),
+ new Diff(Operation.insert, 'a'),
+ new Diff(Operation.equal, ' lazy')
+ ];
Expect.equals('jumps over the lazy', dmp.diff_text1(diffs), 'diff_text1:');
Expect.equals('jumped over a lazy', dmp.diff_text2(diffs), 'diff_text2:');
}
void testDiffDelta() {
// Convert a diff into delta string.
- List<Diff> diffs = [new Diff(Operation.equal, 'jump'), new Diff(Operation.delete, 's'), new Diff(Operation.insert, 'ed'), new Diff(Operation.equal, ' over '), new Diff(Operation.delete, 'the'), new Diff(Operation.insert, 'a'), new Diff(Operation.equal, ' lazy'), new Diff(Operation.insert, 'old dog')];
+ List<Diff> diffs = [
+ new Diff(Operation.equal, 'jump'),
+ new Diff(Operation.delete, 's'),
+ new Diff(Operation.insert, 'ed'),
+ new Diff(Operation.equal, ' over '),
+ new Diff(Operation.delete, 'the'),
+ new Diff(Operation.insert, 'a'),
+ new Diff(Operation.equal, ' lazy'),
+ new Diff(Operation.insert, 'old dog')
+ ];
String text1 = dmp.diff_text1(diffs);
Expect.equals('jumps over the lazy', text1, 'diff_text1: Base text.');
@@ -437,7 +686,11 @@ void testDiffDelta() {
Expect.throws(() => dmp.diff_fromDelta('', '+%c3%xy'), 'diff_fromDelta: Invalid character.');
// Test deltas with special characters.
- diffs = [new Diff(Operation.equal, '\u0680 \x00 \t %'), new Diff(Operation.delete, '\u0681 \x01 \n ^'), new Diff(Operation.insert, '\u0682 \x02 \\ |')];
+ diffs = [
+ new Diff(Operation.equal, '\u0680 \x00 \t %'),
+ new Diff(Operation.delete, '\u0681 \x01 \n ^'),
+ new Diff(Operation.insert, '\u0682 \x02 \\ |')
+ ];
text1 = dmp.diff_text1(diffs);
Expect.equals('\u0680 \x00 \t %\u0681 \x01 \n ^', text1, 'diff_text1: Unicode text.');
@@ -452,7 +705,8 @@ void testDiffDelta() {
Expect.equals('A-Z a-z 0-9 - _ . ! ~ * \' ( ) ; / ? : @ & = + \$ , # ', text2, 'diff_text2: Unchanged characters.');
delta = dmp.diff_toDelta(diffs);
- Expect.equals('+A-Z a-z 0-9 - _ . ! ~ * \' ( ) ; / ? : @ & = + \$ , # ', delta, 'diff_toDelta: Unchanged characters.');
+ Expect.equals(
+ '+A-Z a-z 0-9 - _ . ! ~ * \' ( ) ; / ? : @ & = + \$ , # ', delta, 'diff_toDelta: Unchanged characters.');
// Convert delta string into a diff.
Expect.listEquals(diffs, dmp.diff_fromDelta('', delta), 'diff_fromDelta: Unchanged characters.');
@@ -472,7 +726,11 @@ void testDiffDelta() {
void testDiffXIndex() {
// Translate a location in text1 to text2.
- List<Diff> diffs = [new Diff(Operation.delete, 'a'), new Diff(Operation.insert, '1234'), new Diff(Operation.equal, 'xyz')];
+ List<Diff> diffs = [
+ new Diff(Operation.delete, 'a'),
+ new Diff(Operation.insert, '1234'),
+ new Diff(Operation.equal, 'xyz')
+ ];
Expect.equals(5, dmp.diff_xIndex(diffs, 2), 'diff_xIndex: Translation on equality.');
diffs = [new Diff(Operation.equal, 'a'), new Diff(Operation.delete, '1234'), new Diff(Operation.equal, 'xyz')];
@@ -480,7 +738,11 @@ void testDiffXIndex() {
}
void testDiffLevenshtein() {
- List<Diff> diffs = [new Diff(Operation.delete, 'abc'), new Diff(Operation.insert, '1234'), new Diff(Operation.equal, 'xyz')];
+ List<Diff> diffs = [
+ new Diff(Operation.delete, 'abc'),
+ new Diff(Operation.insert, '1234'),
+ new Diff(Operation.equal, 'xyz')
+ ];
Expect.equals(4, dmp.diff_levenshtein(diffs), 'Levenshtein with trailing equality.');
diffs = [new Diff(Operation.equal, 'xyz'), new Diff(Operation.delete, 'abc'), new Diff(Operation.insert, '1234')];
@@ -497,15 +759,21 @@ void testDiffBisect() {
// 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.
- List<Diff> diffs = [new Diff(Operation.delete, 'c'), new Diff(Operation.insert, 'm'), new Diff(Operation.equal, 'a'), new Diff(Operation.delete, 't'), new Diff(Operation.insert, 'p')];
+ List<Diff> diffs = [
+ new Diff(Operation.delete, 'c'),
+ new Diff(Operation.insert, 'm'),
+ new Diff(Operation.equal, 'a'),
+ new Diff(Operation.delete, 't'),
+ new Diff(Operation.insert, 'p')
+ ];
// One year should be sufficient.
- DateTime deadline = new DateTime.now().add(new Duration(days : 365));
+ DateTime deadline = new DateTime.now().add(new Duration(days: 365));
Expect.listEquals(diffs, dmp.test_diff_bisect(a, b, deadline), 'diff_bisect: Normal.');
// Timeout.
diffs = [new Diff(Operation.delete, 'cat'), new Diff(Operation.insert, 'map')];
// Set deadline to one year ago.
- deadline = new DateTime.now().subtract(new Duration(days : 365));
+ deadline = new DateTime.now().subtract(new Duration(days: 365));
Expect.listEquals(diffs, dmp.test_diff_bisect(a, b, deadline), 'diff_bisect: Timeout.');
}
@@ -523,10 +791,22 @@ void testDiffMain() {
diffs = [new Diff(Operation.equal, 'a'), new Diff(Operation.delete, '123'), new Diff(Operation.equal, 'bc')];
Expect.listEquals(diffs, dmp.diff_main('a123bc', 'abc', false), 'diff_main: Simple deletion.');
- diffs = [new Diff(Operation.equal, 'a'), new Diff(Operation.insert, '123'), new Diff(Operation.equal, 'b'), new Diff(Operation.insert, '456'), new Diff(Operation.equal, 'c')];
+ diffs = [
+ new Diff(Operation.equal, 'a'),
+ new Diff(Operation.insert, '123'),
+ new Diff(Operation.equal, 'b'),
+ new Diff(Operation.insert, '456'),
+ new Diff(Operation.equal, 'c')
+ ];
Expect.listEquals(diffs, dmp.diff_main('abc', 'a123b456c', false), 'diff_main: Two insertions.');
- diffs = [new Diff(Operation.equal, 'a'), new Diff(Operation.delete, '123'), new Diff(Operation.equal, 'b'), new Diff(Operation.delete, '456'), new Diff(Operation.equal, 'c')];
+ diffs = [
+ new Diff(Operation.equal, 'a'),
+ new Diff(Operation.delete, '123'),
+ new Diff(Operation.equal, 'b'),
+ new Diff(Operation.delete, '456'),
+ new Diff(Operation.equal, 'c')
+ ];
Expect.listEquals(diffs, dmp.diff_main('a123b456c', 'abc', false), 'diff_main: Two deletions.');
// Perform a real diff.
@@ -535,27 +815,67 @@ void testDiffMain() {
diffs = [new Diff(Operation.delete, 'a'), new Diff(Operation.insert, 'b')];
Expect.listEquals(diffs, dmp.diff_main('a', 'b', false), 'diff_main: Simple case #1.');
- diffs = [new Diff(Operation.delete, 'Apple'), new Diff(Operation.insert, 'Banana'), new Diff(Operation.equal, 's are a'), new Diff(Operation.insert, 'lso'), new Diff(Operation.equal, ' fruit.')];
- Expect.listEquals(diffs, dmp.diff_main('Apples are a fruit.', 'Bananas are also fruit.', false), 'diff_main: Simple case #2.');
-
- diffs = [new Diff(Operation.delete, 'a'), new Diff(Operation.insert, '\u0680'), new Diff(Operation.equal, 'x'), new Diff(Operation.delete, '\t'), new Diff(Operation.insert, '\000')];
+ diffs = [
+ new Diff(Operation.delete, 'Apple'),
+ new Diff(Operation.insert, 'Banana'),
+ new Diff(Operation.equal, 's are a'),
+ new Diff(Operation.insert, 'lso'),
+ new Diff(Operation.equal, ' fruit.')
+ ];
+ Expect.listEquals(
+ diffs, dmp.diff_main('Apples are a fruit.', 'Bananas are also fruit.', false), 'diff_main: Simple case #2.');
+
+ diffs = [
+ new Diff(Operation.delete, 'a'),
+ new Diff(Operation.insert, '\u0680'),
+ new Diff(Operation.equal, 'x'),
+ new Diff(Operation.delete, '\t'),
+ new Diff(Operation.insert, '\000')
+ ];
Expect.listEquals(diffs, dmp.diff_main('ax\t', '\u0680x\000', false), 'diff_main: Simple case #3.');
- diffs = [new Diff(Operation.delete, '1'), new Diff(Operation.equal, 'a'), new Diff(Operation.delete, 'y'), new Diff(Operation.equal, 'b'), new Diff(Operation.delete, '2'), new Diff(Operation.insert, 'xab')];
+ diffs = [
+ new Diff(Operation.delete, '1'),
+ new Diff(Operation.equal, 'a'),
+ new Diff(Operation.delete, 'y'),
+ new Diff(Operation.equal, 'b'),
+ new Diff(Operation.delete, '2'),
+ new Diff(Operation.insert, 'xab')
+ ];
Expect.listEquals(diffs, dmp.diff_main('1ayb2', 'abxab', false), 'diff_main: Overlap #1.');
diffs = [new Diff(Operation.insert, 'xaxcx'), new Diff(Operation.equal, 'abc'), new Diff(Operation.delete, 'y')];
Expect.listEquals(diffs, dmp.diff_main('abcy', 'xaxcxabc', false), 'diff_main: Overlap #2.');
- diffs = [new Diff(Operation.delete, 'ABCD'), new Diff(Operation.equal, 'a'), new Diff(Operation.delete, '='), new Diff(Operation.insert, '-'), new Diff(Operation.equal, 'bcd'), new Diff(Operation.delete, '='), new Diff(Operation.insert, '-'), new Diff(Operation.equal, 'efghijklmnopqrs'), new Diff(Operation.delete, 'EFGHIJKLMNOefg')];
- Expect.listEquals(diffs, dmp.diff_main('ABCDa=bcd=efghijklmnopqrsEFGHIJKLMNOefg', 'a-bcd-efghijklmnopqrs', false), 'diff_main: Overlap #3.');
-
- diffs = [new Diff(Operation.insert, ' '), new Diff(Operation.equal, 'a'), new Diff(Operation.insert, 'nd'), new Diff(Operation.equal, ' [[Pennsylvania]]'), new Diff(Operation.delete, ' and [[New')];
- Expect.listEquals(diffs, dmp.diff_main('a [[Pennsylvania]] and [[New', ' and [[Pennsylvania]]', false), 'diff_main: Large equality.');
-
- dmp.Diff_Timeout = 0.1; // 100ms
- String a = '`Twas brillig, and the slithy toves\nDid gyre and gimble in the wabe:\nAll mimsy were the borogoves,\nAnd the mome raths outgrabe.\n';
- String b = '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';
+ diffs = [
+ new Diff(Operation.delete, 'ABCD'),
+ new Diff(Operation.equal, 'a'),
+ new Diff(Operation.delete, '='),
+ new Diff(Operation.insert, '-'),
+ new Diff(Operation.equal, 'bcd'),
+ new Diff(Operation.delete, '='),
+ new Diff(Operation.insert, '-'),
+ new Diff(Operation.equal, 'efghijklmnopqrs'),
+ new Diff(Operation.delete, 'EFGHIJKLMNOefg')
+ ];
+ Expect.listEquals(diffs, dmp.diff_main('ABCDa=bcd=efghijklmnopqrsEFGHIJKLMNOefg', 'a-bcd-efghijklmnopqrs', false),
+ 'diff_main: Overlap #3.');
+
+ diffs = [
+ new Diff(Operation.insert, ' '),
+ new Diff(Operation.equal, 'a'),
+ new Diff(Operation.insert, 'nd'),
+ new Diff(Operation.equal, ' [[Pennsylvania]]'),
+ new Diff(Operation.delete, ' and [[New')
+ ];
+ Expect.listEquals(diffs, dmp.diff_main('a [[Pennsylvania]] and [[New', ' and [[Pennsylvania]]', false),
+ 'diff_main: Large equality.');
+
+ dmp.Diff_Timeout = 0.1; // 100ms
+ String a =
+ '`Twas brillig, and the slithy toves\nDid gyre and gimble in the wabe:\nAll mimsy were the borogoves,\nAnd the mome raths outgrabe.\n';
+ String b =
+ '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';
// Increase the text lengths by 1024 times to ensure a timeout.
for (int i = 0; i < 10; i++) {
a += a;
@@ -593,7 +913,6 @@ void testDiffMain() {
Expect.throws(() => dmp.diff_main(null, null), 'diff_main: Null inputs.');
}
-
// MATCH TEST FUNCTIONS
void testMatchAlphabet() {
@@ -641,12 +960,14 @@ void testMatchBitap() {
Expect.equals(8, dmp.test_match_bitap('abcdexyzabcde', 'abccde', 5), 'match_bitap: Multiple select #2.');
- dmp.Match_Distance = 10; // Strict location.
- Expect.equals(-1, dmp.test_match_bitap('abcdefghijklmnopqrstuvwxyz', 'abcdefg', 24), 'match_bitap: Distance test #1.');
+ dmp.Match_Distance = 10; // Strict location.
+ Expect.equals(
+ -1, dmp.test_match_bitap('abcdefghijklmnopqrstuvwxyz', 'abcdefg', 24), 'match_bitap: Distance test #1.');
- Expect.equals(0, dmp.test_match_bitap('abcdefghijklmnopqrstuvwxyz', 'abcdxxefg', 1), 'match_bitap: Distance test #2.');
+ Expect.equals(
+ 0, dmp.test_match_bitap('abcdefghijklmnopqrstuvwxyz', 'abcdxxefg', 1), 'match_bitap: Distance test #2.');
- dmp.Match_Distance = 1000; // Loose location.
+ dmp.Match_Distance = 1000; // Loose location.
Expect.equals(0, dmp.test_match_bitap('abcdefghijklmnopqrstuvwxyz', 'abcdefg', 24), 'match_bitap: Distance test #3.');
}
@@ -665,17 +986,16 @@ void testMatchMain() {
Expect.equals(0, dmp.match_main('abcdef', 'abcdefy', 0), 'match_main: Oversized pattern.');
dmp.Match_Threshold = 0.7;
- Expect.equals(4, dmp.match_main('I am the very model of a modern major general.', ' that berry ', 5), 'match_main: Complex match.');
+ Expect.equals(4, dmp.match_main('I am the very model of a modern major general.', ' that berry ', 5),
+ 'match_main: Complex match.');
dmp.Match_Threshold = 0.5;
// Test null inputs.
Expect.throws(() => dmp.match_main(null, null, 0), 'match_main: Null inputs.');
}
-
// PATCH TEST FUNCTIONS
-
void testPatchObj() {
// Patch Object.
Patch p = new Patch();
@@ -683,7 +1003,15 @@ void testPatchObj() {
p.start2 = 21;
p.length1 = 18;
p.length2 = 17;
- p.diffs = [new Diff(Operation.equal, 'jump'), new Diff(Operation.delete, 's'), new Diff(Operation.insert, 'ed'), new Diff(Operation.equal, ' over '), new Diff(Operation.delete, 'the'), new Diff(Operation.insert, 'a'), new Diff(Operation.equal, '\nlaz')];
+ p.diffs = [
+ new Diff(Operation.equal, 'jump'),
+ new Diff(Operation.delete, 's'),
+ new Diff(Operation.insert, 'ed'),
+ new Diff(Operation.equal, ' over '),
+ new Diff(Operation.delete, 'the'),
+ new Diff(Operation.insert, 'a'),
+ new Diff(Operation.equal, '\nlaz')
+ ];
String strp = '@@ -21,18 +22,17 @@\n jump\n-s\n+ed\n over \n-the\n+a\n %0Alaz\n';
Expect.equals(strp, p.toString(), 'Patch: toString.');
}
@@ -694,11 +1022,14 @@ void testPatchFromText() {
String strp = '@@ -21,18 +22,17 @@\n jump\n-s\n+ed\n over \n-the\n+a\n %0Alaz\n';
Expect.equals(strp, dmp.patch_fromText(strp)[0].toString(), 'patch_fromText: #1.');
- Expect.equals('@@ -1 +1 @@\n-a\n+b\n', dmp.patch_fromText('@@ -1 +1 @@\n-a\n+b\n')[0].toString(), 'patch_fromText: #2.');
+ Expect.equals(
+ '@@ -1 +1 @@\n-a\n+b\n', dmp.patch_fromText('@@ -1 +1 @@\n-a\n+b\n')[0].toString(), 'patch_fromText: #2.');
- Expect.equals('@@ -1,3 +0,0 @@\n-abc\n', dmp.patch_fromText('@@ -1,3 +0,0 @@\n-abc\n')[0].toString(), 'patch_fromText: #3.');
+ Expect.equals(
+ '@@ -1,3 +0,0 @@\n-abc\n', dmp.patch_fromText('@@ -1,3 +0,0 @@\n-abc\n')[0].toString(), 'patch_fromText: #3.');
- Expect.equals('@@ -0,0 +1,3 @@\n+abc\n', dmp.patch_fromText('@@ -0,0 +1,3 @@\n+abc\n')[0].toString(), 'patch_fromText: #4.');
+ Expect.equals(
+ '@@ -0,0 +1,3 @@\n+abc\n', dmp.patch_fromText('@@ -0,0 +1,3 @@\n+abc\n')[0].toString(), 'patch_fromText: #4.');
// Generates error.
Expect.throws(() => dmp.patch_fromText('Bad\nPatch\n'), 'patch_fromText: #5.');
@@ -720,19 +1051,23 @@ void testPatchAddContext() {
Patch p;
p = dmp.patch_fromText('@@ -21,4 +21,10 @@\n-jump\n+somersault\n')[0];
dmp.test_patch_addContext(p, 'The quick brown fox jumps over the lazy dog.');
- Expect.equals('@@ -17,12 +17,18 @@\n fox \n-jump\n+somersault\n s ov\n', p.toString(), 'patch_addContext: Simple case.');
+ Expect.equals(
+ '@@ -17,12 +17,18 @@\n fox \n-jump\n+somersault\n s ov\n', p.toString(), 'patch_addContext: Simple case.');
p = dmp.patch_fromText('@@ -21,4 +21,10 @@\n-jump\n+somersault\n')[0];
dmp.test_patch_addContext(p, 'The quick brown fox jumps.');
- Expect.equals('@@ -17,10 +17,16 @@\n fox \n-jump\n+somersault\n s.\n', p.toString(), 'patch_addContext: Not enough trailing context.');
+ Expect.equals('@@ -17,10 +17,16 @@\n fox \n-jump\n+somersault\n s.\n', p.toString(),
+ 'patch_addContext: Not enough trailing context.');
p = dmp.patch_fromText('@@ -3 +3,2 @@\n-e\n+at\n')[0];
dmp.test_patch_addContext(p, 'The quick brown fox jumps.');
- Expect.equals('@@ -1,7 +1,8 @@\n Th\n-e\n+at\n qui\n', p.toString(), 'patch_addContext: Not enough leading context.');
+ Expect.equals(
+ '@@ -1,7 +1,8 @@\n Th\n-e\n+at\n qui\n', p.toString(), 'patch_addContext: Not enough leading context.');
p = dmp.patch_fromText('@@ -3 +3,2 @@\n-e\n+at\n')[0];
dmp.test_patch_addContext(p, 'The quick brown fox jumps. The quick brown fox crashes.');
- Expect.equals('@@ -1,27 +1,28 @@\n Th\n-e\n+at\n quick brown fox jumps. \n', p.toString(), 'patch_addContext: Ambiguity.');
+ Expect.equals(
+ '@@ -1,27 +1,28 @@\n Th\n-e\n+at\n quick brown fox jumps. \n', p.toString(), 'patch_addContext: Ambiguity.');
}
void testPatchMake() {
@@ -742,12 +1077,14 @@ void testPatchMake() {
String text1 = 'The quick brown fox jumps over the lazy dog.';
String text2 = 'That quick brown fox jumped over a lazy dog.';
- String expectedPatch = '@@ -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';
+ String expectedPatch =
+ '@@ -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';
// The second patch must be '-21,17 +21,18', not '-22,17 +21,18' due to rolling context.
patches = dmp.patch_make(text2, text1);
Expect.equals(expectedPatch, dmp.patch_toText(patches), 'patch_make: Text2+Text1 inputs.');
- expectedPatch = '@@ -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';
+ expectedPatch =
+ '@@ -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';
patches = dmp.patch_make(text1, text2);
Expect.equals(expectedPatch, dmp.patch_toText(patches), 'patch_make: Text1+Text2 inputs.');
@@ -762,10 +1099,17 @@ void testPatchMake() {
Expect.equals(expectedPatch, dmp.patch_toText(patches), 'patch_make: Text1+Text2+Diff inputs (deprecated).');
patches = dmp.patch_make('`1234567890-=[]\\;\',./', '~!@#\$%^&*()_+{}|:"<>?');
- Expect.equals('@@ -1,21 +1,21 @@\n-%601234567890-=%5B%5D%5C;\',./\n+~!@#\$%25%5E&*()_+%7B%7D%7C:%22%3C%3E?\n', dmp.patch_toText(patches), 'patch_toText: Character encoding.');
+ Expect.equals('@@ -1,21 +1,21 @@\n-%601234567890-=%5B%5D%5C;\',./\n+~!@#\$%25%5E&*()_+%7B%7D%7C:%22%3C%3E?\n',
+ dmp.patch_toText(patches), 'patch_toText: Character encoding.');
diffs = [new Diff(Operation.delete, '`1234567890-=[]\\;\',./'), new Diff(Operation.insert, '~!@#\$%^&*()_+{}|:"<>?')];
- Expect.listEquals(diffs, dmp.patch_fromText('@@ -1,21 +1,21 @@\n-%601234567890-=%5B%5D%5C;\',./\n+~!@#\$%25%5E&*()_+%7B%7D%7C:%22%3C%3E?\n')[0].diffs, 'patch_fromText: Character decoding.');
+ Expect.listEquals(
+ diffs,
+ dmp
+ .patch_fromText(
+ '@@ -1,21 +1,21 @@\n-%601234567890-=%5B%5D%5C;\',./\n+~!@#\$%25%5E&*()_+%7B%7D%7C:%22%3C%3E?\n')[0]
+ .diffs,
+ 'patch_fromText: Character decoding.');
final sb = new StringBuffer();
for (int x = 0; x < 100; x++) {
@@ -784,22 +1128,34 @@ void testPatchMake() {
void testPatchSplitMax() {
// Assumes that Match_MaxBits is 32.
List<Patch> patches;
- patches = dmp.patch_make('abcdefghijklmnopqrstuvwxyz01234567890', 'XabXcdXefXghXijXklXmnXopXqrXstXuvXwxXyzX01X23X45X67X89X0');
+ patches = dmp.patch_make(
+ 'abcdefghijklmnopqrstuvwxyz01234567890', 'XabXcdXefXghXijXklXmnXopXqrXstXuvXwxXyzX01X23X45X67X89X0');
dmp.patch_splitMax(patches);
- Expect.equals('@@ -1,32 +1,46 @@\n+X\n ab\n+X\n cd\n+X\n ef\n+X\n gh\n+X\n ij\n+X\n kl\n+X\n mn\n+X\n op\n+X\n qr\n+X\n st\n+X\n uv\n+X\n wx\n+X\n yz\n+X\n 012345\n@@ -25,13 +39,18 @@\n zX01\n+X\n 23\n+X\n 45\n+X\n 67\n+X\n 89\n+X\n 0\n', dmp.patch_toText(patches), 'patch_splitMax: #1.');
+ Expect.equals(
+ '@@ -1,32 +1,46 @@\n+X\n ab\n+X\n cd\n+X\n ef\n+X\n gh\n+X\n ij\n+X\n kl\n+X\n mn\n+X\n op\n+X\n qr\n+X\n st\n+X\n uv\n+X\n wx\n+X\n yz\n+X\n 012345\n@@ -25,13 +39,18 @@\n zX01\n+X\n 23\n+X\n 45\n+X\n 67\n+X\n 89\n+X\n 0\n',
+ dmp.patch_toText(patches),
+ 'patch_splitMax: #1.');
- patches = dmp.patch_make('abcdef1234567890123456789012345678901234567890123456789012345678901234567890uvwxyz', 'abcdefuvwxyz');
+ patches = dmp.patch_make(
+ 'abcdef1234567890123456789012345678901234567890123456789012345678901234567890uvwxyz', 'abcdefuvwxyz');
String oldToText = dmp.patch_toText(patches);
dmp.patch_splitMax(patches);
Expect.equals(oldToText, dmp.patch_toText(patches), 'patch_splitMax: #2.');
patches = dmp.patch_make('1234567890123456789012345678901234567890123456789012345678901234567890', 'abc');
dmp.patch_splitMax(patches);
- Expect.equals('@@ -1,32 +1,4 @@\n-1234567890123456789012345678\n 9012\n@@ -29,32 +1,4 @@\n-9012345678901234567890123456\n 7890\n@@ -57,14 +1,3 @@\n-78901234567890\n+abc\n', dmp.patch_toText(patches), 'patch_splitMax: #3.');
+ Expect.equals(
+ '@@ -1,32 +1,4 @@\n-1234567890123456789012345678\n 9012\n@@ -29,32 +1,4 @@\n-9012345678901234567890123456\n 7890\n@@ -57,14 +1,3 @@\n-78901234567890\n+abc\n',
+ dmp.patch_toText(patches),
+ 'patch_splitMax: #3.');
- patches = dmp.patch_make('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');
+ patches = dmp.patch_make('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');
dmp.patch_splitMax(patches);
- Expect.equals('@@ -2,32 +2,32 @@\n bcdefghij , h : \n-0\n+1\n , t : 1 abcdef\n@@ -29,32 +29,32 @@\n bcdefghij , h : \n-0\n+1\n , t : 1 abcdef\n', dmp.patch_toText(patches), 'patch_splitMax: #4.');
+ Expect.equals(
+ '@@ -2,32 +2,32 @@\n bcdefghij , h : \n-0\n+1\n , t : 1 abcdef\n@@ -29,32 +29,32 @@\n bcdefghij , h : \n-0\n+1\n , t : 1 abcdef\n',
+ dmp.patch_toText(patches),
+ 'patch_splitMax: #4.');
}
void testPatchAddPadding() {
@@ -807,17 +1163,21 @@ void testPatchAddPadding() {
patches = dmp.patch_make('', 'test');
Expect.equals('@@ -0,0 +1,4 @@\n+test\n', dmp.patch_toText(patches), 'patch_addPadding: Both edges full.');
dmp.patch_addPadding(patches);
- Expect.equals('@@ -1,8 +1,12 @@\n %01%02%03%04\n+test\n %01%02%03%04\n', dmp.patch_toText(patches), 'patch_addPadding: Both edges full.');
+ Expect.equals('@@ -1,8 +1,12 @@\n %01%02%03%04\n+test\n %01%02%03%04\n', dmp.patch_toText(patches),
+ 'patch_addPadding: Both edges full.');
patches = dmp.patch_make('XY', 'XtestY');
Expect.equals('@@ -1,2 +1,6 @@\n X\n+test\n Y\n', dmp.patch_toText(patches), 'patch_addPadding: Both edges partial.');
dmp.patch_addPadding(patches);
- Expect.equals('@@ -2,8 +2,12 @@\n %02%03%04X\n+test\n Y%01%02%03\n', dmp.patch_toText(patches), 'patch_addPadding: Both edges partial.');
+ Expect.equals('@@ -2,8 +2,12 @@\n %02%03%04X\n+test\n Y%01%02%03\n', dmp.patch_toText(patches),
+ 'patch_addPadding: Both edges partial.');
patches = dmp.patch_make('XXXXYYYY', 'XXXXtestYYYY');
- Expect.equals('@@ -1,8 +1,12 @@\n XXXX\n+test\n YYYY\n', dmp.patch_toText(patches), 'patch_addPadding: Both edges none.');
+ Expect.equals(
+ '@@ -1,8 +1,12 @@\n XXXX\n+test\n YYYY\n', dmp.patch_toText(patches), 'patch_addPadding: Both edges none.');
dmp.patch_addPadding(patches);
- Expect.equals('@@ -5,8 +5,12 @@\n XXXX\n+test\n YYYY\n', dmp.patch_toText(patches), 'patch_addPadding: Both edges none.');
+ Expect.equals(
+ '@@ -5,8 +5,12 @@\n XXXX\n+test\n YYYY\n', dmp.patch_toText(patches), 'patch_addPadding: Both edges none.');
}
void testPatchApply() {
@@ -831,7 +1191,8 @@ void testPatchApply() {
String resultStr = '${results[0]}\t${boolArray.length}';
Expect.equals('Hello world.\t0', resultStr, 'patch_apply: Null case.');
- patches = dmp.patch_make('The quick brown fox jumps over the lazy dog.', 'That quick brown fox jumped over a lazy dog.');
+ patches =
+ dmp.patch_make('The quick brown fox jumps over the lazy dog.', 'That quick brown fox jumped over a lazy dog.');
results = dmp.patch_apply(patches, 'The quick brown fox jumps over the lazy dog.');
boolArray = results[1];
resultStr = '${results[0]}\t${boolArray[0]}\t${boolArray[1]}';
@@ -840,28 +1201,34 @@ void testPatchApply() {
results = dmp.patch_apply(patches, 'The quick red rabbit jumps over the tired tiger.');
boolArray = results[1];
resultStr = '${results[0]}\t${boolArray[0]}\t${boolArray[1]}';
- Expect.equals('That quick red rabbit jumped over a tired tiger.\ttrue\ttrue', resultStr, 'patch_apply: Partial match.');
+ Expect.equals(
+ 'That quick red rabbit jumped over a tired tiger.\ttrue\ttrue', resultStr, 'patch_apply: Partial match.');
results = dmp.patch_apply(patches, 'I am the very model of a modern major general.');
boolArray = results[1];
resultStr = '${results[0]}\t${boolArray[0]}\t${boolArray[1]}';
- Expect.equals('I am the very model of a modern major general.\tfalse\tfalse', resultStr, 'patch_apply: Failed match.');
+ Expect.equals(
+ 'I am the very model of a modern major general.\tfalse\tfalse', resultStr, 'patch_apply: Failed match.');
patches = dmp.patch_make('x1234567890123456789012345678901234567890123456789012345678901234567890y', 'xabcy');
- results = dmp.patch_apply(patches, 'x123456789012345678901234567890-----++++++++++-----123456789012345678901234567890y');
+ results =
+ dmp.patch_apply(patches, 'x123456789012345678901234567890-----++++++++++-----123456789012345678901234567890y');
boolArray = results[1];
resultStr = '${results[0]}\t${boolArray[0]}\t${boolArray[1]}';
Expect.equals('xabcy\ttrue\ttrue', resultStr, 'patch_apply: Big delete, small change.');
patches = dmp.patch_make('x1234567890123456789012345678901234567890123456789012345678901234567890y', 'xabcy');
- results = dmp.patch_apply(patches, 'x12345678901234567890---------------++++++++++---------------12345678901234567890y');
+ results =
+ dmp.patch_apply(patches, 'x12345678901234567890---------------++++++++++---------------12345678901234567890y');
boolArray = results[1];
resultStr = '${results[0]}\t${boolArray[0]}\t${boolArray[1]}';
- Expect.equals('xabc12345678901234567890---------------++++++++++---------------12345678901234567890y\tfalse\ttrue', resultStr, 'patch_apply: Big delete, big change 1.');
+ Expect.equals('xabc12345678901234567890---------------++++++++++---------------12345678901234567890y\tfalse\ttrue',
+ resultStr, 'patch_apply: Big delete, big change 1.');
dmp.Patch_DeleteThreshold = 0.6;
patches = dmp.patch_make('x1234567890123456789012345678901234567890123456789012345678901234567890y', 'xabcy');
- results = dmp.patch_apply(patches, 'x12345678901234567890---------------++++++++++---------------12345678901234567890y');
+ results =
+ dmp.patch_apply(patches, 'x12345678901234567890---------------++++++++++---------------12345678901234567890y');
boolArray = results[1];
resultStr = '${results[0]}\t${boolArray[0]}\t${boolArray[1]}';
Expect.equals('xabcy\ttrue\ttrue', resultStr, 'patch_apply: Big delete, big change 2.');
@@ -870,11 +1237,13 @@ void testPatchApply() {
// Compensate for failed patch.
dmp.Match_Threshold = 0.0;
dmp.Match_Distance = 0;
- patches = dmp.patch_make('abcdefghijklmnopqrstuvwxyz--------------------1234567890', 'abcXXXXXXXXXXdefghijklmnopqrstuvwxyz--------------------1234567YYYYYYYYYY890');
+ patches = dmp.patch_make('abcdefghijklmnopqrstuvwxyz--------------------1234567890',
+ 'abcXXXXXXXXXXdefghijklmnopqrstuvwxyz--------------------1234567YYYYYYYYYY890');
results = dmp.patch_apply(patches, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ--------------------1234567890');
boolArray = results[1];
resultStr = '${results[0]}\t${boolArray[0]}\t${boolArray[1]}';
- Expect.equals('ABCDEFGHIJKLMNOPQRSTUVWXYZ--------------------1234567YYYYYYYYYY890\tfalse\ttrue', resultStr, 'patch_apply: Compensate for failed patch.');
+ Expect.equals('ABCDEFGHIJKLMNOPQRSTUVWXYZ--------------------1234567YYYYYYYYYY890\tfalse\ttrue', resultStr,
+ 'patch_apply: Compensate for failed patch.');
dmp.Match_Threshold = 0.5;
dmp.Match_Distance = 1000;
diff --git a/dart/tests/Speedtest.dart b/dart/tests/Speedtest.dart
index 7fb565ae..7008f7ed 100644
--- a/dart/tests/Speedtest.dart
+++ b/dart/tests/Speedtest.dart
@@ -5,10 +5,10 @@ import '../DiffMatchPatch.dart';
// dart2js -O4 --out=Speedtest.dart.js Speedtest.dart
void launch(Event e) {
- HtmlElement input1 = document.getElementById('text1');
- HtmlElement input2 = document.getElementById('text2');
- String text1 = input1.text;
- String text2 = input2.text;
+ Element? input1 = document.getElementById('text1');
+ Element? input2 = document.getElementById('text2');
+ String? text1 = input1!.text;
+ String? text2 = input2!.text;
DiffMatchPatch dmp = new DiffMatchPatch();
dmp.Diff_Timeout = 0.0;
@@ -19,20 +19,18 @@ void launch(Event e) {
DateTime date_end = new DateTime.now();
var ds = dmp.diff_prettyHtml(d);
- document.getElementById('outputdiv').setInnerHtml(
- '$ds<BR>Time: ${date_end.difference(date_start)} (h:mm:ss.mmm)',
+ document.getElementById('outputdiv')!.setInnerHtml('$ds<BR>Time: ${date_end.difference(date_start)} (h:mm:ss.mmm)',
validator: new TrustedNodeValidator());
}
void main() {
- document.getElementById('launch').addEventListener('click', launch);
- document.getElementById('outputdiv').setInnerHtml('');
+ document.getElementById('launch')!.addEventListener('click', launch);
+ document.getElementById('outputdiv')!.setInnerHtml('');
}
/// A NodeValidator which allows any contents.
/// The default validator strips 'style' attributes.
class TrustedNodeValidator implements NodeValidator {
bool allowsElement(Element element) => true;
- bool allowsAttribute(Element element, String attributeName, String value)
- => true;
+ bool allowsAttribute(Element element, String attributeName, String value) => true;
}