[maven-release-plugin] prepare release java-diff-utils-parent-4.8

fixes #98 - deleted file mode
improved the documentation of DeltyType a bit
2026-03-13 10:11:17 +08:00 · 2020-09-27 22:07:59 +02:00 · 2020-09-27 22:04:44 +02:00 · 2020-09-27 22:03:18 +02:00 · 2020-09-27 21:48:59 +02:00 · 2020-09-27 18:13:03 +02:00
49 changed files with 1440 additions and 437 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -2,3 +2,5 @@
 build/
 nbproject/
 target/
+
+*.iml
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,7 +5,26 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 This project uses a custom versioning scheme (and not [Semantic Versioning](https://semver.org/spec/v2.0.0.html)).

-## [Unreleased]
+## [unreleased]
+
+### Changed
+
+## [4.8]
+
+### Changed
+
+* some bugfixes regarding unified diff writer
+* UnifiedDiffReader improved for **deleted file mode** and better timestamp recognition
+* UnifiedDiffReader improved for **new file mode** and better timestamp recognition
+
+## [4.7]
+
+### Changed 
+
+* minor bug fixes
+* optional include equal parts of original and revised data
+* **API** change: removed DiffException completely
+* added possibility to **process diffs** to for instance show whitespace characters

 ## [4.4] – 2019-11-06

@@ -82,8 +101,10 @@ This project uses a custom versioning scheme (and not [Semantic Versioning](http
 * Ant build script
 * Generate output in unified diff format (thanks for Bill James)

-[Unreleased]: https://github.com/java-diff-utils/java-diff-utils/compare/java-diff-utils-4.0...HEAD
-[4.0]: https://github.com/java-diff-utils/java-diff-utils/compare/diff-utils-3.0...java-diff-utils-4.0
-[3.0]: https://github.com/java-diff-utils/java-diff-utils/compare/diff-utils-2.2...diff-utils-3.0
-[2.2]: https://github.com/java-diff-utils/java-diff-utils/compare/diff-utils-2.0...diff-utils-2.2
+[Unreleased]: https://github.com/java-diff-utils/java-diff-utils/compare/java-diff-utils-parent-4.5...HEAD
+[4.5]: https://github.com/java-diff-utils/java-diff-utils/compare/java-diff-utils-parent-4.4...java-diff-utils-parent-4.5
+[4.4]: https://github.com/java-diff-utils/java-diff-utils/compare/java-diff-utils-4.0...java-diff-utils-parent-4.4
+[4.0]: https://github.com/java-diff-utils/java-diff-utils/compare/diffutils-3.0...java-diff-utils-4.0
+[3.0]: https://github.com/java-diff-utils/java-diff-utils/compare/diffutils-2.2...diffutils-3.0
+[2.2]: https://github.com/java-diff-utils/java-diff-utils/compare/diffutils-2.0...diffutils-2.2

--- a/README.md
+++ b/README.md
@@ -14,6 +14,10 @@ Main reason to build this library was the lack of easy-to-use libraries with all

 **This is originally a fork of java-diff-utils from Google Code Archive.**

+## API
+
+Javadocs of the actual release version: [JavaDocs java-diff-utils](https://java-diff-utils.github.io/java-diff-utils/4.7/docs/api/)
+
 ## Examples

 Look [here](https://github.com/wumpz/java-diff-utils/wiki) to find more helpful informations and examples.
@@ -80,7 +84,7 @@ Just add the code below to your maven dependencies:
 <dependency>
    <groupId>io.github.java-diff-utils</groupId>
    <artifactId>java-diff-utils</artifactId>
-    <version>4.4</version>
+    <version>4.5</version>
 </dependency>
 ```

@@ -88,5 +92,5 @@ or using gradle:

 ```groovy
 // https://mvnrepository.com/artifact/io.github.java-diff-utils/java-diff-utils
-implementation "io.github.java-diff-utils:java-diff-utils:4.4"
+implementation "io.github.java-diff-utils:java-diff-utils:4.5"
 ```
--- a/_config.yml
+++ b/_config.yml
@@ -1 +0,0 @@
-theme: jekyll-theme-minimal
--- a/java-diff-utils-jgit/nb-configuration.xml
+++ b/java-diff-utils-jgit/nb-configuration.xml
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project-shared-configuration>
+    <!--
+This file contains additional configuration written by modules in the NetBeans IDE.
+The configuration is intended to be shared among all the users of project and
+therefore it is assumed to be part of version control checkout.
+Without this configuration present, some functionality in the IDE may be limited or fail altogether.
+-->
+    <properties xmlns="http://www.netbeans.org/ns/maven-properties-data/1">
+        <!--
+Properties that influence various parts of the IDE, especially code formatting and the like. 
+You can copy and paste the single properties, into the pom.xml file and the IDE will pick them up.
+That way multiple projects can share the same settings (useful for formatting rules for example).
+Any value defined here will override the pom.xml file value but is only applicable to the current project.
+-->
+        <netbeans.compile.on.save>none</netbeans.compile.on.save>
+    </properties>
+</project-shared-configuration>
--- a/java-diff-utils-jgit/pom.xml
+++ b/java-diff-utils-jgit/pom.xml
@@ -4,25 +4,23 @@
    <parent>
        <groupId>io.github.java-diff-utils</groupId>
        <artifactId>java-diff-utils-parent</artifactId>
-        <version>4.5</version>
+        <version>4.8</version>
    </parent>
    <artifactId>java-diff-utils-jgit</artifactId>
    <name>java-diff-utils-jgit</name>
    <packaging>jar</packaging>
    <description>This is an extension of java-diff-utils using jgit to use its implementation of
-some difference algorithms.</description>
+        some difference algorithms.</description>
    <dependencies>
        <dependency>
-            <groupId>junit</groupId>
-            <artifactId>junit</artifactId>
-            <version>4.12</version>
-            <type>jar</type>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.eclipse.jgit</groupId>
            <artifactId>org.eclipse.jgit</artifactId>
-            <version>4.4.1.201607150455-r</version>
+            <version>5.8.1.202007141445-r</version>
            <exclusions>
                <exclusion>
                    <groupId>com.googlecode.javaewah</groupId>
--- a/java-diff-utils-jgit/src/test/java/com/github/difflib/algorithm/jgit/HistogramDiffTest.java
+++ b/java-diff-utils-jgit/src/test/java/com/github/difflib/algorithm/jgit/HistogramDiffTest.java
@@ -21,12 +21,9 @@ import com.github.difflib.patch.PatchFailedException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
-import org.junit.After;
-import org.junit.AfterClass;
-import static org.junit.Assert.*;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import org.junit.jupiter.api.Test;

 /**
 *
@@ -37,22 +34,6 @@ public class HistogramDiffTest {
    public HistogramDiffTest() {
    }

-    @BeforeClass
-    public static void setUpClass() {
-    }
-
-    @AfterClass
-    public static void tearDownClass() {
-    }
-
-    @Before
-    public void setUp() {
-    }
-
-    @After
-    public void tearDown() {
-    }
-
    /**
     * Test of diff method, of class HistogramDiff.
     */
@@ -101,6 +82,6 @@ public class HistogramDiffTest {
        assertEquals(revList, patched);
        
        System.out.println(logdata);
-        assertEquals(17, logdata.size());
+        assertEquals(19, logdata.size());
    }
 }
--- a/java-diff-utils-jgit/src/test/java/com/github/difflib/algorithm/jgit/LRHistogramDiffTest.java
+++ b/java-diff-utils-jgit/src/test/java/com/github/difflib/algorithm/jgit/LRHistogramDiffTest.java
@@ -28,12 +28,9 @@ import java.util.ArrayList;
 import java.util.List;
 import static java.util.stream.Collectors.toList;
 import java.util.zip.ZipFile;
-import org.junit.After;
-import org.junit.AfterClass;
-import static org.junit.Assert.*;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.Test;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import org.junit.jupiter.api.Test;

 /**
 *
@@ -41,25 +38,6 @@ import org.junit.Test;
 */
 public class LRHistogramDiffTest {

-    public LRHistogramDiffTest() {
-    }
-
-    @BeforeClass
-    public static void setUpClass() {
-    }
-
-    @AfterClass
-    public static void tearDownClass() {
-    }
-
-    @Before
-    public void setUp() {
-    }
-
-    @After
-    public void tearDown() {
-    }
-
    @Test
    public void testPossibleDiffHangOnLargeDatasetDnaumenkoIssue26() throws IOException, PatchFailedException {
        ZipFile zip = new ZipFile("target/test-classes/mocks/large_dataset1.zip");
--- a/java-diff-utils/nb-configuration.xml
+++ b/java-diff-utils/nb-configuration.xml
@@ -14,5 +14,6 @@ That way multiple projects can share the same settings (useful for formatting ru
 Any value defined here will override the pom.xml file value but is only applicable to the current project.
 -->
        <netbeans.hint.jdkPlatform>JDK_1.8</netbeans.hint.jdkPlatform>
+        <netbeans.compile.on.save>none</netbeans.compile.on.save>
    </properties>
 </project-shared-configuration>
--- a/java-diff-utils/pom.xml
+++ b/java-diff-utils/pom.xml
@@ -7,7 +7,7 @@
    <parent>
        <groupId>io.github.java-diff-utils</groupId>
        <artifactId>java-diff-utils-parent</artifactId>
-        <version>4.5</version>
+        <version>4.8</version>
    </parent>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
@@ -15,16 +15,13 @@

    <dependencies>
        <dependency>
-            <groupId>junit</groupId>
-            <artifactId>junit</artifactId>
-            <version>4.12</version>
-            <type>jar</type>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.assertj</groupId>
            <artifactId>assertj-core</artifactId>
-            <version>3.11.1</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
@@ -54,6 +51,16 @@
                    </archive>
                </configuration>
            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <configuration>
+                    <trimStackTrace>false</trimStackTrace>
+                    <systemPropertyVariables>
+                        <java.util.logging.config.file>target/test-classes/logging.properties</java.util.logging.config.file>
+                    </systemPropertyVariables>
+                </configuration>
+            </plugin>
        </plugins>
    </build>
 </project>
--- a/java-diff-utils/src/main/java/com/github/difflib/DiffUtils.java
+++ b/java-diff-utils/src/main/java/com/github/difflib/DiffUtils.java
@@ -17,7 +17,6 @@ package com.github.difflib;

 import com.github.difflib.algorithm.DiffAlgorithmI;
 import com.github.difflib.algorithm.DiffAlgorithmListener;
-import com.github.difflib.algorithm.DiffException;
 import com.github.difflib.algorithm.myers.MyersDiff;
 import com.github.difflib.patch.AbstractDelta;
 import com.github.difflib.patch.Patch;
@@ -31,50 +30,56 @@ import java.util.function.BiPredicate;

 /**
 * Implements the difference and patching engine
- *
- * @author <a href="dm.naumenko@gmail.com">Dmitry Naumenko</a>
 */
 public final class DiffUtils {

    /**
-     * Computes the difference between the original and revised list of elements with default diff algorithm
+     * Computes the difference between the original and revised list of elements with default diff
+     * algorithm
     *
+     * @param <T> types to be diffed
     * @param original The original text. Must not be {@code null}.
     * @param revised The revised text. Must not be {@code null}.
     * @param progress progress listener
-     * @return The patch describing the difference between the original and revised sequences. Never {@code null}.
-     * @throws com.github.difflib.algorithm.DiffException
+     * @return The patch describing the difference between the original and revised sequences. Never
+     * {@code null}.
     */
-    public static <T> Patch<T> diff(List<T> original, List<T> revised, DiffAlgorithmListener progress) throws DiffException {
+    public static <T> Patch<T> diff(List<T> original, List<T> revised, DiffAlgorithmListener progress) {
        return DiffUtils.diff(original, revised, new MyersDiff<>(), progress);
    }
-    
-    public static <T> Patch<T> diff(List<T> original, List<T> revised) throws DiffException {
+
+    public static <T> Patch<T> diff(List<T> original, List<T> revised) {
        return DiffUtils.diff(original, revised, new MyersDiff<>(), null);
    }
+    
+    public static <T> Patch<T> diff(List<T> original, List<T> revised, boolean includeEqualParts) {
+        return DiffUtils.diff(original, revised, new MyersDiff<>(), null, includeEqualParts);
+    }

    /**
     * Computes the difference between the original and revised text.
     */
    public static Patch<String> diff(String sourceText, String targetText,
-            DiffAlgorithmListener progress) throws DiffException {
+            DiffAlgorithmListener progress) {
        return DiffUtils.diff(
-                 Arrays.asList(sourceText.split("\n")), 
-                 Arrays.asList(targetText.split("\n")), progress);
+                Arrays.asList(sourceText.split("\n")),
+                Arrays.asList(targetText.split("\n")), progress);
    }

    /**
-     * Computes the difference between the original and revised list of elements with default diff algorithm
+     * Computes the difference between the original and revised list of elements with default diff
+     * algorithm
     *
     * @param source The original text. Must not be {@code null}.
     * @param target The revised text. Must not be {@code null}.
     *
-     * @param equalizer the equalizer object to replace the default compare algorithm (Object.equals). If {@code null}
-     * the default equalizer of the default algorithm is used..
-     * @return The patch describing the difference between the original and revised sequences. Never {@code null}.
+     * @param equalizer the equalizer object to replace the default compare algorithm
+     * (Object.equals). If {@code null} the default equalizer of the default algorithm is used..
+     * @return The patch describing the difference between the original and revised sequences. Never
+     * {@code null}.
     */
    public static <T> Patch<T> diff(List<T> source, List<T> target,
-            BiPredicate<T, T> equalizer) throws DiffException {
+            BiPredicate<T, T> equalizer) {
        if (equalizer != null) {
            return DiffUtils.diff(source, target,
                    new MyersDiff<>(equalizer));
@@ -82,46 +87,57 @@ public final class DiffUtils {
        return DiffUtils.diff(source, target, new MyersDiff<>());
    }

+    public static <T> Patch<T> diff(List<T> original, List<T> revised,
+            DiffAlgorithmI<T> algorithm, DiffAlgorithmListener progress) {
+        return diff(original, revised, algorithm, progress, false);
+    }
+    
    /**
-     * Computes the difference between the original and revised list of elements with default diff algorithm
+     * Computes the difference between the original and revised list of elements with default diff
+     * algorithm
     *
     * @param original The original text. Must not be {@code null}.
     * @param revised The revised text. Must not be {@code null}.
     * @param algorithm The diff algorithm. Must not be {@code null}.
     * @param progress The diff algorithm listener.
-     * @return The patch describing the difference between the original and revised sequences. Never {@code null}.
+     * @param includeEqualParts Include equal data parts into the patch.
+     * @return The patch describing the difference between the original and revised sequences. Never
+     * {@code null}.
     */
    public static <T> Patch<T> diff(List<T> original, List<T> revised,
-            DiffAlgorithmI<T> algorithm, DiffAlgorithmListener progress) throws DiffException {
+            DiffAlgorithmI<T> algorithm, DiffAlgorithmListener progress, 
+            boolean includeEqualParts) {
        Objects.requireNonNull(original, "original must not be null");
        Objects.requireNonNull(revised, "revised must not be null");
        Objects.requireNonNull(algorithm, "algorithm must not be null");

-        return Patch.generate(original, revised, algorithm.computeDiff(original, revised, progress));
+        return Patch.generate(original, revised, algorithm.computeDiff(original, revised, progress), includeEqualParts);
    }
-    
+
    /**
-     * Computes the difference between the original and revised list of elements with default diff algorithm
+     * Computes the difference between the original and revised list of elements with default diff
+     * algorithm
     *
     * @param original The original text. Must not be {@code null}.
     * @param revised The revised text. Must not be {@code null}.
     * @param algorithm The diff algorithm. Must not be {@code null}.
-     * @return The patch describing the difference between the original and revised sequences. Never {@code null}.
+     * @return The patch describing the difference between the original and revised sequences. Never
+     * {@code null}.
     */
-     public static <T> Patch<T> diff(List<T> original, List<T> revised,
-            DiffAlgorithmI<T> algorithm) throws DiffException {
-         return diff(original, revised, algorithm, null);
-     }
+    public static <T> Patch<T> diff(List<T> original, List<T> revised, DiffAlgorithmI<T> algorithm) {
+        return diff(original, revised, algorithm, null);
+    }

    /**
-     * Computes the difference between the given texts inline. This one uses the "trick" to make out of texts lists of
-     * characters, like DiffRowGenerator does and merges those changes at the end together again.
+     * Computes the difference between the given texts inline. This one uses the "trick" to make out
+     * of texts lists of characters, like DiffRowGenerator does and merges those changes at the end
+     * together again.
     *
     * @param original
     * @param revised
     * @return
     */
-    public static Patch<String> diffInline(String original, String revised) throws DiffException {
+    public static Patch<String> diffInline(String original, String revised) {
        List<String> origList = new ArrayList<>();
        List<String> revList = new ArrayList<>();
        for (Character character : original.toCharArray()) {
--- a/java-diff-utils/src/main/java/com/github/difflib/UnifiedDiffUtils.java
+++ b/java-diff-utils/src/main/java/com/github/difflib/UnifiedDiffUtils.java
@@ -21,6 +21,7 @@ import com.github.difflib.patch.AbstractDelta;
 import com.github.difflib.patch.Patch;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Optional;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;

@@ -32,6 +33,7 @@ public final class UnifiedDiffUtils {

    private static final Pattern UNIFIED_DIFF_CHUNK_REGEXP = Pattern
            .compile("^@@\\s+-(?:(\\d+)(?:,(\\d+))?)\\s+\\+(?:(\\d+)(?:,(\\d+))?)\\s+@@$");
+    private static final String NULL_FILE_INDICATOR = "/dev/null";

    /**
     * Parse the given text in unified format and creates the list of deltas for it.
@@ -59,25 +61,7 @@ public final class UnifiedDiffUtils {
            Matcher m = UNIFIED_DIFF_CHUNK_REGEXP.matcher(line);
            if (m.find()) {
                // Process the lines in the previous chunk
-                if (!rawChunk.isEmpty()) {
-                    List<String> oldChunkLines = new ArrayList<>();
-                    List<String> newChunkLines = new ArrayList<>();
-
-                    for (String[] raw_line : rawChunk) {
-                        tag = raw_line[0];
-                        rest = raw_line[1];
-                        if (" ".equals(tag) || "-".equals(tag)) {
-                            oldChunkLines.add(rest);
-                        }
-                        if (" ".equals(tag) || "+".equals(tag)) {
-                            newChunkLines.add(rest);
-                        }
-                    }
-                    patch.addDelta(new ChangeDelta<>(new Chunk<>(
-                            old_ln - 1, oldChunkLines), new Chunk<>(
-                            new_ln - 1, newChunkLines)));
-                    rawChunk.clear();
-                }
+                processLinesInPrevChunk(rawChunk, patch, old_ln, new_ln);
                // Parse the @@ header
                old_ln = m.group(1) == null ? 1 : Integer.parseInt(m.group(1));
                new_ln = m.group(3) == null ? 1 : Integer.parseInt(m.group(3));
@@ -102,33 +86,50 @@ public final class UnifiedDiffUtils {
        }

        // Process the lines in the last chunk
-        if (!rawChunk.isEmpty()) {
-            List<String> oldChunkLines = new ArrayList<>();
-            List<String> newChunkLines = new ArrayList<>();
-
-            for (String[] raw_line : rawChunk) {
-                tag = raw_line[0];
-                rest = raw_line[1];
-                if (" ".equals(tag) || "-".equals(tag)) {
-                    oldChunkLines.add(rest);
-                }
-                if (" ".equals(tag) || "+".equals(tag)) {
-                    newChunkLines.add(rest);
-                }
-            }
-
-            patch.addDelta(new ChangeDelta<>(new Chunk<>(
-                    old_ln - 1, oldChunkLines), new Chunk<>(new_ln - 1,
-                    newChunkLines)));
-            rawChunk.clear();
-        }
+        processLinesInPrevChunk(rawChunk, patch, old_ln, new_ln);

        return patch;
    }

+    private static void processLinesInPrevChunk(List<String[]> rawChunk, Patch<String> patch, int old_ln, int new_ln) {
+        String tag;
+        String rest;
+        if (!rawChunk.isEmpty()) {
+            List<String> oldChunkLines = new ArrayList<>();
+            List<String> newChunkLines = new ArrayList<>();
+
+            List<Integer> removePosition = new ArrayList<>();
+            List<Integer> addPosition = new ArrayList<>();
+            int removeNum = 0;
+            int addNum = 0;
+            for (String[] raw_line : rawChunk) {
+                tag = raw_line[0];
+                rest = raw_line[1];
+                if (" ".equals(tag) || "-".equals(tag)) {
+                    removeNum++;
+                    oldChunkLines.add(rest);
+                    if ("-".equals(tag)) {
+                        removePosition.add(old_ln - 1 + removeNum);
+                    }
+                }
+                if (" ".equals(tag) || "+".equals(tag)) {
+                    addNum++;
+                    newChunkLines.add(rest);
+                    if ("+".equals(tag)) {
+                        addPosition.add(new_ln - 1 + addNum);
+                    }
+                }
+            }
+            patch.addDelta(new ChangeDelta<>(new Chunk<>(
+                    old_ln - 1, oldChunkLines, removePosition), new Chunk<>(
+                    new_ln - 1, newChunkLines, addPosition)));
+            rawChunk.clear();
+        }
+    }
+
    /**
-     * generateUnifiedDiff takes a Patch and some other arguments, returning the Unified Diff format text representing
-     * the Patch.
+     * generateUnifiedDiff takes a Patch and some other arguments, returning the Unified Diff format
+     * text representing the Patch.
     *
     * @param originalFileName - Filename of the original (unrevised file)
     * @param revisedFileName - Filename of the revised file
@@ -143,8 +144,8 @@ public final class UnifiedDiffUtils {
            int contextSize) {
        if (!patch.getDeltas().isEmpty()) {
            List<String> ret = new ArrayList<>();
-            ret.add("--- " + originalFileName);
-            ret.add("+++ " + revisedFileName);
+            ret.add("--- " + Optional.ofNullable(originalFileName).orElse(NULL_FILE_INDICATOR));
+            ret.add("+++ " + Optional.ofNullable(revisedFileName).orElse(NULL_FILE_INDICATOR));

            List<AbstractDelta<String>> patchDeltas = new ArrayList<>(
                    patch.getDeltas());
@@ -179,7 +180,7 @@ public final class UnifiedDiffUtils {
                        // then create a new set and add the current Delta to
                        // it.
                        List<String> curBlock = processDeltas(originalLines,
-                                deltas, contextSize);
+                                deltas, contextSize, false);
                        ret.addAll(curBlock);
                        deltas.clear();
                        deltas.add(nextDelta);
@@ -190,7 +191,7 @@ public final class UnifiedDiffUtils {
            }
            // don't forget to process the last set of Deltas
            List<String> curBlock = processDeltas(originalLines, deltas,
-                    contextSize);
+                    contextSize, patchDeltas.size() == 1 && originalFileName == null);
            ret.addAll(curBlock);
            return ret;
        }
@@ -198,7 +199,8 @@ public final class UnifiedDiffUtils {
    }

    /**
-     * processDeltas takes a list of Deltas and outputs them together in a single block of Unified-Diff-format text.
+     * processDeltas takes a list of Deltas and outputs them together in a single block of
+     * Unified-Diff-format text.
     *
     * @param origLines - the lines of the original file
     * @param deltas - the Deltas to be output as a single block
@@ -207,18 +209,22 @@ public final class UnifiedDiffUtils {
     * @author Bill James (tankerbay@gmail.com)
     */
    private static List<String> processDeltas(List<String> origLines,
-            List<AbstractDelta<String>> deltas, int contextSize) {
+            List<AbstractDelta<String>> deltas, int contextSize, boolean newFile) {
        List<String> buffer = new ArrayList<>();
        int origTotal = 0; // counter for total lines output from Original
        int revTotal = 0; // counter for total lines output from Original
        int line;

        AbstractDelta<String> curDelta = deltas.get(0);
-
-        // NOTE: +1 to overcome the 0-offset Position
-        int origStart = curDelta.getSource().getPosition() + 1 - contextSize;
-        if (origStart < 1) {
-            origStart = 1;
+        int origStart;
+        if (newFile) {
+            origStart = 0;
+        } else {
+            // NOTE: +1 to overcome the 0-offset Position
+            origStart = curDelta.getSource().getPosition() + 1 - contextSize;
+            if (origStart < 1) {
+                origStart = 1;
+            }
        }

        int revStart = curDelta.getTarget().getPosition() + 1 - contextSize;
--- a/java-diff-utils/src/main/java/com/github/difflib/algorithm/DiffAlgorithmI.java
+++ b/java-diff-utils/src/main/java/com/github/difflib/algorithm/DiffAlgorithmI.java
@@ -22,6 +22,7 @@ import java.util.List;
 * Interface of a diff algorithm.
 *
 * @author Tobias Warneke (t.warneke@gmx.net)
+ * @param <T> type of data that is diffed.
 */
 public interface DiffAlgorithmI<T> {

@@ -32,9 +33,8 @@ public interface DiffAlgorithmI<T> {
     * @param target target data
     * @param progress progress listener
     * @return
-     * @throws DiffException
     */
-    List<Change> computeDiff(List<T> source, List<T> target, DiffAlgorithmListener progress) throws DiffException;
+    List<Change> computeDiff(List<T> source, List<T> target, DiffAlgorithmListener progress);

    /**
     * Simple extension to compute a changeset using arrays.
@@ -43,9 +43,8 @@ public interface DiffAlgorithmI<T> {
     * @param target
     * @param progress
     * @return
-     * @throws com.github.difflib.algorithm.DiffException
     */
-    default List<Change> computeDiff(T[] source, T[] target, DiffAlgorithmListener progress) throws DiffException {
+    default List<Change> computeDiff(T[] source, T[] target, DiffAlgorithmListener progress) {
        return computeDiff(Arrays.asList(source), Arrays.asList(target), progress);
    }
 }
--- a/java-diff-utils/src/main/java/com/github/difflib/algorithm/DiffException.java
+++ b/java-diff-utils/src/main/java/com/github/difflib/algorithm/DiffException.java
@@ -1,28 +0,0 @@
-/*
- * Copyright 2009-2017 java-diff-utils.
- *
- * 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.
- */
-package com.github.difflib.algorithm;
-
-public class DiffException extends Exception {
-
-    private static final long serialVersionUID = 1L;
-
-    public DiffException() {
-    }
-
-    public DiffException(String msg) {
-        super(msg);
-    }
-}
--- a/java-diff-utils/src/main/java/com/github/difflib/algorithm/DifferentiationFailedException.java
+++ b/java-diff-utils/src/main/java/com/github/difflib/algorithm/DifferentiationFailedException.java
@@ -1,34 +0,0 @@
-/*
- * Copyright 2009-2017 java-diff-utils.
- *
- * 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.
- */
-package com.github.difflib.algorithm;
-
-/**
- * Thrown whenever the differencing engine cannot produce the differences between two revisions of ta text.
- *
- * @see com.github.difflib.algorithm.myers.MyersDiff
- * @see DiffAlgorithmI
- */
-public class DifferentiationFailedException extends DiffException {
-
-    private static final long serialVersionUID = 1L;
-
-    public DifferentiationFailedException() {
-    }
-
-    public DifferentiationFailedException(String msg) {
-        super(msg);
-    }
-}
--- a/java-diff-utils/src/main/java/com/github/difflib/algorithm/myers/MyersDiff.java
+++ b/java-diff-utils/src/main/java/com/github/difflib/algorithm/myers/MyersDiff.java
@@ -18,8 +18,6 @@ package com.github.difflib.algorithm.myers;
 import com.github.difflib.algorithm.Change;
 import com.github.difflib.algorithm.DiffAlgorithmI;
 import com.github.difflib.algorithm.DiffAlgorithmListener;
-import com.github.difflib.algorithm.DiffException;
-import com.github.difflib.algorithm.DifferentiationFailedException;
 import com.github.difflib.patch.DeltaType;
 import com.github.difflib.patch.Patch;
 import java.util.ArrayList;
@@ -50,7 +48,7 @@ public final class MyersDiff<T> implements DiffAlgorithmI<T> {
     * Return empty diff if get the error while procession the difference.
     */
    @Override
-    public List<Change> computeDiff(final List<T> source, final List<T> target, DiffAlgorithmListener progress) throws DiffException {
+    public List<Change> computeDiff(final List<T> source, final List<T> target, DiffAlgorithmListener progress) {
        Objects.requireNonNull(source, "source list must not be null");
        Objects.requireNonNull(target, "target list must not be null");

@@ -74,8 +72,7 @@ public final class MyersDiff<T> implements DiffAlgorithmI<T> {
     * @return A minimum {@link PathNode Path} accross the differences graph.
     * @throws DifferentiationFailedException if a diff path could not be found.
     */
-    private PathNode buildPath(final List<T> orig, final List<T> rev, DiffAlgorithmListener progress)
-            throws DifferentiationFailedException {
+    private PathNode buildPath(final List<T> orig, final List<T> rev, DiffAlgorithmListener progress) {
        Objects.requireNonNull(orig, "original sequence is null");
        Objects.requireNonNull(rev, "revised sequence is null");

@@ -132,7 +129,7 @@ public final class MyersDiff<T> implements DiffAlgorithmI<T> {
            diagonal[middle + d - 1] = null;
        }
        // According to Myers, this cannot happen
-        throw new DifferentiationFailedException("could not find a diff path");
+        throw new IllegalStateException("could not find a diff path");
    }

    /**
--- a/java-diff-utils/src/main/java/com/github/difflib/patch/AbstractDelta.java
+++ b/java-diff-utils/src/main/java/com/github/difflib/patch/AbstractDelta.java
@@ -60,6 +60,11 @@ public abstract class AbstractDelta<T> {
    public abstract void applyTo(List<T> target) throws PatchFailedException;
    
    public abstract void restore(List<T> target);
+    
+    /**
+     * Create a new delta of the actual instance with customized chunk data.
+     */
+    public abstract AbstractDelta<T> withChunks(Chunk<T> original, Chunk<T> revised);

    @Override
    public int hashCode() {
--- a/java-diff-utils/src/main/java/com/github/difflib/patch/ChangeDelta.java
+++ b/java-diff-utils/src/main/java/com/github/difflib/patch/ChangeDelta.java
@@ -72,4 +72,9 @@ public final class ChangeDelta<T> extends AbstractDelta<T> {
        return "[ChangeDelta, position: " + getSource().getPosition() + ", lines: "
                + getSource().getLines() + " to " + getTarget().getLines() + "]";
    }
+
+    @Override
+    public AbstractDelta<T> withChunks(Chunk<T> original, Chunk<T> revised) {
+        return new ChangeDelta(original, revised);
+    }
 }
--- a/java-diff-utils/src/main/java/com/github/difflib/patch/Chunk.java
+++ b/java-diff-utils/src/main/java/com/github/difflib/patch/Chunk.java
@@ -37,6 +37,20 @@ public final class Chunk<T> {

    private final int position;
    private List<T> lines;
+    private final List<Integer> changePosition;
+
+    /**
+     * Creates a chunk and saves a copy of affected lines
+     *
+     * @param position the start position
+     * @param lines the affected lines
+     * @param changePosition the positions of changed lines
+     */
+    public Chunk(int position, List<T> lines, List<Integer> changePosition) {
+        this.position = position;
+        this.lines = new ArrayList<>(lines);
+        this.changePosition = changePosition;
+    }

    /**
     * Creates a chunk and saves a copy of affected lines
@@ -45,8 +59,20 @@ public final class Chunk<T> {
     * @param lines the affected lines
     */
    public Chunk(int position, List<T> lines) {
+        this(position, lines, null);
+    }
+
+    /**
+     * Creates a chunk and saves a copy of affected lines
+     *
+     * @param position the start position
+     * @param lines the affected lines
+     * @param changePosition the positions of changed lines
+     */
+    public Chunk(int position, T[] lines, List<Integer> changePosition) {
        this.position = position;
-        this.lines = new ArrayList<>(lines);
+        this.lines = Arrays.asList(lines);
+        this.changePosition = changePosition;
    }

    /**
@@ -56,8 +82,7 @@ public final class Chunk<T> {
     * @param lines the affected lines
     */
    public Chunk(int position, T[] lines) {
-        this.position = position;
-        this.lines = Arrays.asList(lines);
+        this(position, lines, null);
    }

    /**
@@ -96,6 +121,13 @@ public final class Chunk<T> {
        return lines;
    }

+    /**
+     * @return the positions of changed lines of chunk in the text
+     */
+    public List<Integer> getChangePosition() {
+        return changePosition;
+    }
+
    public int size() {
        return lines.size();
    }
--- a/java-diff-utils/src/main/java/com/github/difflib/patch/DeleteDelta.java
+++ b/java-diff-utils/src/main/java/com/github/difflib/patch/DeleteDelta.java
@@ -59,4 +59,9 @@ public final class DeleteDelta<T> extends AbstractDelta<T> {
        return "[DeleteDelta, position: " + getSource().getPosition() + ", lines: "
                + getSource().getLines() + "]";
    }
+    
+    @Override
+    public AbstractDelta<T> withChunks(Chunk<T> original, Chunk<T> revised) {
+        return new DeleteDelta(original, revised);
+    }
 }
--- a/java-diff-utils/src/main/java/com/github/difflib/patch/DeltaType.java
+++ b/java-diff-utils/src/main/java/com/github/difflib/patch/DeltaType.java
@@ -16,7 +16,18 @@
 package com.github.difflib.patch;

 /**
- * Specifies the type of the delta.
+ * Specifies the type of the delta. There are three types of modifications from  
+ * the original to get the revised text. 
+ * 
+ * CHANGE: a block of data of the original is replaced by another block of data.
+ * DELETE: a block of data of the original is removed
+ * INSERT: at a position of the original a block of data is inserted
+ * 
+ * to be complete there is also 
+ * 
+ * EQUAL: a block of data of original and the revised text is equal
+ * 
+ * which is no change at all.
 *
 */
 public enum DeltaType {
--- a/java-diff-utils/src/main/java/com/github/difflib/patch/EqualDelta.java
+++ b/java-diff-utils/src/main/java/com/github/difflib/patch/EqualDelta.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2020 java-diff-utils.
+ *
+ * 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.
+ */
+package com.github.difflib.patch;
+
+import java.util.List;
+
+/**
+ * This delta contains equal lines of data. Therefore nothing is to do in applyTo and restore.
+ * @author tobens
+ */
+public class EqualDelta<T> extends AbstractDelta<T> {
+
+    public EqualDelta(Chunk<T> source, Chunk<T> target) {
+        super(DeltaType.EQUAL, source, target);
+    }
+
+    @Override
+    public void applyTo(List<T> target) throws PatchFailedException {
+        verifyChunk(target);
+    }
+
+    @Override
+    public void restore(List<T> target) {
+    }
+
+    @Override
+    public String toString() {
+        return "[EqualDelta, position: " + getSource().getPosition() + ", lines: "
+                + getSource().getLines() + "]";
+    }
+    
+    @Override
+    public AbstractDelta<T> withChunks(Chunk<T> original, Chunk<T> revised) {
+        return new EqualDelta(original, revised);
+    }
+}
--- a/java-diff-utils/src/main/java/com/github/difflib/patch/InsertDelta.java
+++ b/java-diff-utils/src/main/java/com/github/difflib/patch/InsertDelta.java
@@ -59,4 +59,9 @@ public final class InsertDelta<T> extends AbstractDelta<T> {
        return "[InsertDelta, position: " + getSource().getPosition()
                + ", lines: " + getTarget().getLines() + "]";
    }
+    
+    @Override
+    public AbstractDelta<T> withChunks(Chunk<T> original, Chunk<T> revised) {
+        return new InsertDelta(original, revised);
+    }
 }
--- a/java-diff-utils/src/main/java/com/github/difflib/patch/Patch.java
+++ b/java-diff-utils/src/main/java/com/github/difflib/patch/Patch.java
@@ -22,6 +22,7 @@ package com.github.difflib.patch;
 import static java.util.Comparator.comparing;
 import com.github.difflib.algorithm.Change;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 import java.util.ListIterator;

@@ -100,10 +101,35 @@ public final class Patch<T> {
    }

    public static <T> Patch<T> generate(List<T> original, List<T> revised, List<Change> changes) {
-        Patch<T> patch = new Patch<>(changes.size());
+        return generate(original, revised, changes, false);
+    }
+
+    private static <T> Chunk<T> buildChunk(int start, int end, List<T> data) {
+        return new Chunk<>(start, new ArrayList<>(data.subList(start, end)));
+    }
+
+    public static <T> Patch<T> generate(List<T> original, List<T> revised, List<Change> _changes, boolean includeEquals) {
+        Patch<T> patch = new Patch<>(_changes.size());
+        int startOriginal = 0;
+        int startRevised = 0;
+        
+        List<Change> changes = _changes;
+        
+        if (includeEquals) {
+            changes = new ArrayList<Change>(_changes);
+            Collections.sort(changes, comparing(d -> d.startOriginal));
+        }
+        
        for (Change change : changes) {
-            Chunk<T> orgChunk = new Chunk<>(change.startOriginal, new ArrayList<>(original.subList(change.startOriginal, change.endOriginal)));
-            Chunk<T> revChunk = new Chunk<>(change.startRevised, new ArrayList<>(revised.subList(change.startRevised, change.endRevised)));
+
+            if (includeEquals && startOriginal < change.startOriginal) {
+                patch.addDelta(new EqualDelta(
+                        buildChunk(startOriginal, change.startOriginal, original),
+                        buildChunk(startRevised, change.startRevised, revised)));
+            }
+
+            Chunk<T> orgChunk = buildChunk(change.startOriginal, change.endOriginal, original);
+            Chunk<T> revChunk = buildChunk(change.startRevised, change.endRevised, revised);
            switch (change.deltaType) {
                case DELETE:
                    patch.addDelta(new DeleteDelta<>(orgChunk, revChunk));
@@ -115,7 +141,17 @@ public final class Patch<T> {
                    patch.addDelta(new ChangeDelta<>(orgChunk, revChunk));
                    break;
            }
+
+            startOriginal = change.endOriginal;
+            startRevised = change.endRevised;
        }
+
+        if (includeEquals && startOriginal < original.size()) {
+            patch.addDelta(new EqualDelta(
+                    buildChunk(startOriginal, original.size(), original),
+                    buildChunk(startRevised, revised.size(), revised)));
+        }
+
        return patch;
    }
 }
--- a/java-diff-utils/src/main/java/com/github/difflib/text/DiffRowGenerator.java
+++ b/java-diff-utils/src/main/java/com/github/difflib/text/DiffRowGenerator.java
@@ -16,15 +16,13 @@
 package com.github.difflib.text;

 import com.github.difflib.DiffUtils;
-import com.github.difflib.algorithm.DiffException;
 import com.github.difflib.patch.AbstractDelta;
-import com.github.difflib.patch.ChangeDelta;
 import com.github.difflib.patch.Chunk;
-import com.github.difflib.patch.DeleteDelta;
-import com.github.difflib.patch.InsertDelta;
+import com.github.difflib.patch.DeltaType;
 import com.github.difflib.patch.Patch;
 import com.github.difflib.text.DiffRow.Tag;
 import java.util.*;
+import java.util.function.BiFunction;
 import java.util.function.BiPredicate;
 import java.util.function.Function;
 import java.util.regex.Matcher;
@@ -32,9 +30,10 @@ import java.util.regex.Pattern;
 import static java.util.stream.Collectors.toList;

 /**
- * This class for generating DiffRows for side-by-sidy view. You can customize the way of generating. For example, show
- * inline diffs on not, ignoring white spaces or/and blank lines and so on. All parameters for generating are optional.
- * If you do not specify them, the class will use the default values.
+ * This class for generating DiffRows for side-by-sidy view. You can customize the way of
+ * generating. For example, show inline diffs on not, ignoring white spaces or/and blank lines and
+ * so on. All parameters for generating are optional. If you do not specify them, the class will use
+ * the default values.
 *
 * These values are: showInlineDiffs = false; ignoreWhiteSpaces = true; ignoreBlankLines = true; ...
 *
@@ -52,7 +51,6 @@ public final class DiffRowGenerator {

    public static final Function<String, String> LINE_NORMALIZER_FOR_HTML = StringUtils::normalize;

-
    /**
     * Splitting lines by character to achieve char by char diff checking.
     */
@@ -63,6 +61,7 @@ public final class DiffRowGenerator {
        }
        return list;
    };
+
    public static final Pattern SPLIT_BY_WORD_PATTERN = Pattern.compile("\\s+|[,.\\[\\](){}/\\\\*+\\-#]");

    /**
@@ -101,12 +100,14 @@ public final class DiffRowGenerator {
    /**
     * Wrap the elements in the sequence with the given tag
     *
-     * @param startPosition the position from which tag should start. The counting start from a zero.
+     * @param startPosition the position from which tag should start. The counting start from a
+     * zero.
     * @param endPosition the position before which tag should should be closed.
     * @param tagGenerator the tag generator
     */
    static void wrapInTag(List<String> sequence, int startPosition,
-            int endPosition, Function<Boolean, String> tagGenerator) {
+            int endPosition, Tag tag, BiFunction<Tag, Boolean, String> tagGenerator,
+            Function<String, String> processDiffs, boolean replaceLinefeedWithSpace) {
        int endPos = endPosition;

        while (endPos >= startPosition) {
@@ -115,6 +116,9 @@ public final class DiffRowGenerator {
            while (endPos > startPosition) {
                if (!"\n".equals(sequence.get(endPos - 1))) {
                    break;
+                } else if (replaceLinefeedWithSpace) {
+                    sequence.set(endPos - 1, " ");
+                    break;
                }
                endPos--;
            }
@@ -123,35 +127,47 @@ public final class DiffRowGenerator {
                break;
            }

-            sequence.add(endPos, tagGenerator.apply(false));
+            sequence.add(endPos, tagGenerator.apply(tag, false));
+            if (processDiffs != null) {
+                sequence.set(endPos - 1,
+                        processDiffs.apply(sequence.get(endPos - 1)));
+            }
            endPos--;

            //search position for end tag
            while (endPos > startPosition) {
                if ("\n".equals(sequence.get(endPos - 1))) {
-                    break;
+                    if (replaceLinefeedWithSpace) {
+                        sequence.set(endPos - 1, " ");
+                    } else {
+                        break;
+                    }
+                }
+                if (processDiffs != null) {
+                    sequence.set(endPos - 1,
+                            processDiffs.apply(sequence.get(endPos - 1)));
                }
                endPos--;
            }

-            sequence.add(endPos, tagGenerator.apply(true));
+            sequence.add(endPos, tagGenerator.apply(tag, true));
            endPos--;
        }
-
-//        sequence.add(endPosition, tagGenerator.apply(false));
-//        sequence.add(startPosition, tagGenerator.apply(true));
    }
+
    private final int columnWidth;
    private final BiPredicate<String, String> equalizer;
    private final boolean ignoreWhiteSpaces;
    private final Function<String, List<String>> inlineDiffSplitter;
    private final boolean mergeOriginalRevised;
-    private final Function<Boolean, String> newTag;
-    private final Function<Boolean, String> oldTag;
+    private final BiFunction<Tag, Boolean, String> newTag;
+    private final BiFunction<Tag, Boolean, String> oldTag;
    private final boolean reportLinesUnchanged;
    private final Function<String, String> lineNormalizer;
+    private final Function<String, String> processDiffs;

    private final boolean showInlineDiffs;
+    private final boolean replaceOriginalLinefeedInChangesWithSpaces;

    private DiffRowGenerator(Builder builder) {
        showInlineDiffs = builder.showInlineDiffs;
@@ -161,35 +177,44 @@ public final class DiffRowGenerator {
        columnWidth = builder.columnWidth;
        mergeOriginalRevised = builder.mergeOriginalRevised;
        inlineDiffSplitter = builder.inlineDiffSplitter;
-        equalizer = ignoreWhiteSpaces ? IGNORE_WHITESPACE_EQUALIZER : DEFAULT_EQUALIZER;
+
+        if (builder.equalizer != null) {
+            equalizer = builder.equalizer;
+        } else {
+            equalizer = ignoreWhiteSpaces ? IGNORE_WHITESPACE_EQUALIZER : DEFAULT_EQUALIZER;
+        }
+
        reportLinesUnchanged = builder.reportLinesUnchanged;
        lineNormalizer = builder.lineNormalizer;
+        processDiffs = builder.processDiffs;
+        
+        replaceOriginalLinefeedInChangesWithSpaces = builder.replaceOriginalLinefeedInChangesWithSpaces;

        Objects.requireNonNull(inlineDiffSplitter);
        Objects.requireNonNull(lineNormalizer);
    }

    /**
-     * Get the DiffRows describing the difference between original and revised texts using the given patch. Useful for
-     * displaying side-by-side diff.
+     * Get the DiffRows describing the difference between original and revised texts using the given
+     * patch. Useful for displaying side-by-side diff.
     *
     * @param original the original text
     * @param revised the revised text
     * @return the DiffRows between original and revised texts
     */
-    public List<DiffRow> generateDiffRows(List<String> original, List<String> revised) throws DiffException {
+    public List<DiffRow> generateDiffRows(List<String> original, List<String> revised) {
        return generateDiffRows(original, DiffUtils.diff(original, revised, equalizer));
    }

    /**
-     * Generates the DiffRows describing the difference between original and revised texts using the given patch. Useful
-     * for displaying side-by-side diff.
+     * Generates the DiffRows describing the difference between original and revised texts using the
+     * given patch. Useful for displaying side-by-side diff.
     *
     * @param original the original text
     * @param patch the given patch
     * @return the DiffRows between original and revised texts
     */
-    public List<DiffRow> generateDiffRows(final List<String> original, Patch<String> patch) throws DiffException {
+    public List<DiffRow> generateDiffRows(final List<String> original, Patch<String> patch) {
        List<DiffRow> diffRows = new ArrayList<>();
        int endPos = 0;
        final List<AbstractDelta<String>> deltaList = patch.getDeltas();
@@ -202,7 +227,7 @@ public final class DiffRowGenerator {
            }

            // Inserted DiffRow
-            if (delta instanceof InsertDelta) {
+            if (delta.getType() == DeltaType.INSERT) {
                endPos = orig.last() + 1;
                for (String line : rev.getLines()) {
                    diffRows.add(buildDiffRow(Tag.INSERT, "", line));
@@ -211,7 +236,7 @@ public final class DiffRowGenerator {
            }

            // Deleted DiffRow
-            if (delta instanceof DeleteDelta) {
+            if (delta.getType() == DeltaType.DELETE) {
                endPos = orig.last() + 1;
                for (String line : orig.getLines()) {
                    diffRows.add(buildDiffRow(Tag.DELETE, line, ""));
@@ -245,15 +270,15 @@ public final class DiffRowGenerator {
            String wrapOrg = preprocessLine(orgline);
            if (Tag.DELETE == type) {
                if (mergeOriginalRevised || showInlineDiffs) {
-                    wrapOrg = oldTag.apply(true) + wrapOrg + oldTag.apply(false);
+                    wrapOrg = oldTag.apply(type, true) + wrapOrg + oldTag.apply(type, false);
                }
            }
            String wrapNew = preprocessLine(newline);
            if (Tag.INSERT == type) {
                if (mergeOriginalRevised) {
-                    wrapOrg = newTag.apply(true) + wrapNew + newTag.apply(false);
+                    wrapOrg = newTag.apply(type, true) + wrapNew + newTag.apply(type, false);
                } else if (showInlineDiffs) {
-                    wrapNew = newTag.apply(true) + wrapNew + newTag.apply(false);
+                    wrapNew = newTag.apply(type, true) + wrapNew + newTag.apply(type, false);
                }
            }
            return new DiffRow(type, wrapOrg, wrapNew);
@@ -279,7 +304,7 @@ public final class DiffRowGenerator {
     *
     * @param delta the given delta
     */
-    private List<DiffRow> generateInlineDiffs(AbstractDelta<String> delta) throws DiffException {
+    private List<DiffRow> generateInlineDiffs(AbstractDelta<String> delta) {
        List<String> orig = normalizeLines(delta.getSource().getLines());
        List<String> rev = normalizeLines(delta.getTarget().getLines());
        List<String> origList;
@@ -290,41 +315,45 @@ public final class DiffRowGenerator {
        origList = inlineDiffSplitter.apply(joinedOrig);
        revList = inlineDiffSplitter.apply(joinedRev);

-        List<AbstractDelta<String>> inlineDeltas = DiffUtils.diff(origList, revList).getDeltas();
+        List<AbstractDelta<String>> inlineDeltas = DiffUtils.diff(origList, revList, equalizer).getDeltas();

        Collections.reverse(inlineDeltas);
        for (AbstractDelta<String> inlineDelta : inlineDeltas) {
            Chunk<String> inlineOrig = inlineDelta.getSource();
            Chunk<String> inlineRev = inlineDelta.getTarget();
-            if (inlineDelta instanceof DeleteDelta) {
+            if (inlineDelta.getType() == DeltaType.DELETE) {
                wrapInTag(origList, inlineOrig.getPosition(), inlineOrig
                        .getPosition()
-                        + inlineOrig.size(), oldTag);
-            } else if (inlineDelta instanceof InsertDelta) {
+                        + inlineOrig.size(), Tag.DELETE, oldTag, processDiffs, replaceOriginalLinefeedInChangesWithSpaces && mergeOriginalRevised);
+            } else if (inlineDelta.getType() == DeltaType.INSERT) {
                if (mergeOriginalRevised) {
                    origList.addAll(inlineOrig.getPosition(),
-                            revList.subList(inlineRev.getPosition(), inlineRev.getPosition()
-                                    + inlineRev.size()));
-                    wrapInTag(origList, inlineOrig.getPosition(), inlineOrig.getPosition()
-                            + inlineRev.size(), newTag);
+                            revList.subList(inlineRev.getPosition(),
+                                    inlineRev.getPosition() + inlineRev.size()));
+                    wrapInTag(origList, inlineOrig.getPosition(),
+                            inlineOrig.getPosition() + inlineRev.size(),
+                            Tag.INSERT, newTag, processDiffs, false);
                } else {
-                    wrapInTag(revList, inlineRev.getPosition(), inlineRev.getPosition()
-                            + inlineRev.size(), newTag);
+                    wrapInTag(revList, inlineRev.getPosition(),
+                            inlineRev.getPosition() + inlineRev.size(),
+                            Tag.INSERT, newTag, processDiffs, false);
                }
-            } else if (inlineDelta instanceof ChangeDelta) {
+            } else if (inlineDelta.getType() == DeltaType.CHANGE) {
                if (mergeOriginalRevised) {
                    origList.addAll(inlineOrig.getPosition() + inlineOrig.size(),
-                            revList.subList(inlineRev.getPosition(), inlineRev.getPosition()
-                                    + inlineRev.size()));
-                    wrapInTag(origList, inlineOrig.getPosition() + inlineOrig.size(), inlineOrig.getPosition() + inlineOrig.size()
-                            + inlineRev.size(), newTag);
+                            revList.subList(inlineRev.getPosition(),
+                                    inlineRev.getPosition() + inlineRev.size()));
+                    wrapInTag(origList, inlineOrig.getPosition() + inlineOrig.size(),
+                            inlineOrig.getPosition() + inlineOrig.size() + inlineRev.size(),
+                            Tag.CHANGE, newTag, processDiffs, false);
                } else {
-                    wrapInTag(revList, inlineRev.getPosition(), inlineRev.getPosition()
-                            + inlineRev.size(), newTag);
+                    wrapInTag(revList, inlineRev.getPosition(),
+                            inlineRev.getPosition() + inlineRev.size(),
+                            Tag.CHANGE, newTag, processDiffs, false);
                }
-                wrapInTag(origList, inlineOrig.getPosition(), inlineOrig
-                        .getPosition()
-                        + inlineOrig.size(), oldTag);
+                wrapInTag(origList, inlineOrig.getPosition(),
+                        inlineOrig.getPosition() + inlineOrig.size(),
+                        Tag.CHANGE, oldTag, processDiffs, replaceOriginalLinefeedInChangesWithSpaces && mergeOriginalRevised);
            }
        }
        StringBuilder origResult = new StringBuilder();
@@ -367,14 +396,19 @@ public final class DiffRowGenerator {
        private boolean showInlineDiffs = false;
        private boolean ignoreWhiteSpaces = false;

-        private Function<Boolean, String> oldTag = f -> f ? "<span class=\"editOldInline\">" : "</span>";
-        private Function<Boolean, String> newTag = f -> f ? "<span class=\"editNewInline\">" : "</span>";
+        private BiFunction<Tag, Boolean, String> oldTag
+                = (tag, f) -> f ? "<span class=\"editOldInline\">" : "</span>";
+        private BiFunction<Tag, Boolean, String> newTag
+                = (tag, f) -> f ? "<span class=\"editNewInline\">" : "</span>";

        private int columnWidth = 0;
        private boolean mergeOriginalRevised = false;
        private boolean reportLinesUnchanged = false;
        private Function<String, List<String>> inlineDiffSplitter = SPLITTER_BY_CHARACTER;
        private Function<String, String> lineNormalizer = LINE_NORMALIZER_FOR_HTML;
+        private Function<String, String> processDiffs = null;
+        private BiPredicate<String, String> equalizer = null;
+        private boolean replaceOriginalLinefeedInChangesWithSpaces = false;

        private Builder() {
        }
@@ -402,8 +436,8 @@ public final class DiffRowGenerator {
        }

        /**
-         * Give the originial old and new text lines to Diffrow without any additional processing and without any tags to
-         * highlight the change.
+         * Give the originial old and new text lines to Diffrow without any additional processing
+         * and without any tags to highlight the change.
         *
         * @param val the value to set. Default: false.
         * @return builder with configured reportLinesUnWrapped parameter
@@ -419,11 +453,33 @@ public final class DiffRowGenerator {
         * @param generator the tag generator
         * @return builder with configured ignoreBlankLines parameter
         */
-        public Builder oldTag(Function<Boolean, String> generator) {
+        public Builder oldTag(BiFunction<Tag, Boolean, String> generator) {
            this.oldTag = generator;
            return this;
        }

+        /**
+         * Generator for Old-Text-Tags.
+         *
+         * @param generator the tag generator
+         * @return builder with configured ignoreBlankLines parameter
+         */
+        public Builder oldTag(Function<Boolean, String> generator) {
+            this.oldTag = (tag, f) -> generator.apply(f);
+            return this;
+        }
+
+        /**
+         * Generator for New-Text-Tags.
+         *
+         * @param generator
+         * @return
+         */
+        public Builder newTag(BiFunction<Tag, Boolean, String> generator) {
+            this.newTag = generator;
+            return this;
+        }
+
        /**
         * Generator for New-Text-Tags.
         *
@@ -431,15 +487,27 @@ public final class DiffRowGenerator {
         * @return
         */
        public Builder newTag(Function<Boolean, String> generator) {
-            this.newTag = generator;
+            this.newTag = (tag, f) -> generator.apply(f);
+            return this;
+        }
+
+        /**
+         * Processor for diffed text parts. Here e.g. whitecharacters could be replaced by something
+         * visible.
+         *
+         * @param processDiffs
+         * @return
+         */
+        public Builder processDiffs(Function<String, String> processDiffs) {
+            this.processDiffs = processDiffs;
            return this;
        }

        /**
         * Set the column width of generated lines of original and revised texts.
         *
-         * @param width the width to set. Making it < 0 doesn't have any sense. Default 80. @return builder with config
-         * ured ignoreBlankLines parameter
+         * @param width the width to set. Making it < 0 doesn't make any sense. Default 80. 
+         * @return builder with config of column width
         */
        public Builder columnWidth(int width) {
            if (width >= 0) {
@@ -458,7 +526,8 @@ public final class DiffRowGenerator {
        }

        /**
-         * Merge the complete result within the original text. This makes sense for one line display.
+         * Merge the complete result within the original text. This makes sense for one line
+         * display.
         *
         * @param mergeOriginalRevised
         * @return
@@ -469,8 +538,9 @@ public final class DiffRowGenerator {
        }

        /**
-         * Per default each character is separatly processed. This variant introduces processing by word, which does not
-         * deliver in word changes. Therefore the whole word will be tagged as changed:
+         * Per default each character is separatly processed. This variant introduces processing by
+         * word, which does not deliver in word changes. Therefore the whole word will be tagged as
+         * changed:
         *
         * <pre>
         * false:    (aBa : aba) --  changed: a(B)a : a(b)a
@@ -483,8 +553,8 @@ public final class DiffRowGenerator {
        }

        /**
-         * To provide some customized splitting a splitter can be provided. Here someone could think about sentence splitter,
-         * comma splitter or stuff like that.
+         * To provide some customized splitting a splitter can be provided. Here someone could think
+         * about sentence splitter, comma splitter or stuff like that.
         *
         * @param inlineDiffSplitter
         * @return
@@ -495,8 +565,9 @@ public final class DiffRowGenerator {
        }

        /**
-         * By default DiffRowGenerator preprocesses lines for HTML output. Tabs and special HTML characters like "&lt;"
-         * are replaced with its encoded value. To change this you can provide a customized line normalizer here.
+         * By default DiffRowGenerator preprocesses lines for HTML output. Tabs and special HTML
+         * characters like "&lt;" are replaced with its encoded value. To change this you can
+         * provide a customized line normalizer here.
         *
         * @param lineNormalizer
         * @return
@@ -505,5 +576,28 @@ public final class DiffRowGenerator {
            this.lineNormalizer = lineNormalizer;
            return this;
        }
+
+        /**
+         * Provide an equalizer for diff processing.
+         *
+         * @param equalizer equalizer for diff processing.
+         * @return builder with configured equalizer parameter
+         */
+        public Builder equalizer(BiPredicate<String, String> equalizer) {
+            this.equalizer = equalizer;
+            return this;
+        }
+        
+        /**
+         * Sometimes it happens that a change contains multiple lines. If there is no correspondence
+         * in old and new. To keep the merged line more readable the linefeeds could be replaced
+         * by spaces.
+         * @param replace
+         * @return 
+         */
+        public Builder replaceOriginalLinefeedInChangesWithSpaces(boolean replace) {
+            this.replaceOriginalLinefeedInChangesWithSpaces = replace;
+            return this;
+        }
    }
 }
--- a/java-diff-utils/src/main/java/com/github/difflib/unifieddiff/UnifiedDiffFile.java
+++ b/java-diff-utils/src/main/java/com/github/difflib/unifieddiff/UnifiedDiffFile.java
@@ -29,6 +29,8 @@ public final class UnifiedDiffFile {
    private String toFile;
    private String toTimestamp;
    private String index;
+    private String newFileMode;
+    private String deletedFileMode;
    private Patch<String> patch = new Patch<>();

    public String getDiffCommand() {
@@ -92,4 +94,20 @@ public final class UnifiedDiffFile {
        file.patch = patch;
        return file;
    }
+
+    public void setNewFileMode(String newFileMode) {
+        this.newFileMode = newFileMode;
+    }
+    
+    public String getNewFileMode() {
+        return newFileMode;
+    }
+
+    public String getDeletedFileMode() {
+        return deletedFileMode;
+    }
+
+    public void setDeletedFileMode(String deletedFileMode) {
+        this.deletedFileMode = deletedFileMode;
+    }
 }
--- a/java-diff-utils/src/main/java/com/github/difflib/unifieddiff/UnifiedDiffReader.java
+++ b/java-diff-utils/src/main/java/com/github/difflib/unifieddiff/UnifiedDiffReader.java
@@ -39,7 +39,7 @@ import java.util.regex.Pattern;
 public final class UnifiedDiffReader {

    static final Pattern UNIFIED_DIFF_CHUNK_REGEXP = Pattern.compile("^@@\\s+-(?:(\\d+)(?:,(\\d+))?)\\s+\\+(?:(\\d+)(?:,(\\d+))?)\\s+@@");
-    static final Pattern TIMESTAMP_REGEXP = Pattern.compile("(\\d{4}-\\d{2}-\\d{2}[T ]\\d{2}:\\d{2}:\\d{2}\\.\\d{3,})");
+    static final Pattern TIMESTAMP_REGEXP = Pattern.compile("(\\d{4}-\\d{2}-\\d{2}[T ]\\d{2}:\\d{2}:\\d{2}\\.\\d{3,})(?: [+-]\\d+)?");

    private final InternalUnifiedDiffReader READER;
    private final UnifiedDiff data = new UnifiedDiff();
@@ -49,6 +49,10 @@ public final class UnifiedDiffReader {
    private final UnifiedDiffLine FROM_FILE = new UnifiedDiffLine(true, "^---\\s", this::processFromFile);
    private final UnifiedDiffLine TO_FILE = new UnifiedDiffLine(true, "^\\+\\+\\+\\s", this::processToFile);

+    private final UnifiedDiffLine NEW_FILE_MODE = new UnifiedDiffLine(true, "^new\\sfile\\smode\\s(\\d+)", this::processNewFileMode);
+    
+    private final UnifiedDiffLine DELETED_FILE_MODE = new UnifiedDiffLine(true, "^deleted\\sfile\\smode\\s(\\d+)", this::processDeletedFileMode);
+
    private final UnifiedDiffLine CHUNK = new UnifiedDiffLine(false, UNIFIED_DIFF_CHUNK_REGEXP, this::processChunk);
    private final UnifiedDiffLine LINE_NORMAL = new UnifiedDiffLine("^\\s", this::processNormalLine);
    private final UnifiedDiffLine LINE_DEL = new UnifiedDiffLine("^-", this::processDelLine);
@@ -66,13 +70,14 @@ public final class UnifiedDiffReader {
    // [/^-/, del], [/^\+/, add], [/^\\ No newline at end of file$/, eof]];
    private UnifiedDiff parse() throws IOException, UnifiedDiffParserException {
        String headerTxt = "";
-        LOG.log(Level.INFO, "header parsing");
+        LOG.log(Level.FINE, "header parsing");
        String line = null;
        while (READER.ready()) {
            line = READER.readLine();
-            LOG.log(Level.INFO, "parsing line {0}", line);
+            LOG.log(Level.FINE, "parsing line {0}", line);
            if (DIFF_COMMAND.validLine(line) || INDEX.validLine(line)
-                    || FROM_FILE.validLine(line) || TO_FILE.validLine(line)) {
+                    || FROM_FILE.validLine(line) || TO_FILE.validLine(line)
+                    || NEW_FILE_MODE.validLine(line)) {
                break;
            } else {
                headerTxt += line + "\n";
@@ -85,26 +90,28 @@ public final class UnifiedDiffReader {
        while (line != null) {
            if (!CHUNK.validLine(line)) {
                initFileIfNecessary();
-                while (!CHUNK.validLine(line)) {
-                    if (processLine(line, DIFF_COMMAND, INDEX, FROM_FILE, TO_FILE) == false) {
+                while (line != null && !CHUNK.validLine(line)) {
+                    if (processLine(line, DIFF_COMMAND, INDEX, FROM_FILE, TO_FILE, NEW_FILE_MODE, DELETED_FILE_MODE) == false) {
                        throw new UnifiedDiffParserException("expected file start line not found");
                    }
                    line = READER.readLine();
                }
            }
-            processLine(line, CHUNK);
-            while ((line = READER.readLine()) != null) {
-                if (processLine(line, LINE_NORMAL, LINE_ADD, LINE_DEL) == false) {
-                    throw new UnifiedDiffParserException("expected data line not found");
-                }
-                if ((originalTxt.size() == old_size && revisedTxt.size() == new_size) 
-                        || (old_size==0 && new_size==0 && originalTxt.size() == this.old_ln 
+            if (line != null) {
+                processLine(line, CHUNK);
+                while ((line = READER.readLine()) != null) {
+                    if (processLine(line, LINE_NORMAL, LINE_ADD, LINE_DEL) == false) {
+                        throw new UnifiedDiffParserException("expected data line not found");
+                    }
+                    if ((originalTxt.size() == old_size && revisedTxt.size() == new_size)
+                            || (old_size == 0 && new_size == 0 && originalTxt.size() == this.old_ln
                            && revisedTxt.size() == this.new_ln)) {
-                    finalizeChunk();
-                    break;
+                        finalizeChunk();
+                        break;
+                    }
                }
+                line = READER.readLine();
            }
-            line = READER.readLine();
            if (line == null || line.startsWith("--")) {
                break;
            }
@@ -113,7 +120,10 @@ public final class UnifiedDiffReader {
        if (READER.ready()) {
            String tailTxt = "";
            while (READER.ready()) {
-                tailTxt += READER.readLine() + "\n";
+                if (tailTxt.length() > 0) {
+                    tailTxt += "\n";
+                }
+                tailTxt += READER.readLine();
            }
            data.setTailTxt(tailTxt);
        }
@@ -137,13 +147,16 @@ public final class UnifiedDiffReader {
    }

    private boolean processLine(String line, UnifiedDiffLine... rules) throws UnifiedDiffParserException {
+        if (line == null) {
+            return false;
+        }
        for (UnifiedDiffLine rule : rules) {
            if (rule.processLine(line)) {
-                LOG.info("  >>> processed rule " + rule.toString());
+                LOG.fine("  >>> processed rule " + rule.toString());
                return true;
            }
        }
-        LOG.info("  >>> no rule matched " + line);
+        LOG.warning("  >>> no rule matched " + line);
        return false;
        //throw new UnifiedDiffParserException("parsing error at line " + line);
    }
@@ -161,7 +174,7 @@ public final class UnifiedDiffReader {

    private void processDiff(MatchResult match, String line) {
        //initFileIfNecessary();
-        LOG.log(Level.INFO, "start {0}", line);
+        LOG.log(Level.FINE, "start {0}", line);
        String[] fromTo = parseFileNames(READER.lastLine());
        actualFile.setFromFile(fromTo[0]);
        actualFile.setToFile(fromTo[1]);
@@ -223,7 +236,7 @@ public final class UnifiedDiffReader {

    private void processIndex(MatchResult match, String line) {
        //initFileIfNecessary();
-        LOG.log(Level.INFO, "index {0}", line);
+        LOG.log(Level.FINE, "index {0}", line);
        actualFile.setIndex(line.substring(6));
    }

@@ -239,14 +252,25 @@ public final class UnifiedDiffReader {
        actualFile.setToTimestamp(extractTimestamp(line));
    }

+    private void processNewFileMode(MatchResult match, String line) {
+        //initFileIfNecessary();
+        actualFile.setNewFileMode(match.group(1));
+    }
+    
+    private void processDeletedFileMode(MatchResult match, String line) {
+        //initFileIfNecessary();
+        actualFile.setDeletedFileMode(match.group(1));
+    }
+
    private String extractFileName(String _line) {
        Matcher matcher = TIMESTAMP_REGEXP.matcher(_line);
        String line = _line;
        if (matcher.find()) {
            line = line.substring(0, matcher.start());
        }
+        line = line.split("\t")[0];
        return line.substring(4).replaceFirst("^(a|b|old|new)(\\/)?", "")
-                .replace(TIMESTAMP_REGEXP.toString(), "").trim();
+                .trim();
    }

    private String extractTimestamp(String line) {
--- a/java-diff-utils/src/main/java/com/github/difflib/unifieddiff/UnifiedDiffWriter.java
+++ b/java-diff-utils/src/main/java/com/github/difflib/unifieddiff/UnifiedDiffWriter.java
@@ -20,6 +20,7 @@ import java.io.IOException;
 import java.io.Writer;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Objects;
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.logging.Level;
@@ -34,6 +35,7 @@ public class UnifiedDiffWriter {
    private static final Logger LOG = Logger.getLogger(UnifiedDiffWriter.class.getName());

    public static void write(UnifiedDiff diff, Function<String, List<String>> originalLinesProvider, Writer writer, int contextSize) throws IOException {
+        Objects.requireNonNull(originalLinesProvider, "original lines provider needs to be specified");
        write(diff, originalLinesProvider, line -> {
            try {
                writer.append(line).append("\n");
@@ -44,7 +46,9 @@ public class UnifiedDiffWriter {
    }

    public static void write(UnifiedDiff diff, Function<String, List<String>> originalLinesProvider, Consumer<String> writer, int contextSize) throws IOException {
-        writer.accept(diff.getHeader());
+        if (diff.getHeader() != null) {
+            writer.accept(diff.getHeader());
+        }

        for (UnifiedDiffFile file : diff.getFiles()) {
            List<AbstractDelta<String>> patchDeltas = new ArrayList<>(
@@ -54,9 +58,9 @@ public class UnifiedDiffWriter {
                if (file.getIndex() != null) {
                    writer.accept("index " + file.getIndex());
                }
-                if (file.getFromFile() != null) {
-                    writer.accept("--- " + file.getFromFile());
-                }
+
+                writer.accept("--- " + (file.getFromFile() == null ? "/dev/null" : file.getFromFile()));
+
                if (file.getToFile() != null) {
                    writer.accept("+++ " + file.getToFile());
                }
@@ -83,7 +87,7 @@ public class UnifiedDiffWriter {
                            // if it isn't, output the current set,
                            // then create a new set and add the current Delta to
                            // it.
-                            processDeltas(writer, originalLines, deltas, contextSize);
+                            processDeltas(writer, originalLines, deltas, contextSize, false);
                            deltas.clear();
                            deltas.add(nextDelta);
                        }
@@ -92,7 +96,8 @@ public class UnifiedDiffWriter {

                }
                // don't forget to process the last set of Deltas
-                processDeltas(writer, originalLines, deltas, contextSize);
+                processDeltas(writer, originalLines, deltas, contextSize,
+                        patchDeltas.size() == 1 && file.getFromFile() == null);
            }

        }
@@ -104,7 +109,7 @@ public class UnifiedDiffWriter {

    private static void processDeltas(Consumer<String> writer,
            List<String> origLines, List<AbstractDelta<String>> deltas,
-            int contextSize) {
+            int contextSize, boolean newFile) {
        List<String> buffer = new ArrayList<>();
        int origTotal = 0; // counter for total lines output from Original
        int revTotal = 0; // counter for total lines output from Original
@@ -112,10 +117,15 @@ public class UnifiedDiffWriter {

        AbstractDelta<String> curDelta = deltas.get(0);

-        // NOTE: +1 to overcome the 0-offset Position
-        int origStart = curDelta.getSource().getPosition() + 1 - contextSize;
-        if (origStart < 1) {
-            origStart = 1;
+        int origStart;
+        if (newFile) {
+            origStart = 0;
+        } else {
+            // NOTE: +1 to overcome the 0-offset Position
+            origStart = curDelta.getSource().getPosition() + 1 - contextSize;
+            if (origStart < 1) {
+                origStart = 1;
+            }
        }

        int revStart = curDelta.getTarget().getPosition() + 1 - contextSize;
@@ -130,7 +140,8 @@ public class UnifiedDiffWriter {
        }

        // output the context before the first Delta
-        for (line = contextStart; line < curDelta.getSource().getPosition(); line++) { //
+        for (line = contextStart; line < curDelta.getSource().getPosition()
+                && line < origLines.size(); line++) { //
            buffer.add(" " + origLines.get(line));
            origTotal++;
            revTotal++;
@@ -145,8 +156,8 @@ public class UnifiedDiffWriter {
            AbstractDelta<String> nextDelta = deltas.get(deltaIndex);
            int intermediateStart = curDelta.getSource().getPosition()
                    + curDelta.getSource().getLines().size();
-            for (line = intermediateStart; line < nextDelta.getSource()
-                    .getPosition(); line++) {
+            for (line = intermediateStart; line < nextDelta.getSource().getPosition()
+                    && line < origLines.size(); line++) {
                // output the code between the last Delta and this one
                buffer.add(" " + origLines.get(line));
                origTotal++;
--- a/java-diff-utils/src/test/java/com/github/difflib/DiffUtilsTest.java
+++ b/java-diff-utils/src/test/java/com/github/difflib/DiffUtilsTest.java
@@ -1,10 +1,10 @@
 package com.github.difflib;

-import com.github.difflib.algorithm.DiffException;
 import com.github.difflib.patch.ChangeDelta;
 import com.github.difflib.patch.Chunk;
 import com.github.difflib.patch.DeleteDelta;
 import com.github.difflib.patch.AbstractDelta;
+import com.github.difflib.patch.EqualDelta;
 import com.github.difflib.patch.InsertDelta;
 import com.github.difflib.patch.Patch;
 import java.io.BufferedReader;
@@ -19,16 +19,17 @@ import java.util.Collections;
 import java.util.List;
 import static java.util.stream.Collectors.toList;
 import java.util.zip.ZipFile;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-import org.junit.Ignore;
-import org.junit.Test;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;

 public class DiffUtilsTest {

    @Test
-    public void testDiff_Insert() throws DiffException {
+    public void testDiff_Insert() {
        final Patch<String> patch = DiffUtils.diff(Arrays.asList("hhh"), Arrays.
                asList("hhh", "jjj", "kkk"));
        assertNotNull(patch);
@@ -40,7 +41,7 @@ public class DiffUtilsTest {
    }

    @Test
-    public void testDiff_Delete() throws DiffException {
+    public void testDiff_Delete() {
        final Patch<String> patch = DiffUtils.diff(Arrays.asList("ddd", "fff", "ggg"), Arrays.
                asList("ggg"));
        assertNotNull(patch);
@@ -52,7 +53,7 @@ public class DiffUtilsTest {
    }

    @Test
-    public void testDiff_Change() throws DiffException {
+    public void testDiff_Change() {
        final List<String> changeTest_from = Arrays.asList("aaa", "bbb", "ccc");
        final List<String> changeTest_to = Arrays.asList("aaa", "zzz", "ccc");

@@ -66,14 +67,14 @@ public class DiffUtilsTest {
    }

    @Test
-    public void testDiff_EmptyList() throws DiffException {
+    public void testDiff_EmptyList() {
        final Patch<String> patch = DiffUtils.diff(new ArrayList<>(), new ArrayList<>());
        assertNotNull(patch);
        assertEquals(0, patch.getDeltas().size());
    }

    @Test
-    public void testDiff_EmptyListWithNonEmpty() throws DiffException {
+    public void testDiff_EmptyListWithNonEmpty() {
        final Patch<String> patch = DiffUtils.diff(new ArrayList<>(), Arrays.asList("aaa"));
        assertNotNull(patch);
        assertEquals(1, patch.getDeltas().size());
@@ -82,7 +83,7 @@ public class DiffUtilsTest {
    }

    @Test
-    public void testDiffInline() throws DiffException {
+    public void testDiffInline() {
        final Patch<String> patch = DiffUtils.diffInline("", "test");
        assertEquals(1, patch.getDeltas().size());
        assertTrue(patch.getDeltas().get(0) instanceof InsertDelta);
@@ -92,7 +93,7 @@ public class DiffUtilsTest {
    }

    @Test
-    public void testDiffInline2() throws DiffException {
+    public void testDiffInline2() {
        final Patch<String> patch = DiffUtils.diffInline("es", "fest");
        assertEquals(2, patch.getDeltas().size());
        assertTrue(patch.getDeltas().get(0) instanceof InsertDelta);
@@ -105,7 +106,7 @@ public class DiffUtilsTest {
    }

    @Test
-    public void testDiffIntegerList() throws DiffException {
+    public void testDiffIntegerList() {
        List<Integer> original = Arrays.asList(1, 2, 3, 4, 5);
        List<Integer> revised = Arrays.asList(2, 3, 4, 6);

@@ -121,7 +122,7 @@ public class DiffUtilsTest {
    }

    @Test
-    public void testDiffMissesChangeForkDnaumenkoIssue31() throws DiffException {
+    public void testDiffMissesChangeForkDnaumenkoIssue31() {
        List<String> original = Arrays.asList("line1", "line2", "line3");
        List<String> revised = Arrays.asList("line1", "line2-2", "line4");

@@ -134,8 +135,8 @@ public class DiffUtilsTest {
     * To test this, the greedy meyer algorithm is not suitable.
     */
    @Test
-    @Ignore
-    public void testPossibleDiffHangOnLargeDatasetDnaumenkoIssue26() throws IOException, DiffException {
+    @Disabled
+    public void testPossibleDiffHangOnLargeDatasetDnaumenkoIssue26() throws IOException {
        ZipFile zip = new ZipFile(TestConstants.MOCK_FOLDER + "/large_dataset1.zip");

        Patch<String> patch = DiffUtils.diff(
@@ -154,10 +155,76 @@ public class DiffUtilsTest {
    }

    @Test
-    public void testDiffMyersExample1() throws DiffException {
+    public void testDiffMyersExample1() {
        final Patch<String> patch = DiffUtils.diff(Arrays.asList("A", "B", "C", "A", "B", "B", "A"), Arrays.asList("C", "B", "A", "B", "A", "C"));
        assertNotNull(patch);
        assertEquals(4, patch.getDeltas().size());
        assertEquals("Patch{deltas=[[DeleteDelta, position: 0, lines: [A, B]], [InsertDelta, position: 3, lines: [B]], [DeleteDelta, position: 5, lines: [B]], [InsertDelta, position: 7, lines: [C]]]}", patch.toString());
    }
+
+    @Test
+    public void testDiff_Equal() {
+        final Patch<String> patch = DiffUtils.diff(
+                Arrays.asList("hhh", "jjj", "kkk"),
+                Arrays.asList("hhh", "jjj", "kkk"), true);
+        assertNotNull(patch);
+        assertEquals(1, patch.getDeltas().size());
+        final AbstractDelta<String> delta = patch.getDeltas().get(0);
+        assertTrue(delta instanceof EqualDelta);
+        assertEquals(new Chunk<>(0, Arrays.asList("hhh", "jjj", "kkk")), delta.getSource());
+        assertEquals(new Chunk<>(0, Arrays.asList("hhh", "jjj", "kkk")), delta.getTarget());
+    }
+
+    @Test
+    public void testDiff_InsertWithEqual() {
+        final Patch<String> patch = DiffUtils.diff(Arrays.asList("hhh"), Arrays.
+                asList("hhh", "jjj", "kkk"), true);
+        assertNotNull(patch);
+        assertEquals(2, patch.getDeltas().size());
+
+        AbstractDelta<String> delta = patch.getDeltas().get(0);
+        assertTrue(delta instanceof EqualDelta);
+        assertEquals(new Chunk<>(0, Arrays.asList("hhh")), delta.getSource());
+        assertEquals(new Chunk<>(0, Arrays.asList("hhh")), delta.getTarget());
+
+        delta = patch.getDeltas().get(1);
+        assertTrue(delta instanceof InsertDelta);
+        assertEquals(new Chunk<>(1, Collections.<String>emptyList()), delta.getSource());
+        assertEquals(new Chunk<>(1, Arrays.asList("jjj", "kkk")), delta.getTarget());
+    }
+
+    @Test
+    public void testDiff_ProblemIssue42() {
+        final Patch<String> patch = DiffUtils.diff(
+                Arrays.asList("The", "dog", "is", "brown"),
+                Arrays.asList("The", "fox", "is", "down"), true);
+
+        System.out.println(patch);
+        assertNotNull(patch);
+        assertEquals(4, patch.getDeltas().size());
+
+        
+        assertThat(patch.getDeltas()).extracting(d -> d.getType().name())
+                .containsExactly("EQUAL", "CHANGE", "EQUAL", "CHANGE");
+        
+        AbstractDelta<String> delta = patch.getDeltas().get(0);
+        assertTrue(delta instanceof EqualDelta);
+        assertEquals(new Chunk<>(0, Arrays.asList("The")), delta.getSource());
+        assertEquals(new Chunk<>(0, Arrays.asList("The")), delta.getTarget());
+
+        delta = patch.getDeltas().get(1);
+        assertTrue(delta instanceof ChangeDelta);
+        assertEquals(new Chunk<>(1, Arrays.asList("dog")), delta.getSource());
+        assertEquals(new Chunk<>(1, Arrays.asList("fox")), delta.getTarget());
+        
+        delta = patch.getDeltas().get(2);
+        assertTrue(delta instanceof EqualDelta);
+        assertEquals(new Chunk<>(2, Arrays.asList("is")), delta.getSource());
+        assertEquals(new Chunk<>(2, Arrays.asList("is")), delta.getTarget());
+        
+        delta = patch.getDeltas().get(3);
+        assertTrue(delta instanceof ChangeDelta);
+        assertEquals(new Chunk<>(3, Arrays.asList("brown")), delta.getSource());
+        assertEquals(new Chunk<>(3, Arrays.asList("down")), delta.getTarget());
+    }
 }
--- a/java-diff-utils/src/test/java/com/github/difflib/GenerateUnifiedDiffTest.java
+++ b/java-diff-utils/src/test/java/com/github/difflib/GenerateUnifiedDiffTest.java
@@ -1,6 +1,6 @@
 package com.github.difflib;

-import com.github.difflib.algorithm.DiffException;
+import com.github.difflib.patch.Chunk;
 import com.github.difflib.patch.Patch;
 import com.github.difflib.patch.PatchFailedException;
 import java.io.BufferedReader;
@@ -9,11 +9,13 @@ import java.io.FileReader;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 import static java.util.stream.Collectors.joining;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
-import org.junit.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+import org.junit.jupiter.api.Test;

 public class GenerateUnifiedDiffTest {

@@ -29,7 +31,7 @@ public class GenerateUnifiedDiffTest {
    }

    @Test
-    public void testGenerateUnified() throws DiffException, IOException {
+    public void testGenerateUnified() throws IOException {
        List<String> origLines = fileToLines(TestConstants.MOCK_FOLDER + "original.txt");
        List<String> revLines = fileToLines(TestConstants.MOCK_FOLDER + "revised.txt");

@@ -37,7 +39,7 @@ public class GenerateUnifiedDiffTest {
    }

    @Test
-    public void testGenerateUnifiedWithOneDelta() throws DiffException, IOException {
+    public void testGenerateUnifiedWithOneDelta() throws IOException {
        List<String> origLines = fileToLines(TestConstants.MOCK_FOLDER + "one_delta_test_original.txt");
        List<String> revLines = fileToLines(TestConstants.MOCK_FOLDER + "one_delta_test_revised.txt");

@@ -45,7 +47,7 @@ public class GenerateUnifiedDiffTest {
    }

    @Test
-    public void testGenerateUnifiedDiffWithoutAnyDeltas() throws DiffException {
+    public void testGenerateUnifiedDiffWithoutAnyDeltas() {
        List<String> test = Arrays.asList("abc");
        Patch<String> patch = DiffUtils.diff(test, test);
        UnifiedDiffUtils.generateUnifiedDiff("abc", "abc", test, patch, 0);
@@ -67,14 +69,14 @@ public class GenerateUnifiedDiffTest {
     * Issue 12
     */
    @Test
-    public void testPatchWithNoDeltas() throws DiffException, IOException {
+    public void testPatchWithNoDeltas() throws IOException {
        final List<String> lines1 = fileToLines(TestConstants.MOCK_FOLDER + "issue11_1.txt");
        final List<String> lines2 = fileToLines(TestConstants.MOCK_FOLDER + "issue11_2.txt");
        verify(lines1, lines2, "issue11_1.txt", "issue11_2.txt");
    }

    @Test
-    public void testDiff5() throws DiffException, IOException {
+    public void testDiff5() throws IOException {
        final List<String> lines1 = fileToLines(TestConstants.MOCK_FOLDER + "5A.txt");
        final List<String> lines2 = fileToLines(TestConstants.MOCK_FOLDER + "5B.txt");
        verify(lines1, lines2, "5A.txt", "5B.txt");
@@ -84,7 +86,7 @@ public class GenerateUnifiedDiffTest {
     * Issue 19
     */
    @Test
-    public void testDiffWithHeaderLineInText() throws DiffException {
+    public void testDiffWithHeaderLineInText() {
        List<String> original = new ArrayList<>();
        List<String> revised = new ArrayList<>();

@@ -104,9 +106,69 @@ public class GenerateUnifiedDiffTest {
                original, patch, 10);
        UnifiedDiffUtils.parseUnifiedDiff(udiff);
    }
+    
+    /**
+     * Issue 47
+     */
+    @Test
+    public void testNewFileCreation() {
+        List<String> original = new ArrayList<>();
+        List<String> revised = new ArrayList<>();
+
+        revised.add("line1");
+        revised.add("line2");
+
+        Patch<String> patch = DiffUtils.diff(original, revised);
+        List<String> udiff = UnifiedDiffUtils.generateUnifiedDiff(null, "revised",
+                original, patch, 10);
+        
+        assertEquals("--- /dev/null", udiff.get(0));
+        assertEquals("+++ revised", udiff.get(1));
+        assertEquals("@@ -0,0 +1,2 @@", udiff.get(2));
+        
+        UnifiedDiffUtils.parseUnifiedDiff(udiff);
+    }
+
+    /**
+     * Issue 89
+     */
+    @Test
+    public void testChagngePosition() throws IOException {
+        final List<String> patchLines = fileToLines(TestConstants.MOCK_FOLDER + "issue89_patch.txt");
+        final Patch<String> patch = UnifiedDiffUtils.parseUnifiedDiff(patchLines);
+        List<Integer> realRemoveListOne = Collections.singletonList(3);
+        List<Integer> realAddListOne = Arrays.asList(3, 7, 8, 9, 10, 11, 12, 13, 14);
+        validateChangePosition(patch, 0, realRemoveListOne, realAddListOne);
+        List<Integer> realRemoveListTwo = new ArrayList<>();
+        List<Integer> realAddListTwo = Arrays.asList(27, 28);
+        validateChangePosition(patch, 1, realRemoveListTwo, realAddListTwo);
+
+    }
+
+    private void validateChangePosition(Patch<String> patch, int index, List<Integer> realRemoveList,
+                                        List<Integer> realAddList ) {
+        final Chunk originChunk = patch.getDeltas().get(index).getSource();
+        List<Integer> removeList = originChunk.getChangePosition();
+        assertEquals(realRemoveList.size(), removeList.size());
+        for (Integer ele: realRemoveList) {
+            assertTrue(realRemoveList.contains(ele));
+        }
+        for (Integer ele: removeList) {
+            assertTrue(realAddList.contains(ele));
+        }
+        final Chunk targetChunk = patch.getDeltas().get(index).getTarget();
+        List<Integer> addList = targetChunk.getChangePosition();
+        assertEquals(realAddList.size(), addList.size());
+        for (Integer ele: realAddList) {
+            assertTrue(addList.contains(ele));
+        }
+        for (Integer ele: addList) {
+            assertTrue(realAddList.contains(ele));
+        }
+    }

    private void verify(List<String> origLines, List<String> revLines,
-            String originalFile, String revisedFile) throws DiffException {
+            String originalFile, String revisedFile) {
        Patch<String> patch = DiffUtils.diff(origLines, revLines);
        List<String> unifiedDiff = UnifiedDiffUtils.generateUnifiedDiff(originalFile, revisedFile,
                origLines, patch, 10);
--- a/java-diff-utils/src/test/java/com/github/difflib/algorithm/myers/MyersDiffTest.java
+++ b/java-diff-utils/src/test/java/com/github/difflib/algorithm/myers/MyersDiffTest.java
@@ -16,13 +16,13 @@
 package com.github.difflib.algorithm.myers;

 import com.github.difflib.algorithm.DiffAlgorithmListener;
-import com.github.difflib.algorithm.DiffException;
 import com.github.difflib.patch.Patch;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
-import static org.junit.Assert.*;
-import org.junit.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import org.junit.jupiter.api.Test;

 /**
 *
@@ -31,7 +31,7 @@ import org.junit.Test;
 public class MyersDiffTest {

    @Test
-    public void testDiffMyersExample1Forward() throws DiffException {
+    public void testDiffMyersExample1Forward() {
        List<String> original = Arrays.asList("A", "B", "C", "A", "B", "B", "A");
        List<String> revised = Arrays.asList("C", "B", "A", "B", "A", "C");
        final Patch<String> patch = Patch.generate(original, revised, new MyersDiff<String>().computeDiff(original, revised, null));
@@ -41,7 +41,7 @@ public class MyersDiffTest {
    }
    
    @Test
-    public void testDiffMyersExample1ForwardWithListener() throws DiffException {
+    public void testDiffMyersExample1ForwardWithListener() {
        List<String> original = Arrays.asList("A", "B", "C", "A", "B", "B", "A");
        List<String> revised = Arrays.asList("C", "B", "A", "B", "A", "C");
        
--- a/java-diff-utils/src/test/java/com/github/difflib/examples/ComputeDifference.java
+++ b/java-diff-utils/src/test/java/com/github/difflib/examples/ComputeDifference.java
@@ -2,7 +2,6 @@ package com.github.difflib.examples;

 import com.github.difflib.DiffUtils;
 import com.github.difflib.TestConstants;
-import com.github.difflib.algorithm.DiffException;
 import com.github.difflib.patch.AbstractDelta;
 import com.github.difflib.patch.Patch;
 import java.io.File;
@@ -15,7 +14,7 @@ public class ComputeDifference {
    private static final String ORIGINAL = TestConstants.MOCK_FOLDER + "original.txt";
    private static final String RIVISED = TestConstants.MOCK_FOLDER + "revised.txt";

-    public static void main(String[] args) throws DiffException, IOException {
+    public static void main(String[] args) throws IOException {
        List<String> original = Files.readAllLines(new File(ORIGINAL).toPath());
        List<String> revised = Files.readAllLines(new File(RIVISED).toPath());

--- a/java-diff-utils/src/test/java/com/github/difflib/patch/PatchTest.java
+++ b/java-diff-utils/src/test/java/com/github/difflib/patch/PatchTest.java
@@ -1,17 +1,16 @@
 package com.github.difflib.patch;

 import com.github.difflib.DiffUtils;
-import com.github.difflib.algorithm.DiffException;
 import java.util.Arrays;
 import java.util.List;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
-import org.junit.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.fail;
+import org.junit.jupiter.api.Test;

 public class PatchTest {

    @Test
-    public void testPatch_Insert() throws DiffException {
+    public void testPatch_Insert() {
        final List<String> insertTest_from = Arrays.asList("hhh");
        final List<String> insertTest_to = Arrays.asList("hhh", "jjj", "kkk", "lll");

@@ -24,7 +23,7 @@ public class PatchTest {
    }

    @Test
-    public void testPatch_Delete() throws DiffException {
+    public void testPatch_Delete() {
        final List<String> deleteTest_from = Arrays.asList("ddd", "fff", "ggg", "hhh");
        final List<String> deleteTest_to = Arrays.asList("ggg");

@@ -37,7 +36,7 @@ public class PatchTest {
    }

    @Test
-    public void testPatch_Change() throws DiffException {
+    public void testPatch_Change() {
        final List<String> changeTest_from = Arrays.asList("aaa", "bbb", "ccc", "ddd");
        final List<String> changeTest_to = Arrays.asList("aaa", "bxb", "cxc", "ddd");

--- a/java-diff-utils/src/test/java/com/github/difflib/text/DiffRowGeneratorTest.java
+++ b/java-diff-utils/src/test/java/com/github/difflib/text/DiffRowGeneratorTest.java
@@ -1,22 +1,24 @@
 package com.github.difflib.text;

-import com.github.difflib.algorithm.DiffException;
 import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
+import java.nio.file.Paths;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 import java.util.regex.Pattern;
+import static java.util.stream.Collectors.joining;
 import static java.util.stream.Collectors.toList;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import org.junit.Test;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import org.junit.jupiter.api.Test;

 public class DiffRowGeneratorTest {

    @Test
-    public void testGenerator_Default() throws DiffException {
+    public void testGenerator_Default() {
        String first = "anything \n \nother";
        String second = "anything\n\nother";

@@ -40,7 +42,7 @@ public class DiffRowGeneratorTest {
    }

    @Test
-    public void testGenerator_Default2() throws DiffException {
+    public void testGenerator_Default2() {
        String first = "anything \n \nother";
        String second = "anything\n\nother";

@@ -54,7 +56,7 @@ public class DiffRowGeneratorTest {
    }

    @Test
-    public void testGenerator_InlineDiff() throws DiffException {
+    public void testGenerator_InlineDiff() {
        String first = "anything \n \nother";
        String second = "anything\n\nother";

@@ -70,7 +72,7 @@ public class DiffRowGeneratorTest {
    }

    @Test
-    public void testGenerator_IgnoreWhitespaces() throws DiffException {
+    public void testGenerator_IgnoreWhitespaces() {
        String first = "anything \n \nother\nmore lines";
        String second = "anything\n\nother\nsome more lines";

@@ -99,7 +101,7 @@ public class DiffRowGeneratorTest {
    }

    @Test
-    public void testGeneratorWithWordWrap() throws DiffException {
+    public void testGeneratorWithWordWrap() {
        String first = "anything \n \nother";
        String second = "anything\n\nother";

@@ -116,7 +118,7 @@ public class DiffRowGeneratorTest {
    }

    @Test
-    public void testGeneratorWithMerge() throws DiffException {
+    public void testGeneratorWithMerge() {
        String first = "anything \n \nother";
        String second = "anything\n\nother";

@@ -134,7 +136,7 @@ public class DiffRowGeneratorTest {
    }

    @Test
-    public void testGeneratorWithMerge2() throws DiffException {
+    public void testGeneratorWithMerge2() {
        DiffRowGenerator generator = DiffRowGenerator.create()
                .showInlineDiffs(true)
                .mergeOriginalRevised(true)
@@ -147,7 +149,7 @@ public class DiffRowGeneratorTest {
    }

    @Test
-    public void testGeneratorWithMerge3() throws DiffException {
+    public void testGeneratorWithMerge3() {
        String first = "test\nanything \n \nother";
        String second = "anything\n\nother\ntest\ntest2";

@@ -168,7 +170,7 @@ public class DiffRowGeneratorTest {
    }

    @Test
-    public void testGeneratorWithMergeByWord4() throws DiffException {
+    public void testGeneratorWithMergeByWord4() {
        DiffRowGenerator generator = DiffRowGenerator.create()
                .showInlineDiffs(true)
                .mergeOriginalRevised(true)
@@ -182,7 +184,7 @@ public class DiffRowGeneratorTest {
    }

    @Test
-    public void testGeneratorWithMergeByWord5() throws DiffException {
+    public void testGeneratorWithMergeByWord5() {
        DiffRowGenerator generator = DiffRowGenerator.create()
                .showInlineDiffs(true)
                .mergeOriginalRevised(true)
@@ -220,7 +222,7 @@ public class DiffRowGeneratorTest {
    }

    @Test
-    public void testGeneratorExample1() throws DiffException {
+    public void testGeneratorExample1() {
        DiffRowGenerator generator = DiffRowGenerator.create()
                .showInlineDiffs(true)
                .mergeOriginalRevised(true)
@@ -239,7 +241,7 @@ public class DiffRowGeneratorTest {
    }

    @Test
-    public void testGeneratorExample2() throws DiffException {
+    public void testGeneratorExample2() {
        DiffRowGenerator generator = DiffRowGenerator.create()
                .showInlineDiffs(true)
                .inlineDiffByWord(true)
@@ -262,7 +264,7 @@ public class DiffRowGeneratorTest {
    }

    @Test
-    public void testGeneratorUnchanged() throws DiffException {
+    public void testGeneratorUnchanged() {
        String first = "anything \n \nother";
        String second = "anything\n\nother";

@@ -280,7 +282,7 @@ public class DiffRowGeneratorTest {
    }

    @Test
-    public void testGeneratorIssue14() throws DiffException {
+    public void testGeneratorIssue14() {
        DiffRowGenerator generator = DiffRowGenerator.create()
                .showInlineDiffs(true)
                .mergeOriginalRevised(true)
@@ -299,7 +301,7 @@ public class DiffRowGeneratorTest {
    }

    @Test
-    public void testGeneratorIssue15() throws DiffException, IOException {
+    public void testGeneratorIssue15() throws IOException {
        DiffRowGenerator generator = DiffRowGenerator.create()
                .showInlineDiffs(true) //show the ~ ~ and ** ** symbols on each difference
                .inlineDiffByWord(true) //show the ~ ~ and ** ** around each different word instead of each letter
@@ -328,7 +330,7 @@ public class DiffRowGeneratorTest {
    }

    @Test
-    public void testGeneratorIssue22() throws DiffException {
+    public void testGeneratorIssue22() {
        DiffRowGenerator generator = DiffRowGenerator.create()
                .showInlineDiffs(true)
                .inlineDiffByWord(true)
@@ -352,7 +354,7 @@ public class DiffRowGeneratorTest {
    }

    @Test
-    public void testGeneratorIssue22_2() throws DiffException {
+    public void testGeneratorIssue22_2() {
        DiffRowGenerator generator = DiffRowGenerator.create()
                .showInlineDiffs(true)
                .inlineDiffByWord(true)
@@ -370,7 +372,7 @@ public class DiffRowGeneratorTest {
    }

    @Test
-    public void testGeneratorIssue22_3() throws DiffException {
+    public void testGeneratorIssue22_3() {
        DiffRowGenerator generator = DiffRowGenerator.create()
                .showInlineDiffs(true)
                .inlineDiffByWord(true)
@@ -388,7 +390,7 @@ public class DiffRowGeneratorTest {
    }

    @Test
-    public void testGeneratorIssue41DefaultNormalizer() throws DiffException {
+    public void testGeneratorIssue41DefaultNormalizer() {
        DiffRowGenerator generator = DiffRowGenerator.create()
                .build();
        List<DiffRow> rows = generator.generateDiffRows(Arrays.asList("<"), Arrays.asList("<"));
@@ -396,7 +398,7 @@ public class DiffRowGeneratorTest {
    }

    @Test
-    public void testGeneratorIssue41UserNormalizer() throws DiffException {
+    public void testGeneratorIssue41UserNormalizer() {
        DiffRowGenerator generator = DiffRowGenerator.create()
                .lineNormalizer(str -> str.replace("\t", "    "))
                .build();
@@ -407,7 +409,7 @@ public class DiffRowGeneratorTest {
    }

    @Test
-    public void testGenerationIssue44reportLinesUnchangedProblem() throws DiffException {
+    public void testGenerationIssue44reportLinesUnchangedProblem() {
        DiffRowGenerator generator = DiffRowGenerator.create()
                .showInlineDiffs(true)
                .reportLinesUnchanged(true)
@@ -417,4 +419,206 @@ public class DiffRowGeneratorTest {
        List<DiffRow> rows = generator.generateDiffRows(Arrays.asList("<dt>To do</dt>"), Arrays.asList("<dt>Done</dt>"));
        assertEquals("[[CHANGE,<dt>~~T~~o~~ do~~</dt>,<dt>**D**o**ne**</dt>]]", rows.toString());
    }
+
+    @Test
+    public void testIgnoreWhitespaceIssue66() {
+        DiffRowGenerator generator = DiffRowGenerator.create()
+                .showInlineDiffs(true)
+                .inlineDiffByWord(true)
+                .ignoreWhiteSpaces(true)
+                .mergeOriginalRevised(true)
+                .oldTag(f -> "~") //introduce markdown style for strikethrough
+                .newTag(f -> "**") //introduce markdown style for bold
+                .build();
+
+        //compute the differences for two test texts.
+        //CHECKSTYLE:OFF
+        List<DiffRow> rows = generator.generateDiffRows(
+                Arrays.asList("This\tis\ta\ttest."),
+                Arrays.asList("This is a test"));
+        //CHECKSTYLE:ON
+
+        assertEquals("This    is    a    test~.~", rows.get(0).getOldLine());
+    }
+
+    @Test
+    public void testIgnoreWhitespaceIssue66_2() {
+        DiffRowGenerator generator = DiffRowGenerator.create()
+                .showInlineDiffs(true)
+                .inlineDiffByWord(true)
+                .ignoreWhiteSpaces(true)
+                .mergeOriginalRevised(true)
+                .oldTag(f -> "~") //introduce markdown style for strikethrough
+                .newTag(f -> "**") //introduce markdown style for bold
+                .build();
+
+        //compute the differences for two test texts.
+        List<DiffRow> rows = generator.generateDiffRows(
+                Arrays.asList("This  is  a  test."),
+                Arrays.asList("This is a test"));
+
+        assertEquals("This  is  a  test~.~", rows.get(0).getOldLine());
+    }
+
+    @Test
+    public void testIgnoreWhitespaceIssue64() {
+        DiffRowGenerator generator = DiffRowGenerator.create()
+                .showInlineDiffs(true)
+                .inlineDiffByWord(true)
+                .ignoreWhiteSpaces(true)
+                .mergeOriginalRevised(true)
+                .oldTag(f -> "~") //introduce markdown style for strikethrough
+                .newTag(f -> "**") //introduce markdown style for bold
+                .build();
+
+        //compute the differences for two test texts.
+        List<DiffRow> rows = generator.generateDiffRows(
+                Arrays.asList("test\n\ntestline".split("\n")),
+                Arrays.asList("A new text line\n\nanother one".split("\n")));
+
+        assertThat(rows).extracting(item -> item.getOldLine())
+                .containsExactly("~test~**A new text line**",
+                        "",
+                        "~testline~**another one**");
+    }
+
+    @Test
+    public void testReplaceDiffsIssue63() {
+        DiffRowGenerator generator = DiffRowGenerator.create()
+                .showInlineDiffs(true)
+                .inlineDiffByWord(true)
+                .mergeOriginalRevised(true)
+                .oldTag(f -> "~") //introduce markdown style for strikethrough
+                .newTag(f -> "**") //introduce markdown style for bold
+                .processDiffs(str -> str.replace(" ", "/"))
+                .build();
+
+        //compute the differences for two test texts.
+        List<DiffRow> rows = generator.generateDiffRows(
+                Arrays.asList("This  is  a  test."),
+                Arrays.asList("This is a test"));
+
+        assertEquals("This~//~**/**is~//~**/**a~//~**/**test~.~", rows.get(0).getOldLine());
+    }
+
+    @Test
+    public void testProblemTooManyDiffRowsIssue65() {
+        DiffRowGenerator generator = DiffRowGenerator.create()
+                .showInlineDiffs(true)
+                .reportLinesUnchanged(true)
+                .oldTag(f -> "~")
+                .newTag(f -> "**")
+                .mergeOriginalRevised(true)
+                .inlineDiffByWord(false)
+                .replaceOriginalLinefeedInChangesWithSpaces(true)
+                .build();
+
+        List<DiffRow> diffRows = generator.generateDiffRows(
+                Arrays.asList("Ich möchte nicht mit einem Bot sprechen.", "Ich soll das schon wieder wiederholen?"),
+                Arrays.asList("Ich möchte nicht mehr mit dir sprechen. Leite mich weiter.", "Kannst du mich zum Kundendienst weiterleiten?"));
+
+        print(diffRows);
+
+        assertThat(diffRows).hasSize(2);
+    }
+
+    @Test
+    public void testProblemTooManyDiffRowsIssue65_NoMerge() {
+        DiffRowGenerator generator = DiffRowGenerator.create()
+                .showInlineDiffs(true)
+                .reportLinesUnchanged(true)
+                .oldTag(f -> "~")
+                .newTag(f -> "**")
+                .mergeOriginalRevised(false)
+                .inlineDiffByWord(false)
+                .build();
+
+        List<DiffRow> diffRows = generator.generateDiffRows(
+                Arrays.asList("Ich möchte nicht mit einem Bot sprechen.", "Ich soll das schon wieder wiederholen?"),
+                Arrays.asList("Ich möchte nicht mehr mit dir sprechen. Leite mich weiter.", "Kannst du mich zum Kundendienst weiterleiten?"));
+
+        System.out.println(diffRows);
+
+        assertThat(diffRows).hasSize(2);
+    }
+
+    @Test
+    public void testProblemTooManyDiffRowsIssue65_DiffByWord() {
+        DiffRowGenerator generator = DiffRowGenerator.create()
+                .showInlineDiffs(true)
+                .reportLinesUnchanged(true)
+                .oldTag(f -> "~")
+                .newTag(f -> "**")
+                .mergeOriginalRevised(true)
+                .inlineDiffByWord(true)
+                .build();
+
+        List<DiffRow> diffRows = generator.generateDiffRows(
+                Arrays.asList("Ich möchte nicht mit einem Bot sprechen.", "Ich soll das schon wieder wiederholen?"),
+                Arrays.asList("Ich möchte nicht mehr mit dir sprechen. Leite mich weiter.", "Kannst du mich zum Kundendienst weiterleiten?"));
+
+        System.out.println(diffRows);
+
+        assertThat(diffRows).hasSize(2);
+    }
+
+    @Test
+    public void testProblemTooManyDiffRowsIssue65_NoInlineDiff() {
+        DiffRowGenerator generator = DiffRowGenerator.create()
+                .showInlineDiffs(false)
+                .reportLinesUnchanged(true)
+                .oldTag(f -> "~")
+                .newTag(f -> "**")
+                .mergeOriginalRevised(true)
+                .inlineDiffByWord(false)
+                .build();
+
+        List<DiffRow> diffRows = generator.generateDiffRows(
+                Arrays.asList("Ich möchte nicht mit einem Bot sprechen.", "Ich soll das schon wieder wiederholen?"),
+                Arrays.asList("Ich möchte nicht mehr mit dir sprechen. Leite mich weiter.", "Kannst du mich zum Kundendienst weiterleiten?"));
+
+        System.out.println(diffRows);
+
+        assertThat(diffRows).hasSize(2);
+    }
+
+    @Test
+    public void testLinefeedInStandardTagsWithLineWidthIssue81() {
+        List<String> original = Arrays.asList(("American bobtail jaguar. American bobtail bombay but turkish angora and tomcat.\n"
+                + "Russian blue leopard. Lion. Tabby scottish fold for russian blue, so savannah yet lynx. Tomcat singapura, cheetah.\n"
+                + "Bengal tiger panther but singapura but bombay munchkin for cougar.").split("\n"));
+        List<String> revised = Arrays.asList(("bobtail jaguar. American bobtail turkish angora and tomcat.\n"
+                + "Russian blue leopard. Lion. Tabby scottish folded for russian blue, so savannah yettie? lynx. Tomcat singapura, cheetah.\n"
+                + "Bengal tiger panther but singapura but bombay munchkin for cougar. And more.").split("\n"));
+
+        DiffRowGenerator generator = DiffRowGenerator.create()
+                .showInlineDiffs(true)
+                .ignoreWhiteSpaces(true)
+                .columnWidth(100)
+                .build();
+        List<DiffRow> deltas = generator.generateDiffRows(original, revised);
+
+        System.out.println(deltas);
+    }
+    
+    @Test
+    public void testIssue86WrongInlineDiff() throws IOException {      
+        String original = Files.lines(Paths.get("target/test-classes/com/github/difflib/text/issue_86_original.txt")).collect(joining("\n"));
+        String revised = Files.lines(Paths.get("target/test-classes/com/github/difflib/text/issue_86_revised.txt")).collect(joining("\n"));
+        
+        DiffRowGenerator generator = DiffRowGenerator.create()
+            .showInlineDiffs(true)
+            .mergeOriginalRevised(false)
+            .inlineDiffByWord(true)
+            .oldTag( f -> "~" )
+            .newTag( f -> "**" )
+            .build();
+        List<DiffRow> rows = generator.generateDiffRows(
+                Arrays.asList(original.split("\n")),
+                Arrays.asList(revised.split("\n")));
+        
+        for (DiffRow diff : rows) {
+            System.out.println(diff);
+        }
+    }
 }
--- a/java-diff-utils/src/test/java/com/github/difflib/text/StringUtilsTest.java
+++ b/java-diff-utils/src/test/java/com/github/difflib/text/StringUtilsTest.java
@@ -15,8 +15,9 @@
 */
 package com.github.difflib.text;

-import static org.junit.Assert.*;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import org.junit.jupiter.api.Test;

 /**
 *
@@ -50,9 +51,10 @@ public class StringUtilsTest {
        assertEquals("test", StringUtils.wrapText("test", 10));
    }

-    @Test(expected = IllegalArgumentException.class)
+    @Test
    public void testWrapText_String_int_zero() {
-        assertEquals("test", StringUtils.wrapText("test", -1));
+        Assertions.assertThrows(IllegalArgumentException.class, 
+                () -> StringUtils.wrapText("test", -1));
    }

 }
--- a/java-diff-utils/src/test/java/com/github/difflib/unifieddiff/UnifiedDiffReaderTest.java
+++ b/java-diff-utils/src/test/java/com/github/difflib/unifieddiff/UnifiedDiffReaderTest.java
@@ -19,10 +19,11 @@ import com.github.difflib.patch.AbstractDelta;
 import java.io.IOException;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
-import static org.assertj.core.api.Java6Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import org.junit.Test;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import org.junit.jupiter.api.Test;

 /**
 *
@@ -42,7 +43,7 @@ public class UnifiedDiffReaderTest {
        assertThat(file1.getFromFile()).isEqualTo("src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt");
        assertThat(file1.getPatch().getDeltas().size()).isEqualTo(3);

-        assertThat(diff.getTail()).isEqualTo("2.17.1.windows.2\n\n");
+        assertThat(diff.getTail()).isEqualTo("2.17.1.windows.2\n");
    }

    @Test
@@ -100,7 +101,7 @@ public class UnifiedDiffReaderTest {
        assertThat(first.getSource().size()).isGreaterThan(0);
        assertThat(first.getTarget().size()).isGreaterThan(0);

-        assertThat(diff.getTail()).isEqualTo("2.17.1.windows.2\n\n");
+        assertThat(diff.getTail()).isEqualTo("2.17.1.windows.2\n");
    }

    @Test
@@ -141,7 +142,7 @@ public class UnifiedDiffReaderTest {
        assertThat(diff.getTail()).isNull();
        assertThat(diff.getHeader()).isNull();
    }
-    
+
    @Test
    public void testParseIssue51() throws IOException {
        UnifiedDiff diff = UnifiedDiffReader.parseUnifiedDiff(
@@ -154,7 +155,85 @@ public class UnifiedDiffReaderTest {
        UnifiedDiffFile file1 = diff.getFiles().get(0);
        assertThat(file1.getFromFile()).isEqualTo("f1");
        assertThat(file1.getPatch().getDeltas().size()).isEqualTo(1);
+        
+        UnifiedDiffFile file2 = diff.getFiles().get(1);
+        assertThat(file2.getFromFile()).isEqualTo("f2");
+        assertThat(file2.getPatch().getDeltas().size()).isEqualTo(1);

        assertThat(diff.getTail()).isNull();
    }
+
+    @Test
+    public void testParseIssue79() throws IOException {
+        UnifiedDiff diff = UnifiedDiffReader.parseUnifiedDiff(
+                UnifiedDiffReaderTest.class.getResourceAsStream("problem_diff_issue79.diff"));
+
+        assertThat(diff.getFiles().size()).isEqualTo(1);
+
+        UnifiedDiffFile file1 = diff.getFiles().get(0);
+        assertThat(file1.getFromFile()).isEqualTo("test/Issue.java");
+        assertThat(file1.getPatch().getDeltas().size()).isEqualTo(0);
+
+        assertThat(diff.getTail()).isNull();
+        assertThat(diff.getHeader()).isNull();
+    }
+
+    @Test
+    public void testParseIssue84() throws IOException {
+        UnifiedDiff diff = UnifiedDiffReader.parseUnifiedDiff(
+                UnifiedDiffReaderTest.class.getResourceAsStream("problem_diff_issue84.diff"));
+
+        assertThat(diff.getFiles().size()).isEqualTo(2);
+
+        UnifiedDiffFile file1 = diff.getFiles().get(0);
+        assertThat(file1.getFromFile()).isEqualTo("config/ant-phase-verify.xml");
+        assertThat(file1.getPatch().getDeltas().size()).isEqualTo(1);
+
+        UnifiedDiffFile file2 = diff.getFiles().get(1);
+        assertThat(file2.getFromFile()).isEqualTo("/dev/null");
+        assertThat(file2.getPatch().getDeltas().size()).isEqualTo(1);
+
+        assertThat(diff.getTail()).isEqualTo("2.7.4");
+        assertThat(diff.getHeader()).startsWith("From b53e612a2ab5ff15d14860e252f84c0f343fe93a Mon Sep 17 00:00:00 2001");
+    }
+
+    @Test
+    public void testParseIssue85() throws IOException {
+        UnifiedDiff diff = UnifiedDiffReader.parseUnifiedDiff(
+                UnifiedDiffReaderTest.class.getResourceAsStream("problem_diff_issue85.diff"));
+
+        assertThat(diff.getFiles().size()).isEqualTo(1);
+
+        assertEquals(1, diff.getFiles().size());
+
+        final UnifiedDiffFile file1 = diff.getFiles().get(0);
+        assertEquals("diff -r 83e41b73d115 -r a4438263b228 tests/test-check-pyflakes.t",
+                file1.getDiffCommand());
+        assertEquals("tests/test-check-pyflakes.t", file1.getFromFile());
+        assertEquals("tests/test-check-pyflakes.t", file1.getToFile());
+        assertEquals(1, file1.getPatch().getDeltas().size());
+
+        assertNull(diff.getTail());
+    }
+
+    @Test
+    public void testTimeStampRegexp() {
+        assertThat("2019-04-18 13:49:39.516149751 +0200").matches(UnifiedDiffReader.TIMESTAMP_REGEXP);
+    }
+    
+    @Test
+    public void testParseIssue98() throws IOException {
+        UnifiedDiff diff = UnifiedDiffReader.parseUnifiedDiff(
+                UnifiedDiffReaderTest.class.getResourceAsStream("problem_diff_issue98.diff"));
+
+        assertThat(diff.getFiles().size()).isEqualTo(1);
+
+        assertEquals(1, diff.getFiles().size());
+
+        final UnifiedDiffFile file1 = diff.getFiles().get(0);
+        assertEquals("100644",
+                file1.getDeletedFileMode());
+        assertEquals("src/test/java/se/bjurr/violations/lib/model/ViolationTest.java", file1.getFromFile());
+        assertThat(diff.getTail()).isEqualTo("2.25.1");
+    }
 }
--- a/java-diff-utils/src/test/java/com/github/difflib/unifieddiff/UnifiedDiffRoundTripTest.java
+++ b/java-diff-utils/src/test/java/com/github/difflib/unifieddiff/UnifiedDiffRoundTripTest.java
@@ -2,7 +2,6 @@ package com.github.difflib.unifieddiff;

 import com.github.difflib.DiffUtils;
 import com.github.difflib.TestConstants;
-import com.github.difflib.algorithm.DiffException;
 import com.github.difflib.patch.Patch;
 import com.github.difflib.patch.PatchFailedException;
 import java.io.BufferedReader;
@@ -15,10 +14,10 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import static java.util.stream.Collectors.joining;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
-import org.junit.Ignore;
-import org.junit.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.fail;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;

 public class UnifiedDiffRoundTripTest {

@@ -34,7 +33,7 @@ public class UnifiedDiffRoundTripTest {
    }

    @Test
-    public void testGenerateUnified() throws DiffException, IOException {
+    public void testGenerateUnified() throws IOException {
        List<String> origLines = fileToLines(TestConstants.MOCK_FOLDER + "original.txt");
        List<String> revLines = fileToLines(TestConstants.MOCK_FOLDER + "revised.txt");

@@ -42,7 +41,7 @@ public class UnifiedDiffRoundTripTest {
    }

    @Test
-    public void testGenerateUnifiedWithOneDelta() throws DiffException, IOException {
+    public void testGenerateUnifiedWithOneDelta() throws IOException {
        List<String> origLines = fileToLines(TestConstants.MOCK_FOLDER + "one_delta_test_original.txt");
        List<String> revLines = fileToLines(TestConstants.MOCK_FOLDER + "one_delta_test_revised.txt");

@@ -50,7 +49,7 @@ public class UnifiedDiffRoundTripTest {
    }

    @Test
-    public void testGenerateUnifiedDiffWithoutAnyDeltas() throws DiffException, IOException {
+    public void testGenerateUnifiedDiffWithoutAnyDeltas() throws IOException {
        List<String> test = Arrays.asList("abc");
        Patch<String> patch = DiffUtils.diff(test, test);
        StringWriter writer = new StringWriter();
@@ -84,15 +83,15 @@ public class UnifiedDiffRoundTripTest {
     * Issue 12
     */
    @Test
-    @Ignore
-    public void testPatchWithNoDeltas() throws DiffException, IOException {
+    @Disabled
+    public void testPatchWithNoDeltas() throws IOException {
        final List<String> lines1 = fileToLines(TestConstants.MOCK_FOLDER + "issue11_1.txt");
        final List<String> lines2 = fileToLines(TestConstants.MOCK_FOLDER + "issue11_2.txt");
        verify(lines1, lines2, "issue11_1.txt", "issue11_2.txt");
    }

    @Test
-    public void testDiff5() throws DiffException, IOException {
+    public void testDiff5() throws IOException {
        final List<String> lines1 = fileToLines(TestConstants.MOCK_FOLDER + "5A.txt");
        final List<String> lines2 = fileToLines(TestConstants.MOCK_FOLDER + "5B.txt");
        verify(lines1, lines2, "5A.txt", "5B.txt");
@@ -102,7 +101,7 @@ public class UnifiedDiffRoundTripTest {
     * Issue 19
     */
    @Test
-    public void testDiffWithHeaderLineInText() throws DiffException, IOException {
+    public void testDiffWithHeaderLineInText() throws IOException {
        List<String> original = new ArrayList<>();
        List<String> revised = new ArrayList<>();

@@ -130,7 +129,7 @@ public class UnifiedDiffRoundTripTest {
    }

    private void verify(List<String> origLines, List<String> revLines,
-            String originalFile, String revisedFile) throws DiffException, IOException {
+            String originalFile, String revisedFile) throws IOException {
        Patch<String> patch = DiffUtils.diff(origLines, revLines);

        StringWriter writer = new StringWriter();
--- a/java-diff-utils/src/test/java/com/github/difflib/unifieddiff/UnifiedDiffWriterTest.java
+++ b/java-diff-utils/src/test/java/com/github/difflib/unifieddiff/UnifiedDiffWriterTest.java
@@ -15,6 +15,8 @@
 */
 package com.github.difflib.unifieddiff;

+import com.github.difflib.DiffUtils;
+import com.github.difflib.patch.Patch;
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.StringWriter;
@@ -23,7 +25,11 @@ import java.net.URISyntaxException;
 import java.nio.charset.Charset;
 import java.nio.file.Files;
 import java.nio.file.Paths;
-import org.junit.Test;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import org.junit.jupiter.api.Test;

 /**
 *
@@ -40,8 +46,35 @@ public class UnifiedDiffWriterTest {
        UnifiedDiff diff = UnifiedDiffReader.parseUnifiedDiff(new ByteArrayInputStream(str.getBytes()));

        StringWriter writer = new StringWriter();
-//        UnifiedDiffWriter.write(diff, writer);
-//        System.out.println(writer.toString());
+        UnifiedDiffWriter.write(diff, f -> Collections.EMPTY_LIST, writer, 5);
+        System.out.println(writer.toString());
+    }
+    
+    /**
+     * Issue 47
+     */
+    @Test
+    public void testWriteWithNewFile() throws URISyntaxException, IOException {
+        
+        List<String> original = new ArrayList<>();
+        List<String> revised = new ArrayList<>();
+
+        revised.add("line1");
+        revised.add("line2");
+
+        Patch<String> patch = DiffUtils.diff(original, revised);
+        UnifiedDiff diff = new UnifiedDiff();
+        diff.addFile( UnifiedDiffFile.from(null, "revised", patch) );
+
+        StringWriter writer = new StringWriter();
+        UnifiedDiffWriter.write(diff, f -> original, writer, 5);
+        System.out.println(writer.toString());
+        
+        String[] lines = writer.toString().split("\\n");
+        
+        assertEquals("--- /dev/null", lines[0]);
+        assertEquals("+++ revised", lines[1]);
+        assertEquals("@@ -0,0 +1,2 @@", lines[2]);
    }

    static String readFile(URI path, Charset encoding)
--- a/java-diff-utils/src/test/resources/com/github/difflib/text/issue_86_original.txt
+++ b/java-diff-utils/src/test/resources/com/github/difflib/text/issue_86_original.txt
@@ -0,0 +1,7 @@
+MessageTime,MessageType,Instrument,InstrumentState,TradePrice,TradeVolume,TradeCond,TradeId,AskPrice1,AskVol1,BidPrice1,BidVol1,AskPrice2,AskVol2,BidPrice2,BidVol2,AskPrice3,AskVol3,BidPrice3,BidVol3,AskPrice4,AskVol4,BidPrice4,BidVol4,AskPrice5,AskVol5,BidPrice5,BidVol5
+2020-04-04T08:00:00.000Z,S,HHD_MAY20,Open,,,,,,,,,,,,,,,,,,,,,,,,
+2020-04-04T08:00:00.000Z,S,FHK_C23.5_MAY20,Open,,,,,,,,,,,,,,,,,,,,,,,,
+2020-04-04T13:49:11.522Z,Q,HHD_MAY20,,,,,,2.6,10,2.6,10,,,,,,,,,,,,,,,,
+2020-04-04T13:49:18.210Z,T,HHD_MAY20,,2.6,1,Screen,0,,,,,,,,,,,,,,,,,,,,
+2020-04-04T17:00:00.000Z,S,HHD_MAY20,Close,,,,,,,,,,,,,,,,,,,,,,,,
+2020-04-04T17:00:00.000Z,S,FHK_C23.5_MAY20,Close,,,,,,,,,,,,,,,,,,,,,,,,
--- a/java-diff-utils/src/test/resources/com/github/difflib/text/issue_86_revised.txt
+++ b/java-diff-utils/src/test/resources/com/github/difflib/text/issue_86_revised.txt
@@ -0,0 +1,8 @@
+MessageTime,MessageType,Instrument,InstrumentState,TradePrice,TradeVolume,TradeCond,TradeId,AskPrice1,AskVol1,BidPrice1,BidVol1,AskPrice2,AskVol2,BidPrice2,BidVol2,AskPrice3,AskVol3,BidPrice3,BidVol3,AskPrice4,AskVol4,BidPrice4,BidVol4,AskPrice5,AskVol5,BidPrice5,BidVol5
+2020-04-02T08:00:00.000Z,S,HHD_MAY20,Open,,,,,,,,,,,,,,,,,,,,,,,,
+2020-04-02T08:00:00.000Z,S,FHK_C23.5_MAY20,Open,,,,,,,,,,,,,,,,,,,,,,,,
+2020-04-04T13:49:11.522Z,Q,HHD_MAY20,,,,,,2.6,10,2.6,10,,,,,,,,,,,,,,,,
+2020-04xs-04T17dw:00:00.000Z,Sdwdw,HHD_MAY20dwdw,Closdwde,,,,,,,,,,,,,,,,,,,,,,,,
+2020-04-04T13:49:18.210Z,T,HHD_MAY20,,2.6,2,Screen,0,,,,,,,,,,,,,,,,,,,,
+2020-04-04T17:00:00.000Z,S,HHD_MAY20,Close,,,,,,,,,,,,,,,,,,,,,,,,
+2020-04-04T17:00:00.000Z,S,FHK_C23.5_MAY20,Close,,,,,,,,,,,,,,,,,,,,,,,,
--- a/java-diff-utils/src/test/resources/com/github/difflib/unifieddiff/problem_diff_issue51.diff
+++ b/java-diff-utils/src/test/resources/com/github/difflib/unifieddiff/problem_diff_issue51.diff
@@ -8,4 +8,5 @@ diff -U0 old/f2 new/f2
 --- old/f2	2019-09-25 14:38:14.000000000 +0200
 +++ new/f2	2019-09-25 14:38:32.000000000 +0200
@@ -1 +1 @@
-a\nc
+-a\nc
+a\nb\nd
--- a/java-diff-utils/src/test/resources/com/github/difflib/unifieddiff/problem_diff_issue79.diff
+++ b/java-diff-utils/src/test/resources/com/github/difflib/unifieddiff/problem_diff_issue79.diff
@@ -0,0 +1,3 @@
+diff --git a/test/Issue.java b/test/Issue.java
+new file mode 100644
+index 00000000..9702606e
--- a/java-diff-utils/src/test/resources/com/github/difflib/unifieddiff/problem_diff_issue84.diff
+++ b/java-diff-utils/src/test/resources/com/github/difflib/unifieddiff/problem_diff_issue84.diff
@@ -0,0 +1,109 @@
+From b53e612a2ab5ff15d14860e252f84c0f343fe93a Mon Sep 17 00:00:00 2001
+From: nmancus1 <nmancus1
+Date: Thu, 4 Jun 2020 11:46:34 -0400
+Subject: [PATCH] minor: Add input file for Java14 instanceof with pattern
+ matching (#7290)
+
+---
+ config/ant-phase-verify.xml                        |  2 +
+ .../InputJava14InstanceofWithPatternMatching.java  | 76 ++++++++++++++++++++++
+ 2 files changed, 78 insertions(+)
+ create mode 100644 src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java14/InputJava14InstanceofWithPatternMatching.java
+
+diff --git a/config/ant-phase-verify.xml b/config/ant-phase-verify.xml
+index d27ffef..e0285ce 100644
+--- a/config/ant-phase-verify.xml
+++ b/config/ant-phase-verify.xml
+@@ -148,6 +148,8 @@
+          <exclude name="**/InputMainFrameModelIncorrectClass.java"/>
+          <exclude name="**/InputBeforeExecutionExclusionFileFilterIncorrectClass.java"/>
+          <exclude name="**/InputJavaParser.java"/>
+         <!-- until https://github.com/checkstyle/checkstyle/issues/7290 -->
+         <exclude name="**/InputJava14InstanceofWithPatternMatching.java"/>
+          <!-- Cannot parse until Java 14 support -->
+          <exclude name="**/InputJava14Records.java"/>
+         </fileset>
+diff --git a/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java14/InputJava14InstanceofWithPatternMatching.java b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java14/InputJava14InstanceofWithPatternMatching.java
+new file mode 100644
+index 0000000..8fa3eba
+--- /dev/null
+++ b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java14/InputJava14InstanceofWithPatternMatching.java
+@@ -0,0 +1,76 @@
+//non-compiled with javac: Compilable with Java14
+package com.puppycrawl.tools.checkstyle.grammar.java14;
+
+import java.util.Arrays;
+import java.util.Locale;
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+ ...... I removed it
+        }
+    }
+}
+--
+2.7.4
--- a/java-diff-utils/src/test/resources/com/github/difflib/unifieddiff/problem_diff_issue85.diff
+++ b/java-diff-utils/src/test/resources/com/github/difflib/unifieddiff/problem_diff_issue85.diff
@@ -0,0 +1,31 @@
+# HG changeset patch
+# User Anton Shestakov <av6@dwimlabs.net>
+# Date 1591442367 -28800
+# Node ID a4438263b228dd3e2983d59095c6180b1411f0e8
+# Parent  83e41b73d115e3717943c2e5a83d36d05670384c
+tests: skip pyflakes for mercurial/thirdparty/
+
+The current version of pyflakes (2.2.0) correctly detects one issue:
+
+  mercurial/thirdparty/selectors2.py:335:40 '...'.format(...) has unused arguments at position(s): 1
+
+But we're not interested in fixing lint errors in third-party code, so we need
+to exclude at least selectors2.py. And in the discussion for this patch it was
+decided to just skip the entire thirdparty directory.
+
+Differential Revision: https://phab.mercurial-scm.org/D8619
+
+diff -r 83e41b73d115 -r a4438263b228 tests/test-check-pyflakes.t
+--- a/tests/test-check-pyflakes.t	Tue Jun 09 17:13:26 2020 -0400
+++ b/tests/test-check-pyflakes.t	Sat Jun 06 19:19:27 2020 +0800
+@@ -16,9 +16,7 @@
+   $ testrepohg locate 'set:**.py or grep("^#!.*python")' \
+   > -X hgext/fsmonitor/pywatchman \
+   > -X mercurial/pycompat.py -X contrib/python-zstandard \
+-  > -X mercurial/thirdparty/cbor \
+-  > -X mercurial/thirdparty/concurrent \
+-  > -X mercurial/thirdparty/zope \
+  > -X mercurial/thirdparty \
+   > 2>/dev/null \
+   > | xargs $PYTHON -m pyflakes 2>/dev/null | "$TESTDIR/filterpyflakes.py"
+   contrib/perf.py:*:* undefined name 'xrange' (glob) (?)
--- a/java-diff-utils/src/test/resources/com/github/difflib/unifieddiff/problem_diff_issue98.diff
+++ b/java-diff-utils/src/test/resources/com/github/difflib/unifieddiff/problem_diff_issue98.diff
@@ -0,0 +1,55 @@
+From fd940c6f66126734e82c00889e7c987e11deea91 Mon Sep 17 00:00:00 2001
+From: Tomas Bjerre <tomas.bjerre85@gmail.com>
+Date: Sun, 6 Sep 2020 11:20:34 +0200
+Subject: [PATCH] removing file
+
+---
+ .../violations/lib/model/ViolationTest.java   | 37 -------------------
+ 1 file changed, 37 deletions(-)
+ delete mode 100644 src/test/java/se/bjurr/violations/lib/model/ViolationTest.java
+
+diff --git a/src/test/java/se/bjurr/violations/lib/model/ViolationTest.java b/src/test/java/se/bjurr/violations/lib/model/ViolationTest.java
+deleted file mode 100644
+index 3e40b52..0000000
+--- a/src/test/java/se/bjurr/violations/lib/model/ViolationTest.java
+++ /dev/null
+@@ -1,37 +0,0 @@
+-package se.bjurr.violations.lib.model;
+-
+-import static org.assertj.core.api.Assertions.assertThat;
+-import static se.bjurr.violations.lib.model.SEVERITY.ERROR;
+-import static se.bjurr.violations.lib.model.Violation.violationBuilder;
+-import static se.bjurr.violations.lib.reports.Parser.CHECKSTYLE;
+-
+-import org.junit.Test;
+-import se.bjurr.violations.lib.model.Violation.ViolationBuilder;
+-import uk.co.jemos.podam.api.PodamFactoryImpl;
+-
+-public class ViolationTest {
+-
+-  @Test
+-  public void testThatFilePathsAreAlwaysFronSlashes() {
+-    final Violation violation =
+-        violationBuilder() //
+-            .setParser(CHECKSTYLE) //
+-            .setFile("c:\\path\\to\\file.xml") //
+-            .setMessage("message") //
+-            .setSeverity(ERROR) //
+-            .setStartLine(1) //
+-            .build();
+-    assertThat(violation.getFile()) //
+-        .isEqualTo("c:/path/to/file.xml");
+-  }
+-
+-  @Test
+-  public void testThatCopyConstructorWorks() {
+-    final ViolationBuilder originalBuilder =
+-        new PodamFactoryImpl().manufacturePojo(ViolationBuilder.class);
+-    final Violation original = originalBuilder.build();
+-    final Violation copied = new Violation(original);
+-    assertThat(copied) //
+-        .isEqualTo(original);
+-  }
+-}
+-- 
+2.25.1
--- a/java-diff-utils/src/test/resources/logging.properties
+++ b/java-diff-utils/src/test/resources/logging.properties
@@ -0,0 +1,8 @@
+handlers=java.util.logging.ConsoleHandler
+
+.level=INFO
+com.github.difflib.unifieddiff.level=FINE
+
+java.util.logging.ConsoleHandler.level=INFO
+#java.util.logging.ConsoleHandler.formatter=java.util.logging.SimpleFormatter
+
--- a/java-diff-utils/src/test/resources/mocks/issue89_patch.txt
+++ b/java-diff-utils/src/test/resources/mocks/issue89_patch.txt
@@ -0,0 +1,29 @@
+--- Origin.java	2020-06-11 11:06:21.000000000 +0800
+++ Update.java	2020-06-11 10:59:48.000000000 +0800
+@@ -1,9 +1,17 @@
+ package checkstyle_demo.PatchSuppression.MultiChangeInOneFile;
+ 
+-public class Origin {
+public class Update {
+     public void test1() {
+ 
+     }
+
+    public void test2() {
+
+    }
+
+    public void test3() {
+
+    }
+ }
+ 
+ class BasicTest {
+@@ -16,5 +24,7 @@
+ class Test2 {
+     public void test1() {
+         System.out.println();
+        System.out.println();
+        System.out.println();
+     }
+ }
--- a/java-diff-utils/src/test/resources/mocks/issue89_revised.txt
+++ b/java-diff-utils/src/test/resources/mocks/issue89_revised.txt
@@ -0,0 +1,30 @@
+package checkstyle_demo.PatchSuppression.MultiChangeInOneFile;
+
+public class issue89_revised {
+    public void test1() {
+
+    }
+
+    public void test2() {
+
+    }
+
+    public void test3() {
+
+    }
+}
+
+class Test {
+    private int i;
+    void foo() {
+        i++;
+    }
+}
+
+class Test2 {
+    public void test1() {
+        System.out.println();
+        System.out.println();
+        System.out.println();
+    }
+}
--- a/pom.xml
+++ b/pom.xml
@@ -3,7 +3,7 @@
    <modelVersion>4.0.0</modelVersion>
    <groupId>io.github.java-diff-utils</groupId>
    <artifactId>java-diff-utils-parent</artifactId>
-    <version>4.5</version>
+    <version>4.8</version>
    <name>java-diff-utils-parent</name>
    <packaging>pom</packaging>
    <modules>
@@ -29,7 +29,7 @@
        <connection>scm:git:https://github.com/java-diff-utils/java-diff-utils.git</connection>
        <developerConnection>scm:git:ssh://git@github.com:java-diff-utils/java-diff-utils.git</developerConnection>
        <url>https://github.com/java-diff-utils/java-diff-utils.git</url>
-        <tag>java-diff-utils-parent-4.5</tag>
+        <tag>java-diff-utils-parent-4.8</tag>
    </scm>
    <issueManagement>
        <system>GitHub Issues</system>
@@ -60,6 +60,22 @@
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>
+    <dependencyManagement>
+        <dependencies>
+            <dependency>
+                <groupId>org.junit.jupiter</groupId>
+                <artifactId>junit-jupiter</artifactId>
+                <version>5.6.2</version>
+                <scope>test</scope>
+            </dependency>
+            <dependency>
+                <groupId>org.assertj</groupId>
+                <artifactId>assertj-core</artifactId>
+                <version>3.15.0</version>
+                <scope>test</scope>
+            </dependency>
+        </dependencies>
+    </dependencyManagement>
    <build>
        <plugins>
            <plugin>
@@ -89,9 +105,10 @@
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-javadoc-plugin</artifactId>
-                <version>2.10.4</version>
+                <version>3.1.1</version>
                <configuration>
                    <additionalparam>${javadoc.opts}</additionalparam>
+                    <doclint>none</doclint>
                </configuration>
                <executions>
                    <execution>
@@ -105,7 +122,7 @@
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-checkstyle-plugin</artifactId>
-                <version>2.17</version>
+                <version>3.1.0</version>
                <executions>
                    <execution>
                        <id>verify-style</id>
@@ -118,12 +135,13 @@
                <configuration>
                    <logViolationsToConsole>true</logViolationsToConsole>
                    <includeTestSourceDirectory>true</includeTestSourceDirectory>
-                    <sourceDirectory>${project.build.sourceDirectory}</sourceDirectory>
+                    <sourceDirectories>${project.build.sourceDirectory}</sourceDirectories>
                    <checkstyleRules>
                        <module name="Checker">
                            <module name="SuppressWarningsFilter" />
                            <module name="FileTabCharacter" />
                            <module name="TreeWalker">
+                                <module name="SuppressionCommentFilter" />
                                <module name="AvoidNestedBlocks" />
                                <module name="ConstantName" />
                                <module name="EmptyCatchBlock" />
@@ -151,14 +169,14 @@
                    <dependency>
                        <groupId>com.puppycrawl.tools</groupId>
                        <artifactId>checkstyle</artifactId>
-                        <version>8.18</version>
+                        <version>8.29</version>
                    </dependency>
                </dependencies>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
-                <version>2.22.1</version>
+                <version>3.0.0-M4</version>
                <configuration>
                    <excludes>
                        <exclude>**/LR*.java</exclude>
@@ -224,4 +242,4 @@
            </build>
        </profile>
    </profiles>
-</project>
+</project>
Author	SHA1	Message	Date
Tobias Warneke	76ae5f3b6f	[maven-release-plugin] prepare release java-diff-utils-parent-4.8	2020-09-27 22:07:59 +02:00
Tobias Warneke	7d88486bdc		2020-09-27 22:04:44 +02:00
Tobias Warneke	694e93143d		2020-09-27 22:03:18 +02:00
Tobias Warneke	dac751bf73	fixes #98 - deleted file mode	2020-09-27 21:48:59 +02:00
Tobias Warneke	f76abb58f6	improved the documentation of DeltyType a bit fixed #99	2020-09-27 18:13:03 +02:00
Tobias Warneke	de04bd688a		2020-08-09 21:44:28 +02:00
Tobias Warneke	e38cd3a99f		2020-08-09 21:38:16 +02:00
Tobias Warneke	96f7fbdebd	finishes pull request #93	2020-08-04 07:35:09 +02:00
Morten Telling	d3524314eb	Mark no file with /dev/null to align with git diff (#93 ) If you run git diff locally with a staged new file the diff will indicate that the file did not exist before with `--- /dev/null`. I believe this should align with this?	2020-08-04 07:29:55 +02:00
Tobias Warneke	85c3199570	changes jgit version	2020-08-04 07:27:41 +02:00
Tobias Warneke	dbe601c2fc	fixes #83	2020-07-03 23:44:48 +02:00
Tobias Warneke	fc7c714264	Merge origin/master	2020-07-03 22:59:18 +02:00
Tobias Warneke	dcc29eee7e	fixes #84 Seems to be solved by a previous issue. A test case was included from issue 84.	2020-07-03 22:59:04 +02:00
iamhlbx	f0f5d241c7	fixes #89 to get exact add/remove lines'positions (#90 )	2020-07-03 16:58:44 +02:00
iamhlbx	e11c1599ee	update .gitignore to ignore *.iml files (#88 )	2020-07-01 14:25:54 +02:00
Tobias	73c4c307a9	Update CHANGELOG.md	2020-06-21 22:38:11 +02:00
Tobias Warneke	8006986dd8	fixes #85	2020-06-21 02:04:14 +02:00
Tobias Warneke	f292c97dae	fixes #79 open #85	2020-06-21 01:29:57 +02:00
Tobias Warneke	7620f919c2	fixes #80	2020-05-24 22:56:28 +02:00
Tobias Warneke	a8e4ce2eff	fixes #65	2020-05-17 17:16:14 +02:00
Tobias	9bd7aaa0f2	Update README.md	2020-04-23 23:47:42 +02:00
Tobias	80c17a30d9	Update README.md	2020-04-23 23:21:18 +02:00
Tobias Warneke	b5569703c8		2020-04-23 23:18:28 +02:00
Tobias Warneke	47fe8e0ea6	[maven-release-plugin] prepare for next development iteration	2020-04-23 22:19:33 +02:00
Tobias Warneke	ba4bd7ff03	[maven-release-plugin] prepare release java-diff-utils-parent-4.7	2020-04-23 22:19:31 +02:00
Tobias Warneke	ea8d442d28	fixes #75	2020-04-22 22:26:25 +02:00
Tobias Warneke	fbb51d28c7		2020-04-22 22:24:49 +02:00
Tobias Warneke	5781cc5178		2020-04-19 23:51:23 +02:00
Tobias Warneke	37310e1628	working on issue #75	2020-04-18 22:59:50 +02:00
Tobias	ccfc40234a	Update CHANGELOG.md	2020-04-18 22:58:56 +02:00
Tobias Warneke	1e7d96e056	Merge origin/master	2020-04-18 22:32:34 +02:00
Tobias Warneke	f0fc883485	first try of implementing issue #42	2020-04-18 22:31:50 +02:00
Tobias	3bc40a14f3	Merge pull request #76 from sullis/junit-5.6.2 junit 5.6.2	2020-04-12 00:33:26 +02:00
Sean C. Sullivan	29de84cd96	junit 5.6.2	2020-04-10 16:35:57 -07:00
Tobias Warneke	11b3c53d2b	fixes #52 fixes #53	2020-03-08 23:01:13 +01:00
Tobias Warneke	d34591ed13	removed diff exception	2020-03-07 00:36:15 +01:00
Tobias Warneke	89c9f94aef	removed diff exception	2020-03-07 00:31:21 +01:00
Tobias Warneke	9a39411ee8	removed diff exception	2020-03-07 00:27:39 +01:00
Tobias Warneke	ae23408748	fixes #47	2020-02-23 23:51:28 +01:00
Tobias Warneke	923918a53e	fixes #63	2020-02-23 23:16:39 +01:00
Tobias Warneke	21d2cbbcdd	fixes #63	2020-02-23 23:13:39 +01:00
Tobias Warneke	fe6dbe243a	fixes #63	2020-02-23 23:10:06 +01:00
Tobias Warneke	df01ef67e3	fixes #63	2020-02-23 23:07:02 +01:00
Tobias Warneke	dbd0b8f72e	fixes #64	2020-02-20 00:53:35 +01:00
Tobias Warneke	e37a52395a	fixes #66	2020-02-20 00:31:24 +01:00
Tobias Warneke	fb7fca643b	fixes #69	2020-02-19 23:03:34 +01:00
Tobias Warneke	94ffdab46f	included new file diff capability to new unified diff parser	2020-01-04 23:45:25 +01:00
Tobias Warneke	ca0959a0a1	included new file diff capability to new unified diff parser	2020-01-04 01:20:57 +01:00
Tobias Warneke	3b23656260	included new file diff capability to new unified diff parser	2020-01-04 01:18:22 +01:00
Tobias Warneke	39efdd5143	Merge origin/master	2019-12-25 23:36:15 +01:00
Tobias Warneke	7dec3fef40	fixes #47	2019-12-25 23:35:47 +01:00
Ibrahim ali abdelghany	81085d368c	Extract duplicate code into method. (#58 ) * Extract duplicate code into method. * fix conflicts.	2019-11-18 16:29:31 +01:00
Oliver Kopp	15a5f060b3	Fix links in CHANGELOG.md (#61 )	2019-11-18 11:11:53 +01:00
Oliver Kopp	93334b5da7	Update release version in README.md (#62 )	2019-11-18 11:10:41 +01:00
Tobias Warneke	3c6fa5f4fe	[maven-release-plugin] prepare for next development iteration	2019-11-17 22:07:32 +01:00