rpm/musescore
SHA256
1
0
Fork 0
forked from pool/musescore
Code Pull Requests Activity
musescore/remove_diff_match_patch.diff
Cor Blom 357ffae805 - Add remove_diff_match_patch.diff to solve license conflict: it 
removes the Apache licensed diff_patch_match library.

OBS-URL: https://build.opensuse.org/package/show/multimedia:apps/musescore?expand=0&rev=3
2018-10-01 09:23:20 +00:00

4112 lines
149 KiB
Diff
Raw Blame History

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 08f8272a5..048911f96 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -648,7 +648,7 @@ ADD_CUSTOM_TARGET(mops2 DEPENDS ${PCH})
##
subdirs(
mscore awl bww2mxml share midi audiofile fluid mstyle libmscore synthesizer
- effects thirdparty/rtf2html thirdparty/diff thirdparty/beatroot
+ effects thirdparty/rtf2html thirdparty/beatroot
thirdparty/xmlstream thirdparty/qzip thirdparty/kQOAuth
)
string(TOUPPER "${CMAKE_BUILD_TYPE}" CMAKE_BUILD_TYPE)
diff --git a/mscore/CMakeLists.txt b/mscore/CMakeLists.txt
index 50379c567..4014c3471 100644
--- a/mscore/CMakeLists.txt
+++ b/mscore/CMakeLists.txt
@@ -303,7 +303,6 @@ add_executable ( ${ExecutableName}
target_link_libraries(mscore
awl
mstyle
- diff_match_patch
bww
rtf2html
${QTSINGLEAPPLICATION_LIBRARIES}
diff --git a/mscore/file.cpp b/mscore/file.cpp
index add6aef86..bb2922e16 100644
--- a/mscore/file.cpp
+++ b/mscore/file.cpp
@@ -81,7 +81,6 @@
#include "omr/importpdf.h"
#endif
-#include "diff/diff_match_patch.h"
#include "libmscore/chordlist.h"
#include "libmscore/mscore.h"
#include "thirdparty/qzip/qzipreader_p.h"
diff --git a/thirdparty/diff/CMakeLists.txt b/thirdparty/diff/CMakeLists.txt
deleted file mode 100644
index d0155b214..000000000
--- a/thirdparty/diff/CMakeLists.txt
+++ /dev/null
@@ -1,46 +0,0 @@
-#=============================================================================
-# MusE
-# Linux Music Editor
-# $Id:$
-#
-# Copyright (C) 2010 by Werner Schweer and others
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License version 2.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-#=============================================================================
-
-include (${PROJECT_SOURCE_DIR}/build/gch.cmake)
-
-if (APPLE)
- file(GLOB_RECURSE INCS "*.h")
-else (APPLE)
- set(INCS "")
-endif (APPLE)
-
-add_library(diff_match_patch STATIC
- diff_match_patch.cpp
- ${PROJECT_BINARY_DIR}/all.h
- ${PCH}
- ${INCS}
- )
-
-set_target_properties (
- diff_match_patch
- PROPERTIES
- COMPILE_FLAGS "${PCH_INCLUDE} -g -Wall -Wextra -Winvalid-pch"
- )
-
-xcode_pch(diff_match_patch all)
-
-ADD_DEPENDENCIES(diff_match_patch mops1)
-ADD_DEPENDENCIES(diff_match_patch mops2)
-
diff --git a/thirdparty/diff/README.txt b/thirdparty/diff/README.txt
deleted file mode 100644
index 6edd1bd6c..000000000
--- a/thirdparty/diff/README.txt
+++ /dev/null
@@ -1,11 +0,0 @@
-Diff, Match and Patch Library
-http://code.google.com/p/google-diff-match-patch/
-Neil Fraser
-
-C++: (ported by Mike Slemmer)
-* diff_match_patch.pro
-* diff_match_patch.h
-* diff_match_patch.cpp
-* diff_match_patch_test.h
-* diff_match_patch_test.cpp
-
diff --git a/thirdparty/diff/diff_match_patch.cpp b/thirdparty/diff/diff_match_patch.cpp
deleted file mode 100644
index 05dc61e8d..000000000
--- a/thirdparty/diff/diff_match_patch.cpp
+++ /dev/null
@@ -1,2077 +0,0 @@
-/*
- * Copyright 2008 Google Inc. All Rights Reserved.
- * Author: fraser@google.com (Neil Fraser)
- * Author: mikeslemmer@gmail.com (Mike Slemmer)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Diff Match and Patch
- * http://code.google.com/p/google-diff-match-patch/
- */
-
-#include <algorithm>
-#include <limits>
-// Code known to compile and run with Qt 4.3 through Qt 4.7.
-#include <time.h>
-#include "diff_match_patch.h"
-
-
-//////////////////////////
-//
-// Diff Class
-//
-//////////////////////////
-
-
-/**
- * Constructor. Initializes the diff with the provided values.
- * @param operation One of INSERT, DELETE or EQUAL
- * @param text The text being applied
- */
-Diff::Diff(Operation _operation, const QString &_text) :
- operation(_operation), text(_text) {
- // Construct a diff with the specified operation and text.
-}
-
-Diff::Diff() {
-}
-
-
-QString Diff::strOperation(Operation op) {
- switch (op) {
- case INSERT:
- return "INSERT";
- case DELETE:
- return "DELETE";
- case EQUAL:
- return "EQUAL";
- }
- throw "Invalid operation.";
-}
-
-/**
- * Display a human-readable version of this Diff.
- * @return text version
- */
-QString Diff::toString() const {
- QString prettyText = text;
- // Replace linebreaks with Pilcrow signs.
- prettyText.replace('\n', L'\u00b6');
- return QString("Diff(") + strOperation(operation) + QString(",\"")
- + prettyText + QString("\")");
-}
-
-/**
- * Is this Diff equivalent to another Diff?
- * @param d Another Diff to compare against
- * @return true or false
- */
-bool Diff::operator==(const Diff &d) const {
- return (d.operation == this->operation) && (d.text == this->text);
-}
-
-bool Diff::operator!=(const Diff &d) const {
- return !(operator == (d));
-}
-
-
-/////////////////////////////////////////////
-//
-// Patch Class
-//
-/////////////////////////////////////////////
-
-
-/**
- * Constructor. Initializes with an empty list of diffs.
- */
-Patch::Patch() :
- start1(0), start2(0),
- length1(0), length2(0) {
-}
-
-bool Patch::isNull() const {
- if (start1 == 0 && start2 == 0 && length1 == 0 && length2 == 0
- && diffs.size() == 0) {
- return true;
- }
- return false;
-}
-
-
-/**
- * Emmulate GNU diff's format.
- * Header: @@ -382,8 +481,9 @@
- * Indicies are printed as 1-based, not 0-based.
- * @return The GNU diff string
- */
-QString Patch::toString() {
- QString coords1, coords2;
- if (length1 == 0) {
- coords1 = QString::number(start1) + QString(",0");
- } else if (length1 == 1) {
- coords1 = QString::number(start1 + 1);
- } else {
- coords1 = QString::number(start1 + 1) + QString(",")
- + QString::number(length1);
- }
- if (length2 == 0) {
- coords2 = QString::number(start2) + QString(",0");
- } else if (length2 == 1) {
- coords2 = QString::number(start2 + 1);
- } else {
- coords2 = QString::number(start2 + 1) + QString(",")
- + QString::number(length2);
- }
- QString text;
- text = QString("@@ -") + coords1 + QString(" +") + coords2
- + QString(" @@\n");
- // Escape the body of the patch with %xx notation.
- foreach (Diff aDiff, diffs) {
- switch (aDiff.operation) {
- case INSERT:
- text += QString('+');
- break;
- case DELETE:
- text += QString('-');
- break;
- case EQUAL:
- text += QString(' ');
- break;
- }
- text += QString(QUrl::toPercentEncoding(aDiff.text, " !~*'();/?:@&=+$,#"))
- + QString("\n");
- }
-
- return text;
-}
-
-
-/////////////////////////////////////////////
-//
-// diff_match_patch Class
-//
-/////////////////////////////////////////////
-
-diff_match_patch::diff_match_patch() :
- Diff_Timeout(1.0f),
- Diff_EditCost(4),
- Match_Threshold(0.5f),
- Match_Distance(1000),
- Patch_DeleteThreshold(0.5f),
- Patch_Margin(4),
- Match_MaxBits(32) {
-}
-
-
-QList<Diff> diff_match_patch::diff_main(const QString &text1,
- const QString &text2) {
- return diff_main(text1, text2, true);
-}
-
-QList<Diff> diff_match_patch::diff_main(const QString &text1,
- const QString &text2, bool checklines) {
- // Set a deadline by which time the diff must be complete.
- clock_t deadline;
- if (Diff_Timeout <= 0) {
- deadline = std::numeric_limits<clock_t>::max();
- } else {
- deadline = clock() + (clock_t)(Diff_Timeout * CLOCKS_PER_SEC);
- }
- return diff_main(text1, text2, checklines, deadline);
-}
-
-QList<Diff> diff_match_patch::diff_main(const QString &text1,
- const QString &text2, bool checklines, clock_t deadline) {
- // Check for null inputs.
- if (text1.isNull() || text2.isNull()) {
- throw "Null inputs. (diff_main)";
- }
-
- // Check for equality (speedup).
- QList<Diff> diffs;
- if (text1 == text2) {
- if (!text1.isEmpty()) {
- diffs.append(Diff(EQUAL, text1));
- }
- return diffs;
- }
-
- // Trim off common prefix (speedup).
- int commonlength = diff_commonPrefix(text1, text2);
- const QString &commonprefix = text1.left(commonlength);
- QString textChopped1 = text1.mid(commonlength);
- QString textChopped2 = text2.mid(commonlength);
-
- // Trim off common suffix (speedup).
- commonlength = diff_commonSuffix(textChopped1, textChopped2);
- const QString &commonsuffix = textChopped1.right(commonlength);
- textChopped1 = textChopped1.left(textChopped1.length() - commonlength);
- textChopped2 = textChopped2.left(textChopped2.length() - commonlength);
-
- // Compute the diff on the middle block.
- diffs = diff_compute(textChopped1, textChopped2, checklines, deadline);
-
- // Restore the prefix and suffix.
- if (!commonprefix.isEmpty()) {
- diffs.prepend(Diff(EQUAL, commonprefix));
- }
- if (!commonsuffix.isEmpty()) {
- diffs.append(Diff(EQUAL, commonsuffix));
- }
-
- diff_cleanupMerge(diffs);
-
- return diffs;
-}
-
-
-QList<Diff> diff_match_patch::diff_compute(QString text1, QString text2,
- bool checklines, clock_t deadline) {
- QList<Diff> diffs;
-
- if (text1.isEmpty()) {
- // Just add some text (speedup).
- diffs.append(Diff(INSERT, text2));
- return diffs;
- }
-
- if (text2.isEmpty()) {
- // Just delete some text (speedup).
- diffs.append(Diff(DELETE, text1));
- return diffs;
- }
-
- {
- const QString longtext = text1.length() > text2.length() ? text1 : text2;
- const QString shorttext = text1.length() > text2.length() ? text2 : text1;
- const int i = longtext.indexOf(shorttext);
- if (i != -1) {
- // Shorter text is inside the longer text (speedup).
- const Operation op = (text1.length() > text2.length()) ? DELETE : INSERT;
- diffs.append(Diff(op, longtext.left(i)));
- diffs.append(Diff(EQUAL, shorttext));
- diffs.append(Diff(op, safeMid(longtext, i + shorttext.length())));
- return diffs;
- }
-
- if (shorttext.length() == 1) {
- // Single character string.
- // After the previous speedup, the character can't be an equality.
- diffs.append(Diff(DELETE, text1));
- diffs.append(Diff(INSERT, text2));
- return diffs;
- }
- // Garbage collect longtext and shorttext by scoping out.
- }
-
- // Check to see if the problem can be split in two.
- const QStringList hm = diff_halfMatch(text1, text2);
- if (hm.count() > 0) {
- // A half-match was found, sort out the return data.
- const QString text1_a = hm[0];
- const QString text1_b = hm[1];
- const QString text2_a = hm[2];
- const QString text2_b = hm[3];
- const QString mid_common = hm[4];
- // Send both pairs off for separate processing.
- const QList<Diff> diffs_a = diff_main(text1_a, text2_a,
- checklines, deadline);
- const QList<Diff> diffs_b = diff_main(text1_b, text2_b,
- checklines, deadline);
- // Merge the results.
- diffs = diffs_a;
- diffs.append(Diff(EQUAL, mid_common));
- diffs += diffs_b;
- return diffs;
- }
-
- // Perform a real diff.
- if (checklines && text1.length() > 100 && text2.length() > 100) {
- return diff_lineMode(text1, text2, deadline);
- }
-
- return diff_bisect(text1, text2, deadline);
-}
-
-
-QList<Diff> diff_match_patch::diff_lineMode(QString text1, QString text2,
- clock_t deadline) {
- // Scan the text on a line-by-line basis first.
- const QList<QVariant> b = diff_linesToChars(text1, text2);
- text1 = b[0].toString();
- text2 = b[1].toString();
- QStringList linearray = b[2].toStringList();
-
- QList<Diff> diffs = diff_main(text1, text2, false, deadline);
-
- // Convert the diff back to original text.
- diff_charsToLines(diffs, linearray);
- // Eliminate freak matches (e.g. blank lines)
- diff_cleanupSemantic(diffs);
-
- // Rediff any replacement blocks, this time character-by-character.
- // Add a dummy entry at the end.
- diffs.append(Diff(EQUAL, ""));
- int count_delete = 0;
- int count_insert = 0;
- QString text_delete = "";
- QString text_insert = "";
-
- QMutableListIterator<Diff> pointer(diffs);
- Diff *thisDiff = pointer.hasNext() ? &pointer.next() : NULL;
- while (thisDiff != NULL) {
- switch (thisDiff->operation) {
- case INSERT:
- count_insert++;
- text_insert += thisDiff->text;
- break;
- case DELETE:
- count_delete++;
- text_delete += thisDiff->text;
- break;
- case EQUAL:
- // Upon reaching an equality, check for prior redundancies.
- if (count_delete >= 1 && count_insert >= 1) {
- // Delete the offending records and add the merged ones.
- pointer.previous();
- for (int j = 0; j < count_delete + count_insert; j++) {
- pointer.previous();
- pointer.remove();
- }
- foreach(Diff newDiff,
- diff_main(text_delete, text_insert, false, deadline)) {
- pointer.insert(newDiff);
- }
- }
- count_insert = 0;
- count_delete = 0;
- text_delete = "";
- text_insert = "";
- break;
- }
- thisDiff = pointer.hasNext() ? &pointer.next() : NULL;
- }
- diffs.removeLast(); // Remove the dummy entry at the end.
-
- return diffs;
-}
-
-
-QList<Diff> diff_match_patch::diff_bisect(const QString &text1,
- const QString &text2, clock_t deadline) {
- // Cache the text lengths to prevent multiple calls.
- const int text1_length = text1.length();
- const int text2_length = text2.length();
- const int max_d = (text1_length + text2_length + 1) / 2;
- const int v_offset = max_d;
- const int v_length = 2 * max_d;
- int *v1 = new int[v_length];
- int *v2 = new int[v_length];
- for (int x = 0; x < v_length; x++) {
- v1[x] = -1;
- v2[x] = -1;
- }
- v1[v_offset + 1] = 0;
- v2[v_offset + 1] = 0;
- const int delta = text1_length - text2_length;
- // If the total number of characters is odd, then the front path will
- // collide with the reverse path.
- const bool front = (delta % 2 != 0);
- // Offsets for start and end of k loop.
- // Prevents mapping of space beyond the grid.
- int k1start = 0;
- int k1end = 0;
- int k2start = 0;
- int k2end = 0;
- for (int d = 0; d < max_d; d++) {
- // Bail out if deadline is reached.
- if (clock() > deadline) {
- break;
- }
-
- // Walk the front path one step.
- for (int k1 = -d + k1start; k1 <= d - k1end; k1 += 2) {
- const int k1_offset = v_offset + k1;
- int x1;
- if (k1 == -d || (k1 != d && v1[k1_offset - 1] < v1[k1_offset + 1])) {
- x1 = v1[k1_offset + 1];
- } else {
- x1 = v1[k1_offset - 1] + 1;
- }
- int y1 = x1 - k1;
- while (x1 < text1_length && y1 < text2_length
- && text1[x1] == text2[y1]) {
- x1++;
- y1++;
- }
- v1[k1_offset] = x1;
- if (x1 > text1_length) {
- // Ran off the right of the graph.
- k1end += 2;
- } else if (y1 > text2_length) {
- // Ran off the bottom of the graph.
- k1start += 2;
- } else if (front) {
- int k2_offset = v_offset + delta - k1;
- if (k2_offset >= 0 && k2_offset < v_length && v2[k2_offset] != -1) {
- // Mirror x2 onto top-left coordinate system.
- int x2 = text1_length - v2[k2_offset];
- if (x1 >= x2) {
- // Overlap detected.
- delete [] v1;
- delete [] v2;
- return diff_bisectSplit(text1, text2, x1, y1, deadline);
- }
- }
- }
- }
-
- // Walk the reverse path one step.
- for (int k2 = -d + k2start; k2 <= d - k2end; k2 += 2) {
- const int k2_offset = v_offset + k2;
- int x2;
- if (k2 == -d || (k2 != d && v2[k2_offset - 1] < v2[k2_offset + 1])) {
- x2 = v2[k2_offset + 1];
- } else {
- 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]) {
- x2++;
- y2++;
- }
- v2[k2_offset] = x2;
- if (x2 > text1_length) {
- // Ran off the left of the graph.
- k2end += 2;
- } else if (y2 > text2_length) {
- // Ran off the top of the graph.
- k2start += 2;
- } else if (!front) {
- int k1_offset = v_offset + delta - k2;
- if (k1_offset >= 0 && k1_offset < v_length && v1[k1_offset] != -1) {
- int x1 = v1[k1_offset];
- int y1 = v_offset + x1 - k1_offset;
- // Mirror x2 onto top-left coordinate system.
- x2 = text1_length - x2;
- if (x1 >= x2) {
- // Overlap detected.
- delete [] v1;
- delete [] v2;
- return diff_bisectSplit(text1, text2, x1, y1, deadline);
- }
- }
- }
- }
- }
- delete [] v1;
- delete [] v2;
- // Diff took too long and hit the deadline or
- // number of diffs equals number of characters, no commonality at all.
- QList<Diff> diffs;
- diffs.append(Diff(DELETE, text1));
- diffs.append(Diff(INSERT, text2));
- return diffs;
-}
-
-QList<Diff> diff_match_patch::diff_bisectSplit(const QString &text1,
- const QString &text2, int x, int y, clock_t deadline) {
- QString text1a = text1.left(x);
- QString text2a = text2.left(y);
- QString text1b = safeMid(text1, x);
- QString text2b = safeMid(text2, y);
-
- // Compute both diffs serially.
- QList<Diff> diffs = diff_main(text1a, text2a, false, deadline);
- QList<Diff> diffsb = diff_main(text1b, text2b, false, deadline);
-
- return diffs + diffsb;
-}
-
-QList<QVariant> diff_match_patch::diff_linesToChars(const QString &text1,
- const QString &text2) {
- QStringList lineArray;
- QMap<QString, int> lineHash;
- // e.g. linearray[4] == "Hello\n"
- // e.g. linehash.get("Hello\n") == 4
-
- // "\x00" is a valid character, but various debuggers don't like it.
- // So we'll insert a junk entry to avoid generating a null character.
- lineArray.append("");
-
- const QString chars1 = diff_linesToCharsMunge(text1, lineArray, lineHash);
- const QString chars2 = diff_linesToCharsMunge(text2, lineArray, lineHash);
-
- QList<QVariant> listRet;
- listRet.append(QVariant::fromValue(chars1));
- listRet.append(QVariant::fromValue(chars2));
- listRet.append(QVariant::fromValue(lineArray));
- return listRet;
-}
-
-
-QString diff_match_patch::diff_linesToCharsMunge(const QString &text,
- QStringList &lineArray,
- QMap<QString, int> &lineHash) {
- int lineStart = 0;
- int lineEnd = -1;
- QString line;
- QString chars;
- // Walk the text, pulling out a substring for each line.
- // text.split('\n') would would temporarily double our memory footprint.
- // Modifying text would create many large strings to garbage collect.
- while (lineEnd < text.length() - 1) {
- lineEnd = text.indexOf('\n', lineStart);
- if (lineEnd == -1) {
- lineEnd = text.length() - 1;
- }
- line = safeMid(text, lineStart, lineEnd + 1 - lineStart);
- lineStart = lineEnd + 1;
-
- if (lineHash.contains(line)) {
- chars += QChar(static_cast<ushort>(lineHash.value(line)));
- } else {
- lineArray.append(line);
- lineHash.insert(line, lineArray.size() - 1);
- chars += QChar(static_cast<ushort>(lineArray.size() - 1));
- }
- }
- return chars;
-}
-
-
-
-void diff_match_patch::diff_charsToLines(QList<Diff> &diffs,
- const QStringList &lineArray) {
- // Qt has no mutable foreach construct.
- QMutableListIterator<Diff> i(diffs);
- while (i.hasNext()) {
- Diff &diff = i.next();
- QString text;
- for (int y = 0; y < diff.text.length(); y++) {
- text += lineArray.value(static_cast<ushort>(diff.text[y].unicode()));
- }
- diff.text = text;
- }
-}
-
-
-int diff_match_patch::diff_commonPrefix(const QString &text1,
- const QString &text2) {
- // Performance analysis: http://neil.fraser.name/news/2007/10/09/
- const int n = std::min(text1.length(), text2.length());
- for (int i = 0; i < n; i++) {
- if (text1[i] != text2[i]) {
- return i;
- }
- }
- return n;
-}
-
-
-int diff_match_patch::diff_commonSuffix(const QString &text1,
- const QString &text2) {
- // Performance analysis: http://neil.fraser.name/news/2007/10/09/
- const int text1_length = text1.length();
- const int text2_length = text2.length();
- const int n = std::min(text1_length, text2_length);
- for (int i = 1; i <= n; i++) {
- if (text1[text1_length - i] != text2[text2_length - i]) {
- return i - 1;
- }
- }
- return n;
-}
-
-int diff_match_patch::diff_commonOverlap(const QString &text1,
- const QString &text2) {
- // Cache the text lengths to prevent multiple calls.
- const int text1_length = text1.length();
- const int text2_length = text2.length();
- // Eliminate the null case.
- if (text1_length == 0 || text2_length == 0) {
- return 0;
- }
- // Truncate the longer string.
- QString text1_trunc = text1;
- QString text2_trunc = text2;
- if (text1_length > text2_length) {
- text1_trunc = text1.right(text2_length);
- } else if (text1_length < text2_length) {
- text2_trunc = text2.left(text1_length);
- }
- const int text_length = std::min(text1_length, text2_length);
- // Quick check for the worst case.
- if (text1_trunc == text2_trunc) {
- return text_length;
- }
-
- // Start by looking for a single character match
- // and increase length until no match is found.
- // Performance analysis: http://neil.fraser.name/news/2010/11/04/
- int best = 0;
- int length = 1;
- while (true) {
- QString pattern = text1_trunc.right(length);
- int found = text2_trunc.indexOf(pattern);
- if (found == -1) {
- return best;
- }
- length += found;
- if (found == 0 || text1_trunc.right(length) == text2_trunc.left(length)) {
- best = length;
- length++;
- }
- }
-}
-
-QStringList diff_match_patch::diff_halfMatch(const QString &text1,
- const QString &text2) {
- if (Diff_Timeout <= 0) {
- // Don't risk returning a non-optimal diff if we have unlimited time.
- return QStringList();
- }
- const QString longtext = text1.length() > text2.length() ? text1 : text2;
- const QString shorttext = text1.length() > text2.length() ? text2 : text1;
- if (longtext.length() < 4 || shorttext.length() * 2 < longtext.length()) {
- return QStringList(); // Pointless.
- }
-
- // First check if the second quarter is the seed for a half-match.
- const QStringList hm1 = diff_halfMatchI(longtext, shorttext,
- (longtext.length() + 3) / 4);
- // Check again based on the third quarter.
- const QStringList hm2 = diff_halfMatchI(longtext, shorttext,
- (longtext.length() + 1) / 2);
- QStringList hm;
- if (hm1.isEmpty() && hm2.isEmpty()) {
- return QStringList();
- } else if (hm2.isEmpty()) {
- hm = hm1;
- } else if (hm1.isEmpty()) {
- hm = hm2;
- } else {
- // Both matched. Select the longest.
- hm = hm1[4].length() > hm2[4].length() ? hm1 : hm2;
- }
-
- // A half-match was found, sort out the return data.
- if (text1.length() > text2.length()) {
- return hm;
- } else {
- QStringList listRet;
- listRet << hm[2] << hm[3] << hm[0] << hm[1] << hm[4];
- return listRet;
- }
-}
-
-
-QStringList diff_match_patch::diff_halfMatchI(const QString &longtext,
- const QString &shorttext,
- int i) {
- // Start with a 1/4 length substring at position i as a seed.
- const QString seed = safeMid(longtext, i, longtext.length() / 4);
- int j = -1;
- QString best_common;
- QString best_longtext_a, best_longtext_b;
- QString best_shorttext_a, best_shorttext_b;
- while ((j = shorttext.indexOf(seed, j + 1)) != -1) {
- const int prefixLength = diff_commonPrefix(safeMid(longtext, i),
- safeMid(shorttext, j));
- const int suffixLength = diff_commonSuffix(longtext.left(i),
- shorttext.left(j));
- if (best_common.length() < suffixLength + prefixLength) {
- best_common = safeMid(shorttext, j - suffixLength, suffixLength)
- + safeMid(shorttext, j, prefixLength);
- best_longtext_a = longtext.left(i - suffixLength);
- best_longtext_b = safeMid(longtext, i + prefixLength);
- best_shorttext_a = shorttext.left(j - suffixLength);
- best_shorttext_b = safeMid(shorttext, j + prefixLength);
- }
- }
- if (best_common.length() * 2 >= longtext.length()) {
- QStringList listRet;
- listRet << best_longtext_a << best_longtext_b << best_shorttext_a
- << best_shorttext_b << best_common;
- return listRet;
- } else {
- return QStringList();
- }
-}
-
-
-void diff_match_patch::diff_cleanupSemantic(QList<Diff> &diffs) {
- if (diffs.isEmpty()) {
- return;
- }
- bool changes = false;
- QStack<Diff> equalities; // Stack of equalities.
- QString lastequality; // Always equal to equalities.lastElement().text
- QMutableListIterator<Diff> pointer(diffs);
- // Number of characters that changed prior to the equality.
- int length_insertions1 = 0;
- int length_deletions1 = 0;
- // Number of characters that changed after the equality.
- int length_insertions2 = 0;
- int length_deletions2 = 0;
- Diff *thisDiff = pointer.hasNext() ? &pointer.next() : NULL;
- while (thisDiff != NULL) {
- if (thisDiff->operation == EQUAL) {
- // Equality found.
- equalities.push(*thisDiff);
- length_insertions1 = length_insertions2;
- length_deletions1 = length_deletions2;
- length_insertions2 = 0;
- length_deletions2 = 0;
- lastequality = thisDiff->text;
- } else {
- // An insertion or deletion.
- if (thisDiff->operation == INSERT) {
- length_insertions2 += thisDiff->text.length();
- } else {
- length_deletions2 += thisDiff->text.length();
- }
- if (!lastequality.isNull()
- && (lastequality.length()
- <= std::max(length_insertions1, length_deletions1))
- && (lastequality.length()
- <= std::max(length_insertions2, length_deletions2))) {
- // printf("Splitting: '%s'\n", qPrintable(lastequality));
- // Walk back to offending equality.
- while (*thisDiff != equalities.top()) {
- thisDiff = &pointer.previous();
- }
- pointer.next();
-
- // Replace equality with a delete.
- pointer.setValue(Diff(DELETE, lastequality));
- // Insert a corresponding an insert.
- pointer.insert(Diff(INSERT, lastequality));
-
- equalities.pop(); // Throw away the equality we just deleted.
- if (!equalities.isEmpty()) {
- // Throw away the previous equality (it needs to be reevaluated).
- equalities.pop();
- }
- if (equalities.isEmpty()) {
- // There are no previous equalities, walk back to the start.
- while (pointer.hasPrevious()) {
- pointer.previous();
- }
- } else {
- // There is a safe equality we can fall back to.
- thisDiff = &equalities.top();
- while (*thisDiff != pointer.previous()) {
- // Intentionally empty loop.
- }
- }
-
- length_insertions1 = 0; // Reset the counters.
- length_deletions1 = 0;
- length_insertions2 = 0;
- length_deletions2 = 0;
- lastequality = QString();
- changes = true;
- }
- }
- thisDiff = pointer.hasNext() ? &pointer.next() : NULL;
- }
-
- // Normalize the diff.
- if (changes) {
- diff_cleanupMerge(diffs);
- }
- diff_cleanupSemanticLossless(diffs);
-
- // Find any overlaps between deletions and insertions.
- // e.g: <del>abcxx</del><ins>xxdef</ins>
- // -> <del>abc</del>xx<ins>def</ins>
- pointer.toFront();
- Diff *prevDiff = NULL;
- thisDiff = NULL;
- if (pointer.hasNext()) {
- prevDiff = &pointer.next();
- if (pointer.hasNext()) {
- thisDiff = &pointer.next();
- }
- }
- while (thisDiff != NULL) {
- if (prevDiff->operation == DELETE &&
- thisDiff->operation == INSERT) {
- QString deletion = prevDiff->text;
- QString insertion = thisDiff->text;
- int overlap_length = diff_commonOverlap(deletion, insertion);
- if (overlap_length != 0) {
- // Overlap found. Insert an equality and trim the surrounding edits.
- pointer.previous();
- pointer.insert(Diff(EQUAL, insertion.left(overlap_length)));
- prevDiff->text =
- deletion.left(deletion.length() - overlap_length);
- thisDiff->text = safeMid(insertion, overlap_length);
- // pointer.insert inserts the element before the cursor, so there is
- // no need to step past the new element.
- }
- thisDiff = pointer.hasNext() ? &pointer.next() : NULL;
- }
- prevDiff = thisDiff;
- thisDiff = pointer.hasNext() ? &pointer.next() : NULL;
- }
-}
-
-
-void diff_match_patch::diff_cleanupSemanticLossless(QList<Diff> &diffs) {
- QString equality1, edit, equality2;
- QString commonString;
- int commonOffset;
- int score, bestScore;
- QString bestEquality1, bestEdit, bestEquality2;
- // Create a new iterator at the start.
- QMutableListIterator<Diff> pointer(diffs);
- Diff *prevDiff = pointer.hasNext() ? &pointer.next() : NULL;
- Diff *thisDiff = pointer.hasNext() ? &pointer.next() : NULL;
- Diff *nextDiff = pointer.hasNext() ? &pointer.next() : NULL;
-
- // Intentionally ignore the first and last element (don't need checking).
- while (nextDiff != NULL) {
- if (prevDiff->operation == EQUAL &&
- nextDiff->operation == EQUAL) {
- // This is a single edit surrounded by equalities.
- equality1 = prevDiff->text;
- edit = thisDiff->text;
- equality2 = nextDiff->text;
-
- // First, shift the edit as far left as possible.
- commonOffset = diff_commonSuffix(equality1, edit);
- if (commonOffset != 0) {
- commonString = safeMid(edit, edit.length() - commonOffset);
- equality1 = equality1.left(equality1.length() - commonOffset);
- edit = commonString + edit.left(edit.length() - commonOffset);
- equality2 = commonString + equality2;
- }
-
- // Second, step character by character right, looking for the best fit.
- bestEquality1 = equality1;
- bestEdit = edit;
- bestEquality2 = equality2;
- bestScore = diff_cleanupSemanticScore(equality1, edit)
- + diff_cleanupSemanticScore(edit, equality2);
- while (!edit.isEmpty() && !equality2.isEmpty()
- && edit[0] == equality2[0]) {
- equality1 += edit[0];
- edit = safeMid(edit, 1) + equality2[0];
- equality2 = safeMid(equality2, 1);
- score = diff_cleanupSemanticScore(equality1, edit)
- + diff_cleanupSemanticScore(edit, equality2);
- // The >= encourages trailing rather than leading whitespace on edits.
- if (score >= bestScore) {
- bestScore = score;
- bestEquality1 = equality1;
- bestEdit = edit;
- bestEquality2 = equality2;
- }
- }
-
- if (prevDiff->text != bestEquality1) {
- // We have an improvement, save it back to the diff.
- if (!bestEquality1.isEmpty()) {
- prevDiff->text = bestEquality1;
- } else {
- pointer.previous(); // Walk past nextDiff.
- pointer.previous(); // Walk past thisDiff.
- pointer.previous(); // Walk past prevDiff.
- pointer.remove(); // Delete prevDiff.
- pointer.next(); // Walk past thisDiff.
- pointer.next(); // Walk past nextDiff.
- }
- thisDiff->text = bestEdit;
- if (!bestEquality2.isEmpty()) {
- nextDiff->text = bestEquality2;
- } else {
- pointer.remove(); // Delete nextDiff.
- nextDiff = thisDiff;
- thisDiff = prevDiff;
- }
- }
- }
- prevDiff = thisDiff;
- thisDiff = nextDiff;
- nextDiff = pointer.hasNext() ? &pointer.next() : NULL;
- }
-}
-
-
-int diff_match_patch::diff_cleanupSemanticScore(const QString &one,
- const QString &two) {
- if (one.isEmpty() || two.isEmpty()) {
- // Edges are the best.
- return 10;
- }
-
- // Each port of this function behaves slightly differently due to
- // subtle differences in each language's definition of things like
- // 'whitespace'. Since this function's purpose is largely cosmetic,
- // the choice has been made to use each language's native features
- // rather than force total conformity.
- int score = 0;
- // One point for non-alphanumeric.
- if (!one[one.length() - 1].isLetterOrNumber()
- || !two[0].isLetterOrNumber()) {
- score++;
- // Two points for whitespace.
- if (one[one.length() - 1].isSpace() || two[0].isSpace()) {
- score++;
- // Three points for line breaks.
- if (one[one.length() - 1].category() == QChar::Other_Control
- || two[0].category() == QChar::Other_Control) {
- score++;
- // Four points for blank lines.
- QRegExp blankLineEnd("\\n\\r?\\n$");
- QRegExp blankLineStart("^\\r?\\n\\r?\\n");
- if (blankLineEnd.indexIn(one) != -1
- || blankLineStart.indexIn(two) != -1) {
- score++;
- }
- }
- }
- }
- return score;
-}
-
-
-void diff_match_patch::diff_cleanupEfficiency(QList<Diff> &diffs) {
- if (diffs.isEmpty()) {
- return;
- }
- bool changes = false;
- QStack<Diff> equalities; // Stack of equalities.
- QString lastequality; // Always equal to equalities.lastElement().text
- QMutableListIterator<Diff> pointer(diffs);
- // Is there an insertion operation before the last equality.
- bool pre_ins = false;
- // Is there a deletion operation before the last equality.
- bool pre_del = false;
- // Is there an insertion operation after the last equality.
- bool post_ins = false;
- // Is there a deletion operation after the last equality.
- bool post_del = false;
-
- Diff *thisDiff = pointer.hasNext() ? &pointer.next() : NULL;
- Diff *safeDiff = thisDiff;
-
- while (thisDiff != NULL) {
- if (thisDiff->operation == EQUAL) {
- // Equality found.
- if (thisDiff->text.length() < Diff_EditCost && (post_ins || post_del)) {
- // Candidate found.
- equalities.push(*thisDiff);
- pre_ins = post_ins;
- pre_del = post_del;
- lastequality = thisDiff->text;
- } else {
- // Not a candidate, and can never become one.
- equalities.clear();
- lastequality = QString();
- safeDiff = thisDiff;
- }
- post_ins = post_del = false;
- } else {
- // An insertion or deletion.
- if (thisDiff->operation == DELETE) {
- post_del = true;
- } else {
- post_ins = true;
- }
- /*
- * Five types to be split:
- * <ins>A</ins><del>B</del>XY<ins>C</ins><del>D</del>
- * <ins>A</ins>X<ins>C</ins><del>D</del>
- * <ins>A</ins><del>B</del>X<ins>C</ins>
- * <ins>A</del>X<ins>C</ins><del>D</del>
- * <ins>A</ins><del>B</del>X<del>C</del>
- */
- if (!lastequality.isNull()
- && ((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))) {
- // printf("Splitting: '%s'\n", qPrintable(lastequality));
- // Walk back to offending equality.
- while (*thisDiff != equalities.top()) {
- thisDiff = &pointer.previous();
- }
- pointer.next();
-
- // Replace equality with a delete.
- pointer.setValue(Diff(DELETE, lastequality));
- // Insert a corresponding an insert.
- pointer.insert(Diff(INSERT, lastequality));
- thisDiff = &pointer.previous();
- pointer.next();
-
- equalities.pop(); // Throw away the equality we just deleted.
- lastequality = QString();
- if (pre_ins && pre_del) {
- // No changes made which could affect previous entry, keep going.
- post_ins = post_del = true;
- equalities.clear();
- safeDiff = thisDiff;
- } else {
- if (!equalities.isEmpty()) {
- // Throw away the previous equality (it needs to be reevaluated).
- equalities.pop();
- }
- if (equalities.isEmpty()) {
- // There are no previous questionable equalities,
- // walk back to the last known safe diff.
- thisDiff = safeDiff;
- } else {
- // There is an equality we can fall back to.
- thisDiff = &equalities.top();
- }
- while (*thisDiff != pointer.previous()) {
- // Intentionally empty loop.
- }
- post_ins = post_del = false;
- }
-
- changes = true;
- }
- }
- thisDiff = pointer.hasNext() ? &pointer.next() : NULL;
- }
-
- if (changes) {
- diff_cleanupMerge(diffs);
- }
-}
-
-
-void diff_match_patch::diff_cleanupMerge(QList<Diff> &diffs) {
- diffs.append(Diff(EQUAL, "")); // Add a dummy entry at the end.
- QMutableListIterator<Diff> pointer(diffs);
- int count_delete = 0;
- int count_insert = 0;
- QString text_delete = "";
- QString text_insert = "";
- Diff *thisDiff = pointer.hasNext() ? &pointer.next() : NULL;
- Diff *prevEqual = NULL;
- int commonlength;
- while (thisDiff != NULL) {
- switch (thisDiff->operation) {
- case INSERT:
- count_insert++;
- text_insert += thisDiff->text;
- prevEqual = NULL;
- break;
- case DELETE:
- count_delete++;
- text_delete += thisDiff->text;
- prevEqual = NULL;
- break;
- case EQUAL:
- if (count_delete + count_insert > 1) {
- bool both_types = count_delete != 0 && count_insert != 0;
- // Delete the offending records.
- pointer.previous(); // Reverse direction.
- while (count_delete-- > 0) {
- pointer.previous();
- pointer.remove();
- }
- while (count_insert-- > 0) {
- pointer.previous();
- pointer.remove();
- }
- if (both_types) {
- // Factor out any common prefixies.
- commonlength = diff_commonPrefix(text_insert, text_delete);
- if (commonlength != 0) {
- if (pointer.hasPrevious()) {
- thisDiff = &pointer.previous();
- if (thisDiff->operation != EQUAL) {
- throw "Previous diff should have been an equality.";
- }
- thisDiff->text += text_insert.left(commonlength);
- pointer.next();
- } else {
- pointer.insert(Diff(EQUAL, text_insert.left(commonlength)));
- }
- text_insert = safeMid(text_insert, commonlength);
- text_delete = safeMid(text_delete, commonlength);
- }
- // Factor out any common suffixies.
- commonlength = diff_commonSuffix(text_insert, text_delete);
- if (commonlength != 0) {
- thisDiff = &pointer.next();
- thisDiff->text = safeMid(text_insert, text_insert.length()
- - commonlength) + thisDiff->text;
- text_insert = text_insert.left(text_insert.length()
- - commonlength);
- text_delete = text_delete.left(text_delete.length()
- - commonlength);
- pointer.previous();
- }
- }
- // Insert the merged records.
- if (!text_delete.isEmpty()) {
- pointer.insert(Diff(DELETE, text_delete));
- }
- if (!text_insert.isEmpty()) {
- pointer.insert(Diff(INSERT, text_insert));
- }
- // Step forward to the equality.
- thisDiff = pointer.hasNext() ? &pointer.next() : NULL;
-
- } else if (prevEqual != NULL) {
- // Merge this equality with the previous one.
- prevEqual->text += thisDiff->text;
- pointer.remove();
- thisDiff = &pointer.previous();
- pointer.next(); // Forward direction
- }
- count_insert = 0;
- count_delete = 0;
- text_delete = "";
- text_insert = "";
- prevEqual = thisDiff;
- break;
- }
- thisDiff = pointer.hasNext() ? &pointer.next() : NULL;
- }
- if (diffs.back().text.isEmpty()) {
- diffs.removeLast(); // Remove the dummy entry at the end.
- }
-
- /*
- * Second pass: look for single edits surrounded on both sides by equalities
- * which can be shifted sideways to eliminate an equality.
- * e.g: A<ins>BA</ins>C -> <ins>AB</ins>AC
- */
- bool changes = false;
- // Create a new iterator at the start.
- // (As opposed to walking the current one back.)
- pointer.toFront();
- Diff *prevDiff = pointer.hasNext() ? &pointer.next() : NULL;
- thisDiff = pointer.hasNext() ? &pointer.next() : NULL;
- Diff *nextDiff = pointer.hasNext() ? &pointer.next() : NULL;
-
- // Intentionally ignore the first and last element (don't need checking).
- while (nextDiff != NULL) {
- if (prevDiff->operation == EQUAL &&
- nextDiff->operation == EQUAL) {
- // This is a single edit surrounded by equalities.
- if (thisDiff->text.endsWith(prevDiff->text)) {
- // Shift the edit over the previous equality.
- thisDiff->text = prevDiff->text
- + thisDiff->text.left(thisDiff->text.length()
- - prevDiff->text.length());
- nextDiff->text = prevDiff->text + nextDiff->text;
- pointer.previous(); // Walk past nextDiff.
- pointer.previous(); // Walk past thisDiff.
- pointer.previous(); // Walk past prevDiff.
- pointer.remove(); // Delete prevDiff.
- pointer.next(); // Walk past thisDiff.
- thisDiff = &pointer.next(); // Walk past nextDiff.
- nextDiff = pointer.hasNext() ? &pointer.next() : NULL;
- changes = true;
- } else if (thisDiff->text.startsWith(nextDiff->text)) {
- // Shift the edit over the next equality.
- prevDiff->text += nextDiff->text;
- thisDiff->text = safeMid(thisDiff->text, nextDiff->text.length())
- + nextDiff->text;
- pointer.remove(); // Delete nextDiff.
- nextDiff = pointer.hasNext() ? &pointer.next() : NULL;
- changes = true;
- }
- }
- prevDiff = thisDiff;
- thisDiff = nextDiff;
- nextDiff = pointer.hasNext() ? &pointer.next() : NULL;
- }
- // If shifts were made, the diff needs reordering and another shift sweep.
- if (changes) {
- diff_cleanupMerge(diffs);
- }
-}
-
-
-int diff_match_patch::diff_xIndex(const QList<Diff> &diffs, int loc) {
- int chars1 = 0;
- int chars2 = 0;
- int last_chars1 = 0;
- int last_chars2 = 0;
- Diff lastDiff;
- foreach(Diff aDiff, diffs) {
- if (aDiff.operation != INSERT) {
- // Equality or deletion.
- chars1 += aDiff.text.length();
- }
- if (aDiff.operation != DELETE) {
- // Equality or insertion.
- chars2 += aDiff.text.length();
- }
- if (chars1 > loc) {
- // Overshot the location.
- lastDiff = aDiff;
- break;
- }
- last_chars1 = chars1;
- last_chars2 = chars2;
- }
- if (lastDiff.operation == DELETE) {
- // The location was deleted.
- return last_chars2;
- }
- // Add the remaining character length.
- return last_chars2 + (loc - last_chars1);
-}
-
-
-QString diff_match_patch::diff_prettyHtml(const QList<Diff> &diffs) {
- QString html;
- QString text;
- int i = 0;
- foreach(Diff aDiff, diffs) {
- text = aDiff.text;
- text.replace("&", "&amp;").replace("<", "&lt;")
- .replace(">", "&gt;").replace("\n", "&para;<br/>");
- switch (aDiff.operation) {
- case INSERT:
- html += QString("<ins style=\"background:#e6ffe6;\">") + text
- + QString("</ins>");
- break;
- case DELETE:
- html += QString("<del style=\"background:#ffe6e6;\">") + text
- + QString("</del>");
- break;
- case EQUAL:
- html += QString("<span>") + text + QString("</span>");
- break;
- }
- if (aDiff.operation != DELETE) {
- i += aDiff.text.length();
- }
- }
- return html;
-}
-
-
-QString diff_match_patch::diff_text1(const QList<Diff> &diffs) {
- QString text;
- foreach(Diff aDiff, diffs) {
- if (aDiff.operation != INSERT) {
- text += aDiff.text;
- }
- }
- return text;
-}
-
-
-QString diff_match_patch::diff_text2(const QList<Diff> &diffs) {
- QString text;
- foreach(Diff aDiff, diffs) {
- if (aDiff.operation != DELETE) {
- text += aDiff.text;
- }
- }
- return text;
-}
-
-
-int diff_match_patch::diff_levenshtein(const QList<Diff> &diffs) {
- int levenshtein = 0;
- int insertions = 0;
- int deletions = 0;
- foreach(Diff aDiff, diffs) {
- switch (aDiff.operation) {
- case INSERT:
- insertions += aDiff.text.length();
- break;
- case DELETE:
- deletions += aDiff.text.length();
- break;
- case EQUAL:
- // A deletion and an insertion is one substitution.
- levenshtein += std::max(insertions, deletions);
- insertions = 0;
- deletions = 0;
- break;
- }
- }
- levenshtein += std::max(insertions, deletions);
- return levenshtein;
-}
-
-
-QString diff_match_patch::diff_toDelta(const QList<Diff> &diffs) {
- QString text;
- foreach(Diff aDiff, diffs) {
- switch (aDiff.operation) {
- case INSERT: {
- QString encoded = QString(QUrl::toPercentEncoding(aDiff.text,
- " !~*'();/?:@&=+$,#"));
- text += QString("+") + encoded + QString("\t");
- break;
- }
- case DELETE:
- text += QString("-") + QString::number(aDiff.text.length())
- + QString("\t");
- break;
- case EQUAL:
- text += QString("=") + QString::number(aDiff.text.length())
- + QString("\t");
- break;
- }
- }
- if (!text.isEmpty()) {
- // Strip off trailing tab character.
- text = text.left(text.length() - 1);
- }
- return text;
-}
-
-
-QList<Diff> diff_match_patch::diff_fromDelta(const QString &text1,
- const QString &delta) {
- QList<Diff> diffs;
- int pointer = 0; // Cursor in text1
- QStringList tokens = delta.split("\t");
- foreach(QString token, tokens) {
- if (token.isEmpty()) {
- // Blank tokens are ok (from a trailing \t).
- continue;
- }
- // Each token begins with a one character parameter which specifies the
- // operation of this token (delete, insert, equality).
- QString param = safeMid(token, 1);
- switch (token[0].toLatin1()) {
- case '+':
- param = QUrl::fromPercentEncoding(qPrintable(param));
- diffs.append(Diff(INSERT, param));
- break;
- case '-':
- // Fall through.
- case '=': {
- int n;
- n = param.toInt();
- if (n < 0) {
- throw QString("Negative number in diff_fromDelta: %1").arg(param);
- }
- QString text;
- text = safeMid(text1, pointer, n);
- pointer += n;
- if (token[0] == QChar('=')) {
- diffs.append(Diff(EQUAL, text));
- } else {
- diffs.append(Diff(DELETE, text));
- }
- break;
- }
- default:
- throw QString("Invalid diff operation in diff_fromDelta: %1")
- .arg(token[0]);
- }
- }
- if (pointer != text1.length()) {
- throw QString("Delta length (%1) smaller than source text length (%2)")
- .arg(pointer).arg(text1.length());
- }
- return diffs;
-}
-
-
- // MATCH FUNCTIONS
-
-
-int diff_match_patch::match_main(const QString &text, const QString &pattern,
- int loc) {
- // Check for null inputs.
- if (text.isNull() || pattern.isNull()) {
- throw "Null inputs. (match_main)";
- }
-
- loc = std::max(0, std::min(loc, text.length()));
- if (text == pattern) {
- // Shortcut (potentially not guaranteed by the algorithm)
- return 0;
- } else if (text.isEmpty()) {
- // Nothing to match.
- return -1;
- } else if (loc + pattern.length() <= text.length()
- && safeMid(text, loc, pattern.length()) == pattern) {
- // Perfect match at the perfect spot! (Includes case of null pattern)
- return loc;
- } else {
- // Do a fuzzy compare.
- return match_bitap(text, pattern, loc);
- }
-}
-
-
-int diff_match_patch::match_bitap(const QString &text, const QString &pattern,
- int loc) {
- if (!(Match_MaxBits == 0 || pattern.length() <= Match_MaxBits)) {
- throw "Pattern too long for this application.";
- }
-
- // Initialise the alphabet.
- QMap<QChar, int> s = match_alphabet(pattern);
-
- // Highest score beyond which we give up.
- double score_threshold = Match_Threshold;
- // Is there a nearby exact match? (speedup)
- int best_loc = text.indexOf(pattern, loc);
- if (best_loc != -1) {
- score_threshold = std::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 = std::min(match_bitapScore(0, best_loc, loc, pattern),
- score_threshold);
- }
- }
-
- // Initialise the bit arrays.
- int matchmask = 1 << (pattern.length() - 1);
- best_loc = -1;
-
- int bin_min, bin_mid;
- int bin_max = pattern.length() + text.length();
- int *rd = NULL;
- int *last_rd = NULL;
- 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
- // this error level.
- bin_min = 0;
- bin_mid = bin_max;
- while (bin_min < bin_mid) {
- if (match_bitapScore(d, loc + bin_mid, loc, pattern)
- <= score_threshold) {
- bin_min = bin_mid;
- } else {
- bin_max = bin_mid;
- }
- bin_mid = (bin_max - bin_min) / 2 + bin_min;
- }
- // Use the result from this iteration as the maximum for the next.
- bin_max = bin_mid;
- int start = std::max(1, loc - bin_mid + 1);
- int finish = std::min(loc + bin_mid, text.length()) + pattern.length();
-
- rd = new int[finish + 2];
- rd[finish + 1] = (1 << d) - 1;
- for (int j = finish; j >= start; j--) {
- int charMatch;
- if (text.length() <= j - 1) {
- // Out of range.
- charMatch = 0;
- } else {
- charMatch = s.value(text[j - 1], 0);
- }
- 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];
- }
- if ((rd[j] & matchmask) != 0) {
- double score = match_bitapScore(d, j - 1, loc, pattern);
- // This match will almost certainly be better than any existing
- // match. But check anyway.
- if (score <= score_threshold) {
- // Told you so.
- score_threshold = score;
- best_loc = j - 1;
- if (best_loc > loc) {
- // When passing loc, don't exceed our current distance from loc.
- start = std::max(1, 2 * loc - best_loc);
- } else {
- // Already passed loc, downhill from here on in.
- break;
- }
- }
- }
- }
- if (match_bitapScore(d + 1, loc, loc, pattern) > score_threshold) {
- // No hope for a (better) match at greater error levels.
- break;
- }
- delete [] last_rd;
- last_rd = rd;
- }
- delete [] last_rd;
- delete [] rd;
- return best_loc;
-}
-
-
-double diff_match_patch::match_bitapScore(int e, int x, int loc,
- const QString &pattern) {
- const float accuracy = static_cast<float> (e) / pattern.length();
- const int proximity = qAbs(loc - x);
- if (Match_Distance == 0) {
- // Dodge divide by zero error.
- return proximity == 0 ? accuracy : 1.0;
- }
- return accuracy + (proximity / static_cast<float> (Match_Distance));
-}
-
-
-QMap<QChar, int> diff_match_patch::match_alphabet(const QString &pattern) {
- QMap<QChar, int> s;
- int i;
- for (i = 0; i < pattern.length(); i++) {
- QChar c = pattern[i];
- s.insert(c, 0);
- }
- for (i = 0; i < pattern.length(); i++) {
- QChar c = pattern[i];
- s.insert(c, s.value(c) | (1 << (pattern.length() - i - 1)));
- }
- return s;
-}
-
-
-// PATCH FUNCTIONS
-
-
-void diff_match_patch::patch_addContext(Patch &patch, const QString &text) {
- if (text.isEmpty()) {
- return;
- }
- QString pattern = safeMid(text, patch.start2, patch.length1);
- int padding = 0;
-
- // Look for the first and last matches of pattern in text. If two different
- // matches are found, increase the pattern length.
- while (text.indexOf(pattern) != text.lastIndexOf(pattern)
- && pattern.length() < Match_MaxBits - Patch_Margin - Patch_Margin) {
- padding += Patch_Margin;
- pattern = safeMid(text, std::max(0, patch.start2 - padding),
- std::min(text.length(), patch.start2 + patch.length1 + padding)
- - std::max(0, patch.start2 - padding));
- }
- // Add one chunk for good luck.
- padding += Patch_Margin;
-
- // Add the prefix.
- QString prefix = safeMid(text, std::max(0, patch.start2 - padding),
- patch.start2 - std::max(0, patch.start2 - padding));
- if (!prefix.isEmpty()) {
- patch.diffs.prepend(Diff(EQUAL, prefix));
- }
- // Add the suffix.
- QString suffix = safeMid(text, patch.start2 + patch.length1,
- std::min(text.length(), patch.start2 + patch.length1 + padding)
- - (patch.start2 + patch.length1));
- if (!suffix.isEmpty()) {
- patch.diffs.append(Diff(EQUAL, suffix));
- }
-
- // Roll back the start points.
- patch.start1 -= prefix.length();
- patch.start2 -= prefix.length();
- // Extend the lengths.
- patch.length1 += prefix.length() + suffix.length();
- patch.length2 += prefix.length() + suffix.length();
-}
-
-
-QList<Patch> diff_match_patch::patch_make(const QString &text1,
- const QString &text2) {
- // Check for null inputs.
- if (text1.isNull() || text2.isNull()) {
- throw "Null inputs. (patch_make)";
- }
-
- // No diffs provided, compute our own.
- QList<Diff> diffs = diff_main(text1, text2, true);
- if (diffs.size() > 2) {
- diff_cleanupSemantic(diffs);
- diff_cleanupEfficiency(diffs);
- }
-
- return patch_make(text1, diffs);
-}
-
-
-QList<Patch> diff_match_patch::patch_make(const QList<Diff> &diffs) {
- // No origin string provided, compute our own.
- const QString text1 = diff_text1(diffs);
- return patch_make(text1, diffs);
-}
-
-
-QList<Patch> diff_match_patch::patch_make(const QString &text1,
- const QString &text2,
- const QList<Diff> &diffs) {
- // text2 is entirely unused.
- return patch_make(text1, diffs);
-
- Q_UNUSED(text2)
-}
-
-
-QList<Patch> diff_match_patch::patch_make(const QString &text1,
- const QList<Diff> &diffs) {
- // Check for null inputs.
- if (text1.isNull()) {
- throw "Null inputs. (patch_make)";
- }
-
- QList<Patch> patches;
- if (diffs.isEmpty()) {
- return patches; // Get rid of the null case.
- }
- Patch patch;
- int char_count1 = 0; // Number of characters into the text1 string.
- int char_count2 = 0; // Number of characters into the text2 string.
- // Start with text1 (prepatch_text) and apply the diffs until we arrive at
- // text2 (postpatch_text). We recreate the patches one by one to determine
- // context info.
- QString prepatch_text = text1;
- QString postpatch_text = text1;
- foreach(Diff aDiff, diffs) {
- if (patch.diffs.isEmpty() && aDiff.operation != EQUAL) {
- // A new patch starts here.
- patch.start1 = char_count1;
- patch.start2 = char_count2;
- }
-
- switch (aDiff.operation) {
- case INSERT:
- patch.diffs.append(aDiff);
- patch.length2 += aDiff.text.length();
- postpatch_text = postpatch_text.left(char_count2)
- + aDiff.text + safeMid(postpatch_text, char_count2);
- break;
- case DELETE:
- patch.length1 += aDiff.text.length();
- patch.diffs.append(aDiff);
- postpatch_text = postpatch_text.left(char_count2)
- + safeMid(postpatch_text, char_count2 + aDiff.text.length());
- break;
- case EQUAL:
- if (aDiff.text.length() <= 2 * Patch_Margin
- && !patch.diffs.isEmpty() && !(aDiff == diffs.back())) {
- // Small equality inside a patch.
- patch.diffs.append(aDiff);
- patch.length1 += aDiff.text.length();
- patch.length2 += aDiff.text.length();
- }
-
- if (aDiff.text.length() >= 2 * Patch_Margin) {
- // Time for a new patch.
- if (!patch.diffs.isEmpty()) {
- patch_addContext(patch, prepatch_text);
- patches.append(patch);
- patch = Patch();
- // Unlike Unidiff, our patch lists have a rolling context.
- // http://code.google.com/p/google-diff-match-patch/wiki/Unidiff
- // Update prepatch text & pos to reflect the application of the
- // just completed patch.
- prepatch_text = postpatch_text;
- char_count1 = char_count2;
- }
- }
- break;
- }
-
- // Update the current character count.
- if (aDiff.operation != INSERT) {
- char_count1 += aDiff.text.length();
- }
- if (aDiff.operation != DELETE) {
- char_count2 += aDiff.text.length();
- }
- }
- // Pick up the leftover patch if not empty.
- if (!patch.diffs.isEmpty()) {
- patch_addContext(patch, prepatch_text);
- patches.append(patch);
- }
-
- return patches;
-}
-
-
-QList<Patch> diff_match_patch::patch_deepCopy(QList<Patch> &patches) {
- QList<Patch> patchesCopy;
- foreach(Patch aPatch, patches) {
- Patch patchCopy = Patch();
- foreach(Diff aDiff, aPatch.diffs) {
- Diff diffCopy = Diff(aDiff.operation, aDiff.text);
- patchCopy.diffs.append(diffCopy);
- }
- patchCopy.start1 = aPatch.start1;
- patchCopy.start2 = aPatch.start2;
- patchCopy.length1 = aPatch.length1;
- patchCopy.length2 = aPatch.length2;
- patchesCopy.append(patchCopy);
- }
- return patchesCopy;
-}
-
-
-QPair<QString, QVector<bool> > diff_match_patch::patch_apply(
- QList<Patch> &patches, const QString &sourceText) {
- QString text = sourceText; // Copy to preserve original.
- if (patches.isEmpty()) {
- return QPair<QString,QVector<bool> >(text, QVector<bool>(0));
- }
-
- // Deep copy the patches so that no changes are made to originals.
- QList<Patch> patchesCopy = patch_deepCopy(patches);
-
- QString nullPadding = patch_addPadding(patchesCopy);
- text = nullPadding + text + nullPadding;
- patch_splitMax(patchesCopy);
-
- int x = 0;
- // delta keeps track of the offset between the expected and actual location
- // of the previous patch. If there are patches expected at positions 10 and
- // 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;
- QVector<bool> results(patchesCopy.size());
- foreach(Patch aPatch, patchesCopy) {
- int expected_loc = aPatch.start2 + delta;
- QString text1 = diff_text1(aPatch.diffs);
- int start_loc;
- int end_loc = -1;
- 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.left(Match_MaxBits), expected_loc);
- if (start_loc != -1) {
- end_loc = match_main(text, text1.right(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;
- }
- }
- } else {
- start_loc = match_main(text, text1, expected_loc);
- }
- if (start_loc == -1) {
- // No match found. :(
- results[x] = false;
- // Subtract the delta for this failed patch from subsequent patches.
- delta -= aPatch.length2 - aPatch.length1;
- } else {
- // Found a match. :)
- results[x] = true;
- delta = start_loc - expected_loc;
- QString text2;
- if (end_loc == -1) {
- text2 = safeMid(text, start_loc, text1.length());
- } else {
- text2 = safeMid(text, start_loc, end_loc + Match_MaxBits - start_loc);
- }
- if (text1 == text2) {
- // Perfect match, just shove the replacement text in.
- text = text.left(start_loc) + diff_text2(aPatch.diffs)
- + safeMid(text, start_loc + text1.length());
- } else {
- // Imperfect match. Run a diff to get a framework of equivalent
- // indices.
- QList<Diff> diffs = diff_main(text1, text2, false);
- if (text1.length() > Match_MaxBits
- && diff_levenshtein(diffs) / static_cast<float> (text1.length())
- > Patch_DeleteThreshold) {
- // The end points match, but the content is unacceptably bad.
- results[x] = false;
- } else {
- diff_cleanupSemanticLossless(diffs);
- int index1 = 0;
- foreach(Diff aDiff, aPatch.diffs) {
- if (aDiff.operation != EQUAL) {
- int index2 = diff_xIndex(diffs, index1);
- if (aDiff.operation == INSERT) {
- // Insertion
- text = text.left(start_loc + index2) + aDiff.text
- + safeMid(text, start_loc + index2);
- } else if (aDiff.operation == DELETE) {
- // Deletion
- text = text.left(start_loc + index2)
- + safeMid(text, start_loc + diff_xIndex(diffs,
- index1 + aDiff.text.length()));
- }
- }
- if (aDiff.operation != DELETE) {
- index1 += aDiff.text.length();
- }
- }
- }
- }
- }
- x++;
- }
- // Strip the padding off.
- text = safeMid(text, nullPadding.length(), text.length()
- - 2 * nullPadding.length());
- return QPair<QString, QVector<bool> >(text, results);
-}
-
-
-QString diff_match_patch::patch_addPadding(QList<Patch> &patches) {
- short paddingLength = Patch_Margin;
- QString nullPadding = "";
- for (short x = 1; x <= paddingLength; x++) {
- nullPadding += QChar((ushort)x);
- }
-
- // Bump all the patches forward.
- QMutableListIterator<Patch> pointer(patches);
- while (pointer.hasNext()) {
- Patch &aPatch = pointer.next();
- aPatch.start1 += paddingLength;
- aPatch.start2 += paddingLength;
- }
-
- // Add some padding on start of first diff.
- Patch &firstPatch = patches.first();
- QList<Diff> &firstPatchDiffs = firstPatch.diffs;
- if (firstPatchDiffs.empty() || firstPatchDiffs.first().operation != EQUAL) {
- // Add nullPadding equality.
- firstPatchDiffs.prepend(Diff(EQUAL, nullPadding));
- firstPatch.start1 -= paddingLength; // Should be 0.
- firstPatch.start2 -= paddingLength; // Should be 0.
- firstPatch.length1 += paddingLength;
- firstPatch.length2 += paddingLength;
- } else if (paddingLength > firstPatchDiffs.first().text.length()) {
- // Grow first equality.
- Diff &firstDiff = firstPatchDiffs.first();
- int extraLength = paddingLength - firstDiff.text.length();
- firstDiff.text = safeMid(nullPadding, firstDiff.text.length(),
- paddingLength - firstDiff.text.length()) + firstDiff.text;
- firstPatch.start1 -= extraLength;
- firstPatch.start2 -= extraLength;
- firstPatch.length1 += extraLength;
- firstPatch.length2 += extraLength;
- }
-
- // Add some padding on end of last diff.
- Patch &lastPatch = patches.first();
- QList<Diff> &lastPatchDiffs = lastPatch.diffs;
- if (lastPatchDiffs.empty() || lastPatchDiffs.last().operation != EQUAL) {
- // Add nullPadding equality.
- lastPatchDiffs.append(Diff(EQUAL, nullPadding));
- lastPatch.length1 += paddingLength;
- lastPatch.length2 += paddingLength;
- } else if (paddingLength > lastPatchDiffs.last().text.length()) {
- // Grow last equality.
- Diff &lastDiff = lastPatchDiffs.last();
- int extraLength = paddingLength - lastDiff.text.length();
- lastDiff.text += nullPadding.left(extraLength);
- lastPatch.length1 += extraLength;
- lastPatch.length2 += extraLength;
- }
-
- return nullPadding;
-}
-
-
-void diff_match_patch::patch_splitMax(QList<Patch> &patches) {
- short patch_size = Match_MaxBits;
- QString precontext, postcontext;
- Patch patch;
- int start1, start2;
- bool empty;
- Operation diff_type;
- QString diff_text;
- QMutableListIterator<Patch> pointer(patches);
- Patch bigpatch;
-
- if (pointer.hasNext()) {
- bigpatch = pointer.next();
- }
-
- while (!bigpatch.isNull()) {
- if (bigpatch.length1 <= patch_size) {
- bigpatch = pointer.hasNext() ? pointer.next() : Patch();
- continue;
- }
- // Remove the big old patch.
- pointer.remove();
- start1 = bigpatch.start1;
- start2 = bigpatch.start2;
- precontext = "";
- while (!bigpatch.diffs.isEmpty()) {
- // Create one of several smaller patches.
- patch = Patch();
- empty = true;
- patch.start1 = start1 - precontext.length();
- patch.start2 = start2 - precontext.length();
- if (!precontext.isEmpty()) {
- patch.length1 = patch.length2 = precontext.length();
- patch.diffs.append(Diff(EQUAL, precontext));
- }
- while (!bigpatch.diffs.isEmpty()
- && patch.length1 < patch_size - Patch_Margin) {
- diff_type = bigpatch.diffs.front().operation;
- diff_text = bigpatch.diffs.front().text;
- if (diff_type == INSERT) {
- // Insertions are harmless.
- patch.length2 += diff_text.length();
- start2 += diff_text.length();
- patch.diffs.append(bigpatch.diffs.front());
- bigpatch.diffs.removeFirst();
- empty = false;
- } else if (diff_type == DELETE && patch.diffs.size() == 1
- && patch.diffs.front().operation == EQUAL
- && diff_text.length() > 2 * patch_size) {
- // This is a large deletion. Let it pass in one chunk.
- patch.length1 += diff_text.length();
- start1 += diff_text.length();
- empty = false;
- patch.diffs.append(Diff(diff_type, diff_text));
- bigpatch.diffs.removeFirst();
- } else {
- // Deletion or equality. Only take as much as we can stomach.
- diff_text = diff_text.left(std::min(diff_text.length(),
- patch_size - patch.length1 - Patch_Margin));
- patch.length1 += diff_text.length();
- start1 += diff_text.length();
- if (diff_type == EQUAL) {
- patch.length2 += diff_text.length();
- start2 += diff_text.length();
- } else {
- empty = false;
- }
- patch.diffs.append(Diff(diff_type, diff_text));
- if (diff_text == bigpatch.diffs.front().text) {
- bigpatch.diffs.removeFirst();
- } else {
- bigpatch.diffs.front().text = safeMid(bigpatch.diffs.front().text,
- diff_text.length());
- }
- }
- }
- // Compute the head context for the next patch.
- precontext = diff_text2(patch.diffs);
- precontext = safeMid(precontext, precontext.length() - Patch_Margin);
- // Append the end context for this patch.
- if (diff_text1(bigpatch.diffs).length() > Patch_Margin) {
- postcontext = diff_text1(bigpatch.diffs).left(Patch_Margin);
- } else {
- postcontext = diff_text1(bigpatch.diffs);
- }
- if (!postcontext.isEmpty()) {
- patch.length1 += postcontext.length();
- patch.length2 += postcontext.length();
- if (!patch.diffs.isEmpty()
- && patch.diffs.back().operation == EQUAL) {
- patch.diffs.back().text += postcontext;
- } else {
- patch.diffs.append(Diff(EQUAL, postcontext));
- }
- }
- if (!empty) {
- pointer.insert(patch);
- }
- }
- bigpatch = pointer.hasNext() ? pointer.next() : Patch();
- }
-}
-
-
-QString diff_match_patch::patch_toText(const QList<Patch> &patches) {
- QString text;
- foreach(Patch aPatch, patches) {
- text.append(aPatch.toString());
- }
- return text;
-}
-
-
-QList<Patch> diff_match_patch::patch_fromText(const QString &textline) {
- QList<Patch> patches;
- if (textline.isEmpty()) {
- return patches;
- }
- QStringList text = textline.split("\n", QString::SkipEmptyParts);
- Patch patch;
- QRegExp patchHeader("^@@ -(\\d+),?(\\d*) \\+(\\d+),?(\\d*) @@$");
- char sign;
- QString line;
- while (!text.isEmpty()) {
- if (!patchHeader.exactMatch(text.front())) {
- throw QString("Invalid patch string: %1").arg(text.front());
- }
-
- patch = Patch();
- patch.start1 = patchHeader.cap(1).toInt();
- if (patchHeader.cap(2).isEmpty()) {
- patch.start1--;
- patch.length1 = 1;
- } else if (patchHeader.cap(2) == "0") {
- patch.length1 = 0;
- } else {
- patch.start1--;
- patch.length1 = patchHeader.cap(2).toInt();
- }
-
- patch.start2 = patchHeader.cap(3).toInt();
- if (patchHeader.cap(4).isEmpty()) {
- patch.start2--;
- patch.length2 = 1;
- } else if (patchHeader.cap(4) == "0") {
- patch.length2 = 0;
- } else {
- patch.start2--;
- patch.length2 = patchHeader.cap(4).toInt();
- }
- text.removeFirst();
-
- while (!text.isEmpty()) {
- if (text.front().isEmpty()) {
- text.removeFirst();
- continue;
- }
- sign = text.front()[0].toLatin1();
- line = safeMid(text.front(), 1);
- line = line.replace("+", "%2B"); // decode would change all "+" to " "
- line = QUrl::fromPercentEncoding(qPrintable(line));
- if (sign == '-') {
- // Deletion.
- patch.diffs.append(Diff(DELETE, line));
- } else if (sign == '+') {
- // Insertion.
- patch.diffs.append(Diff(INSERT, line));
- } else if (sign == ' ') {
- // Minor equality.
- patch.diffs.append(Diff(EQUAL, line));
- } else if (sign == '@') {
- // Start of next patch.
- break;
- } else {
- // WTF?
- throw QString("Invalid patch mode '%1' in: %2").arg(sign).arg(line);
- return QList<Patch>();
- }
- text.removeFirst();
- }
-
- patches.append(patch);
-
- }
- return patches;
-}
diff --git a/thirdparty/diff/diff_match_patch.h b/thirdparty/diff/diff_match_patch.h
deleted file mode 100644
index ebe1fa190..000000000
--- a/thirdparty/diff/diff_match_patch.h
+++ /dev/null
@@ -1,628 +0,0 @@
-/*
- * Copyright 2008 Google Inc. All Rights Reserved.
- * Author: fraser@google.com (Neil Fraser)
- * Author: mikeslemmer@gmail.com (Mike Slemmer)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Diff Match and Patch
- * http://code.google.com/p/google-diff-match-patch/
- */
-
-#ifndef DIFF_MATCH_PATCH_H
-#define DIFF_MATCH_PATCH_H
-
-#include <ctime>
-
-/*
- * Functions for diff, match and patch.
- * Computes the difference between two texts to create a patch.
- * Applies the patch onto another text, allowing for errors.
- *
- * @author fraser@google.com (Neil Fraser)
- *
- * Qt/C++ port by mikeslemmer@gmail.com (Mike Slemmer):
- *
- * Code known to compile and run with Qt 4.3 through Qt 4.7.
- *
- * Here is a trivial sample program which works properly when linked with this
- * library:
- *
-
- #include <QtCore>
- #include <QString>
- #include <QList>
- #include <QMap>
- #include <QVariant>
- #include "diff_match_patch.h"
- int main(int argc, char **argv) {
- diff_match_patch dmp;
- QString str1 = QString("First string in diff");
- QString str2 = QString("Second string in diff");
-
- QString strPatch = dmp.patch_toText(dmp.patch_make(str1, str2));
- QPair<QString, QVector<bool> > out
- = dmp.patch_apply(dmp.patch_fromText(strPatch), str1);
- QString strResult = out.first;
-
- // here, strResult will equal str2 above.
- return 0;
- }
-
- */
-
-
-/**-
-* The data structure representing a diff is a Linked list of Diff objects:
-* {Diff(Operation.DELETE, "Hello"), Diff(Operation.INSERT, "Goodbye"),
-* Diff(Operation.EQUAL, " world.")}
-* which means: delete "Hello", add "Goodbye" and keep " world."
-*/
-#undef DELETE
-#undef INSERT
-#undef EQUAL
-enum Operation {
- DELETE, INSERT, EQUAL
-};
-
-
-/**
-* Class representing one diff operation.
-*/
-class Diff {
- public:
- Operation operation;
- // One of: INSERT, DELETE or EQUAL.
- QString text;
- // The text associated with this diff operation.
-
- /**
- * Constructor. Initializes the diff with the provided values.
- * @param operation One of INSERT, DELETE or EQUAL.
- * @param text The text being applied.
- */
- Diff(Operation _operation, const QString &_text);
- Diff();
- inline bool isNull() const;
- QString toString() const;
- bool operator==(const Diff &d) const;
- bool operator!=(const Diff &d) const;
-
- static QString strOperation(Operation op);
-};
-
-
-/**
-* Class representing one patch operation.
-*/
-class Patch {
- public:
- QList<Diff> diffs;
- int start1;
- int start2;
- int length1;
- int length2;
-
- /**
- * Constructor. Initializes with an empty list of diffs.
- */
- Patch();
- bool isNull() const;
- QString toString();
-};
-
-
-/**
- * Class containing the diff, match and patch methods.
- * Also contains the behaviour settings.
- */
-class diff_match_patch {
-
- friend class diff_match_patch_test;
-
- public:
- // Defaults.
- // Set these on your diff_match_patch instance to override the defaults.
-
- // Number of seconds to map a diff before giving up (0 for infinity).
- float Diff_Timeout;
- // Cost of an empty edit operation in terms of edit characters.
- short Diff_EditCost;
- // At what point is no match declared (0.0 = perfection, 1.0 = very loose).
- float Match_Threshold;
- // How far to search for a match (0 = exact location, 1000+ = broad match).
- // A match this many characters away from the expected location will add
- // 1.0 to the score (0.0 is a perfect match).
- int Match_Distance;
- // When deleting a large block of text (over ~64 characters), how close does
- // the contents have to match the expected contents. (0.0 = perfection,
- // 1.0 = very loose). Note that Match_Threshold controls how closely the
- // end points of a delete need to match.
- float Patch_DeleteThreshold;
- // Chunk size for context length.
- short Patch_Margin;
-
- // The number of bits in an int.
- short Match_MaxBits;
-
-
- public:
-
- diff_match_patch();
-
- // DIFF FUNCTIONS
-
-
- /**
- * Find the differences between two texts.
- * Run a faster slightly less optimal diff.
- * This method allows the 'checklines' of diff_main() to be optional.
- * Most of the time checklines is wanted, so default to true.
- * @param text1 Old string to be diffed.
- * @param text2 New string to be diffed.
- * @return Linked List of Diff objects.
- */
- QList<Diff> diff_main(const QString &text1, const QString &text2);
-
- /**
- * Find the differences between two texts.
- * @param text1 Old string to be diffed.
- * @param text2 New string to be diffed.
- * @param checklines Speedup flag. If false, then don't run a
- * line-level diff first to identify the changed areas.
- * If true, then run a faster slightly less optimal diff.
- * @return Linked List of Diff objects.
- */
- QList<Diff> diff_main(const QString &text1, const QString &text2, bool checklines);
-
- /**
- * Find the differences between two texts. Simplifies the problem by
- * stripping any common prefix or suffix off the texts before diffing.
- * @param text1 Old string to be diffed.
- * @param text2 New string to be diffed.
- * @param checklines Speedup flag. If false, then don't run a
- * line-level diff first to identify the changed areas.
- * If true, then run a faster slightly less optimal diff.
- * @param deadline Time when the diff should be complete by. Used
- * internally for recursive calls. Users should set DiffTimeout instead.
- * @return Linked List of Diff objects.
- */
- private:
- QList<Diff> diff_main(const QString &text1, const QString &text2, bool checklines, clock_t deadline);
-
- /**
- * Find the differences between two texts. Assumes that the texts do not
- * have any common prefix or suffix.
- * @param text1 Old string to be diffed.
- * @param text2 New string to be diffed.
- * @param checklines Speedup flag. If false, then don't run a
- * line-level diff first to identify the changed areas.
- * If true, then run a faster slightly less optimal diff.
- * @param deadline Time when the diff should be complete by.
- * @return Linked List of Diff objects.
- */
- private:
- QList<Diff> diff_compute(QString text1, QString text2, bool checklines, clock_t deadline);
-
- /**
- * Do a quick line-level diff on both strings, then rediff the parts for
- * greater accuracy.
- * This speedup can produce non-minimal diffs.
- * @param text1 Old string to be diffed.
- * @param text2 New string to be diffed.
- * @param deadline Time when the diff should be complete by.
- * @return Linked List of Diff objects.
- */
- private:
- QList<Diff> diff_lineMode(QString text1, QString text2, clock_t deadline);
-
- /**
- * Find the 'middle snake' of a diff, split the problem in two
- * and return the recursively constructed diff.
- * See Myers 1986 paper: An O(ND) Difference Algorithm and Its Variations.
- * @param text1 Old string to be diffed.
- * @param text2 New string to be diffed.
- * @return Linked List of Diff objects.
- */
- protected:
- QList<Diff> diff_bisect(const QString &text1, const QString &text2, clock_t deadline);
-
- /**
- * Given the location of the 'middle snake', split the diff in two parts
- * and recurse.
- * @param text1 Old string to be diffed.
- * @param text2 New string to be diffed.
- * @param x Index of split point in text1.
- * @param y Index of split point in text2.
- * @param deadline Time at which to bail if not yet complete.
- * @return LinkedList of Diff objects.
- */
- private:
- QList<Diff> diff_bisectSplit(const QString &text1, const QString &text2, int x, int y, clock_t deadline);
-
- /**
- * Split two texts into a list of strings. Reduce the texts to a string of
- * hashes where each Unicode character represents one line.
- * @param text1 First string.
- * @param text2 Second string.
- * @return Three element Object array, containing the encoded text1, the
- * encoded text2 and the List of unique strings. The zeroth element
- * of the List of unique strings is intentionally blank.
- */
- protected:
- QList<QVariant> diff_linesToChars(const QString &text1, const QString &text2); // return elems 0 and 1 are QString, elem 2 is QStringList
-
- /**
- * Split a text into a list of strings. Reduce the texts to a string of
- * hashes where each Unicode character represents one line.
- * @param text String to encode.
- * @param lineArray List of unique strings.
- * @param lineHash Map of strings to indices.
- * @return Encoded string.
- */
- private:
- QString diff_linesToCharsMunge(const QString &text, QStringList &lineArray,
- QMap<QString, int> &lineHash);
-
- /**
- * Rehydrate the text in a diff from a string of line hashes to real lines of
- * text.
- * @param diffs LinkedList of Diff objects.
- * @param lineArray List of unique strings.
- */
- private:
- void diff_charsToLines(QList<Diff> &diffs, const QStringList &lineArray);
-
- /**
- * Determine the common prefix of two strings.
- * @param text1 First string.
- * @param text2 Second string.
- * @return The number of characters common to the start of each string.
- */
- public:
- int diff_commonPrefix(const QString &text1, const QString &text2);
-
- /**
- * Determine the common suffix of two strings.
- * @param text1 First string.
- * @param text2 Second string.
- * @return The number of characters common to the end of each string.
- */
- public:
- int diff_commonSuffix(const QString &text1, const QString &text2);
-
- /**
- * Determine if the suffix of one string is the prefix of another.
- * @param text1 First string.
- * @param text2 Second string.
- * @return The number of characters common to the end of the first
- * string and the start of the second string.
- */
- protected:
- int diff_commonOverlap(const QString &text1, const QString &text2);
-
- /**
- * Do the two texts share a substring which is at least half the length of
- * the longer text?
- * This speedup can produce non-minimal diffs.
- * @param text1 First string.
- * @param text2 Second string.
- * @return Five element String array, containing the prefix of text1, the
- * suffix of text1, the prefix of text2, the suffix of text2 and the
- * common middle. Or null if there was no match.
- */
- protected:
- QStringList diff_halfMatch(const QString &text1, const QString &text2);
-
- /**
- * Does a substring of shorttext exist within longtext such that the
- * substring is at least half the length of longtext?
- * @param longtext Longer string.
- * @param shorttext Shorter string.
- * @param i Start index of quarter length substring within longtext.
- * @return Five element String array, containing the prefix of longtext, the
- * suffix of longtext, the prefix of shorttext, the suffix of shorttext
- * and the common middle. Or null if there was no match.
- */
- private:
- QStringList diff_halfMatchI(const QString &longtext, const QString &shorttext, int i);
-
- /**
- * Reduce the number of edits by eliminating semantically trivial equalities.
- * @param diffs LinkedList of Diff objects.
- */
- public:
- void diff_cleanupSemantic(QList<Diff> &diffs);
-
- /**
- * Look for single edits surrounded on both sides by equalities
- * which can be shifted sideways to align the edit to a word boundary.
- * e.g: The c<ins>at c</ins>ame. -> The <ins>cat </ins>came.
- * @param diffs LinkedList of Diff objects.
- */
- public:
- void diff_cleanupSemanticLossless(QList<Diff> &diffs);
-
- /**
- * Given two strings, compute a score representing whether the internal
- * boundary falls on logical boundaries.
- * Scores range from 5 (best) to 0 (worst).
- * @param one First string.
- * @param two Second string.
- * @return The score.
- */
- private:
- int diff_cleanupSemanticScore(const QString &one, const QString &two);
-
- /**
- * Reduce the number of edits by eliminating operationally trivial equalities.
- * @param diffs LinkedList of Diff objects.
- */
- public:
- void diff_cleanupEfficiency(QList<Diff> &diffs);
-
- /**
- * Reorder and merge like edit sections. Merge equalities.
- * Any edit section can move as long as it doesn't cross an equality.
- * @param diffs LinkedList of Diff objects.
- */
- public:
- void diff_cleanupMerge(QList<Diff> &diffs);
-
- /**
- * loc is a location in text1, compute and return the equivalent location in
- * text2.
- * e.g. "The cat" vs "The big cat", 1->1, 5->8
- * @param diffs LinkedList of Diff objects.
- * @param loc Location within text1.
- * @return Location within text2.
- */
- public:
- int diff_xIndex(const QList<Diff> &diffs, int loc);
-
- /**
- * Convert a Diff list into a pretty HTML report.
- * @param diffs LinkedList of Diff objects.
- * @return HTML representation.
- */
- public:
- QString diff_prettyHtml(const QList<Diff> &diffs);
-
- /**
- * Compute and return the source text (all equalities and deletions).
- * @param diffs LinkedList of Diff objects.
- * @return Source text.
- */
- public:
- QString diff_text1(const QList<Diff> &diffs);
-
- /**
- * Compute and return the destination text (all equalities and insertions).
- * @param diffs LinkedList of Diff objects.
- * @return Destination text.
- */
- public:
- QString diff_text2(const QList<Diff> &diffs);
-
- /**
- * Compute the Levenshtein distance; the number of inserted, deleted or
- * substituted characters.
- * @param diffs LinkedList of Diff objects.
- * @return Number of changes.
- */
- public:
- int diff_levenshtein(const QList<Diff> &diffs);
-
- /**
- * Crush the diff into an encoded string which describes the operations
- * required to transform text1 into text2.
- * E.g. =3\t-2\t+ing -> Keep 3 chars, delete 2 chars, insert 'ing'.
- * Operations are tab-separated. Inserted text is escaped using %xx notation.
- * @param diffs Array of diff tuples.
- * @return Delta text.
- */
- public:
- QString diff_toDelta(const QList<Diff> &diffs);
-
- /**
- * Given the original text1, and an encoded string which describes the
- * operations required to transform text1 into text2, compute the full diff.
- * @param text1 Source string for the diff.
- * @param delta Delta text.
- * @return Array of diff tuples or null if invalid.
- * @throws QString If invalid input.
- */
- public:
- QList<Diff> diff_fromDelta(const QString &text1, const QString &delta);
-
-
- // MATCH FUNCTIONS
-
-
- /**
- * Locate the best instance of 'pattern' in 'text' near 'loc'.
- * Returns -1 if no match found.
- * @param text The text to search.
- * @param pattern The pattern to search for.
- * @param loc The location to search around.
- * @return Best match index or -1.
- */
- public:
- int match_main(const QString &text, const QString &pattern, int loc);
-
- /**
- * Locate the best instance of 'pattern' in 'text' near 'loc' using the
- * Bitap algorithm. Returns -1 if no match found.
- * @param text The text to search.
- * @param pattern The pattern to search for.
- * @param loc The location to search around.
- * @return Best match index or -1.
- */
- protected:
- int match_bitap(const QString &text, const QString &pattern, int loc);
-
- /**
- * Compute and return the score for a match with e errors and x location.
- * @param e Number of errors in match.
- * @param x Location of match.
- * @param loc Expected location of match.
- * @param pattern Pattern being sought.
- * @return Overall score for match (0.0 = good, 1.0 = bad).
- */
- private:
- double match_bitapScore(int e, int x, int loc, const QString &pattern);
-
- /**
- * Initialise the alphabet for the Bitap algorithm.
- * @param pattern The text to encode.
- * @return Hash of character locations.
- */
- protected:
- QMap<QChar, int> match_alphabet(const QString &pattern);
-
-
- // PATCH FUNCTIONS
-
-
- /**
- * Increase the context until it is unique,
- * but don't let the pattern expand beyond Match_MaxBits.
- * @param patch The patch to grow.
- * @param text Source text.
- */
- protected:
- void patch_addContext(Patch &patch, const QString &text);
-
- /**
- * Compute a list of patches to turn text1 into text2.
- * A set of diffs will be computed.
- * @param text1 Old text.
- * @param text2 New text.
- * @return LinkedList of Patch objects.
- */
- public:
- QList<Patch> patch_make(const QString &text1, const QString &text2);
-
- /**
- * Compute a list of patches to turn text1 into text2.
- * text1 will be derived from the provided diffs.
- * @param diffs Array of diff tuples for text1 to text2.
- * @return LinkedList of Patch objects.
- */
- public:
- QList<Patch> patch_make(const QList<Diff> &diffs);
-
- /**
- * Compute a list of patches to turn text1 into text2.
- * text2 is ignored, diffs are the delta between text1 and text2.
- * @param text1 Old text.
- * @param text2 Ignored.
- * @param diffs Array of diff tuples for text1 to text2.
- * @return LinkedList of Patch objects.
- * @deprecated Prefer patch_make(const QString &text1, const QList<Diff> &diffs).
- */
- public:
- QList<Patch> patch_make(const QString &text1, const QString &text2, const QList<Diff> &diffs);
-
- /**
- * Compute a list of patches to turn text1 into text2.
- * text2 is not provided, diffs are the delta between text1 and text2.
- * @param text1 Old text.
- * @param diffs Array of diff tuples for text1 to text2.
- * @return LinkedList of Patch objects.
- */
- public:
- QList<Patch> patch_make(const QString &text1, const QList<Diff> &diffs);
-
- /**
- * Given an array of patches, return another array that is identical.
- * @param patches Array of patch objects.
- * @return Array of patch objects.
- */
- public:
- QList<Patch> patch_deepCopy(QList<Patch> &patches);
-
- /**
- * Merge a set of patches onto the text. Return a patched text, as well
- * as an array of true/false values indicating which patches were applied.
- * @param patches Array of patch objects.
- * @param text Old text.
- * @return Two element Object array, containing the new text and an array of
- * boolean values.
- */
- public:
- QPair<QString,QVector<bool> > patch_apply(QList<Patch> &patches, const QString &text);
-
- /**
- * Add some padding on text start and end so that edges can match something.
- * Intended to be called only from within patch_apply.
- * @param patches Array of patch objects.
- * @return The padding string added to each side.
- */
- public:
- QString patch_addPadding(QList<Patch> &patches);
-
- /**
- * Look through the patches and break up any which are longer than the
- * maximum limit of the match algorithm.
- * Intended to be called only from within patch_apply.
- * @param patches LinkedList of Patch objects.
- */
- public:
- void patch_splitMax(QList<Patch> &patches);
-
- /**
- * Take a list of patches and return a textual representation.
- * @param patches List of Patch objects.
- * @return Text representation of patches.
- */
- public:
- QString patch_toText(const QList<Patch> &patches);
-
- /**
- * Parse a textual representation of patches and return a List of Patch
- * objects.
- * @param textline Text representation of patches.
- * @return List of Patch objects.
- * @throws QString If invalid input.
- */
- public:
- QList<Patch> patch_fromText(const QString &textline);
-
- /**
- * A safer version of QString.mid(pos). This one returns "" instead of
- * null when the postion equals the string length.
- * @param str String to take a substring from.
- * @param pos Position to start the substring from.
- * @return Substring.
- */
- private:
- static inline QString safeMid(const QString &str, int pos) {
- return (pos == str.length()) ? QString("") : str.mid(pos);
- }
-
- /**
- * A safer version of QString.mid(pos, len). This one returns "" instead of
- * null when the postion equals the string length.
- * @param str String to take a substring from.
- * @param pos Position to start the substring from.
- * @param len Length of substring.
- * @return Substring.
- */
- private:
- static inline QString safeMid(const QString &str, int pos, int len) {
- return (pos == str.length()) ? QString("") : str.mid(pos, len);
- }
-};
-
-#endif // DIFF_MATCH_PATCH_H
diff --git a/thirdparty/diff/diff_match_patch_test.cpp b/thirdparty/diff/diff_match_patch_test.cpp
deleted file mode 100644
index 2d358dae4..000000000
--- a/thirdparty/diff/diff_match_patch_test.cpp
+++ /dev/null
@@ -1,1184 +0,0 @@
-/*
- * Copyright 2008 Google Inc. All Rights Reserved.
- * Author: fraser@google.com (Neil Fraser)
- * Author: mikeslemmer@gmail.com (Mike Slemmer)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Diff Match and Patch -- Test Harness
- * http://code.google.com/p/google-diff-match-patch/
- */
-
-// Code known to compile and run with Qt 4.3 through Qt 4.7.
-#include <QtCore>
-#include "diff_match_patch.h"
-#include "diff_match_patch_test.h"
-
-int main(int argc, char **argv) {
- diff_match_patch_test dmp_test;
- qDebug("Starting diff_match_patch unit tests.");
- dmp_test.run_all_tests();
- qDebug("Done.");
- return 0;
- Q_UNUSED(argc)
- Q_UNUSED(argv)
-}
-
-
-diff_match_patch_test::diff_match_patch_test() {
-}
-
-void diff_match_patch_test::run_all_tests() {
- QTime t;
- t.start();
- try {
- testDiffCommonPrefix();
- testDiffCommonSuffix();
- testDiffCommonOverlap();
- testDiffHalfmatch();
- testDiffLinesToChars();
- testDiffCharsToLines();
- testDiffCleanupMerge();
- testDiffCleanupSemanticLossless();
- testDiffCleanupSemantic();
- testDiffCleanupEfficiency();
- testDiffPrettyHtml();
- testDiffText();
- testDiffDelta();
- testDiffXIndex();
- testDiffLevenshtein();
- testDiffBisect();
- testDiffMain();
-
- testMatchAlphabet();
- testMatchBitap();
- testMatchMain();
-
- testPatchObj();
- testPatchFromText();
- testPatchToText();
- testPatchAddContext();
- testPatchMake();
- testPatchSplitMax();
- testPatchAddPadding();
- testPatchApply();
- qDebug("All tests passed.");
- } catch (QString strCase) {
- qDebug("Test failed: %s", qPrintable(strCase));
- }
- qDebug("Total time: %d ms", t.elapsed());
-}
-
-// DIFF TEST FUNCTIONS
-
-void diff_match_patch_test::testDiffCommonPrefix() {
- // Detect any common prefix.
- assertEquals("diff_commonPrefix: Null case.", 0, dmp.diff_commonPrefix("abc", "xyz"));
-
- assertEquals("diff_commonPrefix: Non-null case.", 4, dmp.diff_commonPrefix("1234abcdef", "1234xyz"));
-
- assertEquals("diff_commonPrefix: Whole case.", 4, dmp.diff_commonPrefix("1234", "1234xyz"));
-}
-
-void diff_match_patch_test::testDiffCommonSuffix() {
- // Detect any common suffix.
- assertEquals("diff_commonSuffix: Null case.", 0, dmp.diff_commonSuffix("abc", "xyz"));
-
- assertEquals("diff_commonSuffix: Non-null case.", 4, dmp.diff_commonSuffix("abcdef1234", "xyz1234"));
-
- assertEquals("diff_commonSuffix: Whole case.", 4, dmp.diff_commonSuffix("1234", "xyz1234"));
-}
-
-void diff_match_patch_test::testDiffCommonOverlap() {
- // Detect any suffix/prefix overlap.
- assertEquals("diff_commonOverlap: Null case.", 0, dmp.diff_commonOverlap("", "abcd"));
-
- assertEquals("diff_commonOverlap: Whole case.", 3, dmp.diff_commonOverlap("abc", "abcd"));
-
- assertEquals("diff_commonOverlap: No overlap.", 0, dmp.diff_commonOverlap("123456", "abcd"));
-
- assertEquals("diff_commonOverlap: Overlap.", 3, dmp.diff_commonOverlap("123456xxx", "xxxabcd"));
-}
-
-void diff_match_patch_test::testDiffHalfmatch() {
- // Detect a halfmatch.
- dmp.Diff_Timeout = 1;
- assertEmpty("diff_halfMatch: No match #1.", dmp.diff_halfMatch("1234567890", "abcdef"));
-
- assertEmpty("diff_halfMatch: No match #2.", dmp.diff_halfMatch("12345", "23"));
-
- assertEquals("diff_halfMatch: Single Match #1.", QString("12,90,a,z,345678").split(","), dmp.diff_halfMatch("1234567890", "a345678z"));
-
- assertEquals("diff_halfMatch: Single Match #2.", QString("a,z,12,90,345678").split(","), dmp.diff_halfMatch("a345678z", "1234567890"));
-
- assertEquals("diff_halfMatch: Single Match #3.", QString("abc,z,1234,0,56789").split(","), dmp.diff_halfMatch("abc56789z", "1234567890"));
-
- assertEquals("diff_halfMatch: Single Match #4.", QString("a,xyz,1,7890,23456").split(","), dmp.diff_halfMatch("a23456xyz", "1234567890"));
-
- assertEquals("diff_halfMatch: Multiple Matches #1.", QString("12123,123121,a,z,1234123451234").split(","), dmp.diff_halfMatch("121231234123451234123121", "a1234123451234z"));
-
- assertEquals("diff_halfMatch: Multiple Matches #2.", QString(",-=-=-=-=-=,x,,x-=-=-=-=-=-=-=").split(","), dmp.diff_halfMatch("x-=-=-=-=-=-=-=-=-=-=-=-=", "xx-=-=-=-=-=-=-="));
-
- assertEquals("diff_halfMatch: Multiple Matches #3.", QString("-=-=-=-=-=,,,y,-=-=-=-=-=-=-=y").split(","), dmp.diff_halfMatch("-=-=-=-=-=-=-=-=-=-=-=-=y", "-=-=-=-=-=-=-=yy"));
-
- // Optimal diff would be -q+x=H-i+e=lloHe+Hu=llo-Hew+y not -qHillo+x=HelloHe-w+Hulloy
- assertEquals("diff_halfMatch: Non-optimal halfmatch.", QString("qHillo,w,x,Hulloy,HelloHe").split(","), dmp.diff_halfMatch("qHilloHelloHew", "xHelloHeHulloy"));
-
- dmp.Diff_Timeout = 0;
- assertEmpty("diff_halfMatch: Optimal no halfmatch.", dmp.diff_halfMatch("qHilloHelloHew", "xHelloHeHulloy"));
-}
-
-void diff_match_patch_test::testDiffLinesToChars() {
- // Convert lines down to characters.
- QStringList tmpVector;
- QList<QVariant> tmpVarList;
- tmpVector.append("");
- tmpVector.append("alpha\n");
- tmpVector.append("beta\n");
- tmpVarList << QVariant::fromValue(QString() + QChar((ushort)1) + QChar((ushort)2) + QChar((ushort)1)); //(("\u0001\u0002\u0001"));
- tmpVarList << QVariant::fromValue(QString() + QChar((ushort)2) + QChar((ushort)1) + QChar((ushort)2)); // (("\u0002\u0001\u0002"));
- tmpVarList << QVariant::fromValue(tmpVector);
- assertEquals("diff_linesToChars:", tmpVarList, dmp.diff_linesToChars("alpha\nbeta\nalpha\n", "beta\nalpha\nbeta\n"));
-
- tmpVector.clear();
- tmpVarList.clear();
- tmpVector.append("");
- tmpVector.append("alpha\r\n");
- tmpVector.append("beta\r\n");
- tmpVector.append("\r\n");
- tmpVarList << QVariant::fromValue(QString(""));
- tmpVarList << QVariant::fromValue(QString() + QChar((ushort)1) + QChar((ushort)2) + QChar((ushort)3) + QChar((ushort)3)); // (("\u0001\u0002\u0003\u0003"));
- tmpVarList << QVariant::fromValue(tmpVector);
- assertEquals("diff_linesToChars:", tmpVarList, dmp.diff_linesToChars("", "alpha\r\nbeta\r\n\r\n\r\n"));
-
- tmpVector.clear();
- tmpVarList.clear();
- tmpVector.append("");
- tmpVector.append("a");
- tmpVector.append("b");
- tmpVarList << QVariant::fromValue(QString() + QChar((ushort)1)); // (("\u0001"));
- tmpVarList << QVariant::fromValue(QString() + QChar((ushort)2)); // (("\u0002"));
- tmpVarList << QVariant::fromValue(tmpVector);
- assertEquals("diff_linesToChars:", tmpVarList, dmp.diff_linesToChars("a", "b"));
-
- // More than 256 to reveal any 8-bit limitations.
- int n = 300;
- tmpVector.clear();
- tmpVarList.clear();
- QString lines;
- QString chars;
- for (int x = 1; x < n + 1; x++) {
- tmpVector.append(QString::number(x) + "\n");
- lines += QString::number(x) + "\n";
- chars += QChar(static_cast<ushort>(x));
- }
- assertEquals("diff_linesToChars: More than 256 (setup).", n, tmpVector.size());
- assertEquals("diff_linesToChars: More than 256 (setup).", n, chars.length());
- tmpVector.prepend("");
- tmpVarList << QVariant::fromValue(chars);
- tmpVarList << QVariant::fromValue(QString(""));
- tmpVarList << QVariant::fromValue(tmpVector);
- assertEquals("diff_linesToChars: More than 256.", tmpVarList, dmp.diff_linesToChars(lines, ""));
-}
-
-void diff_match_patch_test::testDiffCharsToLines() {
- // First check that Diff equality works.
- assertTrue("diff_charsToLines:", Diff(EQUAL, "a") == Diff(EQUAL, "a"));
-
- assertEquals("diff_charsToLines:", Diff(EQUAL, "a"), Diff(EQUAL, "a"));
-
- // Convert chars up to lines.
- QList<Diff> diffs;
- diffs << Diff(EQUAL, QString() + QChar((ushort)1) + QChar((ushort)2) + QChar((ushort)1)); // ("\u0001\u0002\u0001");
- diffs << Diff(INSERT, QString() + QChar((ushort)2) + QChar((ushort)1) + QChar((ushort)2)); // ("\u0002\u0001\u0002");
- QStringList tmpVector;
- tmpVector.append("");
- tmpVector.append("alpha\n");
- tmpVector.append("beta\n");
- dmp.diff_charsToLines(diffs, tmpVector);
- assertEquals("diff_charsToLines:", diffList(Diff(EQUAL, "alpha\nbeta\nalpha\n"), Diff(INSERT, "beta\nalpha\nbeta\n")), diffs);
-
- // More than 256 to reveal any 8-bit limitations.
- int n = 300;
- tmpVector.clear();
- QList<QVariant> tmpVarList;
- QString lines;
- QString chars;
- for (int x = 1; x < n + 1; x++) {
- tmpVector.append(QString::number(x) + "\n");
- lines += QString::number(x) + "\n";
- chars += QChar(static_cast<ushort>(x));
- }
- assertEquals("diff_linesToChars: More than 256 (setup).", n, tmpVector.size());
- assertEquals("diff_linesToChars: More than 256 (setup).", n, chars.length());
- tmpVector.prepend("");
- diffs = diffList(Diff(DELETE, chars));
- dmp.diff_charsToLines(diffs, tmpVector);
- assertEquals("diff_charsToLines: More than 256.", diffList(Diff(DELETE, lines)), diffs);
-}
-
-void diff_match_patch_test::testDiffCleanupMerge() {
- // Cleanup a messy diff.
- QList<Diff> diffs;
- dmp.diff_cleanupMerge(diffs);
- assertEquals("diff_cleanupMerge: Null case.", diffList(), diffs);
-
- diffs = diffList(Diff(EQUAL, "a"), Diff(DELETE, "b"), Diff(INSERT, "c"));
- dmp.diff_cleanupMerge(diffs);
- assertEquals("diff_cleanupMerge: No change case.", diffList(Diff(EQUAL, "a"), Diff(DELETE, "b"), Diff(INSERT, "c")), diffs);
-
- diffs = diffList(Diff(EQUAL, "a"), Diff(EQUAL, "b"), Diff(EQUAL, "c"));
- dmp.diff_cleanupMerge(diffs);
- assertEquals("diff_cleanupMerge: Merge equalities.", diffList(Diff(EQUAL, "abc")), diffs);
-
- diffs = diffList(Diff(DELETE, "a"), Diff(DELETE, "b"), Diff(DELETE, "c"));
- dmp.diff_cleanupMerge(diffs);
- assertEquals("diff_cleanupMerge: Merge deletions.", diffList(Diff(DELETE, "abc")), diffs);
-
- diffs = diffList(Diff(INSERT, "a"), Diff(INSERT, "b"), Diff(INSERT, "c"));
- dmp.diff_cleanupMerge(diffs);
- assertEquals("diff_cleanupMerge: Merge insertions.", diffList(Diff(INSERT, "abc")), diffs);
-
- diffs = diffList(Diff(DELETE, "a"), Diff(INSERT, "b"), Diff(DELETE, "c"), Diff(INSERT, "d"), Diff(EQUAL, "e"), Diff(EQUAL, "f"));
- dmp.diff_cleanupMerge(diffs);
- assertEquals("diff_cleanupMerge: Merge interweave.", diffList(Diff(DELETE, "ac"), Diff(INSERT, "bd"), Diff(EQUAL, "ef")), diffs);
-
- diffs = diffList(Diff(DELETE, "a"), Diff(INSERT, "abc"), Diff(DELETE, "dc"));
- dmp.diff_cleanupMerge(diffs);
- assertEquals("diff_cleanupMerge: Prefix and suffix detection.", diffList(Diff(EQUAL, "a"), Diff(DELETE, "d"), Diff(INSERT, "b"), Diff(EQUAL, "c")), diffs);
-
- diffs = diffList(Diff(EQUAL, "x"), Diff(DELETE, "a"), Diff(INSERT, "abc"), Diff(DELETE, "dc"), Diff(EQUAL, "y"));
- dmp.diff_cleanupMerge(diffs);
- assertEquals("diff_cleanupMerge: Prefix and suffix detection with equalities.", diffList(Diff(EQUAL, "xa"), Diff(DELETE, "d"), Diff(INSERT, "b"), Diff(EQUAL, "cy")), diffs);
-
- diffs = diffList(Diff(EQUAL, "a"), Diff(INSERT, "ba"), Diff(EQUAL, "c"));
- dmp.diff_cleanupMerge(diffs);
- assertEquals("diff_cleanupMerge: Slide edit left.", diffList(Diff(INSERT, "ab"), Diff(EQUAL, "ac")), diffs);
-
- diffs = diffList(Diff(EQUAL, "c"), Diff(INSERT, "ab"), Diff(EQUAL, "a"));
- dmp.diff_cleanupMerge(diffs);
- assertEquals("diff_cleanupMerge: Slide edit right.", diffList(Diff(EQUAL, "ca"), Diff(INSERT, "ba")), diffs);
-
- diffs = diffList(Diff(EQUAL, "a"), Diff(DELETE, "b"), Diff(EQUAL, "c"), Diff(DELETE, "ac"), Diff(EQUAL, "x"));
- dmp.diff_cleanupMerge(diffs);
- assertEquals("diff_cleanupMerge: Slide edit left recursive.", diffList(Diff(DELETE, "abc"), Diff(EQUAL, "acx")), diffs);
-
- diffs = diffList(Diff(EQUAL, "x"), Diff(DELETE, "ca"), Diff(EQUAL, "c"), Diff(DELETE, "b"), Diff(EQUAL, "a"));
- dmp.diff_cleanupMerge(diffs);
- assertEquals("diff_cleanupMerge: Slide edit right recursive.", diffList(Diff(EQUAL, "xca"), Diff(DELETE, "cba")), diffs);
-}
-
-void diff_match_patch_test::testDiffCleanupSemanticLossless() {
- // Slide diffs to match logical boundaries.
- QList<Diff> diffs = diffList();
- dmp.diff_cleanupSemanticLossless(diffs);
- assertEquals("diff_cleanupSemantic: Null case.", diffList(), diffs);
-
- diffs = diffList(Diff(EQUAL, "AAA\r\n\r\nBBB"), Diff(INSERT, "\r\nDDD\r\n\r\nBBB"), Diff(EQUAL, "\r\nEEE"));
- dmp.diff_cleanupSemanticLossless(diffs);
- assertEquals("diff_cleanupSemanticLossless: Blank lines.", diffList(Diff(EQUAL, "AAA\r\n\r\n"), Diff(INSERT, "BBB\r\nDDD\r\n\r\n"), Diff(EQUAL, "BBB\r\nEEE")), diffs);
-
- diffs = diffList(Diff(EQUAL, "AAA\r\nBBB"), Diff(INSERT, " DDD\r\nBBB"), Diff(EQUAL, " EEE"));
- dmp.diff_cleanupSemanticLossless(diffs);
- assertEquals("diff_cleanupSemanticLossless: Line boundaries.", diffList(Diff(EQUAL, "AAA\r\n"), Diff(INSERT, "BBB DDD\r\n"), Diff(EQUAL, "BBB EEE")), diffs);
-
- diffs = diffList(Diff(EQUAL, "The c"), Diff(INSERT, "ow and the c"), Diff(EQUAL, "at."));
- dmp.diff_cleanupSemanticLossless(diffs);
- assertEquals("diff_cleanupSemantic: Word boundaries.", diffList(Diff(EQUAL, "The "), Diff(INSERT, "cow and the "), Diff(EQUAL, "cat.")), diffs);
-
- diffs = diffList(Diff(EQUAL, "The-c"), Diff(INSERT, "ow-and-the-c"), Diff(EQUAL, "at."));
- dmp.diff_cleanupSemanticLossless(diffs);
- assertEquals("diff_cleanupSemantic: Alphanumeric boundaries.", diffList(Diff(EQUAL, "The-"), Diff(INSERT, "cow-and-the-"), Diff(EQUAL, "cat.")), diffs);
-
- diffs = diffList(Diff(EQUAL, "a"), Diff(DELETE, "a"), Diff(EQUAL, "ax"));
- dmp.diff_cleanupSemanticLossless(diffs);
- assertEquals("diff_cleanupSemantic: Hitting the start.", diffList(Diff(DELETE, "a"), Diff(EQUAL, "aax")), diffs);
-
- diffs = diffList(Diff(EQUAL, "xa"), Diff(DELETE, "a"), Diff(EQUAL, "a"));
- dmp.diff_cleanupSemanticLossless(diffs);
- assertEquals("diff_cleanupSemantic: Hitting the end.", diffList(Diff(EQUAL, "xaa"), Diff(DELETE, "a")), diffs);
-}
-
-void diff_match_patch_test::testDiffCleanupSemantic() {
- // Cleanup semantically trivial equalities.
- QList<Diff> diffs = diffList();
- dmp.diff_cleanupSemantic(diffs);
- assertEquals("diff_cleanupSemantic: Null case.", diffList(), diffs);
-
- diffs = diffList(Diff(DELETE, "ab"), Diff(INSERT, "cd"), Diff(EQUAL, "12"), Diff(DELETE, "e"));
- dmp.diff_cleanupSemantic(diffs);
- assertEquals("diff_cleanupSemantic: No elimination #1.", diffList(Diff(DELETE, "ab"), Diff(INSERT, "cd"), Diff(EQUAL, "12"), Diff(DELETE, "e")), diffs);
-
- diffs = diffList(Diff(DELETE, "abc"), Diff(INSERT, "ABC"), Diff(EQUAL, "1234"), Diff(DELETE, "wxyz"));
- dmp.diff_cleanupSemantic(diffs);
- assertEquals("diff_cleanupSemantic: No elimination #2.", diffList(Diff(DELETE, "abc"), Diff(INSERT, "ABC"), Diff(EQUAL, "1234"), Diff(DELETE, "wxyz")), diffs);
-
- diffs = diffList(Diff(DELETE, "a"), Diff(EQUAL, "b"), Diff(DELETE, "c"));
- dmp.diff_cleanupSemantic(diffs);
- assertEquals("diff_cleanupSemantic: Simple elimination.", diffList(Diff(DELETE, "abc"), Diff(INSERT, "b")), diffs);
-
- diffs = diffList(Diff(DELETE, "ab"), Diff(EQUAL, "cd"), Diff(DELETE, "e"), Diff(EQUAL, "f"), Diff(INSERT, "g"));
- dmp.diff_cleanupSemantic(diffs);
- assertEquals("diff_cleanupSemantic: Backpass elimination.", diffList(Diff(DELETE, "abcdef"), Diff(INSERT, "cdfg")), diffs);
-
- diffs = diffList(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);
- assertEquals("diff_cleanupSemantic: Multiple elimination.", diffList(Diff(DELETE, "AB_AB"), Diff(INSERT, "1A2_1A2")), diffs);
-
- diffs = diffList(Diff(EQUAL, "The c"), Diff(DELETE, "ow and the c"), Diff(EQUAL, "at."));
- dmp.diff_cleanupSemantic(diffs);
- assertEquals("diff_cleanupSemantic: Word boundaries.", diffList(Diff(EQUAL, "The "), Diff(DELETE, "cow and the "), Diff(EQUAL, "cat.")), diffs);
-
- diffs = diffList(Diff(DELETE, "abcxx"), Diff(INSERT, "xxdef"));
- dmp.diff_cleanupSemantic(diffs);
- assertEquals("diff_cleanupSemantic: Overlap elimination #1.", diffList(Diff(DELETE, "abc"), Diff(EQUAL, "xx"), Diff(INSERT, "def")), diffs);
-
- diffs = diffList(Diff(DELETE, "abcxx"), Diff(INSERT, "xxdef"), Diff(DELETE, "ABCXX"), Diff(INSERT, "XXDEF"));
- dmp.diff_cleanupSemantic(diffs);
- assertEquals("diff_cleanupSemantic: Overlap elimination #2.", diffList(Diff(DELETE, "abc"), Diff(EQUAL, "xx"), Diff(INSERT, "def"), Diff(DELETE, "ABC"), Diff(EQUAL, "XX"), Diff(INSERT, "DEF")), diffs);
-}
-
-void diff_match_patch_test::testDiffCleanupEfficiency() {
- // Cleanup operationally trivial equalities.
- dmp.Diff_EditCost = 4;
- QList<Diff> diffs = diffList();
- dmp.diff_cleanupEfficiency(diffs);
- assertEquals("diff_cleanupEfficiency: Null case.", diffList(), diffs);
-
- diffs = diffList(Diff(DELETE, "ab"), Diff(INSERT, "12"), Diff(EQUAL, "wxyz"), Diff(DELETE, "cd"), Diff(INSERT, "34"));
- dmp.diff_cleanupEfficiency(diffs);
- assertEquals("diff_cleanupEfficiency: No elimination.", diffList(Diff(DELETE, "ab"), Diff(INSERT, "12"), Diff(EQUAL, "wxyz"), Diff(DELETE, "cd"), Diff(INSERT, "34")), diffs);
-
- diffs = diffList(Diff(DELETE, "ab"), Diff(INSERT, "12"), Diff(EQUAL, "xyz"), Diff(DELETE, "cd"), Diff(INSERT, "34"));
- dmp.diff_cleanupEfficiency(diffs);
- assertEquals("diff_cleanupEfficiency: Four-edit elimination.", diffList(Diff(DELETE, "abxyzcd"), Diff(INSERT, "12xyz34")), diffs);
-
- diffs = diffList(Diff(INSERT, "12"), Diff(EQUAL, "x"), Diff(DELETE, "cd"), Diff(INSERT, "34"));
- dmp.diff_cleanupEfficiency(diffs);
- assertEquals("diff_cleanupEfficiency: Three-edit elimination.", diffList(Diff(DELETE, "xcd"), Diff(INSERT, "12x34")), diffs);
-
- diffs = diffList(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);
- assertEquals("diff_cleanupEfficiency: Backpass elimination.", diffList(Diff(DELETE, "abxyzcd"), Diff(INSERT, "12xy34z56")), diffs);
-
- dmp.Diff_EditCost = 5;
- diffs = diffList(Diff(DELETE, "ab"), Diff(INSERT, "12"), Diff(EQUAL, "wxyz"), Diff(DELETE, "cd"), Diff(INSERT, "34"));
- dmp.diff_cleanupEfficiency(diffs);
- assertEquals("diff_cleanupEfficiency: High cost elimination.", diffList(Diff(DELETE, "abwxyzcd"), Diff(INSERT, "12wxyz34")), diffs);
- dmp.Diff_EditCost = 4;
-}
-
-void diff_match_patch_test::testDiffPrettyHtml() {
- // Pretty print.
- QList<Diff> diffs = diffList(Diff(EQUAL, "a\n"), Diff(DELETE, "<B>b</B>"), Diff(INSERT, "c&d"));
- assertEquals("diff_prettyHtml:", "<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));
-}
-
-void diff_match_patch_test::testDiffText() {
- // Compute the source and destination texts.
- QList<Diff> diffs = diffList(Diff(EQUAL, "jump"), Diff(DELETE, "s"), Diff(INSERT, "ed"), Diff(EQUAL, " over "), Diff(DELETE, "the"), Diff(INSERT, "a"), Diff(EQUAL, " lazy"));
- assertEquals("diff_text1:", "jumps over the lazy", dmp.diff_text1(diffs));
- assertEquals("diff_text2:", "jumped over a lazy", dmp.diff_text2(diffs));
-}
-
-void diff_match_patch_test::testDiffDelta() {
- // Convert a diff into delta string.
- QList<Diff> diffs = diffList(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"));
- QString text1 = dmp.diff_text1(diffs);
- assertEquals("diff_text1: Base text.", "jumps over the lazy", text1);
-
- QString delta = dmp.diff_toDelta(diffs);
- assertEquals("diff_toDelta:", "=4\t-1\t+ed\t=6\t-3\t+a\t=5\t+old dog", delta);
-
- // Convert delta string into a diff.
- assertEquals("diff_fromDelta: Normal.", diffs, dmp.diff_fromDelta(text1, delta));
-
- // Generates error (19 < 20).
- try {
- dmp.diff_fromDelta(text1 + "x", delta);
- assertFalse("diff_fromDelta: Too long.", true);
- } catch (QString ex) {
- // Exception expected.
- }
-
- // Generates error (19 > 18).
- try {
- dmp.diff_fromDelta(text1.mid(1), delta);
- assertFalse("diff_fromDelta: Too short.", true);
- } catch (QString ex) {
- // Exception expected.
- }
-
- // Generates error (%c3%xy invalid Unicode).
- /* This test does not work because QUrl::fromPercentEncoding("%xy") -> "?"
- try {
- dmp.diff_fromDelta("", "+%c3%xy");
- assertFalse("diff_fromDelta: Invalid character.", true);
- } catch (QString ex) {
- // Exception expected.
- }
- */
-
- // Test deltas with special characters.
- diffs = diffList(Diff(EQUAL, QString::fromWCharArray((const wchar_t*) L"\u0680 \000 \t %", 7)), Diff(DELETE, QString::fromWCharArray((const wchar_t*) L"\u0681 \001 \n ^", 7)), Diff(INSERT, QString::fromWCharArray((const wchar_t*) L"\u0682 \002 \\ |", 7)));
- text1 = dmp.diff_text1(diffs);
- assertEquals("diff_text1: Unicode text.", QString::fromWCharArray((const wchar_t*) L"\u0680 \000 \t %\u0681 \001 \n ^", 14), text1);
-
- delta = dmp.diff_toDelta(diffs);
- assertEquals("diff_toDelta: Unicode.", "=7\t-7\t+%DA%82 %02 %5C %7C", delta);
-
- assertEquals("diff_fromDelta: Unicode.", diffs, dmp.diff_fromDelta(text1, delta));
-
- // Verify pool of unchanged characters.
- diffs = diffList(Diff(INSERT, "A-Z a-z 0-9 - _ . ! ~ * ' ( ) ; / ? : @ & = + $ , # "));
- QString text2 = dmp.diff_text2(diffs);
- assertEquals("diff_text2: Unchanged characters.", "A-Z a-z 0-9 - _ . ! ~ * \' ( ) ; / ? : @ & = + $ , # ", text2);
-
- delta = dmp.diff_toDelta(diffs);
- assertEquals("diff_toDelta: Unchanged characters.", "+A-Z a-z 0-9 - _ . ! ~ * \' ( ) ; / ? : @ & = + $ , # ", delta);
-
- // Convert delta string into a diff.
- assertEquals("diff_fromDelta: Unchanged characters.", diffs, dmp.diff_fromDelta("", delta));
-}
-
-void diff_match_patch_test::testDiffXIndex() {
- // Translate a location in text1 to text2.
- QList<Diff> diffs = diffList(Diff(DELETE, "a"), Diff(INSERT, "1234"), Diff(EQUAL, "xyz"));
- assertEquals("diff_xIndex: Translation on equality.", 5, dmp.diff_xIndex(diffs, 2));
-
- diffs = diffList(Diff(EQUAL, "a"), Diff(DELETE, "1234"), Diff(EQUAL, "xyz"));
- assertEquals("diff_xIndex: Translation on deletion.", 1, dmp.diff_xIndex(diffs, 3));
-}
-
-void diff_match_patch_test::testDiffLevenshtein() {
- QList<Diff> diffs = diffList(Diff(DELETE, "abc"), Diff(INSERT, "1234"), Diff(EQUAL, "xyz"));
- assertEquals("diff_levenshtein: Trailing equality.", 4, dmp.diff_levenshtein(diffs));
-
- diffs = diffList(Diff(EQUAL, "xyz"), Diff(DELETE, "abc"), Diff(INSERT, "1234"));
- assertEquals("diff_levenshtein: Leading equality.", 4, dmp.diff_levenshtein(diffs));
-
- diffs = diffList(Diff(DELETE, "abc"), Diff(EQUAL, "xyz"), Diff(INSERT, "1234"));
- assertEquals("diff_levenshtein: Middle equality.", 7, dmp.diff_levenshtein(diffs));
-}
-
-void diff_match_patch_test::testDiffBisect() {
- // Normal.
- QString a = "cat";
- QString 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.
- QList<Diff> diffs = diffList(Diff(DELETE, "c"), Diff(INSERT, "m"), Diff(EQUAL, "a"), Diff(DELETE, "t"), Diff(INSERT, "p"));
- assertEquals("diff_bisect: Normal.", diffs, dmp.diff_bisect(a, b, std::numeric_limits<clock_t>::max()));
-
- // Timeout.
- diffs = diffList(Diff(DELETE, "cat"), Diff(INSERT, "map"));
- assertEquals("diff_bisect: Timeout.", diffs, dmp.diff_bisect(a, b, 0));
-}
-
-void diff_match_patch_test::testDiffMain() {
- // Perform a trivial diff.
- QList<Diff> diffs = diffList();
- assertEquals("diff_main: Null case.", diffs, dmp.diff_main("", "", false));
-
- diffs = diffList(Diff(EQUAL, "abc"));
- assertEquals("diff_main: Equality.", diffs, dmp.diff_main("abc", "abc", false));
-
- diffs = diffList(Diff(EQUAL, "ab"), Diff(INSERT, "123"), Diff(EQUAL, "c"));
- assertEquals("diff_main: Simple insertion.", diffs, dmp.diff_main("abc", "ab123c", false));
-
- diffs = diffList(Diff(EQUAL, "a"), Diff(DELETE, "123"), Diff(EQUAL, "bc"));
- assertEquals("diff_main: Simple deletion.", diffs, dmp.diff_main("a123bc", "abc", false));
-
- diffs = diffList(Diff(EQUAL, "a"), Diff(INSERT, "123"), Diff(EQUAL, "b"), Diff(INSERT, "456"), Diff(EQUAL, "c"));
- assertEquals("diff_main: Two insertions.", diffs, dmp.diff_main("abc", "a123b456c", false));
-
- diffs = diffList(Diff(EQUAL, "a"), Diff(DELETE, "123"), Diff(EQUAL, "b"), Diff(DELETE, "456"), Diff(EQUAL, "c"));
- assertEquals("diff_main: Two deletions.", diffs, dmp.diff_main("a123b456c", "abc", false));
-
- // Perform a real diff.
- // Switch off the timeout.
- dmp.Diff_Timeout = 0;
- diffs = diffList(Diff(DELETE, "a"), Diff(INSERT, "b"));
- assertEquals("diff_main: Simple case #1.", diffs, dmp.diff_main("a", "b", false));
-
- diffs = diffList(Diff(DELETE, "Apple"), Diff(INSERT, "Banana"), Diff(EQUAL, "s are a"), Diff(INSERT, "lso"), Diff(EQUAL, " fruit."));
- assertEquals("diff_main: Simple case #2.", diffs, dmp.diff_main("Apples are a fruit.", "Bananas are also fruit.", false));
-
- diffs = diffList(Diff(DELETE, "a"), Diff(INSERT, QString::fromWCharArray((const wchar_t*) L"\u0680", 1)), Diff(EQUAL, "x"), Diff(DELETE, "\t"), Diff(INSERT, QString::fromWCharArray((const wchar_t*) L"\000", 1)));
- assertEquals("diff_main: Simple case #3.", diffs, dmp.diff_main("ax\t", QString::fromWCharArray((const wchar_t*) L"\u0680x\000", 3), false));
-
- diffs = diffList(Diff(DELETE, "1"), Diff(EQUAL, "a"), Diff(DELETE, "y"), Diff(EQUAL, "b"), Diff(DELETE, "2"), Diff(INSERT, "xab"));
- assertEquals("diff_main: Overlap #1.", diffs, dmp.diff_main("1ayb2", "abxab", false));
-
- diffs = diffList(Diff(INSERT, "xaxcx"), Diff(EQUAL, "abc"), Diff(DELETE, "y"));
- assertEquals("diff_main: Overlap #2.", diffs, dmp.diff_main("abcy", "xaxcxabc", false));
-
- diffs = diffList(Diff(DELETE, "ABCD"), Diff(EQUAL, "a"), Diff(DELETE, "="), Diff(INSERT, "-"), Diff(EQUAL, "bcd"), Diff(DELETE, "="), Diff(INSERT, "-"), Diff(EQUAL, "efghijklmnopqrs"), Diff(DELETE, "EFGHIJKLMNOefg"));
- assertEquals("diff_main: Overlap #3.", diffs, dmp.diff_main("ABCDa=bcd=efghijklmnopqrsEFGHIJKLMNOefg", "a-bcd-efghijklmnopqrs", false));
-
- diffs = diffList(Diff(INSERT, " "), Diff(EQUAL, "a"), Diff(INSERT, "nd"), Diff(EQUAL, " [[Pennsylvania]]"), Diff(DELETE, " and [[New"));
- assertEquals("diff_main: Large equality.", diffs, dmp.diff_main("a [[Pennsylvania]] and [[New", " and [[Pennsylvania]]", false));
-
- dmp.Diff_Timeout = 0.1f; // 100ms
- // This test may 'fail' on extremely fast computers. If so, just increase the text lengths.
- QString 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";
- QString 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 x = 0; x < 10; x++) {
- a = a + a;
- b = b + b;
- }
- clock_t startTime = clock();
- dmp.diff_main(a, b);
- clock_t endTime = clock();
- // Test that we took at least the timeout period.
- assertTrue("diff_main: Timeout min.", dmp.Diff_Timeout * CLOCKS_PER_SEC <= 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.
- // Java seems to overrun by ~80% (compared with 10% for other languages).
- // Therefore use an upper limit of 0.5s instead of 0.2s.
- assertTrue("diff_main: Timeout max.", dmp.Diff_Timeout * CLOCKS_PER_SEC * 2 > endTime - startTime);
- dmp.Diff_Timeout = 0;
-
- // Test the linemode speedup.
- // Must be long to pass the 100 char cutoff.
- a = "1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n";
- b = "abcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\n";
- assertEquals("diff_main: Simple line-mode.", dmp.diff_main(a, b, true), dmp.diff_main(a, b, false));
-
- a = "1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890";
- b = "abcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghij";
- assertEquals("diff_main: Single line-mode.", dmp.diff_main(a, b, true), dmp.diff_main(a, b, false));
-
- a = "1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n";
- b = "abcdefghij\n1234567890\n1234567890\n1234567890\nabcdefghij\n1234567890\n1234567890\n1234567890\nabcdefghij\n1234567890\n1234567890\n1234567890\nabcdefghij\n";
- QStringList texts_linemode = diff_rebuildtexts(dmp.diff_main(a, b, true));
- QStringList texts_textmode = diff_rebuildtexts(dmp.diff_main(a, b, false));
- assertEquals("diff_main: Overlap line-mode.", texts_textmode, texts_linemode);
-
- // Test null inputs.
- try {
- dmp.diff_main(NULL, NULL);
- assertFalse("diff_main: Null inputs.", true);
- } catch (const char* ex) {
- // Exception expected.
- }
-}
-
-
-// MATCH TEST FUNCTIONS
-
-
-void diff_match_patch_test::testMatchAlphabet() {
- // Initialise the bitmasks for Bitap.
- QMap<QChar, int> bitmask;
- bitmask.insert('a', 4);
- bitmask.insert('b', 2);
- bitmask.insert('c', 1);
- assertEquals("match_alphabet: Unique.", bitmask, dmp.match_alphabet("abc"));
-
- bitmask = QMap<QChar, int>();
- bitmask.insert('a', 37);
- bitmask.insert('b', 18);
- bitmask.insert('c', 8);
- assertEquals("match_alphabet: Duplicates.", bitmask, dmp.match_alphabet("abcaba"));
-}
-
-void diff_match_patch_test::testMatchBitap() {
- // Bitap algorithm.
- dmp.Match_Distance = 100;
- dmp.Match_Threshold = 0.5f;
- assertEquals("match_bitap: Exact match #1.", 5, dmp.match_bitap("abcdefghijk", "fgh", 5));
-
- assertEquals("match_bitap: Exact match #2.", 5, dmp.match_bitap("abcdefghijk", "fgh", 0));
-
- assertEquals("match_bitap: Fuzzy match #1.", 4, dmp.match_bitap("abcdefghijk", "efxhi", 0));
-
- assertEquals("match_bitap: Fuzzy match #2.", 2, dmp.match_bitap("abcdefghijk", "cdefxyhijk", 5));
-
- assertEquals("match_bitap: Fuzzy match #3.", -1, dmp.match_bitap("abcdefghijk", "bxy", 1));
-
- assertEquals("match_bitap: Overflow.", 2, dmp.match_bitap("123456789xx0", "3456789x0", 2));
-
- assertEquals("match_bitap: Before start match.", 0, dmp.match_bitap("abcdef", "xxabc", 4));
-
- assertEquals("match_bitap: Beyond end match.", 3, dmp.match_bitap("abcdef", "defyy", 4));
-
- assertEquals("match_bitap: Oversized pattern.", 0, dmp.match_bitap("abcdef", "xabcdefy", 0));
-
- dmp.Match_Threshold = 0.4f;
- assertEquals("match_bitap: Threshold #1.", 4, dmp.match_bitap("abcdefghijk", "efxyhi", 1));
-
- dmp.Match_Threshold = 0.3f;
- assertEquals("match_bitap: Threshold #2.", -1, dmp.match_bitap("abcdefghijk", "efxyhi", 1));
-
- dmp.Match_Threshold = 0.0f;
- assertEquals("match_bitap: Threshold #3.", 1, dmp.match_bitap("abcdefghijk", "bcdef", 1));
-
- dmp.Match_Threshold = 0.5f;
- assertEquals("match_bitap: Multiple select #1.", 0, dmp.match_bitap("abcdexyzabcde", "abccde", 3));
-
- assertEquals("match_bitap: Multiple select #2.", 8, dmp.match_bitap("abcdexyzabcde", "abccde", 5));
-
- dmp.Match_Distance = 10; // Strict location.
- assertEquals("match_bitap: Distance test #1.", -1, dmp.match_bitap("abcdefghijklmnopqrstuvwxyz", "abcdefg", 24));
-
- assertEquals("match_bitap: Distance test #2.", 0, dmp.match_bitap("abcdefghijklmnopqrstuvwxyz", "abcdxxefg", 1));
-
- dmp.Match_Distance = 1000; // Loose location.
- assertEquals("match_bitap: Distance test #3.", 0, dmp.match_bitap("abcdefghijklmnopqrstuvwxyz", "abcdefg", 24));
-}
-
-void diff_match_patch_test::testMatchMain() {
- // Full match.
- assertEquals("match_main: Equality.", 0, dmp.match_main("abcdef", "abcdef", 1000));
-
- assertEquals("match_main: Null text.", -1, dmp.match_main("", "abcdef", 1));
-
- assertEquals("match_main: Null pattern.", 3, dmp.match_main("abcdef", "", 3));
-
- assertEquals("match_main: Exact match.", 3, dmp.match_main("abcdef", "de", 3));
-
- dmp.Match_Threshold = 0.7f;
- assertEquals("match_main: Complex match.", 4, dmp.match_main("I am the very model of a modern major general.", " that berry ", 5));
- dmp.Match_Threshold = 0.5f;
-
- // Test null inputs.
- try {
- dmp.match_main(NULL, NULL, 0);
- assertFalse("match_main: Null inputs.", true);
- } catch (const char* ex) {
- // Exception expected.
- }
-}
-
-
-// PATCH TEST FUNCTIONS
-
-
-void diff_match_patch_test::testPatchObj() {
- // Patch Object.
- Patch p;
- p.start1 = 20;
- p.start2 = 21;
- p.length1 = 18;
- p.length2 = 17;
- p.diffs = diffList(Diff(EQUAL, "jump"), Diff(DELETE, "s"), Diff(INSERT, "ed"), Diff(EQUAL, " over "), Diff(DELETE, "the"), Diff(INSERT, "a"), Diff(EQUAL, "\nlaz"));
- QString strp = "@@ -21,18 +22,17 @@\n jump\n-s\n+ed\n over \n-the\n+a\n %0Alaz\n";
- assertEquals("Patch: toString.", strp, p.toString());
-}
-
-void diff_match_patch_test::testPatchFromText() {
- assertTrue("patch_fromText: #0.", dmp.patch_fromText("").isEmpty());
-
- QString strp = "@@ -21,18 +22,17 @@\n jump\n-s\n+ed\n over \n-the\n+a\n %0Alaz\n";
- assertEquals("patch_fromText: #1.", strp, dmp.patch_fromText(strp).value(0).toString());
-
- assertEquals("patch_fromText: #2.", "@@ -1 +1 @@\n-a\n+b\n", dmp.patch_fromText("@@ -1 +1 @@\n-a\n+b\n").value(0).toString());
-
- assertEquals("patch_fromText: #3.", "@@ -1,3 +0,0 @@\n-abc\n", dmp.patch_fromText("@@ -1,3 +0,0 @@\n-abc\n").value(0).toString());
-
- assertEquals("patch_fromText: #4.", "@@ -0,0 +1,3 @@\n+abc\n", dmp.patch_fromText("@@ -0,0 +1,3 @@\n+abc\n").value(0).toString());
-
- // Generates error.
- try {
- dmp.patch_fromText("Bad\nPatch\n");
- assertFalse("patch_fromText: #5.", true);
- } catch (QString ex) {
- // Exception expected.
- }
-}
-
-void diff_match_patch_test::testPatchToText() {
- QString strp = "@@ -21,18 +22,17 @@\n jump\n-s\n+ed\n over \n-the\n+a\n laz\n";
- QList<Patch> patches;
- patches = dmp.patch_fromText(strp);
- assertEquals("patch_toText: Single", strp, dmp.patch_toText(patches));
-
- strp = "@@ -1,9 +1,9 @@\n-f\n+F\n oo+fooba\n@@ -7,9 +7,9 @@\n obar\n-,\n+.\n tes\n";
- patches = dmp.patch_fromText(strp);
- assertEquals("patch_toText: Dual", strp, dmp.patch_toText(patches));
-}
-
-void diff_match_patch_test::testPatchAddContext() {
- dmp.Patch_Margin = 4;
- Patch p;
- p = dmp.patch_fromText("@@ -21,4 +21,10 @@\n-jump\n+somersault\n").value(0);
- dmp.patch_addContext(p, "The quick brown fox jumps over the lazy dog.");
- assertEquals("patch_addContext: Simple case.", "@@ -17,12 +17,18 @@\n fox \n-jump\n+somersault\n s ov\n", p.toString());
-
- p = dmp.patch_fromText("@@ -21,4 +21,10 @@\n-jump\n+somersault\n").value(0);
- dmp.patch_addContext(p, "The quick brown fox jumps.");
- assertEquals("patch_addContext: Not enough trailing context.", "@@ -17,10 +17,16 @@\n fox \n-jump\n+somersault\n s.\n", p.toString());
-
- p = dmp.patch_fromText("@@ -3 +3,2 @@\n-e\n+at\n").value(0);
- dmp.patch_addContext(p, "The quick brown fox jumps.");
- assertEquals("patch_addContext: Not enough leading context.", "@@ -1,7 +1,8 @@\n Th\n-e\n+at\n qui\n", p.toString());
-
- p = dmp.patch_fromText("@@ -3 +3,2 @@\n-e\n+at\n").value(0);
- dmp.patch_addContext(p, "The quick brown fox jumps. The quick brown fox crashes.");
- assertEquals("patch_addContext: Ambiguity.", "@@ -1,27 +1,28 @@\n Th\n-e\n+at\n quick brown fox jumps. \n", p.toString());
-}
-
-void diff_match_patch_test::testPatchMake() {
- QList<Patch> patches;
- patches = dmp.patch_make("", "");
- assertEquals("patch_make: Null case", "", dmp.patch_toText(patches));
-
- QString text1 = "The quick brown fox jumps over the lazy dog.";
- QString text2 = "That quick brown fox jumped over a lazy dog.";
- QString 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);
- assertEquals("patch_make: Text2+Text1 inputs", expectedPatch, dmp.patch_toText(patches));
-
- 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);
- assertEquals("patch_make: Text1+Text2 inputs", expectedPatch, dmp.patch_toText(patches));
-
- QList<Diff> diffs = dmp.diff_main(text1, text2, false);
- patches = dmp.patch_make(diffs);
- assertEquals("patch_make: Diff input", expectedPatch, dmp.patch_toText(patches));
-
- patches = dmp.patch_make(text1, diffs);
- assertEquals("patch_make: Text1+Diff inputs", expectedPatch, dmp.patch_toText(patches));
-
- patches = dmp.patch_make(text1, text2, diffs);
- assertEquals("patch_make: Text1+Text2+Diff inputs (deprecated)", expectedPatch, dmp.patch_toText(patches));
-
- patches = dmp.patch_make("`1234567890-=[]\\;',./", "~!@#$%^&*()_+{}|:\"<>?");
- assertEquals("patch_toText: Character encoding.", "@@ -1,21 +1,21 @@\n-%601234567890-=%5B%5D%5C;',./\n+~!@#$%25%5E&*()_+%7B%7D%7C:%22%3C%3E?\n", dmp.patch_toText(patches));
-
- diffs = diffList(Diff(DELETE, "`1234567890-=[]\\;',./"), Diff(INSERT, "~!@#$%^&*()_+{}|:\"<>?"));
- assertEquals("patch_fromText: Character decoding.", diffs, dmp.patch_fromText("@@ -1,21 +1,21 @@\n-%601234567890-=%5B%5D%5C;',./\n+~!@#$%25%5E&*()_+%7B%7D%7C:%22%3C%3E?\n").value(0).diffs);
-
- text1 = "";
- for (int x = 0; x < 100; x++) {
- text1 += "abcdef";
- }
- text2 = text1 + "123";
- expectedPatch = "@@ -573,28 +573,31 @@\n cdefabcdefabcdefabcdefabcdef\n+123\n";
- patches = dmp.patch_make(text1, text2);
- assertEquals("patch_make: Long string with repeats.", expectedPatch, dmp.patch_toText(patches));
-
- // Test null inputs.
- try {
- dmp.patch_make(NULL, NULL);
- assertFalse("patch_make: Null inputs.", true);
- } catch (const char* ex) {
- // Exception expected.
- }
-}
-
-void diff_match_patch_test::testPatchSplitMax() {
- // Assumes that Match_MaxBits is 32.
- QList<Patch> patches;
- patches = dmp.patch_make("abcdefghijklmnopqrstuvwxyz01234567890", "XabXcdXefXghXijXklXmnXopXqrXstXuvXwxXyzX01X23X45X67X89X0");
- dmp.patch_splitMax(patches);
- assertEquals("patch_splitMax: #1.", "@@ -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));
-
- patches = dmp.patch_make("abcdef1234567890123456789012345678901234567890123456789012345678901234567890uvwxyz", "abcdefuvwxyz");
- QString oldToText = dmp.patch_toText(patches);
- dmp.patch_splitMax(patches);
- assertEquals("patch_splitMax: #2.", oldToText, dmp.patch_toText(patches));
-
- patches = dmp.patch_make("1234567890123456789012345678901234567890123456789012345678901234567890", "abc");
- dmp.patch_splitMax(patches);
- assertEquals("patch_splitMax: #3.", "@@ -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));
-
- 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);
- assertEquals("patch_splitMax: #4.", "@@ -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));
-}
-
-void diff_match_patch_test::testPatchAddPadding() {
- QList<Patch> patches;
- patches = dmp.patch_make("", "test");
- assertEquals("patch_addPadding: Both edges full.", "@@ -0,0 +1,4 @@\n+test\n", dmp.patch_toText(patches));
- dmp.patch_addPadding(patches);
- assertEquals("patch_addPadding: Both edges full.", "@@ -1,8 +1,12 @@\n %01%02%03%04\n+test\n %01%02%03%04\n", dmp.patch_toText(patches));
-
- patches = dmp.patch_make("XY", "XtestY");
- assertEquals("patch_addPadding: Both edges partial.", "@@ -1,2 +1,6 @@\n X\n+test\n Y\n", dmp.patch_toText(patches));
- dmp.patch_addPadding(patches);
- assertEquals("patch_addPadding: Both edges partial.", "@@ -2,8 +2,12 @@\n %02%03%04X\n+test\n Y%01%02%03\n", dmp.patch_toText(patches));
-
- patches = dmp.patch_make("XXXXYYYY", "XXXXtestYYYY");
- assertEquals("patch_addPadding: Both edges none.", "@@ -1,8 +1,12 @@\n XXXX\n+test\n YYYY\n", dmp.patch_toText(patches));
- dmp.patch_addPadding(patches);
- assertEquals("patch_addPadding: Both edges none.", "@@ -5,8 +5,12 @@\n XXXX\n+test\n YYYY\n", dmp.patch_toText(patches));
-}
-
-void diff_match_patch_test::testPatchApply() {
- dmp.Match_Distance = 1000;
- dmp.Match_Threshold = 0.5f;
- dmp.Patch_DeleteThreshold = 0.5f;
- QList<Patch> patches;
- patches = dmp.patch_make("", "");
- QPair<QString, QVector<bool> > results = dmp.patch_apply(patches, "Hello world.");
- QVector<bool> boolArray = results.second;
-
- QString resultStr = QString("%1\t%2").arg(results.first).arg(boolArray.count());
- assertEquals("patch_apply: Null case.", "Hello world.\t0", resultStr);
-
- 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.second;
- resultStr = results.first + "\t" + (boolArray[0] ? "true" : "false") + "\t" + (boolArray[1] ? "true" : "false");
- assertEquals("patch_apply: Exact match.", "That quick brown fox jumped over a lazy dog.\ttrue\ttrue", resultStr);
-
- results = dmp.patch_apply(patches, "The quick red rabbit jumps over the tired tiger.");
- boolArray = results.second;
- resultStr = results.first + "\t" + (boolArray[0] ? "true" : "false") + "\t" + (boolArray[1] ? "true" : "false");
- assertEquals("patch_apply: Partial match.", "That quick red rabbit jumped over a tired tiger.\ttrue\ttrue", resultStr);
-
- results = dmp.patch_apply(patches, "I am the very model of a modern major general.");
- boolArray = results.second;
- resultStr = results.first + "\t" + (boolArray[0] ? "true" : "false") + "\t" + (boolArray[1] ? "true" : "false");
- assertEquals("patch_apply: Failed match.", "I am the very model of a modern major general.\tfalse\tfalse", resultStr);
-
- patches = dmp.patch_make("x1234567890123456789012345678901234567890123456789012345678901234567890y", "xabcy");
- results = dmp.patch_apply(patches, "x123456789012345678901234567890-----++++++++++-----123456789012345678901234567890y");
- boolArray = results.second;
- resultStr = results.first + "\t" + (boolArray[0] ? "true" : "false") + "\t" + (boolArray[1] ? "true" : "false");
- assertEquals("patch_apply: Big delete, small change.", "xabcy\ttrue\ttrue", resultStr);
-
- patches = dmp.patch_make("x1234567890123456789012345678901234567890123456789012345678901234567890y", "xabcy");
- results = dmp.patch_apply(patches, "x12345678901234567890---------------++++++++++---------------12345678901234567890y");
- boolArray = results.second;
- resultStr = results.first + "\t" + (boolArray[0] ? "true" : "false") + "\t" + (boolArray[1] ? "true" : "false");
- assertEquals("patch_apply: Big delete, large change 1.", "xabc12345678901234567890---------------++++++++++---------------12345678901234567890y\tfalse\ttrue", resultStr);
-
- dmp.Patch_DeleteThreshold = 0.6f;
- patches = dmp.patch_make("x1234567890123456789012345678901234567890123456789012345678901234567890y", "xabcy");
- results = dmp.patch_apply(patches, "x12345678901234567890---------------++++++++++---------------12345678901234567890y");
- boolArray = results.second;
- resultStr = results.first + "\t" + (boolArray[0] ? "true" : "false") + "\t" + (boolArray[1] ? "true" : "false");
- assertEquals("patch_apply: Big delete, large change 2.", "xabcy\ttrue\ttrue", resultStr);
- dmp.Patch_DeleteThreshold = 0.5f;
-
- dmp.Match_Threshold = 0.0f;
- dmp.Match_Distance = 0;
- patches = dmp.patch_make("abcdefghijklmnopqrstuvwxyz--------------------1234567890", "abcXXXXXXXXXXdefghijklmnopqrstuvwxyz--------------------1234567YYYYYYYYYY890");
- results = dmp.patch_apply(patches, "ABCDEFGHIJKLMNOPQRSTUVWXYZ--------------------1234567890");
- boolArray = results.second;
- resultStr = results.first + "\t" + (boolArray[0] ? "true" : "false") + "\t" + (boolArray[1] ? "true" : "false");
- assertEquals("patch_apply: Compensate for failed patch.", "ABCDEFGHIJKLMNOPQRSTUVWXYZ--------------------1234567YYYYYYYYYY890\tfalse\ttrue", resultStr);
- dmp.Match_Threshold = 0.5f;
- dmp.Match_Distance = 1000;
-
- patches = dmp.patch_make("", "test");
- QString patchStr = dmp.patch_toText(patches);
- dmp.patch_apply(patches, "");
- assertEquals("patch_apply: No side effects.", patchStr, dmp.patch_toText(patches));
-
- patches = dmp.patch_make("The quick brown fox jumps over the lazy dog.", "Woof");
- patchStr = dmp.patch_toText(patches);
- dmp.patch_apply(patches, "The quick brown fox jumps over the lazy dog.");
- assertEquals("patch_apply: No side effects with major delete.", patchStr, dmp.patch_toText(patches));
-
- patches = dmp.patch_make("", "test");
- results = dmp.patch_apply(patches, "");
- boolArray = results.second;
- resultStr = results.first + "\t" + (boolArray[0] ? "true" : "false");
- assertEquals("patch_apply: Edge exact match.", "test\ttrue", resultStr);
-
- patches = dmp.patch_make("XY", "XtestY");
- results = dmp.patch_apply(patches, "XY");
- boolArray = results.second;
- resultStr = results.first + "\t" + (boolArray[0] ? "true" : "false");
- assertEquals("patch_apply: Near edge exact match.", "XtestY\ttrue", resultStr);
-
- patches = dmp.patch_make("y", "y123");
- results = dmp.patch_apply(patches, "x");
- boolArray = results.second;
- resultStr = results.first + "\t" + (boolArray[0] ? "true" : "false");
- assertEquals("patch_apply: Edge partial match.", "x123\ttrue", resultStr);
-}
-
-
-void diff_match_patch_test::assertEquals(const QString &strCase, int n1, int n2) {
- if (n1 != n2) {
- qDebug("%s FAIL\nExpected: %d\nActual: %d", qPrintable(strCase), n1, n2);
- throw strCase;
- }
- qDebug("%s OK", qPrintable(strCase));
-}
-
-void diff_match_patch_test::assertEquals(const QString &strCase, const QString &s1, const QString &s2) {
- if (s1 != s2) {
- qDebug("%s FAIL\nExpected: %s\nActual: %s",
- qPrintable(strCase), qPrintable(s1), qPrintable(s2));
- throw strCase;
- }
- qDebug("%s OK", qPrintable(strCase));
-}
-
-void diff_match_patch_test::assertEquals(const QString &strCase, const Diff &d1, const Diff &d2) {
- if (d1 != d2) {
- qDebug("%s FAIL\nExpected: %s\nActual: %s", qPrintable(strCase),
- qPrintable(d1.toString()), qPrintable(d2.toString()));
- throw strCase;
- }
- qDebug("%s OK", qPrintable(strCase));
-}
-
-void diff_match_patch_test::assertEquals(const QString &strCase, const QList<Diff> &list1, const QList<Diff> &list2) {
- bool fail = false;
- if (list1.count() == list2.count()) {
- int i = 0;
- foreach(Diff d1, list1) {
- Diff d2 = list2.value(i);
- if (d1 != d2) {
- fail = true;
- break;
- }
- i++;
- }
- } else {
- fail = true;
- }
-
- if (fail) {
- // Build human readable description of both lists.
- QString listString1 = "(";
- bool first = true;
- foreach(Diff d1, list1) {
- if (!first) {
- listString1 += ", ";
- }
- listString1 += d1.toString();
- first = false;
- }
- listString1 += ")";
- QString listString2 = "(";
- first = true;
- foreach(Diff d2, list2) {
- if (!first) {
- listString2 += ", ";
- }
- listString2 += d2.toString();
- first = false;
- }
- listString2 += ")";
- qDebug("%s FAIL\nExpected: %s\nActual: %s",
- qPrintable(strCase), qPrintable(listString1), qPrintable(listString2));
- throw strCase;
- }
- qDebug("%s OK", qPrintable(strCase));
-}
-
-void diff_match_patch_test::assertEquals(const QString &strCase, const QList<QVariant> &list1, const QList<QVariant> &list2) {
- bool fail = false;
- if (list1.count() == list2.count()) {
- int i = 0;
- foreach(QVariant q1, list1) {
- QVariant q2 = list2.value(i);
- if (q1 != q2) {
- fail = true;
- break;
- }
- i++;
- }
- } else {
- fail = true;
- }
-
- if (fail) {
- // Build human readable description of both lists.
- QString listString1 = "(";
- bool first = true;
- foreach(QVariant q1, list1) {
- if (!first) {
- listString1 += ", ";
- }
- listString1 += q1.toString();
- first = false;
- }
- listString1 += ")";
- QString listString2 = "(";
- first = true;
- foreach(QVariant q2, list2) {
- if (!first) {
- listString2 += ", ";
- }
- listString2 += q2.toString();
- first = false;
- }
- listString2 += ")";
- qDebug("%s FAIL\nExpected: %s\nActual: %s",
- qPrintable(strCase), qPrintable(listString1), qPrintable(listString2));
- throw strCase;
- }
- qDebug("%s OK", qPrintable(strCase));
-}
-
-void diff_match_patch_test::assertEquals(const QString &strCase, const QVariant &var1, const QVariant &var2) {
- if (var1 != var2) {
- qDebug("%s FAIL\nExpected: %s\nActual: %s", qPrintable(strCase),
- qPrintable(var1.toString()), qPrintable(var2.toString()));
- throw strCase;
- }
- qDebug("%s OK", qPrintable(strCase));
-}
-
-void diff_match_patch_test::assertEquals(const QString &strCase, const QMap<QChar, int> &m1, const QMap<QChar, int> &m2) {
- QMapIterator<QChar, int> i1(m1), i2(m2);
-
- while (i1.hasNext() && i2.hasNext()) {
- i1.next();
- i2.next();
- if (i1.key() != i2.key() || i1.value() != i2.value()) {
- qDebug("%s FAIL\nExpected: (%c, %d)\nActual: (%c, %d)", qPrintable(strCase),
- i1.key().toLatin1(), i1.value(), i2.key().toLatin1(), i2.value());
- throw strCase;
- }
- }
-
- if (i1.hasNext()) {
- i1.next();
- qDebug("%s FAIL\nExpected: (%c, %d)\nActual: none",
- qPrintable(strCase), i1.key().toLatin1(), i1.value());
- throw strCase;
- }
- if (i2.hasNext()) {
- i2.next();
- qDebug("%s FAIL\nExpected: none\nActual: (%c, %d)",
- qPrintable(strCase), i2.key().toLatin1(), i2.value());
- throw strCase;
- }
- qDebug("%s OK", qPrintable(strCase));
-}
-
-void diff_match_patch_test::assertEquals(const QString &strCase, const QStringList &list1, const QStringList &list2) {
- if (list1 != list2) {
- qDebug("%s FAIL\nExpected: %s\nActual: %s", qPrintable(strCase),
- qPrintable(list1.join(",")), qPrintable(list2.join(",")));
- throw strCase;
- }
- qDebug("%s OK", qPrintable(strCase));
-}
-
-void diff_match_patch_test::assertTrue(const QString &strCase, bool value) {
- if (!value) {
- qDebug("%s FAIL\nExpected: true\nActual: false", qPrintable(strCase));
- throw strCase;
- }
- qDebug("%s OK", qPrintable(strCase));
-}
-
-void diff_match_patch_test::assertFalse(const QString &strCase, bool value) {
- if (value) {
- qDebug("%s FAIL\nExpected: false\nActual: true", qPrintable(strCase));
- throw strCase;
- }
- qDebug("%s OK", qPrintable(strCase));
-}
-
-
-// Construct the two texts which made up the diff originally.
-QStringList diff_match_patch_test::diff_rebuildtexts(QList<Diff> diffs) {
- QStringList text;
- text << QString("") << QString("");
- foreach (Diff myDiff, diffs) {
- if (myDiff.operation != INSERT) {
- text[0] += myDiff.text;
- }
- if (myDiff.operation != DELETE) {
- text[1] += myDiff.text;
- }
- }
- return text;
-}
-
-void diff_match_patch_test::assertEmpty(const QString &strCase, const QStringList &list) {
- if (!list.isEmpty()) {
- throw strCase;
- }
-}
-
-
-// Private function for quickly building lists of diffs.
-QList<Diff> diff_match_patch_test::diffList(Diff d1, Diff d2, Diff d3, Diff d4, Diff d5,
- Diff d6, Diff d7, Diff d8, Diff d9, Diff d10) {
- // Diff(INSERT, NULL) is invalid and thus is used as the default argument.
- QList<Diff> listRet;
- if (d1.operation == INSERT && d1.text == NULL) {
- return listRet;
- }
- listRet << d1;
-
- if (d2.operation == INSERT && d2.text == NULL) {
- return listRet;
- }
- listRet << d2;
-
- if (d3.operation == INSERT && d3.text == NULL) {
- return listRet;
- }
- listRet << d3;
-
- if (d4.operation == INSERT && d4.text == NULL) {
- return listRet;
- }
- listRet << d4;
-
- if (d5.operation == INSERT && d5.text == NULL) {
- return listRet;
- }
- listRet << d5;
-
- if (d6.operation == INSERT && d6.text == NULL) {
- return listRet;
- }
- listRet << d6;
-
- if (d7.operation == INSERT && d7.text == NULL) {
- return listRet;
- }
- listRet << d7;
-
- if (d8.operation == INSERT && d8.text == NULL) {
- return listRet;
- }
- listRet << d8;
-
- if (d9.operation == INSERT && d9.text == NULL) {
- return listRet;
- }
- listRet << d9;
-
- if (d10.operation == INSERT && d10.text == NULL) {
- return listRet;
- }
- listRet << d10;
-
- return listRet;
-}
-
-
-/*
-Compile instructions for MinGW and QT4 on Windows:
-qmake -project
-qmake
-mingw32-make
-g++ -o diff_match_patch_test debug\diff_match_patch_test.o debug\diff_match_patch.o \qt4\lib\libQtCore4.a
-diff_match_patch_test.exe
-
-Compile insructions for OS X:
-qmake -spec macx-g++
-make
-./diff_match_patch
-*/
diff --git a/thirdparty/diff/diff_match_patch_test.h b/thirdparty/diff/diff_match_patch_test.h
deleted file mode 100644
index f2f2d9cd5..000000000
--- a/thirdparty/diff/diff_match_patch_test.h
+++ /dev/null
@@ -1,92 +0,0 @@
-/*
- * Copyright 2008 Google Inc. All Rights Reserved.
- * Author: fraser@google.com (Neil Fraser)
- * Author: mikeslemmer@gmail.com (Mike Slemmer)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Diff Match and Patch -- Test Harness
- * http://code.google.com/p/google-diff-match-patch/
- */
-
-#ifndef DIFF_MATCH_PATCH_TEST_H
-#define DIFF_MATCH_PATCH_TEST_H
-
-class diff_match_patch_test {
- public:
- diff_match_patch_test();
- void run_all_tests();
-
- // DIFF TEST FUNCTIONS
- void testDiffCommonPrefix();
- void testDiffCommonSuffix();
- void testDiffCommonOverlap();
- void testDiffHalfmatch();
- void testDiffLinesToChars();
- void testDiffCharsToLines();
- void testDiffCleanupMerge();
- void testDiffCleanupSemanticLossless();
- void testDiffCleanupSemantic();
- void testDiffCleanupEfficiency();
- void testDiffPrettyHtml();
- void testDiffText();
- void testDiffDelta();
- void testDiffXIndex();
- void testDiffLevenshtein();
- void testDiffBisect();
- void testDiffMain();
-
- // MATCH TEST FUNCTIONS
- void testMatchAlphabet();
- void testMatchBitap();
- void testMatchMain();
-
- // PATCH TEST FUNCTIONS
- void testPatchObj();
- void testPatchFromText();
- void testPatchToText();
- void testPatchAddContext();
- void testPatchMake();
- void testPatchSplitMax();
- void testPatchAddPadding();
- void testPatchApply();
-
- private:
- diff_match_patch dmp;
-
- // Define equality.
- void assertEquals(const QString &strCase, int n1, int n2);
- void assertEquals(const QString &strCase, const QString &s1, const QString &s2);
- void assertEquals(const QString &strCase, const Diff &d1, const Diff &d2);
- void assertEquals(const QString &strCase, const QList<Diff> &list1, const QList<Diff> &list2);
- void assertEquals(const QString &strCase, const QList<QVariant> &list1, const QList<QVariant> &list2);
- void assertEquals(const QString &strCase, const QVariant &var1, const QVariant &var2);
- void assertEquals(const QString &strCase, const QMap<QChar, int> &m1, const QMap<QChar, int> &m2);
- void assertEquals(const QString &strCase, const QStringList &list1, const QStringList &list2);
- void assertTrue(const QString &strCase, bool value);
- void assertFalse(const QString &strCase, bool value);
- void assertEmpty(const QString &strCase, const QStringList &list);
-
- // Construct the two texts which made up the diff originally.
- QStringList diff_rebuildtexts(QList<Diff> diffs);
- // Private function for quickly building lists of diffs.
- QList<Diff> diffList(
- // Diff(INSERT, NULL) is invalid and thus is used as the default argument.
- Diff d1 = Diff(INSERT, NULL), Diff d2 = Diff(INSERT, NULL),
- Diff d3 = Diff(INSERT, NULL), Diff d4 = Diff(INSERT, NULL),
- Diff d5 = Diff(INSERT, NULL), Diff d6 = Diff(INSERT, NULL),
- Diff d7 = Diff(INSERT, NULL), Diff d8 = Diff(INSERT, NULL),
- Diff d9 = Diff(INSERT, NULL), Diff d10 = Diff(INSERT, NULL));
-};
-
-#endif // DIFF_MATCH_PATCH_TEST_H
View Git Blame Copy Permalink