diff --git a/build.gradle b/build.gradle
index eff760eaba1..05c333f494f 100644
--- a/build.gradle
+++ b/build.gradle
@@ -175,6 +175,10 @@ dependencies {
     checkstyle 'com.puppycrawl.tools:checkstyle:8.8'
 }
 
+jacoco {
+    toolVersion = '0.8.0'
+}
+
 dependencyUpdates {
     outputFormatter = "json"
 }
@@ -227,7 +231,16 @@ dependencyUpdates.resolutionStrategy = {
                 selection.reject("http://dev.mysql.com/downloads/connector/j/ lists the version 5.* as last stable version.")
             }
         }
-
+        withModule("org.jacoco.agent") { ComponentSelection selection ->
+            if (selection.candidate.version.equals("0.8.0")) {
+                selection.reject("As a native plugin we cannot control the actual version of jacoco. This dependency should be hidden.")
+            }
+        }
+        withModule("org.jacoco.ant") { ComponentSelection selection ->
+            if (selection.candidate.version.equals("0.8.0")) {
+                selection.reject("As a native plugin we cannot control the actual version of jacoco. This dependency should be hidden.")
+            }
+        }
     }
 }
 
@@ -391,7 +404,6 @@ afterEvaluate {
     def junitPlatformTest = tasks.junitPlatformTest
 
     jacoco {
-        toolVersion = '0.8.0'
         applyTo(junitPlatformTest)
     }
 
diff --git a/config/IntelliJ Code Style.xml b/config/IntelliJ Code Style.xml
index 6be214756e6..489f44c1a5c 100644
--- a/config/IntelliJ Code Style.xml	
+++ b/config/IntelliJ Code Style.xml	
@@ -31,6 +31,7 @@
     <option name="KEEP_BLANK_LINES_IN_DECLARATIONS" value="1" />
     <option name="KEEP_BLANK_LINES_IN_CODE" value="1" />
     <option name="KEEP_BLANK_LINES_BEFORE_RBRACE" value="0" />
+    <option name="ALIGN_MULTILINE_CHAINED_METHODS" value="true" />
     <arrangement>
       <rules>
         <section>
diff --git a/eclipse.gradle b/eclipse.gradle
index 771789957fb..e4ab6fbc1ae 100644
--- a/eclipse.gradle
+++ b/eclipse.gradle
@@ -154,7 +154,7 @@ tasks.eclipse.doFirst {
         org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration=16
         org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration=16
         org.eclipse.jdt.core.formatter.alignment_for_resources_in_try=88
-        org.eclipse.jdt.core.formatter.alignment_for_selector_in_method_invocation=16
+        org.eclipse.jdt.core.formatter.alignment_for_selector_in_method_invocation=80
         org.eclipse.jdt.core.formatter.alignment_for_superclass_in_type_declaration=16
         org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration=0
         org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration=16
diff --git a/src/main/java/org/jabref/gui/EntryTypeDialog.java b/src/main/java/org/jabref/gui/EntryTypeDialog.java
index 4a8961c937d..30669a5306e 100644
--- a/src/main/java/org/jabref/gui/EntryTypeDialog.java
+++ b/src/main/java/org/jabref/gui/EntryTypeDialog.java
@@ -288,6 +288,7 @@ protected Optional<BibEntry> doInBackground() throws Exception {
                 generateButton.setText(Localization.lang("Searching..."));
             });
             searchID = idTextField.getText().trim();
+            searchID = searchID.replaceAll(" ", "");
             fetcher = WebFetchers.getIdBasedFetchers(Globals.prefs.getImportFormatPreferences()).get(comboBox.getSelectedIndex());
             if (!searchID.isEmpty()) {
                 try {
diff --git a/src/main/java/org/jabref/logic/bibtex/DuplicateCheck.java b/src/main/java/org/jabref/logic/bibtex/DuplicateCheck.java
index 617ab01cf2e..01b54ce0103 100644
--- a/src/main/java/org/jabref/logic/bibtex/DuplicateCheck.java
+++ b/src/main/java/org/jabref/logic/bibtex/DuplicateCheck.java
@@ -22,6 +22,14 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import static org.jabref.model.entry.FieldName.AUTHOR;
+import static org.jabref.model.entry.FieldName.CHAPTER;
+import static org.jabref.model.entry.FieldName.EDITION;
+import static org.jabref.model.entry.FieldName.EDITOR;
+import static org.jabref.model.entry.FieldName.JOURNAL;
+import static org.jabref.model.entry.FieldName.PAGES;
+import static org.jabref.model.entry.FieldName.TITLE;
+
 /**
  * This class contains utility method for duplicate checking of entries.
  */
@@ -48,10 +56,10 @@ public class DuplicateCheck {
     private static final Map<String, Double> FIELD_WEIGHTS = new HashMap<>();
 
     static {
-        DuplicateCheck.FIELD_WEIGHTS.put(FieldName.AUTHOR, 2.5);
-        DuplicateCheck.FIELD_WEIGHTS.put(FieldName.EDITOR, 2.5);
-        DuplicateCheck.FIELD_WEIGHTS.put(FieldName.TITLE, 3.);
-        DuplicateCheck.FIELD_WEIGHTS.put(FieldName.JOURNAL, 2.);
+        DuplicateCheck.FIELD_WEIGHTS.put(AUTHOR, 2.5);
+        DuplicateCheck.FIELD_WEIGHTS.put(EDITOR, 2.5);
+        DuplicateCheck.FIELD_WEIGHTS.put(TITLE, 3.);
+        DuplicateCheck.FIELD_WEIGHTS.put(JOURNAL, 2.);
     }
 
     private DuplicateCheck() {
@@ -64,68 +72,89 @@ private DuplicateCheck() {
      * @param two BibEntry
      * @return boolean
      */
-    public static boolean isDuplicate(BibEntry one, BibEntry two, BibDatabaseMode bibDatabaseMode) {
+    public static boolean isDuplicate(final BibEntry one, final BibEntry two, final BibDatabaseMode bibDatabaseMode) {
         if (haveSameIdentifier(one, two)) {
             return true;
         }
 
-        // same entry type
-        if (!one.getType().equals(two.getType())) {
+        if (haveDifferentEntryType(one, two) ||
+                haveDifferentEditions(one, two) ||
+                haveDifferentChaptersOrPagesOfTheSameBook(one, two)) {
             return false;
         }
 
-        if (haveDifferentEditions(one, two)) {
-            return false;
-        }
+        final EntryType type = EntryTypes.getTypeOrDefault(one.getType(), bibDatabaseMode);
+        final double[] reqCmpResult = compareRequiredFields(type, one, two);
 
-        EntryType type = EntryTypes.getTypeOrDefault(one.getType(), bibDatabaseMode);
-        // The check if they have the same required fields:
-        Collection<String> var = type.getRequiredFieldsFlat();
-        double[] req;
-        if (var == null) {
-            req = new double[]{0., 0.};
-        } else {
-            req = DuplicateCheck.compareFieldSet(var, one, two);
+        if (isFarFromThreshold(reqCmpResult[0])) {
+            // Far from the threshold value, so we base our decision on the required fields only
+            return reqCmpResult[0] >= DuplicateCheck.DUPLICATE_THRESHOLD;
         }
 
-        if (Math.abs(req[0] - DuplicateCheck.DUPLICATE_THRESHOLD) > DuplicateCheck.DOUBT_RANGE) {
-            // Far from the threshold value, so we base our decision on the req. fields only
-            return req[0] >= DuplicateCheck.DUPLICATE_THRESHOLD;
-        }
         // Close to the threshold value, so we take a look at the optional fields, if any:
-        Collection<String> optionalFields = type.getOptionalFields();
-        if (optionalFields != null) {
-            double[] opt = DuplicateCheck.compareFieldSet(optionalFields, one, two);
-            double totValue = ((DuplicateCheck.REQUIRED_WEIGHT * req[0] * req[1]) + (opt[0] * opt[1])) / ((req[1] * DuplicateCheck.REQUIRED_WEIGHT) + opt[1]);
-            return totValue >= DuplicateCheck.DUPLICATE_THRESHOLD;
-        }
-        return req[0] >= DuplicateCheck.DUPLICATE_THRESHOLD;
+        return compareOptionalFields(type, one, two, reqCmpResult);
     }
 
-    private static boolean haveDifferentEditions(BibEntry one, BibEntry two) {
-        if (one.getField(FieldName.EDITION).isPresent() && two.getField(FieldName.EDITION).isPresent()) {
-            if (!one.getField(FieldName.EDITION).get().equals(two.getField(FieldName.EDITION).get())) {
+    private static boolean haveSameIdentifier(final BibEntry one, final BibEntry two) {
+        for (final String name : FieldName.getIdentifierFieldNames()) {
+            if (one.getField(name).isPresent() && one.getField(name).equals(two.getField(name))) {
                 return true;
             }
         }
         return false;
     }
 
-    private static boolean haveSameIdentifier(BibEntry one, BibEntry two) {
-        for (String name : FieldName.getIdentifierFieldNames()) {
-            if (one.getField(name).isPresent() && one.getField(name).equals(two.getField(name))) {
-                return true;
-            }
+    private static boolean haveDifferentEntryType(final BibEntry one, final BibEntry two) {
+        return !one.getType().equals(two.getType());
+    }
+
+    private static boolean haveDifferentEditions(final BibEntry one, final BibEntry two) {
+        final Optional<String> editionOne = one.getField(EDITION);
+        final Optional<String> editionTwo = two.getField(EDITION);
+        return editionOne.isPresent() &&
+                editionTwo.isPresent() &&
+                !editionOne.get().equals(editionTwo.get());
+    }
+
+    private static boolean haveDifferentChaptersOrPagesOfTheSameBook(final BibEntry one, final BibEntry two) {
+        return compareSingleField(AUTHOR, one, two) == EQUAL &&
+                compareSingleField(TITLE, one, two) == EQUAL &&
+                (compareSingleField(CHAPTER, one, two) == NOT_EQUAL ||
+                        compareSingleField(PAGES, one, two) == NOT_EQUAL);
+
+    }
+
+    private static double[] compareRequiredFields(final EntryType type, final BibEntry one, final BibEntry two) {
+        final Collection<String> requiredFields = type.getRequiredFieldsFlat();
+        return requiredFields == null
+                ? new double[]{0., 0.}
+                : DuplicateCheck.compareFieldSet(requiredFields, one, two);
+    }
+
+    private static boolean isFarFromThreshold(double value) {
+        return Math.abs(value - DuplicateCheck.DUPLICATE_THRESHOLD) > DuplicateCheck.DOUBT_RANGE;
+    }
+
+    private static boolean compareOptionalFields(final EntryType type,
+                                                 final BibEntry one,
+                                                 final BibEntry two,
+                                                 final double[] req) {
+        final Collection<String> optionalFields = type.getOptionalFields();
+        if (optionalFields == null) {
+            return req[0] >= DuplicateCheck.DUPLICATE_THRESHOLD;
         }
-        return false;
+        final double[] opt = DuplicateCheck.compareFieldSet(optionalFields, one, two);
+        final double numerator = (DuplicateCheck.REQUIRED_WEIGHT * req[0] * req[1]) + (opt[0] * opt[1]);
+        final double denominator = (req[1] * DuplicateCheck.REQUIRED_WEIGHT) + opt[1];
+        final double totValue = numerator / denominator;
+        return totValue >= DuplicateCheck.DUPLICATE_THRESHOLD;
     }
 
-    private static double[] compareFieldSet(Collection<String> fields, BibEntry one, BibEntry two) {
+    private static double[] compareFieldSet(final Collection<String> fields, final BibEntry one, final BibEntry two) {
         double res = 0;
         double totWeights = 0.;
-        for (String field : fields) {
-            double weight;
-            weight = DuplicateCheck.FIELD_WEIGHTS.getOrDefault(field, 1.0);
+        for (final String field : fields) {
+            final double weight = DuplicateCheck.FIELD_WEIGHTS.getOrDefault(field, 1.0);
             totWeights += weight;
             int result = DuplicateCheck.compareSingleField(field, one, two);
             if (result == EQUAL) {
@@ -140,9 +169,9 @@ private static double[] compareFieldSet(Collection<String> fields, BibEntry one,
         return new double[]{0.5, 0.0};
     }
 
-    private static int compareSingleField(String field, BibEntry one, BibEntry two) {
-        Optional<String> optionalStringOne = one.getField(field);
-        Optional<String> optionalStringTwo = two.getField(field);
+    private static int compareSingleField(final String field, final BibEntry one, final BibEntry two) {
+        final Optional<String> optionalStringOne = one.getField(field);
+        final Optional<String> optionalStringTwo = two.getField(field);
         if (!optionalStringOne.isPresent()) {
             if (!optionalStringTwo.isPresent()) {
                 return EMPTY_IN_BOTH;
@@ -153,68 +182,96 @@ private static int compareSingleField(String field, BibEntry one, BibEntry two)
         }
 
         // Both strings present
-        String stringOne = optionalStringOne.get();
-        String stringTwo = optionalStringTwo.get();
+        final String stringOne = optionalStringOne.get();
+        final String stringTwo = optionalStringTwo.get();
 
         if (InternalBibtexFields.getFieldProperties(field).contains(FieldProperty.PERSON_NAMES)) {
-            // Specific for name fields.
-            // Harmonise case:
-            String authorOne = AuthorList.fixAuthorLastNameOnlyCommas(stringOne, false).replace(" and ", " ").toLowerCase(Locale.ROOT);
-            String authorTwo = AuthorList.fixAuthorLastNameOnlyCommas(stringTwo, false).replace(" and ", " ").toLowerCase(Locale.ROOT);
-            double similarity = DuplicateCheck.correlateByWords(authorOne, authorTwo);
-            if (similarity > 0.8) {
-                return EQUAL;
-            }
-            return NOT_EQUAL;
-        } else if (FieldName.PAGES.equals(field)) {
-            // Pages can be given with a variety of delimiters, "-", "--", " - ", " -- ".
-            // We do a replace to harmonize these to a simple "-":
-            // After this, a simple test for equality should be enough:
-            stringOne = stringOne.replaceAll("[- ]+", "-");
-            stringTwo = stringTwo.replaceAll("[- ]+", "-");
-            if (stringOne.equals(stringTwo)) {
-                return EQUAL;
-            }
-            return NOT_EQUAL;
-        } else if (FieldName.JOURNAL.equals(field)) {
-            // We do not attempt to harmonize abbreviation state of the journal names,
-            // but we remove periods from the names in case they are abbreviated with
-            // and without dots:
-            stringOne = stringOne.replace(".", "").toLowerCase(Locale.ROOT);
-            stringTwo = stringTwo.replace(".", "").toLowerCase(Locale.ROOT);
-            double similarity = DuplicateCheck.correlateByWords(stringOne, stringTwo);
-            if (similarity > 0.8) {
-                return EQUAL;
-            }
-            return NOT_EQUAL;
-        } else {
-            stringOne = stringOne.toLowerCase(Locale.ROOT);
-            stringTwo = stringTwo.toLowerCase(Locale.ROOT);
-            double similarity = DuplicateCheck.correlateByWords(stringOne, stringTwo);
-            if (similarity > 0.8) {
-                return EQUAL;
-            }
-            return NOT_EQUAL;
+            return compareAuthorField(stringOne, stringTwo);
+
+        } else if (PAGES.equals(field)) {
+            return comparePagesField(stringOne, stringTwo);
+
+        } else if (JOURNAL.equals(field)) {
+            return compareJournalField(stringOne, stringTwo);
+
+        } else if (CHAPTER.equals(field)) {
+            return compareChapterField(stringOne, stringTwo);
+        }
+
+        return compareField(stringOne, stringTwo);
+    }
+
+    private static int compareAuthorField(final String stringOne, final String stringTwo) {
+        // Specific for name fields.
+        // Harmonise case:
+        final String authorOne = AuthorList.fixAuthorLastNameOnlyCommas(stringOne, false).replace(" and ", " ").toLowerCase(Locale.ROOT);
+        final String authorTwo = AuthorList.fixAuthorLastNameOnlyCommas(stringTwo, false).replace(" and ", " ").toLowerCase(Locale.ROOT);
+        final double similarity = DuplicateCheck.correlateByWords(authorOne, authorTwo);
+        if (similarity > 0.8) {
+            return EQUAL;
+        }
+        return NOT_EQUAL;
+    }
+
+    /**
+     * Pages can be given with a variety of delimiters, "-", "--", " - ", " -- ".
+     * We do a replace to harmonize these to a simple "-"
+     * After this, a simple test for equality should be enough
+     */
+    private static int comparePagesField(final String stringOne, final String stringTwo) {
+        final String processedStringOne = stringOne.replaceAll("[- ]+", "-");
+        final String processedStringTwo = stringTwo.replaceAll("[- ]+", "-");
+        if (processedStringOne.equals(processedStringTwo)) {
+            return EQUAL;
+        }
+        return NOT_EQUAL;
+    }
+
+    /**
+     * We do not attempt to harmonize abbreviation state of the journal names,
+     * but we remove periods from the names in case they are abbreviated with and without dots:
+     */
+    private static int compareJournalField(final String stringOne, final String stringTwo) {
+        final String processedStringOne = stringOne.replace(".", "").toLowerCase(Locale.ROOT);
+        final String processedStringTwo = stringTwo.replace(".", "").toLowerCase(Locale.ROOT);
+        final double similarity = DuplicateCheck.correlateByWords(processedStringOne, processedStringTwo);
+        if (similarity > 0.8) {
+            return EQUAL;
         }
+        return NOT_EQUAL;
+    }
+
+    private static int compareChapterField(final String stringOne, final String stringTwo) {
+        final String processedStringOne = stringOne.replaceAll("(?i)chapter", "").trim();
+        final String processedStringTwo = stringTwo.replaceAll("(?i)chapter", "").trim();
+        return compareField(processedStringOne, processedStringTwo);
+    }
+
+    private static int compareField(final String stringOne, final String stringTwo) {
+        final String processedStringOne = stringOne.toLowerCase(Locale.ROOT).trim();
+        final String processedStringTwo = stringTwo.toLowerCase(Locale.ROOT).trim();
+        final double similarity = DuplicateCheck.correlateByWords(processedStringOne, processedStringTwo);
+        if (similarity > 0.8) {
+            return EQUAL;
+        }
+        return NOT_EQUAL;
     }
 
     public static double compareEntriesStrictly(BibEntry one, BibEntry two) {
-        Set<String> allFields = new HashSet<>();
+        final Set<String> allFields = new HashSet<>();
         allFields.addAll(one.getFieldNames());
         allFields.addAll(two.getFieldNames());
 
         int score = 0;
-        for (String field : allFields) {
-            Optional<String> stringOne = one.getField(field);
-            Optional<String> stringTwo = two.getField(field);
+        for (final String field : allFields) {
+            final Optional<String> stringOne = one.getField(field);
+            final Optional<String> stringTwo = two.getField(field);
             if (stringOne.equals(stringTwo)) {
                 score++;
             }
         }
         if (score == allFields.size()) {
-            return 1.01; // Just to make sure we can
-            // use score>1 without
-            // trouble.
+            return 1.01; // Just to make sure we can use score > 1 without trouble.
         }
         return (double) score / allFields.size();
     }
@@ -229,8 +286,10 @@ public static double compareEntriesStrictly(BibEntry one, BibEntry two) {
      * @param entry    The entry of which we are looking for duplicates.
      * @return The first duplicate entry found. Empty Optional if no duplicates are found.
      */
-    public static Optional<BibEntry> containsDuplicate(BibDatabase database, BibEntry entry, BibDatabaseMode bibDatabaseMode) {
-        for (BibEntry other : database.getEntries()) {
+    public static Optional<BibEntry> containsDuplicate(final BibDatabase database,
+                                                       final BibEntry entry,
+                                                       final BibDatabaseMode bibDatabaseMode) {
+        for (final BibEntry other : database.getEntries()) {
             if (DuplicateCheck.isDuplicate(entry, other, bibDatabaseMode)) {
                 return Optional.of(other); // Duplicate found.
             }
@@ -245,10 +304,10 @@ public static Optional<BibEntry> containsDuplicate(BibDatabase database, BibEntr
      * @param s2 The second string
      * @return a value in the interval [0, 1] indicating the degree of match.
      */
-    public static double correlateByWords(String s1, String s2) {
-        String[] w1 = s1.split("\\s");
-        String[] w2 = s2.split("\\s");
-        int n = Math.min(w1.length, w2.length);
+    public static double correlateByWords(final String s1, final String s2) {
+        final String[] w1 = s1.split("\\s");
+        final String[] w2 = s2.split("\\s");
+        final int n = Math.min(w1.length, w2.length);
         int misses = 0;
         for (int i = 0; i < n; i++) {
             double corr = similarity(w1[i], w2[i]);
@@ -256,7 +315,7 @@ public static double correlateByWords(String s1, String s2) {
                 misses++;
             }
         }
-        double missRate = (double) misses / (double) n;
+        final double missRate = (double) misses / (double) n;
         return 1 - missRate;
     }
 
@@ -265,22 +324,26 @@ public static double correlateByWords(String s1, String s2) {
      * Calculates the similarity (a number within 0 and 1) between two strings.
      * http://stackoverflow.com/questions/955110/similarity-string-comparison-in-java
      */
-    private static double similarity(String first, String second) {
-        String longer = first;
-        String shorter = second;
+    private static double similarity(final String first, final String second) {
+        final String longer;
+        final String shorter;
 
         if (first.length() < second.length()) {
             longer = second;
             shorter = first;
+        } else {
+            longer = first;
+            shorter = second;
         }
 
-        int longerLength = longer.length();
+        final int longerLength = longer.length();
         // both strings are zero length
         if (longerLength == 0) {
             return 1.0;
         }
-        double sim = (longerLength - new StringSimilarity().editDistanceIgnoreCase(longer, shorter)) / (double) longerLength;
-        LOGGER.debug("Longer string: " + longer + " Shorter string: " + shorter + " Similarity: " + sim);
-        return sim;
+        final double distanceIgnoredCase = new StringSimilarity().editDistanceIgnoreCase(longer, shorter);
+        final double similarity = (longerLength - distanceIgnoredCase) / (double) longerLength;
+        LOGGER.debug("Longer string: " + longer + " Shorter string: " + shorter + " Similarity: " + similarity);
+        return similarity;
     }
 }
diff --git a/src/main/java/org/jabref/logic/bst/BibtexNameFormatter.java b/src/main/java/org/jabref/logic/bst/BibtexNameFormatter.java
index 6afe53acbe0..a8b0e1b61c4 100644
--- a/src/main/java/org/jabref/logic/bst/BibtexNameFormatter.java
+++ b/src/main/java/org/jabref/logic/bst/BibtexNameFormatter.java
@@ -29,6 +29,15 @@ public class BibtexNameFormatter {
     private BibtexNameFormatter() {
     }
 
+    /**
+     * Formats the nth author of the author name list by a given format string
+     *
+     * @param authorsNameList The string from an author field
+     * @param whichName index of the list, starting with 1
+     * @param formatString TODO
+     * @param warn collects the warnings, may-be-null
+     * @return
+     */
     public static String formatName(String authorsNameList, int whichName, String formatString, Warn warn) {
         AuthorList al = AuthorList.parse(authorsNameList);
 
@@ -40,11 +49,7 @@ public static String formatName(String authorsNameList, int whichName, String fo
     }
 
     /**
-     *
-     * @param author
-     * @param format
-     * @param warn may-be-null
-     * @return
+     * @param warn collects the warnings, may-be-null
      */
     public static String formatName(Author author, String format, Warn warn) {
 
diff --git a/src/main/java/org/jabref/logic/importer/fileformat/BibtexParser.java b/src/main/java/org/jabref/logic/importer/fileformat/BibtexParser.java
index 37c71543d3e..c21c37ddc8c 100644
--- a/src/main/java/org/jabref/logic/importer/fileformat/BibtexParser.java
+++ b/src/main/java/org/jabref/logic/importer/fileformat/BibtexParser.java
@@ -78,19 +78,6 @@ public BibtexParser(ImportFormatPreferences importFormatPreferences, FileUpdateM
         metaDataParser = new MetaDataParser(fileMonitor);
     }
 
-    /**
-     * Shortcut usage to create a Parser and read the input.
-     *
-     * @param in the Reader to read from
-     * @param fileMonitor
-     * @throws IOException
-     * @deprecated inline this method
-     */
-    @Deprecated
-    public static ParserResult parse(Reader in, ImportFormatPreferences importFormatPreferences, FileUpdateMonitor fileMonitor) throws IOException {
-        return new BibtexParser(importFormatPreferences, fileMonitor).parse(in);
-    }
-
     /**
      * Parses BibtexEntries from the given string and returns one entry found (or null if none found)
      * <p>
diff --git a/src/main/java/org/jabref/logic/remote/client/RemoteListenerClient.java b/src/main/java/org/jabref/logic/remote/client/RemoteListenerClient.java
index ab319ffcaf0..ce2b24998f3 100644
--- a/src/main/java/org/jabref/logic/remote/client/RemoteListenerClient.java
+++ b/src/main/java/org/jabref/logic/remote/client/RemoteListenerClient.java
@@ -35,8 +35,8 @@ public static boolean sendToActiveJabRefInstance(String[] args, int remoteServer
 
                 if (!Protocol.IDENTIFIER.equals(identifier)) {
                     String port = String.valueOf(remoteServerPort);
-                    String error = Localization.lang("Cannot use port %0 for remote operation; another application may be using it. Try specifying another port.", port);
-                    System.out.println(error);
+                    String errorMessage = Localization.lang("Cannot use port %0 for remote operation; another application may be using it. Try specifying another port.", port);
+                    LOGGER.error(errorMessage);
                     return false;
                 }
                 protocol.sendMessage(String.join("\n", args));
diff --git a/src/main/java/org/jabref/logic/xmp/XMPUtil.java b/src/main/java/org/jabref/logic/xmp/XMPUtil.java
index 73d63a4b1b1..97be1498ec9 100644
--- a/src/main/java/org/jabref/logic/xmp/XMPUtil.java
+++ b/src/main/java/org/jabref/logic/xmp/XMPUtil.java
@@ -1033,7 +1033,7 @@ public static boolean hasMetadata(Path path, XMPPreferences xmpPreferences) {
         try (InputStream inputStream = Files.newInputStream(path, StandardOpenOption.READ)) {
             return hasMetadata(inputStream, xmpPreferences);
         } catch (IOException e) {
-            LOGGER.error("XMP reading failed", e);
+            // happens if no metadata is found, no reason to log the exception
             return false;
         }
     }
@@ -1056,7 +1056,7 @@ public static boolean hasMetadata(InputStream inputStream, XMPPreferences xmpPre
             LOGGER.info("Encryption not supported by XMPUtil");
             return false;
         } catch (IOException e) {
-            LOGGER.error("XMP reading failed", e);
+            // happens if no metadata is found, no reason to log the exception
             return false;
         }
     }
diff --git a/src/main/java/org/jabref/model/search/matchers/AndMatcher.java b/src/main/java/org/jabref/model/search/matchers/AndMatcher.java
index c39b3c36ffc..81839607ad0 100644
--- a/src/main/java/org/jabref/model/search/matchers/AndMatcher.java
+++ b/src/main/java/org/jabref/model/search/matchers/AndMatcher.java
@@ -1,26 +1,15 @@
 package org.jabref.model.search.matchers;
 
 import org.jabref.model.entry.BibEntry;
-import org.jabref.model.search.SearchMatcher;
 
 /**
- * Subclass of MatcherSet that ANDs or ORs between its rules, returning 0 or
- * 1.
+ * A set of matchers that returns true if all matcher match the given entry.
  */
 public class AndMatcher extends MatcherSet {
 
     @Override
-    public boolean isMatch(BibEntry bibEntry) {
-        int score = 0;
-
-        // We let each rule add a maximum of 1 to the score.
-        for (SearchMatcher rule : matchers) {
-            if (rule.isMatch(bibEntry)) {
-                score++;
-            }
-        }
-
-        // Then an AND rule demands that score == number of rules
-        return score == matchers.size();
+    public boolean isMatch(BibEntry entry) {
+        return matchers.stream()
+                       .allMatch(rule -> rule.isMatch(entry));
     }
 }
diff --git a/src/main/java/org/jabref/model/search/matchers/OrMatcher.java b/src/main/java/org/jabref/model/search/matchers/OrMatcher.java
index ffd2ebf1e28..c0a0eddf1d9 100644
--- a/src/main/java/org/jabref/model/search/matchers/OrMatcher.java
+++ b/src/main/java/org/jabref/model/search/matchers/OrMatcher.java
@@ -1,26 +1,15 @@
 package org.jabref.model.search.matchers;
 
 import org.jabref.model.entry.BibEntry;
-import org.jabref.model.search.SearchMatcher;
 
 /**
- * Subclass of MatcherSet that ANDs or ORs between its rules, returning 0 or
- * 1.
+ * A set of matchers that returns true if any matcher matches the given entry.
  */
 public class OrMatcher extends MatcherSet {
 
     @Override
-    public boolean isMatch(BibEntry bibEntry) {
-        int score = 0;
-
-        // We let each rule add a maximum of 1 to the score.
-        for (SearchMatcher rule : matchers) {
-            if (rule.isMatch(bibEntry)) {
-                score++;
-            }
-        }
-
-        // OR rule demands score > 0.
-        return score > 0;
+    public boolean isMatch(BibEntry entry) {
+        return matchers.stream()
+                       .anyMatch(rule -> rule.isMatch(entry));
     }
 }
diff --git a/src/test/java/org/jabref/logic/bibtex/DuplicateCheckTest.java b/src/test/java/org/jabref/logic/bibtex/DuplicateCheckTest.java
index ab802782ddf..c0a54568f82 100644
--- a/src/test/java/org/jabref/logic/bibtex/DuplicateCheckTest.java
+++ b/src/test/java/org/jabref/logic/bibtex/DuplicateCheckTest.java
@@ -16,6 +16,8 @@ public class DuplicateCheckTest {
 
     private BibEntry simpleArticle;
     private BibEntry unrelatedArticle;
+    private BibEntry simpleInbook;
+    private BibEntry simpleIncollection;
 
     @Before
     public void setUp() {
@@ -27,6 +29,19 @@ public void setUp() {
                 .withField(FieldName.AUTHOR, "Completely Different")
                 .withField(FieldName.TITLE, "Holy Moly Uffdada und Trallalla")
                 .withField(FieldName.YEAR, "1992");
+        simpleInbook = new BibEntry(BibtexEntryTypes.INBOOK.getName())
+                .withField(FieldName.TITLE, "Alice in Wonderland")
+                .withField(FieldName.AUTHOR, "Charles Lutwidge Dodgson")
+                .withField(FieldName.CHAPTER, "Chapter One – Down the Rabbit Hole")
+                .withField(FieldName.LANGUAGE, "English")
+                .withField(FieldName.PUBLISHER, "Macmillan")
+                .withField(FieldName.YEAR, "1865");
+        simpleIncollection = new BibEntry(BibtexEntryTypes.INCOLLECTION.getName())
+                .withField(FieldName.TITLE, "Innovation and Intellectual Property Rights")
+                .withField(FieldName.AUTHOR, "Ove Grandstrand")
+                .withField(FieldName.BOOKTITLE, "The Oxford Handbook of Innovation")
+                .withField(FieldName.PUBLISHER, "Oxford University Press")
+                .withField(FieldName.YEAR, "2004");
     }
 
     @Test
@@ -142,6 +157,51 @@ public void twoEntriesWithSameDoiButDifferentTypesAreDuplicates() {
         assertTrue(DuplicateCheck.isDuplicate(simpleArticle, duplicateWithDifferentType, BibDatabaseMode.BIBTEX));
     }
 
+    @Test
+    public void twoInbooksWithDifferentChaptersAreNotDuplicates() {
+        twoEntriesWithDifferentSpecificFieldsAreNotDuplicates(simpleInbook, FieldName.CHAPTER,
+                "Chapter One – Down the Rabbit Hole",
+                "Chapter Two – The Pool of Tears");
+    }
+
+    @Test
+    public void twoInbooksWithDifferentPagesAreNotDuplicates() {
+        twoEntriesWithDifferentSpecificFieldsAreNotDuplicates(simpleInbook, FieldName.PAGES, "1-20", "21-40");
+    }
+
+    @Test
+    public void twoIncollectionsWithDifferentChaptersAreNotDuplicates() {
+        twoEntriesWithDifferentSpecificFieldsAreNotDuplicates(simpleIncollection, FieldName.CHAPTER, "10", "9");
+    }
+
+    @Test
+    public void twoIncollectionsWithDifferentPagesAreNotDuplicates() {
+        twoEntriesWithDifferentSpecificFieldsAreNotDuplicates(simpleIncollection, FieldName.PAGES, "1-20", "21-40");
+    }
+
+    private void twoEntriesWithDifferentSpecificFieldsAreNotDuplicates(final BibEntry cloneable,
+                                                                       final String fieldType,
+                                                                       final String firstValue,
+                                                                       final String secondValue) {
+        final BibEntry entry1 = (BibEntry) cloneable.clone();
+        entry1.setField(fieldType, firstValue);
+
+        final BibEntry entry2 = (BibEntry) cloneable.clone();
+        entry2.setField(fieldType, secondValue);
+
+        assertFalse(DuplicateCheck.isDuplicate(entry1, entry2, BibDatabaseMode.BIBTEX));
+    }
+
+    @Test
+    public void inbookWithoutChapterCouldBeDuplicateOfInbookWithChapter() {
+        final BibEntry inbook1 = (BibEntry) simpleInbook.clone();
+        final BibEntry inbook2 = (BibEntry) simpleInbook.clone();
+        inbook2.setField(FieldName.CHAPTER, "");
+
+        assertTrue(DuplicateCheck.isDuplicate(inbook1, inbook2, BibDatabaseMode.BIBTEX));
+        assertTrue(DuplicateCheck.isDuplicate(inbook2, inbook1, BibDatabaseMode.BIBTEX));
+    }
+
     @Test
     public void twoBooksWithDifferentEditionsAreNotDuplicates() {
         BibEntry editionOne = new BibEntry(BibtexEntryTypes.BOOK.getName());
diff --git a/src/test/java/org/jabref/logic/importer/fileformat/BibtexParserTest.java b/src/test/java/org/jabref/logic/importer/fileformat/BibtexParserTest.java
index b346f548901..b963f63c4de 100644
--- a/src/test/java/org/jabref/logic/importer/fileformat/BibtexParserTest.java
+++ b/src/test/java/org/jabref/logic/importer/fileformat/BibtexParserTest.java
@@ -280,7 +280,7 @@ public void parseRecognizesEntryInParenthesis() throws IOException {
     @Test
     public void parseRecognizesEntryWithBigNumbers() throws IOException {
         ParserResult result = parser.parse(new StringReader("@article{canh05," + "isbn = 1234567890123456789,\n"
-                + "isbn2 = {1234567890123456789},\n" + "small = 1234,\n" + "}"), importFormatPreferences, fileMonitor);
+                + "isbn2 = {1234567890123456789},\n" + "small = 1234,\n" + "}"));
 
         Collection<BibEntry> parsed = result.getDatabase().getEntries();
         BibEntry entry = parsed.iterator().next();
@@ -367,10 +367,9 @@ public void parseRecognizesMultipleEntries() throws IOException {
         secondEntry.setField("author", "Norton Bar");
         expected.add(secondEntry);
 
-        ParserResult result = BibtexParser.parse(
+        ParserResult result = parser.parse(
                 new StringReader("@article{canh05," + "  author = {Crowston, K. and Annabi, H.},\n"
-                        + "  title = {Title A}}\n" + "@inProceedings{foo," + "  author={Norton Bar}}"),
-                importFormatPreferences, fileMonitor);
+                        + "  title = {Title A}}\n" + "@inProceedings{foo," + "  author={Norton Bar}}"));
         List<BibEntry> parsed = result.getDatabase().getEntries();
 
         assertEquals(expected, parsed);
@@ -467,8 +466,7 @@ public void parseRecognizesHeaderButIgnoresEncoding() throws IOException {
                 + "  title = {Effective work practices for floss development: A model and propositions}," + "\n"
                 + "  booktitle = {Hawaii International Conference On System Sciences (HICSS)}," + "\n"
                 + "  year = {2005}," + "\n" + "  owner = {oezbek}," + "\n" + "  timestamp = {2006.05.29}," + "\n"
-                + "  url = {http://james.howison.name/publications.html}" + "\n" + "}))"),
-                importFormatPreferences, fileMonitor);
+                + "  url = {http://james.howison.name/publications.html}" + "\n" + "}))"));
 
         Collection<BibEntry> parsed = result.getDatabase().getEntries();
         BibEntry entry = parsed.iterator().next();
@@ -497,8 +495,7 @@ public void parseRecognizesFormatedEntry() throws IOException {
                         + "  title = {Effective work practices for floss development: A model and propositions}," + "\n"
                         + "  booktitle = {Hawaii International Conference On System Sciences (HICSS)}," + "\n"
                         + "  year = {2005}," + "\n" + "  owner = {oezbek}," + "\n" + "  timestamp = {2006.05.29},"
-                        + "\n" + "  url = {http://james.howison.name/publications.html}" + "\n" + "}))"),
-                importFormatPreferences, fileMonitor);
+                        + "\n" + "  url = {http://james.howison.name/publications.html}" + "\n" + "}))"));
 
         Collection<BibEntry> parsed = result.getDatabase().getEntries();
         BibEntry entry = parsed.iterator().next();
@@ -600,8 +597,7 @@ public void parseReturnsEmptyListIfNoEntryRecognized() throws IOException {
                         + "  title = {Effective work practices for floss development: A model and propositions}," + "\n"
                         + "  booktitle = {Hawaii International Conference On System Sciences (HICSS)}," + "\n"
                         + "  year = {2005}," + "\n" + "  owner = {oezbek}," + "\n" + "  timestamp = {2006.05.29},"
-                        + "\n" + "  url = {http://james.howison.name/publications.html}" + "\n" + "}))"),
-                importFormatPreferences, fileMonitor);
+                        + "\n" + "  url = {http://james.howison.name/publications.html}" + "\n" + "}))"));
 
         Collection<BibEntry> parsed = result.getDatabase().getEntries();
 
@@ -622,8 +618,7 @@ public void parseReturnsEmptyListIfNoEntryExistent() throws IOException {
     public void parseRecognizesDuplicateBibtexKeys() throws IOException {
         ParserResult result = parser
                 .parse(new StringReader("@article{canh05," + "  author = {Crowston, K. and Annabi, H.},\n"
-                        + "  title = {Title A}}\n" + "@inProceedings{canh05," + "  author={Norton Bar}}"),
-                        importFormatPreferences, fileMonitor);
+                        + "  title = {Title A}}\n" + "@inProceedings{canh05," + "  author={Norton Bar}}"));
 
         List<String> duplicateKeys = result.getDuplicateKeys();
 
@@ -710,8 +705,7 @@ public void parseIgnoresArbitraryContentAfterEntry() throws IOException {
 
     @Test
     public void parseWarnsAboutUnmatchedContentInEntryWithoutComma() throws IOException {
-        ParserResult result = parser.parse(new StringReader("@article{test,author={author bracket } too much}"),
-                importFormatPreferences, fileMonitor);
+        ParserResult result = parser.parse(new StringReader("@article{test,author={author bracket } too much}"));
 
         List<BibEntry> entries = result.getDatabase().getEntries();
 
@@ -720,8 +714,7 @@ public void parseWarnsAboutUnmatchedContentInEntryWithoutComma() throws IOExcept
 
     @Test
     public void parseWarnsAboutUnmatchedContentInEntry() throws IOException {
-        ParserResult result = parser.parse(new StringReader("@article{test,author={author bracket }, too much}"),
-                importFormatPreferences, fileMonitor);
+        ParserResult result = parser.parse(new StringReader("@article{test,author={author bracket }, too much}"));
 
         List<BibEntry> entries = result.getDatabase().getEntries();
 
@@ -801,8 +794,7 @@ public void parseIgnoresAndWarnsAboutEntryWithFieldsThatAreNotSeperatedByComma()
     public void parseIgnoresAndWarnsAboutCorruptedEntryButRecognizeOthers() throws IOException {
         ParserResult result = parser.parse(
                 new StringReader(
-                        "@article{test,author={author missing bracket}" + "@article{test,author={Ed von Test}}"),
-                importFormatPreferences, fileMonitor);
+                        "@article{test,author={author missing bracket}" + "@article{test,author={Ed von Test}}"));
 
         Collection<BibEntry> parsed = result.getDatabase().getEntries();
         BibEntry entry = parsed.iterator().next();
@@ -943,12 +935,11 @@ public void parseRecognizesMultipleStrings() throws IOException {
 
     @Test
     public void parseRecognizesStringAndEntry() throws IOException {
-        ParserResult result = BibtexParser.parse(
+        ParserResult result = parser.parse(
                 new StringReader("" + "@string{bourdieu = {Bourdieu, Pierre}}"
                         + "@book{bourdieu-2002-questions-sociologie, " + "	Address = {Paris}," + "	Author = bourdieu,"
                         + "	Isbn = 2707318256," + "	Publisher = {Minuit}," + "	Title = {Questions de sociologie},"
-                        + "	Year = 2002" + "}"),
-                importFormatPreferences, fileMonitor);
+                        + "	Year = 2002" + "}"));
 
 
         BibtexString parsedString = result.getDatabase().getStringValues().iterator().next();
@@ -1120,8 +1111,9 @@ public void parseConvertsMultipleTabsToSpace() throws IOException {
     public void parsePreservesMultipleSpacesInNonWrappableField() throws IOException {
         when(importFormatPreferences.getFieldContentParserPreferences().getNonWrappableFields())
                 .thenReturn(Collections.singletonList("file"));
-        ParserResult result = BibtexParser
-                .parse(new StringReader("@article{canh05,file = {ups  sala}}"), importFormatPreferences, fileMonitor);
+        BibtexParser parser = new BibtexParser(importFormatPreferences, fileMonitor);
+        ParserResult result = parser
+                .parse(new StringReader("@article{canh05,file = {ups  sala}}"));
 
         Collection<BibEntry> parsedEntries = result.getDatabase().getEntries();
         BibEntry parsedEntry = parsedEntries.iterator().next();
@@ -1131,8 +1123,7 @@ public void parsePreservesMultipleSpacesInNonWrappableField() throws IOException
 
     @Test
     public void parsePreservesTabsInAbstractField() throws IOException {
-        ParserResult result = parser.parse(new StringReader("@article{canh05,abstract = {ups  \tsala}}"),
-                importFormatPreferences, fileMonitor);
+        ParserResult result = parser.parse(new StringReader("@article{canh05,abstract = {ups  \tsala}}"));
 
         Collection<BibEntry> parsedEntries = result.getDatabase().getEntries();
         BibEntry parsedEntry = parsedEntries.iterator().next();
@@ -1142,8 +1133,7 @@ public void parsePreservesTabsInAbstractField() throws IOException {
 
     @Test
     public void parsePreservesNewlineInAbstractField() throws IOException {
-        ParserResult result = parser.parse(new StringReader("@article{canh05,abstract = {ups \nsala}}"),
-                importFormatPreferences, fileMonitor);
+        ParserResult result = parser.parse(new StringReader("@article{canh05,abstract = {ups \nsala}}"));
 
         Collection<BibEntry> parsedEntries = result.getDatabase().getEntries();
         BibEntry parsedEntry = parsedEntries.iterator().next();
@@ -1351,10 +1341,9 @@ public void integrationTestCustomEntryType() throws IOException {
 
     @Test
     public void integrationTestSaveOrderConfig() throws IOException {
-        ParserResult result = BibtexParser.parse(
+        ParserResult result = parser.parse(
                 new StringReader(
-                        "@Comment{jabref-meta: saveOrderConfig:specified;author;false;year;true;abstract;false;}"),
-                importFormatPreferences, fileMonitor);
+                        "@Comment{jabref-meta: saveOrderConfig:specified;author;false;year;true;abstract;false;}"));
 
         Optional<SaveOrderConfig> saveOrderConfig = result.getMetaData().getSaveOrderConfig();
 
@@ -1367,7 +1356,7 @@ public void integrationTestSaveOrderConfig() throws IOException {
     public void integrationTestCustomKeyPattern() throws IOException {
         ParserResult result = parser
                 .parse(new StringReader("@comment{jabref-meta: keypattern_article:articleTest;}" + OS.NEWLINE
-                        + "@comment{jabref-meta: keypatterndefault:test;}"), importFormatPreferences, fileMonitor);
+                        + "@comment{jabref-meta: keypatterndefault:test;}"));
 
         GlobalBibtexKeyPattern pattern = mock(GlobalBibtexKeyPattern.class);
         AbstractBibtexKeyPattern bibtexKeyPattern = result.getMetaData().getCiteKeyPattern(pattern);
@@ -1394,7 +1383,7 @@ public void integrationTestGroupTree() throws IOException, ParseException {
                 + "@comment{jabref-meta: groupstree:" + OS.NEWLINE + "0 AllEntriesGroup:;" + OS.NEWLINE
                 + "1 KeywordGroup:Fréchet\\;0\\;keywords\\;FrechetSpace\\;0\\;1\\;;" + OS.NEWLINE
                 + "1 KeywordGroup:Invariant theory\\;0\\;keywords\\;GIT\\;0\\;0\\;;" + OS.NEWLINE
-                + "1 ExplicitGroup:TestGroup\\;0\\;Key1\\;Key2\\;;" + "}"), importFormatPreferences, fileMonitor);
+                + "1 ExplicitGroup:TestGroup\\;0\\;Key1\\;Key2\\;;" + "}"));
 
         GroupTreeNode root = result.getMetaData().getGroups().get();
 
@@ -1421,7 +1410,7 @@ public void integrationTestProtectedFlag() throws IOException {
     @Test
     public void integrationTestContentSelectors() throws IOException {
         ParserResult result = parser.parse(
-                new StringReader("@Comment{jabref-meta: selector_status:approved;captured;received;status;}"), importFormatPreferences, fileMonitor);
+                new StringReader("@Comment{jabref-meta: selector_status:approved;captured;received;status;}"));
 
         List<String> values = new ArrayList(4);
         values.add("approved");
@@ -1495,8 +1484,7 @@ public void parseDoesNotRecognizeDatabaseIDasUserComment() throws Exception {
     public void integrationTestFileDirectories() throws IOException {
         ParserResult result = parser.parse(
                 new StringReader("@comment{jabref-meta: fileDirectory:\\\\Literature\\\\;}"
-                        + "@comment{jabref-meta: fileDirectory-defaultOwner-user:D:\\\\Documents;}"),
-                importFormatPreferences, fileMonitor);
+                        + "@comment{jabref-meta: fileDirectory-defaultOwner-user:D:\\\\Documents;}"));
 
         assertEquals("\\Literature\\", result.getMetaData().getDefaultFileDirectory().get());
         assertEquals("D:\\Documents", result.getMetaData().getUserFileDirectory("defaultOwner-user").get());
diff --git a/src/test/java/org/jabref/logic/xmp/XMPUtilTest.java b/src/test/java/org/jabref/logic/xmp/XMPUtilTest.java
index d8d60c5e671..3d934e5741f 100644
--- a/src/test/java/org/jabref/logic/xmp/XMPUtilTest.java
+++ b/src/test/java/org/jabref/logic/xmp/XMPUtilTest.java
@@ -79,9 +79,10 @@ public class XMPUtilTest {
 
     private XMPPreferences xmpPreferences;
 
-
     private ImportFormatPreferences importFormatPreferences;
 
+    private BibtexParser parser;
+
     /**
      * Wrap bibtex-data (<bibtex:author>...) into an rdf:Description.
      *
@@ -248,6 +249,8 @@ public void setUp() throws IOException, COSVisitorException {
         when(xmpPreferences.isUseXMPPrivacyFilter()).thenReturn(false);
 
         when(xmpPreferences.getKeywordSeparator()).thenReturn(',');
+
+        parser = new BibtexParser(importFormatPreferences, fileMonitor);
     }
 
     /**
@@ -446,13 +449,12 @@ public void testWriteReadManually() throws COSVisitorException, IOException {
      */
     @Test
     public void testReadWriteXMP() throws IOException, TransformerException {
-        ParserResult result = BibtexParser.parse(new StringReader(
+        ParserResult result = parser.parse(new StringReader(
                 "@article{canh05," + "  author = {Crowston, K. and Annabi, H. and Howison, J. and Masango, C.}," + "\n"
                         + "  title = {Effective work practices for floss development: A model and propositions}," + "\n"
                         + "  booktitle = {Hawaii International Conference On System Sciences (HICSS)}," + "\n"
                         + "  year = {2005}," + "\n" + "  owner = {oezbek}," + "\n" + "  timestamp = {2006.05.29},"
-                        + "\n" + "  url = {http://james.howison.name/publications.html}" + "\n" + "}"),
-                importFormatPreferences, fileMonitor);
+                        + "\n" + "  url = {http://james.howison.name/publications.html}" + "\n" + "}"));
 
         Collection<BibEntry> c = result.getDatabase().getEntries();
         Assert.assertEquals(1, c.size());
@@ -724,13 +726,12 @@ public void testSimpleUpdate() throws Exception {
      */
     @Test
     public void testXMLEscape() throws Exception {
-        ParserResult result = BibtexParser.parse(new StringReader(
+        ParserResult result = parser.parse(new StringReader(
                 "@article{canh05," + "  author = {Crowston, K. and Annabi, H. and Howison, J. and Masango, C.}," + "\n"
                         + "  title = {</bibtex:title> \" bla \" '' '' && &  for floss development: A model and propositions},"
                         + "\n" + "  booktitle = {<randomXML>}," + "\n" + "  year = {2005}," + "\n"
                         + "  owner = {oezbek}," + "\n" + "  timestamp = {2006.05.29}," + "\n"
-                        + "  url = {http://james.howison.name/publications.html}" + "\n" + "}"),
-                importFormatPreferences, fileMonitor);
+                        + "  url = {http://james.howison.name/publications.html}" + "\n" + "}"));
 
         Collection<BibEntry> c = result.getDatabase().getEntries();
         Assert.assertEquals(1, c.size());
@@ -774,10 +775,9 @@ public void assertEqualsBibtexEntry(BibEntry expected, BibEntry actual) {
     @Test
     public void testXMPreadString() throws Exception {
 
-        ParserResult result = BibtexParser
+        ParserResult result = parser
                 .parse(new StringReader("@article{canh05," + "  author = {Crowston, K. and Annabi, H.},\n"
-                        + "  title = {Title A}}\n" + "@inProceedings{foo," + "  author={Norton Bar}}"),
-                        importFormatPreferences, fileMonitor);
+                        + "  title = {Title A}}\n" + "@inProceedings{foo," + "  author={Norton Bar}}"));
 
         Collection<BibEntry> c = result.getDatabase().getEntries();
         Assert.assertEquals(2, c.size());
@@ -1045,13 +1045,12 @@ public void testWriteSingleUpdatesDCAndInfo() throws IOException, TransformerExc
     @Test
     public void testReadRawXMP() throws IOException, TransformerException {
 
-        ParserResult result = BibtexParser.parse(new StringReader(
+        ParserResult result = parser.parse(new StringReader(
                 "@article{canh05," + "  author = {Crowston, K. and Annabi, H. and Howison, J. and Masango, C.},\n"
                         + "  title = {Effective work practices for floss development: A model and propositions},\n"
                         + "  booktitle = {Hawaii International Conference On System Sciences (HICSS)},\n"
                         + "  year = {2005},\n" + "  owner = {oezbek},\n" + "  timestamp = {2006.05.29},\n"
-                        + "  url = {http://james.howison.name/publications.html}}"),
-                importFormatPreferences, fileMonitor);
+                        + "  url = {http://james.howison.name/publications.html}}"));
 
         Collection<BibEntry> c = result.getDatabase().getEntries();
         Assert.assertEquals(1, c.size());
@@ -1285,15 +1284,14 @@ public void testCommandLineSeveral() throws IOException, TransformerException {
      */
     @Test
     public void testResolveStrings() throws IOException, TransformerException {
-        ParserResult original = BibtexParser
+        ParserResult original = parser
                 .parse(new StringReader("@string{ crow = \"Crowston, K.\"}\n" + "@string{ anna = \"Annabi, H.\"}\n"
                         + "@string{ howi = \"Howison, J.\"}\n" + "@string{ masa = \"Masango, C.\"}\n"
                         + "@article{canh05," + "  author = {#crow# and #anna# and #howi# and #masa#}," + "\n"
                         + "  title = {Effective work practices for floss development: A model and propositions}," + "\n"
                         + "  booktitle = {Hawaii International Conference On System Sciences (HICSS)}," + "\n"
                         + "  year = {2005}," + "\n" + "  owner = {oezbek}," + "\n" + "  timestamp = {2006.05.29},"
-                        + "\n" + "  url = {http://james.howison.name/publications.html}" + "\n" + "}"),
-                        importFormatPreferences, fileMonitor);
+                        + "\n" + "  url = {http://james.howison.name/publications.html}" + "\n" + "}"));
 
         Collection<BibEntry> c = original.getDatabase().getEntries();
         Assert.assertEquals(1, c.size());
diff --git a/src/test/resources/log4j2.xml b/src/test/resources/log4j2.xml
index c447f41c6cc..8c6a336420a 100644
--- a/src/test/resources/log4j2.xml
+++ b/src/test/resources/log4j2.xml
@@ -2,7 +2,7 @@
 <Configuration status="INFO" packages="org.jabref">
     <Appenders>
         <Console name="CONSOLE" target="SYSTEM_OUT">
-            <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
+            <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg - %ex{5} %n"/>
         </Console>
     </Appenders>
     <Loggers>