Update README.md

ci: switch to GitHub Actions.

.github/workflows/cpp.yml

@@ -0,0 +1,30 @@
+name: C++
+
+on: [push]
+jobs:
+
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Install scons and gtest
+      run: |
+        sudo apt-get install -y scons
+        sudo apt-get install -y cmake scons
+        wget https://github.com/google/googletest/archive/release-1.11.0.zip
+        unzip -q release-1.11.0.zip
+        cd googletest-release-1.11.0
+        cmake .
+        make
+        sudo make install
+
+    - name: Build examples
+      run: |
+        cd examples
+        scons
+
+    - name: Test
+      run: |
+        cd test
+        scons check

.gitignore

@@ -9,6 +9,7 @@ examples/intdiff3
 examples/patch
 examples/fpatch
 examples/st2ses
+examples/strdiff_storage
 test/strdiff3_test
 test/*/*/*_
 *.o

.travis.yml

@@ -1,18 +0,0 @@
-language: cpp
-compiler:
-  - gcc
-  - clang
-before_script:
-  - sudo apt-get install -y cmake
-  - wget https://github.com/google/googletest/archive/release-1.8.0.zip
-  - unzip -q release-1.8.0.zip
-  - cd googletest-release-1.8.0
-  - cmake .
-  - make
-  - sudo make install
-  - cd ..
-script:
-  - cd examples
-  - scons
-  - cd ../test
-  - scons check

ChangeLog

@@ -1,3 +1,9 @@
+2022-04-11 Tatsuhiko Kubo <cubicdaiya@gmail.com>
+
+	* bugfix: fixed invalid offset in unified format difference when difference is too large.
+
+	* 1.20 released
+
 2015-05-03 Tatsuhiko Kubo <cubicdaiya@gmail.com>
 
 	* added some minor changes.

README.md

@@ -1,6 +1,4 @@
-# dtl
+# dtl - forked from [https://github.com/cubicdaiya/dtl](https://github.com/cubicdaiya/dtl)
-
-[![Build Status](https://travis-ci.org/cubicdaiya/dtl.png?branch=master)](https://travis-ci.org/cubicdaiya/dtl)
 
 `dtl` is the diff template library written in C++. The name of template is derived C++'s Template.
 
@@ -8,30 +6,30 @@
 
  * [Features](#features)
  * [Getting started](#getting-started)
-  * [Compare two strings](#compare-two-strings)
+     * [Compare two strings](#compare-two-strings)
-  * [Compare two data has arbitrary type](#compare-two-data-has-arbitrary-type)
+     * [Compare two data has arbitrary type](#compare-two-data-has-arbitrary-type)
-  * [Merge three sequences](#merge-three-sequences)
+     * [Merge three sequences](#merge-three-sequences)
-  * [Patch function](#patch-function)
+     * [Patch function](#patch-function)
-  * [Difference as Unified Format](#difference-as-unified-format)
+     * [Difference as Unified Format](#difference-as-unified-format)
-  * [Compare large sequences](#compare-large-sequences)
+     * [Compare large sequences](#compare-large-sequences)
-  * [Unserious difference](#unserious-difference)
+     * [Unserious difference](#unserious-difference)
-  * [Calculate only Edit Distance](#calculate-only-edit-distance)
+     * [Calculate only Edit Distance](#calculate-only-edit-distance)
  * [Algorithm](#algorithm)
-  * [Computational complexity](#computational-complexity)
+     * [Computational complexity](#computational-complexity)
-  * [Comparison when difference between two sequences is very large](#comparison-when-difference-between-two-sequences-is-very-large)
+     * [Comparison when difference between two sequences is very large](#comparison-when-difference-between-two-sequences-is-very-large)
-  * [Implementations with various programming languages](#implementations-with-various-programming-languages)
+     * [Implementations with various programming languages](#implementations-with-various-programming-languages)
  * [Examples](#examples)
-  * [strdiff](#strdiff)
+     * [strdiff](#strdiff)
-  * [intdiff](#intdiff)
+     * [intdiff](#intdiff)
-  * [unidiff](#unidiff)
+     * [unidiff](#unidiff)
-  * [unistrdiff](#unistrdiff)
+     * [unistrdiff](#unistrdiff)
-  * [strdiff3](#strdiff3)
+     * [strdiff3](#strdiff3)
-  * [intdiff3](#intdiff3)
+     * [intdiff3](#intdiff3)
-  * [patch](#patch)
+     * [patch](#patch)
-  * [fpatch](#fpatch)
+     * [fpatch](#fpatch)
  * [Running tests](#running-tests)
-  * [Building test programs](#building-test-programs)
+     * [Building test programs](#building-test-programs)
-  * [Running test programs](#running-test-programs)
+     * [Running test programs](#running-test-programs)
  * [Old commit histories](#old-commit-histories)
  * [License](#license)
 
@@ -253,7 +251,7 @@ dtl::Diff<elem, sequence> d(A, B);
 d.compose();
 d.composeUnifiedHunks()
 string s1(A);
-string s2 = d.UniPatch(s1);
+string s2 = d.uniPatch(s1);
 ```
 
 When the above code is run, s2 becomes "abd".
@@ -650,14 +648,14 @@ $
 
 # Running tests
 
-`dtl` uses [googletest](http://code.google.com/p/googletest/) and [SCons](http://www.scons.org/) with testing dtl-self.
+`dtl` uses [googletest](https://github.com/google/googletest) and [SCons](http://www.scons.org/) with testing dtl-self.
 
 # Building test programs
 
 If you build test programs for `dtl`, run `scons` in test direcotry.
 
 ```bash
-$ GTEST_ROOT=${gtest_root_dir} scons
+$ scons
 ```
 
 # Running test programs
@@ -665,7 +663,7 @@ $ GTEST_ROOT=${gtest_root_dir} scons
 If you run all tests for `dtl`, run 'scons check' in test direcotry. (it is necessary that gtest is compiled)
 
 ```bash
-$ GTEST_ROOT=${gtest_root_dir} scons check
+$ scons check
 ```
 
 If you run sectional tests, you may exeucte `dtl_test` directly after you run `scons`.

dtl/Diff.hpp

@@ -67,6 +67,8 @@ namespace dtl {
         bool               editDistanceOnly;
         uniHunkVec         uniHunks;
         comparator         cmp;
+        long long          ox;
+        long long          oy;
     public :
         Diff () {}
         
@@ -162,7 +164,7 @@ namespace dtl {
             return trivial;
         }
         
-        void enableTrivial () const {
+        void enableTrivial () {
             this->trivial = true;
         }
         
@@ -260,7 +262,8 @@ namespace dtl {
             if (isHuge()) {
                 pathCordinates.reserve(MAX_CORDINATES_SIZE);
             }
-            
+            ox = 0;
+            oy = 0;
             long long p = -1;
             fp = new long long[M + N + 3];
             fill(&fp[0], &fp[M + N + 3], -1);
@@ -280,7 +283,7 @@ namespace dtl {
             
             editDistance += static_cast<long long>(delta) + 2 * p;
             long long r = path[delta+offset];
-            P cordinate;
+            P cordinate{};
             editPathCordinates epc(0);
             
             // recording edit distance only
@@ -341,6 +344,15 @@ namespace dtl {
             for_each (ses_v.begin (), ses_v.end(), PT < sesElem, stream > (out));
         }
 
+        /**
+         * store difference between A and B as an SES with custom storage
+         */
+        template < typename storedData, template < typename SEET, typename STRT > class ST >
+        void storeSES(storedData& sd) const {
+            sesElemVec ses_v = ses.getSequence();
+            for_each(ses_v.begin(), ses_v.end(), ST < sesElem, storedData >(sd));
+        }
+        
         /**
          * print difference between A and B in the Unified Format
          */
@@ -549,6 +561,8 @@ namespace dtl {
             trivial          = false;
             editDistanceOnly = false;
             fp               = NULL;
+            ox               = 0;
+            oy               = 0;
         }
         
         /**
@@ -586,18 +600,18 @@ namespace dtl {
                 while(px_idx < v[i].x || py_idx < v[i].y) {
                     if (v[i].y - v[i].x > py_idx - px_idx) {
                         if (!wasSwapped()) {
-                            ses.addSequence(*y, 0, y_idx, SES_ADD);
+                            ses.addSequence(*y, 0, y_idx + oy, SES_ADD);
                         } else {
-                            ses.addSequence(*y, y_idx, 0, SES_DELETE);
+                            ses.addSequence(*y, y_idx + oy, 0, SES_DELETE);
                         }
                         ++y;
                         ++y_idx;
                         ++py_idx;
                     } else if (v[i].y - v[i].x < py_idx - px_idx) {
                         if (!wasSwapped()) {
-                            ses.addSequence(*x, x_idx, 0, SES_DELETE);
+                            ses.addSequence(*x, x_idx + ox, 0, SES_DELETE);
                         } else {
-                            ses.addSequence(*x, 0, x_idx, SES_ADD);
+                            ses.addSequence(*x, 0, x_idx + ox, SES_ADD);
                         }
                         ++x;
                         ++x_idx;
@@ -605,10 +619,10 @@ namespace dtl {
                     } else {
                         if (!wasSwapped()) {
                             lcs.addSequence(*x);
-                            ses.addSequence(*x, x_idx, y_idx, SES_COMMON);
+                            ses.addSequence(*x, x_idx + ox, y_idx + oy, SES_COMMON);
                         } else {
                             lcs.addSequence(*y);
-                            ses.addSequence(*y, y_idx, x_idx, SES_COMMON);
+                            ses.addSequence(*y, y_idx + oy, x_idx + ox, SES_COMMON);
                         }
                         ++x;
                         ++y;
@@ -649,6 +663,8 @@ namespace dtl {
                 fp = new long long[M + N + 3];
                 fill(&fp[0], &fp[M + N + 3], -1);
                 fill(path.begin(), path.end(), -1);
+                ox = x_idx - 1;
+                oy = y_idx - 1;
                 return false;
             }
             return true;

dtl/functors.hpp

@@ -119,6 +119,20 @@ namespace dtl {
         stream& out_;
     };
 
+    /**
+     * storage class template
+     */
+    template <typename sesElem, typename storedData >
+    class Storage
+    {
+    public:
+        Storage(storedData& sd) : storedData_(sd) {}
+        virtual ~Storage() {}
+        virtual void operator() (const sesElem& se) const = 0;
+    protected:
+        storedData& storedData_;
+    };
+    
     /**
      * compare class template
      */

dtl/variables.hpp

@@ -63,7 +63,7 @@ namespace dtl {
     /**
      * version string
      */
-    const string version = "1.19";
+    const string version = "1.20";
 
     /**
      * type of edit for SES

examples/SConstruct

@@ -15,28 +15,29 @@ if os.sys.platform != "win32":
 conf = Configure(env);
 
 if not conf.CheckCXX():
-    print "The C++ compiler is not installed!"
+    print("The C++ compiler is not installed!")
     Exit(1)
 
 libs = ['stdc++']
 for lib in libs:
     if not conf.CheckLib(lib):
-        print "library " + lib + " not installed!"
+        print("library " + lib + " not installed!")
         Exit(1)
 
 conf.Finish()
 
-targets = { 'strdiff'    : ['strdiff.cpp',    'common.cpp'], # diff between two string sequences
+targets = { 'strdiff'         : ['strdiff.cpp',         'common.cpp'], # diff between two string sequences
-            'intdiff'    : ['intdiff.cpp'],                  # diff between two integer sequences
+            'intdiff'         : ['intdiff.cpp'],                       # diff between two integer sequences
-            'unidiff'    : ['unidiff.cpp',    'common.cpp'], # unified diff between two files
+            'unidiff'         : ['unidiff.cpp',         'common.cpp'], # unified diff between two files
-            'unistrdiff' : ['unistrdiff.cpp', 'common.cpp'], # unified diff between two strings
+            'unistrdiff'      : ['unistrdiff.cpp',      'common.cpp'], # unified diff between two strings
-            'bdiff'      : ['bdiff.cpp',      'common.cpp'], # diff between two byte sequences
+            'bdiff'           : ['bdiff.cpp',           'common.cpp'], # diff between two byte sequences
-            'strdiff3'   : ['strdiff3.cpp',   'common.cpp'], # three-way string diff program using dtl
+            'strdiff3'        : ['strdiff3.cpp',        'common.cpp'], # three-way string diff program using dtl
-            'intdiff3'   : ['intdiff3.cpp'],                 # three-way integer diff program using dtl
+            'intdiff3'        : ['intdiff3.cpp'],                      # three-way integer diff program using dtl
-            'patch'      : ['patch.cpp',      'common.cpp'], # string patch program using dtl
+            'patch'           : ['patch.cpp',           'common.cpp'], # string patch program using dtl
-            'fpatch'     : ['fpatch.cpp',     'common.cpp'], # file patch program using dtl
+            'fpatch'          : ['fpatch.cpp',          'common.cpp'], # file patch program using dtl
-            'st2ses'     : ['st2ses.cpp',     'common.cpp'], # convert SES format file to SES instance
+            'st2ses'          : ['st2ses.cpp',          'common.cpp'], # convert SES format file to SES instance
-            'strdiff_cp' : ['strdiff_cp.cpp', 'common.cpp'], # diff between two string sequences with custom printer
+            'strdiff_cp'      : ['strdiff_cp.cpp',      'common.cpp'], # diff between two string sequences with custom printer
+            'strdiff_storage' : ['strdiff_storage.cpp', 'common.cpp'], # diff between two string sequences with custom storage
             }
 
 [ env.Program(target, targets[target]) for target in targets ]

examples/printers.hpp

@@ -1,23 +1,25 @@
 #ifndef DTL_PRINTERS
 #define DTL_PRINTERS
 
+#include <dtl/dtl.hpp>
+
 template <typename sesElem, typename stream = ostream >
-class customChangePrinter : public Printer < sesElem, stream >
+class customChangePrinter : public dtl::Printer < sesElem, stream >
 {
 public :
-    customChangePrinter () : Printer < sesElem, stream > () {}
+    customChangePrinter () : dtl::Printer < sesElem, stream > () {}
-    customChangePrinter (stream& out) : Printer < sesElem, stream > (out) {}
+    customChangePrinter (stream& out) : dtl::Printer < sesElem, stream > (out) {}
     ~customChangePrinter () {}
     void operator() (const sesElem& se) const {
         switch (se.second.type) {
-        case SES_ADD:
+        case dtl::SES_ADD:
-            this->out_ << "Add: " << se.first << endl;
+            this->out_ << "Add: " << se.first << std::endl;
             break;
-        case SES_DELETE:
+        case dtl::SES_DELETE:
-            this->out_ << "Delete: " << se.first << endl;
+            this->out_ << "Delete: " << se.first << std::endl;
             break;
-        case SES_COMMON:
+        case dtl::SES_COMMON:
-            this->out_ << "Common: " << se.first << endl;
+            this->out_ << "Common: " << se.first << std::endl;
             break;
         }
     }

examples/storage.hpp

@@ -0,0 +1,27 @@
+#ifndef DTL_STORAGE
+#define DTL_STORAGE
+
+#include <dtl/dtl.hpp>
+
+template <typename sesElem, typename storedData >
+class CustomStorage : public dtl::Storage < sesElem, storedData >
+{
+public :
+    CustomStorage(storedData& sd) : dtl::Storage < sesElem, storedData > (sd) {}
+    ~CustomStorage() {}
+    void operator() (const sesElem& se) const {
+        switch (se.second.type) {
+        case dtl::SES_ADD:
+            this->storedData_ = this->storedData_ + "Add: " + se.first + "\n";
+            break;
+        case dtl::SES_DELETE:
+            this->storedData_ = this->storedData_ + "Delete: " + se.first + "\n";
+            break;
+        case dtl::SES_COMMON:
+            this->storedData_ = this->storedData_ + "Common: " + se.first + "\n";
+            break;
+        }
+    }
+};
+
+#endif // DTL_STORAGE

examples/strdiff_cp.cpp

@@ -1,19 +1,14 @@
-
 #include <dtl/dtl.hpp>
 #include "common.hpp"
 #include <iostream>
 #include <sstream>
 #include <string>
 
+#include "printers.hpp"
+
 using namespace std;
 
 using dtl::Diff;
-using dtl::SES_ADD;
-using dtl::SES_DELETE;
-using dtl::SES_COMMON;
-using dtl::Printer;
-
-#include "printers.hpp"
 
 int main(int argc, char *argv[]){
     

examples/strdiff_storage.cpp

@@ -0,0 +1,38 @@
+#include <dtl/dtl.hpp>
+#include "common.hpp"
+#include <iostream>
+#include <string>
+
+#include "storage.hpp"
+
+using namespace std;
+
+using dtl::Diff;
+
+int main(int argc, char *argv[]){
+    
+    if (isFewArgs(argc)) {
+        cerr << "Too few arguments." << endl;
+        return -1;
+    }
+    
+    typedef char   elem;
+    typedef string sequence;
+
+    sequence A(argv[1]);
+    sequence B(argv[2]);
+    
+    Diff< elem, sequence > d(A, B);
+    d.compose();
+    
+    // Shortest Edit Script
+    cout << "SES" << endl;
+
+    string result;
+
+    d.storeSES < string, CustomStorage > (result);
+
+    cout << result;
+    
+    return 0;
+}

test/Patchtest.cpp

@@ -35,6 +35,7 @@ protected :
         cases.push_back(createCase("abcdefq3wefarhgorequgho4euhfteowauhfwehogfewrquhoi23hroewhoahfotrhguoiewahrgqqabcdef",
                                    "3abcdef4976fd86ouofita67t85r876e5e746578tgliuhopoqqabcdef")); // 8
         cases.push_back(createCase("abcqqqeqqqccc", "abdqqqeqqqddd")); // 9
+        cases.push_back(createCase("aaaaaaaaaaaaa>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>aaaadsafabcaaaaaaaaaaaaaaaaaaewaaabdaaaaaabbb", "aaaaaaaaaaaaaaadasfdsafsadasdafbaaaaaaaaaaaaaaaaaeaaaaaaaaaae&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&saaabcaaaaaaccc")); // 10
     }
     
     void TearDown () {}
@@ -96,3 +97,8 @@ TEST_F (Patchtest, patch_test9) {
     ASSERT_EQ(cases[9].B, cases[9].diff.patch(cases[9].A));
     ASSERT_EQ(cases[9].B, cases[9].diff.uniPatch(cases[9].A));
 }
+
+TEST_F (Patchtest, patch_test10) {
+    ASSERT_EQ(cases[10].B, cases[10].diff.patch(cases[10].A));
+    ASSERT_EQ(cases[10].B, cases[10].diff.uniPatch(cases[10].A));
+}

test/SConstruct

@@ -11,18 +11,19 @@ def path_chomp(path):
 env  = Environment(
     CPPFLAGS=['-Wall', '-O2'],
     CPPPATH=['..'],
+	CXXFLAGS="-std=c++11",
 )
 
 conf = Configure(env);
 
 if not conf.CheckCXX():
-    print "c++ compiler is not installed!"
+    print("c++ compiler is not installed!")
     Exit(1)
 
 libs = ['stdc++', 'pthread', 'gtest']
 for lib in libs:
     if not conf.CheckLib(lib):
-        print "library " + lib + " not installed!"
+        print("library " + lib + " not installed!")
         Exit(1)
 
 conf.Finish()