* The values will be quoted if needed. Quotes and newLine characters will be escaped. This method adds the record @@ -248,15 +323,19 @@ public void println() throws IOException { * @throws IOException * If an I/O error occurs */ + @SuppressWarnings("resource") public void printRecord(final Iterable values) throws IOException { - for (final Object value : values) { - print(value); + lock.lock(); + try { + IOStream.of(values).forEachOrdered(this::print); + endOfRecord(); + } finally { + lock.unlock(); } - println(); } /** - * Prints the given values a single record of delimiter separated values followed by the record separator. + * Prints the given values as a single record of delimiter-separated values followed by the record separator. * *

* The values will be quoted if needed. Quotes and newLine characters will be escaped. This method adds the record @@ -269,16 +348,55 @@ public void printRecord(final Iterable values) throws IOException { * If an I/O error occurs */ public void printRecord(final Object... values) throws IOException { - format.printRecord(out, values); - newRecord = true; + printRecord(Arrays.asList(values)); } /** - * Prints all the objects in the given collection handling nested collections/arrays as records. + * Prints the given values as a single record of delimiter-separated values followed by the record separator. * *

- * If the given collection only contains simple objects, this method will print a single record like - * {@link #printRecord(Iterable)}. If the given collections contains nested collections/arrays those nested elements + * The values will be quoted if needed. Quotes and newLine characters will be escaped. This method adds the record + * separator to the output after printing the record, so there is no need to call {@link #println()}. + *

+ * If the given Iterable only contains simple objects, this method will print a single record like + * {@link #printRecord(Iterable)}. If the given Iterable contains nested collections/arrays those nested elements * will each be printed as records using {@link #printRecord(Object...)}. *

-     * 
-     * List<String[]> data = ...
+     * 
{@code
+     * List data = new ArrayList<>();
      * data.add(new String[]{ "A", "B", "C" });
      * data.add(new String[]{ "1", "2", "3" });
      * data.add(new String[]{ "A1", "B2", "C3" });
-     * 
+     * }
      * 
      *
      * 

@@ -300,11 +417,11 @@ public void printRecord(final Object... values) throws IOException {
      * 
      *
      * 
-     * 
+     * {@code
      * A, B, C
      * 1, 2, 3
      * A1, B2, C3
-     * 
+     * }
      * 
      *
      * @param values
@@ -312,16 +429,9 @@ public void printRecord(final Object... values) throws IOException {
      * @throws IOException
      *             If an I/O error occurs
      */
+    @SuppressWarnings("resource")
     public void printRecords(final Iterable values) throws IOException {
-        for (final Object value : values) {
-            if (value instanceof Object[]) {
-                this.printRecord((Object[]) value);
-            } else if (value instanceof Iterable) {
-                this.printRecord((Iterable) value);
-            } else {
-                this.printRecord(value);
-            }
-        }
+        printRecords(IOStream.of(values));
     }
 
     /**
@@ -329,7 +439,7 @@ public void printRecords(final Iterable values) throws IOException {
      *
      * 

      * If the given array only contains simple objects, this method will print a single record like
-     * {@link #printRecord(Object...)}. If the given collections contains nested collections/arrays those nested
+     * {@link #printRecord(Object...)}. If the given collections contain nested collections or arrays, those nested
      * elements will each be printed as records using {@link #printRecord(Object...)}.
      * 
      *
@@ -337,25 +447,23 @@ public void printRecords(final Iterable values) throws IOException {
      * Given the following data structure:
      * 

      *
-     * 
-     * 
+     * 
{@code
      * String[][] data = new String[3][]
      * data[0] = String[]{ "A", "B", "C" };
      * data[1] = new String[]{ "1", "2", "3" };
      * data[2] = new String[]{ "A1", "B2", "C3" };
-     * 
+     * }
      * 
      *
      * 

      * Calling this method will print:
      * 
      *
-     * 
-     * 
+     * 
{@code
      * A, B, C
      * 1, 2, 3
      * A1, B2, C3
-     * 
+     * }
      * 
      *
      * @param values
@@ -369,23 +477,103 @@ public void printRecords(final Object... values) throws IOException {
 
     /**
      * Prints all the objects in the given JDBC result set.
+     * 

+     * You can use {@link CSVFormat.Builder#setMaxRows(long)} to limit how many rows a result set produces. This is most useful when you cannot limit rows
+     * through {@link Statement#setLargeMaxRows(long)} or {@link Statement#setMaxRows(int)}.
+     * 
      *
-     * @param resultSet
-     *            result set the values to print.
-     * @throws IOException
-     *             If an I/O error occurs
-     * @throws SQLException
-     *             if a database access error occurs
+     * @param resultSet The values to print.
+     * @throws IOException  If an I/O error occurs.
+     * @throws SQLException Thrown when a database access error occurs.
      */
     public void printRecords(final ResultSet resultSet) throws SQLException, IOException {
         final int columnCount = resultSet.getMetaData().getColumnCount();
-        while (resultSet.next()) {
-            for (int i = 1; i <= columnCount; i++) {
-                final Object object = resultSet.getObject(i);
-                // TODO Who manages the Clob? The JDBC driver or must we close it? Is it driver-dependent?
-                print(object instanceof Clob ? ((Clob) object).getCharacterStream() : object);
+        while (resultSet.next() && format.useRow(resultSet.getRow())) {
+            lock.lock();
+            try {
+                for (int i = 1; i <= columnCount; i++) {
+                    final Object object = resultSet.getObject(i);
+                    if (object instanceof Clob) {
+                        try (Reader reader = ((Clob) object).getCharacterStream()) {
+                            print(reader);
+                        }
+                    } else if (object instanceof Blob) {
+                        try (InputStream inputStream = ((Blob) object).getBinaryStream()) {
+                            print(inputStream);
+                        }
+                    } else {
+                        print(object);
+                    }
+                }
+                endOfRecord();
+            } finally {
+                lock.unlock();
             }
-            println();
         }
     }
+
+    /**
+     * Prints all the objects with metadata in the given JDBC result set based on the header boolean.
+     * 

+     * You can use {@link CSVFormat.Builder#setMaxRows(long)} to limit how many rows a result set produces. This is most useful when you cannot limit rows
+     * through {@link Statement#setLargeMaxRows(long)} or {@link Statement#setMaxRows(int)}.
+     * 
+     *
+     * @param resultSet source of row data.
+     * @param printHeader whether to print headers.
+     * @throws IOException If an I/O error occurs
+     * @throws SQLException if a database access error occurs
+     * @since 1.9.0
+     */
+    public void printRecords(final ResultSet resultSet, final boolean printHeader) throws SQLException, IOException {
+        if (printHeader) {
+            printHeaders(resultSet);
+        }
+        printRecords(resultSet);
+    }
+
+    /**
+     * Prints all the objects in the given {@link Stream} handling nested collections/arrays as records.
+     *
+     * 

+     * If the given Stream only contains simple objects, this method will print a single record like
+     * {@link #printRecord(Iterable)}. If the given Stream contains nested collections/arrays those nested elements
+     * will each be printed as records using {@link #printRecord(Object...)}.
+     * 
+     *
+     * 

+     * Given the following data structure:
+     * 
+     *
+     * 
{@code
+     * List data = new ArrayList<>();
+     * data.add(new String[]{ "A", "B", "C" });
+     * data.add(new String[]{ "1", "2", "3" });
+     * data.add(new String[]{ "A1", "B2", "C3" });
+     * Stream stream = data.stream();
+     * }
+     * 
+     *
+     * 

+     * Calling this method will print:
+     * 
+     *
+     * 
+     * {@code
+     * A, B, C
+     * 1, 2, 3
+     * A1, B2, C3
+     * }
+     * 
+     *
+     * @param values
+     *            the values to print.
+     * @throws IOException
+     *             If an I/O error occurs
+     * @since 1.10.0
+     */
+    @SuppressWarnings({ "resource" }) // Caller closes.
+    public void printRecords(final Stream values) throws IOException {
+        printRecords(IOStream.adapt(values));
+    }
 }
diff --git a/src/main/java/org/apache/commons/csv/CSVRecord.java b/src/main/java/org/apache/commons/csv/CSVRecord.java
index f3b023f6c6..8dab14d907 100644
--- a/src/main/java/org/apache/commons/csv/CSVRecord.java
+++ b/src/main/java/org/apache/commons/csv/CSVRecord.java
@@ -1,18 +1,20 @@
 /*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *   https://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.
+ * 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 org.apache.commons.csv;
@@ -23,8 +25,8 @@
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Objects;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 /**
  * A CSV record parsed from a CSV file.
@@ -32,39 +34,47 @@
  * 

  * Note: Support for {@link Serializable} is scheduled to be removed in version 2.0.
  * In version 1.8 the mapping between the column header and the column index was
- * removed from the serialised state. The class maintains serialization compatibility
+ * removed from the serialized state. The class maintains serialization compatibility
  * with versions pre-1.8 for the record values; these must be accessed by index
- * following deserialization. There will be loss of any functionally linked to the header
- * mapping when transferring serialised forms pre-1.8 to 1.8 and vice versa.
+ * following deserialization. There will be a loss of any functionally linked to the header
+ * mapping when transferring serialized forms pre-1.8 to 1.8 and vice versa.
  * 
  */
 public final class CSVRecord implements Serializable, Iterable {
 
-    private static final String[] EMPTY_STRING_ARRAY = new String[0];
-
     private static final long serialVersionUID = 1L;
 
+    /**
+     * The start position of this record as a character position in the source stream. This may or may not correspond to the byte position depending on the
+     * character set.
+     */
     private final long characterPosition;
 
-    /** The accumulated comments (if any) */
+    /**
+     * The starting position of this record in the source stream, measured in bytes.
+     */
+    private final long bytePosition;
+
+    /** The accumulated comments (if any). */
     private final String comment;
 
     /** The record number. */
     private final long recordNumber;
 
-    /** The values of the record */
+    /** The values of the record. */
     private final String[] values;
 
     /** The parser that originates this record. This is not serialized. */
     private final transient CSVParser parser;
 
-    CSVRecord(final CSVParser parser, final String[] values, final String comment, final long recordNumber,
-            final long characterPosition) {
+    CSVRecord(final CSVParser parser, final String[] values,  final String comment, final long recordNumber,
+            final long characterPosition, final long bytePosition) {
         this.recordNumber = recordNumber;
-        this.values = values != null ? values : EMPTY_STRING_ARRAY;
+        this.values = values != null ? values : Constants.EMPTY_STRING_ARRAY;
         this.parser = parser;
         this.comment = comment;
         this.characterPosition = characterPosition;
+        this.bytePosition = bytePosition;
     }
 
     /**
@@ -75,7 +85,7 @@ public final class CSVRecord implements Serializable, Iterable {
      * @return the String at the given enum String
      */
     public String get(final Enum e) {
-        return get(Objects.toString(e, null));
+        return get(e == null ? null : e.name());
     }
 
     /**
@@ -90,7 +100,7 @@ public String get(final int i) {
     }
 
     /**
-     * Returns a value by name.
+     * Returns a value by name. If multiple instances of the header name exists, only the last occurrence is returned.
      *
      * 

      * Note: This requires a field mapping obtained from the original parser.
@@ -104,34 +114,42 @@ public String get(final int i) {
      *            the name of the column to be retrieved.
      * @return the column value, maybe null depending on {@link CSVFormat#getNullString()}.
      * @throws IllegalStateException
-     *             if no header mapping was provided
+     *             if no header mapping was provided.
      * @throws IllegalArgumentException
-     *             if {@code name} is not mapped or if the record is inconsistent
+     *             if {@code name} is not mapped or if the record is inconsistent.
      * @see #isMapped(String)
      * @see #isConsistent()
      * @see #getParser()
-     * @see CSVFormat#withNullString(String)
+     * @see CSVFormat.Builder#setNullString(String)
      */
     public String get(final String name) {
         final Map headerMap = getHeaderMapRaw();
         if (headerMap == null) {
-            throw new IllegalStateException(
-                "No header mapping was specified, the record values can't be accessed by name");
+            throw new IllegalStateException("No header mapping was specified, the record values can't be accessed by name");
         }
         final Integer index = headerMap.get(name);
         if (index == null) {
-            throw new IllegalArgumentException(String.format("Mapping for %s not found, expected one of %s", name,
-                headerMap.keySet()));
+            throw new IllegalArgumentException(String.format("Mapping for %s not found, expected one of %s", name, headerMap.keySet()));
         }
         try {
-            return values[index.intValue()];
+            return values[index.intValue()]; // Explicit unboxing is intentional
         } catch (final ArrayIndexOutOfBoundsException e) {
-            throw new IllegalArgumentException(String.format(
-                "Index for header '%s' is %d but CSVRecord only has %d values!", name, index,
-                Integer.valueOf(values.length)));
+            // Explicit boxing is intentional
+            throw new IllegalArgumentException(
+                    String.format("Index for header '%s' is %d but CSVRecord only has %d values!", name, index, Integer.valueOf(values.length)));
         }
     }
 
+    /**
+     * Returns the starting position of this record in the source stream, measured in bytes.
+     *
+     * @return the byte position of this record in the source stream.
+     * @since 1.13.0
+     */
+    public long getBytePosition() {
+        return bytePosition;
+    }
+
     /**
      * Returns the start position of this record as a character position in the source stream. This may or may not
      * correspond to the byte position depending on the character set.
@@ -145,8 +163,8 @@ public long getCharacterPosition() {
     /**
      * Returns the comment for this record, if any.
      * Note that comments are attached to the following record.
-     * If there is no following record (i.e. the comment is at EOF)
-     * the comment will be ignored.
+     * If there is no following record (that is, the comment is at EOF),
+     * then the comment will be ignored.
      *
      * @return the comment for this record, or null if no comment for this record is available.
      */
@@ -177,7 +195,7 @@ public CSVParser getParser() {
      * Returns the number of this record in the parsed CSV file.
      *
      * 

-     * ATTENTION: If your CSV input has multi-line values, the returned number does not correspond to
+     * NOTE:If your CSV input has multi-line values, the returned number does not correspond to
      * the current line number of the parser that created this record.
      * 
      *
@@ -191,10 +209,10 @@ public long getRecordNumber() {
     /**
      * Checks whether this record has a comment, false otherwise.
      * Note that comments are attached to the following record.
-     * If there is no following record (i.e. the comment is at EOF)
-     * the comment will be ignored.
+     * If there is no following record (that is, the comment is at EOF),
+     * then the comment will be ignored.
      *
-     * @return true if this record has a comment, false otherwise
+     * @return true if this record has a comment, false otherwise.
      * @since 1.3
      */
     public boolean hasComment() {
@@ -209,7 +227,7 @@ public boolean hasComment() {
      * test but still produce parsable files.
      * 

      *
-     * @return true of this record is valid, false if not
+     * @return true of this record is valid, false if not.
      */
     public boolean isConsistent() {
         final Map headerMap = getHeaderMapRaw();
@@ -217,7 +235,7 @@ public boolean isConsistent() {
     }
 
     /**
-     * Checks whether a given column is mapped, i.e. its name has been defined to the parser.
+     * Checks whether a given column is mapped, that is, its name has been defined to the parser.
      *
      * @param name
      *            the name of the column to be retrieved.
@@ -229,25 +247,25 @@ public boolean isMapped(final String name) {
     }
 
     /**
-     * Checks whether a column with given index has a value.
+     * Checks whether a column with a given index has a value.
      *
      * @param index
-     *         a column index (0-based)
-     * @return whether a column with given index has a value
+     *         a column index (0-based).
+     * @return whether a column with a given index has a value.
      */
     public boolean isSet(final int index) {
         return 0 <= index && index < values.length;
     }
 
     /**
-     * Checks whether a given columns is mapped and has a value.
+     * Checks whether a given column is mapped and has a value.
      *
      * @param name
      *            the name of the column to be retrieved.
-     * @return whether a given columns is mapped and has a value
+     * @return whether a given column is mapped and has a value.
      */
     public boolean isSet(final String name) {
-        return isMapped(name) && getHeaderMapRaw().get(name).intValue() < values.length;
+        return isMapped(name) && getHeaderMapRaw().get(name).intValue() < values.length; // Explicit unboxing is intentional
     }
 
     /**
@@ -263,21 +281,20 @@ public Iterator iterator() {
     /**
      * Puts all values of this record into the given Map.
      *
-     * @param  the map type
+     * @param  The map type.
      * @param map The Map to populate.
      * @return the given map.
-     * @since 1.9
+     * @since 1.9.0
      */
     public > M putIn(final M map) {
         if (getHeaderMapRaw() == null) {
             return map;
         }
-        for (final Entry entry : getHeaderMapRaw().entrySet()) {
-            final int col = entry.getValue().intValue();
-            if (col < values.length) {
-                map.put(entry.getKey(), values[col]);
+        getHeaderMapRaw().forEach((key, value) -> {
+            if (value < values.length) {
+                map.put(key, values[value]);
             }
-        }
+        });
         return map;
     }
 
@@ -291,23 +308,40 @@ public int size() {
     }
 
     /**
-     * Converts the values to a List.
+     * Returns a sequential ordered stream whose elements are the values.
      *
-     * TODO: Maybe make this public?
+     * @return the new stream.
+     * @since 1.9.0
+     */
+    public Stream stream() {
+        return Stream.of(values);
+    }
+
+    /**
+     * Converts the values to a new List.
+     * 

+     * Editing the list does not update this instance.
+     * 
      *
      * @return a new List
+     * @since 1.9.0
      */
-    private List toList() {
-        return Arrays.asList(values);
+    public List toList() {
+        return stream().collect(Collectors.toList());
     }
 
     /**
-     * Copies this record into a new Map of header name to record value.
+     * Copies this record into a new Map of header name to record value. If multiple instances of a header name exist,
+     * then only the last occurrence is mapped.
+     *
+     * 

+     * Editing the map does not update this instance.
+     * 
      *
      * @return A new Map. The map is empty if the record has no headers.
      */
     public Map toMap() {
-        return putIn(new LinkedHashMap(values.length));
+        return putIn(new LinkedHashMap<>(values.length));
     }
 
     /**
@@ -318,11 +352,16 @@ public Map toMap() {
      */
     @Override
     public String toString() {
-        return "CSVRecord [comment='" + comment + "', recordNumber=" + recordNumber + ", values=" +
-            Arrays.toString(values) + "]";
+        return "CSVRecord [comment='" + comment + "', recordNumber=" + recordNumber + ", values=" + Arrays.toString(values) + "]";
     }
 
-    String[] values() {
+    /**
+     * Gets the values for this record. This is not a copy.
+     *
+     * @return the values for this record, never null.
+     * @since 1.10.0
+     */
+    public String[] values() {
         return values;
     }
 
diff --git a/src/main/java/org/apache/commons/csv/Constants.java b/src/main/java/org/apache/commons/csv/Constants.java
index b7dc770ac4..9dd276eccc 100644
--- a/src/main/java/org/apache/commons/csv/Constants.java
+++ b/src/main/java/org/apache/commons/csv/Constants.java
@@ -1,24 +1,26 @@
 /*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *   https://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.
+ * 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 org.apache.commons.csv;
 
 /**
- * Constants for this package.
+ * Private constants for this package.
  */
 final class Constants {
 
@@ -26,7 +28,7 @@ final class Constants {
 
     static final char BACKSPACE = '\b';
 
-    static final char COMMA = ',';
+    static final String COMMA = ",";
 
     /**
      * Starts a comment, the remainder of the line is the comment.
@@ -35,15 +37,14 @@ final class Constants {
 
     static final char CR = '\r';
 
-    /** RFC 4180 defines line breaks as CRLF */
+    /** RFC 4180 defines line breaks as CRLF. */
     static final String CRLF = "\r\n";
 
-    static final Character DOUBLE_QUOTE_CHAR = Character.valueOf('"');
+    static final Character DOUBLE_QUOTE_CHAR = Character.valueOf('"');  // Explicit boxing is intentional.
 
     static final String EMPTY = "";
 
-    /** The end of stream symbol */
-    static final int END_OF_STREAM = -1;
+    static final String[] EMPTY_STRING_ARRAY = {};
 
     static final char FF = '\f';
 
@@ -66,17 +67,24 @@ final class Constants {
 
     static final char PIPE = '|';
 
-    /** ASCII record separator */
+    /** ASCII record separator. */
     static final char RS = 30;
 
     static final char SP = ' ';
 
+    static final String SQL_NULL_STRING = "\\N";
+
     static final char TAB = '\t';
 
-    /** Undefined state for the lookahead char */
+    /** Undefined state for the lookahead char. */
     static final int UNDEFINED = -2;
 
-    /** ASCII unit separator */
+    /** ASCII unit separator. */
     static final char US = 31;
 
+    /** No instances. */
+    private Constants() {
+        // noop
+    }
+
 }
diff --git a/src/main/java/org/apache/commons/csv/DuplicateHeaderMode.java b/src/main/java/org/apache/commons/csv/DuplicateHeaderMode.java
new file mode 100644
index 0000000000..8087f16eeb
--- /dev/null
+++ b/src/main/java/org/apache/commons/csv/DuplicateHeaderMode.java
@@ -0,0 +1,44 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *
+ *   https://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 org.apache.commons.csv;
+
+/**
+ * Enumerates how duplicate header fields should be handled
+ * if {@link CSVFormat.Builder#setHeader(Class)} is not null.
+ *
+ * @since 1.10.0
+ */
+public enum DuplicateHeaderMode {
+
+    /**
+     * Allows all duplicate headers.
+     */
+    ALLOW_ALL,
+
+    /**
+     * Allows duplicate headers only if they're empty, blank, or null strings.
+     */
+    ALLOW_EMPTY,
+
+    /**
+     * Disallows duplicate headers entirely.
+     */
+    DISALLOW
+}
diff --git a/src/main/java/org/apache/commons/csv/ExtendedBufferedReader.java b/src/main/java/org/apache/commons/csv/ExtendedBufferedReader.java
index 66686111c1..20c1ef5444 100644
--- a/src/main/java/org/apache/commons/csv/ExtendedBufferedReader.java
+++ b/src/main/java/org/apache/commons/csv/ExtendedBufferedReader.java
@@ -1,90 +1,171 @@
 /*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *   https://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.
+ * 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 org.apache.commons.csv;
 
 import static org.apache.commons.csv.Constants.CR;
-import static org.apache.commons.csv.Constants.END_OF_STREAM;
 import static org.apache.commons.csv.Constants.LF;
 import static org.apache.commons.csv.Constants.UNDEFINED;
+import static org.apache.commons.io.IOUtils.EOF;
 
-import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.Reader;
+import java.nio.CharBuffer;
+import java.nio.charset.CharacterCodingException;
+import java.nio.charset.Charset;
+import java.nio.charset.CharsetEncoder;
+
+import org.apache.commons.io.IOUtils;
+import org.apache.commons.io.input.UnsynchronizedBufferedReader;
 
 /**
  * A special buffered reader which supports sophisticated read access.
  * 

- * In particular the reader supports a look-ahead option, which allows you to see the next char returned by
- * {@link #read()}. This reader also tracks how many characters have been read with {@link #getPosition()}.
+ * In particular the reader supports a look-ahead option, which allows you to see the next char returned by {@link #read()}. This reader also tracks how many
+ * characters have been read with {@link #getPosition()}.
  * 
  */
-final class ExtendedBufferedReader extends BufferedReader {
+final class ExtendedBufferedReader extends UnsynchronizedBufferedReader {
 
     /** The last char returned */
     private int lastChar = UNDEFINED;
 
+    private int lastCharMark = UNDEFINED;
+
     /** The count of EOLs (CR/LF/CRLF) seen so far */
-    private long eolCounter;
+    private long lineNumber;
 
-    /** The position, which is number of characters read so far */
+    private long lineNumberMark;
+
+    /** The position, which is the number of characters read so far */
     private long position;
 
-    private boolean closed;
+    private long positionMark;
+
+    /** The number of bytes read so far. */
+    private long bytesRead;
+
+    private long bytesReadMark;
+
+    /** Encoder for calculating the number of bytes for each character read. */
+    private final CharsetEncoder encoder;
 
     /**
-     * Created extended buffered reader using default buffer-size
+     * Constructs a new instance using the default buffer size.
      */
     ExtendedBufferedReader(final Reader reader) {
+        this(reader, null, false);
+    }
+
+    /**
+     * Constructs a new instance with the specified reader, character set, and byte tracking option. Initializes an encoder if byte tracking is enabled and a
+     * character set is provided.
+     *
+     * @param reader     the reader supports a look-ahead option.
+     * @param charset    the character set for encoding, or {@code null} if not applicable.
+     * @param trackBytes {@code true} to enable byte tracking; {@code false} to disable it.
+     */
+    ExtendedBufferedReader(final Reader reader, final Charset charset, final boolean trackBytes) {
         super(reader);
+        encoder = charset != null && trackBytes ? charset.newEncoder() : null;
     }
 
     /**
      * Closes the stream.
      *
-     * @throws IOException
-     *             If an I/O error occurs
+     * @throws IOException If an I/O error occurs
      */
     @Override
     public void close() throws IOException {
         // Set ivars before calling super close() in case close() throws an IOException.
-        closed = true;
-        lastChar = END_OF_STREAM;
+        lastChar = EOF;
         super.close();
     }
 
     /**
-     * Returns the current line number
+     * Gets the number of bytes read by the reader.
      *
-     * @return the current line number
+     * @return the number of bytes read by the read
      */
-    long getCurrentLineNumber() {
-        // Check if we are at EOL or EOF or just starting
-        if (lastChar == CR || lastChar == LF || lastChar == UNDEFINED || lastChar == END_OF_STREAM) {
-            return eolCounter; // counter is accurate
+    long getBytesRead() {
+        return this.bytesRead;
+    }
+
+    private long getEncodedCharLength(final char[] buf, final int offset, final int length) throws CharacterCodingException {
+        long len = 0;
+        int previous = lastChar;
+        for (int i = offset; i < offset + length; i++) {
+            len += getEncodedCharLength(previous, buf[i]);
+            previous = buf[i];
         }
-        return eolCounter + 1; // Allow for counter being incremented only at EOL
+        return len;
+    }
+
+    /**
+     * Gets the byte length of the given character based on the original Unicode specification, which defined characters as fixed-width 16-bit entities.
+     * 

+     * The Unicode characters are divided into two main ranges:
+     * 

+     * 
U+0000 to U+FFFF (Basic Multilingual Plane, BMP):
+     * 

+     * 
Represented using a single 16-bit {@code char}.
+     * 
Includes UTF-8 encodings of 1-byte, 2-byte, and some 3-byte characters.
+     * 
+     * 
+     * 
U+10000 to U+10FFFF (Supplementary Characters):
+     * 

+     * 
Represented as a pair of {@code char}s:
+     * 
The first {@code char} is from the high-surrogates range (\uD800-\uDBFF).
+     * 
The second {@code char} is from the low-surrogates range (\uDC00-\uDFFF).
+     * 
Includes UTF-8 encodings of some 3-byte characters and all 4-byte characters.
+     * 
+     * 
+     * 
+     *
+     * @param current the current character to process.
+     * @return the byte length of the character.
+     * @throws CharacterCodingException if the character cannot be encoded.
+     */
+    private int getEncodedCharLength(final int current) throws CharacterCodingException {
+        return getEncodedCharLength(lastChar, current);
+    }
+
+    private int getEncodedCharLength(final int previous, final int current) throws CharacterCodingException {
+        final char cChar = (char) current;
+        final char lChar = (char) previous;
+        if (!Character.isSurrogate(cChar)) {
+            return encoder.encode(CharBuffer.wrap(new char[] { cChar })).limit();
+        }
+        if (Character.isHighSurrogate(cChar)) {
+            // Move on to the next char (low surrogate)
+            return 0;
+        }
+        if (Character.isSurrogatePair(lChar, cChar)) {
+            return encoder.encode(CharBuffer.wrap(new char[] { lChar, cChar })).limit();
+        }
+        throw new CharacterCodingException();
     }
 
     /**
-     * Returns the last character that was read as an integer (0 to 65535). This will be the last character returned by
-     * any of the read methods. This will not include a character read using the {@link #lookAhead()} method. If no
-     * character has been read then this will return {@link Constants#UNDEFINED}. If the end of the stream was reached
-     * on the last read then this will return {@link Constants#END_OF_STREAM}.
+     * Returns the last character that was read as an integer (0 to 65535). This will be the last character returned by any of the read methods. This will not
+     * include a character read using the {@link #peek()} method. If no character has been read then this will return {@link Constants#UNDEFINED}. If the end of
+     * the stream was reached on the last read then this will return {@link IOUtils#EOF}.
      *
      * @return the last character that was read
      */
@@ -93,44 +174,47 @@ int getLastChar() {
     }
 
     /**
-     * Gets the character position in the reader.
+     * Returns the current line number
      *
-     * @return the current position in the reader (counting characters, not bytes since this is a Reader)
+     * @return the current line number
      */
-    long getPosition() {
-        return this.position;
-    }
-
-    public boolean isClosed() {
-        return closed;
+    long getLineNumber() {
+        // Check if we are at EOL or EOF or just starting
+        if (lastChar == CR || lastChar == LF || lastChar == UNDEFINED || lastChar == EOF) {
+            return lineNumber; // counter is accurate
+        }
+        return lineNumber + 1; // Allow for counter being incremented only at EOL
     }
 
     /**
-     * Returns the next character in the current reader without consuming it. So the next call to {@link #read()} will
-     * still return this value. Does not affect line number or last character.
-     *
-     * @return the next character
+     * Gets the character position in the reader.
      *
-     * @throws IOException
-     *             if there is an error in reading
+     * @return the current position in the reader (counting characters, not bytes since this is a Reader)
      */
-    int lookAhead() throws IOException {
-        super.mark(1);
-        final int c = super.read();
-        super.reset();
+    long getPosition() {
+        return this.position;
+    }
 
-        return c;
+    @Override
+    public void mark(final int readAheadLimit) throws IOException {
+        lineNumberMark = lineNumber;
+        lastCharMark = lastChar;
+        positionMark = position;
+        bytesReadMark = bytesRead;
+        super.mark(readAheadLimit);
     }
 
     @Override
     public int read() throws IOException {
         final int current = super.read();
-        if ((current == CR || current == LF && lastChar != CR) ||
-            (current == END_OF_STREAM && lastChar != CR && lastChar != LF && lastChar != END_OF_STREAM)) {
-            eolCounter++;
+        if (current == CR || current == LF && lastChar != CR || current == EOF && lastChar != CR && lastChar != LF && lastChar != EOF) {
+            lineNumber++;
+        }
+        if (encoder != null && current != EOF) {
+            this.bytesRead += getEncodedCharLength(current);
         }
         lastChar = current;
-        this.position++;
+        position++;
         return lastChar;
     }
 
@@ -139,54 +223,68 @@ public int read(final char[] buf, final int offset, final int length) throws IOE
         if (length == 0) {
             return 0;
         }
-
         final int len = super.read(buf, offset, length);
-
+        if (encoder != null && len > 0) {
+            this.bytesRead += getEncodedCharLength(buf, offset, len);
+        }
         if (len > 0) {
-
             for (int i = offset; i < offset + len; i++) {
                 final char ch = buf[i];
                 if (ch == LF) {
-                    if (CR != (i > 0 ? buf[i - 1] : lastChar)) {
-                        eolCounter++;
+                    if (CR != (i > offset ? buf[i - 1] : lastChar)) {
+                        lineNumber++;
                     }
                 } else if (ch == CR) {
-                    eolCounter++;
+                    lineNumber++;
                 }
             }
-
             lastChar = buf[offset + len - 1];
-
-        } else if (len == -1) {
-            lastChar = END_OF_STREAM;
+        } else if (len == EOF) {
+            lastChar = EOF;
         }
-
         position += len;
         return len;
     }
 
     /**
-     * Calls {@link BufferedReader#readLine()} which drops the line terminator(s). This method should only be called
-     * when processing a comment, otherwise information can be lost.
+     * Gets the next line, dropping the line terminator(s). This method should only be called when processing a comment, otherwise, information can be lost.
      * 

-     * Increments {@link #eolCounter}
+     * Increments {@link #lineNumber} and updates {@link #position}.
+     * 
      * 

-     * Sets {@link #lastChar} to {@link Constants#END_OF_STREAM} at EOF, otherwise to LF
+     * Sets {@link #lastChar} to {@code Constants.EOF} at EOF, otherwise the last EOL character.
+     * 
      *
      * @return the line that was read, or null if reached EOF.
      */
     @Override
     public String readLine() throws IOException {
-        final String line = super.readLine();
-
-        if (line != null) {
-            lastChar = LF; // needed for detecting start of line
-            eolCounter++;
-        } else {
-            lastChar = END_OF_STREAM;
+        if (peek() == EOF) {
+            return null;
         }
-
-        return line;
+        final StringBuilder buffer = new StringBuilder();
+        while (true) {
+            final int current = read();
+            if (current == CR) {
+                final int next = peek();
+                if (next == LF) {
+                    read();
+                }
+            }
+            if (current == EOF || current == LF || current == CR) {
+                break;
+            }
+            buffer.append((char) current);
+        }
+        return buffer.toString();
     }
 
+    @Override
+    public void reset() throws IOException {
+        lineNumber = lineNumberMark;
+        lastChar = lastCharMark;
+        position = positionMark;
+        bytesRead = bytesReadMark;
+        super.reset();
+    }
 }
diff --git a/src/main/java/org/apache/commons/csv/IOUtils.java b/src/main/java/org/apache/commons/csv/IOUtils.java
deleted file mode 100644
index 1771d4dc3c..0000000000
--- a/src/main/java/org/apache/commons/csv/IOUtils.java
+++ /dev/null
@@ -1,139 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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 org.apache.commons.csv;
-
-import java.io.IOException;
-import java.io.Reader;
-import java.io.Writer;
-import java.nio.CharBuffer;
-
-/** Copied from Apache Commons IO. */
-class IOUtils {
-
-    /**
-     * 

-     * Copied from Apache Commons IO.
-     * 
-     * The default buffer size ({@value}).
-     */
-    static final int DEFAULT_BUFFER_SIZE = 1024 * 4;
-
-    /**
-     * 

-     * Copied from Apache Commons IO.
-     * 
-     * Represents the end-of-file (or stream).
-     * @since 2.5 (made public)
-     */
-    private static final int EOF = -1;
-
-    /**
-     * Copies chars from a large (over 2GB) {@code Reader} to an {@code Appendable}.
-     * 

-     * This method buffers the input internally, so there is no need to use a
-     * {@code BufferedReader}.
-     * 
-     * The buffer size is given by {@link #DEFAULT_BUFFER_SIZE}.
-     *
-     * @param input the {@code Reader} to read from
-     * @param output the {@code Appendable} to append to
-     * @return the number of characters copied
-     * @throws NullPointerException if the input or output is null
-     * @throws IOException          if an I/O error occurs
-     * @since 2.7
-     */
-    static long copy(final Reader input, final Appendable output) throws IOException {
-        return copy(input, output, CharBuffer.allocate(DEFAULT_BUFFER_SIZE));
-    }
-
-    /**
-     * Copies chars from a large (over 2GB) {@code Reader} to an {@code Appendable}.
-     * 

-     * This method uses the provided buffer, so there is no need to use a
-     * {@code BufferedReader}.
-     * 
-     *
-     * @param input the {@code Reader} to read from
-     * @param output the {@code Appendable} to write to
-     * @param buffer the buffer to be used for the copy
-     * @return the number of characters copied
-     * @throws NullPointerException if the input or output is null
-     * @throws IOException          if an I/O error occurs
-     * @since 2.7
-     */
-    static long copy(final Reader input, final Appendable output, final CharBuffer buffer) throws IOException {
-        long count = 0;
-        int n;
-        while (EOF != (n = input.read(buffer))) {
-            buffer.flip();
-            output.append(buffer, 0, n);
-            count += n;
-        }
-        return count;
-    }
-
-    /**
-     * 

-     * Copied from Apache Commons IO.
-     * 
-     * Copies chars from a large (over 2GB) {@code Reader} to a {@code Writer}.
-     * 

-     * This method buffers the input internally, so there is no need to use a
-     * {@code BufferedReader}.
-     * 

-     * The buffer size is given by {@link #DEFAULT_BUFFER_SIZE}.
-     *
-     * @param input the {@code Reader} to read from
-     * @param output the {@code Writer} to write to
-     * @return the number of characters copied
-     * @throws NullPointerException if the input or output is null
-     * @throws IOException          if an I/O error occurs
-     * @since 1.3
-     */
-    static long copyLarge(final Reader input, final Writer output) throws IOException {
-        return copyLarge(input, output, new char[DEFAULT_BUFFER_SIZE]);
-    }
-
-    /**
-     * 

-     * Copied from Apache Commons IO.
-     * 
-     * Copies chars from a large (over 2GB) {@code Reader} to a {@code Writer}.
-     * 

-     * This method uses the provided buffer, so there is no need to use a
-     * {@code BufferedReader}.
-     * 

-     *
-     * @param input the {@code Reader} to read from
-     * @param output the {@code Writer} to write to
-     * @param buffer the buffer to be used for the copy
-     * @return the number of characters copied
-     * @throws NullPointerException if the input or output is null
-     * @throws IOException          if an I/O error occurs
-     * @since 2.2
-     */
-    static long copyLarge(final Reader input, final Writer output, final char[] buffer) throws IOException {
-        long count = 0;
-        int n;
-        while (EOF != (n = input.read(buffer))) {
-            output.write(buffer, 0, n);
-            count += n;
-        }
-        return count;
-    }
-
-}
diff --git a/src/main/java/org/apache/commons/csv/Lexer.java b/src/main/java/org/apache/commons/csv/Lexer.java
index 2795ca29b7..fe964480a4 100644
--- a/src/main/java/org/apache/commons/csv/Lexer.java
+++ b/src/main/java/org/apache/commons/csv/Lexer.java
@@ -1,80 +1,96 @@
 /*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *   https://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.
+ * 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 org.apache.commons.csv;
 
-import static org.apache.commons.csv.Constants.BACKSPACE;
-import static org.apache.commons.csv.Constants.CR;
-import static org.apache.commons.csv.Constants.END_OF_STREAM;
-import static org.apache.commons.csv.Constants.FF;
-import static org.apache.commons.csv.Constants.LF;
-import static org.apache.commons.csv.Constants.TAB;
-import static org.apache.commons.csv.Constants.UNDEFINED;
-import static org.apache.commons.csv.Token.Type.COMMENT;
-import static org.apache.commons.csv.Token.Type.EOF;
-import static org.apache.commons.csv.Token.Type.EORECORD;
-import static org.apache.commons.csv.Token.Type.INVALID;
-import static org.apache.commons.csv.Token.Type.TOKEN;
+import static org.apache.commons.io.IOUtils.EOF;
 
 import java.io.Closeable;
 import java.io.IOException;
+import java.util.Arrays;
+
+import org.apache.commons.io.IOUtils;
 
 /**
  * Lexical analyzer.
  */
 final class Lexer implements Closeable {
 
-    private static final String CR_STRING = Character.toString(CR);
-    private static final String LF_STRING = Character.toString(LF);
-
-    /**
-     * Constant char to use for disabling comments, escapes and encapsulation. The value -2 is used because it
-     * won't be confused with an EOF signal (-1), and because the Unicode value {@code FFFE} would be encoded as two
-     * chars (using surrogates) and thus there should never be a collision with a real text char.
-     */
-    private static final char DISABLED = '\ufffe';
-
-    private final char delimiter;
-    private final char escape;
-    private final char quoteChar;
-    private final char commentStart;
+    private static final String CR_STRING = Character.toString(Constants.CR);
+    private static final String LF_STRING = Character.toString(Constants.LF);
 
+    private final char[] delimiter;
+    private final char[] delimiterBuf;
+    private final char[] escapeDelimiterBuf;
+    private final int escape;
+    private final int quoteChar;
+    private final int commentStart;
     private final boolean ignoreSurroundingSpaces;
     private final boolean ignoreEmptyLines;
+    private final boolean lenientEof;
+    private final boolean trailingData;
 
-    /** The input stream */
+    /** The buffered reader. */
     private final ExtendedBufferedReader reader;
     private String firstEol;
 
+    private boolean isLastTokenDelimiter;
+
     Lexer(final CSVFormat format, final ExtendedBufferedReader reader) {
         this.reader = reader;
-        this.delimiter = format.getDelimiter();
-        this.escape = mapNullToDisabled(format.getEscapeCharacter());
-        this.quoteChar = mapNullToDisabled(format.getQuoteCharacter());
-        this.commentStart = mapNullToDisabled(format.getCommentMarker());
+        this.delimiter = format.getDelimiterCharArray();
+        this.escape = nullToDisabled(format.getEscapeCharacter());
+        this.quoteChar = nullToDisabled(format.getQuoteCharacter());
+        this.commentStart = nullToDisabled(format.getCommentMarker());
         this.ignoreSurroundingSpaces = format.getIgnoreSurroundingSpaces();
         this.ignoreEmptyLines = format.getIgnoreEmptyLines();
+        this.lenientEof = format.getLenientEof();
+        this.trailingData = format.getTrailingData();
+        this.delimiterBuf = new char[delimiter.length - 1];
+        this.escapeDelimiterBuf = new char[2 * delimiter.length - 1];
+    }
+
+    /**
+     * Appends the next escaped character to the token's content.
+     *
+     * @param token the current token.
+     * @throws IOException  on stream access error.
+     * @throws CSVException Thrown on invalid input.
+     */
+    private void appendNextEscapedCharacterToToken(final Token token) throws IOException {
+        if (isEscapeDelimiter()) {
+            token.content.append(delimiter);
+        } else {
+            final int unescaped = readEscape();
+            if (unescaped == EOF) { // unexpected char after escape
+                token.content.append((char) escape).append((char) reader.getLastChar());
+            } else {
+                token.content.append((char) unescaped);
+            }
+        }
     }
 
     /**
      * Closes resources.
      *
      * @throws IOException
-     *             If an I/O error occurs
+     *             If an I/O error occurs.
      */
     @Override
     public void close() throws IOException {
@@ -82,24 +98,33 @@ public void close() throws IOException {
     }
 
     /**
-     * Returns the current character position
+     * Gets the number of bytes read.
+     *
+     * @return the number of bytes read.
+     */
+    long getBytesRead() {
+        return reader.getBytesRead();
+    }
+
+    /**
+     * Gets the current character position.
      *
-     * @return the current character position
+     * @return the current character position.
      */
     long getCharacterPosition() {
         return reader.getPosition();
     }
 
     /**
-     * Returns the current line number
+     * Gets the current line number.
      *
-     * @return the current line number
+     * @return the current line number.
      */
     long getCurrentLineNumber() {
-        return reader.getCurrentLineNumber();
+        return reader.getLineNumber();
     }
 
-    String getFirstEol(){
+    String getFirstEol() {
         return firstEol;
     }
 
@@ -111,26 +136,78 @@ boolean isCommentStart(final int ch) {
         return ch == commentStart;
     }
 
-    boolean isDelimiter(final int ch) {
-        return ch == delimiter;
+    /**
+     * Tests whether the next characters constitute a delimiter through {@link ExtendedBufferedReader#peek(char[])}.
+     *
+     * @param ch
+     *             the current character.
+     * @return true if the next characters constitute a delimiter.
+     * @throws IOException If an I/O error occurs.
+     */
+    boolean isDelimiter(final int ch) throws IOException {
+        isLastTokenDelimiter = false;
+        if (ch != delimiter[0]) {
+            return false;
+        }
+        if (delimiter.length == 1) {
+            isLastTokenDelimiter = true;
+            return true;
+        }
+        Arrays.fill(delimiterBuf, '\0');
+        reader.peek(delimiterBuf);
+        for (int i = 0; i < delimiterBuf.length; i++) {
+            if (delimiterBuf[i] != delimiter[i + 1]) {
+                return false;
+            }
+        }
+        final int count = reader.read(delimiterBuf, 0, delimiterBuf.length);
+        isLastTokenDelimiter = count != EOF;
+        return isLastTokenDelimiter;
     }
 
     /**
-     * @return true if the given character indicates end of file
+     * Tests if the given character indicates the end of the file.
+     *
+     * @return true if the given character indicates the end of the file.
      */
     boolean isEndOfFile(final int ch) {
-        return ch == END_OF_STREAM;
+        return ch == EOF;
     }
 
+    /**
+     * Tests if the given character is the escape character.
+     *
+     * @return true if the given character is the escape character.
+     */
     boolean isEscape(final int ch) {
         return ch == escape;
     }
 
+    /**
+     * Tests if the next characters constitute a escape delimiter through {@link ExtendedBufferedReader#peek(char[])}.
+     *
+     * For example, for delimiter "[|]" and escape '!', return true if the next characters constitute "![!|!]".
+     *
+     * @return true if the next characters constitute an escape delimiter.
+     * @throws IOException If an I/O error occurs.
+     */
+    boolean isEscapeDelimiter() throws IOException {
+        Arrays.fill(escapeDelimiterBuf, '\0');
+        reader.peek(escapeDelimiterBuf);
+        if (escapeDelimiterBuf[0] != delimiter[0]) {
+            return false;
+        }
+        for (int i = 1; i < delimiter.length; i++) {
+            if (escapeDelimiterBuf[2 * i] != delimiter[i] || escapeDelimiterBuf[2 * i - 1] != escape) {
+                return false;
+            }
+        }
+        final int count = reader.read(escapeDelimiterBuf, 0, escapeDelimiterBuf.length);
+        return count != EOF;
+    }
+
     private boolean isMetaChar(final int ch) {
-        return ch == delimiter ||
-               ch == escape ||
-               ch == quoteChar ||
-               ch == commentStart;
+        return ch == escape || ch == quoteChar || ch == commentStart;
     }
 
     boolean isQuoteChar(final int ch) {
@@ -138,24 +215,13 @@ boolean isQuoteChar(final int ch) {
     }
 
     /**
-     * Checks if the current character represents the start of a line: a CR, LF or is at the start of the file.
+     * Tests if the current character represents the start of a line: a CR, LF, or is at the start of the file.
      *
-     * @param ch the character to check
+     * @param ch the character to check.
      * @return true if the character is at the start of a line.
      */
     boolean isStartOfLine(final int ch) {
-        return ch == LF || ch == CR || ch == UNDEFINED;
-    }
-
-    /**
-     * @return true if the given char is a whitespace character
-     */
-    boolean isWhitespace(final int ch) {
-        return !isDelimiter(ch) && Character.isWhitespace((char) ch);
-    }
-
-    private char mapNullToDisabled(final Character c) {
-        return c == null ? DISABLED : c.charValue();
+        return ch == Constants.LF || ch == Constants.CR || ch == Constants.UNDEFINED;
     }
 
     /**
@@ -164,86 +230,82 @@ private char mapNullToDisabled(final Character c) {
      * A token corresponds to a term, a record change or an end-of-file indicator.
      * 
      *
-     * @param token
-     *            an existing Token object to reuse. The caller is responsible to initialize the Token.
-     * @return the next token found
-     * @throws java.io.IOException
-     *             on stream access error
+     * @param token an existing Token object to reuse. The caller is responsible for initializing the Token.
+     * @return the next token found.
+     * @throws IOException  on stream access error.
+     * @throws CSVException Thrown on invalid input.
      */
     Token nextToken(final Token token) throws IOException {
-
-        // get the last read char (required for empty line detection)
+        // Get the last read char (required for empty line detection)
         int lastChar = reader.getLastChar();
-
         // read the next char and set eol
         int c = reader.read();
-        /*
-         * Note: The following call will swallow LF if c == CR. But we don't need to know if the last char was CR or LF
-         * - they are equivalent here.
-         */
+        // Note: The following call will swallow LF if c == CR. But we don't need to know if the last char was CR or LF - they are equivalent here.
         boolean eol = readEndOfLine(c);
-
         // empty line detection: eol AND (last char was EOL or beginning)
         if (ignoreEmptyLines) {
             while (eol && isStartOfLine(lastChar)) {
-                // go on char ahead ...
+                // Go on char ahead ...
                 lastChar = c;
                 c = reader.read();
                 eol = readEndOfLine(c);
-                // reached end of file without any content (empty line at the end)
+                // reached the end of the file without any content (empty line at the end)
                 if (isEndOfFile(c)) {
-                    token.type = EOF;
+                    token.type = Token.Type.EOF;
                     // don't set token.isReady here because no content
                     return token;
                 }
             }
         }
-
-        // did we reach eof during the last iteration already ? EOF
-        if (isEndOfFile(lastChar) || !isDelimiter(lastChar) && isEndOfFile(c)) {
-            token.type = EOF;
+        // Did we reach EOF during the last iteration already? EOF
+        if (isEndOfFile(lastChar) || !isLastTokenDelimiter && isEndOfFile(c)) {
+            token.type = Token.Type.EOF;
             // don't set token.isReady here because no content
             return token;
         }
-
         if (isStartOfLine(lastChar) && isCommentStart(c)) {
             final String line = reader.readLine();
             if (line == null) {
-                token.type = EOF;
+                token.type = Token.Type.EOF;
                 // don't set token.isReady here because no content
                 return token;
             }
             final String comment = line.trim();
             token.content.append(comment);
-            token.type = COMMENT;
+            token.type = Token.Type.COMMENT;
             return token;
         }
-
-        // important: make sure a new char gets consumed in each iteration
-        while (token.type == INVALID) {
+        // Important: make sure a new char gets consumed in each iteration
+        while (token.type == Token.Type.INVALID) {
+            // isDelimiter consumes the trailing characters of a multi-character delimiter as a side effect, so it must
+            // only be evaluated once per character. Remember a match found while skipping whitespace below.
+            boolean delimiter = false;
             // ignore whitespaces at beginning of a token
             if (ignoreSurroundingSpaces) {
-                while (isWhitespace(c) && !eol) {
+                while (Character.isWhitespace((char) c) && !eol) {
+                    if (isDelimiter(c)) {
+                        delimiter = true;
+                        break;
+                    }
                     c = reader.read();
                     eol = readEndOfLine(c);
                 }
             }
-
             // ok, start of token reached: encapsulated, or token
-            if (isDelimiter(c)) {
+            if (delimiter || isDelimiter(c)) {
                 // empty token return TOKEN("")
-                token.type = TOKEN;
+                token.type = Token.Type.TOKEN;
             } else if (eol) {
                 // empty token return EORECORD("")
                 // noop: token.content.append("");
-                token.type = EORECORD;
+                token.type = Token.Type.EORECORD;
             } else if (isQuoteChar(c)) {
                 // consume encapsulated token
                 parseEncapsulatedToken(token);
             } else if (isEndOfFile(c)) {
                 // end of file return EOF()
                 // noop: token.content.append("");
-                token.type = EOF;
+                token.type = Token.Type.EOF;
                 token.isReady = true; // there is data at EOF
             } else {
                 // next token must be a simple token
@@ -254,14 +316,19 @@ Token nextToken(final Token token) throws IOException {
         return token;
     }
 
+    private int nullToDisabled(final Character c) {
+        return c == null ? Constants.UNDEFINED : c.charValue(); // Explicit unboxing
+    }
+
     /**
      * Parses an encapsulated token.
-     * 

-     * Encapsulated tokens are surrounded by the given encapsulating-string. The encapsulator itself might be included
+     * 

+     * Encapsulated tokens are surrounded by the given encapsulating string. The encapsulator itself might be included
      * in the token using a doubling syntax (as "", '') or using escaping (as in \", \'). Whitespaces before and after
-     * an encapsulated token are ignored. The token is finished when one of the following conditions become true:
+     * an encapsulated token is ignored. The token is finished when one of the following conditions becomes true:
+     * 
      * 

-     * 
an unescaped encapsulator has been reached, and is followed by optional whitespace then:
+     * 
An unescaped encapsulator has been reached and is followed by optional whitespace then:
      * 

      * 
delimiter (TOKEN)
      * 
end of line (EORECORD)
@@ -272,24 +339,19 @@ Token nextToken(final Token token) throws IOException {
      *            the current token
      * @return a valid token object
      * @throws IOException
-     *             on invalid state: EOF before closing encapsulator or invalid character before delimiter or EOL
+     *             Thrown when in an invalid state: EOF before closing encapsulator or invalid character before
+     *             delimiter or EOL.
+     * @throws CSVException Thrown on invalid input.
      */
     private Token parseEncapsulatedToken(final Token token) throws IOException {
-        // save current line number in case needed for IOE
+        token.isQuoted = true;
+        // Save current line number in case needed for IOE
         final long startLineNumber = getCurrentLineNumber();
         int c;
         while (true) {
             c = reader.read();
-
-            if (isEscape(c)) {
-                final int unescaped = readEscape();
-                if (unescaped == END_OF_STREAM) { // unexpected char after escape
-                    token.content.append((char) c).append((char) reader.getLastChar());
-                } else {
-                    token.content.append((char) unescaped);
-                }
-            } else if (isQuoteChar(c)) {
-                if (isQuoteChar(reader.lookAhead())) {
+            if (isQuoteChar(c)) {
+                if (isQuoteChar(reader.peek())) {
                     // double or escaped encapsulator -> add single encapsulator to token
                     c = reader.read();
                     token.content.append((char) c);
@@ -298,26 +360,37 @@ private Token parseEncapsulatedToken(final Token token) throws IOException {
                     while (true) {
                         c = reader.read();
                         if (isDelimiter(c)) {
-                            token.type = TOKEN;
+                            token.type = Token.Type.TOKEN;
                             return token;
-                        } else if (isEndOfFile(c)) {
-                            token.type = EOF;
+                        }
+                        if (isEndOfFile(c)) {
+                            token.type = Token.Type.EOF;
                             token.isReady = true; // There is data at EOF
                             return token;
-                        } else if (readEndOfLine(c)) {
-                            token.type = EORECORD;
+                        }
+                        if (readEndOfLine(c)) {
+                            token.type = Token.Type.EORECORD;
                             return token;
-                        } else if (!isWhitespace(c)) {
+                        }
+                        if (trailingData) {
+                            token.content.append((char) c);
+                        } else if (!Character.isWhitespace((char) c)) {
                             // error invalid char between token and next delimiter
-                            throw new IOException("(line " + getCurrentLineNumber() +
-                                    ") invalid char between encapsulated token and delimiter");
+                            throw new CSVException("Invalid character between encapsulated token and delimiter at line: %,d, position: %,d",
+                                    getCurrentLineNumber(), getCharacterPosition());
                         }
                     }
                 }
+            } else if (isEscape(c)) {
+                appendNextEscapedCharacterToToken(token);
             } else if (isEndOfFile(c)) {
+                if (lenientEof) {
+                    token.type = Token.Type.EOF;
+                    token.isReady = true; // There is data at EOF
+                    return token;
+                }
                 // error condition (end of file before end of token)
-                throw new IOException("(startline " + startLineNumber +
-                        ") EOF reached before encapsulated token finished");
+                throw new CSVException("(startline %,d) EOF reached before encapsulated token finished", startLineNumber);
             } else {
                 // consume character
                 token.content.append((char) c);
@@ -327,48 +400,46 @@ private Token parseEncapsulatedToken(final Token token) throws IOException {
 
     /**
      * Parses a simple token.
-     * 

-     * Simple token are tokens which are not surrounded by encapsulators. A simple token might contain escaped
-     * delimiters (as \, or \;). The token is finished when one of the following conditions become true:
+     * 

+     * Simple tokens are tokens that are not surrounded by encapsulators. A simple token might contain escaped delimiters (as \, or \;). The token is finished
+     * when one of the following conditions becomes true:
+     * 
      * 

-     * 
end of line has been reached (EORECORD)
-     * 
end of stream has been reached (EOF)
-     * 
an unescaped delimiter has been reached (TOKEN)
+     * 
The end of line has been reached (EORECORD)
+     * 
The end of stream has been reached (EOF)
+     * 
An unescaped delimiter has been reached (TOKEN)
      * 
      *
-     * @param token
-     *            the current token
-     * @param ch
-     *            the current character
-     * @return the filled token
-     * @throws IOException
-     *             on stream access error
+     * @param token the current token.
+     * @param ch     the current character.
+     * @return the filled token.
+     * @throws IOException  on stream access error.
+     * @throws CSVException Thrown on invalid input.
      */
-    private Token parseSimpleToken(final Token token, int ch) throws IOException {
+    private Token parseSimpleToken(final Token token, final int ch) throws IOException {
         // Faster to use while(true)+break than while(token.type == INVALID)
+        int cur = ch;
         while (true) {
-            if (readEndOfLine(ch)) {
-                token.type = EORECORD;
+            if (readEndOfLine(cur)) {
+                token.type = Token.Type.EORECORD;
                 break;
-            } else if (isEndOfFile(ch)) {
-                token.type = EOF;
+            }
+            if (isEndOfFile(cur)) {
+                token.type = Token.Type.EOF;
                 token.isReady = true; // There is data at EOF
                 break;
-            } else if (isDelimiter(ch)) {
-                token.type = TOKEN;
+            }
+            if (isDelimiter(cur)) {
+                token.type = Token.Type.TOKEN;
                 break;
-            } else if (isEscape(ch)) {
-                final int unescaped = readEscape();
-                if (unescaped == END_OF_STREAM) { // unexpected char after escape
-                    token.content.append((char) ch).append((char) reader.getLastChar());
-                } else {
-                    token.content.append((char) unescaped);
-                }
-                ch = reader.read(); // continue
+            }
+            // continue
+            if (isEscape(cur)) {
+                appendNextEscapedCharacterToToken(token);
             } else {
-                token.content.append((char) ch);
-                ch = reader.read(); // continue
+                token.content.append((char) cur);
             }
+            cur = reader.read(); // continue
         }
 
         if (ignoreSurroundingSpaces) {
@@ -381,13 +452,14 @@ private Token parseSimpleToken(final Token token, int ch) throws IOException {
     /**
      * Greedily accepts \n, \r and \r\n This checker consumes silently the second control-character...
      *
-     * @return true if the given or next character is a line-terminator
+     * @return true if the given or next character is a line-terminator.
      */
-    boolean readEndOfLine(int ch) throws IOException {
+    boolean readEndOfLine(final int ch) throws IOException {
         // check if we have \r\n...
-        if (ch == CR && reader.lookAhead() == LF) {
+        int cur = ch;
+        if (cur == Constants.CR && reader.peek() == Constants.LF) {
             // note: does not change ch outside of this method!
-            ch = reader.read();
+            cur = reader.read();
             // Save the EOL state
             if (firstEol == null) {
                 this.firstEol = Constants.CRLF;
@@ -395,64 +467,61 @@ boolean readEndOfLine(int ch) throws IOException {
         }
         // save EOL state here.
         if (firstEol == null) {
-            if (ch == LF) {
+            if (cur == Constants.LF) {
                 this.firstEol = LF_STRING;
-            } else if (ch == CR) {
+            } else if (cur == Constants.CR) {
                 this.firstEol = CR_STRING;
             }
         }
 
-        return ch == LF || ch == CR;
+        return cur == Constants.LF || cur == Constants.CR;
     }
 
     // TODO escape handling needs more work
     /**
-     * Handle an escape sequence.
-     * The current character must be the escape character.
-     * On return, the next character is available by calling {@link ExtendedBufferedReader#getLastChar()}
-     * on the input stream.
+     * Handle an escape sequence. The current character must be the escape character. On return, the next character is available by calling
+     * {@link ExtendedBufferedReader#getLastChar()} on the input stream.
      *
-     * @return the unescaped character (as an int) or {@link Constants#END_OF_STREAM} if char following the escape is
-     *      invalid.
-     * @throws IOException if there is a problem reading the stream or the end of stream is detected:
-     *      the escape character is not allowed at end of stream
+     * @return the unescaped character (as an int) or {@link IOUtils#EOF} if char following the escape is invalid.
+     * @throws IOException  if there is a problem reading the stream or the end of stream is detected: the escape character is not allowed at end of stream
+     * @throws CSVException Thrown on invalid input.
      */
     int readEscape() throws IOException {
         // the escape char has just been read (normally a backslash)
         final int ch = reader.read();
         switch (ch) {
         case 'r':
-            return CR;
+            return Constants.CR;
         case 'n':
-            return LF;
+            return Constants.LF;
         case 't':
-            return TAB;
+            return Constants.TAB;
         case 'b':
-            return BACKSPACE;
+            return Constants.BACKSPACE;
         case 'f':
-            return FF;
-        case CR:
-        case LF:
-        case FF: // TODO is this correct?
-        case TAB: // TODO is this correct? Do tabs need to be escaped?
-        case BACKSPACE: // TODO is this correct?
+            return Constants.FF;
+        case Constants.CR:
+        case Constants.LF:
+        case Constants.FF: // TODO is this correct?
+        case Constants.TAB: // TODO is this correct? Do tabs need to be escaped?
+        case Constants.BACKSPACE: // TODO is this correct?
             return ch;
-        case END_OF_STREAM:
-            throw new IOException("EOF whilst processing escape sequence");
+        case EOF:
+            throw new CSVException("EOF while processing escape sequence");
         default:
             // Now check for meta-characters
             if (isMetaChar(ch)) {
                 return ch;
             }
             // indicate unexpected char - available from in.getLastChar()
-            return END_OF_STREAM;
+            return EOF;
         }
     }
 
     void trimTrailingSpaces(final StringBuilder buffer) {
         int length = buffer.length();
         while (length > 0 && Character.isWhitespace(buffer.charAt(length - 1))) {
-            length = length - 1;
+            length--;
         }
         if (length != buffer.length()) {
             buffer.setLength(length);
diff --git a/src/main/java/org/apache/commons/csv/QuoteMode.java b/src/main/java/org/apache/commons/csv/QuoteMode.java
index 272deb7383..ae64ab4863 100644
--- a/src/main/java/org/apache/commons/csv/QuoteMode.java
+++ b/src/main/java/org/apache/commons/csv/QuoteMode.java
@@ -1,23 +1,27 @@
 /*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *   https://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.
+ * 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 org.apache.commons.csv;
 
 /**
- * Defines quoting behavior when printing.
+ * Enumerates quoting behavior.
+ *
+ * @see CSVFormat.Builder#setQuoteMode(QuoteMode)
  */
 public enum QuoteMode {
 
@@ -32,7 +36,7 @@ public enum QuoteMode {
     ALL_NON_NULL,
 
     /**
-     * Quotes fields which contain special characters such as a the field delimiter, quote character or any of the
+     * Quotes fields that contain special characters such as a field delimiter, quote character, or any of the
      * characters in the line separator string.
      */
     MINIMAL,
diff --git a/src/main/java/org/apache/commons/csv/Token.java b/src/main/java/org/apache/commons/csv/Token.java
index dff7d0181a..87af335678 100644
--- a/src/main/java/org/apache/commons/csv/Token.java
+++ b/src/main/java/org/apache/commons/csv/Token.java
@@ -1,18 +1,20 @@
 /*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *   https://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.
+ * 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 org.apache.commons.csv;
@@ -21,16 +23,18 @@
 
 /**
  * Internal token representation.
- * 

- * It is used as contract between the lexer and the parser.
+ * 

+ * This is used as a contract between the lexer and the parser.
+ * 
  */
 final class Token {
 
     enum Type {
-        /** Token has no valid content, i.e. is in its initialized state. */
+
+        /** Token has no valid content, that is, is in its initialized state. */
         INVALID,
 
-        /** Token with content, at beginning or in the middle of a line. */
+        /** Token with content, at the beginning or in the middle of a line. */
         TOKEN,
 
         /** Token (which can have content) when the end of file is reached. */
@@ -43,31 +47,34 @@ enum Type {
         COMMENT
     }
 
-    /** length of the initial token (content-)buffer */
-    private static final int INITIAL_TOKEN_LENGTH = 50;
+    /** Length of the initial token (content-)buffer */
+    private static final int DEFAULT_CAPACITY = 50;
 
     /** Token type */
     Token.Type type = INVALID;
 
-    /** The content buffer. */
-    final StringBuilder content = new StringBuilder(INITIAL_TOKEN_LENGTH);
+    /** The content buffer, never null. */
+    final StringBuilder content = new StringBuilder(DEFAULT_CAPACITY);
 
     /** Token ready flag: indicates a valid token with content (ready for the parser). */
     boolean isReady;
 
+    boolean isQuoted;
+
     void reset() {
         content.setLength(0);
         type = INVALID;
         isReady = false;
+        isQuoted = false;
     }
 
     /**
-     * Eases IDE debugging.
+     * Converts the token state to a string to ease debugging.
      *
      * @return a string helpful for debugging.
      */
     @Override
     public String toString() {
-        return type.name() + " [" + content.toString() + "]";
+        return type + " [" + content.toString() + "]";
     }
 }
diff --git a/src/main/java/org/apache/commons/csv/package-info.java b/src/main/java/org/apache/commons/csv/package-info.java
index 29e7fef612..d3340fcae8 100644
--- a/src/main/java/org/apache/commons/csv/package-info.java
+++ b/src/main/java/org/apache/commons/csv/package-info.java
@@ -1,31 +1,33 @@
 /*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *   https://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.
+ * 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.
  */
 
 /**
- * Apache Commons CSV Format Support.
+ * 
Apache Commons CSV
  *
- * 
CSV are widely used as interfaces to legacy systems or manual data-imports.
+ * 
CSV are widely used as interfaces to legacy systems or manual data imports.
  *    CSV stands for "Comma Separated Values" (or sometimes "Character Separated
  *    Values"). The CSV data format is defined in
- *    RFC 4180
+ *    RFC 4180
  *    but many dialects exist.
  *
  * 
Common to all file dialects is its basic structure: The CSV data-format
- *    is record oriented, whereas each record starts on a new textual line. A
+ *    is record-oriented, whereas each record starts on a new textual line. A
  *    record is build of a list of values. Keep in mind that not all records
  *    must have an equal number of values:
  * 
@@ -36,28 +38,28 @@
  * 
The following list contains the CSV aspects the Commons CSV parser supports:
  * 

  *   
Separators (for lines)
- *   
The record separators are hardcoded and cannot be changed. The must be '\r', '\n' or '\r\n'.
+ *   
The record separators are hardcoded and cannot be changed. The must be '\r', '\n', or '\r\n'.
  *
  *   
Delimiter (for values)
  *   
The delimiter for values is freely configurable (default ',').
  *
  *   
Comments
- *   
Some CSV-dialects support a simple comment syntax. A comment is a record
+ *   
Some CSV dialects support a simple comment syntax. A comment is a record
  *       which must start with a designated character (the commentStarter). A record
- *       of this kind is treated as comment and gets removed from the input (default none)
+ *       of this kind is treated as a comment and gets removed from the input (default none)
  *
  *   
Encapsulator
  *  
Two encapsulator characters (default '"') are used to enclose -> complex values.
  *
  *   
Simple values
- *   
A simple value consist of all characters (except the delimiter) until
- *       (but not including) the next delimiter or a record-terminator. Optionally
+ *   
A simple value consists of all characters (except the delimiter) until
+ *       (but not including) the next delimiter or a record terminator. Optionally
  *       all surrounding whitespaces of a simple value can be ignored (default: true).
  *
  *   
Complex values
  *   
Complex values are encapsulated within a pair of the defined encapsulator characters.
  *       The encapsulator itself must be escaped or doubled when used inside complex values.
- *       Complex values preserve all kind of formatting (including newlines -> multiline-values)
+ *       Complex values preserve all kinds of formatting (including newlines -> multiline-values)
  *
  *  
Empty line skipping
  *   
Optionally empty lines in CSV files can be skipped.
diff --git a/src/main/javadoc/overview.html b/src/main/javadoc/overview.html
new file mode 100644
index 0000000000..0598cf19d0
--- /dev/null
+++ b/src/main/javadoc/overview.html
@@ -0,0 +1,375 @@
+
+
+
+
+
+
+  
+  

+    You can find the Javadoc package list at the bottom of this page.
+  
+  

+    
Introducing Commons CSV
+    
Apache Commons CSV reads and writes files in variations of the Comma Separated Value (CSV) format.
+    

+      Common CSV formats are predefined in the CSVFormat class:
+    
+      
+      
+        
+          
+          
+          
+        
+      
+      
+        
+          
+          
+          
+        
+        
+          
+          
+          
+        
+        
+          
+          
+          
+        
+        
+          
+          
+          
+        
+        
+          
+          
+          
+        
+        
+          
+          
+          
+        
+        
+          
+          
+          
+        
+        
+          
+          
+          
+        
+        
+          
+          
+          
+        
+        
+          
+          
+          
+        
+        
+          
+          
+          
+        
+        
+          
+          
+          
+        
+      
+    
CSV Formats
CSVFormat
Description
Since Version
DEFAULT
IO for the Standard Comma Separated Value format, like RFC 4180 but allowing
+            empty lines.
+          
1.0
EXCEL
IO for the Microsoft
+              Excel CSV. format.
+          
1.0
INFORMIX_UNLOAD
IO for the Informix UNLOAD TO file_name
+            command.
+          
1.3
INFORMIX_UNLOAD_CSV
IO for the Informix UNLOAD CSV TO
+              file_name command with escaping disabled.
+          
1.3
MONGODB_CSV
IO for the MongoDB CSV mongoexport command.
+          
1.7
MONGODB_TSV
IO for the MongoDB Tab Separated Values (TSV)mongoexport
+            command.
+          
1.7
MYSQL
IO for the MySQL CSV format.
+          
1.0
ORACLE
IO for the Oracle CSV format
+            of the SQL*Loader utility.
+          
1.6
POSTGRESQL_CSV
IO for the PostgreSQL CSV format used by the COPY
+            operation.
+          
1.5
POSTGRESQL_TEXT
IO for the PostgreSQL Text format used by the COPY
+            operation.
+          
1.5
RFC4180
IO for the RFC-4180 format defined byRFC 4180.
+          
1.0
TDF
IO for the Tab Delimited Format (also known as Tab Separated Values).
+          
1.0
+    
Custom formats can be created using a fluent style API.
+  
+  

+    
Parsing Standard CSV Files
+    

+      Parsing files with Apache Commons CSV is relatively straight forward. Pick a
+      CSVFormat
+      and go from there.
+    
+    

+      
Parsing an Excel CSV File
+      
To parse an Excel CSV file, write:
+      
+        
+Reader in = new FileReader("path/to/file.csv");
+Iterable<CSVRecord> records = CSVFormat.EXCEL.parse(in);
+for (CSVRecord record : records) {
+    String lastName = record.get("Last Name");
+    String firstName = record.get("First Name");
+}
+        
+      
+    
+  
+  

+    
Parsing Custom CSV Files
+    

+      You can define your own using IO rules by building your own CSVFormat instance. Starting with
+      CSVFormat.builder()
+      lets you start from a predefined format and customize. For example:
+    
+    
+      
+CSVFormat myFormat = CSVFormat.DEFAULT.builder()
+    .setCommentMarker('#')
+    .setEscape('+')
+    .setIgnoreSurroundingSpaces(true)
+    .setQuote('"')
+    .setQuoteMode(QuoteMode.ALL)
+    .get()
+      
+    
+  
+  

+    
Handling Byte Order Marks
+    

+      To handle files that start with a Byte Order Mark (BOM), like some Excel CSV files, you need an extra step to deal with the optional BOM bytes. Using the
+       BOMInputStream  class from Apache Commons IO simplifies this task; for example:
+    
+    
+        
+try (Reader reader = new InputStreamReader(BOMInputStream.builder()
+        .setPath(path)
+        .get(), "UTF-8");
+        CSVParser parser = CSVFormat.EXCEL.builder()
+                .setHeader()
+                .get()
+                .parse(reader)) {
+    for (CSVRecord record : parser) {
+        String string = record.get("ColumnA");
+        // ...
+    }
+}
+        
+      
+    
You might find it handy to create something like this:
+    
+        
+/**
+ * Creates a reader capable of handling BOMs.
+ *
+ * @param path The path to read.
+ * @return a new InputStreamReader for UTF-8 bytes.
+ * @throws IOException if an I/O error occurs.
+ */
+public InputStreamReader newReader(final Path path) throws IOException {
+    return new InputStreamReader(BOMInputStream.builder()
+            .setPath(path)
+            .get(), StandardCharsets.UTF_8);
+}
+        
+      
+  
+  

+    
Using Headers
+    

+      Apache Commons CSV provides several ways to access record values. The simplest way is to access values by their index in the record. However, columns in
+      CSV files often have a name, for example: ID, CustomerNo, Birthday, etc. The CSVFormat class provides an API for specifying these header names and
+      CSVRecord on the other hand has methods to access values by their corresponding header name.
+    
+    

+      
Accessing column values by index
+      
To access a record value by index, no special configuration of the CSVFormat is necessary:
+      
+        
+Reader in = new FileReader("path/to/file.csv");
+Iterable<CSVRecord> records = CSVFormat.RFC4180.parse(in);
+for (CSVRecord record : records) {
+    String columnOne = record.get(0);
+    String columnTwo = record.get(1);
+}
+        
+      
+    
+    

+      
Defining a header manually
+      
Indices may not be the most intuitive way to access record values. For this reason it is possible to assign names to each column in the file:
+      
+        
+Reader in = new FileReader("path/to/file.csv");
+Iterable<CSVRecord> records = CSVFormat.RFC4180.builder()
+  .setHeader("ID", "CustomerNo", "Name")
+  .build()
+  .parse(in);
+for (CSVRecord record : records) {
+    String id = record.get("ID");
+    String customerNo = record.get("CustomerNo");
+    String name = record.get("Name");
+}
+        
+      
+      Note that column values can still be accessed using their index.
+    
+    

+      
Using an enum to define a header
+      
Using String values all over the code to reference columns can be error prone. For this reason, it is possible to define an enum to specify header
+        names. Note that the enum constant names are used to access column values. This may lead to enums constant names which do not follow the Java coding
+        standard of defining constants in upper case with underscores:
+      
+        
+public enum Headers {
+    ID, CustomerNo, Name
+}
+Reader in = new FileReader("path/to/file.csv");
+Iterable<CSVRecord> records = CSVFormat.RFC4180.builder()
+  .setHeader(Headers.class)
+  .build()
+  .parse(in);
+for (CSVRecord record : records) {
+    String id = record.get(Headers.ID);
+    String customerNo = record.get(Headers.CustomerNo);
+    String name = record.get(Headers.Name);
+}
+        
+      
+      Again it is possible to access values by their index and by using a String (for example "CustomerNo").
+    
+    

+      
Header auto detection
+      
Some CSV files define header names in their first record. If configured, Apache Commons CSV can parse the header names from the first record:
+      
+        
+Reader in = new FileReader("path/to/file.csv");
+Iterable<CSVRecord> records = CSVFormat.RFC4180.builder()
+  .setHeader()
+  .setSkipHeaderRecord(true)
+  .build()
+  .parse(in);
+for (CSVRecord record : records) {
+    String id = record.get("ID");
+    String customerNo = record.get("CustomerNo");
+    String name = record.get("Name");
+}
+        
+      
+      This will use the values from the first record as header names and skip the first record when iterating.
+    
+  
+  

+    
Printing with headers
+    
To print a CSV file with headers, you specify the headers in the format:
+    
+        
+Appendable out = ...;
+CSVPrinter printer = CSVFormat.DEFAULT.builder()
+  .setHeader("H1", "H2")
+  .build()
+  .print(out);
+        
+      
+    
To print a CSV file with JDBC column labels, you specify the ResultSet in the format:
+    
+        
+try (ResultSet resultSet = ...) {
+    CSVPrinter printer = CSVFormat.DEFAULT.builder()
+      .setHeader(resultSet)
+      .build()
+      .print(out);
+}
+        
+      
+  
+  

+    
Working with JDBC
+    

+      
Exporting JDBC Result Sets
+      

+        To export row data from a JDBC
+        ResultSet
+        , use CSVPrinter.printRecords(ResultSet) :
+      
+      
+        
+        final StringWriter sw = new StringWriter();
+        final CSVFormat csvFormat = CSVFormat.DEFAULT;
+        try (Connection connection = DriverManager.getConnection("jdbc:h2:mem:my_test;", "sa", "")) {
+            try (Statement stmt = connection.createStatement();
+                    CSVPrinter printer = new CSVPrinter(sw, csvFormat);
+                    ResultSet resultSet = stmt.executeQuery("select ID, NAME, TEXT, BIN_DATA from TEST")) {
+                printer.printRecords(resultSet);
+            }
+        }
+        final String csv = sw.toString();
+        System.out.println(csv);
+        
+        
+    
+    

+      
Limiting rows from JDBC Result Sets
+      
SQL lets you limit how many rows a SELECT statement returns with the LIMIT clause.
+      

+        When you can't or don't want to change the SQL used to generate rows, JDBC lets you limit how many rows a JDBC Statement returns with the Statement.setMaxRows(int) method.
+      
+      

+        When you get a JDBC ResultSet from an API like 
+          DatabaseMetaData.getProcedures(...), there is no SQL or JDBC Statement to use to set a limit, the ResultSet class does not have an API to limit rows.
+      
+      

+        To simplify limiting ResultSet rows, Commons CVS offers the CSVFormat.Builder.setMaxRows(long)
+        method. For example:
+      
+      
+        
+        CSVFormat csvFormat = CSVFormat.DEFAULT
+            .setMaxRows(5_000)
+            .get();
+        try (ResultSet resultSet = ...) {
+            csvFormat.printer().printRecords(resultSet);
+        }
+        
+      
+      

+        Using the above, calling CSVPrinter.printRecords(ResultSet) will
+        limit the row count to the maximum number of rows specified in setMaxRows().
+      
+      
Note that setMaxRows() works with the other methods that print a sequence of records.
+    
+  
+
+
diff --git a/src/media/commons-logo-component-100.xcf b/src/media/commons-logo-component-100.xcf
new file mode 100644
index 0000000000..77d92f2779
Binary files /dev/null and b/src/media/commons-logo-component-100.xcf differ
diff --git a/src/media/commons-logo-component.xcf b/src/media/commons-logo-component.xcf
new file mode 100644
index 0000000000..3670221da7
Binary files /dev/null and b/src/media/commons-logo-component.xcf differ
diff --git a/src/media/logo.png b/src/media/logo.png
new file mode 100644
index 0000000000..93bb6c0148
Binary files /dev/null and b/src/media/logo.png differ
diff --git a/src/site/resources/images/logo.png b/src/site/resources/images/logo.png
index 77e721d2c7..93bb6c0148 100644
Binary files a/src/site/resources/images/logo.png and b/src/site/resources/images/logo.png differ
diff --git a/src/site/resources/images/logo.xcf b/src/site/resources/images/logo.xcf
deleted file mode 100644
index 98ff21ec1d..0000000000
Binary files a/src/site/resources/images/logo.xcf and /dev/null differ
diff --git a/src/site/resources/pmd/pmd-ruleset.xml b/src/site/resources/pmd/pmd-ruleset.xml
index 8d52e45a70..74e41f991d 100644
--- a/src/site/resources/pmd/pmd-ruleset.xml
+++ b/src/site/resources/pmd/pmd-ruleset.xml
@@ -7,7 +7,7 @@
    (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
+       https://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,
@@ -15,10 +15,10 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 -->
-
+    xsi:schemaLocation="http://pmd.sourceforge.net/ruleset/2.0.0 https://pmd.sourceforge.net/ruleset_2_0_0.xsd">
   
     This ruleset checks the code for discouraged programming constructs.
   
@@ -26,16 +26,14 @@
   
   
   
-  
   
   
   
   
-  
-  
   
   
-  
+  
+  
   
   
   
@@ -53,16 +51,7 @@
   
   
   
-  
-  
-  
-  
   
-  
-  
-  
-  
-  
   
   
   
@@ -70,19 +59,17 @@
   
   
   
-  
   
   
   
   
-  
 
-  
+  
 
   
     
       
+        value="//ClassOrInterfaceDeclaration[contains(@Name, 'org.apache.commons.csv.CSVFormat')] or //ClassOrInterfaceDeclaration[contains(@SimpleName, 'org.apache.commons.csv.Lexer')]" />
     
   
 
diff --git a/src/site/resources/profile.jacoco b/src/site/resources/profile.jacoco
index e69de29bb2..0314c63ff2 100644
--- a/src/site/resources/profile.jacoco
+++ b/src/site/resources/profile.jacoco
@@ -0,0 +1,16 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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
+//
+//  https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
diff --git a/src/site/resources/spotbugs/spotbugs-exclude-filter.xml b/src/site/resources/spotbugs/spotbugs-exclude-filter.xml
index 4af22bc790..79c57d3ae4 100644
--- a/src/site/resources/spotbugs/spotbugs-exclude-filter.xml
+++ b/src/site/resources/spotbugs/spotbugs-exclude-filter.xml
@@ -6,7 +6,7 @@
    (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
+       https://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,
@@ -20,12 +20,46 @@
         xsi:schemaLocation="https://github.com/spotbugs/filter/3.0.0 https://raw.githubusercontent.com/spotbugs/spotbugs/3.1.0/spotbugs/etc/findbugsfilter.xsd">
 
 
+  
   
     
-      
-          
-      
+    
     
   
 
+  
+  
+    
+    
+    
+  
+  
+  
+  
+    
+    
+    
+  
+  
+  
+  
+    
+    
+    
+  
+  
+  
+  
+    
+    
+    
+  
+
+  
+  
+    
+    
+    
+  
+  
 
diff --git a/src/site/site.xml b/src/site/site.xml
index 50e9587549..232c2056c5 100644
--- a/src/site/site.xml
+++ b/src/site/site.xml
@@ -7,7 +7,7 @@
  (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
+      https://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,
@@ -15,40 +15,29 @@
  See the License for the specific language governing permissions and
  limitations under the License.
 -->
-
-
-  
-    Apache Commons CSV
-    /images/logo.png
-    /index.html
-    Commons CSV&trade; logo
+
+  
+    
   
-
   
-
     
-      
-      
-      
-      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
     
-
-    
-      
-      
-      
-      
-      
-      
-      
-      
-      
-      
-      
-      
-      
-      
-    
-
   
-
+
diff --git a/src/site/xdoc/download_csv.xml b/src/site/xdoc/download_csv.xml
index 7598025dfd..151c3f69ec 100644
--- a/src/site/xdoc/download_csv.xml
+++ b/src/site/xdoc/download_csv.xml
@@ -7,7 +7,7 @@ The ASF licenses this file to You 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
+     https://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,
@@ -56,10 +56,12 @@ limitations under the License.
  |                                                                      |
  +======================================================================+
 -->
-
+
   
     
-    Apache Commons Documentation Team
+    Apache Commons Team
   
   
     

@@ -79,7 +81,7 @@ limitations under the License.
         mirrors (at the end of the mirrors list) that should be
         available.
         


-        [if-any logo][end]
+        [if-any logo][end]
       

 
       

@@ -107,38 +109,38 @@ limitations under the License.
         failing that using the SHA512 hash (*.sha512 checksum files).
       

       

-        The KEYS
+        The KEYS
         file contains the public PGP keys used by Apache Commons developers
         to sign releases.
       
     
     
-    

+    

       
         
-              
-              
-              
+              
+              
+              
-              
-              
-              
+              
+              
+              

           
commons-csv-1.8-bin.tar.gz
sha512
pgp
commons-csv-1.14.1-bin.tar.gz
sha512
pgp
           
           
commons-csv-1.8-bin.zip
sha512
pgp
commons-csv-1.14.1-bin.zip
sha512
pgp
           
         
       
       
         
-              
-              
-              
+              
+              
+              
-              
-              
-              
+              
+              
+              

           
commons-csv-1.8-src.tar.gz
sha512
pgp
commons-csv-1.14.1-src.tar.gz
sha512
pgp
           
           
commons-csv-1.8-src.zip
sha512
pgp
commons-csv-1.14.1-src.zip
sha512
pgp
           
         
       
diff --git a/src/site/xdoc/index.xml b/src/site/xdoc/index.xml
index 5943b57543..ac5b8cfa9f 100644
--- a/src/site/xdoc/index.xml
+++ b/src/site/xdoc/index.xml
@@ -7,7 +7,7 @@ The ASF licenses this file to You 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
+     https://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,
@@ -18,101 +18,84 @@ limitations under the License.
 
  
   
-  Commons Documentation Team
+  Apache Commons Team
  
+
+  
+
 
-
 

   
Commons CSV reads and writes files in variations of the Comma Separated Value (CSV) format.
-  
The most common CSV formats are predefined in the CSVFormat class:
-  

-    
Microsoft Excel
-    
Informix UNLOAD
-    
Informix UNLOAD CSV
-    
MySQL
-    
Oracle
-    
PostgreSQL CSV
-    
PostgreSQL Text
-    
RFC 4180
-    
TDF
-  
-  

-  
Custom formats can be created using a fluent style API.
+  
Read the documentation starting with the Javadoc Overview.
 
-
 

 

 An overview of the functionality is provided in the
-user guide.
+user guide.
 Various project reports are also available.
 
 

 The Javadoc API documents are available online:
 
 

-  
Javadoc trunk
-  
Javadoc 1.8
-  
Javadoc 1.7
-  
Javadoc 1.6
-  
Javadoc 1.5
-  
Javadoc 1.4
-  
Javadoc 1.3
-  
Javadoc 1.2
-  
Javadoc 1.1
-  
Javadoc 1.0
+  
Javadoc current
+  
Javadoc archives
 
 

 The git repository can be
-browsed.
+browsed.
 
 
-
 

 

-  
Apache Commons CSV 1.8 (mirrors) requires Java 8
-  
Apache Commons CSV 1.7 (archives) requires Java 8
-  
Apache Commons CSV 1.6 (archives) requires Java 7
-  
Apache Commons CSV 1.5 (archives) requires Java 7
-  
Apache Commons CSV 1.4 (archives) requires Java 6
-  
Apache Commons CSV 1.3 (archives) requires Java 6
-  
Apache Commons CSV 1.2 (archives) requires Java 6
-  
Apache Commons CSV 1.1 (archives) requires Java 6
-  
Apache Commons CSV 1.0 (archives) requires Java 6
+  
Download Apache Commons CSV current (mirrors), requires Java 8 or above
+  
Download Apache Commons CSV archived releases
 
 

 See the
 Download Page
-for the latest releases.

+for the latest releases.
 
 

-Change reports are also available.
+Release History are also available.
 
 

 For previous releases, see the Apache Archive
 
 

-  Alternatively, you can pull it from a Maven repository:
-  
<dependency>
-    <groupId>org.apache.commons</groupId>
-    <artifactId>commons-csv</artifactId>
-    <version>1.8</version>
-</dependency>
-

-

-  For other dependency access methods, see Dependency Information
+  For dependency access methods, see Dependency Information
 
 
-
 

-  
The latest code can be checked out from our git repository at https://git-wip-us.apache.org/repos/asf/commons-csv.git.
+  
The latest code can be checked out from our git repository at https://gitbox.apache.org/repos/asf/commons-csv.git.
     You can build the component using Apache Maven using mvn clean package.
   
 
-
+

+  

+    Apache Commons CSV requires Java 8 or above.
+  
+  
+    
+      
+        
+        
+        
+      
+    
+    
+      
+        
+        
+        
+      
+    
+  
Commons CSV
Java
Android
1.10.0+
8
Android 7.0 (API level 24)
+
 

   

     The commons developer mailing list is the main channel of communication for contributors. Please remember that the lists are shared between all commons components, so prefix your email by [csv]. 
-  
You can also visit the #apache-commons IRC channel on irc.freenode.net or peruse JIRA. Specific links of interest for JIRA are:
+  
You can also peruse JIRA. Specific links of interest for JIRA are:
   

     
Ideas looking for code: Patch Needed
     
Issues with patches, looking for reviews: Review Patch
@@ -120,7 +103,6 @@ For previous releases, see the TagList report.

   
If you'd like to offer up pull requests via GitHub rather than applying patches to JIRA, we have a GitHub mirror. 
 
-
 

   

     The commons mailing lists act as the main support forum.
@@ -134,22 +116,18 @@ For previous releases, see the 
   
Commons CSV was started to unify a common and simple interface for reading and writing CSV files under an ASL license. It has been bootstrapped by a code donation from Netcetera in Switzerland. There are three pre-existing BSD compatible CSV parsers which this component will hopefully make redundant (authors willing): 

   

-    
Skife CSV
-    
Open CSV
-    
Genjava CSV
+    
Skife CSV (unsafe link as noted by browser https://kasparov.skife.org/csv/)
+    
Open CSV
+    
Genjava CSV
   
   
In addition to the code from Netcetera (org.apache.commons.csv), Martin van den Bemt has added an additional writer API. 
   
Other CSV implementations: 
   

-    
Super CSV
+    
Super CSV
   
 
-
-
 
 
diff --git a/src/site/xdoc/issue-tracking.xml b/src/site/xdoc/issue-tracking.xml
index c7edd21b1b..3aa64b4042 100644
--- a/src/site/xdoc/issue-tracking.xml
+++ b/src/site/xdoc/issue-tracking.xml
@@ -7,7 +7,7 @@ The ASF licenses this file to You 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
+     https://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,
@@ -41,10 +41,12 @@ limitations under the License.
  |                                                                      |
  +======================================================================+
 -->
-
+
   
     
-    Apache Commons Documentation Team
+    Apache Commons Team
   
   
 
@@ -64,6 +66,7 @@ limitations under the License.
       

       If you would like to report a bug, or raise an enhancement request with
       Apache Commons CSV please do the following:
+      
       

         
Search existing open bugs.
             If you find your issue listed then please add a comment with your details.
@@ -73,30 +76,29 @@ limitations under the License.
         
Submit either a bug report
             or enhancement request.
       
-      

 
       

       Please also remember these points:
+      
       

         
the more information you provide, the better we can help you
         
test cases are vital, particularly for any proposed enhancements
         
the developers of Apache Commons CSV are all unpaid volunteers
       
-      

 
       

-      For more information on subversion and creating patches see the
+      For more information on creating patches see the
       Apache Contributors Guide.
       
 
       

       You may also find these links useful:
+      
       

         
All Open Apache Commons CSV bugs
         
All Resolved Apache Commons CSV bugs
         
All Apache Commons CSV bugs
       
-      

     
   
 
diff --git a/src/site/xdoc/mail-lists.xml b/src/site/xdoc/mail-lists.xml
index e23c6fe81f..345cef8996 100644
--- a/src/site/xdoc/mail-lists.xml
+++ b/src/site/xdoc/mail-lists.xml
@@ -7,7 +7,7 @@ The ASF licenses this file to You 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
+     https://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,
@@ -39,10 +39,12 @@ limitations under the License.
  |                                                                      |
  +======================================================================+
 -->
-
+
   
     
-    Apache Commons Documentation Team
+    Apache Commons Team
   
   
 
@@ -53,15 +55,15 @@ limitations under the License.
         To make it easier for people to only read messages related to components they are interested in,
         the convention in Commons is to prefix the subject line of messages with the component's name,
         for example:
-        

-          
[csv] Problem with the ...
-        
       

+      

+        
[csv] Problem with the ...
+      
       

         Questions related to the usage of Apache Commons CSV should be posted to the
-        User List.
+        User List.
         

-        The Developer List
+        The Developer List
         is for questions and discussion related to the development of Apache Commons CSV.
         

         Please do not cross-post; developers are also subscribed to the user list.
@@ -70,8 +72,10 @@ limitations under the License.
         to subscribe.
       
       

-        Note: please don't send patches or attachments to any of the mailing lists.
+        Note: please don't send patches or attachments to any of the mailing lists;
+        most of the lists are set up to drop attachments.
         Patches are best handled via the Issue Tracking system.
+        If you have a GitHub account, most components also accept PRs (pull requests).
         Otherwise, please upload the file to a public server and include the URL in the mail.
       
     
@@ -105,10 +109,11 @@ limitations under the License.
           Subscribe
           Unsubscribe
           Post
-          mail-archives.apache.org
-          markmail.org

-              www.mail-archive.com

-              news.gmane.org
+          
+              lists.apache.org
+          
+          
+              www.mail-archive.com
           
         
 
@@ -123,10 +128,11 @@ limitations under the License.
           Subscribe
           Unsubscribe
           Post
-          mail-archives.apache.org
-          markmail.org

-              www.mail-archive.com

-              news.gmane.org
+          
+              lists.apache.org
+          
+          
+              www.mail-archive.com
           
         
 
@@ -141,8 +147,10 @@ limitations under the License.
           Subscribe
           Unsubscribe
           read only
-          mail-archives.apache.org
-          markmail.org

+          
+              lists.apache.org
+          
+          
               www.mail-archive.com
           
         
@@ -152,14 +160,16 @@ limitations under the License.
           
             Commons Commits List
             


-            Only for e-mails automatically generated by the source control sytem.
+            Only for e-mails automatically generated by the source control system.
             


           
           Subscribe
           Unsubscribe
           read only
-          mail-archives.apache.org
-          markmail.org

+          
+              lists.apache.org
+          
+          
               www.mail-archive.com
           
         
@@ -191,11 +201,11 @@ limitations under the License.
           Subscribe
           Unsubscribe
           read only
-          mail-archives.apache.org
-          markmail.org

-              old.nabble.com

-              www.mail-archive.com

-              news.gmane.org
+          
+              lists.apache.org
+          
+          
+              www.mail-archive.com
           
         
       
diff --git a/src/site/xdoc/security.xml b/src/site/xdoc/security.xml
new file mode 100644
index 0000000000..47edf5d116
--- /dev/null
+++ b/src/site/xdoc/security.xml
@@ -0,0 +1,56 @@
+
+
+
+  
+    
+    Apache Commons Team
+  
+  
+    

+      

+        For information about reporting or asking questions about security, please see
+        Apache Commons Security.
+      
+      
This page lists all security vulnerabilities fixed in released versions of this component. 
+      
+      
Please note that binary patches are never provided. If you need to apply a source code patch, use the building instructions for the component version
+        that you are using. 
+      
+      

+        If you need help on building this component or other help on following the instructions to mitigate the known vulnerabilities listed here, please send
+        your questions to the public
+        user mailing list.
+      
+      
If you have encountered an unlisted security vulnerability or other unexpected behavior that has security impact, or if the descriptions here are
+        incomplete, please report them privately to the Apache Security Team. Thank you. 
+      
+    
+    

+      
None.
+    
+    

+      

+      For information about safe deserialization, please see Safe Deserialization.
+      
+    
+  
+
\ No newline at end of file
diff --git a/src/site/xdoc/user-guide.xml b/src/site/xdoc/user-guide.xml
index 254b461729..d5a1f26850 100644
--- a/src/site/xdoc/user-guide.xml
+++ b/src/site/xdoc/user-guide.xml
@@ -7,7 +7,7 @@ The ASF licenses this file to You 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
+     https://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,
@@ -21,158 +21,6 @@ limitations under the License.
     Apache Commons Documentation Team
   
   
-    
-
-    
Apache Commons CSV User Guide
-
-    
-    
-
-    

-
-      Parsing files with Apache Commons CSV is relatively straight forward.
-      The CSVFormat class provides some commonly used CSV variants:
-
-      

-        
DEFAULT
Standard Comma Separated Value format, as for RFC4180 but allowing empty lines.
-        
EXCEL
The Microsoft Excel CSV format.
-        
INFORMIX_UNLOAD1.3
Informix UNLOAD format used by the UNLOAD TO file_name operation.
-        
INFORMIX_UNLOAD_CSV1.3
Informix CSV UNLOAD format used by the UNLOAD TO file_name operation (escaping is disabled.)
-        
MONGO_CSV1.7
MongoDB CSV format used by the mongoexport operation.
-        
MONGO_TSV1.7
MongoDB TSV format used by the mongoexport operation.
-        
MYSQL
The MySQL CSV format.
-        
ORACLE1.6
Default Oracle format used by the SQL*Loader utility.
-        
POSTGRESSQL_CSV1.5
Default PostgreSQL CSV format used by the COPY operation.
-        
POSTGRESSQL_TEXT1.5
Default PostgreSQL text format used by the COPY operation.
-        
RFC-4180
The RFC-4180 format defined by RFC-4180.
-        
TDF
A tab delimited format.
-      
-
-      
-        
To parse an Excel CSV file, write:
-        Reader in = new FileReader("path/to/file.csv");
-Iterable<CSVRecord> records = CSVFormat.EXCEL.parse(in);
-for (CSVRecord record : records) {
-    String lastName = record.get("Last Name");
-    String firstName = record.get("First Name");
-}
-        
-      
-      
-        

-          To handle files that start with a Byte Order Mark (BOM) like some Excel CSV files, you need an extra step to
-          deal with these optional bytes.
-          You can use the
-          
-            BOMInputStream
-          
-          class from
-          Apache Commons IO
-          for example:
-        
-        final URL url = ...;
-final Reader reader = new InputStreamReader(new BOMInputStream(url.openStream()), "UTF-8");
-final CSVParser parser = new CSVParser(reader, CSVFormat.EXCEL.withHeader());
-try {
-    for (final CSVRecord record : parser) {
-        final String string = record.get("SomeColumn");
-        ...
-    }
-} finally {
-    parser.close();
-    reader.close();
-}
-        
-        

-          You might find it handy to create something like this:
-        
-        /**
-* Creates a reader capable of handling BOMs.
-*/
-public InputStreamReader newReader(final InputStream inputStream) {
-    return new InputStreamReader(new BOMInputStream(inputStream), StandardCharsets.UTF_8);
-}
-        
-      
-    
-
-    

-
-      Apache Commons CSV provides several ways to access record values.
-      The simplest way is to access values by their index in the record.
-      However, columns in CSV files often have a name, for example: ID, CustomerNo, Birthday, etc.
-      The CSVFormat class provides an API for specifing these header names and CSVRecord on
-      the other hand has methods to access values by their corresponding header name.
-
-      
-        To access a record value by index, no special configuration of the CSVFormat is necessary:
-        Reader in = new FileReader("path/to/file.csv");
-Iterable<CSVRecord> records = CSVFormat.RFC4180.parse(in);
-for (CSVRecord record : records) {
-    String columnOne = record.get(0);
-    String columnTwo = record.get(1);
-}
-        
-      
-      
-        Indices may not be the most intuitive way to access record values. For this reason it is possible to
-        assign names to each column in the file:
-        Reader in = new FileReader("path/to/file.csv");
-Iterable<CSVRecord> records = CSVFormat.RFC4180.withHeader("ID", "CustomerNo", "Name").parse(in);
-for (CSVRecord record : records) {
-    String id = record.get("ID");
-    String customerNo = record.get("CustomerNo");
-    String name = record.get("Name");
-}
-        
-        Note that column values can still be accessed using their index.
-      
-      
-        Using String values all over the code to reference columns can be error prone. For this reason,
-        it is possible to define an enum to specify header names. Note that the enum constant names are
-        used to access column values. This may lead to enums constant names which do not follow the Java
-        coding standard of defining constants in upper case with underscores:
-        public enum Headers {
-    ID, CustomerNo, Name
-}
-Reader in = new FileReader("path/to/file.csv");
-Iterable<CSVRecord> records = CSVFormat.RFC4180.withHeader(Headers.class).parse(in);
-for (CSVRecord record : records) {
-    String id = record.get(Headers.ID);
-    String customerNo = record.get(Headers.CustomerNo);
-    String name = record.get(Headers.Name);
-}
-        
-        Again it is possible to access values by their index and by using a String (for example "CustomerNo").
-      
-      
-        Some CSV files define header names in their first record. If configured, Apache Commons CSV can parse
-        the header names from the first record:
-        Reader in = new FileReader("path/to/file.csv");
-Iterable<CSVRecord> records = CSVFormat.RFC4180.withFirstRecordAsHeader().parse(in);
-for (CSVRecord record : records) {
-    String id = record.get("ID");
-    String customerNo = record.get("CustomerNo");
-    String name = record.get("Name");
-}
-        
-        This will use the values from the first record as header names and skip the first record when iterating.
-      
-      
-        

-          To print a CSV file with headers, you specify the headers in the format:
-        
-        final Appendable out = ...;
-          final CSVPrinter printer = CSVFormat.DEFAULT.withHeader("H1", "H2").print(out)
-        
-        

-          To print a CSV file with JDBC column labels, you specify the ResultSet in the format:
-        
-        final ResultSet resultSet = ...;
-          final CSVPrinter printer = CSVFormat.DEFAULT.withHeader(resultSet).print(out)
-        
-      
-    
-    
+  
The User Guide migrated to the Javadoc.
   
 
diff --git a/src/test/java/org/apache/commons/csv/CSVBenchmark.java b/src/test/java/org/apache/commons/csv/CSVBenchmark.java
index 6d951baf45..b1be4ce095 100644
--- a/src/test/java/org/apache/commons/csv/CSVBenchmark.java
+++ b/src/test/java/org/apache/commons/csv/CSVBenchmark.java
@@ -1,33 +1,35 @@
 /*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *   https://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.
+ * 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 org.apache.commons.csv;
 
 import java.io.BufferedReader;
-import java.io.File;
-import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.Reader;
 import java.io.StringReader;
-import java.util.List;
+import java.nio.charset.StandardCharsets;
+import java.util.Iterator;
+import java.util.Scanner;
 import java.util.concurrent.TimeUnit;
 import java.util.zip.GZIPInputStream;
 
-import com.generationjava.io.CsvReader;
 import org.apache.commons.io.IOUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.openjdk.jmh.annotations.Benchmark;
@@ -45,6 +47,10 @@
 import org.supercsv.io.CsvListReader;
 import org.supercsv.prefs.CsvPreference;
 
+import com.generationjava.io.CsvReader;
+import com.opencsv.CSVParserBuilder;
+import com.opencsv.CSVReaderBuilder;
+
 @BenchmarkMode(Mode.AverageTime)
 @Fork(value = 1, jvmArgs = {"-server", "-Xms1024M", "-Xmx1024M"})
 @Threads(1)
@@ -54,157 +60,169 @@
 @State(Scope.Benchmark)
 public class CSVBenchmark {
 
+    private static final class CountingReaderCallback implements org.skife.csv.ReaderCallback {
+        public int count;
+
+        @Override
+        public void onRow(final String[] fields) {
+            count++;
+        }
+    }
+
     private String data;
 
+    private Reader getReader() {
+        return new StringReader(data);
+    }
+
     /**
      * Load the data in memory before running the benchmarks, this takes out IO from the results.
      */
     @Setup
     public void init() throws IOException {
-        final File file = new File("src/test/resources/perf/worldcitiespop.txt.gz");
-        final InputStream in = new GZIPInputStream(new FileInputStream(file));
-        this.data = IOUtils.toString(in, "ISO-8859-1");
-        in.close();
-    }
-
-    private BufferedReader getReader() {
-        return new BufferedReader(new StringReader(data));
-    }
-
-    @Benchmark
-    public int read(final Blackhole bh) throws Exception {
-        final BufferedReader in = getReader();
-        int count = 0;
-        String line;
-        while ((line = in.readLine()) != null) {
-            count++;
+        try (InputStream in = this.getClass().getClassLoader().getResourceAsStream("org/apache/commons/csv/perf/worldcitiespop.txt.gz");
+                InputStream gzin = new GZIPInputStream(in, 8192)) {
+            this.data = IOUtils.toString(gzin, StandardCharsets.ISO_8859_1);
         }
-
-        bh.consume(count);
-        in.close();
-        return count;
-    }
-
-    @Benchmark
-    public int split(final Blackhole bh) throws Exception {
-        final BufferedReader in = getReader();
-        int count = 0;
-        String line;
-        while ((line = in.readLine()) != null) {
-            final String[] values = StringUtils.split(line, ',');
-            count += values.length;
-        }
-
-        bh.consume(count);
-        in.close();
-        return count;
     }
 
     @Benchmark
     public int parseCommonsCSV(final Blackhole bh) throws Exception {
-        final BufferedReader in = getReader();
-
-        final CSVFormat format = CSVFormat.DEFAULT.withHeader();
-
         int count = 0;
-        for (final CSVRecord record : format.parse(in)) {
-            count++;
+
+        try (Reader in = getReader()) {
+            final CSVFormat format = CSVFormat.Builder.create().setSkipHeaderRecord(true).build();
+            final Iterator iter = format.parse(in).iterator();
+            while (iter.hasNext()) {
+                count++;
+                iter.next();
+            }
         }
 
         bh.consume(count);
-        in.close();
         return count;
     }
 
     @Benchmark
     public int parseGenJavaCSV(final Blackhole bh) throws Exception {
-        final BufferedReader in = getReader();
-
-        final CsvReader reader = new CsvReader(in);
-        reader.setFieldDelimiter(',');
-
         int count = 0;
-        String[] record = null;
-        while ((record = reader.readLine()) != null) {
-            count++;
+
+        try (Reader in = getReader()) {
+            final CsvReader reader = new CsvReader(in);
+            reader.setFieldDelimiter(',');
+            while (reader.readLine() != null) {
+                count++;
+            }
         }
 
         bh.consume(count);
-        in.close();
         return count;
     }
 
     @Benchmark
     public int parseJavaCSV(final Blackhole bh) throws Exception {
-        final BufferedReader in = getReader();
-
-        final com.csvreader.CsvReader reader = new com.csvreader.CsvReader(in, ',');
-        reader.setRecordDelimiter('\n');
-
         int count = 0;
-        while (reader.readRecord()) {
-            count++;
+
+        try (Reader in = getReader()) {
+            final com.csvreader.CsvReader reader = new com.csvreader.CsvReader(in, ',');
+            reader.setRecordDelimiter('\n');
+            while (reader.readRecord()) {
+                count++;
+            }
         }
 
         bh.consume(count);
-        in.close();
         return count;
     }
 
     @Benchmark
     public int parseOpenCSV(final Blackhole bh) throws Exception {
-        final BufferedReader in = getReader();
+        int count = 0;
 
-        final com.opencsv.CSVReader reader = new com.opencsv.CSVReader(in, ',');
+        final com.opencsv.CSVParser parser = new CSVParserBuilder()
+          .withSeparator(',').withIgnoreQuotations(true).build();
 
-        int count = 0;
-        while (reader.readNext() != null) {
-            count++;
+        try (Reader in = getReader()) {
+            final com.opencsv.CSVReader reader = new CSVReaderBuilder(in).withSkipLines(1).withCSVParser(parser).build();
+            while (reader.readNext() != null) {
+                count++;
+            }
         }
 
         bh.consume(count);
-        in.close();
         return count;
     }
 
     @Benchmark
     public int parseSkifeCSV(final Blackhole bh) throws Exception {
-        final BufferedReader in = getReader();
-
         final org.skife.csv.CSVReader reader = new org.skife.csv.SimpleReader();
         reader.setSeperator(',');
-
         final CountingReaderCallback callback = new CountingReaderCallback();
-        reader.parse(in, callback);
+
+        try (Reader in = getReader()) {
+          reader.parse(in, callback);
+        }
 
         bh.consume(callback);
-        in.close();
         return callback.count;
     }
 
-    private static class CountingReaderCallback implements org.skife.csv.ReaderCallback {
-        public int count = 0;
+    @Benchmark
+    public int parseSuperCSV(final Blackhole bh) throws Exception {
+        int count = 0;
 
-        @Override
-        public void onRow(final String[] fields) {
-            count++;
+        try (CsvListReader reader = new CsvListReader(getReader(), CsvPreference.STANDARD_PREFERENCE)) {
+            while (reader.read() != null) {
+                count++;
+            }
         }
+
+        bh.consume(count);
+        return count;
     }
 
     @Benchmark
-    public int parseSuperCSV(final Blackhole bh) throws Exception {
-        final BufferedReader in = getReader();
+    public int read(final Blackhole bh) throws Exception {
+        int count = 0;
+
+        try (BufferedReader reader = new BufferedReader(getReader())) {
+            while (reader.readLine() != null) {
+              count++;
+            }
+        }
 
-        final CsvListReader reader = new CsvListReader(in, CsvPreference.STANDARD_PREFERENCE);
+        bh.consume(count);
+        return count;
+    }
 
+    @Benchmark
+    public int scan(final Blackhole bh) throws Exception {
         int count = 0;
-        List record = null;
-        while ((record = reader.read()) != null) {
-            count++;
+
+        try (Scanner scanner = new Scanner(getReader())) {
+            while (scanner.hasNextLine()) {
+              scanner.nextLine();
+              count++;
+            }
         }
 
         bh.consume(count);
-        in.close();
         return count;
     }
+
+    @Benchmark
+    public int split(final Blackhole bh) throws Exception {
+      int count = 0;
+
+      try (BufferedReader reader = new BufferedReader(getReader())) {
+          String line;
+          while ((line = reader.readLine()) != null) {
+            final String[] values = StringUtils.split(line, ',');
+            count += values.length;
+          }
+      }
+
+      bh.consume(count);
+      return count;
+    }
 }
diff --git a/src/test/java/org/apache/commons/csv/CSVDuplicateHeaderTest.java b/src/test/java/org/apache/commons/csv/CSVDuplicateHeaderTest.java
new file mode 100644
index 0000000000..2f518a1206
--- /dev/null
+++ b/src/test/java/org/apache/commons/csv/CSVDuplicateHeaderTest.java
@@ -0,0 +1,339 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *
+ *   https://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 org.apache.commons.csv;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+/**
+ * Tests parsing of duplicate column names in a CSV header.
+ * The test verifies that headers are consistently handled by CSVFormat and CSVParser.
+ */
+class CSVDuplicateHeaderTest {
+
+    /**
+     * Return test cases for duplicate header data for use in CSVFormat.
+     * 

+     * This filters the parsing test data to all cases where the allow missing column
+     * names flag is true and ignore header case is false: these flags are exclusively for parsing.
+     * CSVFormat validation applies to both parsing and writing and thus validation
+     * is less strict and behaves as if the allow missing column names constraint and
+     * the ignore header case behavior are absent.
+     * The filtered data is then returned with the parser flags set to both true and false
+     * for each test case.
+     * 
+     *
+     * @return the stream of arguments
+     */
+    static Stream duplicateHeaderAllowsMissingColumnsNamesData() {
+        return duplicateHeaderData()
+            .filter(arg -> Boolean.TRUE.equals(arg.get()[1]) && Boolean.FALSE.equals(arg.get()[2]))
+            .flatMap(arg -> {
+                // Return test case with flags as all true/false combinations
+                final Object[][] data = new Object[4][];
+                final Boolean[] flags = {Boolean.TRUE, Boolean.FALSE};
+                int i = 0;
+                for (final Boolean a : flags) {
+                    for (final Boolean b : flags) {
+                        data[i] = arg.get().clone();
+                        data[i][1] = a;
+                        data[i][2] = b;
+                        i++;
+                    }
+                }
+                return Arrays.stream(data).map(Arguments::of);
+            });
+    }
+
+    /**
+     * Return test cases for duplicate header data for use in parsing (CSVParser). Uses the order:
+     * 
+     * DuplicateHeaderMode duplicateHeaderMode
+     * boolean allowMissingColumnNames
+     * String[] headers
+     * boolean valid
+     * 
+     *
+     * @return the stream of arguments
+     */
+    static Stream duplicateHeaderData() {
+        return Stream.of(
+            // Any combination with a valid header
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    false, false, new String[] {"A", "B"}, true),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, false, false, new String[] {"A", "B"}, true),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   false, false, new String[] {"A", "B"}, true),
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    true,  false, new String[] {"A", "B"}, true),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, true,  false, new String[] {"A", "B"}, true),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   true,  false, new String[] {"A", "B"}, true),
+
+            // Any combination with a valid header including empty
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    false, false, new String[] {"A", ""}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, false, false, new String[] {"A", ""}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   false, false, new String[] {"A", ""}, false),
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    true,  false, new String[] {"A", ""}, true),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, true,  false, new String[] {"A", ""}, true),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   true,  false, new String[] {"A", ""}, true),
+
+            // Any combination with a valid header including blank (1 space)
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    false, false, new String[] {"A", " "}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, false, false, new String[] {"A", " "}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   false, false, new String[] {"A", " "}, false),
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    true,  false, new String[] {"A", " "}, true),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, true,  false, new String[] {"A", " "}, true),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   true,  false, new String[] {"A", " "}, true),
+
+            // Any combination with a valid header including null
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    false, false, new String[] {"A", null}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, false, false, new String[] {"A", null}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   false, false, new String[] {"A", null}, false),
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    true,  false, new String[] {"A", null}, true),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, true,  false, new String[] {"A", null}, true),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   true,  false, new String[] {"A", null}, true),
+
+            // Duplicate non-empty names
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    false, false, new String[] {"A", "A"}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, false, false, new String[] {"A", "A"}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   false, false, new String[] {"A", "A"}, true),
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    true,  false, new String[] {"A", "A"}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, true,  false, new String[] {"A", "A"}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   true,  false, new String[] {"A", "A"}, true),
+
+            // Duplicate empty names
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    false, false, new String[] {"", ""}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, false, false, new String[] {"", ""}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   false, false, new String[] {"", ""}, false),
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    true,  false, new String[] {"", ""}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, true,  false, new String[] {"", ""}, true),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   true,  false, new String[] {"", ""}, true),
+
+            // Duplicate blank names (1 space)
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    false, false, new String[] {" ", " "}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, false, false, new String[] {" ", " "}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   false, false, new String[] {" ", " "}, false),
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    true,  false, new String[] {" ", " "}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, true,  false, new String[] {" ", " "}, true),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   true,  false, new String[] {" ", " "}, true),
+
+            // Duplicate blank names (3 spaces)
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    false, false, new String[] {"   ", "   "}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, false, false, new String[] {"   ", "   "}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   false, false, new String[] {"   ", "   "}, false),
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    true,  false, new String[] {"   ", "   "}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, true,  false, new String[] {"   ", "   "}, true),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   true,  false, new String[] {"   ", "   "}, true),
+
+            // Duplicate null names
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    false, false, new String[] {null, null}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, false, false, new String[] {null, null}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   false, false, new String[] {null, null}, false),
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    true,  false, new String[] {null, null}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, true,  false, new String[] {null, null}, true),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   true,  false, new String[] {null, null}, true),
+
+            // Duplicate blank names (1+3 spaces)
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    false, false, new String[] {" ", "   "}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, false, false, new String[] {" ", "   "}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   false, false, new String[] {" ", "   "}, false),
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    true,  false, new String[] {" ", "   "}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, true,  false, new String[] {" ", "   "}, true),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   true,  false, new String[] {" ", "   "}, true),
+
+            // Duplicate blank names and null names
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    false, false, new String[] {" ", null}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, false, false, new String[] {" ", null}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   false, false, new String[] {" ", null}, false),
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    true,  false, new String[] {" ", null}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, true,  false, new String[] {" ", null}, true),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   true,  false, new String[] {" ", null}, true),
+
+            // Duplicate non-empty and empty names
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    false, false, new String[] {"A", "A", "", ""}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, false, false, new String[] {"A", "A", "", ""}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   false, false, new String[] {"A", "A", "", ""}, false),
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    true,  false, new String[] {"A", "A", "", ""}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, true,  false, new String[] {"A", "A", "", ""}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   true,  false, new String[] {"A", "A", "", ""}, true),
+
+            // Non-duplicate non-empty and duplicate empty names
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    false, false, new String[] {"A", "B", "", ""}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, false, false, new String[] {"A", "B", "", ""}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   false, false, new String[] {"A", "B", "", ""}, false),
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    true,  false, new String[] {"A", "B", "", ""}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, true,  false, new String[] {"A", "B", "", ""}, true),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   true,  false, new String[] {"A", "B", "", ""}, true),
+
+            // Duplicate non-empty and blank names
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    false, false, new String[] {"A", "A", " ", " "}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, false, false, new String[] {"A", "A", " ", " "}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   false, false, new String[] {"A", "A", " ", " "}, false),
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    true,  false, new String[] {"A", "A", " ", " "}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, true,  false, new String[] {"A", "A", " ", " "}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   true,  false, new String[] {"A", "A", " ", " "}, true),
+
+            // Duplicate non-empty and null names
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    false, false, new String[] {"A", "A", null, null}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, false, false, new String[] {"A", "A", null, null}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   false, false, new String[] {"A", "A", null, null}, false),
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    true,  false, new String[] {"A", "A", null, null}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, true,  false, new String[] {"A", "A", null, null}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   true,  false, new String[] {"A", "A", null, null}, true),
+
+            // Duplicate blank names
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    false, false, new String[] {"A", "", ""}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, false, false, new String[] {"A", "", ""}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   false, false, new String[] {"A", "", ""}, false),
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    true,  false, new String[] {"A", "", ""}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, true,  false, new String[] {"A", "", ""}, true),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   true,  false, new String[] {"A", "", ""}, true),
+
+            // Duplicate null names
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    false, false, new String[] {"A", null, null}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, false, false, new String[] {"A", null, null}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   false, false, new String[] {"A", null, null}, false),
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    true,  false, new String[] {"A", null, null}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, true,  false, new String[] {"A", null, null}, true),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   true,  false, new String[] {"A", null, null}, true),
+
+            // Duplicate blank names (1+3 spaces)
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    false, false, new String[] {"A", " ", "   "}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, false, false, new String[] {"A", " ", "   "}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   false, false, new String[] {"A", " ", "   "}, false),
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    true,  false, new String[] {"A", " ", "   "}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, true,  false, new String[] {"A", " ", "   "}, true),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   true,  false, new String[] {"A", " ", "   "}, true),
+
+            // Duplicate names (case insensitive)
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    false, true , new String[] {"A", "a"}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, false, true , new String[] {"A", "a"}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   false, true , new String[] {"A", "a"}, true),
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    true,  true , new String[] {"A", "a"}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, true,  true , new String[] {"A", "a"}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   true,  true , new String[] {"A", "a"}, true),
+
+            // Duplicate non-empty (case insensitive) and empty names
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    false, true, new String[] {"A", "a", "", ""}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, false, true, new String[] {"A", "a", "", ""}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   false, true, new String[] {"A", "a", "", ""}, false),
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    true,  true, new String[] {"A", "a", "", ""}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, true,  true, new String[] {"A", "a", "", ""}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   true,  true, new String[] {"A", "a", "", ""}, true),
+
+            // Duplicate non-empty (case insensitive) and blank names
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    false, true, new String[] {"A", "a", " ", " "}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, false, true, new String[] {"A", "a", " ", " "}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   false, true, new String[] {"A", "a", " ", " "}, false),
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    true,  true, new String[] {"A", "a", " ", " "}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, true,  true, new String[] {"A", "a", " ", " "}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   true,  true, new String[] {"A", "a", " ", " "}, true),
+
+            // Duplicate non-empty (case insensitive) and null names
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    false, true, new String[] {"A", "a", null, null}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, false, true, new String[] {"A", "a", null, null}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   false, true, new String[] {"A", "a", null, null}, false),
+            Arguments.of(DuplicateHeaderMode.DISALLOW,    true,  true, new String[] {"A", "a", null, null}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_EMPTY, true,  true, new String[] {"A", "a", null, null}, false),
+            Arguments.of(DuplicateHeaderMode.ALLOW_ALL,   true,  true, new String[] {"A", "a", null, null}, true)
+        );
+    }
+
+    /**
+     * Tests duplicate headers with the CSVFormat.
+     *
+     * @param duplicateHeaderMode the duplicate header mode
+     * @param allowMissingColumnNames the allow missing column names flag (only used for parsing)
+     * @param ignoreHeaderCase the ignore header case flag (only used for parsing)
+     * @param headers the headers
+     * @param valid true if the settings are expected to be valid, otherwise expect a IllegalArgumentException
+     */
+    @ParameterizedTest
+    @MethodSource(value = {"duplicateHeaderAllowsMissingColumnsNamesData"})
+    void testCSVFormat(final DuplicateHeaderMode duplicateHeaderMode,
+                              final boolean allowMissingColumnNames,
+                              final boolean ignoreHeaderCase,
+                              final String[] headers,
+                              final boolean valid) {
+        final CSVFormat.Builder builder =
+            CSVFormat.DEFAULT.builder()
+                             .setDuplicateHeaderMode(duplicateHeaderMode)
+                             .setAllowMissingColumnNames(allowMissingColumnNames)
+                             .setIgnoreHeaderCase(ignoreHeaderCase)
+                             .setHeader(headers);
+        if (valid) {
+            final CSVFormat format = builder.get();
+            assertEquals(duplicateHeaderMode, format.getDuplicateHeaderMode(), "DuplicateHeaderMode");
+            assertEquals(allowMissingColumnNames, format.getAllowMissingColumnNames(), "AllowMissingColumnNames");
+            assertArrayEquals(headers, format.getHeader(), "Header");
+        } else {
+            assertThrows(IllegalArgumentException.class, builder::get);
+        }
+    }
+
+    /**
+     * Tests duplicate headers with the CSVParser.
+     *
+     * @param duplicateHeaderMode the duplicate header mode
+     * @param allowMissingColumnNames the allow missing column names flag (only used for parsing)
+     * @param ignoreHeaderCase the ignore header case flag (only used for parsing)
+     * @param headers the headers (joined with the CSVFormat delimiter to create a string input)
+     * @param valid true if the settings are expected to be valid, otherwise expect a IllegalArgumentException
+     * @throws IOException Signals that an I/O exception has occurred.
+     */
+    @ParameterizedTest
+    @MethodSource(value = {"duplicateHeaderData"})
+    void testCSVParser(final DuplicateHeaderMode duplicateHeaderMode,
+                              final boolean allowMissingColumnNames,
+                              final boolean ignoreHeaderCase,
+                              final String[] headers,
+            final boolean valid) throws IOException {
+        // @formatter:off
+        final CSVFormat format = CSVFormat.DEFAULT.builder()
+                .setDuplicateHeaderMode(duplicateHeaderMode)
+                .setAllowMissingColumnNames(allowMissingColumnNames)
+                .setIgnoreHeaderCase(ignoreHeaderCase)
+                .setNullString("NULL")
+                .setHeader()
+                .get();
+        // @formatter:on
+        final String input = Arrays.stream(headers)
+                .map(s -> s == null ? format.getNullString() : s)
+                .collect(Collectors.joining(format.getDelimiterString()));
+        // @formatter:off
+        if (valid) {
+            try (CSVParser parser = CSVParser.parse(input, format)) {
+                // Parser ignores null headers
+                final List expected = Arrays.stream(headers).filter(s -> s != null).collect(Collectors.toList());
+                assertEquals(expected, parser.getHeaderNames(), "HeaderNames");
+            }
+        } else {
+            assertThrows(IllegalArgumentException.class, () -> CSVParser.parse(input, format));
+        }
+    }
+}
diff --git a/src/test/java/org/apache/commons/csv/CSVFileParserTest.java b/src/test/java/org/apache/commons/csv/CSVFileParserTest.java
index d71007bb40..e74d0e6884 100644
--- a/src/test/java/org/apache/commons/csv/CSVFileParserTest.java
+++ b/src/test/java/org/apache/commons/csv/CSVFileParserTest.java
@@ -1,18 +1,20 @@
 /*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *   https://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.
+ * 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 org.apache.commons.csv;
@@ -25,10 +27,10 @@
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileReader;
-import java.io.FilenameFilter;
 import java.io.IOException;
 import java.net.URL;
 import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
 import java.util.Arrays;
 import java.util.stream.Stream;
 
@@ -38,9 +40,14 @@
 /**
  * Parse tests using test files
  */
-public class CSVFileParserTest {
+class CSVFileParserTest {
 
-    private static final File BASE = new File("src/test/resources/org/apache/commons/csv/CSVFileParser");
+    private static final File BASE_DIR = new File("src/test/resources/org/apache/commons/csv/CSVFileParser");
+
+    public static Stream generateData() {
+        final File[] files = BASE_DIR.listFiles((dir, name) -> name.startsWith("test") && name.endsWith(".txt"));
+        return files != null ? Stream.of(files) : Stream.empty();
+    }
 
     private String readTestData(final BufferedReader reader) throws IOException {
         String line;
@@ -50,20 +57,11 @@ private String readTestData(final BufferedReader reader) throws IOException {
         return line;
     }
 
-    public static Stream generateData() {
-        final FilenameFilter fileNameFilter = (dir, name) -> name.startsWith("test") && name.endsWith(".txt");
-        final File[] files = BASE.listFiles(fileNameFilter);
-        if (files != null) {
-            return Arrays.stream(files);
-        }
-        return Stream.empty();
-    }
-
     @ParameterizedTest
     @MethodSource("generateData")
-    public void testCSVFile(final File testFile) throws Exception {
-        try (FileReader fr = new FileReader(testFile); BufferedReader testData = new BufferedReader(fr)) {
-            String line = readTestData(testData);
+    void testCSVFile(final File testFile) throws Exception {
+        try (FileReader fr = new FileReader(testFile); BufferedReader testDataReader = new BufferedReader(fr)) {
+            String line = readTestData(testDataReader);
             assertNotNull("file must contain config line", line);
             final String[] split = line.split(" ");
             assertTrue(split.length >= 1, testFile.getName() + " require 1 param");
@@ -72,25 +70,25 @@ public void testCSVFile(final File testFile) throws Exception {
             boolean checkComments = false;
             for (int i = 1; i < split.length; i++) {
                 final String option = split[i];
-                final String[] option_parts = option.split("=", 2);
-                if ("IgnoreEmpty".equalsIgnoreCase(option_parts[0])) {
-                    format = format.withIgnoreEmptyLines(Boolean.parseBoolean(option_parts[1]));
-                } else if ("IgnoreSpaces".equalsIgnoreCase(option_parts[0])) {
-                    format = format.withIgnoreSurroundingSpaces(Boolean.parseBoolean(option_parts[1]));
-                } else if ("CommentStart".equalsIgnoreCase(option_parts[0])) {
-                    format = format.withCommentMarker(option_parts[1].charAt(0));
-                } else if ("CheckComments".equalsIgnoreCase(option_parts[0])) {
+                final String[] optionParts = option.split("=", 2);
+                if ("IgnoreEmpty".equalsIgnoreCase(optionParts[0])) {
+                    format = format.withIgnoreEmptyLines(Boolean.parseBoolean(optionParts[1]));
+                } else if ("IgnoreSpaces".equalsIgnoreCase(optionParts[0])) {
+                    format = format.withIgnoreSurroundingSpaces(Boolean.parseBoolean(optionParts[1]));
+                } else if ("CommentStart".equalsIgnoreCase(optionParts[0])) {
+                    format = format.withCommentMarker(optionParts[1].charAt(0));
+                } else if ("CheckComments".equalsIgnoreCase(optionParts[0])) {
                     checkComments = true;
                 } else {
                     fail(testFile.getName() + " unexpected option: " + option);
                 }
             }
-            line = readTestData(testData); // get string version of format
+            line = readTestData(testDataReader); // get string version of format
             assertEquals(line, format.toString(), testFile.getName() + " Expected format ");
 
             // Now parse the file and compare against the expected results
             // We use a buffered reader internally so no need to create one here.
-            try (final CSVParser parser = CSVParser.parse(new File(BASE, split[0]), Charset.defaultCharset(), format)) {
+            try (CSVParser parser = CSVParser.parse(new File(BASE_DIR, split[0]), Charset.defaultCharset(), format)) {
                 for (final CSVRecord record : parser) {
                     String parsed = Arrays.toString(record.values());
                     final String comment = record.getComment();
@@ -98,7 +96,7 @@ public void testCSVFile(final File testFile) throws Exception {
                         parsed += "#" + comment.replace("\n", "\\n");
                     }
                     final int count = record.size();
-                    assertEquals(readTestData(testData), count + ":" + parsed, testFile.getName());
+                    assertEquals(readTestData(testDataReader), count + ":" + parsed, testFile.getName());
                 }
             }
         }
@@ -106,7 +104,7 @@ public void testCSVFile(final File testFile) throws Exception {
 
     @ParameterizedTest
     @MethodSource("generateData")
-    public void testCSVUrl(final File testFile) throws Exception {
+    void testCSVUrl(final File testFile) throws Exception {
         try (FileReader fr = new FileReader(testFile); BufferedReader testData = new BufferedReader(fr)) {
             String line = readTestData(testData);
             assertNotNull("file must contain config line", line);
@@ -117,14 +115,14 @@ public void testCSVUrl(final File testFile) throws Exception {
             boolean checkComments = false;
             for (int i = 1; i < split.length; i++) {
                 final String option = split[i];
-                final String[] option_parts = option.split("=", 2);
-                if ("IgnoreEmpty".equalsIgnoreCase(option_parts[0])) {
-                    format = format.withIgnoreEmptyLines(Boolean.parseBoolean(option_parts[1]));
-                } else if ("IgnoreSpaces".equalsIgnoreCase(option_parts[0])) {
-                    format = format.withIgnoreSurroundingSpaces(Boolean.parseBoolean(option_parts[1]));
-                } else if ("CommentStart".equalsIgnoreCase(option_parts[0])) {
-                    format = format.withCommentMarker(option_parts[1].charAt(0));
-                } else if ("CheckComments".equalsIgnoreCase(option_parts[0])) {
+                final String[] optionParts = option.split("=", 2);
+                if ("IgnoreEmpty".equalsIgnoreCase(optionParts[0])) {
+                    format = format.withIgnoreEmptyLines(Boolean.parseBoolean(optionParts[1]));
+                } else if ("IgnoreSpaces".equalsIgnoreCase(optionParts[0])) {
+                    format = format.withIgnoreSurroundingSpaces(Boolean.parseBoolean(optionParts[1]));
+                } else if ("CommentStart".equalsIgnoreCase(optionParts[0])) {
+                    format = format.withCommentMarker(optionParts[1].charAt(0));
+                } else if ("CheckComments".equalsIgnoreCase(optionParts[0])) {
                     checkComments = true;
                 } else {
                     fail(testFile.getName() + " unexpected option: " + option);
@@ -135,7 +133,7 @@ public void testCSVUrl(final File testFile) throws Exception {
 
             // Now parse the file and compare against the expected results
             final URL resource = ClassLoader.getSystemResource("org/apache/commons/csv/CSVFileParser/" + split[0]);
-            try (final CSVParser parser = CSVParser.parse(resource, Charset.forName("UTF-8"), format)) {
+            try (CSVParser parser = CSVParser.parse(resource, StandardCharsets.UTF_8, format)) {
                 for (final CSVRecord record : parser) {
                     String parsed = Arrays.toString(record.values());
                     final String comment = record.getComment();
diff --git a/src/test/java/org/apache/commons/csv/CSVFormatPredefinedTest.java b/src/test/java/org/apache/commons/csv/CSVFormatPredefinedTest.java
index a3e6ecd049..dad08cdb1d 100644
--- a/src/test/java/org/apache/commons/csv/CSVFormatPredefinedTest.java
+++ b/src/test/java/org/apache/commons/csv/CSVFormatPredefinedTest.java
@@ -1,18 +1,20 @@
 /*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *   https://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.
+ * 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 org.apache.commons.csv;
@@ -24,7 +26,7 @@
 /**
  * Tests {@link CSVFormat.Predefined}.
  */
-public class CSVFormatPredefinedTest {
+class CSVFormatPredefinedTest {
 
     private void test(final CSVFormat format, final String enumName) {
         assertEquals(format, CSVFormat.Predefined.valueOf(enumName).getFormat());
@@ -32,52 +34,52 @@ private void test(final CSVFormat format, final String enumName) {
     }
 
     @Test
-    public void testDefault() {
+    void testDefault() {
         test(CSVFormat.DEFAULT, "Default");
     }
 
     @Test
-    public void testExcel() {
+    void testExcel() {
         test(CSVFormat.EXCEL, "Excel");
     }
 
     @Test
-    public void testMySQL() {
-        test(CSVFormat.MYSQL, "MySQL");
+    void testMongoDbCsv() {
+        test(CSVFormat.MONGODB_CSV, "MongoDBCsv");
     }
 
     @Test
-    public void testOracle() {
-        test(CSVFormat.ORACLE, "Oracle");
+    void testMongoDbTsv() {
+        test(CSVFormat.MONGODB_TSV, "MongoDBTsv");
     }
 
     @Test
-    public void testPostgreSqlCsv() {
-        test(CSVFormat.POSTGRESQL_CSV, "PostgreSQLCsv");
+    void testMySQL() {
+        test(CSVFormat.MYSQL, "MySQL");
     }
 
     @Test
-    public void testMongoDbCsv() {
-        test(CSVFormat.MONGODB_CSV, "MongoDBCsv");
+    void testOracle() {
+        test(CSVFormat.ORACLE, "Oracle");
     }
 
     @Test
-    public void testMongoDbTsv() {
-        test(CSVFormat.MONGODB_TSV, "MongoDBTsv");
+    void testPostgreSqlCsv() {
+        test(CSVFormat.POSTGRESQL_CSV, "PostgreSQLCsv");
     }
 
     @Test
-    public void testPostgreSqlText() {
+    void testPostgreSqlText() {
         test(CSVFormat.POSTGRESQL_TEXT, "PostgreSQLText");
     }
 
     @Test
-    public void testRFC4180() {
+    void testRFC4180() {
         test(CSVFormat.RFC4180, "RFC4180");
     }
 
     @Test
-    public void testTDF() {
+    void testTDF() {
         test(CSVFormat.TDF, "TDF");
     }
 }
diff --git a/src/test/java/org/apache/commons/csv/CSVFormatTest.java b/src/test/java/org/apache/commons/csv/CSVFormatTest.java
index ded2ab9f2a..ed20898de9 100644
--- a/src/test/java/org/apache/commons/csv/CSVFormatTest.java
+++ b/src/test/java/org/apache/commons/csv/CSVFormatTest.java
@@ -1,18 +1,20 @@
 /*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *   https://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.
+ * 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 org.apache.commons.csv;
@@ -21,10 +23,10 @@
 import static org.apache.commons.csv.Constants.CR;
 import static org.apache.commons.csv.Constants.CRLF;
 import static org.apache.commons.csv.Constants.LF;
-
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertNotSame;
 import static org.junit.jupiter.api.Assertions.assertNull;
@@ -34,23 +36,25 @@
 
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
+import java.io.IOException;
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.io.Reader;
-import java.io.IOException;
 import java.io.StringReader;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.Arrays;
+import java.util.Objects;
 
+import org.apache.commons.csv.CSVFormat.Builder;
 import org.junit.jupiter.api.Test;
 
 /**
  * Tests {@link CSVFormat}.
  */
-public class CSVFormatTest {
+class CSVFormatTest {
 
     public enum EmptyEnum {
         // empty enum.
@@ -60,16 +64,16 @@ public enum Header {
         Name, Email, Phone
     }
 
-    private static void assertNotEquals(final Object right, final Object left) {
-        assertFalse(right.equals(left));
-        assertFalse(left.equals(right));
+    private static void assertNotEqualsFlip(final Object right, final Object left) {
+        assertNotEquals(right, left);
+        assertNotEquals(left, right);
     }
 
     private static CSVFormat copy(final CSVFormat format) {
-        return format.withDelimiter(format.getDelimiter());
+        return format.builder().setDelimiter(format.getDelimiter()).get();
     }
 
-    private void assertNotEquals(final String name, final String type, final Object left, final Object right) {
+    private void assertNotEqualsHash(final String name, final String type, final Object left, final Object right) {
         if (left.equals(right) || right.equals(left)) {
             fail("Objects must not compare equal for " + name + "(" + type + ")");
         }
@@ -79,17 +83,74 @@ private void assertNotEquals(final String name, final String type, final Object
     }
 
     @Test
-    public void testDelimiterSameAsCommentStartThrowsException() {
+    void testBuildVsGet() {
+        final Builder builder = CSVFormat.DEFAULT.builder();
+        assertNotSame(builder.get(), builder.build());
+    }
+
+    @Test
+    void testDelimiterCharLineBreakCrThrowsException1() {
+        assertThrows(IllegalArgumentException.class, () -> CSVFormat.DEFAULT.builder().setDelimiter(Constants.CR).get());
+    }
+
+    @Test
+    void testDelimiterCharLineBreakLfThrowsException1() {
+        assertThrows(IllegalArgumentException.class, () -> CSVFormat.DEFAULT.builder().setDelimiter(Constants.LF).get());
+    }
+
+    @Test
+    void testDelimiterEmptyStringThrowsException1() {
+        assertThrows(IllegalArgumentException.class, () -> CSVFormat.DEFAULT.builder().setDelimiter("").get());
+    }
+
+    @SuppressWarnings("deprecation")
+    @Test
+    void testDelimiterSameAsCommentStartThrowsException_Deprecated() {
         assertThrows(IllegalArgumentException.class, () -> CSVFormat.DEFAULT.withDelimiter('!').withCommentMarker('!'));
     }
 
     @Test
-    public void testDelimiterSameAsEscapeThrowsException() {
+    void testDelimiterSameAsCommentStartThrowsException1() {
+        assertThrows(IllegalArgumentException.class, () -> CSVFormat.DEFAULT.builder().setDelimiter('!').setCommentMarker('!').get());
+    }
+
+    @SuppressWarnings("deprecation")
+    @Test
+    void testDelimiterSameAsEscapeThrowsException_Deprecated() {
         assertThrows(IllegalArgumentException.class, () -> CSVFormat.DEFAULT.withDelimiter('!').withEscape('!'));
     }
 
     @Test
-    public void testDuplicateHeaderElements() {
+    void testDelimiterSameAsEscapeThrowsException1() {
+        assertThrows(IllegalArgumentException.class, () -> CSVFormat.DEFAULT.builder().setDelimiter('!').setEscape('!').get());
+    }
+
+    @Test
+    void testDelimiterSameAsRecordSeparatorThrowsException() {
+        assertThrows(IllegalArgumentException.class, () -> CSVFormat.newFormat(CR));
+    }
+
+    @Test
+    void testDelimiterStringLineBreakCrThrowsException1() {
+        assertThrows(IllegalArgumentException.class, () -> CSVFormat.DEFAULT.builder().setDelimiter(String.valueOf(Constants.CR)).get());
+    }
+
+    @Test
+    void testDelimiterStringLineBreakLfThrowsException1() {
+        assertThrows(IllegalArgumentException.class, () -> CSVFormat.DEFAULT.builder().setDelimiter(String.valueOf(Constants.LF)).get());
+    }
+
+    @Test
+    void testDuplicateHeaderElements() {
+        final String[] header = { "A", "A" };
+        final CSVFormat format = CSVFormat.DEFAULT.builder().setHeader(header).get();
+        assertEquals(2, format.getHeader().length);
+        assertArrayEquals(header, format.getHeader());
+    }
+
+    @SuppressWarnings("deprecation")
+    @Test
+    void testDuplicateHeaderElements_Deprecated() {
         final String[] header = { "A", "A" };
         final CSVFormat format = CSVFormat.DEFAULT.withHeader(header);
         assertEquals(2, format.getHeader().length);
@@ -97,200 +158,295 @@ public void testDuplicateHeaderElements() {
     }
 
     @Test
-    public void testDuplicateHeaderElementsFalse() {
-        assertThrows(
-                IllegalArgumentException.class,
-                () -> CSVFormat.DEFAULT.withAllowDuplicateHeaderNames(false).withHeader("A", "A"));
+    void testDuplicateHeaderElementsFalse() {
+        assertThrows(IllegalArgumentException.class, () -> CSVFormat.DEFAULT.builder().setAllowDuplicateHeaderNames(false).setHeader("A", "A").get());
+    }
+
+    @SuppressWarnings("deprecation")
+    @Test
+    void testDuplicateHeaderElementsFalse_Deprecated() {
+        assertThrows(IllegalArgumentException.class, () -> CSVFormat.DEFAULT.withAllowDuplicateHeaderNames(false).withHeader("A", "A"));
     }
 
-    public void testDuplicateHeaderElementsTrue() {
+    @Test
+    void testDuplicateHeaderElementsTrue() {
+        CSVFormat.DEFAULT.builder().setAllowDuplicateHeaderNames(true).setHeader("A", "A").get();
+    }
+
+    @SuppressWarnings("deprecation")
+    @Test
+    void testDuplicateHeaderElementsTrue_Deprecated() {
         CSVFormat.DEFAULT.withAllowDuplicateHeaderNames(true).withHeader("A", "A");
     }
 
     @Test
-    public void testEquals() {
-        final CSVFormat right = CSVFormat.DEFAULT;
-        final CSVFormat left = copy(right);
+    void testDuplicateHeaderElementsTrueContainsEmpty1() {
+        CSVFormat.DEFAULT.builder().setAllowDuplicateHeaderNames(false).setHeader("A", "", "B", "").get();
+    }
+
+    @Test
+    void testDuplicateHeaderElementsTrueContainsEmpty2() {
+        CSVFormat.DEFAULT.builder().setDuplicateHeaderMode(DuplicateHeaderMode.ALLOW_EMPTY).setHeader("A", "", "B", "").get();
+    }
 
-        assertFalse(right.equals(null));
-        assertFalse(right.equals("A String Instance"));
+    @Test
+    void testDuplicateHeaderElementsTrueContainsEmpty3() {
+        CSVFormat.DEFAULT.builder().setAllowDuplicateHeaderNames(false).setAllowMissingColumnNames(true).setHeader("A", "", "B", "").get();
+    }
 
+    @Test
+    void testEquals() {
+        final CSVFormat right = CSVFormat.DEFAULT;
+        final CSVFormat left = copy(right);
+        assertNotEquals(null, right);
+        assertNotEquals("A String Instance", right);
         assertEquals(right, right);
         assertEquals(right, left);
         assertEquals(left, right);
-
         assertEquals(right.hashCode(), right.hashCode());
         assertEquals(right.hashCode(), left.hashCode());
     }
 
     @Test
-    public void testEqualsCommentStart() {
-        final CSVFormat right = CSVFormat.newFormat('\'')
-                .withQuote('"')
-                .withCommentMarker('#')
-                .withQuoteMode(QuoteMode.ALL);
-        final CSVFormat left = right
-                .withCommentMarker('!');
+    void testEqualsCommentStart() {
+        final CSVFormat right = CSVFormat.newFormat('\'').builder().setQuote('"').setCommentMarker('#').setQuoteMode(QuoteMode.ALL).get();
+        final CSVFormat left = right.builder().setCommentMarker('!').get();
 
-        assertNotEquals(right, left);
+        assertNotEqualsFlip(right, left);
+    }
+
+    @SuppressWarnings("deprecation")
+    @Test
+    void testEqualsCommentStart_Deprecated() {
+        final CSVFormat right = CSVFormat.newFormat('\'').withQuote('"').withCommentMarker('#').withQuoteMode(QuoteMode.ALL);
+        final CSVFormat left = right.withCommentMarker('!');
+
+        assertNotEqualsFlip(right, left);
     }
 
     @Test
-    public void testEqualsDelimiter() {
+    void testEqualsDelimiter() {
         final CSVFormat right = CSVFormat.newFormat('!');
         final CSVFormat left = CSVFormat.newFormat('?');
 
-        assertNotEquals(right, left);
+        assertNotEqualsFlip(right, left);
     }
 
     @Test
-    public void testEqualsEscape() {
-        final CSVFormat right = CSVFormat.newFormat('\'')
-                .withQuote('"')
-                .withCommentMarker('#')
-                .withEscape('+')
-                .withQuoteMode(QuoteMode.ALL);
-        final CSVFormat left = right
-                .withEscape('!');
+    void testEqualsEscape() {
+        final CSVFormat right = CSVFormat.newFormat('\'').builder().setQuote('"').setCommentMarker('#').setEscape('+').setQuoteMode(QuoteMode.ALL).get();
+        final CSVFormat left = right.builder().setEscape('!').get();
 
-        assertNotEquals(right, left);
+        assertNotEqualsFlip(right, left);
+    }
+
+    @SuppressWarnings("deprecation")
+    @Test
+    void testEqualsEscape_Deprecated() {
+        final CSVFormat right = CSVFormat.newFormat('\'').withQuote('"').withCommentMarker('#').withEscape('+').withQuoteMode(QuoteMode.ALL);
+        final CSVFormat left = right.withEscape('!');
+
+        assertNotEqualsFlip(right, left);
     }
 
     @Test
-    public void testEqualsHash() throws Exception {
+    void testEqualsHash() throws Exception {
         final Method[] methods = CSVFormat.class.getDeclaredMethods();
         for (final Method method : methods) {
             if (Modifier.isPublic(method.getModifiers())) {
-               final String name = method.getName();
-               if (name.startsWith("with")) {
-                   for (final Class cls : method.getParameterTypes()) {
-                       final String type = cls.getCanonicalName();
-                       if ("boolean".equals(type)) {
-                           final Object defTrue = method.invoke(CSVFormat.DEFAULT, new Object[] {Boolean.TRUE});
-                           final Object defFalse = method.invoke(CSVFormat.DEFAULT, new Object[] {Boolean.FALSE});
-                           assertNotEquals(name, type ,defTrue, defFalse);
-                       } else if ("char".equals(type)){
-                           final Object a = method.invoke(CSVFormat.DEFAULT, new Object[] {'a'});
-                           final Object b = method.invoke(CSVFormat.DEFAULT, new Object[] {'b'});
-                           assertNotEquals(name, type, a, b);
-                       } else if ("java.lang.Character".equals(type)){
-                           final Object a = method.invoke(CSVFormat.DEFAULT, new Object[] {null});
-                           final Object b = method.invoke(CSVFormat.DEFAULT, new Object[] {new Character('d')});
-                           assertNotEquals(name, type, a, b);
-                       } else if ("java.lang.String".equals(type)){
-                           final Object a = method.invoke(CSVFormat.DEFAULT, new Object[] {null});
-                           final Object b = method.invoke(CSVFormat.DEFAULT, new Object[] {"e"});
-                           assertNotEquals(name, type, a, b);
-                       } else if ("java.lang.String[]".equals(type)){
-                           final Object a = method.invoke(CSVFormat.DEFAULT, new Object[] {new String[] {null, null}});
-                           final Object b = method.invoke(CSVFormat.DEFAULT, new Object[] {new String[] {"f", "g"}});
-                           assertNotEquals(name, type, a, b);
-                       } else if ("org.apache.commons.csv.QuoteMode".equals(type)){
-                           final Object a = method.invoke(CSVFormat.DEFAULT, new Object[] {QuoteMode.MINIMAL});
-                           final Object b = method.invoke(CSVFormat.DEFAULT, new Object[] {QuoteMode.ALL});
-                           assertNotEquals(name, type, a, b);
-                       } else if ("java.lang.Object[]".equals(type)){
-                           final Object a = method.invoke(CSVFormat.DEFAULT, new Object[] {new Object[] {null, null}});
-                           final Object b = method.invoke(CSVFormat.DEFAULT, new Object[] {new Object[] {new Object(), new Object()}});
-                           assertNotEquals(name, type, a, b);
-                       } else if ("withHeader".equals(name)){ // covered above by String[]
-                           // ignored
-                       } else {
-                           fail("Unhandled method: "+name + "(" + type + ")");
-                       }
-                   }
-               }
+                final String name = method.getName();
+                if (name.startsWith("with")) {
+                    for (final Class cls : method.getParameterTypes()) {
+                        final String type = cls.getCanonicalName();
+                        switch (type) {
+                        case "boolean": {
+                            final Object defTrue = method.invoke(CSVFormat.DEFAULT, Boolean.TRUE);
+                            final Object defFalse = method.invoke(CSVFormat.DEFAULT, Boolean.FALSE);
+                            assertNotEqualsHash(name, type, defTrue, defFalse);
+                            break;
+                        }
+                        case "char": {
+                            final Object a = method.invoke(CSVFormat.DEFAULT, 'a');
+                            final Object b = method.invoke(CSVFormat.DEFAULT, 'b');
+                            assertNotEqualsHash(name, type, a, b);
+                            break;
+                        }
+                        case "java.lang.Character": {
+                            final Object a = method.invoke(CSVFormat.DEFAULT, new Object[] { null });
+                            final Object b = method.invoke(CSVFormat.DEFAULT, Character.valueOf('d'));
+                            assertNotEqualsHash(name, type, a, b);
+                            break;
+                        }
+                        case "java.lang.String": {
+                            final Object a = method.invoke(CSVFormat.DEFAULT, new Object[] { null });
+                            final Object b = method.invoke(CSVFormat.DEFAULT, "e");
+                            assertNotEqualsHash(name, type, a, b);
+                            break;
+                        }
+                        case "java.lang.String[]": {
+                            final Object a = method.invoke(CSVFormat.DEFAULT, new Object[] { new String[] { null, null } });
+                            final Object b = method.invoke(CSVFormat.DEFAULT, new Object[] { new String[] { "f", "g" } });
+                            assertNotEqualsHash(name, type, a, b);
+                            break;
+                        }
+                        case "org.apache.commons.csv.QuoteMode": {
+                            final Object a = method.invoke(CSVFormat.DEFAULT, QuoteMode.MINIMAL);
+                            final Object b = method.invoke(CSVFormat.DEFAULT, QuoteMode.ALL);
+                            assertNotEqualsHash(name, type, a, b);
+                            break;
+                        }
+                        case "org.apache.commons.csv.DuplicateHeaderMode": {
+                            final Object a = method.invoke(CSVFormat.DEFAULT, DuplicateHeaderMode.ALLOW_ALL);
+                            final Object b = method.invoke(CSVFormat.DEFAULT, DuplicateHeaderMode.DISALLOW);
+                            assertNotEqualsHash(name, type, a, b);
+                            break;
+                        }
+                        case "java.lang.Object[]": {
+                            final Object a = method.invoke(CSVFormat.DEFAULT, new Object[] { new Object[] { null, null } });
+                            final Object b = method.invoke(CSVFormat.DEFAULT, new Object[] { new Object[] { new Object(), new Object() } });
+                            assertNotEqualsHash(name, type, a, b);
+                            break;
+                        }
+                        default:
+                            if ("withHeader".equals(name)) { // covered above by String[]
+                                // ignored
+                            } else {
+                                fail("Unhandled method: " + name + "(" + type + ")");
+                            }
+                            break;
+                        }
+                    }
+                }
             }
-         }
+        }
     }
 
     @Test
-    public void testEqualsHeader() {
-        final CSVFormat right = CSVFormat.newFormat('\'')
-                .withRecordSeparator(CR)
-                .withCommentMarker('#')
-                .withEscape('+')
-                .withHeader("One", "Two", "Three")
-                .withIgnoreEmptyLines()
-                .withIgnoreSurroundingSpaces()
-                .withQuote('"')
-                .withQuoteMode(QuoteMode.ALL);
-        final CSVFormat left = right
-                .withHeader("Three", "Two", "One");
+    void testEqualsHeader() {
+        final CSVFormat right = CSVFormat.newFormat('\'').builder().setRecordSeparator(CR).setCommentMarker('#').setEscape('+').setHeader("One", "Two", "Three")
+                .setIgnoreEmptyLines(true).setIgnoreSurroundingSpaces(true).setQuote('"').setQuoteMode(QuoteMode.ALL).get();
+        final CSVFormat left = right.builder().setHeader("Three", "Two", "One").get();
 
-        assertNotEquals(right, left);
+        assertNotEqualsFlip(right, left);
     }
 
+    @SuppressWarnings("deprecation")
     @Test
-    public void testEqualsIgnoreEmptyLines() {
-        final CSVFormat right = CSVFormat.newFormat('\'')
-                .withCommentMarker('#')
-                .withEscape('+')
-                .withIgnoreEmptyLines()
-                .withIgnoreSurroundingSpaces()
-                .withQuote('"')
-                .withQuoteMode(QuoteMode.ALL);
-        final CSVFormat left = right
-                .withIgnoreEmptyLines(false);
+    void testEqualsHeader_Deprecated() {
+        final CSVFormat right = CSVFormat.newFormat('\'').withRecordSeparator(CR).withCommentMarker('#').withEscape('+').withHeader("One", "Two", "Three")
+                .withIgnoreEmptyLines().withIgnoreSurroundingSpaces().withQuote('"').withQuoteMode(QuoteMode.ALL);
+        final CSVFormat left = right.withHeader("Three", "Two", "One");
 
-        assertNotEquals(right, left);
+        assertNotEqualsFlip(right, left);
     }
 
     @Test
-    public void testEqualsIgnoreSurroundingSpaces() {
-        final CSVFormat right = CSVFormat.newFormat('\'')
-                .withCommentMarker('#')
-                .withEscape('+')
-                .withIgnoreSurroundingSpaces()
-                .withQuote('"')
+    void testEqualsIgnoreEmptyLines() {
+        final CSVFormat right = CSVFormat.newFormat('\'').builder().setCommentMarker('#').setEscape('+').setIgnoreEmptyLines(true)
+                .setIgnoreSurroundingSpaces(true).setQuote('"').setQuoteMode(QuoteMode.ALL).get();
+        final CSVFormat left = right.builder().setIgnoreEmptyLines(false).get();
+
+        assertNotEqualsFlip(right, left);
+    }
+
+    @SuppressWarnings("deprecation")
+    @Test
+    void testEqualsIgnoreEmptyLines_Deprecated() {
+        final CSVFormat right = CSVFormat.newFormat('\'').withCommentMarker('#').withEscape('+').withIgnoreEmptyLines().withIgnoreSurroundingSpaces()
+                .withQuote('"').withQuoteMode(QuoteMode.ALL);
+        final CSVFormat left = right.withIgnoreEmptyLines(false);
+
+        assertNotEqualsFlip(right, left);
+    }
+
+    @Test
+    void testEqualsIgnoreSurroundingSpaces() {
+        final CSVFormat right = CSVFormat.newFormat('\'').builder().setCommentMarker('#').setEscape('+').setIgnoreSurroundingSpaces(true).setQuote('"')
+                .setQuoteMode(QuoteMode.ALL).get();
+        final CSVFormat left = right.builder().setIgnoreSurroundingSpaces(false).get();
+
+        assertNotEqualsFlip(right, left);
+    }
+
+    @SuppressWarnings("deprecation")
+    @Test
+    void testEqualsIgnoreSurroundingSpaces_Deprecated() {
+        final CSVFormat right = CSVFormat.newFormat('\'').withCommentMarker('#').withEscape('+').withIgnoreSurroundingSpaces().withQuote('"')
                 .withQuoteMode(QuoteMode.ALL);
-        final CSVFormat left = right
-                .withIgnoreSurroundingSpaces(false);
+        final CSVFormat left = right.withIgnoreSurroundingSpaces(false);
 
-        assertNotEquals(right, left);
+        assertNotEqualsFlip(right, left);
     }
 
     @Test
-    public void testEqualsLeftNoQuoteRightQuote() {
-    	final CSVFormat left = CSVFormat.newFormat(',').withQuote(null);
-    	final CSVFormat right = left.withQuote('#');
+    void testEqualsLeftNoQuoteRightQuote() {
+        final CSVFormat left = CSVFormat.newFormat(',').builder().setQuote(null).get();
+        final CSVFormat right = left.builder().setQuote('#').get();
 
-    	assertNotEquals(left, right);
+        assertNotEqualsFlip(left, right);
     }
 
+    @SuppressWarnings("deprecation")
     @Test
-    public void testEqualsNoQuotes() {
-    	final CSVFormat left = CSVFormat.newFormat(',').withQuote(null);
-    	final CSVFormat right = left.withQuote(null);
+    void testEqualsLeftNoQuoteRightQuote_Deprecated() {
+        final CSVFormat left = CSVFormat.newFormat(',').withQuote(null);
+        final CSVFormat right = left.withQuote('#');
 
-    	assertEquals(left, right);
+        assertNotEqualsFlip(left, right);
     }
 
     @Test
-    public void testEqualsNullString() {
-        final CSVFormat right = CSVFormat.newFormat('\'')
-                .withRecordSeparator(CR)
-                .withCommentMarker('#')
-                .withEscape('+')
-                .withIgnoreEmptyLines()
-                .withIgnoreSurroundingSpaces()
-                .withQuote('"')
-                .withQuoteMode(QuoteMode.ALL)
-                .withNullString("null");
-        final CSVFormat left = right
-                .withNullString("---");
+    void testEqualsMaxRows() {
+        final CSVFormat right = CSVFormat.DEFAULT.builder().setMaxRows(10).get();
+        final CSVFormat left = CSVFormat.DEFAULT.builder().setMaxRows(1000).get();
+        assertNotEqualsFlip(right, left);
+        assertNotEquals(right.hashCode(), left.hashCode());
+    }
 
-        assertNotEquals(right, left);
+    @Test
+    void testEqualsNoQuotes() {
+        final CSVFormat left = CSVFormat.newFormat(',').builder().setQuote(null).get();
+        final CSVFormat right = left.builder().setQuote(null).get();
+
+        assertEquals(left, right);
     }
 
+    @SuppressWarnings("deprecation")
     @Test
-    public void testEqualsOne() {
+    void testEqualsNoQuotes_Deprecated() {
+        final CSVFormat left = CSVFormat.newFormat(',').withQuote(null);
+        final CSVFormat right = left.withQuote(null);
+
+        assertEquals(left, right);
+    }
+
+    @Test
+    void testEqualsNullString() {
+        final CSVFormat right = CSVFormat.newFormat('\'').builder().setRecordSeparator(CR).setCommentMarker('#').setEscape('+').setIgnoreEmptyLines(true)
+                .setIgnoreSurroundingSpaces(true).setQuote('"').setQuoteMode(QuoteMode.ALL).setNullString("null").get();
+        final CSVFormat left = right.builder().setNullString("---").get();
+
+        assertNotEqualsFlip(right, left);
+    }
+
+    @SuppressWarnings("deprecation")
+    @Test
+    void testEqualsNullString_Deprecated() {
+        final CSVFormat right = CSVFormat.newFormat('\'').withRecordSeparator(CR).withCommentMarker('#').withEscape('+').withIgnoreEmptyLines()
+                .withIgnoreSurroundingSpaces().withQuote('"').withQuoteMode(QuoteMode.ALL).withNullString("null");
+        final CSVFormat left = right.withNullString("---");
+
+        assertNotEqualsFlip(right, left);
+    }
+
+    @Test
+    void testEqualsOne() {
 
         final CSVFormat csvFormatOne = CSVFormat.INFORMIX_UNLOAD;
         final CSVFormat csvFormatTwo = CSVFormat.MYSQL;
 
-
-        assertEquals('\\', (char)csvFormatOne.getEscapeCharacter());
+        assertEquals('\\', (char) csvFormatOne.getEscapeCharacter());
+        assertEquals('\\', csvFormatOne.getEscapeChar());
         assertNull(csvFormatOne.getQuoteMode());
 
         assertTrue(csvFormatOne.getIgnoreEmptyLines());
@@ -308,7 +464,7 @@ public void testEqualsOne() {
         assertTrue(csvFormatOne.isEscapeCharacterSet());
         assertEquals("\n", csvFormatOne.getRecordSeparator());
 
-        assertEquals('\"', (char)csvFormatOne.getQuoteCharacter());
+        assertEquals('\"', (char) csvFormatOne.getQuoteCharacter());
         assertFalse(csvFormatOne.getTrailingDelimiter());
 
         assertFalse(csvFormatOne.getTrim());
@@ -317,7 +473,6 @@ public void testEqualsOne() {
         assertNull(csvFormatOne.getNullString());
         assertFalse(csvFormatOne.getIgnoreSurroundingSpaces());
 
-
         assertTrue(csvFormatTwo.isEscapeCharacterSet());
         assertNull(csvFormatTwo.getQuoteCharacter());
 
@@ -325,12 +480,14 @@ public void testEqualsOne() {
         assertEquals(QuoteMode.ALL_NON_NULL, csvFormatTwo.getQuoteMode());
 
         assertEquals('\t', csvFormatTwo.getDelimiter());
+        assertArrayEquals(new char[] { '\t' }, csvFormatTwo.getDelimiterCharArray());
+        assertEquals("\t", csvFormatTwo.getDelimiterString());
         assertEquals("\n", csvFormatTwo.getRecordSeparator());
 
         assertFalse(csvFormatTwo.isQuoteCharacterSet());
         assertTrue(csvFormatTwo.isNullStringSet());
 
-        assertEquals('\\', (char)csvFormatTwo.getEscapeCharacter());
+        assertEquals('\\', (char) csvFormatTwo.getEscapeCharacter());
         assertFalse(csvFormatTwo.getIgnoreHeaderCase());
 
         assertFalse(csvFormatTwo.getTrim());
@@ -346,9 +503,9 @@ public void testEqualsOne() {
         assertFalse(csvFormatTwo.isCommentMarkerSet());
 
         assertNotSame(csvFormatTwo, csvFormatOne);
-        assertFalse(csvFormatTwo.equals(csvFormatOne));
+        assertNotEquals(csvFormatTwo, csvFormatOne);
 
-        assertEquals('\\', (char)csvFormatOne.getEscapeCharacter());
+        assertEquals('\\', (char) csvFormatOne.getEscapeCharacter());
         assertNull(csvFormatOne.getQuoteMode());
 
         assertTrue(csvFormatOne.getIgnoreEmptyLines());
@@ -366,7 +523,7 @@ public void testEqualsOne() {
         assertTrue(csvFormatOne.isEscapeCharacterSet());
         assertEquals("\n", csvFormatOne.getRecordSeparator());
 
-        assertEquals('\"', (char)csvFormatOne.getQuoteCharacter());
+        assertEquals('\"', (char) csvFormatOne.getQuoteCharacter());
         assertFalse(csvFormatOne.getTrailingDelimiter());
 
         assertFalse(csvFormatOne.getTrim());
@@ -387,7 +544,7 @@ public void testEqualsOne() {
         assertFalse(csvFormatTwo.isQuoteCharacterSet());
         assertTrue(csvFormatTwo.isNullStringSet());
 
-        assertEquals('\\', (char)csvFormatTwo.getEscapeCharacter());
+        assertEquals('\\', (char) csvFormatTwo.getEscapeCharacter());
         assertFalse(csvFormatTwo.getIgnoreHeaderCase());
 
         assertFalse(csvFormatTwo.getTrim());
@@ -405,78 +562,96 @@ public void testEqualsOne() {
         assertNotSame(csvFormatOne, csvFormatTwo);
         assertNotSame(csvFormatTwo, csvFormatOne);
 
-        assertFalse(csvFormatOne.equals(csvFormatTwo));
-        assertFalse(csvFormatTwo.equals(csvFormatOne));
+        assertNotEquals(csvFormatOne, csvFormatTwo);
+        assertNotEquals(csvFormatTwo, csvFormatOne);
+
+        assertNotEquals(csvFormatTwo, csvFormatOne);
+
+    }
 
-        assertFalse(csvFormatTwo.equals(csvFormatOne));
+    @Test
+    void testEqualsQuoteChar() {
+        final CSVFormat right = CSVFormat.newFormat('\'').builder().setQuote('"').get();
+        final CSVFormat left = right.builder().setQuote('!').get();
 
+        assertNotEqualsFlip(right, left);
     }
 
+    @SuppressWarnings("deprecation")
     @Test
-    public void testEqualsQuoteChar() {
+    void testEqualsQuoteChar_Deprecated() {
         final CSVFormat right = CSVFormat.newFormat('\'').withQuote('"');
         final CSVFormat left = right.withQuote('!');
 
-        assertNotEquals(right, left);
+        assertNotEqualsFlip(right, left);
     }
 
     @Test
-    public void testEqualsQuotePolicy() {
-        final CSVFormat right = CSVFormat.newFormat('\'')
-                .withQuote('"')
-                .withQuoteMode(QuoteMode.ALL);
-        final CSVFormat left = right
-                .withQuoteMode(QuoteMode.MINIMAL);
+    void testEqualsQuotePolicy() {
+        final CSVFormat right = CSVFormat.newFormat('\'').builder().setQuote('"').setQuoteMode(QuoteMode.ALL).get();
+        final CSVFormat left = right.builder().setQuoteMode(QuoteMode.MINIMAL).get();
 
-        assertNotEquals(right, left);
+        assertNotEqualsFlip(right, left);
     }
 
+    @SuppressWarnings("deprecation")
     @Test
-    public void testEqualsRecordSeparator() {
-        final CSVFormat right = CSVFormat.newFormat('\'')
-                .withRecordSeparator(CR)
-                .withCommentMarker('#')
-                .withEscape('+')
-                .withIgnoreEmptyLines()
-                .withIgnoreSurroundingSpaces()
-                .withQuote('"')
-                .withQuoteMode(QuoteMode.ALL);
-        final CSVFormat left = right
-                .withRecordSeparator(LF);
+    void testEqualsQuotePolicy_Deprecated() {
+        final CSVFormat right = CSVFormat.newFormat('\'').withQuote('"').withQuoteMode(QuoteMode.ALL);
+        final CSVFormat left = right.withQuoteMode(QuoteMode.MINIMAL);
 
-        assertNotEquals(right, left);
+        assertNotEqualsFlip(right, left);
     }
 
     @Test
-    public void testEqualsSkipHeaderRecord() {
-        final CSVFormat right = CSVFormat.newFormat('\'')
-                .withRecordSeparator(CR)
-                .withCommentMarker('#')
-                .withEscape('+')
-                .withIgnoreEmptyLines()
-                .withIgnoreSurroundingSpaces()
-                .withQuote('"')
-                .withQuoteMode(QuoteMode.ALL)
-                .withNullString("null")
-                .withSkipHeaderRecord();
-        final CSVFormat left = right
-                .withSkipHeaderRecord(false);
+    void testEqualsRecordSeparator() {
+        final CSVFormat right = CSVFormat.newFormat('\'').builder().setRecordSeparator(CR).setCommentMarker('#').setEscape('+').setIgnoreEmptyLines(true)
+                .setIgnoreSurroundingSpaces(true).setQuote('"').setQuoteMode(QuoteMode.ALL).get();
+        final CSVFormat left = right.builder().setRecordSeparator(LF).get();
 
-        assertNotEquals(right, left);
+        assertNotEqualsFlip(right, left);
     }
 
+    @SuppressWarnings("deprecation")
     @Test
-    public void testEqualsWithNull() {
+    void testEqualsRecordSeparator_Deprecated() {
+        final CSVFormat right = CSVFormat.newFormat('\'').withRecordSeparator(CR).withCommentMarker('#').withEscape('+').withIgnoreEmptyLines()
+                .withIgnoreSurroundingSpaces().withQuote('"').withQuoteMode(QuoteMode.ALL);
+        final CSVFormat left = right.withRecordSeparator(LF);
+
+        assertNotEqualsFlip(right, left);
+    }
+
+    void testEqualsSkipHeaderRecord() {
+        final CSVFormat right = CSVFormat.newFormat('\'').builder().setRecordSeparator(CR).setCommentMarker('#').setEscape('+').setIgnoreEmptyLines(true)
+                .setIgnoreSurroundingSpaces(true).setQuote('"').setQuoteMode(QuoteMode.ALL).setNullString("null").setSkipHeaderRecord(true).get();
+        final CSVFormat left = right.builder().setSkipHeaderRecord(false).get();
+
+        assertNotEqualsFlip(right, left);
+    }
+
+    @SuppressWarnings("deprecation")
+    @Test
+    void testEqualsSkipHeaderRecord_Deprecated() {
+        final CSVFormat right = CSVFormat.newFormat('\'').withRecordSeparator(CR).withCommentMarker('#').withEscape('+').withIgnoreEmptyLines()
+                .withIgnoreSurroundingSpaces().withQuote('"').withQuoteMode(QuoteMode.ALL).withNullString("null").withSkipHeaderRecord();
+        final CSVFormat left = right.withSkipHeaderRecord(false);
+
+        assertNotEqualsFlip(right, left);
+    }
+
+    @Test
+    void testEqualsWithNull() {
 
         final CSVFormat csvFormat = CSVFormat.POSTGRESQL_TEXT;
 
-        assertEquals('\\', (char)csvFormat.getEscapeCharacter());
+        assertEquals('\\', (char) csvFormat.getEscapeCharacter());
         assertFalse(csvFormat.getIgnoreSurroundingSpaces());
 
         assertFalse(csvFormat.getTrailingDelimiter());
         assertFalse(csvFormat.getTrim());
 
-        assertTrue(csvFormat.isQuoteCharacterSet());
+        assertFalse(csvFormat.isQuoteCharacterSet());
         assertEquals("\\N", csvFormat.getNullString());
 
         assertFalse(csvFormat.getIgnoreHeaderCase());
@@ -494,16 +669,16 @@ public void testEqualsWithNull() {
         assertEquals("\n", csvFormat.getRecordSeparator());
         assertFalse(csvFormat.getIgnoreEmptyLines());
 
-        assertEquals('\"', (char)csvFormat.getQuoteCharacter());
+        assertNull(csvFormat.getQuoteCharacter());
         assertTrue(csvFormat.isNullStringSet());
 
-        assertEquals('\\', (char)csvFormat.getEscapeCharacter());
+        assertEquals('\\', (char) csvFormat.getEscapeCharacter());
         assertFalse(csvFormat.getIgnoreSurroundingSpaces());
 
         assertFalse(csvFormat.getTrailingDelimiter());
         assertFalse(csvFormat.getTrim());
 
-        assertTrue(csvFormat.isQuoteCharacterSet());
+        assertFalse(csvFormat.isQuoteCharacterSet());
         assertEquals("\\N", csvFormat.getNullString());
 
         assertFalse(csvFormat.getIgnoreHeaderCase());
@@ -521,28 +696,40 @@ public void testEqualsWithNull() {
         assertEquals("\n", csvFormat.getRecordSeparator());
         assertFalse(csvFormat.getIgnoreEmptyLines());
 
-        assertEquals('\"', (char)csvFormat.getQuoteCharacter());
+        assertNull(csvFormat.getQuoteCharacter());
         assertTrue(csvFormat.isNullStringSet());
 
-        assertFalse(csvFormat.equals( null));
+        assertNotEquals(null, csvFormat);
+
+    }
 
+    @Test
+    void testEscapeSameAsCommentStartThrowsException() {
+        assertThrows(IllegalArgumentException.class, () -> CSVFormat.DEFAULT.builder().setEscape('!').setCommentMarker('!').get());
     }
 
+    @SuppressWarnings("deprecation")
     @Test
-    public void testEscapeSameAsCommentStartThrowsException() {
+    void testEscapeSameAsCommentStartThrowsException_Deprecated() {
         assertThrows(IllegalArgumentException.class, () -> CSVFormat.DEFAULT.withEscape('!').withCommentMarker('!'));
     }
 
     @Test
-    public void testEscapeSameAsCommentStartThrowsExceptionForWrapperType() {
+    void testEscapeSameAsCommentStartThrowsExceptionForWrapperType() {
+        // Cannot assume that callers won't use different Character objects
+        assertThrows(IllegalArgumentException.class,
+                () -> CSVFormat.DEFAULT.builder().setEscape(Character.valueOf('!')).setCommentMarker(Character.valueOf('!')).get());
+    }
+
+    @SuppressWarnings("deprecation")
+    @Test
+    void testEscapeSameAsCommentStartThrowsExceptionForWrapperType_Deprecated() {
         // Cannot assume that callers won't use different Character objects
-        assertThrows(
-                IllegalArgumentException.class,
-                () -> CSVFormat.DEFAULT.withEscape(new Character('!')).withCommentMarker(new Character('!')));
+        assertThrows(IllegalArgumentException.class, () -> CSVFormat.DEFAULT.withEscape(Character.valueOf('!')).withCommentMarker(Character.valueOf('!')));
     }
 
     @Test
-    public void testFormat() {
+    void testFormat() {
         final CSVFormat format = CSVFormat.DEFAULT;
 
         assertEquals("", format.format());
@@ -550,18 +737,57 @@ public void testFormat() {
         assertEquals("\"x,y\",z", format.format("x,y", "z"));
     }
 
-    @Test  //I assume this to be a defect.
-    public void testFormatThrowsNullPointerException() {
+    @Test // I assume this to be a defect.
+    void testFormatThrowsNullPointerException() {
 
         final CSVFormat csvFormat = CSVFormat.MYSQL;
 
         final NullPointerException e = assertThrows(NullPointerException.class, () -> csvFormat.format((Object[]) null));
-        assertEquals(CSVFormat.class.getName(), e.getStackTrace()[0].getClassName());
+        assertEquals(Objects.class.getName(), e.getStackTrace()[0].getClassName());
+    }
+
+    @Test
+    void testFormatToString() {
+        // @formatter:off
+        final CSVFormat format = CSVFormat.RFC4180
+                .withEscape('?')
+                .withDelimiter(',')
+                .withQuoteMode(QuoteMode.MINIMAL)
+                .withRecordSeparator(CRLF)
+                .withQuote('"')
+                .withNullString("")
+                .withIgnoreHeaderCase(true)
+                .withHeaderComments("This is HeaderComments")
+                .withHeader("col1", "col2", "col3");
+        // @formatter:on
+        assertEquals(
+                "Delimiter=<,> Escape= QuoteChar=<\"> QuoteMode= NullString=<> RecordSeparator=<" + CRLF +
+                        "> IgnoreHeaderCase:ignored SkipHeaderRecord:false HeaderComments:[This is HeaderComments] Header:[col1, col2, col3]",
+                format.toString());
+    }
+
+    @Test
+    void testGetAllowDuplicateHeaderNames() {
+        final Builder builder = CSVFormat.DEFAULT.builder();
+        assertTrue(builder.get().getAllowDuplicateHeaderNames());
+        assertTrue(builder.setDuplicateHeaderMode(DuplicateHeaderMode.ALLOW_ALL).get().getAllowDuplicateHeaderNames());
+        assertFalse(builder.setDuplicateHeaderMode(DuplicateHeaderMode.ALLOW_EMPTY).get().getAllowDuplicateHeaderNames());
+        assertFalse(builder.setDuplicateHeaderMode(DuplicateHeaderMode.DISALLOW).get().getAllowDuplicateHeaderNames());
+    }
+
+    @Test
+    void testGetDuplicateHeaderMode() {
+        final Builder builder = CSVFormat.DEFAULT.builder();
+
+        assertEquals(DuplicateHeaderMode.ALLOW_ALL, builder.get().getDuplicateHeaderMode());
+        assertEquals(DuplicateHeaderMode.ALLOW_ALL, builder.setDuplicateHeaderMode(DuplicateHeaderMode.ALLOW_ALL).get().getDuplicateHeaderMode());
+        assertEquals(DuplicateHeaderMode.ALLOW_EMPTY, builder.setDuplicateHeaderMode(DuplicateHeaderMode.ALLOW_EMPTY).get().getDuplicateHeaderMode());
+        assertEquals(DuplicateHeaderMode.DISALLOW, builder.setDuplicateHeaderMode(DuplicateHeaderMode.DISALLOW).get().getDuplicateHeaderMode());
     }
 
     @Test
-    public void testGetHeader() {
-        final String[] header = new String[]{"one", "two", "three"};
+    void testGetHeader() {
+        final String[] header = { "one", "two", "three" };
         final CSVFormat formatWithHeader = CSVFormat.DEFAULT.withHeader(header);
         // getHeader() makes a copy of the header array.
         final String[] headerCopy = formatWithHeader.getHeader();
@@ -573,7 +799,7 @@ public void testGetHeader() {
     }
 
     @Test
-    public void testHashCodeAndWithIgnoreHeaderCase() {
+    void testHashCodeAndWithIgnoreHeaderCase() {
 
         final CSVFormat csvFormat = CSVFormat.INFORMIX_UNLOAD_CSV;
         final CSVFormat csvFormatTwo = csvFormat.withIgnoreHeaderCase();
@@ -583,7 +809,7 @@ public void testHashCodeAndWithIgnoreHeaderCase() {
         assertTrue(csvFormatTwo.getIgnoreHeaderCase()); // now different
         assertFalse(csvFormatTwo.getTrailingDelimiter());
 
-        assertFalse(csvFormatTwo.equals(csvFormat)); // CSV-244 - should not be equal
+        assertNotEquals(csvFormatTwo, csvFormat); // CSV-244 - should not be equal
         assertFalse(csvFormatTwo.getAllowMissingColumnNames());
 
         assertFalse(csvFormatTwo.getTrim());
@@ -591,12 +817,18 @@ public void testHashCodeAndWithIgnoreHeaderCase() {
     }
 
     @Test
-    public void testJiraCsv236() {
-        CSVFormat.DEFAULT.withAllowDuplicateHeaderNames().withHeader("CC","VV","VV");
+    void testJiraCsv236() {
+        CSVFormat.DEFAULT.builder().setAllowDuplicateHeaderNames(true).setHeader("CC", "VV", "VV").get();
     }
 
+    @SuppressWarnings("deprecation")
     @Test
-    public void testNewFormat() {
+    void testJiraCsv236__Deprecated() {
+        CSVFormat.DEFAULT.withAllowDuplicateHeaderNames().withHeader("CC", "VV", "VV");
+    }
+
+    @Test
+    void testNewFormat() {
 
         final CSVFormat csvFormat = CSVFormat.newFormat('X');
 
@@ -657,7 +889,16 @@ public void testNewFormat() {
     }
 
     @Test
-    public void testNullRecordSeparatorCsv106() {
+    void testNullRecordSeparatorCsv106() {
+        final CSVFormat format = CSVFormat.newFormat(';').builder().setSkipHeaderRecord(true).setHeader("H1", "H2").get();
+        final String formatStr = format.format("A", "B");
+        assertNotNull(formatStr);
+        assertFalse(formatStr.endsWith("null"));
+    }
+
+    @SuppressWarnings("deprecation")
+    @Test
+    void testNullRecordSeparatorCsv106__Deprecated() {
         final CSVFormat format = CSVFormat.newFormat(';').withSkipHeaderRecord().withHeader("H1", "H2");
         final String formatStr = format.format("A", "B");
         assertNotNull(formatStr);
@@ -665,45 +906,190 @@ public void testNullRecordSeparatorCsv106() {
     }
 
     @Test
-    public void testQuoteCharSameAsCommentStartThrowsException() {
+    void testPrintRecord() throws IOException {
+        final Appendable out = new StringBuilder();
+        final CSVFormat format = CSVFormat.RFC4180;
+        format.printRecord(out, "a", "b", "c");
+        assertEquals("a,b,c" + format.getRecordSeparator(), out.toString());
+    }
+
+    @Test
+    void testPrintRecordEmpty() throws IOException {
+        final Appendable out = new StringBuilder();
+        final CSVFormat format = CSVFormat.RFC4180;
+        format.printRecord(out);
+        assertEquals(format.getRecordSeparator(), out.toString());
+    }
+
+    @Test
+    void testPrintWithEscapesEndWithCRLF() throws IOException {
+        final Reader in = new StringReader("x,y,x\r\na,?b,c\r\n");
+        final Appendable out = new StringBuilder();
+        final CSVFormat format = CSVFormat.RFC4180.withEscape('?').withDelimiter(',').withQuote(null).withRecordSeparator(CRLF);
+        format.print(in, out, true);
+        assertEquals("x?,y?,x?r?na?,??b?,c?r?n", out.toString());
+    }
+
+    @Test
+    void testPrintWithEscapesEndWithoutCRLF() throws IOException {
+        final Reader in = new StringReader("x,y,x");
+        final Appendable out = new StringBuilder();
+        final CSVFormat format = CSVFormat.RFC4180.withEscape('?').withDelimiter(',').withQuote(null).withRecordSeparator(CRLF);
+        format.print(in, out, true);
+        assertEquals("x?,y?,x", out.toString());
+    }
+
+    @Test
+    void testPrintWithoutQuotes() throws IOException {
+        final Reader in = new StringReader("");
+        final Appendable out = new StringBuilder();
+        final CSVFormat format = CSVFormat.RFC4180.withDelimiter(',').withQuote('"').withEscape('?').withQuoteMode(QuoteMode.NON_NUMERIC);
+        format.print(in, out, true);
+        assertEquals("\"\"", out.toString());
+    }
+
+    @Test
+    void testPrintWithQuoteModeIsNONE() throws IOException {
+        final Reader in = new StringReader("a,b,c");
+        final Appendable out = new StringBuilder();
+        final CSVFormat format = CSVFormat.RFC4180.withDelimiter(',').withQuote('"').withEscape('?').withQuoteMode(QuoteMode.NONE);
+        format.print(in, out, true);
+        assertEquals("a?,b?,c", out.toString());
+    }
+
+    @Test
+    void testPrintWithQuotes() throws IOException {
+        final Reader in = new StringReader("\"a,b,c\r\nx,y,z");
+        final Appendable out = new StringBuilder();
+        final CSVFormat format = CSVFormat.RFC4180.withDelimiter(',').withQuote('"').withEscape('?').withQuoteMode(QuoteMode.NON_NUMERIC);
+        format.print(in, out, true);
+        assertEquals("\"\"\"a,b,c\r\nx,y,z\"", out.toString());
+    }
+
+    /**
+     * Tests CSV-326.
+     */
+    @Test
+    void testPrintWithQuotesEscapeBeforeQuote() throws IOException {
+        final CSVFormat format = CSVFormat.DEFAULT.builder()
+                .setEscape('\\')
+                .setQuote('"')
+                .get();
+        final String value = "\\\"";
+        final Appendable out = new StringBuilder();
+        format.print(new StringReader(value), out, true);
+        try (CSVParser parser = CSVParser.parse(out.toString(), format)) {
+            assertEquals(value, parser.getRecords().get(0).get(0));
+        }
+    }
+
+    @Test
+    void testQuoteCharSameAsCommentStartThrowsException() {
+        assertThrows(IllegalArgumentException.class, () -> CSVFormat.DEFAULT.builder().setQuote('!').setCommentMarker('!').get());
+    }
+
+    @SuppressWarnings("deprecation")
+    @Test
+    void testQuoteCharSameAsCommentStartThrowsException_Deprecated() {
         assertThrows(IllegalArgumentException.class, () -> CSVFormat.DEFAULT.withQuote('!').withCommentMarker('!'));
     }
 
     @Test
-    public void testQuoteCharSameAsCommentStartThrowsExceptionForWrapperType() {
+    void testQuoteCharSameAsCommentStartThrowsExceptionForWrapperType() {
         // Cannot assume that callers won't use different Character objects
-        assertThrows(
-                IllegalArgumentException.class,
-                () -> CSVFormat.DEFAULT.withQuote(new Character('!')).withCommentMarker('!'));
+        assertThrows(IllegalArgumentException.class, () -> CSVFormat.DEFAULT.builder().setQuote(Character.valueOf('!')).setCommentMarker('!').get());
     }
 
+    @SuppressWarnings("deprecation")
     @Test
-    public void testQuoteCharSameAsDelimiterThrowsException() {
+    void testQuoteCharSameAsCommentStartThrowsExceptionForWrapperType_Deprecated() {
+        // Cannot assume that callers won't use different Character objects
+        assertThrows(IllegalArgumentException.class, () -> CSVFormat.DEFAULT.withQuote(Character.valueOf('!')).withCommentMarker('!'));
+    }
+
+    @Test
+    void testQuoteCharSameAsDelimiterThrowsException() {
+        assertThrows(IllegalArgumentException.class, () -> CSVFormat.DEFAULT.builder().setQuote('!').setDelimiter('!').get());
+    }
+
+    @SuppressWarnings("deprecation")
+    @Test
+    void testQuoteCharSameAsDelimiterThrowsException_Deprecated() {
         assertThrows(IllegalArgumentException.class, () -> CSVFormat.DEFAULT.withQuote('!').withDelimiter('!'));
     }
 
     @Test
-    public void testQuotePolicyNoneWithoutEscapeThrowsException() {
+    void testQuotedNullStringTracksQuoteCharacter() throws IOException {
+        final StringBuilder out = new StringBuilder();
+        // @formatter:off
+        final Builder builder = CSVFormat.DEFAULT.builder();
+        final CSVFormat format = builder
+                .setQuoteMode(QuoteMode.ALL)
+                .setNullString("NULL")
+                .get();
+        // @formatter:on
+        format.print(null, out, true);
+        assertEquals("\"NULL\"", out.toString());
+        // set
+        out.setLength(0);
+        builder.setQuote('\'');
+        builder.get().print(null, out, true);
+        assertEquals("'NULL'", out.toString());
+        // reset
+        out.setLength(0);
+        builder.setQuote((Character) null);
+        builder.get().print(null, out, true);
+        assertEquals("\"NULL\"", out.toString());
+        // reset, reverse setter order
+        out.setLength(0);
+        builder.setNullString(null).setQuote((Character) null).setNullString("NULL");
+        builder.get().print(null, out, true);
+        assertEquals("\"NULL\"", out.toString());
+    }
+
+    @Test
+    void testQuoteModeNoneShouldReturnMeaningfulExceptionMessage() {
+        final Exception exception = assertThrows(IllegalArgumentException.class, () ->
+        // @formatter:off
+            CSVFormat.DEFAULT.builder()
+                    .setHeader("Col1", "Col2", "Col3", "Col4")
+                    .setQuoteMode(QuoteMode.NONE)
+                    .get()
+        // @formatter:on
+        );
+        final String actualMessage = exception.getMessage();
+        final String expectedMessage = "Quote mode set to NONE but no escape character is set";
+        assertEquals(expectedMessage, actualMessage);
+    }
+
+    @Test
+    void testQuotePolicyNoneWithoutEscapeThrowsException() {
+        assertThrows(IllegalArgumentException.class, () -> CSVFormat.newFormat('!').builder().setQuoteMode(QuoteMode.NONE).get());
+    }
+
+    @SuppressWarnings("deprecation")
+    @Test
+    void testQuotePolicyNoneWithoutEscapeThrowsException_Deprecated() {
         assertThrows(IllegalArgumentException.class, () -> CSVFormat.newFormat('!').withQuoteMode(QuoteMode.NONE));
     }
 
     @Test
-    public void testRFC4180() {
-        assertEquals(null, RFC4180.getCommentMarker());
+    void testRFC4180() {
+        assertNull(RFC4180.getCommentMarker());
         assertEquals(',', RFC4180.getDelimiter());
-        assertEquals(null, RFC4180.getEscapeCharacter());
+        assertNull(RFC4180.getEscapeCharacter());
         assertFalse(RFC4180.getIgnoreEmptyLines());
         assertEquals(Character.valueOf('"'), RFC4180.getQuoteCharacter());
-        assertEquals(null, RFC4180.getQuoteMode());
+        assertNull(RFC4180.getQuoteMode());
         assertEquals("\r\n", RFC4180.getRecordSeparator());
     }
 
     @SuppressWarnings("boxing") // no need to worry about boxing here
     @Test
-    public void testSerialization() throws Exception {
+    void testSerialization() throws Exception {
         final ByteArrayOutputStream out = new ByteArrayOutputStream();
 
-        try (final ObjectOutputStream oos = new ObjectOutputStream(out)) {
+        try (ObjectOutputStream oos = new ObjectOutputStream(out)) {
             oos.writeObject(CSVFormat.DEFAULT);
             oos.flush();
         }
@@ -722,7 +1108,7 @@ public void testSerialization() throws Exception {
     }
 
     @Test
-    public void testToString() {
+    void testToString() {
 
         final String string = CSVFormat.INFORMIX_UNLOAD.toString();
 
@@ -731,10 +1117,10 @@ public void testToString() {
     }
 
     @Test
-    public void testToStringAndWithCommentMarkerTakingCharacter() {
+    void testToStringAndWithCommentMarkerTakingCharacter() {
 
-        final CSVFormat.Predefined csvFormat_Predefined = CSVFormat.Predefined.Default;
-        final CSVFormat csvFormat = csvFormat_Predefined.getFormat();
+        final CSVFormat.Predefined csvFormatPredefined = CSVFormat.Predefined.Default;
+        final CSVFormat csvFormat = csvFormatPredefined.getFormat();
 
         assertNull(csvFormat.getEscapeCharacter());
         assertTrue(csvFormat.isQuoteCharacterSet());
@@ -761,7 +1147,7 @@ public void testToStringAndWithCommentMarkerTakingCharacter() {
         assertNull(csvFormat.getQuoteMode());
 
         assertTrue(csvFormat.getIgnoreEmptyLines());
-        assertEquals('\"', (char)csvFormat.getQuoteCharacter());
+        assertEquals('\"', (char) csvFormat.getQuoteCharacter());
 
         final Character character = Character.valueOf('n');
 
@@ -792,12 +1178,12 @@ public void testToStringAndWithCommentMarkerTakingCharacter() {
         assertNull(csvFormat.getQuoteMode());
 
         assertTrue(csvFormat.getIgnoreEmptyLines());
-        assertEquals('\"', (char)csvFormat.getQuoteCharacter());
+        assertEquals('\"', (char) csvFormat.getQuoteCharacter());
 
         assertFalse(csvFormatTwo.isNullStringSet());
         assertFalse(csvFormatTwo.getAllowMissingColumnNames());
 
-        assertEquals('\"', (char)csvFormatTwo.getQuoteCharacter());
+        assertEquals('\"', (char) csvFormatTwo.getQuoteCharacter());
         assertNull(csvFormatTwo.getNullString());
 
         assertEquals(',', csvFormatTwo.getDelimiter());
@@ -815,7 +1201,7 @@ public void testToStringAndWithCommentMarkerTakingCharacter() {
         assertEquals("\r\n", csvFormatTwo.getRecordSeparator());
         assertNull(csvFormatTwo.getQuoteMode());
 
-        assertEquals('n', (char)csvFormatTwo.getCommentMarker());
+        assertEquals('n', (char) csvFormatTwo.getCommentMarker());
         assertFalse(csvFormatTwo.getSkipHeaderRecord());
 
         assertFalse(csvFormatTwo.isEscapeCharacterSet());
@@ -824,7 +1210,7 @@ public void testToStringAndWithCommentMarkerTakingCharacter() {
         assertNotSame(csvFormat, csvFormatTwo);
         assertNotSame(csvFormatTwo, csvFormat);
 
-        assertFalse(csvFormatTwo.equals(csvFormat));
+        assertNotEquals(csvFormatTwo, csvFormat);
 
         assertNull(csvFormat.getEscapeCharacter());
         assertTrue(csvFormat.isQuoteCharacterSet());
@@ -851,12 +1237,12 @@ public void testToStringAndWithCommentMarkerTakingCharacter() {
         assertNull(csvFormat.getQuoteMode());
 
         assertTrue(csvFormat.getIgnoreEmptyLines());
-        assertEquals('\"', (char)csvFormat.getQuoteCharacter());
+        assertEquals('\"', (char) csvFormat.getQuoteCharacter());
 
         assertFalse(csvFormatTwo.isNullStringSet());
         assertFalse(csvFormatTwo.getAllowMissingColumnNames());
 
-        assertEquals('\"', (char)csvFormatTwo.getQuoteCharacter());
+        assertEquals('\"', (char) csvFormatTwo.getQuoteCharacter());
         assertNull(csvFormatTwo.getNullString());
 
         assertEquals(',', csvFormatTwo.getDelimiter());
@@ -874,7 +1260,7 @@ public void testToStringAndWithCommentMarkerTakingCharacter() {
         assertEquals("\r\n", csvFormatTwo.getRecordSeparator());
         assertNull(csvFormatTwo.getQuoteMode());
 
-        assertEquals('n', (char)csvFormatTwo.getCommentMarker());
+        assertEquals('n', (char) csvFormatTwo.getCommentMarker());
         assertFalse(csvFormatTwo.getSkipHeaderRecord());
 
         assertFalse(csvFormatTwo.isEscapeCharacterSet());
@@ -883,77 +1269,108 @@ public void testToStringAndWithCommentMarkerTakingCharacter() {
         assertNotSame(csvFormat, csvFormatTwo);
         assertNotSame(csvFormatTwo, csvFormat);
 
-        assertFalse(csvFormat.equals(csvFormatTwo));
+        assertNotEquals(csvFormat, csvFormatTwo);
+
+        assertNotEquals(csvFormatTwo, csvFormat);
+        assertEquals("Delimiter=<,> QuoteChar=<\"> CommentStart= RecordSeparator=<\r\n> EmptyLines:ignored SkipHeaderRecord:false",
+                csvFormatTwo.toString());
+
+    }
+
+    @Test
+    void testTrim() throws IOException {
+        final CSVFormat formatWithTrim = CSVFormat.DEFAULT.withDelimiter(',').withTrim().withQuote(null).withRecordSeparator(CRLF);
+
+        CharSequence in = "a,b,c";
+        final StringBuilder out = new StringBuilder();
+        formatWithTrim.print(in, out, true);
+        assertEquals("a,b,c", out.toString());
+
+        in = new StringBuilder(" x,y,z");
+        out.setLength(0);
+        formatWithTrim.print(in, out, true);
+        assertEquals("x,y,z", out.toString());
 
-        assertFalse(csvFormatTwo.equals(csvFormat));
-        assertEquals("Delimiter=<,> QuoteChar=<\"> CommentStart= " +
-                        "RecordSeparator=<\r\n> EmptyLines:ignored SkipHeaderRecord:false"
-                , csvFormatTwo.toString());
+        in = new StringBuilder("");
+        out.setLength(0);
+        formatWithTrim.print(in, out, true);
+        assertEquals("", out.toString());
 
+        in = new StringBuilder("header\r\n");
+        out.setLength(0);
+        formatWithTrim.print(in, out, true);
+        assertEquals("header", out.toString());
     }
 
     @Test
-    public void testWithCommentStart() {
+    void testWithCommentStart() {
         final CSVFormat formatWithCommentStart = CSVFormat.DEFAULT.withCommentMarker('#');
-        assertEquals( Character.valueOf('#'), formatWithCommentStart.getCommentMarker());
+        assertEquals(Character.valueOf('#'), formatWithCommentStart.getCommentMarker());
     }
 
     @Test
-    public void testWithCommentStartCRThrowsException() {
+    void testWithCommentStartCRThrowsException() {
         assertThrows(IllegalArgumentException.class, () -> CSVFormat.DEFAULT.withCommentMarker(CR));
     }
 
     @Test
-    public void testWithDelimiter() {
+    void testWithDelimiter() {
         final CSVFormat formatWithDelimiter = CSVFormat.DEFAULT.withDelimiter('!');
         assertEquals('!', formatWithDelimiter.getDelimiter());
     }
 
     @Test
-    public void testWithDelimiterLFThrowsException() {
+    void testWithDelimiterLFThrowsException() {
         assertThrows(IllegalArgumentException.class, () -> CSVFormat.DEFAULT.withDelimiter(LF));
     }
 
     @Test
-    public void testWithEmptyEnum() {
+    void testWithEmptyDuplicates() {
+        final CSVFormat formatWithEmptyDuplicates = CSVFormat.DEFAULT.builder().setDuplicateHeaderMode(DuplicateHeaderMode.ALLOW_EMPTY).get();
+
+        assertEquals(DuplicateHeaderMode.ALLOW_EMPTY, formatWithEmptyDuplicates.getDuplicateHeaderMode());
+        assertFalse(formatWithEmptyDuplicates.getAllowDuplicateHeaderNames());
+    }
+
+    @Test
+    void testWithEmptyEnum() {
         final CSVFormat formatWithHeader = CSVFormat.DEFAULT.withHeader(EmptyEnum.class);
-        assertTrue(formatWithHeader.getHeader().length == 0);
+        assertEquals(0, formatWithHeader.getHeader().length);
     }
 
     @Test
-    public void testWithEscape() {
+    void testWithEscape() {
         final CSVFormat formatWithEscape = CSVFormat.DEFAULT.withEscape('&');
         assertEquals(Character.valueOf('&'), formatWithEscape.getEscapeCharacter());
     }
 
     @Test
-    public void testWithEscapeCRThrowsExceptions() {
+    void testWithEscapeCRThrowsExceptions() {
         assertThrows(IllegalArgumentException.class, () -> CSVFormat.DEFAULT.withEscape(CR));
     }
 
     @Test
-    public void testWithFirstRecordAsHeader() {
+    void testWithFirstRecordAsHeader() {
         final CSVFormat formatWithFirstRecordAsHeader = CSVFormat.DEFAULT.withFirstRecordAsHeader();
         assertTrue(formatWithFirstRecordAsHeader.getSkipHeaderRecord());
-        assertTrue(formatWithFirstRecordAsHeader.getHeader().length == 0);
+        assertEquals(0, formatWithFirstRecordAsHeader.getHeader().length);
     }
 
     @Test
-    public void testWithHeader() {
-        final String[] header = new String[]{"one", "two", "three"};
+    void testWithHeader() {
+        final String[] header = { "one", "two", "three" };
         // withHeader() makes a copy of the header array.
         final CSVFormat formatWithHeader = CSVFormat.DEFAULT.withHeader(header);
         assertArrayEquals(header, formatWithHeader.getHeader());
         assertNotSame(header, formatWithHeader.getHeader());
     }
 
-
     @Test
-    public void testWithHeaderComments() {
+    void testWithHeaderComments() {
 
         final CSVFormat csvFormat = CSVFormat.DEFAULT;
 
-        assertEquals('\"', (char)csvFormat.getQuoteCharacter());
+        assertEquals('\"', (char) csvFormat.getQuoteCharacter());
         assertFalse(csvFormat.isCommentMarkerSet());
 
         assertFalse(csvFormat.isEscapeCharacterSet());
@@ -983,7 +1400,7 @@ public void testWithHeaderComments() {
         final Object[] objectArray = new Object[8];
         final CSVFormat csvFormatTwo = csvFormat.withHeaderComments(objectArray);
 
-        assertEquals('\"', (char)csvFormat.getQuoteCharacter());
+        assertEquals('\"', (char) csvFormat.getQuoteCharacter());
         assertFalse(csvFormat.isCommentMarkerSet());
 
         assertFalse(csvFormat.isEscapeCharacterSet());
@@ -1023,7 +1440,7 @@ public void testWithHeaderComments() {
         assertTrue(csvFormatTwo.isQuoteCharacterSet());
 
         assertFalse(csvFormatTwo.getSkipHeaderRecord());
-        assertEquals('\"', (char)csvFormatTwo.getQuoteCharacter());
+        assertEquals('\"', (char) csvFormatTwo.getQuoteCharacter());
 
         assertFalse(csvFormatTwo.getAllowMissingColumnNames());
         assertNull(csvFormatTwo.getNullString());
@@ -1040,11 +1457,11 @@ public void testWithHeaderComments() {
         assertNotSame(csvFormat, csvFormatTwo);
         assertNotSame(csvFormatTwo, csvFormat);
 
-        assertFalse(csvFormatTwo.equals(csvFormat)); // CSV-244 - should not be equal
+        assertNotEquals(csvFormatTwo, csvFormat); // CSV-244 - should not be equal
 
         final String string = csvFormatTwo.format(objectArray);
 
-        assertEquals('\"', (char)csvFormat.getQuoteCharacter());
+        assertEquals('\"', (char) csvFormat.getQuoteCharacter());
         assertFalse(csvFormat.isCommentMarkerSet());
 
         assertFalse(csvFormat.isEscapeCharacterSet());
@@ -1084,7 +1501,7 @@ public void testWithHeaderComments() {
         assertTrue(csvFormatTwo.isQuoteCharacterSet());
 
         assertFalse(csvFormatTwo.getSkipHeaderRecord());
-        assertEquals('\"', (char)csvFormatTwo.getQuoteCharacter());
+        assertEquals('\"', (char) csvFormatTwo.getQuoteCharacter());
 
         assertFalse(csvFormatTwo.getAllowMissingColumnNames());
         assertNull(csvFormatTwo.getNullString());
@@ -1102,180 +1519,89 @@ public void testWithHeaderComments() {
         assertNotSame(csvFormatTwo, csvFormat);
 
         assertNotNull(string);
-        assertFalse(csvFormat.equals(csvFormatTwo)); // CSV-244 - should not be equal
+        assertNotEquals(csvFormat, csvFormatTwo); // CSV-244 - should not be equal
 
-        assertFalse(csvFormatTwo.equals(csvFormat)); // CSV-244 - should not be equal
+        assertNotEquals(csvFormatTwo, csvFormat); // CSV-244 - should not be equal
         assertEquals(",,,,,,,", string);
 
     }
 
-
     @Test
-    public void testWithHeaderEnum() {
+    void testWithHeaderEnum() {
         final CSVFormat formatWithHeader = CSVFormat.DEFAULT.withHeader(Header.class);
-        assertArrayEquals(new String[]{ "Name", "Email", "Phone" }, formatWithHeader.getHeader());
+        assertArrayEquals(new String[] { "Name", "Email", "Phone" }, formatWithHeader.getHeader());
     }
 
+    @Test
+    void testWithHeaderEnumNull() {
+        final CSVFormat format = CSVFormat.DEFAULT;
+        final Class> simpleName = null;
+        format.withHeader(simpleName);
+    }
+
+    @Test
+    void testWithHeaderResultSetNull() throws SQLException {
+        final CSVFormat format = CSVFormat.DEFAULT;
+        final ResultSet resultSet = null;
+        format.withHeader(resultSet);
+    }
 
     @Test
-    public void testWithIgnoreEmptyLines() {
+    void testWithIgnoreEmptyLines() {
         assertFalse(CSVFormat.DEFAULT.withIgnoreEmptyLines(false).getIgnoreEmptyLines());
         assertTrue(CSVFormat.DEFAULT.withIgnoreEmptyLines().getIgnoreEmptyLines());
     }
 
-
     @Test
-    public void testWithIgnoreSurround() {
+    void testWithIgnoreSurround() {
         assertFalse(CSVFormat.DEFAULT.withIgnoreSurroundingSpaces(false).getIgnoreSurroundingSpaces());
         assertTrue(CSVFormat.DEFAULT.withIgnoreSurroundingSpaces().getIgnoreSurroundingSpaces());
     }
 
-
     @Test
-    public void testWithNullString() {
+    void testWithNullString() {
         final CSVFormat formatWithNullString = CSVFormat.DEFAULT.withNullString("null");
         assertEquals("null", formatWithNullString.getNullString());
     }
 
-
     @Test
-    public void testWithQuoteChar() {
+    void testWithQuoteChar() {
         final CSVFormat formatWithQuoteChar = CSVFormat.DEFAULT.withQuote('"');
         assertEquals(Character.valueOf('"'), formatWithQuoteChar.getQuoteCharacter());
     }
 
-
     @Test
-    public void testWithQuoteLFThrowsException() {
+    void testWithQuoteLFThrowsException() {
         assertThrows(IllegalArgumentException.class, () -> CSVFormat.DEFAULT.withQuote(LF));
     }
 
     @Test
-    public void testWithQuotePolicy() {
+    void testWithQuotePolicy() {
         final CSVFormat formatWithQuotePolicy = CSVFormat.DEFAULT.withQuoteMode(QuoteMode.ALL);
         assertEquals(QuoteMode.ALL, formatWithQuotePolicy.getQuoteMode());
     }
 
     @Test
-    public void testWithRecordSeparatorCR() {
+    void testWithRecordSeparatorCR() {
         final CSVFormat formatWithRecordSeparator = CSVFormat.DEFAULT.withRecordSeparator(CR);
         assertEquals(String.valueOf(CR), formatWithRecordSeparator.getRecordSeparator());
     }
 
     @Test
-    public void testWithRecordSeparatorCRLF() {
+    void testWithRecordSeparatorCRLF() {
         final CSVFormat formatWithRecordSeparator = CSVFormat.DEFAULT.withRecordSeparator(CRLF);
         assertEquals(CRLF, formatWithRecordSeparator.getRecordSeparator());
     }
 
     @Test
-    public void testWithRecordSeparatorLF() {
+    void testWithRecordSeparatorLF() {
         final CSVFormat formatWithRecordSeparator = CSVFormat.DEFAULT.withRecordSeparator(LF);
         assertEquals(String.valueOf(LF), formatWithRecordSeparator.getRecordSeparator());
     }
 
     @Test
-    public void testWithSystemRecordSeparator() {
+    void testWithSystemRecordSeparator() {
         final CSVFormat formatWithRecordSeparator = CSVFormat.DEFAULT.withSystemRecordSeparator();
-        assertEquals(System.getProperty("line.separator"), formatWithRecordSeparator.getRecordSeparator());
-    }
-
-    @Test
-    public void testPrintWithEscapesEndWithCRLF() throws IOException {
-        final Reader in = new StringReader("x,y,x\r\na,?b,c\r\n");
-        final Appendable out = new StringBuilder();
-        final CSVFormat format = CSVFormat.RFC4180.withEscape('?').withDelimiter(',').withQuote(null).withRecordSeparator(CRLF);
-        format.print(in,out,true);
-        assertEquals("x?,y?,x?r?na?,??b?,c?r?n", out.toString());
-    }
-
-    @Test
-    public void testPrintWithEscapesEndWithoutCRLF() throws IOException {
-        final Reader in = new StringReader("x,y,x");
-        final Appendable out = new StringBuilder();
-        final CSVFormat format = CSVFormat.RFC4180.withEscape('?').withDelimiter(',').withQuote(null).withRecordSeparator(CRLF);
-        format.print(in,out,true);
-        assertEquals("x?,y?,x", out.toString());
-    }
-
-    @Test
-    public void testFormatToString() throws IOException {
-        final CSVFormat format = CSVFormat.RFC4180.withEscape('?').withDelimiter(',')
-                .withQuoteMode(QuoteMode.MINIMAL).withRecordSeparator(CRLF).withQuote('"')
-                .withNullString("").withIgnoreHeaderCase(true)
-                .withHeaderComments("This is HeaderComments").withHeader("col1","col2","col3");
-        assertEquals("Delimiter=<,> Escape= QuoteChar=<\"> QuoteMode= NullString=<> RecordSeparator=<" +CRLF+
-                "> IgnoreHeaderCase:ignored SkipHeaderRecord:false HeaderComments:[This is HeaderComments] Header:[col1, col2, col3]", format.toString());
-    }
-
-    @Test
-    public void testDelimiterSameAsRecordSeparatorThrowsException() {
-        assertThrows(IllegalArgumentException.class, () -> CSVFormat.newFormat(CR));
-    }
-
-    @Test
-    public void testWithHeaderEnumNull() {
-        final CSVFormat format =  CSVFormat.DEFAULT;
-        final Class> simpleName = null;
-        format.withHeader(simpleName);
-    }
-
-    @Test
-    public  void testWithHeaderResultSetNull() throws SQLException {
-        final CSVFormat format = CSVFormat.DEFAULT;
-        final ResultSet resultSet = null;
-        format.withHeader(resultSet);
-    }
-
-    @Test
-    public void testPrintWithQuoteModeIsNONE() throws IOException {
-        final Reader in = new StringReader("a,b,c");
-        final Appendable out = new StringBuilder();
-        final CSVFormat format = CSVFormat.RFC4180.withDelimiter(',').withQuote('"').withEscape('?').withQuoteMode(QuoteMode.NONE);
-        format.print(in, out, true);
-        assertEquals("a?,b?,c", out.toString());
-    }
-
-    @Test
-    public void testPrintWithQuotes() throws IOException {
-        final Reader in = new StringReader("\"a,b,c\r\nx,y,z");
-        final Appendable out = new StringBuilder();
-        final CSVFormat format = CSVFormat.RFC4180.withDelimiter(',').withQuote('"').withEscape('?').withQuoteMode(QuoteMode.NON_NUMERIC);
-        format.print(in, out, true);
-        assertEquals("\"\"\"\"a,b,c\r\nx,y,z\"", out.toString());
-    }
-
-    @Test
-    public void testPrintWithoutQuotes() throws IOException {
-        final Reader in = new StringReader("");
-        final Appendable out = new StringBuilder();
-        final CSVFormat format = CSVFormat.RFC4180.withDelimiter(',').withQuote('"').withEscape('?').withQuoteMode(QuoteMode.NON_NUMERIC);
-        format.print(in, out, true);
-        assertEquals("\"\"", out.toString());
-    }
-
-    @Test
-    public void testTrim() throws IOException {
-        final CSVFormat formatWithTrim = CSVFormat.DEFAULT.withDelimiter(',').withTrim().withQuote(null).withRecordSeparator(CRLF);
-
-        CharSequence in = "a,b,c";
-        final StringBuilder out = new StringBuilder();
-        formatWithTrim.print(in, out, true);
-        assertEquals("a,b,c", out.toString());
-
-        in = new StringBuilder(" x,y,z");
-        out.setLength(0);
-        formatWithTrim.print(in, out, true);
-        assertEquals("x,y,z", out.toString());
-
-        in = new StringBuilder("");
-        out.setLength(0);
-        formatWithTrim.print(in, out, true);
-        assertEquals("", out.toString());
-
-        in = new StringBuilder("header\r\n");
-        out.setLength(0);
-        formatWithTrim.print(in, out, true);
-        assertEquals("header", out.toString());
+        assertEquals(System.lineSeparator(), formatWithRecordSeparator.getRecordSeparator());
     }
 }
diff --git a/src/test/java/org/apache/commons/csv/CSVParserTest.java b/src/test/java/org/apache/commons/csv/CSVParserTest.java
index 0df4f0e192..6d9bdd9e80 100644
--- a/src/test/java/org/apache/commons/csv/CSVParserTest.java
+++ b/src/test/java/org/apache/commons/csv/CSVParserTest.java
@@ -1,18 +1,20 @@
 /*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *   https://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.
+ * 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 org.apache.commons.csv;
@@ -20,9 +22,10 @@
 import static org.apache.commons.csv.Constants.CR;
 import static org.apache.commons.csv.Constants.CRLF;
 import static org.apache.commons.csv.Constants.LF;
-import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.apache.commons.csv.CsvAssertions.assertValuesEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
@@ -30,12 +33,14 @@
 
 import java.io.File;
 import java.io.IOException;
+import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.PipedReader;
 import java.io.PipedWriter;
 import java.io.Reader;
 import java.io.StringReader;
 import java.io.StringWriter;
+import java.io.UncheckedIOException;
 import java.net.URL;
 import java.nio.charset.Charset;
 import java.nio.charset.StandardCharsets;
@@ -48,209 +53,250 @@
 import java.util.List;
 import java.util.Map;
 import java.util.NoSuchElementException;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import org.apache.commons.io.input.BOMInputStream;
+import org.apache.commons.io.input.BrokenInputStream;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.EnumSource;
+import org.junit.jupiter.params.provider.ValueSource;
 
 /**
- * CSVParserTest
+ * Tests {@link CSVParser}.
  *
- * The test are organized in three different sections: The 'setter/getter' section, the lexer section and finally the
- * parser section. In case a test fails, you should follow a top-down approach for fixing a potential bug (its likely
- * that the parser itself fails if the lexer has problems...).
+ * The test are organized in three different sections: The 'setter/getter' section, the lexer section and finally the parser section. In case a test fails, you
+ * should follow a top-down approach for fixing a potential bug (its likely that the parser itself fails if the lexer has problems...).
  */
-public class CSVParserTest {
+class CSVParserTest {
+
+    private static final CSVFormat EXCEL_WITH_HEADER = CSVFormat.EXCEL.withHeader();
 
     private static final Charset UTF_8 = StandardCharsets.UTF_8;
 
     private static final String UTF_8_NAME = UTF_8.name();
 
-    private static final String CSV_INPUT = "a,b,c,d\n" + " a , b , 1 2 \n" + "\"foo baar\", b,\n"
-    // + " \"foo\n,,\n\"\",,\n\\\"\",d,e\n";
-        + "   \"foo\n,,\n\"\",,\n\"\"\",d,e\n"; // changed to use standard CSV escaping
+    // @formatter:off
+    private static final String CSV_INPUT = "a,b,c,d\n" +
+            " a , b , 1 2 \n" +
+            "\"foo baar\", b,\n" +
+            // + " \"foo\n,,\n\"\",,\n\\\"\",d,e\n";
+            "   \"foo\n,,\n\"\",,\n\"\"\",d,e\n"; // changed to use standard CSV escaping
+    // @formatter:on
 
     private static final String CSV_INPUT_1 = "a,b,c,d";
 
     private static final String CSV_INPUT_2 = "a,b,1 2";
 
-    private static final String[][] RESULT = { { "a", "b", "c", "d" }, { "a", "b", "1 2" }, { "foo baar", "b", "" },
-        { "foo\n,,\n\",,\n\"", "d", "e" } };
+    private static final String[][] RESULT = { { "a", "b", "c", "d" }, { "a", "b", "1 2" }, { "foo baar", "b", "" }, { "foo\n,,\n\",,\n\"", "d", "e" } };
+
+    // CSV with no header comments
+    private static final String CSV_INPUT_NO_COMMENT = "A,B" + CRLF + "1,2" + CRLF;
+
+    // CSV with a header comment
+    private static final String CSV_INPUT_HEADER_COMMENT = "# header comment" + CRLF + "A,B" + CRLF + "1,2" + CRLF;
+
+    // CSV with a single line header and trailer comment
+    private static final String CSV_INPUT_HEADER_TRAILER_COMMENT = "# header comment" + CRLF + "A,B" + CRLF + "1,2" + CRLF + "# comment";
+
+    // CSV with a multi-line header and trailer comment
+    private static final String CSV_INPUT_MULTILINE_HEADER_TRAILER_COMMENT = "# multi-line" + CRLF + "# header comment" + CRLF + "A,B" + CRLF + "1,2" + CRLF +
+            "# multi-line" + CRLF + "# comment";
+
+    // Format with auto-detected header
+    private static final CSVFormat FORMAT_AUTO_HEADER = CSVFormat.Builder.create(CSVFormat.DEFAULT).setCommentMarker('#').setHeader().get();
+
+    // Format with explicit header
+    // @formatter:off
+    private static final CSVFormat FORMAT_EXPLICIT_HEADER = CSVFormat.Builder.create(CSVFormat.DEFAULT)
+            .setSkipHeaderRecord(true)
+            .setCommentMarker('#')
+            .setHeader("A", "B")
+            .get();
+    // @formatter:on
+
+    // Format with explicit header that does not skip the header line
+    // @formatter:off
+    CSVFormat FORMAT_EXPLICIT_HEADER_NOSKIP = CSVFormat.Builder.create(CSVFormat.DEFAULT)
+            .setCommentMarker('#')
+            .setHeader("A", "B")
+            .get();
+    // @formatter:on
 
+    @SuppressWarnings("resource") // caller releases
     private BOMInputStream createBOMInputStream(final String resource) throws IOException {
-        final URL url = ClassLoader.getSystemClassLoader().getResource(resource);
-        return new BOMInputStream(url.openStream());
+        return new BOMInputStream(ClassLoader.getSystemClassLoader().getResource(resource).openStream());
     }
 
-    private void parseFully(final CSVParser parser) {
-        for (final CSVRecord csvRecord : parser) {
-            assertNotNull(csvRecord);
+    CSVRecord parse(final CSVParser parser, final int failParseRecordNo) throws IOException {
+        if (parser.getRecordNumber() + 1 == failParseRecordNo) {
+            assertThrows(IOException.class, () -> parser.nextRecord());
+            return null;
         }
+        return parser.nextRecord();
     }
 
-    @Test
-    public void testBackslashEscaping() throws IOException {
+    private void parseFully(final CSVParser parser) {
+        parser.forEach(Assertions::assertNotNull);
+    }
 
+    @Test
+    void testBackslashEscaping() throws IOException {
         // To avoid confusion over the need for escaping chars in java code,
         // We will test with a forward slash as the escape char, and a single
         // quote as the encapsulator.
 
-        final String code = "one,two,three\n" // 0
-            + "'',''\n" // 1) empty encapsulators
-            + "/',/'\n" // 2) single encapsulators
-            + "'/'','/''\n" // 3) single encapsulators encapsulated via escape
-            + "'''',''''\n" // 4) single encapsulators encapsulated via doubling
-            + "/,,/,\n" // 5) separator escaped
-            + "//,//\n" // 6) escape escaped
-            + "'//','//'\n" // 7) escape escaped in encapsulation
-            + "   8   ,   \"quoted \"\" /\" // string\"   \n" // don't eat spaces
-            + "9,   /\n   \n" // escaped newline
-            + "";
-        final String[][] res = { { "one", "two", "three" }, // 0
-            { "", "" }, // 1
-            { "'", "'" }, // 2
-            { "'", "'" }, // 3
-            { "'", "'" }, // 4
-            { ",", "," }, // 5
-            { "/", "/" }, // 6
-            { "/", "/" }, // 7
-            { "   8   ", "   \"quoted \"\" /\" / string\"   " }, { "9", "   \n   " }, };
-
-        final CSVFormat format = CSVFormat.newFormat(',').withQuote('\'').withRecordSeparator(CRLF).withEscape('/')
-            .withIgnoreEmptyLines();
-
-        try (final CSVParser parser = CSVParser.parse(code, format)) {
+        // @formatter:off
+        final String code = "one,two,three\n" + // 0
+            "'',''\n" + // 1) empty encapsulators
+            "/',/'\n" + // 2) single encapsulators
+            "'/'','/''\n" + // 3) single encapsulators encapsulated via escape
+            "'''',''''\n" + // 4) single encapsulators encapsulated via doubling
+            "/,,/,\n" + // 5) separator escaped
+            "//,//\n" + // 6) escape escaped
+            "'//','//'\n" + // 7) escape escaped in encapsulation
+            "   8   ,   \"quoted \"\" /\" // string\"   \n" + // don't eat spaces
+            "9,   /\n   \n" + // escaped newline
+            "";
+        final String[][] res = {{"one", "two", "three"}, // 0
+            {"", ""}, // 1
+            {"'", "'"}, // 2
+            {"'", "'"}, // 3
+            {"'", "'"}, // 4
+            {",", ","}, // 5
+            {"/", "/"}, // 6
+            {"/", "/"}, // 7
+            {"   8   ", "   \"quoted \"\" /\" / string\"   "}, {"9", "   \n   "} };
+        // @formatter:on
+        final CSVFormat format = CSVFormat.newFormat(',').withQuote('\'').withRecordSeparator(CRLF).withEscape('/').withIgnoreEmptyLines();
+        try (CSVParser parser = CSVParser.parse(code, format)) {
             final List records = parser.getRecords();
-            assertTrue(records.size() > 0);
-
-            Utils.compare("Records do not match expected result", res, records);
+            assertFalse(records.isEmpty());
+            Utils.compare("Records do not match expected result", res, records, -1);
         }
     }
 
     @Test
-    public void testBackslashEscaping2() throws IOException {
-
+    void testBackslashEscaping2() throws IOException {
         // To avoid confusion over the need for escaping chars in java code,
         // We will test with a forward slash as the escape char, and a single
         // quote as the encapsulator.
-
-        final String code = "" + " , , \n" // 1)
-            + " \t ,  , \n" // 2)
-            + " // , /, , /,\n" // 3)
-            + "";
-        final String[][] res = { { " ", " ", " " }, // 1
-            { " \t ", "  ", " " }, // 2
-            { " / ", " , ", " ," }, // 3
+        // @formatter:off
+        final String code = " , , \n" + // 1)
+            " \t ,  , \n" + // 2)
+            " // , /, , /,\n" + // 3)
+            "";
+        final String[][] res = {{" ", " ", " "}, // 1
+            {" \t ", "  ", " "}, // 2
+            {" / ", " , ", " ,"}, // 3
         };
-
-        final CSVFormat format = CSVFormat.newFormat(',').withRecordSeparator(CRLF).withEscape('/')
-            .withIgnoreEmptyLines();
-
-        try (final CSVParser parser = CSVParser.parse(code, format)) {
+        // @formatter:on
+        final CSVFormat format = CSVFormat.newFormat(',').withRecordSeparator(CRLF).withEscape('/').withIgnoreEmptyLines();
+        try (CSVParser parser = CSVParser.parse(code, format)) {
             final List records = parser.getRecords();
-            assertTrue(records.size() > 0);
-
-            Utils.compare("", res, records);
+            assertFalse(records.isEmpty());
+            Utils.compare("", res, records, -1);
         }
     }
 
     @Test
     @Disabled
-    public void testBackslashEscapingOld() throws IOException {
-        final String code = "one,two,three\n" + "on\\\"e,two\n" + "on\"e,two\n" + "one,\"tw\\\"o\"\n"
-            + "one,\"t\\,wo\"\n" + "one,two,\"th,ree\"\n" + "\"a\\\\\"\n" + "a\\,b\n" + "\"a\\\\,b\"";
-        final String[][] res = { { "one", "two", "three" }, { "on\\\"e", "two" }, { "on\"e", "two" },
-            { "one", "tw\"o" }, { "one", "t\\,wo" }, // backslash in quotes only escapes a delimiter (",")
-            { "one", "two", "th,ree" }, { "a\\\\" }, // backslash in quotes only escapes a delimiter (",")
-            { "a\\", "b" }, // a backslash must be returned
-            { "a\\\\,b" } // backslash in quotes only escapes a delimiter (",")
+    void testBackslashEscapingOld() throws IOException {
+        // @formatter:off
+        final String code = "one,two,three\n" +
+                "on\\\"e,two\n" +
+                "on\"e,two\n" +
+                "one,\"tw\\\"o\"\n" +
+                "one,\"t\\,wo\"\n" +
+                "one,two,\"th,ree\"\n" +
+                "\"a\\\\\"\n" +
+                "a\\,b\n" +
+                "\"a\\\\,b\"";
+        // @formatter:on
+        final String[][] res = { { "one", "two", "three" }, { "on\\\"e", "two" }, { "on\"e", "two" }, { "one", "tw\"o" }, { "one", "t\\,wo" }, // backslash in
+                                                                                                                                               // quotes only
+                                                                                                                                               // escapes a
+                                                                                                                                               // delimiter
+                                                                                                                                               // (",")
+                { "one", "two", "th,ree" }, { "a\\\\" }, // backslash in quotes only escapes a delimiter (",")
+                { "a\\", "b" }, // a backslash must be returned
+                { "a\\\\,b" } // backslash in quotes only escapes a delimiter (",")
         };
-        try (final CSVParser parser = CSVParser.parse(code, CSVFormat.DEFAULT)) {
+        try (CSVParser parser = CSVParser.parse(code, CSVFormat.DEFAULT)) {
             final List records = parser.getRecords();
             assertEquals(res.length, records.size());
-            assertTrue(records.size() > 0);
+            assertFalse(records.isEmpty());
             for (int i = 0; i < res.length; i++) {
-                assertArrayEquals(res[i], records.get(i).values());
+                assertValuesEquals(res[i], records.get(i));
             }
         }
     }
 
     @Test
     @Disabled("CSV-107")
-    public void testBOM() throws IOException {
+    void testBOM() throws IOException {
         final URL url = ClassLoader.getSystemClassLoader().getResource("org/apache/commons/csv/CSVFileParser/bom.csv");
-        try (final CSVParser parser = CSVParser.parse(url, Charset.forName(UTF_8_NAME), CSVFormat.EXCEL.withHeader())) {
-            for (final CSVRecord record : parser) {
-                final String string = record.get("Date");
-                assertNotNull(string);
-                // System.out.println("date: " + record.get("Date"));
-            }
+        try (CSVParser parser = CSVParser.parse(url, StandardCharsets.UTF_8, EXCEL_WITH_HEADER)) {
+            parser.forEach(record -> assertNotNull(record.get("Date")));
         }
     }
 
     @Test
-    public void testBOMInputStream_ParserWithInputStream() throws IOException {
-        try (final BOMInputStream inputStream = createBOMInputStream("org/apache/commons/csv/CSVFileParser/bom.csv");
-            final CSVParser parser = CSVParser.parse(inputStream, UTF_8, CSVFormat.EXCEL.withHeader())) {
-            for (final CSVRecord record : parser) {
-                final String string = record.get("Date");
-                assertNotNull(string);
-                // System.out.println("date: " + record.get("Date"));
-            }
+    void testBOMInputStreamParserWithInputStream() throws IOException {
+        try (BOMInputStream inputStream = createBOMInputStream("org/apache/commons/csv/CSVFileParser/bom.csv");
+                CSVParser parser = CSVParser.parse(inputStream, UTF_8, EXCEL_WITH_HEADER)) {
+            parser.forEach(record -> assertNotNull(record.get("Date")));
         }
     }
 
     @Test
-    public void testBOMInputStream_ParserWithReader() throws IOException {
-        try (
-            final Reader reader = new InputStreamReader(
-                createBOMInputStream("org/apache/commons/csv/CSVFileParser/bom.csv"), UTF_8_NAME);
-            final CSVParser parser = new CSVParser(reader, CSVFormat.EXCEL.withHeader())) {
-            for (final CSVRecord record : parser) {
-                final String string = record.get("Date");
-                assertNotNull(string);
-                // System.out.println("date: " + record.get("Date"));
-            }
+    void testBOMInputStreamParserWithReader() throws IOException {
+        try (Reader reader = new InputStreamReader(createBOMInputStream("org/apache/commons/csv/CSVFileParser/bom.csv"), UTF_8_NAME);
+                CSVParser parser = CSVParser.builder()
+                        .setReader(reader)
+                        .setFormat(EXCEL_WITH_HEADER)
+                        .get()) {
+            parser.forEach(record -> assertNotNull(record.get("Date")));
         }
     }
 
     @Test
-    public void testBOMInputStream_parseWithReader() throws IOException {
-        try (
-            final Reader reader = new InputStreamReader(
-                createBOMInputStream("org/apache/commons/csv/CSVFileParser/bom.csv"), UTF_8_NAME);
-            final CSVParser parser = CSVParser.parse(reader, CSVFormat.EXCEL.withHeader())) {
-            for (final CSVRecord record : parser) {
-                final String string = record.get("Date");
-                assertNotNull(string);
-                // System.out.println("date: " + record.get("Date"));
-            }
+    void testBOMInputStreamParseWithReader() throws IOException {
+        try (Reader reader = new InputStreamReader(createBOMInputStream("org/apache/commons/csv/CSVFileParser/bom.csv"), UTF_8_NAME);
+                CSVParser parser = CSVParser.builder()
+                        .setReader(reader)
+                        .setFormat(EXCEL_WITH_HEADER)
+                        .get()) {
+            parser.forEach(record -> assertNotNull(record.get("Date")));
         }
     }
 
     @Test
-    public void testCarriageReturnEndings() throws IOException {
-        final String code = "foo\rbaar,\rhello,world\r,kanu";
-        try (final CSVParser parser = CSVParser.parse(code, CSVFormat.DEFAULT)) {
+    void testCarriageReturnEndings() throws IOException {
+        final String string = "foo\rbaar,\rhello,world\r,kanu";
+        try (CSVParser parser = CSVParser.builder().setCharSequence(string).get()) {
             final List records = parser.getRecords();
             assertEquals(4, records.size());
         }
     }
 
     @Test
-    public void testCarriageReturnLineFeedEndings() throws IOException {
-        final String code = "foo\r\nbaar,\r\nhello,world\r\n,kanu";
-        try (final CSVParser parser = CSVParser.parse(code, CSVFormat.DEFAULT)) {
+    void testCarriageReturnLineFeedEndings() throws IOException {
+        final String string = "foo\r\nbaar,\r\nhello,world\r\n,kanu";
+        try (CSVParser parser = CSVParser.builder().setCharSequence(string).get()) {
             final List records = parser.getRecords();
             assertEquals(4, records.size());
         }
     }
 
     @Test
-    public void testClose() throws Exception {
+    void testClose() throws Exception {
         final Reader in = new StringReader("# comment\na,b,c\n1,2,3\nx,y,z");
         final Iterator records;
-        try (final CSVParser parser = CSVFormat.DEFAULT.withCommentMarker('#').withHeader().parse(in)) {
+        try (CSVParser parser = CSVFormat.DEFAULT.withCommentMarker('#').withHeader().parse(in)) {
             records = parser.iterator();
             assertTrue(records.hasNext());
         }
@@ -259,8 +305,122 @@ public void testClose() throws Exception {
     }
 
     @Test
-    public void testCSV57() throws Exception {
-        try (final CSVParser parser = CSVParser.parse("", CSVFormat.DEFAULT)) {
+    void testCSV141CSVFormat_DEFAULT() throws Exception {
+        testCSV141Failure(CSVFormat.DEFAULT, 3);
+    }
+
+    @Test
+    void testCSV141CSVFormat_INFORMIX_UNLOAD() throws Exception {
+        testCSV141Failure(CSVFormat.INFORMIX_UNLOAD, 1);
+    }
+
+    @Test
+    void testCSV141CSVFormat_INFORMIX_UNLOAD_CSV() throws Exception {
+        testCSV141Failure(CSVFormat.INFORMIX_UNLOAD_CSV, 3);
+    }
+
+    @Test
+    void testCSV141CSVFormat_ORACLE() throws Exception {
+        testCSV141Failure(CSVFormat.ORACLE, 2);
+    }
+
+    @Test
+    void testCSV141CSVFormat_POSTGRESQL_CSV() throws Exception {
+        testCSV141Failure(CSVFormat.POSTGRESQL_CSV, 3);
+    }
+
+    @Test
+    void testCSV141Excel() throws Exception {
+        testCSV141Ok(CSVFormat.EXCEL);
+    }
+
+    private void testCSV141Failure(final CSVFormat format, final int failParseRecordNo) throws IOException {
+        final Path path = Paths.get("src/test/resources/org/apache/commons/csv/CSV-141/csv-141.csv");
+        try (CSVParser parser = CSVParser.parse(path, StandardCharsets.UTF_8, format)) {
+            // row 1
+            CSVRecord record = parse(parser, failParseRecordNo);
+            if (record == null) {
+                return; // expected failure
+            }
+            assertEquals("1414770317901", record.get(0));
+            assertEquals("android.widget.EditText", record.get(1));
+            assertEquals("pass sem1 _84*|*", record.get(2));
+            assertEquals("0", record.get(3));
+            assertEquals("pass sem1 _8", record.get(4));
+            assertEquals(5, record.size());
+            // row 2
+            record = parse(parser, failParseRecordNo);
+            if (record == null) {
+                return; // expected failure
+            }
+            assertEquals("1414770318470", record.get(0));
+            assertEquals("android.widget.EditText", record.get(1));
+            assertEquals("pass sem1 _84:|", record.get(2));
+            assertEquals("0", record.get(3));
+            assertEquals("pass sem1 _84:\\", record.get(4));
+            assertEquals(5, record.size());
+            // row 3: Fail for certain
+            assertThrows(IOException.class, () -> parser.nextRecord());
+        }
+    }
+
+    private void testCSV141Ok(final CSVFormat format) throws IOException {
+        final Path path = Paths.get("src/test/resources/org/apache/commons/csv/CSV-141/csv-141.csv");
+        try (CSVParser parser = CSVParser.parse(path, StandardCharsets.UTF_8, format)) {
+            // row 1
+            CSVRecord record = parser.nextRecord();
+            assertEquals("1414770317901", record.get(0));
+            assertEquals("android.widget.EditText", record.get(1));
+            assertEquals("pass sem1 _84*|*", record.get(2));
+            assertEquals("0", record.get(3));
+            assertEquals("pass sem1 _8", record.get(4));
+            assertEquals(5, record.size());
+            // row 2
+            record = parser.nextRecord();
+            assertEquals("1414770318470", record.get(0));
+            assertEquals("android.widget.EditText", record.get(1));
+            assertEquals("pass sem1 _84:|", record.get(2));
+            assertEquals("0", record.get(3));
+            assertEquals("pass sem1 _84:\\", record.get(4));
+            assertEquals(5, record.size());
+            // row 3
+            record = parser.nextRecord();
+            assertEquals("1414770318327", record.get(0));
+            assertEquals("android.widget.EditText", record.get(1));
+            assertEquals("pass sem1\n1414770318628\"", record.get(2));
+            assertEquals("android.widget.EditText", record.get(3));
+            assertEquals("pass sem1 _84*|*", record.get(4));
+            assertEquals("0", record.get(5));
+            assertEquals("pass sem1\n", record.get(6));
+            assertEquals(7, record.size());
+            // EOF
+            record = parser.nextRecord();
+            assertNull(record);
+        }
+    }
+
+    @Test
+    void testCSV141RFC4180() throws Exception {
+        testCSV141Failure(CSVFormat.RFC4180, 3);
+    }
+
+    @Test
+    void testCSV235() throws IOException {
+        final String dqString = "\"aaa\",\"b\"\"bb\",\"ccc\""; // "aaa","b""bb","ccc"
+        try (CSVParser parser = CSVFormat.RFC4180.parse(new StringReader(dqString))) {
+            final Iterator records = parser.iterator();
+            final CSVRecord record = records.next();
+            assertFalse(records.hasNext());
+            assertEquals(3, record.size());
+            assertEquals("aaa", record.get(0));
+            assertEquals("b\"bb", record.get(1));
+            assertEquals("ccc", record.get(2));
+        }
+    }
+
+    @Test
+    void testCSV57() throws Exception {
+        try (CSVParser parser = CSVParser.parse("", CSVFormat.DEFAULT)) {
             final List list = parser.getRecords();
             assertNotNull(list);
             assertEquals(0, list.size());
@@ -268,183 +428,210 @@ public void testCSV57() throws Exception {
     }
 
     @Test
-    public void testDefaultFormat() throws IOException {
-        final String code = "" + "a,b#\n" // 1)
-            + "\"\n\",\" \",#\n" // 2)
-            + "#,\"\"\n" // 3)
-            + "# Final comment\n"// 4)
+    void testDefaultFormat() throws IOException {
+        // @formatter:off
+        final String code = "a,b#\n" +      // 1)
+            "\"\n\",\" \",#\n" +            // 2)
+            "#,\"\"\n" +                    // 3)
+            "# Final comment\n"             // 4)
         ;
+        // @formatter:on
         final String[][] res = { { "a", "b#" }, { "\n", " ", "#" }, { "#", "" }, { "# Final comment" } };
-
         CSVFormat format = CSVFormat.DEFAULT;
         assertFalse(format.isCommentMarkerSet());
-        final String[][] res_comments = { { "a", "b#" }, { "\n", " ", "#" }, };
-
-        try (final CSVParser parser = CSVParser.parse(code, format)) {
+        final String[][] resComments = { { "a", "b#" }, { "\n", " ", "#" } };
+        try (CSVParser parser = CSVParser.parse(code, format)) {
             final List records = parser.getRecords();
-            assertTrue(records.size() > 0);
-
-            Utils.compare("Failed to parse without comments", res, records);
-
+            assertFalse(records.isEmpty());
+            Utils.compare("Failed to parse without comments", res, records, -1);
             format = CSVFormat.DEFAULT.withCommentMarker('#');
         }
-        try (final CSVParser parser = CSVParser.parse(code, format)) {
+        try (CSVParser parser = CSVParser.parse(code, format)) {
             final List records = parser.getRecords();
+            Utils.compare("Failed to parse with comments", resComments, records, -1);
+        }
+    }
 
-            Utils.compare("Failed to parse with comments", res_comments, records);
+    @Test
+    void testDuplicateHeadersAllowedByDefault() throws Exception {
+        try (CSVParser parser = CSVParser.parse("a,b,a\n1,2,3\nx,y,z", CSVFormat.DEFAULT.withHeader())) {
+            // noop
         }
     }
 
     @Test
-    public void testDuplicateHeadersNotAllowed() {
-        assertThrows(IllegalArgumentException.class, () -> CSVParser.parse("a,b,a\n1,2,3\nx,y,z",
-            CSVFormat.DEFAULT.withHeader().withAllowDuplicateHeaderNames(false)));
+    void testDuplicateHeadersNotAllowed() {
+        assertThrows(IllegalArgumentException.class,
+                () -> CSVParser.parse("a,b,a\n1,2,3\nx,y,z", CSVFormat.DEFAULT.withHeader().withAllowDuplicateHeaderNames(false)));
     }
 
+    /**
+     * With {@code ignoreSurroundingSpaces} enabled and a multi-character delimiter whose first character is whitespace,
+     * the empty field at the delimiter boundary must survive. The delimiter look-ahead is consumed while skipping
+     * leading whitespace, so re-evaluating it would drop the empty field and merge the following field's value.
+     */
     @Test
-    public void testDuplicateHeadersAllowedByDefault() throws Exception {
-        CSVParser.parse("a,b,a\n1,2,3\nx,y,z", CSVFormat.DEFAULT.withHeader());
+    void testEmptyFieldBeforeWhitespacePrefixedMultiCharacterDelimiter() throws IOException {
+        final CSVFormat format = CSVFormat.DEFAULT.builder().setDelimiter(" |").setIgnoreSurroundingSpaces(true).get();
+        try (CSVParser parser = CSVParser.parse(" |a", format)) {
+            final List records = parser.getRecords();
+            assertEquals(1, records.size());
+            assertValuesEquals(new String[] { "", "a" }, records.get(0));
+        }
+        try (CSVParser parser = CSVParser.parse("a | |b", format)) {
+            final List records = parser.getRecords();
+            assertEquals(1, records.size());
+            assertValuesEquals(new String[] { "a", "", "b" }, records.get(0));
+        }
+        try (CSVParser parser = CSVParser.parse("a | |b |", format)) {
+            final List records = parser.getRecords();
+            assertEquals(1, records.size());
+            assertValuesEquals(new String[] { "a", "", "b", "" }, records.get(0));
+        }
     }
 
     @Test
-    public void testEmptyFileHeaderParsing() throws Exception {
-        try (final CSVParser parser = CSVParser.parse("", CSVFormat.DEFAULT.withFirstRecordAsHeader())) {
+    void testEmptyFile() throws Exception {
+        try (CSVParser parser = CSVParser.parse(Paths.get("src/test/resources/org/apache/commons/csv/empty.txt"), StandardCharsets.UTF_8,
+                CSVFormat.DEFAULT)) {
             assertNull(parser.nextRecord());
-            assertTrue(parser.getHeaderNames().isEmpty());
         }
     }
 
     @Test
-    public void testEmptyFile() throws Exception {
-        try (final CSVParser parser = CSVParser.parse("", CSVFormat.DEFAULT)) {
+    void testEmptyFileHeaderParsing() throws Exception {
+        try (CSVParser parser = CSVParser.parse("", CSVFormat.DEFAULT.withFirstRecordAsHeader())) {
             assertNull(parser.nextRecord());
+            assertTrue(parser.getHeaderNames().isEmpty());
         }
     }
 
     @Test
-    public void testEmptyLineBehaviorCSV() throws Exception {
+    void testEmptyLineBehaviorCSV() throws Exception {
         final String[] codes = { "hello,\r\n\r\n\r\n", "hello,\n\n\n", "hello,\"\"\r\n\r\n\r\n", "hello,\"\"\n\n\n" };
         final String[][] res = { { "hello", "" } // CSV format ignores empty lines
         };
         for (final String code : codes) {
-            try (final CSVParser parser = CSVParser.parse(code, CSVFormat.DEFAULT)) {
+            try (CSVParser parser = CSVParser.parse(code, CSVFormat.DEFAULT)) {
                 final List records = parser.getRecords();
                 assertEquals(res.length, records.size());
-                assertTrue(records.size() > 0);
+                assertFalse(records.isEmpty());
                 for (int i = 0; i < res.length; i++) {
-                    assertArrayEquals(res[i], records.get(i).values());
+                    assertValuesEquals(res[i], records.get(i));
                 }
             }
         }
     }
 
     @Test
-    public void testEmptyLineBehaviorExcel() throws Exception {
+    void testEmptyLineBehaviorExcel() throws Exception {
         final String[] codes = { "hello,\r\n\r\n\r\n", "hello,\n\n\n", "hello,\"\"\r\n\r\n\r\n", "hello,\"\"\n\n\n" };
         final String[][] res = { { "hello", "" }, { "" }, // Excel format does not ignore empty lines
-            { "" } };
+                { "" } };
         for (final String code : codes) {
-            try (final CSVParser parser = CSVParser.parse(code, CSVFormat.EXCEL)) {
+            try (CSVParser parser = CSVParser.parse(code, CSVFormat.EXCEL)) {
                 final List records = parser.getRecords();
                 assertEquals(res.length, records.size());
-                assertTrue(records.size() > 0);
+                assertFalse(records.isEmpty());
                 for (int i = 0; i < res.length; i++) {
-                    assertArrayEquals(res[i], records.get(i).values());
+                    assertValuesEquals(res[i], records.get(i));
                 }
             }
         }
     }
 
     @Test
-    public void testEndOfFileBehaviorCSV() throws Exception {
-        final String[] codes = { "hello,\r\n\r\nworld,\r\n", "hello,\r\n\r\nworld,", "hello,\r\n\r\nworld,\"\"\r\n",
-            "hello,\r\n\r\nworld,\"\"", "hello,\r\n\r\nworld,\n", "hello,\r\n\r\nworld,", "hello,\r\n\r\nworld,\"\"\n",
-            "hello,\r\n\r\nworld,\"\"" };
+    void testEmptyString() throws Exception {
+        try (CSVParser parser = CSVParser.parse("", CSVFormat.DEFAULT)) {
+            assertNull(parser.nextRecord());
+        }
+    }
+
+    @Test
+    void testEndOfFileBehaviorCSV() throws Exception {
+        final String[] codes = { "hello,\r\n\r\nworld,\r\n", "hello,\r\n\r\nworld,", "hello,\r\n\r\nworld,\"\"\r\n", "hello,\r\n\r\nworld,\"\"",
+                "hello,\r\n\r\nworld,\n", "hello,\r\n\r\nworld,", "hello,\r\n\r\nworld,\"\"\n", "hello,\r\n\r\nworld,\"\"" };
         final String[][] res = { { "hello", "" }, // CSV format ignores empty lines
-            { "world", "" } };
+                { "world", "" } };
         for (final String code : codes) {
-            try (final CSVParser parser = CSVParser.parse(code, CSVFormat.DEFAULT)) {
+            try (CSVParser parser = CSVParser.parse(code, CSVFormat.DEFAULT)) {
                 final List records = parser.getRecords();
                 assertEquals(res.length, records.size());
-                assertTrue(records.size() > 0);
+                assertFalse(records.isEmpty());
                 for (int i = 0; i < res.length; i++) {
-                    assertArrayEquals(res[i], records.get(i).values());
+                    assertValuesEquals(res[i], records.get(i));
                 }
             }
         }
     }
 
     @Test
-    public void testEndOfFileBehaviorExcel() throws Exception {
-        final String[] codes = { "hello,\r\n\r\nworld,\r\n", "hello,\r\n\r\nworld,", "hello,\r\n\r\nworld,\"\"\r\n",
-            "hello,\r\n\r\nworld,\"\"", "hello,\r\n\r\nworld,\n", "hello,\r\n\r\nworld,", "hello,\r\n\r\nworld,\"\"\n",
-            "hello,\r\n\r\nworld,\"\"" };
+    void testEndOfFileBehaviorExcel() throws Exception {
+        final String[] codes = { "hello,\r\n\r\nworld,\r\n", "hello,\r\n\r\nworld,", "hello,\r\n\r\nworld,\"\"\r\n", "hello,\r\n\r\nworld,\"\"",
+                "hello,\r\n\r\nworld,\n", "hello,\r\n\r\nworld,", "hello,\r\n\r\nworld,\"\"\n", "hello,\r\n\r\nworld,\"\"" };
         final String[][] res = { { "hello", "" }, { "" }, // Excel format does not ignore empty lines
-            { "world", "" } };
+                { "world", "" } };
 
         for (final String code : codes) {
-            try (final CSVParser parser = CSVParser.parse(code, CSVFormat.EXCEL)) {
+            try (CSVParser parser = CSVParser.parse(code, CSVFormat.EXCEL)) {
                 final List records = parser.getRecords();
                 assertEquals(res.length, records.size());
-                assertTrue(records.size() > 0);
+                assertFalse(records.isEmpty());
                 for (int i = 0; i < res.length; i++) {
-                    assertArrayEquals(res[i], records.get(i).values());
+                    assertValuesEquals(res[i], records.get(i));
                 }
             }
         }
     }
 
     @Test
-    public void testExcelFormat1() throws IOException {
-        final String code = "value1,value2,value3,value4\r\na,b,c,d\r\n  x,,,"
-            + "\r\n\r\n\"\"\"hello\"\"\",\"  \"\"world\"\"\",\"abc\ndef\",\r\n";
-        final String[][] res = { { "value1", "value2", "value3", "value4" }, { "a", "b", "c", "d" },
-            { "  x", "", "", "" }, { "" }, { "\"hello\"", "  \"world\"", "abc\ndef", "" } };
-        try (final CSVParser parser = CSVParser.parse(code, CSVFormat.EXCEL)) {
+    void testExcelFormat1() throws IOException {
+        final String code = "value1,value2,value3,value4\r\na,b,c,d\r\n  x,,,\r\n\r\n\"\"\"hello\"\"\",\"  \"\"world\"\"\",\"abc\ndef\",\r\n";
+        final String[][] res = { { "value1", "value2", "value3", "value4" }, { "a", "b", "c", "d" }, { "  x", "", "", "" }, { "" },
+                { "\"hello\"", "  \"world\"", "abc\ndef", "" } };
+        try (CSVParser parser = CSVParser.parse(code, CSVFormat.EXCEL)) {
             final List records = parser.getRecords();
             assertEquals(res.length, records.size());
-            assertTrue(records.size() > 0);
+            assertFalse(records.isEmpty());
             for (int i = 0; i < res.length; i++) {
-                assertArrayEquals(res[i], records.get(i).values());
+                assertValuesEquals(res[i], records.get(i));
             }
         }
     }
 
     @Test
-    public void testExcelFormat2() throws Exception {
+    void testExcelFormat2() throws Exception {
         final String code = "foo,baar\r\n\r\nhello,\r\n\r\nworld,\r\n";
         final String[][] res = { { "foo", "baar" }, { "" }, { "hello", "" }, { "" }, { "world", "" } };
-        try (final CSVParser parser = CSVParser.parse(code, CSVFormat.EXCEL)) {
+        try (CSVParser parser = CSVParser.parse(code, CSVFormat.EXCEL)) {
             final List records = parser.getRecords();
             assertEquals(res.length, records.size());
-            assertTrue(records.size() > 0);
+            assertFalse(records.isEmpty());
             for (int i = 0; i < res.length; i++) {
-                assertArrayEquals(res[i], records.get(i).values());
+                assertValuesEquals(res[i], records.get(i));
             }
         }
     }
 
     /**
      * Tests an exported Excel worksheet with a header row and rows that have more columns than the headers
-     *
-     * @throws Exception
      */
     @Test
-    public void testExcelHeaderCountLessThanData() throws Exception {
+    void testExcelHeaderCountLessThanData() throws Exception {
         final String code = "A,B,C,,\r\na,b,c,d,e\r\n";
-        try (final CSVParser parser = CSVParser.parse(code, CSVFormat.EXCEL.withHeader())) {
-            for (final CSVRecord record : parser.getRecords()) {
+        try (CSVParser parser = CSVParser.parse(code, EXCEL_WITH_HEADER)) {
+            parser.getRecords().forEach(record -> {
                 assertEquals("a", record.get("A"));
                 assertEquals("b", record.get("B"));
                 assertEquals("c", record.get("C"));
-            }
+            });
         }
     }
 
     @Test
-    public void testFirstEndOfLineCr() throws IOException {
+    void testFirstEndOfLineCr() throws IOException {
         final String data = "foo\rbaar,\rhello,world\r,kanu";
-        try (final CSVParser parser = CSVParser.parse(data, CSVFormat.DEFAULT)) {
+        try (CSVParser parser = CSVParser.parse(data, CSVFormat.DEFAULT)) {
             final List records = parser.getRecords();
             assertEquals(4, records.size());
             assertEquals("\r", parser.getFirstEndOfLine());
@@ -452,9 +639,9 @@ public void testFirstEndOfLineCr() throws IOException {
     }
 
     @Test
-    public void testFirstEndOfLineCrLf() throws IOException {
+    void testFirstEndOfLineCrLf() throws IOException {
         final String data = "foo\r\nbaar,\r\nhello,world\r\n,kanu";
-        try (final CSVParser parser = CSVParser.parse(data, CSVFormat.DEFAULT)) {
+        try (CSVParser parser = CSVParser.parse(data, CSVFormat.DEFAULT)) {
             final List records = parser.getRecords();
             assertEquals(4, records.size());
             assertEquals("\r\n", parser.getFirstEndOfLine());
@@ -462,9 +649,9 @@ public void testFirstEndOfLineCrLf() throws IOException {
     }
 
     @Test
-    public void testFirstEndOfLineLf() throws IOException {
+    void testFirstEndOfLineLf() throws IOException {
         final String data = "foo\nbaar,\nhello,world\n,kanu";
-        try (final CSVParser parser = CSVParser.parse(data, CSVFormat.DEFAULT)) {
+        try (CSVParser parser = CSVParser.parse(data, CSVFormat.DEFAULT)) {
             final List records = parser.getRecords();
             assertEquals(4, records.size());
             assertEquals("\n", parser.getFirstEndOfLine());
@@ -472,23 +659,187 @@ public void testFirstEndOfLineLf() throws IOException {
     }
 
     @Test
-    public void testForEach() throws Exception {
-        final List records = new ArrayList<>();
-        try (final Reader in = new StringReader("a,b,c\n1,2,3\nx,y,z")) {
-            for (final CSVRecord record : CSVFormat.DEFAULT.parse(in)) {
+    void testForEach() throws Exception {
+        try (Reader in = new StringReader("a,b,c\n1,2,3\nx,y,z");
+                CSVParser parser = CSVFormat.DEFAULT.parse(in)) {
+            final List records = new ArrayList<>();
+            for (final CSVRecord record : parser) {
                 records.add(record);
             }
             assertEquals(3, records.size());
-            assertArrayEquals(new String[] { "a", "b", "c" }, records.get(0).values());
-            assertArrayEquals(new String[] { "1", "2", "3" }, records.get(1).values());
-            assertArrayEquals(new String[] { "x", "y", "z" }, records.get(2).values());
+            assertValuesEquals(new String[] { "a", "b", "c" }, records.get(0));
+            assertValuesEquals(new String[] { "1", "2", "3" }, records.get(1));
+            assertValuesEquals(new String[] { "x", "y", "z" }, records.get(2));
+        }
+    }
+
+    @Test
+    void testGetBytePositionMultiCharacterDelimiter() throws IOException {
+        final String code = "aa[|]bb\ncc[|]dd\n";
+        final CSVFormat format = CSVFormat.DEFAULT.builder().setDelimiter("[|]").get();
+        try (CSVParser parser = CSVParser.builder()
+                .setReader(new StringReader(code))
+                .setFormat(format)
+                .setCharset(StandardCharsets.UTF_8)
+                .setTrackBytes(true)
+                .get()) {
+            final Iterator it = parser.iterator();
+            final CSVRecord first = it.next();
+            final CSVRecord second = it.next();
+            assertEquals(0, first.getBytePosition());
+            assertEquals(8, second.getBytePosition());
+        }
+    }
+
+    /**
+     * Tests CSV-329.
+     */
+    @Test
+    void testGetBytePositionMultiCharacterDelimiterWithSupplementaryCharacter() throws IOException {
+        final String delimiter = "x😀";
+        final String code = "ax😀b\ncx😀d\n";
+        final CSVFormat format = CSVFormat.DEFAULT.builder().setDelimiter(delimiter).get();
+        try (CSVParser parser = CSVParser.builder()
+                .setReader(new StringReader(code))
+                .setFormat(format)
+                .setCharset(UTF_8)
+                .setTrackBytes(true)
+                .get()) {
+            final CSVRecord first = parser.nextRecord();
+            final CSVRecord second = parser.nextRecord();
+            assertNotNull(first);
+            assertNotNull(second);
+            assertValuesEquals(new String[] { "a", "b" }, first);
+            assertValuesEquals(new String[] { "c", "d" }, second);
+            assertEquals(0, first.getBytePosition());
+            assertEquals("ax😀b\n".getBytes(UTF_8).length, second.getBytePosition());
+        }
+    }
+
+    @Test
+    void testGetBytePositionWithCharacterOffsetAndMultiBytePrefix() throws Exception {
+        final String row0 = "é,x\n";
+        final Charset charset = UTF_8;
+        // row0 char count is 4
+        assertEquals(4, row0.length());
+        // row0 byte count is 5
+        final int record1ByteOffset = row0.getBytes(charset).length;
+        assertEquals(5, record1ByteOffset);
+        final String row1 = "b,c\n";
+        final String rows = row0 + row1;
+        final long record1CharOffset = row0.length();
+        final long expectedByteOffset = row0.getBytes(charset).length;
+        try (CSVParser parser = CSVParser.builder()
+                .setReader(new StringReader(row1))
+                .setFormat(CSVFormat.DEFAULT)
+                .setCharset(charset)
+                .setTrackBytes(true)
+                .setByteOffset(record1ByteOffset)
+                .setCharacterOffset(record1CharOffset)
+                .setRecordNumber(2) // not relevant but a better use case example.
+                .get()) {
+            final CSVRecord record = parser.nextRecord();
+            assertNotNull(record);
+            assertEquals(4, record.getCharacterPosition());
+            assertEquals(record1CharOffset, record.getCharacterPosition());
+            assertEquals(expectedByteOffset, record.getBytePosition());
+        }
+    }
+
+    @Test
+    void testGetBytePositionWithSingleByteCharset() throws IOException {
+        // A single-byte charset cannot encode U+FFFF, the char value of the EOF sentinel.
+        // Byte counting must skip the EOF read so a valid file parses without throwing.
+        final String code = "a,b\nc,d\n";
+        try (CSVParser parser = CSVParser.builder()
+                .setReader(new StringReader(code))
+                .setFormat(CSVFormat.DEFAULT)
+                .setCharset(StandardCharsets.ISO_8859_1)
+                .setTrackBytes(true)
+                .get()) {
+            final CSVRecord first = parser.nextRecord();
+            final CSVRecord second = parser.nextRecord();
+            assertNotNull(first);
+            assertNotNull(second);
+            assertNull(parser.nextRecord());
+            assertEquals(0, first.getBytePosition());
+            assertEquals(4, second.getBytePosition());
+        }
+    }
+
+    @Test
+    void testGetHeaderComment_HeaderComment1() throws IOException {
+        try (CSVParser parser = CSVParser.parse(CSV_INPUT_HEADER_COMMENT, FORMAT_AUTO_HEADER)) {
+            parser.getRecords();
+            // Expect a header comment
+            assertTrue(parser.hasHeaderComment());
+            assertEquals("header comment", parser.getHeaderComment());
+        }
+    }
+
+    @Test
+    void testGetHeaderComment_HeaderComment2() throws IOException {
+        try (CSVParser parser = CSVParser.parse(CSV_INPUT_HEADER_COMMENT, FORMAT_EXPLICIT_HEADER)) {
+            parser.getRecords();
+            // Expect a header comment
+            assertTrue(parser.hasHeaderComment());
+            assertEquals("header comment", parser.getHeaderComment());
+        }
+    }
+
+    @Test
+    void testGetHeaderComment_HeaderComment3() throws IOException {
+        try (CSVParser parser = CSVParser.parse(CSV_INPUT_HEADER_COMMENT, FORMAT_EXPLICIT_HEADER_NOSKIP)) {
+            parser.getRecords();
+            // Expect no header comment - the text "comment" is attached to the first record
+            assertFalse(parser.hasHeaderComment());
+            assertNull(parser.getHeaderComment());
+        }
+    }
+
+    @Test
+    void testGetHeaderComment_HeaderTrailerComment() throws IOException {
+        try (CSVParser parser = CSVParser.parse(CSV_INPUT_MULTILINE_HEADER_TRAILER_COMMENT, FORMAT_AUTO_HEADER)) {
+            parser.getRecords();
+            // Expect a header comment
+            assertTrue(parser.hasHeaderComment());
+            assertEquals("multi-line" + LF + "header comment", parser.getHeaderComment());
+        }
+    }
+
+    @Test
+    void testGetHeaderComment_NoComment1() throws IOException {
+        try (CSVParser parser = CSVParser.parse(CSV_INPUT_NO_COMMENT, FORMAT_AUTO_HEADER)) {
+            parser.getRecords();
+            // Expect no header comment
+            assertFalse(parser.hasHeaderComment());
+            assertNull(parser.getHeaderComment());
         }
     }
 
     @Test
-    public void testGetHeaderMap() throws Exception {
-        try (final CSVParser parser = CSVParser.parse("a,b,c\n1,2,3\nx,y,z",
-            CSVFormat.DEFAULT.withHeader("A", "B", "C"))) {
+    void testGetHeaderComment_NoComment2() throws IOException {
+        try (CSVParser parser = CSVParser.parse(CSV_INPUT_NO_COMMENT, FORMAT_EXPLICIT_HEADER)) {
+            parser.getRecords();
+            // Expect no header comment
+            assertFalse(parser.hasHeaderComment());
+            assertNull(parser.getHeaderComment());
+        }
+    }
+
+    @Test
+    void testGetHeaderComment_NoComment3() throws IOException {
+        try (CSVParser parser = CSVParser.parse(CSV_INPUT_NO_COMMENT, FORMAT_EXPLICIT_HEADER_NOSKIP)) {
+            parser.getRecords();
+            // Expect no header comment
+            assertFalse(parser.hasHeaderComment());
+            assertNull(parser.getHeaderComment());
+        }
+    }
+
+    @Test
+    void testGetHeaderMap() throws Exception {
+        try (CSVParser parser = CSVParser.parse("a,b,c\n1,2,3\nx,y,z", CSVFormat.DEFAULT.withHeader("A", "B", "C"))) {
             final Map headerMap = parser.getHeaderMap();
             final Iterator columnNames = headerMap.keySet().iterator();
             // Headers are iterated in column order.
@@ -511,9 +862,8 @@ public void testGetHeaderMap() throws Exception {
     }
 
     @Test
-    public void testGetHeaderNames() throws IOException {
-        try (final CSVParser parser = CSVParser.parse("a,b,c\n1,2,3\nx,y,z",
-            CSVFormat.DEFAULT.withHeader("A", "B", "C"))) {
+    void testGetHeaderNames() throws IOException {
+        try (CSVParser parser = CSVParser.parse("a,b,c\n1,2,3\nx,y,z", CSVFormat.DEFAULT.withHeader("A", "B", "C"))) {
             final Map nameIndexMap = parser.getHeaderMap();
             final List headerNames = parser.getHeaderNames();
             assertNotNull(headerNames);
@@ -526,9 +876,8 @@ public void testGetHeaderNames() throws IOException {
     }
 
     @Test
-    public void testGetHeaderNamesReadOnly() throws IOException {
-        try (final CSVParser parser = CSVParser.parse("a,b,c\n1,2,3\nx,y,z",
-            CSVFormat.DEFAULT.withHeader("A", "B", "C"))) {
+    void testGetHeaderNamesReadOnly() throws IOException {
+        try (CSVParser parser = CSVParser.parse("a,b,c\n1,2,3\nx,y,z", CSVFormat.DEFAULT.withHeader("A", "B", "C"))) {
             final List headerNames = parser.getHeaderNames();
             assertNotNull(headerNames);
             assertThrows(UnsupportedOperationException.class, () -> headerNames.add("This is a read-only list."));
@@ -536,10 +885,10 @@ public void testGetHeaderNamesReadOnly() throws IOException {
     }
 
     @Test
-    public void testGetLine() throws IOException {
-        try (final CSVParser parser = CSVParser.parse(CSV_INPUT, CSVFormat.DEFAULT.withIgnoreSurroundingSpaces())) {
+    void testGetLine() throws IOException {
+        try (CSVParser parser = CSVParser.parse(CSV_INPUT, CSVFormat.DEFAULT.withIgnoreSurroundingSpaces())) {
             for (final String[] re : RESULT) {
-                assertArrayEquals(re, parser.nextRecord().values());
+                assertValuesEquals(re, parser.nextRecord());
             }
 
             assertNull(parser.nextRecord());
@@ -547,91 +896,203 @@ public void testGetLine() throws IOException {
     }
 
     @Test
-    public void testGetLineNumberWithCR() throws Exception {
-        this.validateLineNumbers(String.valueOf(CR));
+    void testGetLineNumberWithCR() throws Exception {
+        validateLineNumbers(String.valueOf(CR));
     }
 
     @Test
-    public void testGetLineNumberWithCRLF() throws Exception {
-        this.validateLineNumbers(CRLF);
+    void testGetLineNumberWithCRLF() throws Exception {
+        validateLineNumbers(CRLF);
     }
 
     @Test
-    public void testGetLineNumberWithLF() throws Exception {
-        this.validateLineNumbers(String.valueOf(LF));
+    void testGetLineNumberWithLF() throws Exception {
+        validateLineNumbers(String.valueOf(LF));
     }
 
     @Test
-    public void testGetOneLine() throws IOException {
-        try (final CSVParser parser = CSVParser.parse(CSV_INPUT_1, CSVFormat.DEFAULT)) {
+    void testGetOneLine() throws IOException {
+        try (CSVParser parser = CSVParser.parse(CSV_INPUT_1, CSVFormat.DEFAULT)) {
             final CSVRecord record = parser.getRecords().get(0);
-            assertArrayEquals(RESULT[0], record.values());
+            assertValuesEquals(RESULT[0], record);
         }
     }
 
     /**
      * Tests reusing a parser to process new string records one at a time as they are being discovered. See [CSV-110].
      *
-     * @throws IOException
+     * @throws IOException when an I/O error occurs.
      */
     @Test
-    public void testGetOneLineOneParser() throws IOException {
+    void testGetOneLineOneParser() throws IOException {
         final CSVFormat format = CSVFormat.DEFAULT;
-        try (final PipedWriter writer = new PipedWriter();
-            final CSVParser parser = new CSVParser(new PipedReader(writer), format)) {
+        try (PipedWriter writer = new PipedWriter();
+                PipedReader origin = new PipedReader(writer);
+                CSVParser parser = CSVParser.builder()
+                        .setReader(origin)
+                        .setFormat(format)
+                        .get()) {
             writer.append(CSV_INPUT_1);
             writer.append(format.getRecordSeparator());
             final CSVRecord record1 = parser.nextRecord();
-            assertArrayEquals(RESULT[0], record1.values());
+            assertValuesEquals(RESULT[0], record1);
             writer.append(CSV_INPUT_2);
             writer.append(format.getRecordSeparator());
             final CSVRecord record2 = parser.nextRecord();
-            assertArrayEquals(RESULT[1], record2.values());
+            assertValuesEquals(RESULT[1], record2);
         }
     }
 
     @Test
-    public void testGetRecordNumberWithCR() throws Exception {
-        this.validateRecordNumbers(String.valueOf(CR));
+    void testGetRecordFourBytesRead() throws Exception {
+        final String code = "id,a,b,c\n" +
+            "1,😊,🤔,😂\n" +
+            "2,😊,🤔,😂\n" +
+            "3,😊,🤔,😂\n";
+        final CSVFormat format = CSVFormat.Builder.create()
+            .setDelimiter(',')
+            .setQuote('\'')
+            .get();
+        try (CSVParser parser = CSVParser.builder().setReader(new StringReader(code)).setFormat(format).setCharset(UTF_8).setTrackBytes(true).get()) {
+            CSVRecord record = new CSVRecord(parser, null, null, 1L, 0L, 0L);
+
+            assertEquals(0, parser.getRecordNumber());
+            assertNotNull(record = parser.nextRecord());
+            assertEquals(1, record.getRecordNumber());
+            assertEquals(code.indexOf('i'), record.getCharacterPosition());
+            assertEquals(record.getBytePosition(), record.getCharacterPosition());
+
+            assertNotNull(record = parser.nextRecord());
+            assertEquals(2, record.getRecordNumber());
+            assertEquals(code.indexOf('1'), record.getCharacterPosition());
+            assertEquals(record.getBytePosition(), record.getCharacterPosition());
+            assertNotNull(record = parser.nextRecord());
+            assertEquals(3, record.getRecordNumber());
+            assertEquals(code.indexOf('2'), record.getCharacterPosition());
+            assertEquals(record.getBytePosition(), 26);
+            assertNotNull(record = parser.nextRecord());
+            assertEquals(4, record.getRecordNumber());
+            assertEquals(code.indexOf('3'), record.getCharacterPosition());
+            assertEquals(record.getBytePosition(), 43);
+        }
+    }
+
+    @Test
+    void testGetRecordNumberWithCR() throws Exception {
+        validateRecordNumbers(String.valueOf(CR));
     }
 
     @Test
-    public void testGetRecordNumberWithCRLF() throws Exception {
-        this.validateRecordNumbers(CRLF);
+    void testGetRecordNumberWithCRLF() throws Exception {
+        validateRecordNumbers(CRLF);
     }
 
     @Test
-    public void testGetRecordNumberWithLF() throws Exception {
-        this.validateRecordNumbers(String.valueOf(LF));
+    void testGetRecordNumberWithLF() throws Exception {
+        validateRecordNumbers(String.valueOf(LF));
     }
 
     @Test
-    public void testGetRecordPositionWithCRLF() throws Exception {
-        this.validateRecordPosition(CRLF);
+    void testGetRecordPositionWithCRLF() throws Exception {
+        validateRecordPosition(CRLF);
     }
 
     @Test
-    public void testGetRecordPositionWithLF() throws Exception {
-        this.validateRecordPosition(String.valueOf(LF));
+    void testGetRecordPositionWithLF() throws Exception {
+        validateRecordPosition(String.valueOf(LF));
     }
 
     @Test
-    public void testGetRecords() throws IOException {
-        try (final CSVParser parser = CSVParser.parse(CSV_INPUT, CSVFormat.DEFAULT.withIgnoreSurroundingSpaces())) {
+    void testGetRecords() throws IOException {
+        try (CSVParser parser = CSVParser.parse(CSV_INPUT, CSVFormat.DEFAULT.withIgnoreSurroundingSpaces())) {
             final List records = parser.getRecords();
             assertEquals(RESULT.length, records.size());
-            assertTrue(records.size() > 0);
+            assertFalse(records.isEmpty());
             for (int i = 0; i < RESULT.length; i++) {
-                assertArrayEquals(RESULT[i], records.get(i).values());
+                assertValuesEquals(RESULT[i], records.get(i));
+            }
+        }
+    }
+
+    @Test
+    void testGetRecordsFromBrokenInputStream() throws IOException {
+        @SuppressWarnings("resource") // We also get an exception on close, which is OK but can't assert in a try.
+        final CSVParser parser = CSVParser.parse(new BrokenInputStream(), UTF_8, CSVFormat.DEFAULT);
+        assertThrows(UncheckedIOException.class, parser::getRecords);
+
+    }
+
+    @ParameterizedTest
+    @ValueSource(longs = { -1, 0, 1, 2, 3, 4, Long.MAX_VALUE })
+    void testGetRecordsMaxRows(final long maxRows) throws IOException {
+        try (CSVParser parser = CSVParser.parse(CSV_INPUT, CSVFormat.DEFAULT.builder().setIgnoreSurroundingSpaces(true).setMaxRows(maxRows).get())) {
+            final List records = parser.getRecords();
+            final long expectedLength = maxRows <= 0 || maxRows > RESULT.length ? RESULT.length : maxRows;
+            assertEquals(expectedLength, records.size());
+            assertFalse(records.isEmpty());
+            for (int i = 0; i < expectedLength; i++) {
+                assertValuesEquals(RESULT[i], records.get(i));
             }
         }
     }
 
+    /**
+     * Tests CSV-327.
+     */
+    @Test
+    void testGetRecordsMaxRowsWithRecordNumberOffset() throws IOException {
+        try (CSVParser parser = CSVParser.builder()
+                .setReader(new StringReader("a,b\nc,d\n"))
+                .setFormat(CSVFormat.DEFAULT.builder().setMaxRows(1).get())
+                .setRecordNumber(2)
+                .get()) {
+            final List records = parser.getRecords();
+            assertEquals(1, records.size());
+            assertEquals(2, records.get(0).getRecordNumber());
+            assertValuesEquals(new String[] { "a", "b" }, records.get(0));
+        }
+    }
+
     @Test
-    public void testGetRecordWithMultiLineValues() throws Exception {
-        try (final CSVParser parser = CSVParser.parse(
-            "\"a\r\n1\",\"a\r\n2\"" + CRLF + "\"b\r\n1\",\"b\r\n2\"" + CRLF + "\"c\r\n1\",\"c\r\n2\"",
-            CSVFormat.DEFAULT.withRecordSeparator(CRLF))) {
+    void testGetRecordThreeBytesRead() throws Exception {
+        final String code = "id,date,val5,val4\n" +
+            "11111111111111,'4017-09-01',きちんと節分近くには咲いてる～,v4\n" +
+            "22222222222222,'4017-01-01',おはよう私の友人～,v4\n" +
+            "33333333333333,'4017-01-01',きる自然の力ってすごいな～,v4\n";
+        final CSVFormat format = CSVFormat.Builder.create()
+            .setDelimiter(',')
+            .setQuote('\'')
+            .get();
+        try (CSVParser parser = CSVParser.builder().setReader(new StringReader(code)).setFormat(format).setCharset(UTF_8).setTrackBytes(true).get()) {
+            CSVRecord record = new CSVRecord(parser, null, null, 1L, 0L, 0L);
+
+            assertEquals(0, parser.getRecordNumber());
+            assertNotNull(record = parser.nextRecord());
+            assertEquals(1, record.getRecordNumber());
+            assertEquals(code.indexOf('i'), record.getCharacterPosition());
+            assertEquals(record.getBytePosition(), record.getCharacterPosition());
+
+            assertNotNull(record = parser.nextRecord());
+            assertEquals(2, record.getRecordNumber());
+            assertEquals(code.indexOf('1'), record.getCharacterPosition());
+            assertEquals(record.getBytePosition(), record.getCharacterPosition());
+
+            assertNotNull(record = parser.nextRecord());
+            assertEquals(3, record.getRecordNumber());
+            assertEquals(code.indexOf('2'), record.getCharacterPosition());
+            assertEquals(record.getBytePosition(), 95);
+
+            assertNotNull(record = parser.nextRecord());
+            assertEquals(4, record.getRecordNumber());
+            assertEquals(code.indexOf('3'), record.getCharacterPosition());
+            assertEquals(record.getBytePosition(), 154);
+        }
+    }
+
+    @Test
+    void testGetRecordWithMultiLineValues() throws Exception {
+        try (CSVParser parser = CSVParser.parse("\"a\r\n1\",\"a\r\n2\"" + CRLF + "\"b\r\n1\",\"b\r\n2\"" + CRLF + "\"c\r\n1\",\"c\r\n2\"",
+                CSVFormat.DEFAULT.withRecordSeparator(CRLF))) {
             CSVRecord record;
             assertEquals(0, parser.getRecordNumber());
             assertEquals(0, parser.getCurrentLineNumber());
@@ -654,144 +1115,239 @@ public void testGetRecordWithMultiLineValues() throws Exception {
     }
 
     @Test
-    public void testHeader() throws Exception {
-        final Reader in = new StringReader("a,b,c\n1,2,3\nx,y,z");
-
-        final Iterator records = CSVFormat.DEFAULT.withHeader().parse(in).iterator();
+    void testGetTrailerComment_HeaderComment1() throws IOException {
+        try (CSVParser parser = CSVParser.parse(CSV_INPUT_HEADER_COMMENT, FORMAT_AUTO_HEADER)) {
+            parser.getRecords();
+            assertFalse(parser.hasTrailerComment());
+            assertNull(parser.getTrailerComment());
+        }
+    }
 
-        for (int i = 0; i < 2; i++) {
-            assertTrue(records.hasNext());
-            final CSVRecord record = records.next();
-            assertEquals(record.get(0), record.get("a"));
-            assertEquals(record.get(1), record.get("b"));
-            assertEquals(record.get(2), record.get("c"));
+    @Test
+    void testGetTrailerComment_HeaderComment2() throws IOException {
+        try (CSVParser parser = CSVParser.parse(CSV_INPUT_HEADER_COMMENT, FORMAT_EXPLICIT_HEADER)) {
+            parser.getRecords();
+            assertFalse(parser.hasTrailerComment());
+            assertNull(parser.getTrailerComment());
         }
+    }
 
-        assertFalse(records.hasNext());
+    @Test
+    void testGetTrailerComment_HeaderComment3() throws IOException {
+        try (CSVParser parser = CSVParser.parse(CSV_INPUT_HEADER_COMMENT, FORMAT_EXPLICIT_HEADER_NOSKIP)) {
+            parser.getRecords();
+            assertFalse(parser.hasTrailerComment());
+            assertNull(parser.getTrailerComment());
+        }
     }
 
     @Test
-    public void testHeaderComment() throws Exception {
-        final Reader in = new StringReader("# comment\na,b,c\n1,2,3\nx,y,z");
+    void testGetTrailerComment_HeaderTrailerComment1() throws IOException {
+        try (CSVParser parser = CSVParser.parse(CSV_INPUT_HEADER_TRAILER_COMMENT, FORMAT_AUTO_HEADER)) {
+            parser.getRecords();
+            assertTrue(parser.hasTrailerComment());
+            assertEquals("comment", parser.getTrailerComment());
+        }
+    }
 
-        final Iterator records = CSVFormat.DEFAULT.withCommentMarker('#').withHeader().parse(in).iterator();
+    @Test
+    void testGetTrailerComment_HeaderTrailerComment2() throws IOException {
+        try (CSVParser parser = CSVParser.parse(CSV_INPUT_HEADER_TRAILER_COMMENT, FORMAT_EXPLICIT_HEADER)) {
+            parser.getRecords();
+            assertTrue(parser.hasTrailerComment());
+            assertEquals("comment", parser.getTrailerComment());
+        }
+    }
 
-        for (int i = 0; i < 2; i++) {
-            assertTrue(records.hasNext());
-            final CSVRecord record = records.next();
-            assertEquals(record.get(0), record.get("a"));
-            assertEquals(record.get(1), record.get("b"));
-            assertEquals(record.get(2), record.get("c"));
+    @Test
+    void testGetTrailerComment_HeaderTrailerComment3() throws IOException {
+        try (CSVParser parser = CSVParser.parse(CSV_INPUT_HEADER_TRAILER_COMMENT, FORMAT_EXPLICIT_HEADER_NOSKIP)) {
+            parser.getRecords();
+            assertTrue(parser.hasTrailerComment());
+            assertEquals("comment", parser.getTrailerComment());
         }
+    }
 
-        assertFalse(records.hasNext());
+    @Test
+    void testGetTrailerComment_MultilineComment() throws IOException {
+        try (CSVParser parser = CSVParser.parse(CSV_INPUT_MULTILINE_HEADER_TRAILER_COMMENT, FORMAT_AUTO_HEADER)) {
+            parser.getRecords();
+            assertTrue(parser.hasTrailerComment());
+            assertEquals("multi-line" + LF + "comment", parser.getTrailerComment());
+        }
     }
 
     @Test
-    public void testHeaderMissing() throws Exception {
-        final Reader in = new StringReader("a,,c\n1,2,3\nx,y,z");
+    void testHeader() throws Exception {
+        final Reader in = new StringReader("a,b,c\n1,2,3\nx,y,z");
 
-        final Iterator records = CSVFormat.DEFAULT.withHeader().withAllowMissingColumnNames().parse(in)
-            .iterator();
+        try (CSVParser parser = CSVFormat.DEFAULT.withHeader().parse(in)) {
+            final Iterator records = parser.iterator();
 
-        for (int i = 0; i < 2; i++) {
-            assertTrue(records.hasNext());
-            final CSVRecord record = records.next();
-            assertEquals(record.get(0), record.get("a"));
-            assertEquals(record.get(2), record.get("c"));
+            for (int i = 0; i < 2; i++) {
+                assertTrue(records.hasNext());
+                final CSVRecord record = records.next();
+                assertEquals(record.get(0), record.get("a"));
+                assertEquals(record.get(1), record.get("b"));
+                assertEquals(record.get(2), record.get("c"));
+            }
+
+            assertFalse(records.hasNext());
         }
+    }
 
-        assertFalse(records.hasNext());
+    @Test
+    void testHeaderComment() throws Exception {
+        final Reader in = new StringReader("# comment\na,b,c\n1,2,3\nx,y,z");
+        try (CSVParser parser = CSVFormat.DEFAULT.withCommentMarker('#').withHeader().parse(in)) {
+            final Iterator records = parser.iterator();
+            for (int i = 0; i < 2; i++) {
+                assertTrue(records.hasNext());
+                final CSVRecord record = records.next();
+                assertEquals(record.get(0), record.get("a"));
+                assertEquals(record.get(1), record.get("b"));
+                assertEquals(record.get(2), record.get("c"));
+            }
+            assertFalse(records.hasNext());
+        }
     }
 
     @Test
-    public void testHeaderMissingWithNull() throws Exception {
-        final Reader in = new StringReader("a,,c,,e\n1,2,3,4,5\nv,w,x,y,z");
-        CSVFormat.DEFAULT.withHeader().withNullString("").withAllowMissingColumnNames().parse(in).iterator();
+    void testHeaderMissing() throws Exception {
+        final Reader in = new StringReader("a,,c\n1,2,3\nx,y,z");
+        try (CSVParser parser = CSVFormat.DEFAULT.withHeader().withAllowMissingColumnNames().parse(in)) {
+            final Iterator records = parser.iterator();
+            for (int i = 0; i < 2; i++) {
+                assertTrue(records.hasNext());
+                final CSVRecord record = records.next();
+                assertEquals(record.get(0), record.get("a"));
+                assertEquals(record.get(2), record.get("c"));
+            }
+            assertFalse(records.hasNext());
+        }
     }
 
     @Test
-    public void testHeadersMissing() throws Exception {
+    void testHeaderMissingWithNull() throws Exception {
         final Reader in = new StringReader("a,,c,,e\n1,2,3,4,5\nv,w,x,y,z");
-        CSVFormat.DEFAULT.withHeader().withAllowMissingColumnNames().parse(in).iterator();
+        try (CSVParser parser = CSVFormat.DEFAULT.withHeader().withNullString("").withAllowMissingColumnNames().parse(in)) {
+            parser.iterator();
+        }
     }
 
     @Test
-    public void testHeadersMissingException() {
+    void testHeadersMissing() throws Exception {
+        try (Reader in = new StringReader("a,,c,,e\n1,2,3,4,5\nv,w,x,y,z");
+                CSVParser parser = CSVFormat.DEFAULT.withHeader().withAllowMissingColumnNames().parse(in)) {
+            parser.iterator();
+        }
+    }
+
+    @Test
+    void testHeadersMissingException() {
         final Reader in = new StringReader("a,,c,,e\n1,2,3,4,5\nv,w,x,y,z");
         assertThrows(IllegalArgumentException.class, () -> CSVFormat.DEFAULT.withHeader().parse(in).iterator());
     }
 
     @Test
-    public void testHeadersMissingOneColumnException() throws Exception {
+    void testHeadersMissingOneColumnException() {
         final Reader in = new StringReader("a,,c,d,e\n1,2,3,4,5\nv,w,x,y,z");
         assertThrows(IllegalArgumentException.class, () -> CSVFormat.DEFAULT.withHeader().parse(in).iterator());
     }
 
     @Test
-    public void testHeadersWithNullColumnName() throws IOException {
+    void testHeadersWithNullColumnName() throws IOException {
         final Reader in = new StringReader("header1,null,header3\n1,2,3\n4,5,6");
-        final Iterator records = CSVFormat.DEFAULT.withHeader().withNullString("null")
-            .withAllowMissingColumnNames().parse(in).iterator();
-        final CSVRecord record = records.next();
-        // Expect the null header to be missing
-        assertEquals(Arrays.asList("header1", "header3"), record.getParser().getHeaderNames());
-        assertEquals(2, record.getParser().getHeaderMap().size());
+        try (CSVParser parser = CSVFormat.DEFAULT.withHeader().withNullString("null").withAllowMissingColumnNames().parse(in)) {
+            final Iterator records = parser.iterator();
+            final CSVRecord record = records.next();
+            // Expect the null header to be missing
+            @SuppressWarnings("resource")
+            final CSVParser recordParser = record.getParser();
+            assertEquals(Arrays.asList("header1", "header3"), recordParser.getHeaderNames());
+            assertEquals(2, recordParser.getHeaderMap().size());
+        }
     }
 
     @Test
-    public void testIgnoreCaseHeaderMapping() throws Exception {
+    void testIgnoreCaseHeaderMapping() throws Exception {
         final Reader reader = new StringReader("1,2,3");
-        final Iterator records = CSVFormat.DEFAULT.withHeader("One", "TWO", "three").withIgnoreHeaderCase()
-            .parse(reader).iterator();
-        final CSVRecord record = records.next();
-        assertEquals("1", record.get("one"));
-        assertEquals("2", record.get("two"));
-        assertEquals("3", record.get("THREE"));
+        try (CSVParser parser = CSVFormat.DEFAULT.withHeader("One", "TWO", "three").withIgnoreHeaderCase().parse(reader)) {
+            final Iterator records = parser.iterator();
+            final CSVRecord record = records.next();
+            assertEquals("1", record.get("one"));
+            assertEquals("2", record.get("two"));
+            assertEquals("3", record.get("THREE"));
+        }
     }
 
     @Test
-    public void testIgnoreEmptyLines() throws IOException {
+    void testIgnoreEmptyLines() throws IOException {
         final String code = "\nfoo,baar\n\r\n,\n\n,world\r\n\n";
         // String code = "world\r\n\n";
         // String code = "foo;baar\r\n\r\nhello;\r\n\r\nworld;\r\n";
-        try (final CSVParser parser = CSVParser.parse(code, CSVFormat.DEFAULT)) {
+        try (CSVParser parser = CSVParser.parse(code, CSVFormat.DEFAULT)) {
             final List records = parser.getRecords();
             assertEquals(3, records.size());
         }
     }
 
     @Test
-    public void testInvalidFormat() {
+    void testInvalidFormat() {
         assertThrows(IllegalArgumentException.class, () -> CSVFormat.DEFAULT.withDelimiter(CR));
     }
 
     @Test
-    public void testIterator() throws Exception {
+    void testIterator() throws Exception {
         final Reader in = new StringReader("a,b,c\n1,2,3\nx,y,z");
+        try (CSVParser parser = CSVFormat.DEFAULT.parse(in)) {
+            final Iterator iterator = parser.iterator();
+            assertTrue(iterator.hasNext());
+            assertThrows(UnsupportedOperationException.class, iterator::remove);
+            assertValuesEquals(new String[] { "a", "b", "c" }, iterator.next());
+            assertValuesEquals(new String[] { "1", "2", "3" }, iterator.next());
+            assertTrue(iterator.hasNext());
+            assertTrue(iterator.hasNext());
+            assertTrue(iterator.hasNext());
+            assertValuesEquals(new String[] { "x", "y", "z" }, iterator.next());
+            assertFalse(iterator.hasNext());
+            assertThrows(NoSuchElementException.class, iterator::next);
+        }
+    }
 
-        final Iterator iterator = CSVFormat.DEFAULT.parse(in).iterator();
-
-        assertTrue(iterator.hasNext());
-        assertThrows(UnsupportedOperationException.class, iterator::remove);
-        assertArrayEquals(new String[] { "a", "b", "c" }, iterator.next().values());
-        assertArrayEquals(new String[] { "1", "2", "3" }, iterator.next().values());
-        assertTrue(iterator.hasNext());
-        assertTrue(iterator.hasNext());
-        assertTrue(iterator.hasNext());
-        assertArrayEquals(new String[] { "x", "y", "z" }, iterator.next().values());
-        assertFalse(iterator.hasNext());
-
-        assertThrows(NoSuchElementException.class, iterator::next);
+    @ParameterizedTest
+    @ValueSource(longs = { -1, 0, 1, 2, 3, 4, 5, Long.MAX_VALUE })
+    void testIteratorMaxRows(final long maxRows) throws Exception {
+        final Reader in = new StringReader("a,b,c\n1,2,3\nx,y,z");
+        try (CSVParser parser = CSVFormat.DEFAULT.builder().setMaxRows(maxRows).get().parse(in)) {
+            final Iterator iterator = parser.iterator();
+            assertTrue(iterator.hasNext());
+            assertThrows(UnsupportedOperationException.class, iterator::remove);
+            assertValuesEquals(new String[] { "a", "b", "c" }, iterator.next());
+            final boolean noLimit = maxRows <= 0;
+            final int fixtureLen = 3;
+            final long expectedLen = noLimit ? fixtureLen : Math.min(fixtureLen, maxRows);
+            if (expectedLen > 1) {
+                assertTrue(iterator.hasNext());
+                assertValuesEquals(new String[] { "1", "2", "3" }, iterator.next());
+            }
+            assertEquals(expectedLen > 2, iterator.hasNext());
+            // again
+            assertEquals(expectedLen > 2, iterator.hasNext());
+            if (expectedLen == fixtureLen) {
+                assertTrue(iterator.hasNext());
+                assertValuesEquals(new String[] { "x", "y", "z" }, iterator.next());
+            }
+            assertFalse(iterator.hasNext());
+            assertThrows(NoSuchElementException.class, iterator::next);
+        }
     }
 
     @Test
-    public void testIteratorSequenceBreaking() throws IOException {
+    void testIteratorSequenceBreaking() throws IOException {
         final String fiveRows = "1\n2\n3\n4\n5\n";
-
         // Iterator hasNext() shouldn't break sequence
         try (CSVParser parser = CSVFormat.DEFAULT.parse(new StringReader(fiveRows))) {
-            
             final Iterator iter = parser.iterator();
             int recordNumber = 0;
             while (iter.hasNext()) {
@@ -809,7 +1365,6 @@ public void testIteratorSequenceBreaking() throws IOException {
                 assertEquals(String.valueOf(recordNumber), record.get(0));
             }
         }
-
         // Consecutive enhanced for loops shouldn't break sequence
         try (CSVParser parser = CSVFormat.DEFAULT.parse(new StringReader(fiveRows))) {
             int recordNumber = 0;
@@ -825,7 +1380,6 @@ public void testIteratorSequenceBreaking() throws IOException {
                 assertEquals(String.valueOf(recordNumber), record.get(0));
             }
         }
-
         // Consecutive enhanced for loops with hasNext() peeking shouldn't break sequence
         try (CSVParser parser = CSVFormat.DEFAULT.parse(new StringReader(fiveRows))) {
             int recordNumber = 0;
@@ -845,53 +1399,52 @@ public void testIteratorSequenceBreaking() throws IOException {
     }
 
     @Test
-    public void testLineFeedEndings() throws IOException {
+    void testLineFeedEndings() throws IOException {
         final String code = "foo\nbaar,\nhello,world\n,kanu";
-        try (final CSVParser parser = CSVParser.parse(code, CSVFormat.DEFAULT)) {
+        try (CSVParser parser = CSVParser.parse(code, CSVFormat.DEFAULT)) {
             final List records = parser.getRecords();
             assertEquals(4, records.size());
         }
     }
 
     @Test
-    public void testMappedButNotSetAsOutlook2007ContactExport() throws Exception {
+    void testMappedButNotSetAsOutlook2007ContactExport() throws Exception {
         final Reader in = new StringReader("a,b,c\n1,2\nx,y,z");
-        final Iterator records = CSVFormat.DEFAULT.withHeader("A", "B", "C").withSkipHeaderRecord().parse(in)
-            .iterator();
-        CSVRecord record;
-
-        // 1st record
-        record = records.next();
-        assertTrue(record.isMapped("A"));
-        assertTrue(record.isMapped("B"));
-        assertTrue(record.isMapped("C"));
-        assertTrue(record.isSet("A"));
-        assertTrue(record.isSet("B"));
-        assertFalse(record.isSet("C"));
-        assertEquals("1", record.get("A"));
-        assertEquals("2", record.get("B"));
-        assertFalse(record.isConsistent());
-
-        // 2nd record
-        record = records.next();
-        assertTrue(record.isMapped("A"));
-        assertTrue(record.isMapped("B"));
-        assertTrue(record.isMapped("C"));
-        assertTrue(record.isSet("A"));
-        assertTrue(record.isSet("B"));
-        assertTrue(record.isSet("C"));
-        assertEquals("x", record.get("A"));
-        assertEquals("y", record.get("B"));
-        assertEquals("z", record.get("C"));
-        assertTrue(record.isConsistent());
-
-        assertFalse(records.hasNext());
+        try (CSVParser parser = CSVFormat.DEFAULT.withHeader("A", "B", "C").withSkipHeaderRecord().parse(in)) {
+            final Iterator records = parser.iterator();
+            CSVRecord record;
+            // 1st record
+            record = records.next();
+            assertTrue(record.isMapped("A"));
+            assertTrue(record.isMapped("B"));
+            assertTrue(record.isMapped("C"));
+            assertTrue(record.isSet("A"));
+            assertTrue(record.isSet("B"));
+            assertFalse(record.isSet("C"));
+            assertEquals("1", record.get("A"));
+            assertEquals("2", record.get("B"));
+            assertFalse(record.isConsistent());
+            // 2nd record
+            record = records.next();
+            assertTrue(record.isMapped("A"));
+            assertTrue(record.isMapped("B"));
+            assertTrue(record.isMapped("C"));
+            assertTrue(record.isSet("A"));
+            assertTrue(record.isSet("B"));
+            assertTrue(record.isSet("C"));
+            assertEquals("x", record.get("A"));
+            assertEquals("y", record.get("B"));
+            assertEquals("z", record.get("C"));
+            assertTrue(record.isConsistent());
+            // end
+            assertFalse(records.hasNext());
+        }
     }
 
     @Test
     @Disabled
-    public void testMongoDbCsv() throws Exception {
-        try (final CSVParser parser = CSVParser.parse("\"a a\",b,c" + LF + "d,e,f", CSVFormat.MONGODB_CSV)) {
+    void testMongoDbCsv() throws Exception {
+        try (CSVParser parser = CSVParser.parse("\"a a\",b,c" + LF + "d,e,f", CSVFormat.MONGODB_CSV)) {
             final Iterator itr1 = parser.iterator();
             final Iterator itr2 = parser.iterator();
 
@@ -909,8 +1462,8 @@ public void testMongoDbCsv() throws Exception {
 
     @Test
     // TODO this may lead to strange behavior, throw an exception if iterator() has already been called?
-    public void testMultipleIterators() throws Exception {
-        try (final CSVParser parser = CSVParser.parse("a,b,c" + CRLF + "d,e,f", CSVFormat.DEFAULT)) {
+    void testMultipleIterators() throws Exception {
+        try (CSVParser parser = CSVParser.parse("a,b,c" + CRLF + "d,e,f", CSVFormat.DEFAULT)) {
             final Iterator itr1 = parser.iterator();
 
             final CSVRecord first = itr1.next();
@@ -926,266 +1479,533 @@ public void testMultipleIterators() throws Exception {
     }
 
     @Test
-    public void testNewCSVParserNullReaderFormat() {
+    void testNewCSVParserNullReaderFormat() {
         assertThrows(NullPointerException.class, () -> new CSVParser(null, CSVFormat.DEFAULT));
     }
 
     @Test
-    public void testNewCSVParserReaderNullFormat() {
+    void testNewCSVParserReaderNullFormat() {
         assertThrows(NullPointerException.class, () -> new CSVParser(new StringReader(""), null));
     }
 
     @Test
-    public void testNoHeaderMap() throws Exception {
-        try (final CSVParser parser = CSVParser.parse("a,b,c\n1,2,3\nx,y,z", CSVFormat.DEFAULT)) {
+    void testNoHeaderMap() throws Exception {
+        try (CSVParser parser = CSVParser.parse("a,b,c\n1,2,3\nx,y,z", CSVFormat.DEFAULT)) {
             assertNull(parser.getHeaderMap());
         }
     }
 
     @Test
-    public void testParse() throws Exception {
-        final ClassLoader loader = ClassLoader.getSystemClassLoader();
-        final URL url = loader.getResource("org/apache/commons/csv/CSVFileParser/test.csv");
-        final CSVFormat format = CSVFormat.DEFAULT.withHeader("A", "B", "C", "D");
-        final Charset charset = StandardCharsets.UTF_8;
+    void testNotValueCSV() throws IOException {
+        final String source = "#";
+        final CSVFormat csvFormat = CSVFormat.DEFAULT.withCommentMarker('#');
+        try (CSVParser csvParser = csvFormat.parse(new StringReader(source))) {
+            final CSVRecord csvRecord = csvParser.nextRecord();
+            assertNull(csvRecord);
+        }
+    }
 
-        try (final CSVParser parser = CSVParser.parse(new InputStreamReader(url.openStream(), charset), format)) {
+    @Test
+    void testParse() throws Exception {
+        final URL url = ClassLoader.getSystemClassLoader().getResource("org/apache/commons/csv/CSVFileParser/test.csv");
+        final CSVFormat format = CSVFormat.DEFAULT.builder().setHeader("A", "B", "C", "D").get();
+        final Charset charset = StandardCharsets.UTF_8;
+        // Reader
+        try (CSVParser parser = CSVParser.parse(new InputStreamReader(url.openStream(), charset), format)) {
+            parseFully(parser);
+        }
+        try (CSVParser parser = CSVParser.builder().setReader(new InputStreamReader(url.openStream(), charset)).setFormat(format).get()) {
+            parseFully(parser);
+        }
+        // String
+        final Path path = Paths.get(url.toURI());
+        final String string = new String(Files.readAllBytes(path), charset);
+        try (CSVParser parser = CSVParser.parse(string, format)) {
+            parseFully(parser);
+        }
+        try (CSVParser parser = CSVParser.builder().setCharSequence(string).setFormat(format).get()) {
+            parseFully(parser);
+        }
+        // File
+        final File file = new File(url.toURI());
+        try (CSVParser parser = CSVParser.parse(file, charset, format)) {
+            parseFully(parser);
+        }
+        try (CSVParser parser = CSVParser.builder().setFile(file).setCharset(charset).setFormat(format).get()) {
             parseFully(parser);
         }
-        try (final CSVParser parser = CSVParser.parse(new String(Files.readAllBytes(Paths.get(url.toURI())), charset),
-            format)) {
+        // InputStream
+        try (CSVParser parser = CSVParser.parse(url.openStream(), charset, format)) {
             parseFully(parser);
         }
-        try (final CSVParser parser = CSVParser.parse(new File(url.toURI()), charset, format)) {
+        try (CSVParser parser = CSVParser.builder().setInputStream(url.openStream()).setCharset(charset).setFormat(format).get()) {
             parseFully(parser);
         }
-        try (final CSVParser parser = CSVParser.parse(url.openStream(), charset, format)) {
+        // Path
+        try (CSVParser parser = CSVParser.parse(path, charset, format)) {
             parseFully(parser);
         }
-        try (final CSVParser parser = CSVParser.parse(Paths.get(url.toURI()), charset, format)) {
+        try (CSVParser parser = CSVParser.builder().setPath(path).setCharset(charset).setFormat(format).get()) {
             parseFully(parser);
         }
-        try (final CSVParser parser = CSVParser.parse(url, charset, format)) {
+        // URL
+        try (CSVParser parser = CSVParser.parse(url, charset, format)) {
             parseFully(parser);
         }
-        try (final CSVParser parser = new CSVParser(new InputStreamReader(url.openStream(), charset), format)) {
+        try (CSVParser parser = CSVParser.builder().setURI(url.toURI()).setCharset(charset).setFormat(format).get()) {
             parseFully(parser);
         }
-        try (final CSVParser parser = new CSVParser(new InputStreamReader(url.openStream(), charset), format,
-            /* characterOffset= */0, /* recordNumber= */1)) {
+        // InputStreamReader
+        try (CSVParser parser = new CSVParser(new InputStreamReader(url.openStream(), charset), format)) {
+            parseFully(parser);
+        }
+        try (CSVParser parser = CSVParser.builder().setReader(new InputStreamReader(url.openStream(), charset)).setFormat(format).get()) {
+            parseFully(parser);
+        }
+        // InputStreamReader with longs
+        try (CSVParser parser = new CSVParser(new InputStreamReader(url.openStream(), charset), format, /* characterOffset= */0, /* recordNumber= */1)) {
+            parseFully(parser);
+        }
+        try (CSVParser parser = CSVParser.builder().setReader(new InputStreamReader(url.openStream(), charset)).setFormat(format).setCharacterOffset(0)
+                .setRecordNumber(0).get()) {
+            parseFully(parser);
+        }
+    }
+
+    @Test
+    void testParseFileCharsetNullFormat() throws IOException {
+        final File file = new File("src/test/resources/org/apache/commons/csv/CSVFileParser/test.csv");
+        try (CSVParser parser = CSVParser.parse(file, Charset.defaultCharset(), null)) {
+            // null maps to DEFAULT.
             parseFully(parser);
         }
     }
 
     @Test
-    public void testParseFileNullFormat() {
-        assertThrows(NullPointerException.class,
-            () -> CSVParser.parse(new File("CSVFileParser/test.csv"), Charset.defaultCharset(), null));
+    void testParseInputStreamCharsetNullFormat() throws IOException {
+        try (InputStream in = Files.newInputStream(Paths.get("src/test/resources/org/apache/commons/csv/CSVFileParser/test.csv"));
+                CSVParser parser = CSVParser.parse(in, Charset.defaultCharset(), null)) {
+            // null maps to DEFAULT.
+            parseFully(parser);
+        }
     }
 
     @Test
-    public void testParseNullFileFormat() {
-        assertThrows(NullPointerException.class,
-            () -> CSVParser.parse((File) null, Charset.defaultCharset(), CSVFormat.DEFAULT));
+    void testParseNullFileFormat() {
+        assertThrows(NullPointerException.class, () -> CSVParser.parse((File) null, Charset.defaultCharset(), CSVFormat.DEFAULT));
     }
 
     @Test
-    public void testParseNullPathFormat() {
-        assertThrows(NullPointerException.class,
-            () -> CSVParser.parse((Path) null, Charset.defaultCharset(), CSVFormat.DEFAULT));
+    void testParseNullPathFormat() {
+        assertThrows(NullPointerException.class, () -> CSVParser.parse((Path) null, Charset.defaultCharset(), CSVFormat.DEFAULT));
     }
 
     @Test
-    public void testParseNullStringFormat() {
+    void testParseNullStringFormat() {
         assertThrows(NullPointerException.class, () -> CSVParser.parse((String) null, CSVFormat.DEFAULT));
     }
 
     @Test
-    public void testParseNullUrlCharsetFormat() {
-        assertThrows(NullPointerException.class,
-            () -> CSVParser.parse((URL) null, Charset.defaultCharset(), CSVFormat.DEFAULT));
+    void testParseNullUrlCharsetFormat() {
+        assertThrows(NullPointerException.class, () -> CSVParser.parse((URL) null, Charset.defaultCharset(), CSVFormat.DEFAULT));
     }
 
     @Test
-    public void testParserUrlNullCharsetFormat() {
-        assertThrows(NullPointerException.class,
-            () -> CSVParser.parse(new URL("https://commons.apache.org"), null, CSVFormat.DEFAULT));
+    void testParsePathCharsetNullFormat() throws IOException {
+        final Path path = Paths.get("src/test/resources/org/apache/commons/csv/CSVFileParser/test.csv");
+        try (CSVParser parser = CSVParser.parse(path, Charset.defaultCharset(), null)) {
+            // null maps to DEFAULT.
+            parseFully(parser);
+        }
     }
 
     @Test
-    public void testParseStringNullFormat() {
-        assertThrows(NullPointerException.class, () -> CSVParser.parse("csv data", (CSVFormat) null));
+    void testParserUrlNullCharsetFormat() throws IOException {
+        final URL url = ClassLoader.getSystemClassLoader().getResource("org/apache/commons/csv/CSVFileParser/test.csv");
+        try (CSVParser parser = CSVParser.parse(url, null, CSVFormat.DEFAULT)) {
+            // null maps to DEFAULT.
+            parseFully(parser);
+        }
     }
 
     @Test
-    public void testParseUrlCharsetNullFormat() {
-        assertThrows(NullPointerException.class,
-            () -> CSVParser.parse(new URL("https://commons.apache.org"), Charset.defaultCharset(), null));
+    void testParseStringNullFormat() throws IOException {
+        try (CSVParser parser = CSVParser.parse("1,2,3", null)) {
+            // null maps to DEFAULT.
+            final List records = parser.getRecords();
+            assertEquals(1, records.size());
+            final CSVRecord record = records.get(0);
+            assertEquals(3, record.size());
+            assertEquals("1", record.get(0));
+            assertEquals("2", record.get(1));
+            assertEquals("3", record.get(2));
+        }
     }
 
     @Test
-    public void testProvidedHeader() throws Exception {
-        final Reader in = new StringReader("a,b,c\n1,2,3\nx,y,z");
+    void testParseUrlCharsetNullFormat() throws IOException {
+        final URL url = ClassLoader.getSystemClassLoader().getResource("org/apache/commons/csv/CSVFileParser/test.csv");
+        try (CSVParser parser = CSVParser.parse(url, Charset.defaultCharset(), null)) {
+            // null maps to DEFAULT.
+            parseFully(parser);
+        }
+    }
 
-        final Iterator records = CSVFormat.DEFAULT.withHeader("A", "B", "C").parse(in).iterator();
+    @Test
+    void testParseWithDelimiterStringWithEscape() throws IOException {
+        final String source = "a![!|!]b![|]c[|]xyz\r\nabc[abc][|]xyz";
+        final CSVFormat csvFormat = CSVFormat.DEFAULT.builder().setDelimiter("[|]").setEscape('!').get();
+        try (CSVParser csvParser = csvFormat.parse(new StringReader(source))) {
+            CSVRecord csvRecord = csvParser.nextRecord();
+            assertEquals("a[|]b![|]c", csvRecord.get(0));
+            assertEquals("xyz", csvRecord.get(1));
+            csvRecord = csvParser.nextRecord();
+            assertEquals("abc[abc]", csvRecord.get(0));
+            assertEquals("xyz", csvRecord.get(1));
+        }
+    }
 
-        for (int i = 0; i < 3; i++) {
-            assertTrue(records.hasNext());
-            final CSVRecord record = records.next();
-            assertTrue(record.isMapped("A"));
-            assertTrue(record.isMapped("B"));
-            assertTrue(record.isMapped("C"));
-            assertFalse(record.isMapped("NOT MAPPED"));
-            assertEquals(record.get(0), record.get("A"));
-            assertEquals(record.get(1), record.get("B"));
-            assertEquals(record.get(2), record.get("C"));
+    @Test
+    void testParseWithDelimiterStringWithQuote() throws IOException {
+        final String source = "'a[|]b[|]c'[|]xyz\r\nabc[abc][|]xyz";
+        final CSVFormat csvFormat = CSVFormat.DEFAULT.builder().setDelimiter("[|]").setQuote('\'').get();
+        try (CSVParser csvParser = csvFormat.parse(new StringReader(source))) {
+            CSVRecord csvRecord = csvParser.nextRecord();
+            assertEquals("a[|]b[|]c", csvRecord.get(0));
+            assertEquals("xyz", csvRecord.get(1));
+            csvRecord = csvParser.nextRecord();
+            assertEquals("abc[abc]", csvRecord.get(0));
+            assertEquals("xyz", csvRecord.get(1));
         }
+    }
 
-        assertFalse(records.hasNext());
+    @Test
+    void testParseWithDelimiterWithEscape() throws IOException {
+        final String source = "a!,b!,c,xyz";
+        final CSVFormat csvFormat = CSVFormat.DEFAULT.withEscape('!');
+        try (CSVParser csvParser = csvFormat.parse(new StringReader(source))) {
+            final CSVRecord csvRecord = csvParser.nextRecord();
+            assertEquals("a,b,c", csvRecord.get(0));
+            assertEquals("xyz", csvRecord.get(1));
+        }
+    }
+
+    @Test
+    void testParseWithDelimiterWithQuote() throws IOException {
+        final String source = "'a,b,c',xyz";
+        final CSVFormat csvFormat = CSVFormat.DEFAULT.withQuote('\'');
+        try (CSVParser csvParser = csvFormat.parse(new StringReader(source))) {
+            final CSVRecord csvRecord = csvParser.nextRecord();
+            assertEquals("a,b,c", csvRecord.get(0));
+            assertEquals("xyz", csvRecord.get(1));
+        }
+    }
+
+    @Test
+    void testParseWithQuoteThrowsException() {
+        final CSVFormat csvFormat = CSVFormat.DEFAULT.withQuote('\'');
+        assertThrows(IOException.class, () -> csvFormat.parse(new StringReader("'a,b,c','")).nextRecord());
+        assertThrows(IOException.class, () -> csvFormat.parse(new StringReader("'a,b,c'abc,xyz")).nextRecord());
+        assertThrows(IOException.class, () -> csvFormat.parse(new StringReader("'abc'a,b,c',xyz")).nextRecord());
+    }
+
+    @Test
+    void testParseWithQuoteWithEscape() throws IOException {
+        final String source = "'a?,b?,c?d',xyz";
+        final CSVFormat csvFormat = CSVFormat.DEFAULT.withQuote('\'').withEscape('?');
+        try (CSVParser csvParser = csvFormat.parse(new StringReader(source))) {
+            final CSVRecord csvRecord = csvParser.nextRecord();
+            assertEquals("a,b,c?d", csvRecord.get(0));
+            assertEquals("xyz", csvRecord.get(1));
+        }
+    }
+
+    @ParameterizedTest
+    @EnumSource(CSVFormat.Predefined.class)
+    void testParsingPrintedEmptyFirstColumn(final CSVFormat.Predefined format) throws Exception {
+        final String[][] lines = { { "a", "b" }, { "", "x" } };
+        final StringWriter buf = new StringWriter();
+        try (CSVPrinter printer = new CSVPrinter(buf, format.getFormat())) {
+            printer.printRecords(Stream.of(lines));
+        }
+        try (CSVParser csvRecords = CSVParser.builder()
+                .setReader(new StringReader(buf.toString()))
+                .setFormat(format.getFormat())
+                .get()) {
+            for (final String[] line : lines) {
+                assertValuesEquals(line, csvRecords.nextRecord());
+            }
+            assertNull(csvRecords.nextRecord());
+        }
     }
 
+    /**
+     * A truncated escaped multi-character delimiter at EOF must stay literal data and not be completed from a stale
+     * escape delimiter look-ahead.
+     */
     @Test
-    public void testProvidedHeaderAuto() throws Exception {
+    void testPartialEscapedMultiCharacterDelimiterAtEOF() throws IOException {
+        final CSVFormat format = CSVFormat.DEFAULT.builder().setDelimiter("[|]").setEscape('!').get();
+        try (CSVParser parser = format.parse(new StringReader("x![!|!]y![!|"))) {
+            final CSVRecord record = parser.nextRecord();
+            assertEquals("x[|]y![!|", record.get(0));
+            assertEquals(1, record.size());
+        }
+    }
+
+    /**
+     * Tests CSV-324.
+     */
+    @Test
+    void testPartialMultiCharacterDelimiterAtEOF() throws IOException {
+        final CSVFormat format = CSVFormat.DEFAULT.builder().setDelimiter("[|]").get();
+        try (CSVParser parser = format.parse(new StringReader("a[|]b[|"))) {
+            final CSVRecord record = parser.nextRecord();
+            assertEquals("a", record.get(0));
+            assertEquals("b[|", record.get(1));
+            assertEquals(2, record.size());
+        }
+    }
+
+    /**
+     * A truncated multi-character delimiter at EOF must not be completed from the look-ahead buffer left dirty by an
+     * earlier non-matching peek in the same token.
+     */
+    @Test
+    void testPartialMultiCharacterDelimiterAtEOFAfterMismatch() throws IOException {
+        final CSVFormat format = CSVFormat.DEFAULT.builder().setDelimiter("[|]").get();
+        // The "[a]" peek leaves ']' in the look-ahead buffer; the trailing "[|" must not match "[|]".
+        final String recordString = "x[a][|";
+        try (CSVParser parser = format.parse(new StringReader(recordString))) {
+            final CSVRecord record = parser.nextRecord();
+            assertEquals(recordString, record.get(0));
+            assertEquals(1, record.size());
+        }
+    }
+
+    @Test
+    void testProvidedHeader() throws Exception {
         final Reader in = new StringReader("a,b,c\n1,2,3\nx,y,z");
+        try (CSVParser parser = CSVFormat.DEFAULT.withHeader("A", "B", "C").parse(in)) {
+            final Iterator records = parser.iterator();
+            for (int i = 0; i < 3; i++) {
+                assertTrue(records.hasNext());
+                final CSVRecord record = records.next();
+                assertTrue(record.isMapped("A"));
+                assertTrue(record.isMapped("B"));
+                assertTrue(record.isMapped("C"));
+                assertFalse(record.isMapped("NOT MAPPED"));
+                assertEquals(record.get(0), record.get("A"));
+                assertEquals(record.get(1), record.get("B"));
+                assertEquals(record.get(2), record.get("C"));
+            }
+            assertFalse(records.hasNext());
+        }
+    }
 
-        final Iterator records = CSVFormat.DEFAULT.withHeader().parse(in).iterator();
+    @Test
+    void testProvidedHeaderAuto() throws Exception {
+        final Reader in = new StringReader("a,b,c\n1,2,3\nx,y,z");
+        try (CSVParser parser = CSVFormat.DEFAULT.withHeader().parse(in)) {
+            final Iterator records = parser.iterator();
+            for (int i = 0; i < 2; i++) {
+                assertTrue(records.hasNext());
+                final CSVRecord record = records.next();
+                assertTrue(record.isMapped("a"));
+                assertTrue(record.isMapped("b"));
+                assertTrue(record.isMapped("c"));
+                assertFalse(record.isMapped("NOT MAPPED"));
+                assertEquals(record.get(0), record.get("a"));
+                assertEquals(record.get(1), record.get("b"));
+                assertEquals(record.get(2), record.get("c"));
+            }
+            assertFalse(records.hasNext());
+        }
+    }
 
-        for (int i = 0; i < 2; i++) {
-            assertTrue(records.hasNext());
+    @Test
+    void testRepeatedHeadersAreReturnedInCSVRecordHeaderNames() throws IOException {
+        final Reader in = new StringReader("header1,header2,header1\n1,2,3\n4,5,6");
+        try (CSVParser parser = CSVFormat.DEFAULT.withFirstRecordAsHeader().withTrim().parse(in)) {
+            final Iterator records = parser.iterator();
             final CSVRecord record = records.next();
-            assertTrue(record.isMapped("a"));
-            assertTrue(record.isMapped("b"));
-            assertTrue(record.isMapped("c"));
-            assertFalse(record.isMapped("NOT MAPPED"));
-            assertEquals(record.get(0), record.get("a"));
-            assertEquals(record.get(1), record.get("b"));
-            assertEquals(record.get(2), record.get("c"));
+            @SuppressWarnings("resource")
+            final CSVParser recordParser = record.getParser();
+            assertEquals(Arrays.asList("header1", "header2", "header1"), recordParser.getHeaderNames());
         }
-
-        assertFalse(records.hasNext());
     }
 
     @Test
-    public void testRoundtrip() throws Exception {
+    void testRoundtrip() throws Exception {
         final StringWriter out = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(out, CSVFormat.DEFAULT)) {
-            final String input = "a,b,c\r\n1,2,3\r\nx,y,z\r\n";
-            for (final CSVRecord record : CSVParser.parse(input, CSVFormat.DEFAULT)) {
+        final String data = "a,b,c\r\n1,2,3\r\nx,y,z\r\n";
+        try (CSVPrinter printer = new CSVPrinter(out, CSVFormat.DEFAULT);
+                CSVParser parse = CSVParser.parse(data, CSVFormat.DEFAULT)) {
+            for (final CSVRecord record : parse) {
                 printer.printRecord(record);
             }
-            assertEquals(input, out.toString());
+            assertEquals(data, out.toString());
         }
     }
 
     @Test
-    public void testSkipAutoHeader() throws Exception {
+    void testSkipAutoHeader() throws Exception {
         final Reader in = new StringReader("a,b,c\n1,2,3\nx,y,z");
-        final Iterator records = CSVFormat.DEFAULT.withHeader().parse(in).iterator();
-        final CSVRecord record = records.next();
-        assertEquals("1", record.get("a"));
-        assertEquals("2", record.get("b"));
-        assertEquals("3", record.get("c"));
+        try (CSVParser parser = CSVFormat.DEFAULT.withHeader().parse(in)) {
+            final Iterator records = parser.iterator();
+            final CSVRecord record = records.next();
+            assertEquals("1", record.get("a"));
+            assertEquals("2", record.get("b"));
+            assertEquals("3", record.get("c"));
+        }
     }
 
     @Test
-    public void testSkipHeaderOverrideDuplicateHeaders() throws Exception {
+    void testSkipHeaderOverrideDuplicateHeaders() throws Exception {
         final Reader in = new StringReader("a,a,a\n1,2,3\nx,y,z");
-        final Iterator records = CSVFormat.DEFAULT.withHeader("X", "Y", "Z").withSkipHeaderRecord().parse(in)
-            .iterator();
-        final CSVRecord record = records.next();
-        assertEquals("1", record.get("X"));
-        assertEquals("2", record.get("Y"));
-        assertEquals("3", record.get("Z"));
+        try (CSVParser parser = CSVFormat.DEFAULT.withHeader("X", "Y", "Z").withSkipHeaderRecord().parse(in)) {
+            final Iterator records = parser.iterator();
+            final CSVRecord record = records.next();
+            assertEquals("1", record.get("X"));
+            assertEquals("2", record.get("Y"));
+            assertEquals("3", record.get("Z"));
+        }
     }
 
     @Test
-    public void testSkipSetAltHeaders() throws Exception {
+    void testSkipSetAltHeaders() throws Exception {
         final Reader in = new StringReader("a,b,c\n1,2,3\nx,y,z");
-        final Iterator records = CSVFormat.DEFAULT.withHeader("X", "Y", "Z").withSkipHeaderRecord().parse(in)
-            .iterator();
-        final CSVRecord record = records.next();
-        assertEquals("1", record.get("X"));
-        assertEquals("2", record.get("Y"));
-        assertEquals("3", record.get("Z"));
+        try (CSVParser parser = CSVFormat.DEFAULT.withHeader("X", "Y", "Z").withSkipHeaderRecord().parse(in)) {
+            final Iterator records = parser.iterator();
+            final CSVRecord record = records.next();
+            assertEquals("1", record.get("X"));
+            assertEquals("2", record.get("Y"));
+            assertEquals("3", record.get("Z"));
+        }
     }
 
     @Test
-    public void testSkipSetHeader() throws Exception {
+    void testSkipSetHeader() throws Exception {
         final Reader in = new StringReader("a,b,c\n1,2,3\nx,y,z");
-        final Iterator records = CSVFormat.DEFAULT.withHeader("a", "b", "c").withSkipHeaderRecord().parse(in)
-            .iterator();
-        final CSVRecord record = records.next();
-        assertEquals("1", record.get("a"));
-        assertEquals("2", record.get("b"));
-        assertEquals("3", record.get("c"));
+        try (CSVParser parser = CSVFormat.DEFAULT.withHeader("a", "b", "c").withSkipHeaderRecord().parse(in)) {
+            final Iterator records = parser.iterator();
+            final CSVRecord record = records.next();
+            assertEquals("1", record.get("a"));
+            assertEquals("2", record.get("b"));
+            assertEquals("3", record.get("c"));
+        }
     }
 
     @Test
     @Disabled
-    public void testStartWithEmptyLinesThenHeaders() throws Exception {
-        final String[] codes = { "\r\n\r\n\r\nhello,\r\n\r\n\r\n", "hello,\n\n\n", "hello,\"\"\r\n\r\n\r\n",
-            "hello,\"\"\n\n\n" };
+    void testStartWithEmptyLinesThenHeaders() throws Exception {
+        final String[] codes = { "\r\n\r\n\r\nhello,\r\n\r\n\r\n", "hello,\n\n\n", "hello,\"\"\r\n\r\n\r\n", "hello,\"\"\n\n\n" };
         final String[][] res = { { "hello", "" }, { "" }, // Excel format does not ignore empty lines
-            { "" } };
+                { "" } };
         for (final String code : codes) {
-            try (final CSVParser parser = CSVParser.parse(code, CSVFormat.EXCEL)) {
+            try (CSVParser parser = CSVParser.parse(code, CSVFormat.EXCEL)) {
                 final List records = parser.getRecords();
                 assertEquals(res.length, records.size());
-                assertTrue(records.size() > 0);
+                assertFalse(records.isEmpty());
                 for (int i = 0; i < res.length; i++) {
-                    assertArrayEquals(res[i], records.get(i).values());
+                    assertValuesEquals(res[i], records.get(i));
                 }
             }
         }
     }
 
     @Test
-    public void testTrailingDelimiter() throws Exception {
-        final Reader in = new StringReader("a,a,a,\n\"1\",\"2\",\"3\",\nx,y,z,");
-        final Iterator records = CSVFormat.DEFAULT.withHeader("X", "Y", "Z").withSkipHeaderRecord()
-            .withTrailingDelimiter().parse(in).iterator();
-        final CSVRecord record = records.next();
-        assertEquals("1", record.get("X"));
-        assertEquals("2", record.get("Y"));
-        assertEquals("3", record.get("Z"));
-        assertEquals(3, record.size());
+    void testStream() throws Exception {
+        final Reader in = new StringReader("a,b,c\n1,2,3\nx,y,z");
+        try (CSVParser parser = CSVFormat.DEFAULT.parse(in)) {
+            final List list = parser.stream().collect(Collectors.toList());
+            assertFalse(list.isEmpty());
+            assertValuesEquals(new String[] { "a", "b", "c" }, list.get(0));
+            assertValuesEquals(new String[] { "1", "2", "3" }, list.get(1));
+            assertValuesEquals(new String[] { "x", "y", "z" }, list.get(2));
+        }
+    }
+
+    @ParameterizedTest
+    @ValueSource(longs = { -1, 0, 1, 2, 3, 4, Long.MAX_VALUE })
+    void testStreamMaxRows(final long maxRows) throws Exception {
+        final Reader in = new StringReader("a,b,c\n1,2,3\nx,y,z");
+        try (CSVParser parser = CSVFormat.DEFAULT.builder().setMaxRows(maxRows).get().parse(in)) {
+            final List list = parser.stream().collect(Collectors.toList());
+            assertFalse(list.isEmpty());
+            assertValuesEquals(new String[] { "a", "b", "c" }, list.get(0));
+            if (maxRows <= 0 || maxRows > 1) {
+                assertValuesEquals(new String[] { "1", "2", "3" }, list.get(1));
+            }
+            if (maxRows <= 0 || maxRows > 2) {
+                assertValuesEquals(new String[] { "x", "y", "z" }, list.get(2));
+            }
+        }
     }
 
     @Test
-    public void testTrim() throws Exception {
-        final Reader in = new StringReader("a,a,a\n\" 1 \",\" 2 \",\" 3 \"\nx,y,z");
-        final Iterator records = CSVFormat.DEFAULT.withHeader("X", "Y", "Z").withSkipHeaderRecord()
-            .withTrim().parse(in).iterator();
-        final CSVRecord record = records.next();
-        assertEquals("1", record.get("X"));
-        assertEquals("2", record.get("Y"));
-        assertEquals("3", record.get("Z"));
-        assertEquals(3, record.size());
+    void testThrowExceptionWithLineAndPosition() throws IOException {
+        final String csvContent = "col1,col2,col3,col4,col5,col6,col7,col8,col9,col10\nrec1,rec2,rec3,rec4,rec5,rec6,rec7,rec8,\"\"rec9\"\",rec10";
+        final StringReader stringReader = new StringReader(csvContent);
+        // @formatter:off
+        final CSVFormat csvFormat = CSVFormat.DEFAULT.builder()
+                .setHeader()
+                .setSkipHeaderRecord(true)
+                .get();
+        // @formatter:on
+        try (CSVParser csvParser = csvFormat.parse(stringReader)) {
+            final UncheckedIOException exception = assertThrows(UncheckedIOException.class, csvParser::getRecords);
+            assertInstanceOf(CSVException.class, exception.getCause());
+            assertTrue(exception.getMessage().contains("Invalid character between encapsulated token and delimiter at line: 2, position: 94"),
+                    exception::getMessage);
+        }
     }
 
     @Test
-    public void testRepeatedHeadersAreReturnedInCSVRecordHeaderNames() throws IOException {
-        final Reader in = new StringReader("header1,header2,header1\n1,2,3\n4,5,6");
-        final Iterator records = CSVFormat.DEFAULT.withFirstRecordAsHeader().withTrim().parse(in).iterator();
-        final CSVRecord record = records.next();
-        assertEquals(Arrays.asList("header1", "header2", "header1"), record.getParser().getHeaderNames());
+    void testTrailingDelimiter() throws Exception {
+        final Reader in = new StringReader("a,a,a,\n\"1\",\"2\",\"3\",\nx,y,z,");
+        try (CSVParser parser = CSVFormat.DEFAULT.withHeader("X", "Y", "Z").withSkipHeaderRecord().withTrailingDelimiter().parse(in)) {
+            final Iterator records = parser.iterator();
+            final CSVRecord record = records.next();
+            assertEquals("1", record.get("X"));
+            assertEquals("2", record.get("Y"));
+            assertEquals("3", record.get("Z"));
+            assertEquals(3, record.size());
+        }
     }
 
     @Test
-    public void testCSV235() throws IOException {
-        final String dqString = "\"aaa\",\"b\"\"bb\",\"ccc\""; // "aaa","b""bb","ccc"
-        final Iterator records = CSVFormat.RFC4180.parse(new StringReader(dqString)).iterator();
-        final CSVRecord record = records.next();
-        assertFalse(records.hasNext());
-        assertEquals(3, record.size());
-        assertEquals("aaa", record.get(0));
-        assertEquals("b\"bb", record.get(1));
-        assertEquals("ccc", record.get(2));
+    void testTrailingDelimiterKeepsQuotedEmptyLastField() throws Exception {
+        final CSVFormat format = CSVFormat.DEFAULT.builder().setTrailingDelimiter(true).get();
+        try (CSVParser parser = CSVParser.parse("a,b,\"\"", format)) {
+            final CSVRecord record = parser.iterator().next();
+            assertEquals(3, record.size());
+            assertEquals("a", record.get(0));
+            assertEquals("b", record.get(1));
+            assertEquals("", record.get(2));
+        }
+        // An unquoted trailing delimiter still drops the empty field.
+        try (CSVParser parser = CSVParser.parse("a,b,", format)) {
+            final CSVRecord record = parser.iterator().next();
+            assertEquals(2, record.size());
+        }
+    }
+
+    @Test
+    void testTrim() throws Exception {
+        final Reader in = new StringReader("a,a,a\n\" 1 \",\" 2 \",\" 3 \"\nx,y,z");
+        try (CSVParser parser = CSVFormat.DEFAULT.withHeader("X", "Y", "Z").withSkipHeaderRecord().withTrim().parse(in)) {
+            final Iterator records = parser.iterator();
+            final CSVRecord record = records.next();
+            assertEquals("1", record.get("X"));
+            assertEquals("2", record.get("Y"));
+            assertEquals("3", record.get("Z"));
+            assertEquals(3, record.size());
+        }
     }
 
     private void validateLineNumbers(final String lineSeparator) throws IOException {
-        try (final CSVParser parser = CSVParser.parse("a" + lineSeparator + "b" + lineSeparator + "c",
-            CSVFormat.DEFAULT.withRecordSeparator(lineSeparator))) {
+        try (CSVParser parser = CSVParser.parse("a" + lineSeparator + "b" + lineSeparator + "c", CSVFormat.DEFAULT.withRecordSeparator(lineSeparator))) {
             assertEquals(0, parser.getCurrentLineNumber());
             assertNotNull(parser.nextRecord());
             assertEquals(1, parser.getCurrentLineNumber());
@@ -1201,8 +2021,7 @@ private void validateLineNumbers(final String lineSeparator) throws IOException
     }
 
     private void validateRecordNumbers(final String lineSeparator) throws IOException {
-        try (final CSVParser parser = CSVParser.parse("a" + lineSeparator + "b" + lineSeparator + "c",
-            CSVFormat.DEFAULT.withRecordSeparator(lineSeparator))) {
+        try (CSVParser parser = CSVParser.parse("a" + lineSeparator + "b" + lineSeparator + "c", CSVFormat.DEFAULT.withRecordSeparator(lineSeparator))) {
             CSVRecord record;
             assertEquals(0, parser.getRecordNumber());
             assertNotNull(record = parser.nextRecord());
@@ -1221,61 +2040,77 @@ private void validateRecordNumbers(final String lineSeparator) throws IOExceptio
 
     private void validateRecordPosition(final String lineSeparator) throws IOException {
         final String nl = lineSeparator; // used as linebreak in values for better distinction
-
         final String code = "a,b,c" + lineSeparator + "1,2,3" + lineSeparator +
-        // to see if recordPosition correctly points to the enclosing quote
-            "'A" + nl + "A','B" + nl + "B',CC" + lineSeparator +
-            // unicode test... not very relevant while operating on strings instead of bytes, but for
-            // completeness...
-            "\u00c4,\u00d6,\u00dc" + lineSeparator + "EOF,EOF,EOF";
-
+                // to see if recordPosition correctly points to the enclosing quote
+                "'A" + nl + "A','B" + nl + "B',CC" + lineSeparator +
+                // unicode test... not very relevant while operating on strings instead of bytes, but for
+                // completeness...
+                "\u00c4,\u00d6,\u00dc" + lineSeparator + "EOF,EOF,EOF";
         final CSVFormat format = CSVFormat.newFormat(',').withQuote('\'').withRecordSeparator(lineSeparator);
-        CSVParser parser = CSVParser.parse(code, format);
-
-        CSVRecord record;
-        assertEquals(0, parser.getRecordNumber());
-
-        assertNotNull(record = parser.nextRecord());
-        assertEquals(1, record.getRecordNumber());
-        assertEquals(code.indexOf('a'), record.getCharacterPosition());
-
-        assertNotNull(record = parser.nextRecord());
-        assertEquals(2, record.getRecordNumber());
-        assertEquals(code.indexOf('1'), record.getCharacterPosition());
-
-        assertNotNull(record = parser.nextRecord());
-        final long positionRecord3 = record.getCharacterPosition();
-        assertEquals(3, record.getRecordNumber());
-        assertEquals(code.indexOf("'A"), record.getCharacterPosition());
-        assertEquals("A" + lineSeparator + "A", record.get(0));
-        assertEquals("B" + lineSeparator + "B", record.get(1));
-        assertEquals("CC", record.get(2));
-
-        assertNotNull(record = parser.nextRecord());
-        assertEquals(4, record.getRecordNumber());
-        assertEquals(code.indexOf('\u00c4'), record.getCharacterPosition());
-
-        assertNotNull(record = parser.nextRecord());
-        assertEquals(5, record.getRecordNumber());
-        assertEquals(code.indexOf("EOF"), record.getCharacterPosition());
-
-        parser.close();
-
+        final long positionRecord3;
+        try (CSVParser parser = CSVParser.parse(code, format)) {
+            CSVRecord record;
+            assertEquals(0, parser.getRecordNumber());
+            // nextRecord
+            assertNotNull(record = parser.nextRecord());
+            assertEquals(1, record.getRecordNumber());
+            assertEquals(code.indexOf('a'), record.getCharacterPosition());
+            // nextRecord
+            assertNotNull(record = parser.nextRecord());
+            assertEquals(2, record.getRecordNumber());
+            assertEquals(code.indexOf('1'), record.getCharacterPosition());
+            // nextRecord
+            assertNotNull(record = parser.nextRecord());
+            positionRecord3 = record.getCharacterPosition();
+            assertEquals(3, record.getRecordNumber());
+            assertEquals(code.indexOf("'A"), record.getCharacterPosition());
+            assertEquals("A" + lineSeparator + "A", record.get(0));
+            assertEquals("B" + lineSeparator + "B", record.get(1));
+            assertEquals("CC", record.get(2));
+            // nextRecord
+            assertNotNull(record = parser.nextRecord());
+            assertEquals(4, record.getRecordNumber());
+            assertEquals(code.indexOf('\u00c4'), record.getCharacterPosition());
+            // nextRecord
+            assertNotNull(record = parser.nextRecord());
+            assertEquals(5, record.getRecordNumber());
+            assertEquals(code.indexOf("EOF"), record.getCharacterPosition());
+        }
         // now try to read starting at record 3
-        parser = new CSVParser(new StringReader(code.substring((int) positionRecord3)), format, positionRecord3, 3);
-
-        assertNotNull(record = parser.nextRecord());
-        assertEquals(3, record.getRecordNumber());
-        assertEquals(code.indexOf("'A"), record.getCharacterPosition());
-        assertEquals("A" + lineSeparator + "A", record.get(0));
-        assertEquals("B" + lineSeparator + "B", record.get(1));
-        assertEquals("CC", record.get(2));
-
-        assertNotNull(record = parser.nextRecord());
-        assertEquals(4, record.getRecordNumber());
-        assertEquals(code.indexOf('\u00c4'), record.getCharacterPosition());
-        assertEquals("\u00c4", record.get(0));
-
-        parser.close();
+        try (CSVParser parser = CSVParser.builder()
+                .setReader(new StringReader(code.substring((int) positionRecord3)))
+                .setFormat(format)
+                .setCharacterOffset(positionRecord3)
+                .setRecordNumber(3)
+                .get()) {
+            CSVRecord record;
+            // nextRecord
+            assertNotNull(record = parser.nextRecord());
+            assertEquals(3, record.getRecordNumber());
+            assertEquals(code.indexOf("'A"), record.getCharacterPosition());
+            assertEquals("A" + lineSeparator + "A", record.get(0));
+            assertEquals("B" + lineSeparator + "B", record.get(1));
+            assertEquals("CC", record.get(2));
+            // nextRecord
+            assertNotNull(record = parser.nextRecord());
+            assertEquals(4, record.getRecordNumber());
+            assertEquals(code.indexOf('\u00c4'), record.getCharacterPosition());
+            assertEquals("\u00c4", record.get(0));
+        } // again with ctor
+        try (CSVParser parser = new CSVParser(new StringReader(code.substring((int) positionRecord3)), format, positionRecord3, 3)) {
+            CSVRecord record;
+            // nextRecord
+            assertNotNull(record = parser.nextRecord());
+            assertEquals(3, record.getRecordNumber());
+            assertEquals(code.indexOf("'A"), record.getCharacterPosition());
+            assertEquals("A" + lineSeparator + "A", record.get(0));
+            assertEquals("B" + lineSeparator + "B", record.get(1));
+            assertEquals("CC", record.get(2));
+            // nextRecord
+            assertNotNull(record = parser.nextRecord());
+            assertEquals(4, record.getRecordNumber());
+            assertEquals(code.indexOf('\u00c4'), record.getCharacterPosition());
+            assertEquals("\u00c4", record.get(0));
+        }
     }
 }
diff --git a/src/test/java/org/apache/commons/csv/CSVPrinterTest.java b/src/test/java/org/apache/commons/csv/CSVPrinterTest.java
index 66033b454d..9ae80c1e51 100644
--- a/src/test/java/org/apache/commons/csv/CSVPrinterTest.java
+++ b/src/test/java/org/apache/commons/csv/CSVPrinterTest.java
@@ -1,26 +1,31 @@
 /*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *   https://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.
+ * 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 org.apache.commons.csv;
 
+import static org.apache.commons.csv.Constants.BACKSLASH;
 import static org.apache.commons.csv.Constants.CR;
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
@@ -29,15 +34,17 @@
 
 import java.io.CharArrayWriter;
 import java.io.File;
+import java.io.FileReader;
 import java.io.IOException;
 import java.io.PrintStream;
+import java.io.Reader;
 import java.io.StringReader;
 import java.io.StringWriter;
 import java.io.Writer;
-import java.io.Reader;
-import java.io.FileReader;
 import java.nio.charset.Charset;
 import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
 import java.sql.BatchUpdateException;
 import java.sql.Connection;
 import java.sql.DriverManager;
@@ -53,24 +60,30 @@
 import java.util.Objects;
 import java.util.Random;
 import java.util.Vector;
+import java.util.stream.Stream;
 
 import org.apache.commons.io.FileUtils;
+import org.apache.commons.io.IOUtils;
 import org.apache.commons.io.output.NullOutputStream;
 import org.apache.commons.lang3.StringUtils;
 import org.h2.tools.SimpleResultSet;
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
 
 /**
- *
+ * Tests {@link CSVPrinter}.
  */
-public class CSVPrinterTest {
+class CSVPrinterTest {
 
-    private static final char EURO_CH = '\u20AC';
+    private static final int TABLE_RECORD_COUNT = 2;
+    private static final int TABLE_AND_HEADER_RECORD_COUNT = TABLE_RECORD_COUNT + 1;
     private static final char DQUOTE_CHAR = '"';
-    private static final char BACKSLASH_CH = '\\';
+    private static final char EURO_CH = '\u20AC';
+    private static final int ITERATIONS_FOR_RANDOM_TEST = 50_000;
     private static final char QUOTE_CH = '\'';
-    private static final int ITERATIONS_FOR_RANDOM_TEST = 50000;
+    private static final String RECORD_SEPARATOR = CSVFormat.DEFAULT.getRecordSeparator();
 
     private static String printable(final String s) {
         final StringBuilder sb = new StringBuilder();
@@ -85,9 +98,26 @@ private static String printable(final String s) {
         return sb.toString();
     }
 
-    private final String recordSeparator = CSVFormat.DEFAULT.getRecordSeparator();
     private String longText2;
 
+    private void assertInitialState(final CSVPrinter printer) {
+        assertEquals(0, printer.getRecordCount());
+    }
+
+    private void assertRowCount(final CSVFormat format, final String resultString, final int rowCount) throws IOException {
+        try (CSVParser parser = format.parse(new StringReader(resultString))) {
+            assertEquals(rowCount, parser.getRecords().size());
+        }
+    }
+
+    private File createTempFile() throws IOException {
+        return createTempPath().toFile();
+    }
+
+    private Path createTempPath() throws IOException {
+        return Files.createTempFile(getClass().getName(), ".csv");
+    }
+
     private void doOneRandom(final CSVFormat format) throws Exception {
         final Random r = new Random();
 
@@ -97,7 +127,7 @@ private void doOneRandom(final CSVFormat format) throws Exception {
         final String[][] lines = generateLines(nLines, nCol);
 
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, format)) {
+        try (CSVPrinter printer = new CSVPrinter(sw, format)) {
 
             for (int i = 0; i < nLines; i++) {
                 // for (int j=0; j parseResult = parser.getRecords();
 
             final String[][] expected = lines.clone();
             for (int i = 0; i < expected.length; i++) {
                 expected[i] = expectNulls(expected[i], format);
             }
-            Utils.compare("Printer output :" + printable(result), expected, parseResult);
+            Utils.compare("Printer output :" + printable(result), expected, parseResult, -1);
         }
     }
 
@@ -127,8 +157,8 @@ private void doRandom(final CSVFormat format, final int iter) throws Exception {
     }
 
     /**
-     * Converts an input CSV array into expected output values WRT NULLs. NULL strings are converted to null values
-     * because the parser will convert these strings to null.
+     * Converts an input CSV array into expected output values, including NULLs. NULL strings are converted to null values because the parser will convert
+     * these strings to null.
      */
     private  T[] expectNulls(final T[] original, final CSVFormat csvFormat) {
         final T[] fixed = original.clone();
@@ -140,11 +170,6 @@ private  T[] expectNulls(final T[] original, final CSVFormat csvFormat) {
         return fixed;
     }
 
-    private Connection geH2Connection() throws SQLException, ClassNotFoundException {
-        Class.forName("org.h2.Driver");
-        return DriverManager.getConnection("jdbc:h2:mem:my_test;", "sa", "");
-    }
-
     private String[][] generateLines(final int nLines, final int nCol) {
         final String[][] lines = new String[nLines][];
         for (int i = 0; i < nLines; i++) {
@@ -157,23 +182,31 @@ private String[][] generateLines(final int nLines, final int nCol) {
         return lines;
     }
 
-    private CSVPrinter printWithHeaderComments(final StringWriter sw, final Date now, final CSVFormat baseFormat)
-            throws IOException {
-        CSVFormat format = baseFormat;
+    private Connection getH2Connection() throws SQLException, ClassNotFoundException {
+        Class.forName("org.h2.Driver");
+        return DriverManager.getConnection("jdbc:h2:mem:my_test;", "sa", "");
+    }
+
+    private CSVPrinter printWithHeaderComments(final StringWriter sw, final Date now, final CSVFormat baseFormat) throws IOException {
         // Use withHeaderComments first to test CSV-145
-        format = format.withHeaderComments("Generated by Apache Commons CSV 1.1", now);
-        format = format.withCommentMarker('#');
-        format = format.withHeader("Col1", "Col2");
-        final CSVPrinter csvPrinter = format.print(sw);
-        csvPrinter.printRecord("A", "B");
-        csvPrinter.printRecord("C", "D");
-        csvPrinter.close();
-        return csvPrinter;
+        // @formatter:off
+        final CSVFormat format = baseFormat.builder()
+                .setHeaderComments((String[]) null) // don't blow up
+                .setHeaderComments((Object[]) null) // don't blow up
+                .setHeaderComments("Generated by Apache Commons CSV 1.1", now)
+                .setCommentMarker('#')
+                .setHeader("Col1", "Col2")
+                .get();
+        // @formatter:on
+        final CSVPrinter printer = format.print(sw);
+        printer.printRecord("A", "B");
+        printer.printRecord("C", "D");
+        printer.close();
+        return printer;
     }
 
     private String randStr() {
         final Random r = new Random();
-
         final int sz = r.nextInt(20);
         // sz = r.nextInt(3);
         final char[] buf = new char[sz];
@@ -207,7 +240,7 @@ private String randStr() {
                 ch = '\'';
                 break;
             case 8:
-                ch = BACKSLASH_CH;
+                ch = BACKSLASH;
                 break;
             default:
                 ch = (char) r.nextInt(300);
@@ -220,34 +253,35 @@ private String randStr() {
     }
 
     private void setUpTable(final Connection connection) throws SQLException {
-        try (final Statement statement = connection.createStatement()) {
-            statement.execute("CREATE TABLE TEST(ID INT PRIMARY KEY, NAME VARCHAR(255), TEXT CLOB)");
-            statement.execute("insert into TEST values(1, 'r1', 'long text 1')");
+        try (Statement statement = connection.createStatement()) {
+            statement.execute("CREATE TABLE TEST(ID INT PRIMARY KEY, NAME VARCHAR(255), TEXT CLOB, BIN_DATA BLOB)");
+            statement.execute("insert into TEST values(1, 'r1', 'long text 1', 'binary data 1')");
             longText2 = StringUtils.repeat('a', IOUtils.DEFAULT_BUFFER_SIZE - 4);
-            longText2 += "\"\r\n\"a\"";
-            longText2 += StringUtils.repeat('a', IOUtils.DEFAULT_BUFFER_SIZE - 1);
-            statement.execute("insert into TEST values(2, 'r2', '" + longText2 + "')");
-            longText2 = longText2.replace("\"","\"\"");
+            longText2 += "\"\r\n\"b\"";
+            longText2 += StringUtils.repeat('c', IOUtils.DEFAULT_BUFFER_SIZE - 1);
+            statement.execute("insert into TEST values(2, 'r2', '" + longText2 + "', 'binary data 2')");
+            longText2 = longText2.replace("\"", "\"\"");
         }
     }
 
     @Test
-    public void testCloseBackwardCompatibility() throws IOException {
-        try (final Writer writer = mock(Writer.class)) {
+    void testCloseBackwardCompatibility() throws IOException {
+        try (Writer writer = mock(Writer.class)) {
             final CSVFormat csvFormat = CSVFormat.DEFAULT;
-            try (CSVPrinter csvPrinter = new CSVPrinter(writer, csvFormat)) {
-                // empty
+            try (CSVPrinter printer = new CSVPrinter(writer, csvFormat)) {
+                assertInitialState(printer);
             }
             verify(writer, never()).flush();
             verify(writer, times(1)).close();
-        }}
+        }
+    }
 
     @Test
-    public void testCloseWithCsvFormatAutoFlushOff() throws IOException {
-        try (final Writer writer = mock(Writer.class)) {
+    void testCloseWithCsvFormatAutoFlushOff() throws IOException {
+        try (Writer writer = mock(Writer.class)) {
             final CSVFormat csvFormat = CSVFormat.DEFAULT.withAutoFlush(false);
-            try (CSVPrinter csvPrinter = new CSVPrinter(writer, csvFormat)) {
-                // empty
+            try (CSVPrinter printer = new CSVPrinter(writer, csvFormat)) {
+                assertInitialState(printer);
             }
             verify(writer, never()).flush();
             verify(writer, times(1)).close();
@@ -255,89 +289,98 @@ public void testCloseWithCsvFormatAutoFlushOff() throws IOException {
     }
 
     @Test
-    public void testCloseWithCsvFormatAutoFlushOn() throws IOException {
+    void testCloseWithCsvFormatAutoFlushOn() throws IOException {
         // System.out.println("start method");
-        try (final Writer writer = mock(Writer.class)) {
+        try (Writer writer = mock(Writer.class)) {
             final CSVFormat csvFormat = CSVFormat.DEFAULT.withAutoFlush(true);
-            try (CSVPrinter csvPrinter = new CSVPrinter(writer, csvFormat)) {
-                // empty
+            try (CSVPrinter printer = new CSVPrinter(writer, csvFormat)) {
+                assertInitialState(printer);
             }
             verify(writer, times(1)).flush();
             verify(writer, times(1)).close();
-        }}
+        }
+    }
 
     @Test
-    public void testCloseWithFlushOff() throws IOException {
-        try (final Writer writer = mock(Writer.class)) {
+    void testCloseWithFlushOff() throws IOException {
+        try (Writer writer = mock(Writer.class)) {
             final CSVFormat csvFormat = CSVFormat.DEFAULT;
             @SuppressWarnings("resource")
-            final CSVPrinter csvPrinter = new CSVPrinter(writer, csvFormat);
-            csvPrinter.close(false);
+            final CSVPrinter printer = new CSVPrinter(writer, csvFormat);
+            assertInitialState(printer);
+            printer.close(false);
+            assertEquals(0, printer.getRecordCount());
             verify(writer, never()).flush();
             verify(writer, times(1)).close();
         }
     }
 
     @Test
-    public void testCloseWithFlushOn() throws IOException {
-        try (final Writer writer = mock(Writer.class)) {
-            final CSVFormat csvFormat = CSVFormat.DEFAULT;
+    void testCloseWithFlushOn() throws IOException {
+        try (Writer writer = mock(Writer.class)) {
             @SuppressWarnings("resource")
-            final CSVPrinter csvPrinter = new CSVPrinter(writer, csvFormat);
-            csvPrinter.close(true);
+            final CSVPrinter printer = new CSVPrinter(writer, CSVFormat.DEFAULT);
+            assertInitialState(printer);
+            printer.close(true);
+            assertEquals(0, printer.getRecordCount());
             verify(writer, times(1)).flush();
         }
     }
 
     @Test
-    public void testCRComment() throws IOException {
+    void testCRComment() throws IOException {
         final StringWriter sw = new StringWriter();
         final Object value = "abc";
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withCommentMarker('#'))) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withCommentMarker('#'))) {
+            assertInitialState(printer);
             printer.print(value);
+            assertEquals(0, printer.getRecordCount());
             printer.printComment("This is a comment\r\non multiple lines\rthis is next comment\r");
-            assertEquals("abc" + recordSeparator + "# This is a comment" + recordSeparator + "# on multiple lines"
-                        + recordSeparator + "# this is next comment" + recordSeparator + "# " + recordSeparator, sw.toString());
+            assertEquals("abc" + RECORD_SEPARATOR + "# This is a comment" + RECORD_SEPARATOR + "# on multiple lines" + RECORD_SEPARATOR +
+                    "# this is next comment" + RECORD_SEPARATOR + "# " + RECORD_SEPARATOR, sw.toString());
+            assertEquals(0, printer.getRecordCount());
         }
     }
 
     @Test
-    public void testCSV135() throws IOException {
+    void testCSV135() throws IOException {
         final List list = new LinkedList<>();
-        list.add("\"\"");   // ""
-        list.add("\\\\");   // \\
+        list.add("\"\""); // ""
+        list.add("\\\\"); // \\
         list.add("\\\"\\"); // \"\
         //
         // "",\\,\"\ (unchanged)
         tryFormat(list, null, null, "\"\",\\\\,\\\"\\");
         //
         // """""",\\,"\""\" (quoted, and embedded DQ doubled)
-        tryFormat(list, '"',  null, "\"\"\"\"\"\",\\\\,\"\\\"\"\\\"");
+        tryFormat(list, '"', null, "\"\"\"\"\"\",\\\\,\"\\\"\"\\\"");
         //
         // "",\\\\,\\"\\ (escapes escaped, not quoted)
         tryFormat(list, null, '\\', "\"\",\\\\\\\\,\\\\\"\\\\");
         //
         // "\"\"","\\\\","\\\"\\" (quoted, and embedded DQ & escape escaped)
-        tryFormat(list, '"',  '\\', "\"\\\"\\\"\",\"\\\\\\\\\",\"\\\\\\\"\\\\\"");
+        tryFormat(list, '"', '\\', "\"\\\"\\\"\",\"\\\\\\\\\",\"\\\\\\\"\\\\\"");
         //
         // """""",\\,"\""\" (quoted, embedded DQ escaped)
-        tryFormat(list, '"',  '"',  "\"\"\"\"\"\",\\\\,\"\\\"\"\\\"");
+        tryFormat(list, '"', '"', "\"\"\"\"\"\",\\\\,\"\\\"\"\\\"");
     }
 
     @Test
-    public void testCSV259() throws IOException {
+    void testCSV259() throws IOException {
         final StringWriter sw = new StringWriter();
-        final Reader reader = new FileReader("src/test/resources/org/apache/commons/csv/CSV-259/sample.txt");
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withEscape('!').withQuote(null))) {
+        try (Reader reader = new FileReader("src/test/resources/org/apache/commons/csv/CSV-259/sample.txt");
+                CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withEscape('!').withQuote(null))) {
+            assertInitialState(printer);
             printer.print(reader);
             assertEquals("x!,y!,z", sw.toString());
         }
     }
 
     @Test
-    public void testDelimeterQuoted() throws IOException {
+    void testDelimeterQuoted() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuote('\''))) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuote('\''))) {
+            assertInitialState(printer);
             printer.print("a,b,c");
             printer.print("xyz");
             assertEquals("'a,b,c',xyz", sw.toString());
@@ -345,10 +388,11 @@ public void testDelimeterQuoted() throws IOException {
     }
 
     @Test
-    public void testDelimeterQuoteNone() throws IOException {
+    void testDelimeterQuoteNone() throws IOException {
         final StringWriter sw = new StringWriter();
         final CSVFormat format = CSVFormat.DEFAULT.withEscape('!').withQuoteMode(QuoteMode.NONE);
-        try (final CSVPrinter printer = new CSVPrinter(sw, format)) {
+        try (CSVPrinter printer = new CSVPrinter(sw, format)) {
+            assertInitialState(printer);
             printer.print("a,b,c");
             printer.print("xyz");
             assertEquals("a!,b!,c,xyz", sw.toString());
@@ -356,9 +400,34 @@ public void testDelimeterQuoteNone() throws IOException {
     }
 
     @Test
-    public void testDelimiterEscaped() throws IOException {
+    void testDelimeterStringQuoted() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withEscape('!').withQuote(null))) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.builder().setDelimiter("[|]").setQuote('\'').get())) {
+            assertInitialState(printer);
+            printer.print("a[|]b[|]c");
+            printer.print("xyz");
+            assertEquals("'a[|]b[|]c'[|]xyz", sw.toString());
+        }
+    }
+
+    @Test
+    void testDelimeterStringQuoteNone() throws IOException {
+        final StringWriter sw = new StringWriter();
+        final CSVFormat format = CSVFormat.DEFAULT.builder().setDelimiter("[|]").setEscape('!').setQuoteMode(QuoteMode.NONE).get();
+        try (CSVPrinter printer = new CSVPrinter(sw, format)) {
+            assertInitialState(printer);
+            printer.print("a[|]b[|]c");
+            printer.print("xyz");
+            printer.print("a[xy]bc[]");
+            assertEquals("a![!|!]b![!|!]c[|]xyz[|]a[xy]bc[]", sw.toString());
+        }
+    }
+
+    @Test
+    void testDelimiterEscaped() throws IOException {
+        final StringWriter sw = new StringWriter();
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withEscape('!').withQuote(null))) {
+            assertInitialState(printer);
             printer.print("a,b,c");
             printer.print("xyz");
             assertEquals("a!,b!,c,xyz", sw.toString());
@@ -366,9 +435,10 @@ public void testDelimiterEscaped() throws IOException {
     }
 
     @Test
-    public void testDelimiterPlain() throws IOException {
+    void testDelimiterPlain() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuote(null))) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuote(null))) {
+            assertInitialState(printer);
             printer.print("a,b,c");
             printer.print("xyz");
             assertEquals("a,b,c,xyz", sw.toString());
@@ -376,27 +446,42 @@ public void testDelimiterPlain() throws IOException {
     }
 
     @Test
-    public void testDisabledComment() throws IOException {
+    void testDelimiterStringEscaped() throws IOException {
+        final StringWriter sw = new StringWriter();
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.builder().setDelimiter("|||").setEscape('!').setQuote(null).get())) {
+            assertInitialState(printer);
+            printer.print("a|||b|||c");
+            printer.print("xyz");
+            assertEquals("a!|!|!|b!|!|!|c|||xyz", sw.toString());
+        }
+    }
+
+    @Test
+    void testDisabledComment() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT)) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT)) {
+            assertInitialState(printer);
             printer.printComment("This is a comment");
             assertEquals("", sw.toString());
+            assertEquals(0, printer.getRecordCount());
         }
     }
 
     @Test
-    public void testDontQuoteEuroFirstChar() throws IOException {
+    void testDontQuoteEuroFirstChar() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.RFC4180)) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.RFC4180)) {
+            assertInitialState(printer);
             printer.printRecord(EURO_CH, "Deux");
-            assertEquals(EURO_CH + ",Deux" + recordSeparator, sw.toString());
+            assertEquals(EURO_CH + ",Deux" + RECORD_SEPARATOR, sw.toString());
         }
     }
 
     @Test
-    public void testEolEscaped() throws IOException {
+    void testEolEscaped() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuote(null).withEscape('!'))) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuote(null).withEscape('!'))) {
+            assertInitialState(printer);
             printer.print("a\rb\nc");
             printer.print("x\fy\bz");
             assertEquals("a!rb!nc,x\fy\bz", sw.toString());
@@ -404,9 +489,10 @@ public void testEolEscaped() throws IOException {
     }
 
     @Test
-    public void testEolPlain() throws IOException {
+    void testEolPlain() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuote(null))) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuote(null))) {
+            assertInitialState(printer);
             printer.print("a\rb\nc");
             printer.print("x\fy\bz");
             assertEquals("a\rb\nc,x\fy\bz", sw.toString());
@@ -414,166 +500,307 @@ public void testEolPlain() throws IOException {
     }
 
     @Test
-    public void testEolQuoted() throws IOException {
+    void testEolQuoted() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuote('\''))) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuote('\''))) {
+            assertInitialState(printer);
             printer.print("a\rb\nc");
             printer.print("x\by\fz");
             assertEquals("'a\rb\nc',x\by\fz", sw.toString());
         }
     }
 
+    @SuppressWarnings("unlikely-arg-type")
     @Test
-    public void testEscapeBackslash1() throws IOException {
+    void testEquals() throws IOException {
+        // Don't use assertNotEquals here
+        assertFalse(CSVFormat.DEFAULT.equals(null));
+        // Don't use assertNotEquals here
+        assertFalse(CSVFormat.DEFAULT.equals(""));
+    }
+
+    @Test
+    void testEscapeBackslash1() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuote(QUOTE_CH))) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuote(QUOTE_CH))) {
+            assertInitialState(printer);
             printer.print("\\");
         }
         assertEquals("\\", sw.toString());
     }
 
     @Test
-    public void testEscapeBackslash2() throws IOException {
+    void testEscapeBackslash2() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuote(QUOTE_CH))) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuote(QUOTE_CH))) {
+            assertInitialState(printer);
             printer.print("\\\r");
         }
         assertEquals("'\\\r'", sw.toString());
     }
 
     @Test
-    public void testEscapeBackslash3() throws IOException {
+    void testEscapeBackslash3() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuote(QUOTE_CH))) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuote(QUOTE_CH))) {
+            assertInitialState(printer);
             printer.print("X\\\r");
         }
         assertEquals("'X\\\r'", sw.toString());
     }
 
     @Test
-    public void testEscapeBackslash4() throws IOException {
+    void testEscapeBackslash4() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuote(QUOTE_CH))) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuote(QUOTE_CH))) {
+            assertInitialState(printer);
             printer.print("\\\\");
         }
         assertEquals("\\\\", sw.toString());
     }
 
     @Test
-    public void testEscapeBackslash5() throws IOException {
+    void testEscapeBackslash5() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuote(QUOTE_CH))) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuote(QUOTE_CH))) {
+            assertInitialState(printer);
             printer.print("\\\\");
         }
         assertEquals("\\\\", sw.toString());
     }
 
     @Test
-    public void testEscapeNull1() throws IOException {
+    void testEscapeCommentMarkerFirstChar() throws IOException {
+        // No quoting available in escape mode, so a leading comment marker must be escaped or the
+        // record reads back as a comment and is dropped. Mirrors the quoting fix for QuoteMode.MINIMAL.
+        final CSVFormat format = CSVFormat.DEFAULT.builder().setQuote(null).setEscape('\\').setCommentMarker(';').get();
+        final StringWriter sw = new StringWriter();
+        final String col1 = ";comment-like";
+        try (CSVPrinter printer = new CSVPrinter(sw, format)) {
+            printer.printRecord(col1, "b");
+            printer.printRecord(new StringReader(col1), new StringReader("b"));
+            // The marker past the first character does not start a comment and is left alone.
+            printer.printRecord("a;b", ";c");
+        }
+        final String string = sw.toString();
+        assertEquals("\\;comment-like,b" + RECORD_SEPARATOR +
+                "\\;comment-like,b" + RECORD_SEPARATOR +
+                "a;b,\\;c" + RECORD_SEPARATOR, string);
+        // The emitted records must read back as the original values, none parsed as a comment.
+        try (CSVParser parser = CSVParser.parse(string, format)) {
+            final List records = parser.getRecords();
+            assertEquals(3, records.size());
+            assertEquals(col1, records.get(0).get(0));
+            assertEquals("b", records.get(0).get(1));
+            assertEquals(col1, records.get(1).get(0));
+            assertEquals("b", records.get(1).get(1));
+            assertEquals("a;b", records.get(2).get(0));
+            assertEquals(";c", records.get(2).get(1));
+        }
+    }
+
+    @Test
+    void testEscapeCommentMarkerFirstCharWithQuoteModeNone() throws IOException {
+        final CSVFormat format = CSVFormat.DEFAULT.builder().setEscape('\\').setQuoteMode(QuoteMode.NONE).setCommentMarker(';').get();
+        final StringWriter sw = new StringWriter();
+        final String col1 = ";bar";
+        try (CSVPrinter printer = new CSVPrinter(sw, format)) {
+            printer.printRecord(col1, "b");
+            printer.printRecord(new StringReader(col1), new StringReader("b"));
+        }
+        final String string = sw.toString();
+        assertEquals("\\;bar,b" + RECORD_SEPARATOR + "\\;bar,b" + RECORD_SEPARATOR, string);
+        try (CSVParser parser = CSVParser.parse(string, format)) {
+            final List records = parser.getRecords();
+            assertEquals(2, records.size());
+            for (final CSVRecord record : records) {
+                assertEquals(col1, record.get(0));
+                assertEquals("b", record.get(1));
+            }
+        }
+    }
+
+    @Test
+    void testEscapeNull1() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withEscape(null))) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withEscape(null))) {
+            assertInitialState(printer);
             printer.print("\\");
         }
         assertEquals("\\", sw.toString());
     }
 
     @Test
-    public void testEscapeNull2() throws IOException {
+    void testEscapeNull2() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withEscape(null))) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withEscape(null))) {
+            assertInitialState(printer);
             printer.print("\\\r");
         }
         assertEquals("\"\\\r\"", sw.toString());
     }
 
     @Test
-    public void testEscapeNull3() throws IOException {
+    void testEscapeNull3() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withEscape(null))) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withEscape(null))) {
+            assertInitialState(printer);
             printer.print("X\\\r");
         }
         assertEquals("\"X\\\r\"", sw.toString());
     }
 
     @Test
-    public void testEscapeNull4() throws IOException {
+    void testEscapeNull4() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withEscape(null))) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withEscape(null))) {
+            assertInitialState(printer);
             printer.print("\\\\");
         }
         assertEquals("\\\\", sw.toString());
     }
 
     @Test
-    public void testEscapeNull5() throws IOException {
+    void testEscapeNull5() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withEscape(null))) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withEscape(null))) {
+            assertInitialState(printer);
             printer.print("\\\\");
         }
         assertEquals("\\\\", sw.toString());
     }
 
     @Test
-    public void testExcelPrintAllArrayOfArrays() throws IOException {
+    void testExcelPrintAllArrayOfArrays() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.EXCEL)) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.EXCEL)) {
+            assertInitialState(printer);
             printer.printRecords((Object[]) new String[][] { { "r1c1", "r1c2" }, { "r2c1", "r2c2" } });
-            assertEquals("r1c1,r1c2" + recordSeparator + "r2c1,r2c2" + recordSeparator, sw.toString());
+            assertEquals("r1c1,r1c2" + RECORD_SEPARATOR + "r2c1,r2c2" + RECORD_SEPARATOR, sw.toString());
+        }
+    }
+
+    @Test
+    void testExcelPrintAllArrayOfArraysWithFirstEmptyValue2() throws IOException {
+        final StringWriter sw = new StringWriter();
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.EXCEL)) {
+            assertInitialState(printer);
+            printer.printRecords((Object[]) new String[][] { { "" } });
+            assertEquals("\"\"" + RECORD_SEPARATOR, sw.toString());
+        }
+    }
+
+    @Test
+    void testExcelPrintAllArrayOfArraysWithFirstSpaceValue1() throws IOException {
+        final StringWriter sw = new StringWriter();
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.EXCEL)) {
+            assertInitialState(printer);
+            printer.printRecords((Object[]) new String[][] { { " ", "r1c2" } });
+            assertEquals("\" \",r1c2" + RECORD_SEPARATOR, sw.toString());
+        }
+    }
+
+    @Test
+    void testExcelPrintAllArrayOfArraysWithFirstTabValue1() throws IOException {
+        final StringWriter sw = new StringWriter();
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.EXCEL)) {
+            assertInitialState(printer);
+            printer.printRecords((Object[]) new String[][] { { "\t", "r1c2" } });
+            assertEquals("\"\t\",r1c2" + RECORD_SEPARATOR, sw.toString());
+        }
+    }
+
+    @Test
+    void testExcelPrintAllArrayOfLists() throws IOException {
+        final StringWriter sw = new StringWriter();
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.EXCEL)) {
+            assertInitialState(printer);
+            printer.printRecords((Object[]) new List[] { Arrays.asList("r1c1", "r1c2"), Arrays.asList("r2c1", "r2c2") });
+            assertEquals("r1c1,r1c2" + RECORD_SEPARATOR + "r2c1,r2c2" + RECORD_SEPARATOR, sw.toString());
         }
     }
 
     @Test
-    public void testExcelPrintAllArrayOfLists() throws IOException {
+    void testExcelPrintAllArrayOfListsWithFirstEmptyValue2() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.EXCEL)) {
-            printer.printRecords(
-                    (Object[]) new List[] { Arrays.asList("r1c1", "r1c2"), Arrays.asList("r2c1", "r2c2") });
-            assertEquals("r1c1,r1c2" + recordSeparator + "r2c1,r2c2" + recordSeparator, sw.toString());
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.EXCEL)) {
+            assertInitialState(printer);
+            printer.printRecords((Object[]) new List[] { Arrays.asList("") });
+            assertEquals("\"\"" + RECORD_SEPARATOR, sw.toString());
         }
     }
 
     @Test
-    public void testExcelPrintAllIterableOfArrays() throws IOException {
+    void testExcelPrintAllIterableOfArrays() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.EXCEL)) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.EXCEL)) {
+            assertInitialState(printer);
             printer.printRecords(Arrays.asList(new String[][] { { "r1c1", "r1c2" }, { "r2c1", "r2c2" } }));
-            assertEquals("r1c1,r1c2" + recordSeparator + "r2c1,r2c2" + recordSeparator, sw.toString());
+            assertEquals("r1c1,r1c2" + RECORD_SEPARATOR + "r2c1,r2c2" + RECORD_SEPARATOR, sw.toString());
         }
     }
 
     @Test
-    public void testExcelPrintAllIterableOfLists() throws IOException {
+    void testExcelPrintAllIterableOfArraysWithFirstEmptyValue2() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.EXCEL)) {
-            printer.printRecords(
-                    Arrays.asList(new List[] { Arrays.asList("r1c1", "r1c2"), Arrays.asList("r2c1", "r2c2") }));
-            assertEquals("r1c1,r1c2" + recordSeparator + "r2c1,r2c2" + recordSeparator, sw.toString());
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.EXCEL)) {
+            assertInitialState(printer);
+            printer.printRecords(Arrays.asList(new String[][] { { "" } }));
+            assertEquals("\"\"" + RECORD_SEPARATOR, sw.toString());
         }
     }
 
     @Test
-    public void testExcelPrinter1() throws IOException {
+    void testExcelPrintAllIterableOfLists() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.EXCEL)) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.EXCEL)) {
+            assertInitialState(printer);
+            printer.printRecords(Arrays.asList(Arrays.asList("r1c1", "r1c2"), Arrays.asList("r2c1", "r2c2")));
+            assertEquals("r1c1,r1c2" + RECORD_SEPARATOR + "r2c1,r2c2" + RECORD_SEPARATOR, sw.toString());
+        }
+    }
+
+    @ParameterizedTest
+    @ValueSource(longs = { -1, 0, 1, 2, Long.MAX_VALUE })
+    void testExcelPrintAllStreamOfArrays(final long maxRows) throws IOException {
+        final StringWriter sw = new StringWriter();
+        final CSVFormat format = CSVFormat.EXCEL.builder().setMaxRows(maxRows).get();
+        try (CSVPrinter printer = new CSVPrinter(sw, format)) {
+            assertInitialState(printer);
+            printer.printRecords(Stream.of(new String[][] { { "r1c1", "r1c2" }, { "r2c1", "r2c2" } }));
+            String expected = "r1c1,r1c2" + RECORD_SEPARATOR;
+            if (maxRows != 1) {
+                expected += "r2c1,r2c2" + RECORD_SEPARATOR;
+            }
+            assertEquals(expected, sw.toString());
+        }
+    }
+
+    @Test
+    void testExcelPrinter1() throws IOException {
+        final StringWriter sw = new StringWriter();
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.EXCEL)) {
+            assertInitialState(printer);
             printer.printRecord("a", "b");
-            assertEquals("a,b" + recordSeparator, sw.toString());
+            assertEquals("a,b" + RECORD_SEPARATOR, sw.toString());
         }
     }
 
     @Test
-    public void testExcelPrinter2() throws IOException {
+    void testExcelPrinter2() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.EXCEL)) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.EXCEL)) {
+            assertInitialState(printer);
             printer.printRecord("a,b", "b");
-            assertEquals("\"a,b\",b" + recordSeparator, sw.toString());
+            assertEquals("\"a,b\",b" + RECORD_SEPARATOR, sw.toString());
         }
     }
 
     @Test
-    public void testHeader() throws IOException {
+    void testHeader() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw,
-                CSVFormat.DEFAULT.withQuote(null).withHeader("C1", "C2", "C3"))) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuote(null).withHeader("C1", "C2", "C3"))) {
+            assertEquals(1, printer.getRecordCount());
             printer.printRecord("a", "b", "c");
             printer.printRecord("x", "y", "z");
             assertEquals("C1,C2,C3\r\na,b,c\r\nx,y,z\r\n", sw.toString());
@@ -581,31 +808,30 @@ public void testHeader() throws IOException {
     }
 
     @Test
-    public void testHeaderCommentExcel() throws IOException {
+    void testHeaderCommentExcel() throws IOException {
         final StringWriter sw = new StringWriter();
         final Date now = new Date();
         final CSVFormat format = CSVFormat.EXCEL;
-        try (final CSVPrinter csvPrinter = printWithHeaderComments(sw, now, format)) {
-            assertEquals("# Generated by Apache Commons CSV 1.1\r\n# " + now + "\r\nCol1,Col2\r\nA,B\r\nC,D\r\n",
-                    sw.toString());
+        try (CSVPrinter csvPrinter = printWithHeaderComments(sw, now, format)) {
+            assertEquals("# Generated by Apache Commons CSV 1.1\r\n# " + now + "\r\nCol1,Col2\r\nA,B\r\nC,D\r\n", sw.toString());
         }
     }
 
     @Test
-    public void testHeaderCommentTdf() throws IOException {
+    void testHeaderCommentTdf() throws IOException {
         final StringWriter sw = new StringWriter();
         final Date now = new Date();
         final CSVFormat format = CSVFormat.TDF;
-        try (final CSVPrinter csvPrinter = printWithHeaderComments(sw, now, format)) {
-            assertEquals("# Generated by Apache Commons CSV 1.1\r\n# " + now + "\r\nCol1\tCol2\r\nA\tB\r\nC\tD\r\n",
-                    sw.toString());
+        try (CSVPrinter csvPrinter = printWithHeaderComments(sw, now, format)) {
+            assertEquals("# Generated by Apache Commons CSV 1.1\r\n# " + now + "\r\nCol1\tCol2\r\nA\tB\r\nC\tD\r\n", sw.toString());
         }
     }
 
     @Test
-    public void testHeaderNotSet() throws IOException {
+    void testHeaderNotSet() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuote(null))) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuote(null))) {
+            assertInitialState(printer);
             printer.printRecord("a", "b", "c");
             printer.printRecord("x", "y", "z");
             assertEquals("a,b,c\r\nx,y,z\r\n", sw.toString());
@@ -613,63 +839,137 @@ public void testHeaderNotSet() throws IOException {
     }
 
     @Test
-    public void testInvalidFormat() {
+    void testInvalidFormat() {
         assertThrows(IllegalArgumentException.class, () -> CSVFormat.DEFAULT.withDelimiter(CR));
     }
 
     @Test
-    public void testJdbcPrinter() throws IOException, ClassNotFoundException, SQLException {
+    void testJdbcPrinter() throws IOException, ClassNotFoundException, SQLException {
         final StringWriter sw = new StringWriter();
-        try (final Connection connection = geH2Connection()) {
+        final CSVFormat csvFormat = CSVFormat.DEFAULT;
+        try (Connection connection = getH2Connection()) {
             setUpTable(connection);
-            try (final Statement stmt = connection.createStatement();
-                    final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT)) {
-                printer.printRecords(stmt.executeQuery("select ID, NAME, TEXT from TEST"));
+            try (Statement stmt = connection.createStatement();
+                    CSVPrinter printer = new CSVPrinter(sw, csvFormat);
+                    ResultSet resultSet = stmt.executeQuery("select ID, NAME, TEXT, BIN_DATA from TEST")) {
+                assertInitialState(printer);
+                printer.printRecords(resultSet);
+                assertEquals(TABLE_RECORD_COUNT, printer.getRecordCount());
             }
         }
-        assertEquals("1,r1,\"long text 1\"" + recordSeparator + "2,r2,\"" + longText2 + "\"" + recordSeparator,
-                sw.toString());
+        final String csv = sw.toString();
+        assertEquals("1,r1,\"long text 1\",\"YmluYXJ5IGRhdGEgMQ==\"" + RECORD_SEPARATOR + "2,r2,\"" + longText2 + "\",\"YmluYXJ5IGRhdGEgMg==\"" +
+                RECORD_SEPARATOR, csv);
+        // Round trip the data
+        try (StringReader reader = new StringReader(csv);
+                CSVParser csvParser = csvFormat.parse(reader)) {
+            // Row 1
+            CSVRecord record = csvParser.nextRecord();
+            assertEquals("1", record.get(0));
+            assertEquals("r1", record.get(1));
+            assertEquals("long text 1", record.get(2));
+            assertEquals("YmluYXJ5IGRhdGEgMQ==", record.get(3));
+            // Row 2
+            record = csvParser.nextRecord();
+            assertEquals("2", record.get(0));
+            assertEquals("r2", record.get(1));
+            assertEquals("YmluYXJ5IGRhdGEgMg==", record.get(3));
+        }
+    }
+
+    @Test
+    void testJdbcPrinterWithFirstEmptyValue2() throws IOException, ClassNotFoundException, SQLException {
+        final StringWriter sw = new StringWriter();
+        try (Connection connection = getH2Connection()) {
+            try (Statement stmt = connection.createStatement();
+                    ResultSet resultSet = stmt.executeQuery("select '' AS EMPTYVALUE from DUAL");
+                    CSVPrinter printer = CSVFormat.DEFAULT.withHeader(resultSet).print(sw)) {
+                printer.printRecords(resultSet);
+            }
+        }
+        assertEquals("EMPTYVALUE" + RECORD_SEPARATOR + "\"\"" + RECORD_SEPARATOR, sw.toString());
     }
 
-    @Test
-    public void testJdbcPrinterWithResultSet() throws IOException, ClassNotFoundException, SQLException {
+    @ParameterizedTest
+    @ValueSource(longs = { -1, 0, 1, 2, 3, 4, Long.MAX_VALUE })
+    void testJdbcPrinterWithResultSet(final long maxRows) throws IOException, ClassNotFoundException, SQLException {
         final StringWriter sw = new StringWriter();
-        Class.forName("org.h2.Driver");
-        try (final Connection connection = geH2Connection();) {
+        final CSVFormat format = CSVFormat.DEFAULT.builder().setMaxRows(maxRows).get();
+        try (Connection connection = getH2Connection()) {
             setUpTable(connection);
-            try (final Statement stmt = connection.createStatement();
-                    final ResultSet resultSet = stmt.executeQuery("select ID, NAME, TEXT from TEST");
-                    final CSVPrinter printer = CSVFormat.DEFAULT.withHeader(resultSet).print(sw)) {
+            try (Statement stmt = connection.createStatement();
+                    ResultSet resultSet = stmt.executeQuery("select ID, NAME, TEXT from TEST");
+                    CSVPrinter printer = format.withHeader(resultSet).print(sw)) {
                 printer.printRecords(resultSet);
             }
         }
-        assertEquals("ID,NAME,TEXT" + recordSeparator + "1,r1,\"long text 1\"" + recordSeparator + "2,r2,\"" + longText2
-                + "\"" + recordSeparator, sw.toString());
+        final String resultString = sw.toString();
+        final String header = "ID,NAME,TEXT";
+        final String headerRow1 = header + RECORD_SEPARATOR + "1,r1,\"long text 1\"" + RECORD_SEPARATOR;
+        final String allRows = headerRow1 + "2,r2,\"" + longText2 + "\"" + RECORD_SEPARATOR;
+        final int expectedRowsWithHeader;
+        if (maxRows == 1) {
+            assertEquals(headerRow1, resultString);
+            expectedRowsWithHeader = 2;
+        } else {
+            assertEquals(allRows, resultString);
+            expectedRowsWithHeader = TABLE_AND_HEADER_RECORD_COUNT;
+        }
+        assertRowCount(CSVFormat.DEFAULT, resultString, expectedRowsWithHeader);
     }
 
-    @Test
-    public void testJdbcPrinterWithResultSetMetaData() throws IOException, ClassNotFoundException, SQLException {
+    @ParameterizedTest
+    @ValueSource(longs = { -1, 0, 3, 4, Long.MAX_VALUE })
+    void testJdbcPrinterWithResultSetHeader(final long maxRows) throws IOException, ClassNotFoundException, SQLException {
         final StringWriter sw = new StringWriter();
-        Class.forName("org.h2.Driver");
-        try (final Connection connection = geH2Connection()) {
+        try (Connection connection = getH2Connection()) {
             setUpTable(connection);
-            try (final Statement stmt = connection.createStatement();
-                    final ResultSet resultSet = stmt.executeQuery("select ID, NAME, TEXT from TEST");
-                    final CSVPrinter printer = CSVFormat.DEFAULT.withHeader(resultSet.getMetaData()).print(sw)) {
+            final CSVFormat format = CSVFormat.DEFAULT.builder().setMaxRows(maxRows).get();
+            try (Statement stmt = connection.createStatement();
+                    CSVPrinter printer = new CSVPrinter(sw, format)) {
+                try (ResultSet resultSet = stmt.executeQuery("select ID, NAME from TEST")) {
+                    printer.printRecords(resultSet, true);
+                    assertEquals(TABLE_RECORD_COUNT, printer.getRecordCount());
+                    assertEquals("ID,NAME" + RECORD_SEPARATOR + "1,r1" + RECORD_SEPARATOR + "2,r2" + RECORD_SEPARATOR, sw.toString());
+                }
+                assertRowCount(format, sw.toString(), TABLE_AND_HEADER_RECORD_COUNT);
+                try (ResultSet resultSet = stmt.executeQuery("select ID, NAME from TEST")) {
+                    printer.printRecords(resultSet, false);
+                    assertEquals(TABLE_RECORD_COUNT * 2, printer.getRecordCount());
+                    assertNotEquals("ID,NAME" + RECORD_SEPARATOR + "1,r1" + RECORD_SEPARATOR + "2,r2" + RECORD_SEPARATOR, sw.toString());
+                }
+                assertRowCount(CSVFormat.DEFAULT, sw.toString(), TABLE_AND_HEADER_RECORD_COUNT + TABLE_RECORD_COUNT);
+            }
+        }
+    }
+
+    @ParameterizedTest
+    @ValueSource(longs = { -1, 0, 3, 4, Long.MAX_VALUE })
+    void testJdbcPrinterWithResultSetMetaData(final long maxRows) throws IOException, ClassNotFoundException, SQLException {
+        final StringWriter sw = new StringWriter();
+        try (Connection connection = getH2Connection()) {
+            setUpTable(connection);
+            final CSVFormat format = CSVFormat.DEFAULT.builder().setMaxRows(maxRows).get();
+            try (Statement stmt = connection.createStatement();
+                    ResultSet resultSet = stmt.executeQuery("select ID, NAME, TEXT from TEST");
+                    CSVPrinter printer = format.withHeader(resultSet.getMetaData()).print(sw)) {
+                // The header is the first record.
+                assertEquals(1, printer.getRecordCount());
                 printer.printRecords(resultSet);
-                assertEquals("ID,NAME,TEXT" + recordSeparator + "1,r1,\"long text 1\"" + recordSeparator + "2,r2,\""
-                        + longText2 + "\"" + recordSeparator, sw.toString());
+                assertEquals(3, printer.getRecordCount());
+                assertEquals("ID,NAME,TEXT" + RECORD_SEPARATOR + "1,r1,\"long text 1\"" + RECORD_SEPARATOR + "2,r2,\"" + longText2 + "\"" + RECORD_SEPARATOR,
+                        sw.toString());
             }
+            assertRowCount(format, sw.toString(), TABLE_AND_HEADER_RECORD_COUNT);
         }
     }
 
     @Test
-    @Disabled
-    public void testJira135_part1() throws IOException {
-        final CSVFormat format = CSVFormat.DEFAULT.withRecordSeparator('\n').withQuote(DQUOTE_CHAR).withEscape(BACKSLASH_CH);
+    void testJira135_part1() throws IOException {
+        final CSVFormat format = CSVFormat.DEFAULT.withRecordSeparator('\n').withQuote(DQUOTE_CHAR).withEscape(BACKSLASH);
         final StringWriter sw = new StringWriter();
         final List list = new LinkedList<>();
-        try (final CSVPrinter printer = new CSVPrinter(sw, format)) {
+        try (CSVPrinter printer = new CSVPrinter(sw, format)) {
             list.add("\"");
             printer.printRecord(list);
         }
@@ -681,11 +981,11 @@ public void testJira135_part1() throws IOException {
 
     @Test
     @Disabled
-    public void testJira135_part2() throws IOException {
-        final CSVFormat format = CSVFormat.DEFAULT.withRecordSeparator('\n').withQuote(DQUOTE_CHAR).withEscape(BACKSLASH_CH);
+    void testJira135_part2() throws IOException {
+        final CSVFormat format = CSVFormat.DEFAULT.withRecordSeparator('\n').withQuote(DQUOTE_CHAR).withEscape(BACKSLASH);
         final StringWriter sw = new StringWriter();
         final List list = new LinkedList<>();
-        try (final CSVPrinter printer = new CSVPrinter(sw, format)) {
+        try (CSVPrinter printer = new CSVPrinter(sw, format)) {
             list.add("\n");
             printer.printRecord(list);
         }
@@ -696,12 +996,11 @@ public void testJira135_part2() throws IOException {
     }
 
     @Test
-    @Disabled
-    public void testJira135_part3() throws IOException {
-        final CSVFormat format = CSVFormat.DEFAULT.withRecordSeparator('\n').withQuote(DQUOTE_CHAR).withEscape(BACKSLASH_CH);
+    void testJira135_part3() throws IOException {
+        final CSVFormat format = CSVFormat.DEFAULT.withRecordSeparator('\n').withQuote(DQUOTE_CHAR).withEscape(BACKSLASH);
         final StringWriter sw = new StringWriter();
         final List list = new LinkedList<>();
-        try (final CSVPrinter printer = new CSVPrinter(sw, format)) {
+        try (CSVPrinter printer = new CSVPrinter(sw, format)) {
             list.add("\\");
             printer.printRecord(list);
         }
@@ -713,11 +1012,11 @@ public void testJira135_part3() throws IOException {
 
     @Test
     @Disabled
-    public void testJira135All() throws IOException {
-        final CSVFormat format = CSVFormat.DEFAULT.withRecordSeparator('\n').withQuote(DQUOTE_CHAR).withEscape(BACKSLASH_CH);
+    void testJira135All() throws IOException {
+        final CSVFormat format = CSVFormat.DEFAULT.withRecordSeparator('\n').withQuote(DQUOTE_CHAR).withEscape(BACKSLASH);
         final StringWriter sw = new StringWriter();
         final List list = new LinkedList<>();
-        try (final CSVPrinter printer = new CSVPrinter(sw, format)) {
+        try (CSVPrinter printer = new CSVPrinter(sw, format)) {
             list.add("\"");
             list.add("\n");
             list.add("\\");
@@ -730,97 +1029,101 @@ public void testJira135All() throws IOException {
     }
 
     @Test
-    public void testMongoDbCsvBasic() throws IOException {
+    void testMongoDbCsvBasic() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.MONGODB_CSV)) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.MONGODB_CSV)) {
             printer.printRecord("a", "b");
-            assertEquals("a,b" + recordSeparator, sw.toString());
+            assertEquals("a,b" + RECORD_SEPARATOR, sw.toString());
+            assertEquals(1, printer.getRecordCount());
         }
     }
 
     @Test
-    public void testMongoDbCsvCommaInValue() throws IOException {
+    void testMongoDbCsvCommaInValue() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.MONGODB_CSV)) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.MONGODB_CSV)) {
             printer.printRecord("a,b", "c");
-            assertEquals("\"a,b\",c" + recordSeparator, sw.toString());
+            assertEquals("\"a,b\",c" + RECORD_SEPARATOR, sw.toString());
+            assertEquals(1, printer.getRecordCount());
         }
     }
 
     @Test
-    public void testMongoDbCsvDoubleQuoteInValue() throws IOException {
+    void testMongoDbCsvDoubleQuoteInValue() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.MONGODB_CSV)) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.MONGODB_CSV)) {
             printer.printRecord("a \"c\" b", "d");
-            assertEquals("\"a \"\"c\"\" b\",d" + recordSeparator, sw.toString());
+            assertEquals("\"a \"\"c\"\" b\",d" + RECORD_SEPARATOR, sw.toString());
+            assertEquals(1, printer.getRecordCount());
         }
     }
 
     @Test
-    public void testMongoDbCsvTabInValue() throws IOException {
+    void testMongoDbCsvTabInValue() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.MONGODB_CSV)) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.MONGODB_CSV)) {
             printer.printRecord("a\tb", "c");
-            assertEquals("a\tb,c" + recordSeparator, sw.toString());
+            assertEquals("a\tb,c" + RECORD_SEPARATOR, sw.toString());
+            assertEquals(1, printer.getRecordCount());
         }
     }
 
     @Test
-    public void testMongoDbTsvBasic() throws IOException {
+    void testMongoDbTsvBasic() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.MONGODB_TSV)) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.MONGODB_TSV)) {
             printer.printRecord("a", "b");
-            assertEquals("a\tb" + recordSeparator, sw.toString());
+            assertEquals("a\tb" + RECORD_SEPARATOR, sw.toString());
+            assertEquals(1, printer.getRecordCount());
         }
     }
 
     @Test
-    public void testMongoDbTsvCommaInValue() throws IOException {
+    void testMongoDbTsvCommaInValue() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.MONGODB_TSV)) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.MONGODB_TSV)) {
             printer.printRecord("a,b", "c");
-            assertEquals("a,b\tc" + recordSeparator, sw.toString());
+            assertEquals("a,b\tc" + RECORD_SEPARATOR, sw.toString());
+            assertEquals(1, printer.getRecordCount());
         }
     }
 
     @Test
-    public void testMongoDbTsvTabInValue() throws IOException {
+    void testMongoDbTsvTabInValue() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.MONGODB_TSV)) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.MONGODB_TSV)) {
             printer.printRecord("a\tb", "c");
-            assertEquals("\"a\tb\"\tc" + recordSeparator, sw.toString());
+            assertEquals("\"a\tb\"\tc" + RECORD_SEPARATOR, sw.toString());
         }
     }
 
     @Test
-    public void testMultiLineComment() throws IOException {
+    void testMultiLineComment() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withCommentMarker('#'))) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withCommentMarker('#'))) {
             printer.printComment("This is a comment\non multiple lines");
-
-            assertEquals("# This is a comment" + recordSeparator + "# on multiple lines" + recordSeparator,
-                    sw.toString());
+            assertEquals("# This is a comment" + RECORD_SEPARATOR + "# on multiple lines" + RECORD_SEPARATOR, sw.toString());
+            assertEquals(0, printer.getRecordCount());
         }
     }
 
     @Test
-    public void testMySqlNullOutput() throws IOException {
+    void testMySqlNullOutput() throws IOException {
         Object[] s = new String[] { "NULL", null };
-        CSVFormat format = CSVFormat.MYSQL.withQuote(DQUOTE_CHAR).withNullString("NULL")
-            .withQuoteMode(QuoteMode.NON_NUMERIC);
+        CSVFormat format = CSVFormat.MYSQL.withQuote(DQUOTE_CHAR).withNullString("NULL").withQuoteMode(QuoteMode.NON_NUMERIC);
         StringWriter writer = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(writer, format)) {
+        try (CSVPrinter printer = new CSVPrinter(writer, format)) {
             printer.printRecord(s);
         }
         String expected = "\"NULL\"\tNULL\n";
         assertEquals(expected, writer.toString());
         String[] record0 = toFirstRecordValues(expected, format);
-        assertArrayEquals(new Object[2], record0);
+        assertArrayEquals(s, record0);
 
         s = new String[] { "\\N", null };
         format = CSVFormat.MYSQL.withNullString("\\N");
         writer = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(writer, format)) {
+        try (CSVPrinter printer = new CSVPrinter(writer, format)) {
             printer.printRecord(s);
         }
         expected = "\\\\N\t\\N\n";
@@ -831,7 +1134,7 @@ public void testMySqlNullOutput() throws IOException {
         s = new String[] { "\\N", "A" };
         format = CSVFormat.MYSQL.withNullString("\\N");
         writer = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(writer, format)) {
+        try (CSVPrinter printer = new CSVPrinter(writer, format)) {
             printer.printRecord(s);
         }
         expected = "\\\\N\tA\n";
@@ -842,7 +1145,7 @@ public void testMySqlNullOutput() throws IOException {
         s = new String[] { "\n", "A" };
         format = CSVFormat.MYSQL.withNullString("\\N");
         writer = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(writer, format)) {
+        try (CSVPrinter printer = new CSVPrinter(writer, format)) {
             printer.printRecord(s);
         }
         expected = "\\n\tA\n";
@@ -853,7 +1156,7 @@ public void testMySqlNullOutput() throws IOException {
         s = new String[] { "", null };
         format = CSVFormat.MYSQL.withNullString("NULL");
         writer = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(writer, format)) {
+        try (CSVPrinter printer = new CSVPrinter(writer, format)) {
             printer.printRecord(s);
         }
         expected = "\tNULL\n";
@@ -864,7 +1167,7 @@ public void testMySqlNullOutput() throws IOException {
         s = new String[] { "", null };
         format = CSVFormat.MYSQL;
         writer = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(writer, format)) {
+        try (CSVPrinter printer = new CSVPrinter(writer, format)) {
             printer.printRecord(s);
         }
         expected = "\t\\N\n";
@@ -875,7 +1178,7 @@ public void testMySqlNullOutput() throws IOException {
         s = new String[] { "\\N", "", "\u000e,\\\r" };
         format = CSVFormat.MYSQL;
         writer = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(writer, format)) {
+        try (CSVPrinter printer = new CSVPrinter(writer, format)) {
             printer.printRecord(s);
         }
         expected = "\\\\N\t\t\u000e,\\\\\\r\n";
@@ -886,7 +1189,7 @@ public void testMySqlNullOutput() throws IOException {
         s = new String[] { "NULL", "\\\r" };
         format = CSVFormat.MYSQL;
         writer = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(writer, format)) {
+        try (CSVPrinter printer = new CSVPrinter(writer, format)) {
             printer.printRecord(s);
         }
         expected = "NULL\t\\\\\\r\n";
@@ -897,7 +1200,7 @@ public void testMySqlNullOutput() throws IOException {
         s = new String[] { "\\\r" };
         format = CSVFormat.MYSQL;
         writer = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(writer, format)) {
+        try (CSVPrinter printer = new CSVPrinter(writer, format)) {
             printer.printRecord(s);
         }
         expected = "\\\\\\r\n";
@@ -907,53 +1210,53 @@ public void testMySqlNullOutput() throws IOException {
     }
 
     @Test
-    public void testMySqlNullStringDefault() {
+    void testMySqlNullStringDefault() {
         assertEquals("\\N", CSVFormat.MYSQL.getNullString());
     }
 
     @Test
-    public void testNewCsvPrinterAppendableNullFormat() {
+    void testNewCsvPrinterAppendableNullFormat() {
         assertThrows(NullPointerException.class, () -> new CSVPrinter(new StringWriter(), null));
     }
 
     @Test
-    public void testNewCsvPrinterNullAppendableFormat() {
+    void testNewCsvPrinterNullAppendableFormat() {
         assertThrows(NullPointerException.class, () -> new CSVPrinter(null, CSVFormat.DEFAULT));
     }
 
     @Test
-    public void testNotFlushable() throws IOException {
+    void testNotFlushable() throws IOException {
         final Appendable out = new StringBuilder();
-        try (final CSVPrinter printer = new CSVPrinter(out, CSVFormat.DEFAULT)) {
+        try (CSVPrinter printer = new CSVPrinter(out, CSVFormat.DEFAULT)) {
             printer.printRecord("a", "b", "c");
-            assertEquals("a,b,c" + recordSeparator, out.toString());
+            assertEquals("a,b,c" + RECORD_SEPARATOR, out.toString());
             printer.flush();
         }
     }
 
     @Test
-    public void testParseCustomNullValues() throws IOException {
+    void testParseCustomNullValues() throws IOException {
         final StringWriter sw = new StringWriter();
         final CSVFormat format = CSVFormat.DEFAULT.withNullString("NULL");
-        try (final CSVPrinter printer = new CSVPrinter(sw, format)) {
+        try (CSVPrinter printer = new CSVPrinter(sw, format)) {
             printer.printRecord("a", null, "b");
         }
         final String csvString = sw.toString();
-        assertEquals("a,NULL,b" + recordSeparator, csvString);
-        try (final CSVParser iterable = format.parse(new StringReader(csvString))) {
+        assertEquals("a,NULL,b" + RECORD_SEPARATOR, csvString);
+        try (CSVParser iterable = format.parse(new StringReader(csvString))) {
             final Iterator iterator = iterable.iterator();
             final CSVRecord record = iterator.next();
             assertEquals("a", record.get(0));
-            assertEquals(null, record.get(1));
+            assertNull(record.get(1));
             assertEquals("b", record.get(2));
             assertFalse(iterator.hasNext());
         }
     }
 
     @Test
-    public void testPlainEscaped() throws IOException {
+    void testPlainEscaped() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuote(null).withEscape('!'))) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuote(null).withEscape('!'))) {
             printer.print("abc");
             printer.print("xyz");
             assertEquals("abc,xyz", sw.toString());
@@ -961,9 +1264,9 @@ public void testPlainEscaped() throws IOException {
     }
 
     @Test
-    public void testPlainPlain() throws IOException {
+    void testPlainPlain() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuote(null))) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuote(null))) {
             printer.print("abc");
             printer.print("xyz");
             assertEquals("abc,xyz", sw.toString());
@@ -971,9 +1274,9 @@ public void testPlainPlain() throws IOException {
     }
 
     @Test
-    public void testPlainQuoted() throws IOException {
+    void testPlainQuoted() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuote('\''))) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuote('\''))) {
             printer.print("abc");
             assertEquals("abc", sw.toString());
         }
@@ -981,11 +1284,11 @@ public void testPlainQuoted() throws IOException {
 
     @Test
     @Disabled
-    public void testPostgreSqlCsvNullOutput() throws IOException {
+    void testPostgreSqlCsvNullOutput() throws IOException {
         Object[] s = new String[] { "NULL", null };
         CSVFormat format = CSVFormat.POSTGRESQL_CSV.withQuote(DQUOTE_CHAR).withNullString("NULL").withQuoteMode(QuoteMode.ALL_NON_NULL);
         StringWriter writer = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(writer, format)) {
+        try (CSVPrinter printer = new CSVPrinter(writer, format)) {
             printer.printRecord(s);
         }
         String expected = "\"NULL\",NULL\n";
@@ -996,7 +1299,7 @@ public void testPostgreSqlCsvNullOutput() throws IOException {
         s = new String[] { "\\N", null };
         format = CSVFormat.POSTGRESQL_CSV.withNullString("\\N");
         writer = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(writer, format)) {
+        try (CSVPrinter printer = new CSVPrinter(writer, format)) {
             printer.printRecord(s);
         }
         expected = "\\\\N\t\\N\n";
@@ -1007,7 +1310,7 @@ public void testPostgreSqlCsvNullOutput() throws IOException {
         s = new String[] { "\\N", "A" };
         format = CSVFormat.POSTGRESQL_CSV.withNullString("\\N");
         writer = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(writer, format)) {
+        try (CSVPrinter printer = new CSVPrinter(writer, format)) {
             printer.printRecord(s);
         }
         expected = "\\\\N\tA\n";
@@ -1018,7 +1321,7 @@ public void testPostgreSqlCsvNullOutput() throws IOException {
         s = new String[] { "\n", "A" };
         format = CSVFormat.POSTGRESQL_CSV.withNullString("\\N");
         writer = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(writer, format)) {
+        try (CSVPrinter printer = new CSVPrinter(writer, format)) {
             printer.printRecord(s);
         }
         expected = "\\n\tA\n";
@@ -1029,7 +1332,7 @@ public void testPostgreSqlCsvNullOutput() throws IOException {
         s = new String[] { "", null };
         format = CSVFormat.POSTGRESQL_CSV.withNullString("NULL");
         writer = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(writer, format)) {
+        try (CSVPrinter printer = new CSVPrinter(writer, format)) {
             printer.printRecord(s);
         }
         expected = "\tNULL\n";
@@ -1040,7 +1343,7 @@ public void testPostgreSqlCsvNullOutput() throws IOException {
         s = new String[] { "", null };
         format = CSVFormat.POSTGRESQL_CSV;
         writer = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(writer, format)) {
+        try (CSVPrinter printer = new CSVPrinter(writer, format)) {
             printer.printRecord(s);
         }
         expected = "\t\\N\n";
@@ -1051,7 +1354,7 @@ public void testPostgreSqlCsvNullOutput() throws IOException {
         s = new String[] { "\\N", "", "\u000e,\\\r" };
         format = CSVFormat.POSTGRESQL_CSV;
         writer = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(writer, format)) {
+        try (CSVPrinter printer = new CSVPrinter(writer, format)) {
             printer.printRecord(s);
         }
         expected = "\\\\N\t\t\u000e,\\\\\\r\n";
@@ -1062,7 +1365,7 @@ public void testPostgreSqlCsvNullOutput() throws IOException {
         s = new String[] { "NULL", "\\\r" };
         format = CSVFormat.POSTGRESQL_CSV;
         writer = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(writer, format)) {
+        try (CSVPrinter printer = new CSVPrinter(writer, format)) {
             printer.printRecord(s);
         }
         expected = "NULL\t\\\\\\r\n";
@@ -1073,7 +1376,7 @@ public void testPostgreSqlCsvNullOutput() throws IOException {
         s = new String[] { "\\\r" };
         format = CSVFormat.POSTGRESQL_CSV;
         writer = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(writer, format)) {
+        try (CSVPrinter printer = new CSVPrinter(writer, format)) {
             printer.printRecord(s);
         }
         expected = "\\\\\\r\n";
@@ -1084,11 +1387,11 @@ public void testPostgreSqlCsvNullOutput() throws IOException {
 
     @Test
     @Disabled
-    public void testPostgreSqlCsvTextOutput() throws IOException {
+    void testPostgreSqlCsvTextOutput() throws IOException {
         Object[] s = new String[] { "NULL", null };
         CSVFormat format = CSVFormat.POSTGRESQL_TEXT.withQuote(DQUOTE_CHAR).withNullString("NULL").withQuoteMode(QuoteMode.ALL_NON_NULL);
         StringWriter writer = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(writer, format)) {
+        try (CSVPrinter printer = new CSVPrinter(writer, format)) {
             printer.printRecord(s);
         }
         String expected = "\"NULL\"\tNULL\n";
@@ -1099,7 +1402,7 @@ public void testPostgreSqlCsvTextOutput() throws IOException {
         s = new String[] { "\\N", null };
         format = CSVFormat.POSTGRESQL_TEXT.withNullString("\\N");
         writer = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(writer, format)) {
+        try (CSVPrinter printer = new CSVPrinter(writer, format)) {
             printer.printRecord(s);
         }
         expected = "\\\\N\t\\N\n";
@@ -1110,7 +1413,7 @@ public void testPostgreSqlCsvTextOutput() throws IOException {
         s = new String[] { "\\N", "A" };
         format = CSVFormat.POSTGRESQL_TEXT.withNullString("\\N");
         writer = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(writer, format)) {
+        try (CSVPrinter printer = new CSVPrinter(writer, format)) {
             printer.printRecord(s);
         }
         expected = "\\\\N\tA\n";
@@ -1121,7 +1424,7 @@ public void testPostgreSqlCsvTextOutput() throws IOException {
         s = new String[] { "\n", "A" };
         format = CSVFormat.POSTGRESQL_TEXT.withNullString("\\N");
         writer = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(writer, format)) {
+        try (CSVPrinter printer = new CSVPrinter(writer, format)) {
             printer.printRecord(s);
         }
         expected = "\\n\tA\n";
@@ -1132,7 +1435,7 @@ public void testPostgreSqlCsvTextOutput() throws IOException {
         s = new String[] { "", null };
         format = CSVFormat.POSTGRESQL_TEXT.withNullString("NULL");
         writer = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(writer, format)) {
+        try (CSVPrinter printer = new CSVPrinter(writer, format)) {
             printer.printRecord(s);
         }
         expected = "\tNULL\n";
@@ -1143,7 +1446,7 @@ public void testPostgreSqlCsvTextOutput() throws IOException {
         s = new String[] { "", null };
         format = CSVFormat.POSTGRESQL_TEXT;
         writer = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(writer, format)) {
+        try (CSVPrinter printer = new CSVPrinter(writer, format)) {
             printer.printRecord(s);
         }
         expected = "\t\\N\n";
@@ -1154,7 +1457,7 @@ public void testPostgreSqlCsvTextOutput() throws IOException {
         s = new String[] { "\\N", "", "\u000e,\\\r" };
         format = CSVFormat.POSTGRESQL_TEXT;
         writer = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(writer, format)) {
+        try (CSVPrinter printer = new CSVPrinter(writer, format)) {
             printer.printRecord(s);
         }
         expected = "\\\\N\t\t\u000e,\\\\\\r\n";
@@ -1165,7 +1468,7 @@ public void testPostgreSqlCsvTextOutput() throws IOException {
         s = new String[] { "NULL", "\\\r" };
         format = CSVFormat.POSTGRESQL_TEXT;
         writer = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(writer, format)) {
+        try (CSVPrinter printer = new CSVPrinter(writer, format)) {
             printer.printRecord(s);
         }
         expected = "NULL\t\\\\\\r\n";
@@ -1176,7 +1479,7 @@ public void testPostgreSqlCsvTextOutput() throws IOException {
         s = new String[] { "\\\r" };
         format = CSVFormat.POSTGRESQL_TEXT;
         writer = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(writer, format)) {
+        try (CSVPrinter printer = new CSVPrinter(writer, format)) {
             printer.printRecord(s);
         }
         expected = "\\\\\\r\n";
@@ -1186,129 +1489,217 @@ public void testPostgreSqlCsvTextOutput() throws IOException {
     }
 
     @Test
-    public void testPostgreSqlNullStringDefaultCsv() {
+    void testPostgreSqlNullStringDefaultCsv() {
         assertEquals("", CSVFormat.POSTGRESQL_CSV.getNullString());
     }
 
     @Test
-    public void testPostgreSqlNullStringDefaultText() {
+    void testPostgreSqlNullStringDefaultText() {
         assertEquals("\\N", CSVFormat.POSTGRESQL_TEXT.getNullString());
     }
 
     @Test
-    public void testPrint() throws IOException {
+    void testPrint() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = CSVFormat.DEFAULT.print(sw)) {
+        try (CSVPrinter printer = CSVFormat.DEFAULT.print(sw)) {
+            assertInitialState(printer);
             printer.printRecord("a", "b\\c");
-            assertEquals("a,b\\c" + recordSeparator, sw.toString());
+            assertEquals("a,b\\c" + RECORD_SEPARATOR, sw.toString());
         }
     }
 
     @Test
-    public void testPrintCustomNullValues() throws IOException {
+    void testPrintCSVParser() throws IOException {
+        // @formatter:off
+        final String code = "a1,b1\n" + // 1)
+                "a2,b2\n" + // 2)
+                "a3,b3\n" + // 3)
+                "a4,b4\n";  // 4)
+        // @formatter:on
+        final String[][] res = { { "a1", "b1" }, { "a2", "b2" }, { "a3", "b3" }, { "a4", "b4" } };
+        final CSVFormat format = CSVFormat.DEFAULT;
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withNullString("NULL"))) {
+        try (CSVPrinter printer = format.print(sw);
+                CSVParser parser = CSVParser.parse(code, format)) {
+            assertInitialState(printer);
+            printer.printRecords(parser);
+        }
+        try (CSVParser parser = CSVParser.parse(sw.toString(), format)) {
+            final List records = parser.getRecords();
+            assertFalse(records.isEmpty());
+            Utils.compare("Fail", res, records, -1);
+        }
+    }
+
+    @Test
+    void testPrintCSVRecord() throws IOException {
+        // @formatter:off
+        final String code = "a1,b1\n" + // 1)
+                "a2,b2\n" +  // 2)
+                "a3,b3\n" +  // 3)
+                "a4,b4\n";   // 4)
+        // @formatter:on
+        final String[][] res = { { "a1", "b1" }, { "a2", "b2" }, { "a3", "b3" }, { "a4", "b4" } };
+        final CSVFormat format = CSVFormat.DEFAULT;
+        final StringWriter sw = new StringWriter();
+        int row = 0;
+        try (CSVPrinter printer = format.print(sw);
+                CSVParser parser = CSVParser.parse(code, format)) {
+            assertInitialState(printer);
+            for (final CSVRecord record : parser) {
+                printer.printRecord(record);
+                assertEquals(++row, printer.getRecordCount());
+            }
+            assertEquals(row, printer.getRecordCount());
+        }
+        try (CSVParser parser = CSVParser.parse(sw.toString(), format)) {
+            final List records = parser.getRecords();
+            assertFalse(records.isEmpty());
+            Utils.compare("Fail", res, records, -1);
+        }
+    }
+
+    @ParameterizedTest
+    @ValueSource(longs = { -1, 0, 3, 4, Long.MAX_VALUE })
+    void testPrintCSVRecords(final long maxRows) throws IOException {
+        // @formatter:off
+        final String code = "a1,b1\n" + // 1)
+                "a2,b2\n" + // 2)
+                "a3,b3\n" + // 3)
+                "a4,b4\n";  // 4)
+        // @formatter:on
+        final String[][] expected = { { "a1", "b1" }, { "a2", "b2" }, { "a3", "b3" }, { "a4", "b4" } };
+        final CSVFormat format = CSVFormat.DEFAULT.builder().setMaxRows(maxRows).get();
+        final StringWriter sw = new StringWriter();
+        try (CSVPrinter printer = format.print(sw);
+                CSVParser parser = CSVParser.parse(code, format)) {
+            assertInitialState(printer);
+            printer.printRecords(parser.getRecords());
+        }
+        try (CSVParser parser = CSVParser.parse(sw.toString(), format)) {
+            final List records = parser.getRecords();
+            assertFalse(records.isEmpty());
+            Utils.compare("Fail", expected, records, maxRows);
+        }
+    }
+
+    @Test
+    void testPrintCustomNullValues() throws IOException {
+        final StringWriter sw = new StringWriter();
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withNullString("NULL"))) {
+            assertInitialState(printer);
             printer.printRecord("a", null, "b");
-            assertEquals("a,NULL,b" + recordSeparator, sw.toString());
+            assertEquals("a,NULL,b" + RECORD_SEPARATOR, sw.toString());
         }
     }
 
     @Test
-    public void testPrinter1() throws IOException {
+    void testPrinter1() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT)) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT)) {
+            assertInitialState(printer);
             printer.printRecord("a", "b");
-            assertEquals("a,b" + recordSeparator, sw.toString());
+            assertEquals(1, printer.getRecordCount());
+            assertEquals("a,b" + RECORD_SEPARATOR, sw.toString());
         }
     }
 
     @Test
-    public void testPrinter2() throws IOException {
+    void testPrinter2() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT)) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT)) {
+            assertInitialState(printer);
             printer.printRecord("a,b", "b");
-            assertEquals("\"a,b\",b" + recordSeparator, sw.toString());
+            assertEquals("\"a,b\",b" + RECORD_SEPARATOR, sw.toString());
         }
     }
 
     @Test
-    public void testPrinter3() throws IOException {
+    void testPrinter3() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT)) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT)) {
+            assertInitialState(printer);
             printer.printRecord("a, b", "b ");
-            assertEquals("\"a, b\",\"b \"" + recordSeparator, sw.toString());
+            assertEquals("\"a, b\",\"b \"" + RECORD_SEPARATOR, sw.toString());
         }
     }
 
     @Test
-    public void testPrinter4() throws IOException {
+    void testPrinter4() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT)) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT)) {
+            assertInitialState(printer);
             printer.printRecord("a", "b\"c");
-            assertEquals("a,\"b\"\"c\"" + recordSeparator, sw.toString());
+            assertEquals("a,\"b\"\"c\"" + RECORD_SEPARATOR, sw.toString());
         }
     }
 
     @Test
-    public void testPrinter5() throws IOException {
+    void testPrinter5() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT)) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT)) {
+            assertInitialState(printer);
             printer.printRecord("a", "b\nc");
-            assertEquals("a,\"b\nc\"" + recordSeparator, sw.toString());
+            assertEquals("a,\"b\nc\"" + RECORD_SEPARATOR, sw.toString());
         }
     }
 
     @Test
-    public void testPrinter6() throws IOException {
+    void testPrinter6() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT)) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT)) {
+            assertInitialState(printer);
             printer.printRecord("a", "b\r\nc");
-            assertEquals("a,\"b\r\nc\"" + recordSeparator, sw.toString());
+            assertEquals("a,\"b\r\nc\"" + RECORD_SEPARATOR, sw.toString());
         }
     }
 
     @Test
-    public void testPrinter7() throws IOException {
+    void testPrinter7() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT)) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT)) {
+            assertInitialState(printer);
             printer.printRecord("a", "b\\c");
-            assertEquals("a,b\\c" + recordSeparator, sw.toString());
+            assertEquals("a,b\\c" + RECORD_SEPARATOR, sw.toString());
         }
     }
 
     @Test
-    public void testPrintNullValues() throws IOException {
+    void testPrintNullValues() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT)) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT)) {
+            assertInitialState(printer);
             printer.printRecord("a", null, "b");
-            assertEquals("a,,b" + recordSeparator, sw.toString());
+            assertEquals("a,,b" + RECORD_SEPARATOR, sw.toString());
         }
     }
 
     @Test
-    public void testPrintOnePositiveInteger() throws IOException {
+    void testPrintOnePositiveInteger() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuoteMode(QuoteMode.MINIMAL))) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuoteMode(QuoteMode.MINIMAL))) {
+            assertInitialState(printer);
             printer.print(Integer.MAX_VALUE);
             assertEquals(String.valueOf(Integer.MAX_VALUE), sw.toString());
         }
     }
 
     /**
-     * Test to target the use of {@link IOUtils#copy(java.io.Reader, Appendable)} which directly
-     * buffers the value from the Reader to the Appendable.
+     * Test to target the use of {@link IOUtils#copy(java.io.Reader, Appendable)} which directly buffers the value from the Reader to the Appendable.
      *
-     * 
Requires the format to have no quote or escape character, value to be a
-     * {@link java.io.Reader Reader} and the output MUST NOT be a
-     * {@link java.io.Writer Writer} but some other Appendable.
+     * 

+     * Requires the format to have no quote or escape character, value to be a {@link Reader Reader} and the output MUST NOT be a {@link Writer Writer}
+     * but some other Appendable.
+     * 
      *
      * @throws IOException Not expected to happen
      */
     @Test
-    public void testPrintReaderWithoutQuoteToAppendable() throws IOException {
+    void testPrintReaderWithoutQuoteToAppendable() throws IOException {
         final StringBuilder sb = new StringBuilder();
         final String content = "testValue";
-        try (final CSVPrinter printer = new CSVPrinter(sb, CSVFormat.DEFAULT.withQuote(null))) {
+        try (CSVPrinter printer = new CSVPrinter(sb, CSVFormat.DEFAULT.withQuote(null))) {
+            assertInitialState(printer);
             final StringReader value = new StringReader(content);
             printer.print(value);
         }
@@ -1316,20 +1707,19 @@ public void testPrintReaderWithoutQuoteToAppendable() throws IOException {
     }
 
     /**
-     * Test to target the use of {@link IOUtils#copyLarge(java.io.Reader, Writer)} which directly
-     * buffers the value from the Reader to the Writer.
+     * Test to target the use of {@link IOUtils#copyLarge(java.io.Reader, Writer)} which directly buffers the value from the Reader to the Writer.
      *
-     * 
Requires the format to have no quote or escape character, value to be a
-     * {@link java.io.Reader Reader} and the output MUST be a
-     * {@link java.io.Writer Writer}.
+     * 

+     * Requires the format to have no quote or escape character, value to be a {@link Reader Reader} and the output MUST be a {@link Writer Writer}.
+     * 
      *
      * @throws IOException Not expected to happen
      */
     @Test
-    public void testPrintReaderWithoutQuoteToWriter() throws IOException {
+    void testPrintReaderWithoutQuoteToWriter() throws IOException {
         final StringWriter sw = new StringWriter();
         final String content = "testValue";
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuote(null))) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuote(null))) {
             final StringReader value = new StringReader(content);
             printer.print(value);
         }
@@ -1337,14 +1727,42 @@ public void testPrintReaderWithoutQuoteToWriter() throws IOException {
     }
 
     @Test
-    public void testPrintRecordsWithCSVRecord() throws IOException {
-        final String[] values = new String[] {"A", "B", "C"};
+    void testPrintRecordStream() throws IOException {
+        // @formatter:off
+        final String code = "a1,b1\n" + // 1)
+                "a2,b2\n" + // 2)
+                "a3,b3\n" + // 3)
+                "a4,b4\n";  // 4)
+        // @formatter:on
+        final String[][] res = { { "a1", "b1" }, { "a2", "b2" }, { "a3", "b3" }, { "a4", "b4" } };
+        final CSVFormat format = CSVFormat.DEFAULT;
+        final StringWriter sw = new StringWriter();
+        try (CSVPrinter printer = format.print(sw);
+                CSVParser parser = CSVParser.parse(code, format)) {
+            long count = 0;
+            for (final CSVRecord record : parser) {
+                printer.printRecord(record.stream());
+                assertEquals(++count, printer.getRecordCount());
+            }
+        }
+        try (CSVParser parser = CSVParser.parse(sw.toString(), format)) {
+            final List records = parser.getRecords();
+            assertFalse(records.isEmpty());
+            Utils.compare("Fail", res, records, -1);
+        }
+    }
+
+    @Test
+    void testPrintRecordsWithCSVRecord() throws IOException {
+        final String[] values = { "A", "B", "C" };
         final String rowData = StringUtils.join(values, ',');
         final CharArrayWriter charArrayWriter = new CharArrayWriter(0);
-        try (final CSVParser parser = CSVFormat.DEFAULT.parse(new StringReader(rowData));
-            final CSVPrinter csvPrinter = CSVFormat.INFORMIX_UNLOAD.print(charArrayWriter)) {
+        try (CSVParser parser = CSVFormat.DEFAULT.parse(new StringReader(rowData));
+                CSVPrinter printer = CSVFormat.INFORMIX_UNLOAD.print(charArrayWriter)) {
+            long count = 0;
             for (final CSVRecord record : parser) {
-                csvPrinter.printRecord(record);
+                printer.printRecord(record);
+                assertEquals(++count, printer.getRecordCount());
             }
         }
         assertEquals(6, charArrayWriter.size());
@@ -1352,16 +1770,17 @@ public void testPrintRecordsWithCSVRecord() throws IOException {
     }
 
     @Test
-    public void testPrintRecordsWithEmptyVector() throws IOException {
+    void testPrintRecordsWithEmptyVector() throws IOException {
         final PrintStream out = System.out;
         try {
-            System.setOut(new PrintStream(NullOutputStream.NULL_OUTPUT_STREAM));
-            try (CSVPrinter csvPrinter = CSVFormat.POSTGRESQL_TEXT.printer()) {
+            System.setOut(new PrintStream(NullOutputStream.INSTANCE));
+            try (CSVPrinter printer = CSVFormat.POSTGRESQL_TEXT.printer()) {
                 final Vector vector = new Vector<>();
                 final int expectedCapacity = 23;
                 vector.setSize(expectedCapacity);
-                csvPrinter.printRecords(vector);
+                printer.printRecords(vector);
                 assertEquals(expectedCapacity, vector.capacity());
+                assertEquals(expectedCapacity, printer.getRecordCount());
             }
         } finally {
             System.setOut(out);
@@ -1369,145 +1788,197 @@ public void testPrintRecordsWithEmptyVector() throws IOException {
     }
 
     @Test
-    public void testPrintRecordsWithObjectArray() throws IOException {
+    void testPrintRecordsWithObjectArray() throws IOException {
         final CharArrayWriter charArrayWriter = new CharArrayWriter(0);
-        try (CSVPrinter csvPrinter = CSVFormat.INFORMIX_UNLOAD.print(charArrayWriter)) {
+        final Object[] objectArray = new Object[6];
+        try (CSVPrinter printer = CSVFormat.INFORMIX_UNLOAD.print(charArrayWriter)) {
             final HashSet hashSet = new HashSet<>();
-            final Object[] objectArray = new Object[6];
             objectArray[3] = hashSet;
-            csvPrinter.printRecords(objectArray);
+            printer.printRecords(objectArray);
+            assertEquals(objectArray.length, printer.getRecordCount());
         }
         assertEquals(6, charArrayWriter.size());
         assertEquals("\n\n\n\n\n\n", charArrayWriter.toString());
     }
 
     @Test
-    public void testPrintRecordsWithResultSetOneRow() throws IOException, SQLException {
-        try (CSVPrinter csvPrinter = CSVFormat.MYSQL.printer()) {
+    void testPrintRecordsWithResultSetOneRow() throws IOException, SQLException {
+        try (CSVPrinter printer = CSVFormat.MYSQL.printer()) {
             try (ResultSet resultSet = new SimpleResultSet()) {
-                csvPrinter.printRecords(resultSet);
+                assertInitialState(printer);
+                printer.printRecords(resultSet);
+                assertInitialState(printer);
                 assertEquals(0, resultSet.getRow());
             }
         }
     }
 
     @Test
-    public void testPrintToFileWithCharsetUtf16Be() throws IOException {
-        final File file = File.createTempFile(getClass().getName(), ".csv");
-        try (final CSVPrinter printer = CSVFormat.DEFAULT.print(file, StandardCharsets.UTF_16BE)) {
+    void testPrintToFileWithCharsetUtf16Be() throws IOException {
+        final File file = createTempFile();
+        try (CSVPrinter printer = CSVFormat.DEFAULT.print(file, StandardCharsets.UTF_16BE)) {
             printer.printRecord("a", "b\\c");
         }
-        assertEquals("a,b\\c" + recordSeparator, FileUtils.readFileToString(file, StandardCharsets.UTF_16BE));
+        assertEquals("a,b\\c" + RECORD_SEPARATOR, FileUtils.readFileToString(file, StandardCharsets.UTF_16BE));
     }
 
     @Test
-    public void testPrintToFileWithDefaultCharset() throws IOException {
-        final File file = File.createTempFile(getClass().getName(), ".csv");
-        try (final CSVPrinter printer = CSVFormat.DEFAULT.print(file, Charset.defaultCharset())) {
+    void testPrintToFileWithDefaultCharset() throws IOException {
+        final File file = createTempFile();
+        try (CSVPrinter printer = CSVFormat.DEFAULT.print(file, Charset.defaultCharset())) {
             printer.printRecord("a", "b\\c");
         }
-        assertEquals("a,b\\c" + recordSeparator, FileUtils.readFileToString(file, Charset.defaultCharset()));
+        assertEquals("a,b\\c" + RECORD_SEPARATOR, FileUtils.readFileToString(file, Charset.defaultCharset()));
     }
 
     @Test
-    public void testPrintToPathWithDefaultCharset() throws IOException {
-        final File file = File.createTempFile(getClass().getName(), ".csv");
-        try (final CSVPrinter printer = CSVFormat.DEFAULT.print(file.toPath(), Charset.defaultCharset())) {
+    void testPrintToPathWithDefaultCharset() throws IOException {
+        final Path file = createTempPath();
+        try (CSVPrinter printer = CSVFormat.DEFAULT.print(file, Charset.defaultCharset())) {
             printer.printRecord("a", "b\\c");
         }
-        assertEquals("a,b\\c" + recordSeparator, FileUtils.readFileToString(file, Charset.defaultCharset()));
+        assertEquals("a,b\\c" + RECORD_SEPARATOR, new String(Files.readAllBytes(file), Charset.defaultCharset()));
     }
 
     @Test
-    public void testQuoteAll() throws IOException {
+    void testQuoteAll() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuoteMode(QuoteMode.ALL))) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuoteMode(QuoteMode.ALL))) {
             printer.printRecord("a", "b\nc", "d");
-            assertEquals("\"a\",\"b\nc\",\"d\"" + recordSeparator, sw.toString());
+            assertEquals("\"a\",\"b\nc\",\"d\"" + RECORD_SEPARATOR, sw.toString());
+        }
+    }
+
+    @Test
+    void testQuoteCharEscapedWithQuoteModeNone() throws IOException {
+        final CSVFormat format = CSVFormat.DEFAULT.builder().setQuote('"').setEscape('?').setQuoteMode(QuoteMode.NONE).get();
+        final StringWriter sw = new StringWriter();
+        final String col1 = "\"abc";
+        final String col2 = "x\"y";
+        try (CSVPrinter printer = new CSVPrinter(sw, format)) {
+            printer.printRecord(col1, col2);
+            printer.printRecord(new StringReader(col1), new StringReader(col2));
+        }
+        assertEquals("?\"abc,x?\"y" + RECORD_SEPARATOR + "?\"abc,x?\"y" + RECORD_SEPARATOR, sw.toString());
+        // The emitted records must read back as the original values.
+        try (CSVParser parser = CSVParser.parse(sw.toString(), format)) {
+            final List records = parser.getRecords();
+            assertEquals(2, records.size());
+            for (final CSVRecord record : records) {
+                assertEquals(col1, record.get(0));
+                assertEquals(col2, record.get(1));
+            }
         }
     }
 
     @Test
-    public void testQuoteCommaFirstChar() throws IOException {
+    void testQuoteCommaFirstChar() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.RFC4180)) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.RFC4180)) {
             printer.printRecord(",");
-            assertEquals("\",\"" + recordSeparator, sw.toString());
+            assertEquals("\",\"" + RECORD_SEPARATOR, sw.toString());
         }
     }
 
     @Test
-    public void testQuoteNonNumeric() throws IOException {
+    void testQuoteCommentMarkerFirstChar() throws IOException {
+        final CSVFormat format = CSVFormat.DEFAULT.builder().setCommentMarker(';').get();
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuoteMode(QuoteMode.NON_NUMERIC))) {
+        final String col1 = ";comment-like";
+        try (CSVPrinter printer = new CSVPrinter(sw, format)) {
+            // A real comment is written with the marker, unquoted.
+            printer.printComment("a real comment");
+            // A value starting with the marker is quoted, so it does not read back as a comment.
+            printer.printRecord(col1, "b");
+            // The marker past the first character does not start a comment, so only the leading-marker value is quoted.
+            printer.printRecord("a;b", ";c");
+        }
+        final String string = sw.toString();
+        assertEquals("; a real comment" + RECORD_SEPARATOR +
+                "\";comment-like\",b" + RECORD_SEPARATOR +
+                "a;b,\";c\"" + RECORD_SEPARATOR, string);
+        // The comment is dropped on read; both data records survive intact.
+        try (CSVParser parser = CSVParser.parse(string, format)) {
+            final List records = parser.getRecords();
+            assertEquals(2, records.size());
+            assertEquals(col1, records.get(0).get(0));
+            assertEquals("b", records.get(0).get(1));
+            assertEquals("a;b", records.get(1).get(0));
+            assertEquals(";c", records.get(1).get(1));
+        }
+    }
+
+    @Test
+    void testQuoteNonNumeric() throws IOException {
+        final StringWriter sw = new StringWriter();
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuoteMode(QuoteMode.NON_NUMERIC))) {
             printer.printRecord("a", "b\nc", Integer.valueOf(1));
-            assertEquals("\"a\",\"b\nc\",1" + recordSeparator, sw.toString());
+            assertEquals("\"a\",\"b\nc\",1" + RECORD_SEPARATOR, sw.toString());
         }
     }
 
     @Test
-    public void testRandomDefault() throws Exception {
+    void testRandomDefault() throws Exception {
         doRandom(CSVFormat.DEFAULT, ITERATIONS_FOR_RANDOM_TEST);
     }
 
     @Test
-    public void testRandomExcel() throws Exception {
+    void testRandomExcel() throws Exception {
         doRandom(CSVFormat.EXCEL, ITERATIONS_FOR_RANDOM_TEST);
     }
 
     @Test
     @Disabled
-    public void testRandomMongoDbCsv() throws Exception {
+    void testRandomMongoDbCsv() throws Exception {
         doRandom(CSVFormat.MONGODB_CSV, ITERATIONS_FOR_RANDOM_TEST);
     }
 
     @Test
-    public void testRandomMySql() throws Exception {
+    void testRandomMySql() throws Exception {
         doRandom(CSVFormat.MYSQL, ITERATIONS_FOR_RANDOM_TEST);
     }
 
     @Test
     @Disabled
-    public void testRandomOracle() throws Exception {
+    void testRandomOracle() throws Exception {
         doRandom(CSVFormat.ORACLE, ITERATIONS_FOR_RANDOM_TEST);
     }
 
     @Test
     @Disabled
-    public void testRandomPostgreSqlCsv() throws Exception {
+    void testRandomPostgreSqlCsv() throws Exception {
         doRandom(CSVFormat.POSTGRESQL_CSV, ITERATIONS_FOR_RANDOM_TEST);
     }
 
     @Test
-    @Disabled
-    public void testRandomPostgreSqlText() throws Exception {
+    void testRandomPostgreSqlText() throws Exception {
         doRandom(CSVFormat.POSTGRESQL_TEXT, ITERATIONS_FOR_RANDOM_TEST);
     }
 
-
     @Test
-    public void testRandomRfc4180() throws Exception {
+    void testRandomRfc4180() throws Exception {
         doRandom(CSVFormat.RFC4180, ITERATIONS_FOR_RANDOM_TEST);
     }
 
     @Test
-    public void testRandomTdf() throws Exception {
+    void testRandomTdf() throws Exception {
         doRandom(CSVFormat.TDF, ITERATIONS_FOR_RANDOM_TEST);
     }
 
     @Test
-    public void testSingleLineComment() throws IOException {
+    void testSingleLineComment() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withCommentMarker('#'))) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withCommentMarker('#'))) {
             printer.printComment("This is a comment");
-            assertEquals("# This is a comment" + recordSeparator, sw.toString());
+            assertEquals("# This is a comment" + RECORD_SEPARATOR, sw.toString());
+            assertEquals(0, printer.getRecordCount());
         }
     }
 
     @Test
-    public void testSingleQuoteQuoted() throws IOException {
+    void testSingleQuoteQuoted() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuote('\''))) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuote('\''))) {
             printer.print("a'b'c");
             printer.print("xyz");
             assertEquals("'a''b''c',xyz", sw.toString());
@@ -1515,11 +1986,10 @@ public void testSingleQuoteQuoted() throws IOException {
     }
 
     @Test
-    public void testSkipHeaderRecordFalse() throws IOException {
+    void testSkipHeaderRecordFalse() throws IOException {
         // functionally identical to testHeader, used to test CSV-153
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw,
-                CSVFormat.DEFAULT.withQuote(null).withHeader("C1", "C2", "C3").withSkipHeaderRecord(false))) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuote(null).withHeader("C1", "C2", "C3").withSkipHeaderRecord(false))) {
             printer.printRecord("a", "b", "c");
             printer.printRecord("x", "y", "z");
             assertEquals("C1,C2,C3\r\na,b,c\r\nx,y,z\r\n", sw.toString());
@@ -1527,11 +1997,10 @@ public void testSkipHeaderRecordFalse() throws IOException {
     }
 
     @Test
-    public void testSkipHeaderRecordTrue() throws IOException {
+    void testSkipHeaderRecordTrue() throws IOException {
         // functionally identical to testHeaderNotSet, used to test CSV-153
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw,
-                CSVFormat.DEFAULT.withQuote(null).withHeader("C1", "C2", "C3").withSkipHeaderRecord(true))) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withQuote(null).withHeader("C1", "C2", "C3").withSkipHeaderRecord(true))) {
             printer.printRecord("a", "b", "c");
             printer.printRecord("x", "y", "z");
             assertEquals("a,b,c\r\nx,y,z\r\n", sw.toString());
@@ -1539,36 +2008,36 @@ public void testSkipHeaderRecordTrue() throws IOException {
     }
 
     @Test
-    public void testTrailingDelimiterOnTwoColumns() throws IOException {
+    void testTrailingDelimiterOnTwoColumns() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withTrailingDelimiter())) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withTrailingDelimiter())) {
             printer.printRecord("A", "B");
             assertEquals("A,B,\r\n", sw.toString());
         }
     }
 
     @Test
-    public void testTrimOffOneColumn() throws IOException {
+    void testTrimOffOneColumn() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withTrim(false))) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withTrim(false))) {
             printer.print(" A ");
             assertEquals("\" A \"", sw.toString());
         }
     }
 
     @Test
-    public void testTrimOnOneColumn() throws IOException {
+    void testTrimOnOneColumn() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withTrim())) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withTrim())) {
             printer.print(" A ");
             assertEquals("A", sw.toString());
         }
     }
 
     @Test
-    public void testTrimOnTwoColumns() throws IOException {
+    void testTrimOnTwoColumns() throws IOException {
         final StringWriter sw = new StringWriter();
-        try (final CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withTrim())) {
+        try (CSVPrinter printer = new CSVPrinter(sw, CSVFormat.DEFAULT.withTrim())) {
             printer.print(" A ");
             printer.print(" B ");
             assertEquals("A,B", sw.toString());
@@ -1576,15 +2045,18 @@ public void testTrimOnTwoColumns() throws IOException {
     }
 
     private String[] toFirstRecordValues(final String expected, final CSVFormat format) throws IOException {
-        return CSVParser.parse(expected, format).getRecords().get(0).values();
+        try (CSVParser parser = CSVParser.parse(expected, format)) {
+            return parser.getRecords().get(0).values();
+        }
     }
 
-    private void tryFormat(final List l, final Character quote, final Character escape, final String expected) throws IOException {
+    private void tryFormat(final List list, final Character quote, final Character escape, final String expected) throws IOException {
         final CSVFormat format = CSVFormat.DEFAULT.withQuote(quote).withEscape(escape).withRecordSeparator(null);
         final Appendable out = new StringBuilder();
-        final CSVPrinter printer = new CSVPrinter(out, format);
-        printer.printRecord(l);
-        printer.close();
+        try (CSVPrinter printer = new CSVPrinter(out, format)) {
+            printer.printRecord(list);
+        }
         assertEquals(expected, out.toString());
     }
+
 }
diff --git a/src/test/java/org/apache/commons/csv/CSVRecordTest.java b/src/test/java/org/apache/commons/csv/CSVRecordTest.java
index 1f93c247a6..94060d62b2 100644
--- a/src/test/java/org/apache/commons/csv/CSVRecordTest.java
+++ b/src/test/java/org/apache/commons/csv/CSVRecordTest.java
@@ -1,23 +1,28 @@
 /*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *   https://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.
+ * 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 org.apache.commons.csv;
 
+import static org.junit.jupiter.api.Assertions.assertAll;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
@@ -30,25 +35,25 @@
 import java.io.ObjectOutputStream;
 import java.io.StringReader;
 import java.util.ArrayList;
-import java.util.Collections;
+import java.util.List;
 import java.util.Map;
 import java.util.TreeMap;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
 
 import org.apache.commons.lang3.StringUtils;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
-public class CSVRecordTest {
+class CSVRecordTest {
 
     private enum EnumFixture {
         UNKNOWN_COLUMN
     }
 
+    /** This enum overrides toString() but it's the names that matter. */
     public enum EnumHeader {
-        FIRST("first"),
-        SECOND("second"),
-        THIRD("third");
+        FIRST("first"), SECOND("second"), THIRD("third");
 
         private final String number;
 
@@ -63,75 +68,122 @@ public String toString() {
     }
 
     private Map headerMap;
-    private CSVRecord record, recordWithHeader;
+    private CSVRecord record;
+    private CSVRecord recordWithHeader;
     private String[] values;
 
     @BeforeEach
     public void setUp() throws Exception {
         values = new String[] { "A", "B", "C" };
         final String rowData = StringUtils.join(values, ',');
-        try (final CSVParser parser = CSVFormat.DEFAULT.parse(new StringReader(rowData))) {
+        try (CSVParser parser = CSVFormat.DEFAULT.parse(new StringReader(rowData))) {
             record = parser.iterator().next();
         }
-        final String[] headers = { "first", "second", "third" };
-        try (final CSVParser parser = CSVFormat.DEFAULT.withHeader(headers).parse(new StringReader(rowData))) {
+        try (CSVParser parser = CSVFormat.DEFAULT.builder().setHeader(EnumHeader.class).get().parse(new StringReader(rowData))) {
             recordWithHeader = parser.iterator().next();
             headerMap = parser.getHeaderMap();
         }
     }
 
     @Test
-    public void testGetInt() {
+    void testCSVRecordNULLValues() throws IOException {
+        try (CSVParser parser = CSVParser.parse("A,B\r\nONE,TWO", CSVFormat.DEFAULT.withHeader())) {
+            final CSVRecord csvRecord = new CSVRecord(parser, null, null, 0L, 0L, 0L);
+            assertEquals(0, csvRecord.size());
+            assertThrows(IllegalArgumentException.class, () -> csvRecord.get("B"));
+        }
+    }
+
+    @Test
+    void testDuplicateHeaderGet() throws IOException {
+        final String csv = "A,A,B,B\n1,2,5,6\n";
+        final CSVFormat format = CSVFormat.DEFAULT.builder().setHeader().get();
+
+        try (CSVParser parser = CSVParser.parse(csv, format)) {
+            final CSVRecord record = parser.nextRecord();
+
+            assertAll("Test that it gets the last instance of a column when there are duplicate headings",
+                () -> assertEquals("2", record.get("A")),
+                () -> assertEquals("6", record.get("B"))
+            );
+        }
+    }
+
+    @Test
+    void testDuplicateHeaderToMap() throws IOException {
+        final String csv = "A,A,B,B\n1,2,5,6\n";
+        final CSVFormat format = CSVFormat.DEFAULT.builder().setHeader().get();
+
+        try (CSVParser parser = CSVParser.parse(csv, format)) {
+            final CSVRecord record = parser.nextRecord();
+            final Map map = record.toMap();
+
+            assertAll("Test that it gets the last instance of a column when there are duplicate headings",
+                () -> assertEquals("2", map.get("A")),
+                () -> assertEquals("6", map.get("B"))
+            );
+        }
+    }
+
+    @Test
+    void testGetInt() {
         assertEquals(values[0], record.get(0));
         assertEquals(values[1], record.get(1));
         assertEquals(values[2], record.get(2));
     }
 
     @Test
-    public void testGetString() {
-        assertEquals(values[0], recordWithHeader.get("first"));
-        assertEquals(values[1], recordWithHeader.get("second"));
-        assertEquals(values[2], recordWithHeader.get("third"));
+    void testGetNullEnum() {
+        assertThrows(IllegalArgumentException.class, () -> recordWithHeader.get((Enum) null));
+    }
+
+    @Test
+    void testGetString() {
+        assertEquals(values[0], recordWithHeader.get(EnumHeader.FIRST.name()));
+        assertEquals(values[1], recordWithHeader.get(EnumHeader.SECOND.name()));
+        assertEquals(values[2], recordWithHeader.get(EnumHeader.THIRD.name()));
     }
 
     @Test
-    public void testGetStringInconsistentRecord() {
+    void testGetStringInconsistentRecord() {
         headerMap.put("fourth", Integer.valueOf(4));
         assertThrows(IllegalArgumentException.class, () -> recordWithHeader.get("fourth"));
     }
 
     @Test
-    public void testGetStringNoHeader() {
+    void testGetStringNoHeader() {
         assertThrows(IllegalStateException.class, () -> record.get("first"));
     }
 
     @Test
-    public void testGetUnmappedEnum() {
+    void testGetUnmappedEnum() {
         assertThrows(IllegalArgumentException.class, () -> recordWithHeader.get(EnumFixture.UNKNOWN_COLUMN));
     }
 
     @Test
-    public void testGetNullEnum() {
-        assertThrows(IllegalArgumentException.class, () -> recordWithHeader.get((Enum) null));
-    }
-
-    @Test
-    public void testGetUnmappedName() {
+    void testGetUnmappedName() {
         assertThrows(IllegalArgumentException.class, () -> assertNull(recordWithHeader.get("fourth")));
     }
 
     @Test
-    public void testGetUnmappedNegativeInt() {
+    void testGetUnmappedNegativeInt() {
         assertThrows(ArrayIndexOutOfBoundsException.class, () -> recordWithHeader.get(Integer.MIN_VALUE));
     }
 
     @Test
-    public void testGetUnmappedPositiveInt() {
+    void testGetUnmappedPositiveInt() {
         assertThrows(ArrayIndexOutOfBoundsException.class, () -> recordWithHeader.get(Integer.MAX_VALUE));
     }
 
     @Test
-    public void testIsConsistent() {
+    void testGetWithEnum() {
+        assertEquals(recordWithHeader.get("FIRST"), recordWithHeader.get(EnumHeader.FIRST));
+        assertEquals(recordWithHeader.get("SECOND"), recordWithHeader.get(EnumHeader.SECOND));
+        assertThrows(IllegalArgumentException.class, () -> recordWithHeader.get(EnumFixture.UNKNOWN_COLUMN));
+    }
+
+    @Test
+    void testIsConsistent() {
         assertTrue(record.isConsistent());
         assertTrue(recordWithHeader.isConsistent());
         final Map map = recordWithHeader.getParser().getHeaderMap();
@@ -141,10 +193,10 @@ public void testIsConsistent() {
     }
 
     @Test
-    public void testIsInconsistent() throws IOException {
+    void testIsInconsistent() throws IOException {
         final String[] headers = { "first", "second", "third" };
         final String rowData = StringUtils.join(values, ',');
-        try (final CSVParser parser = CSVFormat.DEFAULT.withHeader(headers).parse(new StringReader(rowData))) {
+        try (CSVParser parser = CSVFormat.DEFAULT.withHeader(headers).parse(new StringReader(rowData))) {
             final Map map = parser.getHeaderMapRaw();
             final CSVRecord record1 = parser.iterator().next();
             map.put("fourth", Integer.valueOf(4));
@@ -153,14 +205,14 @@ public void testIsInconsistent() throws IOException {
     }
 
     @Test
-    public void testIsMapped() {
+    void testIsMapped() {
         assertFalse(record.isMapped("first"));
-        assertTrue(recordWithHeader.isMapped("first"));
+        assertTrue(recordWithHeader.isMapped(EnumHeader.FIRST.name()));
         assertFalse(recordWithHeader.isMapped("fourth"));
     }
 
     @Test
-    public void testIsSetInt() {
+    void testIsSetInt() {
         assertFalse(record.isSet(-1));
         assertTrue(record.isSet(0));
         assertTrue(record.isSet(2));
@@ -170,14 +222,14 @@ public void testIsSetInt() {
     }
 
     @Test
-    public void testIsSetString() {
+    void testIsSetString() {
         assertFalse(record.isSet("first"));
-        assertTrue(recordWithHeader.isSet("first"));
-        assertFalse(recordWithHeader.isSet("fourth"));
+        assertTrue(recordWithHeader.isSet(EnumHeader.FIRST.name()));
+        assertFalse(recordWithHeader.isSet("DOES NOT EXIST"));
     }
 
     @Test
-    public void testIterator() {
+    void testIterator() {
         int i = 0;
         for (final String value : record) {
             assertEquals(values[i], value);
@@ -186,34 +238,34 @@ public void testIterator() {
     }
 
     @Test
-    public void testPutInMap() {
+    void testPutInMap() {
         final Map map = new ConcurrentHashMap<>();
         this.recordWithHeader.putIn(map);
-        this.validateMap(map, false);
+        validateMap(map, false);
         // Test that we can compile with assignment to the same map as the param.
-        final TreeMap map2 = recordWithHeader.putIn(new TreeMap());
-        this.validateMap(map2, false);
+        final TreeMap map2 = recordWithHeader.putIn(new TreeMap<>());
+        validateMap(map2, false);
     }
 
     @Test
-    public void testRemoveAndAddColumns() throws IOException {
+    void testRemoveAndAddColumns() throws IOException {
         // do:
-        try (final CSVPrinter printer = new CSVPrinter(new StringBuilder(), CSVFormat.DEFAULT)) {
+        try (CSVPrinter printer = new CSVPrinter(new StringBuilder(), CSVFormat.DEFAULT)) {
             final Map map = recordWithHeader.toMap();
             map.remove("OldColumn");
             map.put("ZColumn", "NewValue");
             // check:
             final ArrayList list = new ArrayList<>(map.values());
-            Collections.sort(list);
+            list.sort(null);
             printer.printRecord(list);
             assertEquals("A,B,C,NewValue" + CSVFormat.DEFAULT.getRecordSeparator(), printer.getOut().toString());
         }
     }
 
     @Test
-    public void testSerialization() throws IOException, ClassNotFoundException {
+    void testSerialization() throws IOException, ClassNotFoundException {
         final CSVRecord shortRec;
-        try (final CSVParser parser = CSVParser.parse("A,B\n#my comment\nOne,Two", CSVFormat.DEFAULT.withHeader().withCommentMarker('#'))) {
+        try (CSVParser parser = CSVParser.parse("A,B\n#my comment\nOne,Two", CSVFormat.DEFAULT.withHeader().withCommentMarker('#'))) {
             shortRec = parser.iterator().next();
         }
         final ByteArrayOutputStream out = new ByteArrayOutputStream();
@@ -223,7 +275,7 @@ public void testSerialization() throws IOException, ClassNotFoundException {
         final ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
         try (ObjectInputStream ois = new ObjectInputStream(in)) {
             final Object object = ois.readObject();
-            assertTrue(object instanceof CSVRecord);
+            assertInstanceOf(CSVRecord.class, object);
             final CSVRecord rec = (CSVRecord) object;
             assertEquals(1L, rec.getRecordNumber());
             assertEquals("One", rec.get(0));
@@ -239,24 +291,65 @@ public void testSerialization() throws IOException, ClassNotFoundException {
             assertFalse(rec.isSet("A"));
             assertEquals(0, rec.toMap().size());
             // This will throw
-            try {
-                rec.get("A");
-                org.junit.jupiter.api.Assertions.fail("Access by name is not expected after deserialisation");
-            } catch (final IllegalStateException expected) {
-                // OK
-            }
+            assertThrows(IllegalStateException.class, () -> rec.get("A"));
         }
     }
 
     @Test
-    public void testToMap() {
+    void testStream() {
+        final AtomicInteger i = new AtomicInteger();
+        record.stream().forEach(value -> {
+            assertEquals(values[i.get()], value);
+            i.incrementAndGet();
+        });
+    }
+
+    @Test
+    void testToListAdd() {
+        final String[] expected = values.clone();
+        final List list = record.toList();
+        list.add("Last");
+        assertEquals("Last", list.get(list.size() - 1));
+        assertEquals(list.size(), values.length + 1);
+        assertArrayEquals(expected, values);
+    }
+
+    @Test
+    void testToListFor() {
+        int i = 0;
+        for (final String value : record.toList()) {
+            assertEquals(values[i], value);
+            i++;
+        }
+    }
+
+    @Test
+    void testToListForEach() {
+        final AtomicInteger i = new AtomicInteger();
+        record.toList().forEach(e -> {
+            assertEquals(values[i.getAndIncrement()], e);
+        });
+    }
+
+    @Test
+    void testToListSet() {
+        final String[] expected = values.clone();
+        final List list = record.toList();
+        list.set(list.size() - 1, "Last");
+        assertEquals("Last", list.get(list.size() - 1));
+        assertEquals(list.size(), values.length);
+        assertArrayEquals(expected, values);
+    }
+
+    @Test
+    void testToMap() {
         final Map map = this.recordWithHeader.toMap();
-        this.validateMap(map, true);
+        validateMap(map, true);
     }
 
     @Test
-    public void testToMapWithNoHeader() throws Exception {
-        try (final CSVParser parser = CSVParser.parse("a,b", CSVFormat.newFormat(','))) {
+    void testToMapWithNoHeader() throws Exception {
+        try (CSVParser parser = CSVParser.parse("a,b", CSVFormat.newFormat(','))) {
             final CSVRecord shortRec = parser.iterator().next();
             final Map map = shortRec.toMap();
             assertNotNull(map, "Map is not null.");
@@ -265,47 +358,32 @@ public void testToMapWithNoHeader() throws Exception {
     }
 
     @Test
-    public void testToMapWithShortRecord() throws Exception {
-        try (final CSVParser parser = CSVParser.parse("a,b", CSVFormat.DEFAULT.withHeader("A", "B", "C"))) {
+    void testToMapWithShortRecord() throws Exception {
+        try (CSVParser parser = CSVParser.parse("a,b", CSVFormat.DEFAULT.withHeader("A", "B", "C"))) {
             final CSVRecord shortRec = parser.iterator().next();
             shortRec.toMap();
         }
     }
 
-    private void validateMap(final Map map, final boolean allowsNulls) {
-        assertTrue(map.containsKey("first"));
-        assertTrue(map.containsKey("second"));
-        assertTrue(map.containsKey("third"));
-        assertFalse(map.containsKey("fourth"));
-        if (allowsNulls) {
-            assertFalse(map.containsKey(null));
-        }
-        assertEquals("A", map.get("first"));
-        assertEquals("B", map.get("second"));
-        assertEquals("C", map.get("third"));
-        assertEquals(null, map.get("fourth"));
-    }
-
     @Test
-    public void testToString() {
+    void testToString() {
         assertNotNull(recordWithHeader.toString());
         assertTrue(recordWithHeader.toString().contains("comment="));
         assertTrue(recordWithHeader.toString().contains("recordNumber="));
         assertTrue(recordWithHeader.toString().contains("values="));
     }
 
-    @Test
-    public void testGetWithEnum() {
-        assertEquals(recordWithHeader.get("first"), recordWithHeader.get(EnumHeader.FIRST));
-        assertEquals(recordWithHeader.get("second"), recordWithHeader.get(EnumHeader.SECOND));
-        assertThrows(IllegalArgumentException.class, () -> recordWithHeader.get(EnumFixture.UNKNOWN_COLUMN));
-    }
-
-    @Test
-    public void testCSVRecordNULLValues() throws IOException {
-        final CSVParser parser = CSVParser.parse("A,B\r\nONE,TWO", CSVFormat.DEFAULT.withHeader());
-        final CSVRecord csvRecord = new CSVRecord(parser, null, null, 0L, 0L);
-        assertEquals(0, csvRecord.size());
-        assertThrows(IllegalArgumentException.class, () -> csvRecord.get("B"));
+    private void validateMap(final Map map, final boolean allowsNulls) {
+        assertTrue(map.containsKey(EnumHeader.FIRST.name()));
+        assertTrue(map.containsKey(EnumHeader.SECOND.name()));
+        assertTrue(map.containsKey(EnumHeader.THIRD.name()));
+        assertFalse(map.containsKey("fourth"));
+        if (allowsNulls) {
+            assertFalse(map.containsKey(null));
+        }
+        assertEquals("A", map.get(EnumHeader.FIRST.name()));
+        assertEquals("B", map.get(EnumHeader.SECOND.name()));
+        assertEquals("C", map.get(EnumHeader.THIRD.name()));
+        assertNull(map.get("fourth"));
     }
 }
diff --git a/src/test/java/org/apache/commons/csv/CsvAssertions.java b/src/test/java/org/apache/commons/csv/CsvAssertions.java
new file mode 100644
index 0000000000..b6c2b5d9cd
--- /dev/null
+++ b/src/test/java/org/apache/commons/csv/CsvAssertions.java
@@ -0,0 +1,29 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *
+ *   https://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 org.apache.commons.csv;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+
+public class CsvAssertions {
+
+    public static void assertValuesEquals(final String[] expected, final CSVRecord actual) {
+        assertArrayEquals(expected, actual.values());
+    }
+}
diff --git a/src/test/java/org/apache/commons/csv/ExtendedBufferedReaderTest.java b/src/test/java/org/apache/commons/csv/ExtendedBufferedReaderTest.java
index a570aec5e2..b8d9b9f198 100644
--- a/src/test/java/org/apache/commons/csv/ExtendedBufferedReaderTest.java
+++ b/src/test/java/org/apache/commons/csv/ExtendedBufferedReaderTest.java
@@ -1,113 +1,231 @@
 /*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *   https://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.
+ * 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 org.apache.commons.csv;
 
-import static org.apache.commons.csv.Constants.END_OF_STREAM;
 import static org.apache.commons.csv.Constants.UNDEFINED;
+import static org.apache.commons.io.IOUtils.EOF;
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNull;
 
 import java.io.StringReader;
+import java.nio.charset.StandardCharsets;
 
 import org.junit.jupiter.api.Test;
 
 /**
- *
+ * Test {@link ExtendedBufferedReader}.
  */
-public class ExtendedBufferedReaderTest {
+class ExtendedBufferedReaderTest {
+
+    static final String LF = "\n";
+    static final String CR = "\r";
+    static final String CRLF = CR + LF;
+    static final String LFCR = LF + CR; // easier to read the string below
+
+    private ExtendedBufferedReader createBufferedReader(final String s) {
+        return new ExtendedBufferedReader(new StringReader(s));
+    }
 
     @Test
-    public void testEmptyInput() throws Exception {
-        try (final ExtendedBufferedReader br = createBufferedReader("")) {
-            assertEquals(END_OF_STREAM, br.read());
-            assertEquals(END_OF_STREAM, br.lookAhead());
-            assertEquals(END_OF_STREAM, br.getLastChar());
+    void testEmptyInput() throws Exception {
+        try (ExtendedBufferedReader br = createBufferedReader("")) {
+            assertEquals(EOF, br.read());
+            assertEquals(EOF, br.peek());
+            assertEquals(EOF, br.getLastChar());
             assertNull(br.readLine());
             assertEquals(0, br.read(new char[10], 0, 0));
         }
     }
 
+    /*
+     * Test to illustrate https://issues.apache.org/jira/browse/CSV-75
+     */
+    @Test
+    void testReadChar() throws Exception {
+        final String test = "a" + LF + "b" + CR + "c" + LF + LF + "d" + CR + CR + "e" + LFCR + "f " + CRLF;
+        // EOL eol EOL EOL eol eol EOL+CR EOL
+        final int eolCount = 9;
+
+        try (ExtendedBufferedReader br = createBufferedReader(test)) {
+            assertEquals(0, br.getLineNumber());
+            int lineCount = 0;
+            while (br.readLine() != null) {
+                // consume all
+                lineCount++;
+            }
+            assertEquals(eolCount, br.getLineNumber());
+            assertEquals(lineCount, br.getLineNumber());
+        }
+        try (ExtendedBufferedReader br = createBufferedReader(test)) {
+            assertEquals(0, br.getLineNumber());
+            int readCount = 0;
+            while (br.read() != EOF) {
+                // consume all
+                readCount++;
+            }
+            assertEquals(eolCount, br.getLineNumber());
+            assertEquals(readCount, test.length());
+        }
+        try (ExtendedBufferedReader br = createBufferedReader(test)) {
+            assertEquals(0, br.getLineNumber());
+            final char[] buff = new char[10];
+            while (br.read(buff, 0, 3) != EOF) {
+                // consume all
+            }
+            assertEquals(eolCount, br.getLineNumber());
+        }
+    }
+
+    @Test
+    void testReadingInDifferentBuffer() throws Exception {
+        final char[] tmp1 = new char[2];
+        final char[] tmp2 = new char[4];
+        try (ExtendedBufferedReader reader = createBufferedReader("1\r\n2\r\n")) {
+            reader.read(tmp1, 0, 2);
+            reader.read(tmp2, 2, 2);
+            assertEquals(2, reader.getLineNumber());
+        }
+    }
+
+    @Test
+    void testReadingSupplementaryCharacterTracksBytes() throws Exception {
+        final String input = "😀";
+        final char[] buffer = new char[input.length()];
+        try (ExtendedBufferedReader reader = new ExtendedBufferedReader(new StringReader(input), StandardCharsets.UTF_8, true)) {
+            assertEquals(input.length(), reader.read(buffer, 0, buffer.length));
+            assertArrayEquals(input.toCharArray(), buffer);
+            assertEquals(input.getBytes(StandardCharsets.UTF_8).length, reader.getBytesRead());
+            assertEquals(input.length(), reader.getPosition());
+            assertEquals(input.charAt(input.length() - 1), reader.getLastChar());
+        }
+    }
+
+    @Test
+    void testReadLine() throws Exception {
+        try (ExtendedBufferedReader br = createBufferedReader("")) {
+            assertNull(br.readLine());
+        }
+        try (ExtendedBufferedReader br = createBufferedReader("\n")) {
+            assertEquals("", br.readLine());
+            assertNull(br.readLine());
+        }
+        try (ExtendedBufferedReader br = createBufferedReader("foo\n\nhello")) {
+            assertEquals(0, br.getLineNumber());
+            assertEquals("foo", br.readLine());
+            assertEquals(1, br.getLineNumber());
+            assertEquals("", br.readLine());
+            assertEquals(2, br.getLineNumber());
+            assertEquals("hello", br.readLine());
+            assertEquals(3, br.getLineNumber());
+            assertNull(br.readLine());
+            assertEquals(3, br.getLineNumber());
+        }
+        try (ExtendedBufferedReader br = createBufferedReader("foo\n\nhello")) {
+            assertEquals('f', br.read());
+            assertEquals('o', br.peek());
+            assertEquals("oo", br.readLine());
+            assertEquals(1, br.getLineNumber());
+            assertEquals('\n', br.peek());
+            assertEquals("", br.readLine());
+            assertEquals(2, br.getLineNumber());
+            assertEquals('h', br.peek());
+            assertEquals("hello", br.readLine());
+            assertNull(br.readLine());
+            assertEquals(3, br.getLineNumber());
+        }
+        try (ExtendedBufferedReader br = createBufferedReader("foo\rbaar\r\nfoo")) {
+            assertEquals("foo", br.readLine());
+            assertEquals('b', br.peek());
+            assertEquals("baar", br.readLine());
+            assertEquals('f', br.peek());
+            assertEquals("foo", br.readLine());
+            assertNull(br.readLine());
+        }
+    }
+
     @Test
-    public void testReadLookahead1() throws Exception {
-        try (final ExtendedBufferedReader br = createBufferedReader("1\n2\r3\n")) {
-            assertEquals(0, br.getCurrentLineNumber());
-            assertEquals('1', br.lookAhead());
+    void testReadLookahead1() throws Exception {
+        try (ExtendedBufferedReader br = createBufferedReader("1\n2\r3\n")) {
+            assertEquals(0, br.getLineNumber());
+            assertEquals('1', br.peek());
             assertEquals(UNDEFINED, br.getLastChar());
-            assertEquals(0, br.getCurrentLineNumber());
+            assertEquals(0, br.getLineNumber());
             assertEquals('1', br.read()); // Start line 1
             assertEquals('1', br.getLastChar());
 
-            assertEquals(1, br.getCurrentLineNumber());
-            assertEquals('\n', br.lookAhead());
-            assertEquals(1, br.getCurrentLineNumber());
+            assertEquals(1, br.getLineNumber());
+            assertEquals('\n', br.peek());
+            assertEquals(1, br.getLineNumber());
             assertEquals('1', br.getLastChar());
             assertEquals('\n', br.read());
-            assertEquals(1, br.getCurrentLineNumber());
+            assertEquals(1, br.getLineNumber());
             assertEquals('\n', br.getLastChar());
-            assertEquals(1, br.getCurrentLineNumber());
+            assertEquals(1, br.getLineNumber());
 
-            assertEquals('2', br.lookAhead());
-            assertEquals(1, br.getCurrentLineNumber());
+            assertEquals('2', br.peek());
+            assertEquals(1, br.getLineNumber());
             assertEquals('\n', br.getLastChar());
-            assertEquals(1, br.getCurrentLineNumber());
+            assertEquals(1, br.getLineNumber());
             assertEquals('2', br.read()); // Start line 2
-            assertEquals(2, br.getCurrentLineNumber());
+            assertEquals(2, br.getLineNumber());
             assertEquals('2', br.getLastChar());
 
-            assertEquals('\r', br.lookAhead());
-            assertEquals(2, br.getCurrentLineNumber());
+            assertEquals('\r', br.peek());
+            assertEquals(2, br.getLineNumber());
             assertEquals('2', br.getLastChar());
             assertEquals('\r', br.read());
             assertEquals('\r', br.getLastChar());
-            assertEquals(2, br.getCurrentLineNumber());
+            assertEquals(2, br.getLineNumber());
 
-            assertEquals('3', br.lookAhead());
+            assertEquals('3', br.peek());
             assertEquals('\r', br.getLastChar());
             assertEquals('3', br.read()); // Start line 3
             assertEquals('3', br.getLastChar());
-            assertEquals(3, br.getCurrentLineNumber());
+            assertEquals(3, br.getLineNumber());
 
-            assertEquals('\n', br.lookAhead());
-            assertEquals(3, br.getCurrentLineNumber());
+            assertEquals('\n', br.peek());
+            assertEquals(3, br.getLineNumber());
             assertEquals('3', br.getLastChar());
             assertEquals('\n', br.read());
-            assertEquals(3, br.getCurrentLineNumber());
+            assertEquals(3, br.getLineNumber());
             assertEquals('\n', br.getLastChar());
-            assertEquals(3, br.getCurrentLineNumber());
+            assertEquals(3, br.getLineNumber());
 
-            assertEquals(END_OF_STREAM, br.lookAhead());
+            assertEquals(EOF, br.peek());
             assertEquals('\n', br.getLastChar());
-            assertEquals(END_OF_STREAM, br.read());
-            assertEquals(END_OF_STREAM, br.getLastChar());
-            assertEquals(END_OF_STREAM, br.read());
-            assertEquals(END_OF_STREAM, br.lookAhead());
-            assertEquals(3, br.getCurrentLineNumber());
+            assertEquals(EOF, br.read());
+            assertEquals(EOF, br.getLastChar());
+            assertEquals(EOF, br.read());
+            assertEquals(EOF, br.peek());
+            assertEquals(3, br.getLineNumber());
 
         }
     }
 
     @Test
-    public void testReadLookahead2() throws Exception {
+    void testReadLookahead2() throws Exception {
         final char[] ref = new char[5];
         final char[] res = new char[5];
 
-        try (final ExtendedBufferedReader br = createBufferedReader("abcdefg")) {
+        try (ExtendedBufferedReader br = createBufferedReader("abcdefg")) {
             ref[0] = 'a';
             ref[1] = 'b';
             ref[2] = 'c';
@@ -115,96 +233,11 @@ public void testReadLookahead2() throws Exception {
             assertArrayEquals(ref, res);
             assertEquals('c', br.getLastChar());
 
-            assertEquals('d', br.lookAhead());
+            assertEquals('d', br.peek());
             ref[4] = 'd';
             assertEquals(1, br.read(res, 4, 1));
             assertArrayEquals(ref, res);
             assertEquals('d', br.getLastChar());
         }
     }
-
-    @Test
-    public void testReadLine() throws Exception {
-        try (final ExtendedBufferedReader br = createBufferedReader("")) {
-            assertNull(br.readLine());
-        }
-        try (final ExtendedBufferedReader br = createBufferedReader("\n")) {
-            assertEquals("", br.readLine());
-            assertNull(br.readLine());
-        }
-        try (final ExtendedBufferedReader br = createBufferedReader("foo\n\nhello")) {
-            assertEquals(0, br.getCurrentLineNumber());
-            assertEquals("foo", br.readLine());
-            assertEquals(1, br.getCurrentLineNumber());
-            assertEquals("", br.readLine());
-            assertEquals(2, br.getCurrentLineNumber());
-            assertEquals("hello", br.readLine());
-            assertEquals(3, br.getCurrentLineNumber());
-            assertNull(br.readLine());
-            assertEquals(3, br.getCurrentLineNumber());
-        }
-        try (final ExtendedBufferedReader br = createBufferedReader("foo\n\nhello")) {
-            assertEquals('f', br.read());
-            assertEquals('o', br.lookAhead());
-            assertEquals("oo", br.readLine());
-            assertEquals(1, br.getCurrentLineNumber());
-            assertEquals('\n', br.lookAhead());
-            assertEquals("", br.readLine());
-            assertEquals(2, br.getCurrentLineNumber());
-            assertEquals('h', br.lookAhead());
-            assertEquals("hello", br.readLine());
-            assertNull(br.readLine());
-            assertEquals(3, br.getCurrentLineNumber());
-        }
-        try (final ExtendedBufferedReader br = createBufferedReader("foo\rbaar\r\nfoo")) {
-            assertEquals("foo", br.readLine());
-            assertEquals('b', br.lookAhead());
-            assertEquals("baar", br.readLine());
-            assertEquals('f', br.lookAhead());
-            assertEquals("foo", br.readLine());
-            assertNull(br.readLine());
-        }
-    }
-
-    /*
-     * Test to illustrate https://issues.apache.org/jira/browse/CSV-75
-     *
-     */
-    @Test
-    public void testReadChar() throws Exception {
-        final String LF = "\n";
-        final String CR = "\r";
-        final String CRLF = CR + LF;
-        final String LFCR = LF + CR;// easier to read the string below
-        final String test = "a" + LF + "b" + CR + "c" + LF + LF + "d" + CR + CR + "e" + LFCR + "f " + CRLF;
-        // EOL eol EOL EOL eol eol EOL+CR EOL
-        final int EOLeolct = 9;
-
-        try (final ExtendedBufferedReader br = createBufferedReader(test)) {
-            assertEquals(0, br.getCurrentLineNumber());
-            while (br.readLine() != null) {
-                // consume all
-            }
-            assertEquals(EOLeolct, br.getCurrentLineNumber());
-        }
-        try (final ExtendedBufferedReader br = createBufferedReader(test)) {
-            assertEquals(0, br.getCurrentLineNumber());
-            while (br.read() != -1) {
-                // consume all
-            }
-            assertEquals(EOLeolct, br.getCurrentLineNumber());
-        }
-        try (final ExtendedBufferedReader br = createBufferedReader(test)) {
-            assertEquals(0, br.getCurrentLineNumber());
-            final char[] buff = new char[10];
-            while (br.read(buff, 0, 3) != -1) {
-                // consume all
-            }
-            assertEquals(EOLeolct, br.getCurrentLineNumber());
-        }
-    }
-
-    private ExtendedBufferedReader createBufferedReader(final String s) {
-        return new ExtendedBufferedReader(new StringReader(s));
-    }
 }
diff --git a/src/test/java/org/apache/commons/csv/JiraCsv196Test.java b/src/test/java/org/apache/commons/csv/JiraCsv196Test.java
new file mode 100644
index 0000000000..aaf8e206b3
--- /dev/null
+++ b/src/test/java/org/apache/commons/csv/JiraCsv196Test.java
@@ -0,0 +1,76 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *
+ *   https://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 org.apache.commons.csv;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.Reader;
+import java.nio.charset.StandardCharsets;
+
+import org.junit.jupiter.api.Test;
+
+class JiraCsv196Test {
+
+    private Reader getTestInput(final String path) {
+        return new InputStreamReader(ClassLoader.getSystemClassLoader().getResourceAsStream(path));
+    }
+
+    @Test
+    void testParseFourBytes() throws IOException {
+        final CSVFormat format = CSVFormat.Builder.create().setDelimiter(',').setQuote('\'').get();
+        // @formatter:off
+        try (@SuppressWarnings("resource") // parser closes the reader.
+            CSVParser parser = new CSVParser.Builder()
+                .setFormat(format)
+                .setReader(getTestInput("org/apache/commons/csv/CSV-196/emoji.csv"))
+                .setCharset(StandardCharsets.UTF_8)
+                .setTrackBytes(true)
+                .get()) {
+            // @formatter:on
+            final long[] charByteKey = { 0, 84, 701, 1318, 1935 };
+            int idx = 0;
+            for (final CSVRecord record : parser) {
+                assertEquals(charByteKey[idx++], record.getBytePosition(), "At index " + idx);
+            }
+        }
+    }
+
+    @Test
+    void testParseThreeBytes() throws IOException {
+        final CSVFormat format = CSVFormat.Builder.create().setDelimiter(',').setQuote('\'').get();
+        // @formatter:off
+        try (@SuppressWarnings("resource") // parser closes the reader.
+            CSVParser parser = new CSVParser.Builder()
+                .setFormat(format)
+                .setReader(getTestInput("org/apache/commons/csv/CSV-196/japanese.csv"))
+                .setCharset(StandardCharsets.UTF_8)
+                .setTrackBytes(true)
+                .get()) {
+            // @formatter:on
+            final long[] charByteKey = { 0, 89, 242, 395 };
+            int idx = 0;
+            for (final CSVRecord record : parser) {
+                assertEquals(charByteKey[idx++], record.getBytePosition(), "At index " + idx);
+            }
+        }
+    }
+}
diff --git a/src/test/java/org/apache/commons/csv/JiraCsv318Test.java b/src/test/java/org/apache/commons/csv/JiraCsv318Test.java
new file mode 100644
index 0000000000..984509e87d
--- /dev/null
+++ b/src/test/java/org/apache/commons/csv/JiraCsv318Test.java
@@ -0,0 +1,125 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *
+ *   https://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 org.apache.commons.csv;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Stream;
+
+import org.apache.commons.io.function.IOConsumer;
+import org.apache.commons.io.function.IOStream;
+import org.apache.commons.lang3.ArrayUtils;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Tests https://issues.apache.org/jira/projects/CSV/issues/CSV-318?filter=allopenissues
+ *
+ * @see CSVPrinter
+ */
+class JiraCsv318Test {
+
+    private void checkOutput(final ByteArrayOutputStream baos) {
+        checkOutput(baos.toString());
+    }
+
+    private void checkOutput(final String string) {
+        assertEquals("col a,col b,col c", string.trim());
+    }
+
+    private Stream newParallelStream() {
+        // returned stream is intermediate
+        return newStream().parallel();
+    }
+
+    private CSVPrinter newPrinter(final ByteArrayOutputStream baos) throws IOException {
+        return new CSVPrinter(new PrintWriter(baos), CSVFormat.DEFAULT);
+    }
+
+    private Stream newSequentialStream() {
+        // returned stream is intermediate
+        return newStream().sequential();
+    }
+
+    private Stream newStream() {
+        return Stream.of("col a", "col b", "col c");
+    }
+
+    @Test
+    void testDefaultStream() throws IOException {
+        final ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        try (CSVPrinter printer = newPrinter(baos)) {
+            printer.printRecord(newStream());
+        }
+        checkOutput(baos);
+    }
+
+    @SuppressWarnings("resource")
+    @Test
+    void testParallelIOStream() throws IOException {
+        final ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        try (CSVPrinter printer = newPrinter(baos)) {
+            IOStream.adapt(newParallelStream()).forEachOrdered(printer::print);
+        }
+        // No EOR marker in this test intentionally, so checkOutput will trim.
+        checkOutput(baos);
+    }
+
+    @SuppressWarnings("resource")
+    @Test
+    void testParallelIOStreamSynchronizedPrinterNotUsed() throws IOException {
+        final ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        try (CSVPrinter printer = newPrinter(baos)) {
+            synchronized (printer) {
+                IOStream.adapt(newParallelStream()).forEachOrdered(IOConsumer.noop());
+            }
+        }
+        final List list = new ArrayList<>();
+        try (CSVPrinter printer = newPrinter(baos)) {
+            synchronized (printer) {
+                IOStream.adapt(newParallelStream()).forEachOrdered(list::add);
+            }
+        }
+        // No EOR marker in this test intentionally, so checkOutput will trim.
+        checkOutput(String.join(",", list.toArray(ArrayUtils.EMPTY_STRING_ARRAY)));
+    }
+
+    @Test
+    void testParallelStream() throws IOException {
+        final ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        try (CSVPrinter printer = newPrinter(baos)) {
+            printer.printRecord(newParallelStream());
+        }
+        checkOutput(baos);
+    }
+
+    @Test
+    void testSequentialStream() throws IOException {
+        final ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        try (CSVPrinter printer = newPrinter(baos)) {
+            printer.printRecord(newSequentialStream());
+        }
+        checkOutput(baos);
+    }
+}
diff --git a/src/test/java/org/apache/commons/csv/LexerTest.java b/src/test/java/org/apache/commons/csv/LexerTest.java
index d2dea02323..a76f6e513b 100644
--- a/src/test/java/org/apache/commons/csv/LexerTest.java
+++ b/src/test/java/org/apache/commons/csv/LexerTest.java
@@ -1,18 +1,20 @@
 /*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *   https://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.
+ * 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 org.apache.commons.csv;
@@ -26,13 +28,11 @@
 import static org.apache.commons.csv.Token.Type.EOF;
 import static org.apache.commons.csv.Token.Type.EORECORD;
 import static org.apache.commons.csv.Token.Type.TOKEN;
-import static org.apache.commons.csv.TokenMatchers.hasContent;
-import static org.apache.commons.csv.TokenMatchers.matches;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+
 import java.io.IOException;
 import java.io.StringReader;
 
@@ -40,94 +40,116 @@
 import org.junit.jupiter.api.Test;
 
 /**
- *
  */
-public class LexerTest {
+class LexerTest {
 
-    private CSVFormat formatWithEscaping;
+    private static void assertContent(final String expectedContent, final Token actualToken) {
+        assertEquals(expectedContent, actualToken.content.toString());
+    }
 
-    @BeforeEach
-    public void setUp() {
-        formatWithEscaping = CSVFormat.DEFAULT.withEscape('\\');
+    private static void assertNextToken(final String expectedContent, final Lexer lexer) throws IOException {
+        assertContent(expectedContent, lexer.nextToken(new Token()));
     }
 
+    private static void assertNextToken(final Token.Type expectedType, final String expectedContent, final Lexer lexer) throws IOException {
+        final Token actualToken = lexer.nextToken(new Token());
+        assertEquals(expectedType, actualToken.type);
+        assertContent(expectedContent, actualToken);
+    }
+
+    private CSVFormat formatWithEscaping;
+
     @SuppressWarnings("resource")
     private Lexer createLexer(final String input, final CSVFormat format) {
         return new Lexer(format, new ExtendedBufferedReader(new StringReader(input)));
     }
 
+    @BeforeEach
+    public void setUp() {
+        formatWithEscaping = CSVFormat.DEFAULT.withEscape('\\');
+    }
+
+    // simple token with escaping enabled
     @Test
-    public void testSurroundingSpacesAreDeleted() throws IOException {
-        final String code = "noSpaces,  leadingSpaces,trailingSpaces  ,  surroundingSpaces  ,  ,,";
-        try (final Lexer parser = createLexer(code, CSVFormat.DEFAULT.withIgnoreSurroundingSpaces())) {
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "noSpaces"));
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "leadingSpaces"));
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "trailingSpaces"));
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "surroundingSpaces"));
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, ""));
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, ""));
-            assertThat(parser.nextToken(new Token()), matches(EOF, ""));
+    void testBackslashWithEscaping() throws IOException {
+        /*
+         * file: a,\,,b \,,
+         */
+        final String code = "a,\\,,b\\\\\n\\,,\\\nc,d\\\r\ne";
+        final CSVFormat format = formatWithEscaping.withIgnoreEmptyLines(false);
+        assertTrue(format.isEscapeCharacterSet());
+        try (Lexer lexer = createLexer(code, format)) {
+            assertNextToken(TOKEN, "a", lexer);
+            assertNextToken(TOKEN, ",", lexer);
+            assertNextToken(EORECORD, "b\\", lexer);
+            assertNextToken(TOKEN, ",", lexer);
+            assertNextToken(TOKEN, "\nc", lexer);
+            assertNextToken(EORECORD, "d\r", lexer);
+            assertNextToken(EOF, "e", lexer);
         }
     }
 
+    // simple token with escaping not enabled
     @Test
-    public void testSurroundingTabsAreDeleted() throws IOException {
-        final String code = "noTabs,\tleadingTab,trailingTab\t,\tsurroundingTabs\t,\t\t,,";
-        try (final Lexer parser = createLexer(code, CSVFormat.DEFAULT.withIgnoreSurroundingSpaces())) {
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "noTabs"));
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "leadingTab"));
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "trailingTab"));
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "surroundingTabs"));
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, ""));
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, ""));
-            assertThat(parser.nextToken(new Token()), matches(EOF, ""));
+    void testBackslashWithoutEscaping() throws IOException {
+        /*
+         * file: a,\,,b \,,
+         */
+        final String code = "a,\\,,b\\\n\\,,";
+        final CSVFormat format = CSVFormat.DEFAULT;
+        assertFalse(format.isEscapeCharacterSet());
+        try (Lexer lexer = createLexer(code, format)) {
+            // parser.nextToken(new Token())
+            assertNextToken(TOKEN, "a", lexer);
+            // an unquoted single backslash is not an escape char
+            assertNextToken(TOKEN, "\\", lexer);
+            assertNextToken(TOKEN, "", lexer);
+            assertNextToken(EORECORD, "b\\", lexer);
+            // an unquoted single backslash is not an escape char
+            assertNextToken(TOKEN, "\\", lexer);
+            assertNextToken(TOKEN, "", lexer);
+            assertNextToken(EOF, "", lexer);
         }
     }
 
     @Test
-    public void testIgnoreEmptyLines() throws IOException {
-        final String code = "first,line,\n" + "\n" + "\n" + "second,line\n" + "\n" + "\n" + "third line \n" + "\n" +
-                "\n" + "last, line \n" + "\n" + "\n" + "\n";
-        final CSVFormat format = CSVFormat.DEFAULT.withIgnoreEmptyLines();
-        try (final Lexer parser = createLexer(code, format)) {
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "first"));
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "line"));
-            assertThat(parser.nextToken(new Token()), matches(EORECORD, ""));
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "second"));
-            assertThat(parser.nextToken(new Token()), matches(EORECORD, "line"));
-            assertThat(parser.nextToken(new Token()), matches(EORECORD, "third line "));
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "last"));
-            assertThat(parser.nextToken(new Token()), matches(EORECORD, " line "));
-            assertThat(parser.nextToken(new Token()), matches(EOF, ""));
-            assertThat(parser.nextToken(new Token()), matches(EOF, ""));
+    void testBackspace() throws Exception {
+        try (Lexer lexer = createLexer("character" + BACKSPACE + "NotEscaped", formatWithEscaping)) {
+            assertNextToken("character" + BACKSPACE + "NotEscaped", lexer);
         }
     }
 
     @Test
-    public void testComments() throws IOException {
-        final String code = "first,line,\n" + "second,line,tokenWith#no-comment\n" + "# comment line \n" +
-                "third,line,#no-comment\n" + "# penultimate comment\n" + "# Final comment\n";
+    void testComments() throws IOException {
+        // @formatter:off
+        final String code = "first,line,\n" +
+                "second,line,tokenWith#no-comment\n" +
+                "# comment line \n" +
+                "third,line,#no-comment\n" +
+                "# penultimate comment\n" +
+                "# Final comment\n";
+        // @formatter:on
         final CSVFormat format = CSVFormat.DEFAULT.withCommentMarker('#');
-        try (final Lexer parser = createLexer(code, format)) {
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "first"));
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "line"));
-            assertThat(parser.nextToken(new Token()), matches(EORECORD, ""));
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "second"));
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "line"));
-            assertThat(parser.nextToken(new Token()), matches(EORECORD, "tokenWith#no-comment"));
-            assertThat(parser.nextToken(new Token()), matches(COMMENT, "comment line"));
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "third"));
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "line"));
-            assertThat(parser.nextToken(new Token()), matches(EORECORD, "#no-comment"));
-            assertThat(parser.nextToken(new Token()), matches(COMMENT, "penultimate comment"));
-            assertThat(parser.nextToken(new Token()), matches(COMMENT, "Final comment"));
-            assertThat(parser.nextToken(new Token()), matches(EOF, ""));
-            assertThat(parser.nextToken(new Token()), matches(EOF, ""));
-        }
-    }
-
-    @Test
-    public void testCommentsAndEmptyLines() throws IOException {
+        try (Lexer lexer = createLexer(code, format)) {
+            assertNextToken(TOKEN, "first", lexer);
+            assertNextToken(TOKEN, "line", lexer);
+            assertNextToken(EORECORD, "", lexer);
+            assertNextToken(TOKEN, "second", lexer);
+            assertNextToken(TOKEN, "line", lexer);
+            assertNextToken(EORECORD, "tokenWith#no-comment", lexer);
+            assertNextToken(COMMENT, "comment line", lexer);
+            assertNextToken(TOKEN, "third", lexer);
+            assertNextToken(TOKEN, "line", lexer);
+            assertNextToken(EORECORD, "#no-comment", lexer);
+            assertNextToken(COMMENT, "penultimate comment", lexer);
+            assertNextToken(COMMENT, "Final comment", lexer);
+            assertNextToken(EOF, "", lexer);
+            assertNextToken(EOF, "", lexer);
+        }
+    }
+
+    @Test
+    void testCommentsAndEmptyLines() throws IOException {
         final String code = "1,2,3,\n" + // 1
                 "\n" + // 1b
                 "\n" + // 1c
@@ -145,289 +167,384 @@ public void testCommentsAndEmptyLines() throws IOException {
         final CSVFormat format = CSVFormat.DEFAULT.withCommentMarker('#').withIgnoreEmptyLines(false);
         assertFalse(format.getIgnoreEmptyLines(), "Should not ignore empty lines");
 
-        try (final Lexer parser = createLexer(code, format)) {
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "1"));
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "2"));
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "3"));
-            assertThat(parser.nextToken(new Token()), matches(EORECORD, "")); // 1
-            assertThat(parser.nextToken(new Token()), matches(EORECORD, "")); // 1b
-            assertThat(parser.nextToken(new Token()), matches(EORECORD, "")); // 1c
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "a"));
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "b x"));
-            assertThat(parser.nextToken(new Token()), matches(EORECORD, "c#no-comment")); // 2
-            assertThat(parser.nextToken(new Token()), matches(COMMENT, "foo")); // 3
-            assertThat(parser.nextToken(new Token()), matches(EORECORD, "")); // 4
-            assertThat(parser.nextToken(new Token()), matches(EORECORD, "")); // 4b
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "d"));
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "e"));
-            assertThat(parser.nextToken(new Token()), matches(EORECORD, "#no-comment")); // 5
-            assertThat(parser.nextToken(new Token()), matches(EORECORD, "")); // 5b
-            assertThat(parser.nextToken(new Token()), matches(EORECORD, "")); // 5c
-            assertThat(parser.nextToken(new Token()), matches(COMMENT, "penultimate comment")); // 6
-            assertThat(parser.nextToken(new Token()), matches(EORECORD, "")); // 6b
-            assertThat(parser.nextToken(new Token()), matches(EORECORD, "")); // 6c
-            assertThat(parser.nextToken(new Token()), matches(COMMENT, "Final comment")); // 7
-            assertThat(parser.nextToken(new Token()), matches(EOF, ""));
-            assertThat(parser.nextToken(new Token()), matches(EOF, ""));
+        try (Lexer lexer = createLexer(code, format)) {
+            assertNextToken(TOKEN, "1", lexer);
+            assertNextToken(TOKEN, "2", lexer);
+            assertNextToken(TOKEN, "3", lexer);
+            assertNextToken(EORECORD, "", lexer); // 1
+            assertNextToken(EORECORD, "", lexer); // 1b
+            assertNextToken(EORECORD, "", lexer); // 1c
+            assertNextToken(TOKEN, "a", lexer);
+            assertNextToken(TOKEN, "b x", lexer);
+            assertNextToken(EORECORD, "c#no-comment", lexer); // 2
+            assertNextToken(COMMENT, "foo", lexer); // 3
+            assertNextToken(EORECORD, "", lexer); // 4
+            assertNextToken(EORECORD, "", lexer); // 4b
+            assertNextToken(TOKEN, "d", lexer);
+            assertNextToken(TOKEN, "e", lexer);
+            assertNextToken(EORECORD, "#no-comment", lexer); // 5
+            assertNextToken(EORECORD, "", lexer); // 5b
+            assertNextToken(EORECORD, "", lexer); // 5c
+            assertNextToken(COMMENT, "penultimate comment", lexer); // 6
+            assertNextToken(EORECORD, "", lexer); // 6b
+            assertNextToken(EORECORD, "", lexer); // 6c
+            assertNextToken(COMMENT, "Final comment", lexer); // 7
+            assertNextToken(EOF, "", lexer);
+            assertNextToken(EOF, "", lexer);
         }
     }
 
-    // simple token with escaping not enabled
     @Test
-    public void testBackslashWithoutEscaping() throws IOException {
-        /*
-         * file: a,\,,b \,,
-         */
-        final String code = "a,\\,,b\\\n\\,,";
-        final CSVFormat format = CSVFormat.DEFAULT;
-        assertFalse(format.isEscapeCharacterSet());
-        try (final Lexer parser = createLexer(code, format)) {
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "a"));
-            // an unquoted single backslash is not an escape char
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "\\"));
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, ""));
-            assertThat(parser.nextToken(new Token()), matches(EORECORD, "b\\"));
-            // an unquoted single backslash is not an escape char
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "\\"));
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, ""));
-            assertThat(parser.nextToken(new Token()), matches(EOF, ""));
+    void testCR() throws Exception {
+        try (Lexer lexer = createLexer("character" + CR + "NotEscaped", formatWithEscaping)) {
+            assertNextToken("character", lexer);
+            assertNextToken("NotEscaped", lexer);
         }
     }
 
-    // simple token with escaping enabled
+    // From CSV-1
     @Test
-    public void testBackslashWithEscaping() throws IOException {
-        /*
-         * file: a,\,,b \,,
-         */
-        final String code = "a,\\,,b\\\\\n\\,,\\\nc,d\\\r\ne";
-        final CSVFormat format = formatWithEscaping.withIgnoreEmptyLines(false);
-        assertTrue(format.isEscapeCharacterSet());
-        try (final Lexer parser = createLexer(code, format)) {
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "a"));
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, ","));
-            assertThat(parser.nextToken(new Token()), matches(EORECORD, "b\\"));
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, ","));
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "\nc"));
-            assertThat(parser.nextToken(new Token()), matches(EORECORD, "d\r"));
-            assertThat(parser.nextToken(new Token()), matches(EOF, "e"));
+    void testDelimiterIsWhitespace() throws IOException {
+        final String code = "one\ttwo\t\tfour \t five\t six";
+        try (Lexer lexer = createLexer(code, CSVFormat.TDF)) {
+            assertNextToken(TOKEN, "one", lexer);
+            assertNextToken(TOKEN, "two", lexer);
+            assertNextToken(TOKEN, "", lexer);
+            assertNextToken(TOKEN, "four", lexer);
+            assertNextToken(TOKEN, "five", lexer);
+            assertNextToken(EOF, "six", lexer);
         }
     }
 
-    // encapsulator tokenizer (single line)
+    /**
+     * With {@code ignoreSurroundingSpaces} enabled and a multi-character delimiter whose first character is whitespace,
+     * the side-effecting {@link Lexer#isDelimiter(int)} must only be evaluated once per character, otherwise the
+     * delimiter is consumed in the whitespace-skip loop and the empty field at the boundary is dropped.
+     */
     @Test
-    public void testNextToken4() throws IOException {
-        /*
-         * file: a,"foo",b a, " foo",b a,"foo " ,b // whitespace after closing encapsulator a, " foo " ,b
-         */
-        final String code = "a,\"foo\",b\na,   \" foo\",b\na,\"foo \"  ,b\na,  \" foo \"  ,b";
-        try (final Lexer parser = createLexer(code, CSVFormat.DEFAULT.withIgnoreSurroundingSpaces())) {
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "a"));
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "foo"));
-            assertThat(parser.nextToken(new Token()), matches(EORECORD, "b"));
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "a"));
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, " foo"));
-            assertThat(parser.nextToken(new Token()), matches(EORECORD, "b"));
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "a"));
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "foo "));
-            assertThat(parser.nextToken(new Token()), matches(EORECORD, "b"));
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "a"));
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, " foo "));
-            // assertTokenEquals(EORECORD, "b", parser.nextToken(new Token()));
-            assertThat(parser.nextToken(new Token()), matches(EOF, "b"));
+    void testEmptyTokenBeforeWhitespacePrefixedMultiCharacterDelimiter() throws IOException {
+        final CSVFormat format = CSVFormat.DEFAULT.builder().setDelimiter(" |").setIgnoreSurroundingSpaces(true).get();
+        try (Lexer lexer = createLexer(" |a", format)) {
+            assertNextToken(TOKEN, "", lexer);
+            assertNextToken(EOF, "a", lexer);
+        }
+        try (Lexer lexer = createLexer("a | |b", format)) {
+            assertNextToken(TOKEN, "a", lexer);
+            assertNextToken(TOKEN, "", lexer);
+            assertNextToken(EOF, "b", lexer);
         }
     }
 
-    // encapsulator tokenizer (multi line, delimiter in string)
     @Test
-    public void testNextToken5() throws IOException {
-        final String code = "a,\"foo\n\",b\n\"foo\n  baar ,,,\"\n\"\n\t \n\"";
-        try (final Lexer parser = createLexer(code, CSVFormat.DEFAULT)) {
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "a"));
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "foo\n"));
-            assertThat(parser.nextToken(new Token()), matches(EORECORD, "b"));
-            assertThat(parser.nextToken(new Token()), matches(EORECORD, "foo\n  baar ,,,"));
-            assertThat(parser.nextToken(new Token()), matches(EOF, "\n\t \n"));
+    void testEOFWithoutClosingQuote() throws Exception {
+        final String code = "a,\"b";
+        try (Lexer lexer = createLexer(code, CSVFormat.Builder.create().setLenientEof(true).get())) {
+            assertNextToken(TOKEN, "a", lexer);
+            assertNextToken(EOF, "b", lexer);
+        }
+        try (Lexer lexer = createLexer(code, CSVFormat.Builder.create().setLenientEof(false).get())) {
+            assertNextToken(TOKEN, "a", lexer);
+            assertThrows(IOException.class, () -> lexer.nextToken(new Token()));
+        }
+    }
+
+    @Test // TODO is this correct? Do we expect BACKSPACE to be unescaped?
+    void testEscapedBackspace() throws Exception {
+        try (Lexer lexer = createLexer("character\\" + BACKSPACE + "Escaped", formatWithEscaping)) {
+            assertNextToken("character" + BACKSPACE + "Escaped", lexer);
         }
     }
 
-    // change delimiters, comment, encapsulater
     @Test
-    public void testNextToken6() throws IOException {
-        /*
-         * file: a;'b and \' more ' !comment;;;; ;;
-         */
-        final String code = "a;'b and '' more\n'\n!comment;;;;\n;;";
-        final CSVFormat format = CSVFormat.DEFAULT.withQuote('\'').withCommentMarker('!').withDelimiter(';');
-        try (final Lexer parser = createLexer(code, format)) {
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "a"));
-            assertThat(parser.nextToken(new Token()), matches(EORECORD, "b and ' more\n"));
+    void testEscapedCharacter() throws Exception {
+        try (Lexer lexer = createLexer("character\\aEscaped", formatWithEscaping)) {
+            assertNextToken("character\\aEscaped", lexer);
         }
     }
 
-    // From CSV-1
     @Test
-    public void testDelimiterIsWhitespace() throws IOException {
-        final String code = "one\ttwo\t\tfour \t five\t six";
-        try (final Lexer parser = createLexer(code, CSVFormat.TDF)) {
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "one"));
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "two"));
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, ""));
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "four"));
-            assertThat(parser.nextToken(new Token()), matches(TOKEN, "five"));
-            assertThat(parser.nextToken(new Token()), matches(EOF, "six"));
+    void testEscapedControlCharacter() throws Exception {
+        // we are explicitly using an escape different from \ here
+        try (Lexer lexer = createLexer("character!rEscaped", CSVFormat.DEFAULT.withEscape('!'))) {
+            assertNextToken("character" + CR + "Escaped", lexer);
         }
     }
 
     @Test
-    public void testEscapedCR() throws Exception {
-        try (final Lexer lexer = createLexer("character\\" + CR + "Escaped", formatWithEscaping)) {
-            assertThat(lexer.nextToken(new Token()), hasContent("character" + CR + "Escaped"));
+    void testEscapedControlCharacter2() throws Exception {
+        try (Lexer lexer = createLexer("character\\rEscaped", CSVFormat.DEFAULT.withEscape('\\'))) {
+            assertNextToken("character" + CR + "Escaped", lexer);
         }
     }
 
     @Test
-    public void testCR() throws Exception {
-        try (final Lexer lexer = createLexer("character" + CR + "NotEscaped", formatWithEscaping)) {
-            assertThat(lexer.nextToken(new Token()), hasContent("character"));
-            assertThat(lexer.nextToken(new Token()), hasContent("NotEscaped"));
+    void testEscapedCR() throws Exception {
+        try (Lexer lexer = createLexer("character\\" + CR + "Escaped", formatWithEscaping)) {
+            assertNextToken("character" + CR + "Escaped", lexer);
+        }
+    }
+
+    @Test // TODO is this correct? Do we expect FF to be unescaped?
+    void testEscapedFF() throws Exception {
+        try (Lexer lexer = createLexer("character\\" + FF + "Escaped", formatWithEscaping)) {
+            assertNextToken("character" + FF + "Escaped", lexer);
         }
     }
 
     @Test
-    public void testEscapedLF() throws Exception {
-        try (final Lexer lexer = createLexer("character\\" + LF + "Escaped", formatWithEscaping)) {
-            assertThat(lexer.nextToken(new Token()), hasContent("character" + LF + "Escaped"));
+    void testEscapedLF() throws Exception {
+        try (Lexer lexer = createLexer("character\\" + LF + "Escaped", formatWithEscaping)) {
+            assertNextToken("character" + LF + "Escaped", lexer);
         }
     }
 
     @Test
-    public void testLF() throws Exception {
-        try (final Lexer lexer = createLexer("character" + LF + "NotEscaped", formatWithEscaping)) {
-            assertThat(lexer.nextToken(new Token()), hasContent("character"));
-            assertThat(lexer.nextToken(new Token()), hasContent("NotEscaped"));
+    void testEscapedMySqlNullValue() throws Exception {
+        // MySQL uses \N to symbolize null values. We have to restore this
+        try (Lexer lexer = createLexer("character\\NEscaped", formatWithEscaping)) {
+            assertNextToken("character\\NEscaped", lexer);
         }
     }
 
     @Test // TODO is this correct? Do we expect TAB to be unescaped?
-    public void testEscapedTab() throws Exception {
-        try (final Lexer lexer = createLexer("character\\" + TAB + "Escaped", formatWithEscaping)) {
-            assertThat(lexer.nextToken(new Token()), hasContent("character" + TAB + "Escaped"));
+    void testEscapedTab() throws Exception {
+        try (Lexer lexer = createLexer("character\\" + TAB + "Escaped", formatWithEscaping)) {
+            assertNextToken("character" + TAB + "Escaped", lexer);
         }
 
     }
 
     @Test
-    public void testTab() throws Exception {
-        try (final Lexer lexer = createLexer("character" + TAB + "NotEscaped", formatWithEscaping)) {
-            assertThat(lexer.nextToken(new Token()), hasContent("character" + TAB + "NotEscaped"));
+    void testEscapingAtEOF() throws Exception {
+        final String code = "escaping at EOF is evil\\";
+        try (Lexer lexer = createLexer(code, formatWithEscaping)) {
+            assertThrows(IOException.class, () -> lexer.nextToken(new Token()));
         }
     }
 
-    @Test // TODO is this correct? Do we expect BACKSPACE to be unescaped?
-    public void testEscapedBackspace() throws Exception {
-        try (final Lexer lexer = createLexer("character\\" + BACKSPACE + "Escaped", formatWithEscaping)) {
-            assertThat(lexer.nextToken(new Token()), hasContent("character" + BACKSPACE + "Escaped"));
+    @Test
+    void testFF() throws Exception {
+        try (Lexer lexer = createLexer("character" + FF + "NotEscaped", formatWithEscaping)) {
+            assertNextToken("character" + FF + "NotEscaped", lexer);
         }
     }
 
     @Test
-    public void testBackspace() throws Exception {
-        try (final Lexer lexer = createLexer("character" + BACKSPACE + "NotEscaped", formatWithEscaping)) {
-            assertThat(lexer.nextToken(new Token()), hasContent("character" + BACKSPACE + "NotEscaped"));
+    void testIgnoreEmptyLines() throws IOException {
+        // @formatter:off
+        final String code = "first,line,\n" +
+                "\n" +
+                "\n" +
+                "second,line\n" +
+                "\n" +
+                "\n" +
+                "third line \n" +
+                "\n" +
+                "\n" +
+                "last, line \n" +
+                "\n" +
+                "\n" +
+                "\n";
+        // @formatter:on
+        final CSVFormat format = CSVFormat.DEFAULT.withIgnoreEmptyLines();
+        try (Lexer lexer = createLexer(code, format)) {
+            assertNextToken(TOKEN, "first", lexer);
+            assertNextToken(TOKEN, "line", lexer);
+            assertNextToken(EORECORD, "", lexer);
+            assertNextToken(TOKEN, "second", lexer);
+            assertNextToken(EORECORD, "line", lexer);
+            assertNextToken(EORECORD, "third line ", lexer);
+            assertNextToken(TOKEN, "last", lexer);
+            assertNextToken(EORECORD, " line ", lexer);
+            assertNextToken(EOF, "", lexer);
+            assertNextToken(EOF, "", lexer);
         }
     }
 
-    @Test // TODO is this correct? Do we expect FF to be unescaped?
-    public void testEscapedFF() throws Exception {
-        try (final Lexer lexer = createLexer("character\\" + FF + "Escaped", formatWithEscaping)) {
-            assertThat(lexer.nextToken(new Token()), hasContent("character" + FF + "Escaped"));
+    @Test
+    void testIsMetaCharCommentStart() throws IOException {
+        try (Lexer lexer = createLexer("#", CSVFormat.DEFAULT.withCommentMarker('#'))) {
+            final int ch = lexer.readEscape();
+            assertEquals('#', ch);
         }
     }
 
     @Test
-    public void testFF() throws Exception {
-        try (final Lexer lexer = createLexer("character" + FF + "NotEscaped", formatWithEscaping)) {
-            assertThat(lexer.nextToken(new Token()), hasContent("character" + FF + "NotEscaped"));
+    void testLF() throws Exception {
+        try (Lexer lexer = createLexer("character" + LF + "NotEscaped", formatWithEscaping)) {
+            assertNextToken("character", lexer);
+            assertNextToken("NotEscaped", lexer);
         }
     }
 
+    // encapsulator tokenizer (single line)
     @Test
-    public void testEscapedMySqlNullValue() throws Exception {
-        // MySQL uses \N to symbolize null values. We have to restore this
-        try (final Lexer lexer = createLexer("character\\NEscaped", formatWithEscaping)) {
-            assertThat(lexer.nextToken(new Token()), hasContent("character\\NEscaped"));
+    void testNextToken4() throws IOException {
+        /*
+         * file: a,"foo",b a, " foo",b a,"foo " ,b // whitespace after closing encapsulator a, " foo " ,b
+         */
+        final String code = "a,\"foo\",b\na,   \" foo\",b\na,\"foo \"  ,b\na,  \" foo \"  ,b";
+        try (Lexer lexer = createLexer(code, CSVFormat.DEFAULT.withIgnoreSurroundingSpaces())) {
+            assertNextToken(TOKEN, "a", lexer);
+            assertNextToken(TOKEN, "foo", lexer);
+            assertNextToken(EORECORD, "b", lexer);
+            assertNextToken(TOKEN, "a", lexer);
+            assertNextToken(TOKEN, " foo", lexer);
+            assertNextToken(EORECORD, "b", lexer);
+            assertNextToken(TOKEN, "a", lexer);
+            assertNextToken(TOKEN, "foo ", lexer);
+            assertNextToken(EORECORD, "b", lexer);
+            assertNextToken(TOKEN, "a", lexer);
+            assertNextToken(TOKEN, " foo ", lexer);
+            // assertTokenEquals(EORECORD, "b", parser);
+            assertNextToken(EOF, "b", lexer);
         }
     }
 
+    // encapsulator tokenizer (multi line, delimiter in string)
     @Test
-    public void testEscapedCharacter() throws Exception {
-        try (final Lexer lexer = createLexer("character\\aEscaped", formatWithEscaping)) {
-            assertThat(lexer.nextToken(new Token()), hasContent("character\\aEscaped"));
+    void testNextToken5() throws IOException {
+        final String code = "a,\"foo\n\",b\n\"foo\n  baar ,,,\"\n\"\n\t \n\"";
+        try (Lexer lexer = createLexer(code, CSVFormat.DEFAULT)) {
+            assertNextToken(TOKEN, "a", lexer);
+            assertNextToken(TOKEN, "foo\n", lexer);
+            assertNextToken(EORECORD, "b", lexer);
+            assertNextToken(EORECORD, "foo\n  baar ,,,", lexer);
+            assertNextToken(EOF, "\n\t \n", lexer);
         }
     }
 
+    // change delimiters, comment, encapsulater
     @Test
-    public void testEscapedControlCharacter() throws Exception {
-        // we are explicitly using an escape different from \ here
-        try (final Lexer lexer = createLexer("character!rEscaped", CSVFormat.DEFAULT.withEscape('!'))) {
-            assertThat(lexer.nextToken(new Token()), hasContent("character" + CR + "Escaped"));
+    void testNextToken6() throws IOException {
+        /*
+         * file: a;'b and \' more ' !comment;;;; ;;
+         */
+        final String code = "a;'b and '' more\n'\n!comment;;;;\n;;";
+        final CSVFormat format = CSVFormat.DEFAULT.withQuote('\'').withCommentMarker('!').withDelimiter(';');
+        try (Lexer lexer = createLexer(code, format)) {
+            assertNextToken(TOKEN, "a", lexer);
+            assertNextToken(EORECORD, "b and ' more\n", lexer);
         }
     }
 
+    /**
+     * A truncated escaped multi-character delimiter at EOF must not be accepted by reusing the previous escape delimiter
+     * look-ahead in {@link Lexer#isEscapeDelimiter()}.
+     */
     @Test
-    public void testEscapedControlCharacter2() throws Exception {
-        try (final Lexer lexer = createLexer("character\\rEscaped", CSVFormat.DEFAULT.withEscape('\\'))) {
-            assertThat(lexer.nextToken(new Token()), hasContent("character" + CR + "Escaped"));
+    void testPartialEscapedMultiCharacterDelimiterAtEOF() throws IOException {
+        final CSVFormat format = CSVFormat.DEFAULT.builder().setDelimiter("[|]").setEscape('!').get();
+        try (Lexer lexer = createLexer("x![!|!]y![!|", format)) {
+            assertNextToken(EOF, "x[|]y![!|", lexer);
         }
     }
 
+    /**
+     * Tests CSV-324.
+     */
     @Test
-    public void testEscapingAtEOF() throws Exception {
-        final String code = "escaping at EOF is evil\\";
-        try (final Lexer lexer = createLexer(code, formatWithEscaping)) {
-            assertThrows(IOException.class, () -> lexer.nextToken(new Token()));
+    void testPartialMultiCharacterDelimiterAtEOF() throws IOException {
+        final CSVFormat format = CSVFormat.DEFAULT.builder().setDelimiter("[|]").get();
+        try (Lexer lexer = createLexer("a[|]b[|", format)) {
+            assertNextToken(TOKEN, "a", lexer);
+            assertNextToken(EOF, "b[|", lexer);
         }
     }
 
+    /**
+     * A truncated multi-character delimiter at EOF must not be accepted by reusing the look-ahead buffer left dirty by an
+     * earlier non-matching peek in the same token (CSV-324 only cleared the buffer once per token).
+     */
     @Test
-    public void testTrimTrailingSpacesZeroLength() throws Exception {
-        final StringBuilder buffer = new StringBuilder("");
-        final Lexer lexer = createLexer(buffer.toString(), CSVFormat.DEFAULT);
-        lexer.trimTrailingSpaces(buffer);
-        assertThat(lexer.nextToken(new Token()), matches(EOF, ""));
+    void testPartialMultiCharacterDelimiterAtEOFAfterMismatch() throws IOException {
+        final CSVFormat format = CSVFormat.DEFAULT.builder().setDelimiter("[|]").get();
+        // The "[a]" peek leaves ']' in the look-ahead buffer; the trailing "[|" must not match "[|]".
+        final String recordString = "x[a][|";
+        try (Lexer lexer = createLexer(recordString, format)) {
+            assertNextToken(EOF, recordString, lexer);
+        }
     }
 
     @Test
-    public void testReadEscapeTab() throws IOException {
-        try (final Lexer lexer = createLexer("t", CSVFormat.DEFAULT.withEscape('\t'))) {
+    void testReadEscapeBackspace() throws IOException {
+        try (Lexer lexer = createLexer("b", CSVFormat.DEFAULT.withEscape('\b'))) {
             final int ch = lexer.readEscape();
-            assertThat(lexer.nextToken(new Token()), matches(EOF, ""));
-            assertEquals(TAB, ch);
+            assertEquals(BACKSPACE, ch);
         }
     }
 
     @Test
-    public void testReadEscapeBackspace() throws IOException {
-        try (final Lexer lexer = createLexer("b", CSVFormat.DEFAULT.withEscape('\b'))) {
+    void testReadEscapeFF() throws IOException {
+        try (Lexer lexer = createLexer("f", CSVFormat.DEFAULT.withEscape('\f'))) {
             final int ch = lexer.readEscape();
-            assertEquals(BACKSPACE, ch);
+            assertEquals(FF, ch);
         }
     }
 
     @Test
-    public void testReadEscapeFF() throws IOException {
-        try (final Lexer lexer = createLexer("f", CSVFormat.DEFAULT.withEscape('\f'))) {
+    void testReadEscapeTab() throws IOException {
+        try (Lexer lexer = createLexer("t", CSVFormat.DEFAULT.withEscape('\t'))) {
             final int ch = lexer.readEscape();
-            assertEquals(FF, ch);
+            assertNextToken(EOF, "", lexer);
+            assertEquals(TAB, ch);
         }
     }
 
     @Test
-    public void testIsMetaCharCommentStart() throws IOException {
-        try (final Lexer lexer = createLexer("#", CSVFormat.DEFAULT.withCommentMarker('#'))) {
-            final int ch = lexer.readEscape();
-            assertEquals('#', ch);
+    void testSurroundingSpacesAreDeleted() throws IOException {
+        final String code = "noSpaces,  leadingSpaces,trailingSpaces  ,  surroundingSpaces  ,  ,,";
+        try (Lexer lexer = createLexer(code, CSVFormat.DEFAULT.withIgnoreSurroundingSpaces())) {
+            assertNextToken(TOKEN, "noSpaces", lexer);
+            assertNextToken(TOKEN, "leadingSpaces", lexer);
+            assertNextToken(TOKEN, "trailingSpaces", lexer);
+            assertNextToken(TOKEN, "surroundingSpaces", lexer);
+            assertNextToken(TOKEN, "", lexer);
+            assertNextToken(TOKEN, "", lexer);
+            assertNextToken(EOF, "", lexer);
+        }
+    }
+
+    @Test
+    void testSurroundingTabsAreDeleted() throws IOException {
+        final String code = "noTabs,\tleadingTab,trailingTab\t,\tsurroundingTabs\t,\t\t,,";
+        try (Lexer lexer = createLexer(code, CSVFormat.DEFAULT.withIgnoreSurroundingSpaces())) {
+            assertNextToken(TOKEN, "noTabs", lexer);
+            assertNextToken(TOKEN, "leadingTab", lexer);
+            assertNextToken(TOKEN, "trailingTab", lexer);
+            assertNextToken(TOKEN, "surroundingTabs", lexer);
+            assertNextToken(TOKEN, "", lexer);
+            assertNextToken(TOKEN, "", lexer);
+            assertNextToken(EOF, "", lexer);
+        }
+    }
+
+    @Test
+    void testTab() throws Exception {
+        try (Lexer lexer = createLexer("character" + TAB + "NotEscaped", formatWithEscaping)) {
+            assertNextToken("character" + TAB + "NotEscaped", lexer);
+        }
+    }
+
+    @Test
+    void testTrailingTextAfterQuote() throws Exception {
+        final String code = "\"a\" b,\"a\" \" b,\"a\" b \"\"";
+        try (Lexer lexer = createLexer(code, CSVFormat.Builder.create().setTrailingData(true).get())) {
+            assertNextToken(TOKEN, "a b", lexer);
+            assertNextToken(TOKEN, "a \" b", lexer);
+            assertNextToken(EOF, "a b \"\"", lexer);
+        }
+        try (Lexer parser = createLexer(code, CSVFormat.Builder.create().setTrailingData(false).get())) {
+            assertThrows(IOException.class, () -> parser.nextToken(new Token()));
+        }
+    }
+
+    @Test
+    void testTrimTrailingSpacesZeroLength() throws Exception {
+        final StringBuilder buffer = new StringBuilder("");
+        try (Lexer lexer = createLexer(buffer.toString(), CSVFormat.DEFAULT)) {
+            lexer.trimTrailingSpaces(buffer);
+            assertNextToken(EOF, "", lexer);
         }
     }
 }
diff --git a/src/test/java/org/apache/commons/csv/PerformanceTest.java b/src/test/java/org/apache/commons/csv/PerformanceTest.java
index 023f2f5168..9284828e6c 100644
--- a/src/test/java/org/apache/commons/csv/PerformanceTest.java
+++ b/src/test/java/org/apache/commons/csv/PerformanceTest.java
@@ -1,22 +1,26 @@
 /*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *   https://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.
+ * 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 org.apache.commons.csv;
 
+import static org.apache.commons.io.IOUtils.EOF;
+
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileInputStream;
@@ -33,55 +37,93 @@
 import java.nio.file.Paths;
 import java.util.zip.GZIPInputStream;
 
+import org.apache.commons.io.FileUtils;
 import org.apache.commons.io.IOUtils;
 
 /**
  * Basic test harness.
- *
- * Requires test file to be downloaded separately.
  */
 @SuppressWarnings("boxing")
-public class PerformanceTest {
+class PerformanceTest {
+
+    @FunctionalInterface
+    private interface CSVParserFactory {
+        CSVParser createParser() throws IOException;
+    }
+
+    // Container for basic statistics
+    private static final class Stats {
+        final int count;
+        final int fields;
+
+        Stats(final int c, final int f) {
+            count = c;
+            fields = f;
+        }
+    }
 
-    private static final String[] PROPS = {
-        "java.version",                  // Java Runtime Environment version
-        "java.vendor",                   // Java Runtime Environment vendor
+    private static final String[] PROPERTY_NAMES = { "java.version", // Java Runtime Environment version
+            "java.vendor", // Java Runtime Environment vendor
 //        "java.vm.specification.version", // Java Virtual Machine specification version
 //        "java.vm.specification.vendor",  // Java Virtual Machine specification vendor
 //        "java.vm.specification.name",    // Java Virtual Machine specification name
-        "java.vm.version",               // Java Virtual Machine implementation version
+            "java.vm.version", // Java Virtual Machine implementation version
 //        "java.vm.vendor",                // Java Virtual Machine implementation vendor
-        "java.vm.name",                  // Java Virtual Machine implementation name
+            "java.vm.name", // Java Virtual Machine implementation name
 //        "java.specification.version",    // Java Runtime Environment specification version
 //        "java.specification.vendor",     // Java Runtime Environment specification vendor
 //        "java.specification.name",       // Java Runtime Environment specification name
 
-        "os.name",                       // Operating system name
-        "os.arch",                       // Operating system architecture
-        "os.version",                    // Operating system version
+            "os.name", // Operating system name
+            "os.arch", // Operating system architecture
+            "os.version", // Operating system version
     };
-
     private static int max = 11; // skip first test
 
-    private static int num = 0; // number of elapsed times recorded
-    private static long[] elapsedTimes = new long[max];
+    private static int num; // number of elapsed times recorded
 
+    private static final long[] ELAPSED_TIMES = new long[max];
     private static final CSVFormat format = CSVFormat.EXCEL;
 
-    private static final File BIG_FILE = new File("src/test/resources/perf/worldcitiespop.txt");
+    private static final String TEST_RESRC = "org/apache/commons/csv/perf/worldcitiespop.txt.gz";
+
+    private static final File BIG_FILE = new File(FileUtils.getTempDirectoryPath(), "worldcitiespop.txt");
+
+    private static Reader createReader() throws IOException {
+        return new InputStreamReader(new FileInputStream(BIG_FILE), StandardCharsets.ISO_8859_1);
+    }
+
+    private static Lexer createTestCSVLexer(final String test, final ExtendedBufferedReader input)
+            throws InstantiationException, IllegalAccessException, InvocationTargetException, Exception {
+        return test.startsWith("CSVLexer") ? getLexerCtor(test).newInstance(format, input) : new Lexer(format, input);
+    }
 
-    public static void main(final String [] args) throws Exception {
+    private static Constructor getLexerCtor(final String clazz) throws Exception {
+        @SuppressWarnings("unchecked")
+        final Class lexer = (Class) Class.forName("org.apache.commons.csv." + clazz);
+        return lexer.getConstructor(CSVFormat.class, ExtendedBufferedReader.class);
+    }
+
+    private static Stats iterate(final Iterable iterable) {
+        int count = 0;
+        int fields = 0;
+        for (final CSVRecord record : iterable) {
+            count++;
+            fields += record.size();
+        }
+        return new Stats(count, fields);
+    }
+
+    public static void main(final String[] args) throws Exception {
         if (BIG_FILE.exists()) {
             System.out.printf("Found test fixture %s: %,d bytes.%n", BIG_FILE, BIG_FILE.length());
         } else {
-            final File compressedFile = new File(BIG_FILE.getParentFile(), BIG_FILE.getName() + ".gz");
-            System.out.printf("Decompressing test fixture %s...%n", compressedFile);
-            long bytesOut = 0L;
-            try (final InputStream input = new GZIPInputStream(new FileInputStream(compressedFile));
-                    final OutputStream output = new FileOutputStream(BIG_FILE)) {
-                bytesOut = IOUtils.copy(input, output);
+            System.out.println("Decompressing test fixture to: " + BIG_FILE + "...");
+            try (InputStream input = new GZIPInputStream(PerformanceTest.class.getClassLoader().getResourceAsStream(TEST_RESRC));
+                    OutputStream output = new FileOutputStream(BIG_FILE)) {
+                IOUtils.copy(input, output);
+                System.out.println(String.format("Decompressed test fixture %s: %,d bytes.", BIG_FILE, BIG_FILE.length()));
             }
-            System.out.printf("Decompressed test fixture %s: %,d bytes to: %s: %,d bytes.%n", compressedFile, compressedFile.length(), BIG_FILE, bytesOut);
         }
         final int argc = args.length;
         if (argc > 0) {
@@ -91,115 +133,146 @@ public static void main(final String [] args) throws Exception {
         final String[] tests;
         if (argc > 1) {
             tests = new String[argc - 1];
-            for (int i = 1; i < argc; i++) {
-                tests[i - 1] = args[i];
-            }
+            System.arraycopy(args, 1, tests, 0, argc - 1);
         } else {
             tests = new String[] { "file", "split", "extb", "exts", "csv", "csv-path", "csv-path-db", "csv-url", "lexreset", "lexnew" };
         }
-        for (final String p : PROPS) {
+        for (final String p : PROPERTY_NAMES) {
             System.out.printf("%s=%s%n", p, System.getProperty(p));
         }
         System.out.printf("Max count: %d%n%n", max);
 
         for (final String test : tests) {
-            if ("file".equals(test)) {
+            switch (test) {
+            case "file":
                 testReadBigFile(false);
-            } else if ("split".equals(test)) {
+                break;
+            case "split":
                 testReadBigFile(true);
-            } else if ("csv".equals(test)) {
+                break;
+            case "csv":
                 testParseCommonsCSV();
-            } else if ("csv-path".equals(test)) {
+                break;
+            case "csv-path":
                 testParsePath();
-            } else if ("csv-path-db".equals(test)) {
+                break;
+            case "csv-path-db":
                 testParsePathDoubleBuffering();
-            } else if ("csv-url".equals(test)) {
+                break;
+            case "csv-url":
                 testParseURL();
-            } else if ("lexreset".equals(test)) {
+                break;
+            case "lexreset":
                 testCSVLexer(false, test);
-            } else if ("lexnew".equals(test)) {
+                break;
+            case "lexnew":
                 testCSVLexer(true, test);
-            } else if (test.startsWith("CSVLexer")) {
-                testCSVLexer(false, test);
-            } else if ("extb".equals(test)) {
-                testExtendedBuffer(false);
-            } else if ("exts".equals(test)) {
-                testExtendedBuffer(true);
-            } else {
-                System.out.printf("Invalid test name: %s%n", test);
+                break;
+            default:
+                if (test.startsWith("CSVLexer")) {
+                    testCSVLexer(false, test);
+                } else if ("extb".equals(test)) {
+                    testExtendedBuffer(false);
+                } else if ("exts".equals(test)) {
+                    testExtendedBuffer(true);
+                } else {
+                    System.out.printf("Invalid test name: %s%n", test);
+                }
+                break;
             }
         }
     }
 
-    private static Reader createReader() throws IOException {
-        return new InputStreamReader(new FileInputStream(BIG_FILE), StandardCharsets.ISO_8859_1);
-    }
-
-    // Container for basic statistics
-    private static class Stats {
-        final int count;
-        final int fields;
-        Stats(final int c, final int f) {
-            count = c;
-            fields = f;
+    private static Stats readAll(final BufferedReader in, final boolean split) throws IOException {
+        int count = 0;
+        int fields = 0;
+        String record;
+        while ((record = in.readLine()) != null) {
+            count++;
+            fields += split ? record.split(",").length : 1;
         }
-    }
-
-    // Display end stats; store elapsed for average
-    private static void show(final String msg, final Stats s, final long start) {
-        final long elapsed = System.currentTimeMillis() - start;
-        System.out.printf("%-20s: %5dms %d lines %d fields%n", msg, elapsed, s.count, s.fields);
-        elapsedTimes[num] = elapsed;
-        num++;
+        return new Stats(count, fields);
     }
 
     // calculate and show average
-    private static void show(){
+    private static void show() {
         if (num > 1) {
             long tot = 0;
             for (int i = 1; i < num; i++) { // skip first test
-                tot += elapsedTimes[i];
+                tot += ELAPSED_TIMES[i];
             }
             System.out.printf("%-20s: %5dms%n%n", "Average(not first)", tot / (num - 1));
         }
         num = 0; // ready for next set
     }
 
-    private static void testReadBigFile(final boolean split) throws Exception {
+    // Display end stats; store elapsed for average
+    private static void show(final String msg, final Stats s, final long start) {
+        final long elapsed = System.currentTimeMillis() - start;
+        System.out.printf("%-20s: %5dms %d lines %d fields%n", msg, elapsed, s.count, s.fields);
+        ELAPSED_TIMES[num] = elapsed;
+        num++;
+    }
+
+    private static void testCSVLexer(final boolean newToken, final String test) throws Exception {
+        Token token = new Token();
+        String dynamic = "";
         for (int i = 0; i < max; i++) {
-            final long startMillis;
+            final String simpleName;
             final Stats stats;
-            try (final BufferedReader in = new BufferedReader(createReader())) {
+            final long startMillis;
+            try (ExtendedBufferedReader input = new ExtendedBufferedReader(createReader());
+                    Lexer lexer = createTestCSVLexer(test, input)) {
+                if (test.startsWith("CSVLexer")) {
+                    dynamic = "!";
+                }
+                simpleName = lexer.getClass().getSimpleName();
+                int count = 0;
+                int fields = 0;
                 startMillis = System.currentTimeMillis();
-                stats = readAll(in, split);
+                do {
+                    if (newToken) {
+                        token = new Token();
+                    } else {
+                        token.reset();
+                    }
+                    lexer.nextToken(token);
+                    switch (token.type) {
+                    case EOF:
+                        break;
+                    case EORECORD:
+                        fields++;
+                        count++;
+                        break;
+                    case INVALID:
+                        throw new IOException("invalid parse sequence <" + token.content.toString() + ">");
+                    case TOKEN:
+                        fields++;
+                        break;
+                    case COMMENT: // not really expecting these
+                        break;
+                    default:
+                        throw new IllegalStateException("Unexpected Token type: " + token.type);
+                    }
+                } while (!token.type.equals(Token.Type.EOF));
+                stats = new Stats(count, fields);
             }
-            show(split ? "file+split" : "file", stats, startMillis);
+            show(simpleName + dynamic + " " + (newToken ? "new" : "reset"), stats, startMillis);
         }
         show();
     }
 
-    private static Stats readAll(final BufferedReader in, final boolean split) throws IOException {
-        int count = 0;
-        int fields = 0;
-        String record;
-        while ((record = in.readLine()) != null) {
-            count++;
-            fields += split ? record.split(",").length : 1;
-        }
-        return new Stats(count, fields);
-    }
-
     private static void testExtendedBuffer(final boolean makeString) throws Exception {
         for (int i = 0; i < max; i++) {
             int fields = 0;
             int lines = 0;
             final long startMillis;
-            try (final ExtendedBufferedReader in = new ExtendedBufferedReader(createReader())) {
+            try (ExtendedBufferedReader in = new ExtendedBufferedReader(createReader())) {
                 startMillis = System.currentTimeMillis();
                 int read;
                 if (makeString) {
                     StringBuilder sb = new StringBuilder();
-                    while ((read = in.read()) != -1) {
+                    while ((read = in.read()) != EOF) {
                         sb.append((char) read);
                         if (read == ',') { // count delimiters
                             sb.toString();
@@ -212,7 +285,7 @@ private static void testExtendedBuffer(final boolean makeString) throws Exceptio
                         }
                     }
                 } else {
-                    while ((read = in.read()) != -1) {
+                    while ((read = in.read()) != EOF) {
                         if (read == ',') { // count delimiters
                             fields++;
                         } else if (read == '\n') {
@@ -227,26 +300,8 @@ private static void testExtendedBuffer(final boolean makeString) throws Exceptio
         show();
     }
 
-    private static void testParser(final String msg, final CSVParserFactory fac) throws Exception {
-        for (int i = 0; i < max; i++) {
-            final long startMillis;
-            final Stats stats;
-            try (final CSVParser parser = fac.createParser()) {
-                startMillis = System.currentTimeMillis();
-                stats = iterate(parser);
-            }
-            show(msg, stats, startMillis);
-        }
-        show();
-    }
-
-    @FunctionalInterface
-    private interface CSVParserFactory {
-        CSVParser createParser() throws IOException;
-    }
-
     private static void testParseCommonsCSV() throws Exception {
-        testParser("CSV", () -> new CSVParser(createReader(), format));
+        testParser("CSV", () -> CSVParser.builder().setReader(createReader()).setFormat(format).get());
     }
 
     private static void testParsePath() throws Exception {
@@ -257,77 +312,34 @@ private static void testParsePathDoubleBuffering() throws Exception {
         testParser("CSV-PATH-DB", () -> CSVParser.parse(Files.newBufferedReader(Paths.get(BIG_FILE.toURI()), StandardCharsets.ISO_8859_1), format));
     }
 
-    private static void testParseURL() throws Exception {
-        testParser("CSV-URL", () -> CSVParser.parse(BIG_FILE.toURI().toURL(), StandardCharsets.ISO_8859_1, format));
-    }
-
-    private static Constructor getLexerCtor(final String clazz) throws Exception {
-        @SuppressWarnings("unchecked")
-        final Class lexer = (Class) Class.forName("org.apache.commons.csv." + clazz);
-        return lexer.getConstructor(CSVFormat.class, ExtendedBufferedReader.class);
-    }
-
-    private static void testCSVLexer(final boolean newToken, final String test) throws Exception {
-        Token token = new Token();
-        String dynamic = "";
+    private static void testParser(final String msg, final CSVParserFactory fac) throws Exception {
         for (int i = 0; i < max; i++) {
-            final String simpleName;
-            final Stats stats;
             final long startMillis;
-            try (final ExtendedBufferedReader input = new ExtendedBufferedReader(createReader());
-                    final Lexer lexer = createTestCSVLexer(test, input)) {
-                if (test.startsWith("CSVLexer")) {
-                    dynamic = "!";
-                }
-                simpleName = lexer.getClass().getSimpleName();
-                int count = 0;
-                int fields = 0;
+            final Stats stats;
+            try (CSVParser parser = fac.createParser()) {
                 startMillis = System.currentTimeMillis();
-                do {
-                    if (newToken) {
-                        token = new Token();
-                    } else {
-                        token.reset();
-                    }
-                    lexer.nextToken(token);
-                    switch (token.type) {
-                    case EOF:
-                        break;
-                    case EORECORD:
-                        fields++;
-                        count++;
-                        break;
-                    case INVALID:
-                        throw new IOException("invalid parse sequence <" + token.content.toString() + ">");
-                    case TOKEN:
-                        fields++;
-                        break;
-                    case COMMENT: // not really expecting these
-                        break;
-                    default:
-                        throw new IllegalStateException("Unexpected Token type: " + token.type);
-                    }
-                } while (!token.type.equals(Token.Type.EOF));
-                stats = new Stats(count, fields);
+                stats = iterate(parser);
             }
-            show(simpleName + dynamic + " " + (newToken ? "new" : "reset"), stats, startMillis);
+            show(msg, stats, startMillis);
         }
         show();
     }
 
-    private static Lexer createTestCSVLexer(final String test, final ExtendedBufferedReader input)
-            throws InstantiationException, IllegalAccessException, InvocationTargetException, Exception {
-        return test.startsWith("CSVLexer") ? getLexerCtor(test).newInstance(format, input) : new Lexer(format, input);
+    private static void testParseURL() throws Exception {
+        testParser("CSV-URL", () -> CSVParser.parse(BIG_FILE.toURI().toURL(), StandardCharsets.ISO_8859_1, format));
     }
 
-    private static Stats iterate(final Iterable it) {
-        int count = 0;
-        int fields = 0;
-        for (final CSVRecord record : it) {
-            count++;
-            fields += record.size();
+    private static void testReadBigFile(final boolean split) throws Exception {
+        for (int i = 0; i < max; i++) {
+            final long startMillis;
+            final Stats stats;
+            try (BufferedReader in = new BufferedReader(createReader())) {
+                startMillis = System.currentTimeMillis();
+                stats = readAll(in, split);
+            }
+            show(split ? "file+split" : "file", stats, startMillis);
         }
-        return new Stats(count, fields);
+        show();
     }
+}
 
-}
\ No newline at end of file
diff --git a/src/test/java/org/apache/commons/csv/TokenMatchers.java b/src/test/java/org/apache/commons/csv/TokenMatchers.java
deleted file mode 100644
index cfe522e821..0000000000
--- a/src/test/java/org/apache/commons/csv/TokenMatchers.java
+++ /dev/null
@@ -1,89 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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 org.apache.commons.csv;
-
-import static org.hamcrest.core.AllOf.allOf;
-
-import org.hamcrest.Description;
-import org.hamcrest.Matcher;
-import org.hamcrest.TypeSafeDiagnosingMatcher;
-
-/**
- * Collection of matchers for asserting the type and content of tokens.
- */
-final class TokenMatchers {
-
-    public static Matcher hasType(final Token.Type expectedType) {
-        return new TypeSafeDiagnosingMatcher() {
-
-            @Override
-            public void describeTo(final Description description) {
-                description.appendText("token has type ");
-                description.appendValue(expectedType);
-            }
-
-            @Override
-            protected boolean matchesSafely(final Token item,
-                    final Description mismatchDescription) {
-                mismatchDescription.appendText("token type is ");
-                mismatchDescription.appendValue(item.type);
-                return item.type == expectedType;
-            }
-        };
-    }
-
-    public static Matcher hasContent(final String expectedContent) {
-        return new TypeSafeDiagnosingMatcher() {
-
-            @Override
-            public void describeTo(final Description description) {
-                description.appendText("token has content ");
-                description.appendValue(expectedContent);
-            }
-
-            @Override
-            protected boolean matchesSafely(final Token item,
-                    final Description mismatchDescription) {
-                mismatchDescription.appendText("token content is ");
-                mismatchDescription.appendValue(item.content.toString());
-                return expectedContent.equals(item.content.toString());
-            }
-        };
-    }
-
-    public static Matcher isReady() {
-        return new TypeSafeDiagnosingMatcher() {
-
-            @Override
-            public void describeTo(final Description description) {
-                description.appendText("token is ready ");
-            }
-
-            @Override
-            protected boolean matchesSafely(final Token item,
-                    final Description mismatchDescription) {
-                mismatchDescription.appendText("token is not ready ");
-                return item.isReady;
-            }
-        };
-    }
-
-    public static Matcher matches(final Token.Type expectedType, final String expectedContent) {
-        return allOf(hasType(expectedType), hasContent(expectedContent));
-    }
-
-}
diff --git a/src/test/java/org/apache/commons/csv/TokenMatchersTest.java b/src/test/java/org/apache/commons/csv/TokenMatchersTest.java
deleted file mode 100644
index 3123e4367d..0000000000
--- a/src/test/java/org/apache/commons/csv/TokenMatchersTest.java
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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 org.apache.commons.csv;
-
-import static org.apache.commons.csv.TokenMatchers.hasContent;
-import static org.apache.commons.csv.TokenMatchers.hasType;
-import static org.apache.commons.csv.TokenMatchers.isReady;
-import static org.apache.commons.csv.TokenMatchers.matches;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-
-public class TokenMatchersTest {
-
-    private Token token;
-
-    @BeforeEach
-    public void setUp() {
-        token = new Token();
-        token.type = Token.Type.TOKEN;
-        token.isReady = true;
-        token.content.append("content");
-    }
-
-    @Test
-    public void testHasType() {
-        assertFalse(hasType(Token.Type.COMMENT).matches(token));
-        assertFalse(hasType(Token.Type.EOF).matches(token));
-        assertFalse(hasType(Token.Type.EORECORD).matches(token));
-        assertTrue(hasType(Token.Type.TOKEN).matches(token));
-    }
-
-    @Test
-    public void testHasContent() {
-        assertFalse(hasContent("This is not the token's content").matches(token));
-        assertTrue(hasContent("content").matches(token));
-    }
-
-    @Test
-    public void testIsReady() {
-        assertTrue(isReady().matches(token));
-        token.isReady = false;
-        assertFalse(isReady().matches(token));
-    }
-
-    @Test
-    public void testMatches() {
-        assertTrue(matches(Token.Type.TOKEN, "content").matches(token));
-        assertFalse(matches(Token.Type.EOF, "content").matches(token));
-        assertFalse(matches(Token.Type.TOKEN, "not the content").matches(token));
-        assertFalse(matches(Token.Type.EORECORD, "not the content").matches(token));
-    }
-
-    @Test
-    public void testToString() {
-        assertTrue(matches(Token.Type.TOKEN, "content").matches(token));
-        assertEquals("TOKEN", token.type.name());
-        assertEquals("TOKEN [content]", token.toString());
-    }
-}
diff --git a/src/test/java/org/apache/commons/csv/TokenTest.java b/src/test/java/org/apache/commons/csv/TokenTest.java
new file mode 100644
index 0000000000..075c1b1d9c
--- /dev/null
+++ b/src/test/java/org/apache/commons/csv/TokenTest.java
@@ -0,0 +1,50 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *
+ *   https://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 org.apache.commons.csv;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.EnumSource;
+
+/**
+ * Tests {@link Token}.
+ */
+class TokenTest {
+
+    @ParameterizedTest
+    @EnumSource(Token.Type.class)
+    void testToString(final Token.Type type) {
+        // Should never blow up
+        final Token token = new Token();
+        final String resetName = Token.Type.INVALID.name();
+        assertTrue(token.toString().contains(resetName));
+        token.reset();
+        assertTrue(token.toString().contains(resetName));
+        token.type = null;
+        assertFalse(token.toString().isEmpty());
+        token.reset();
+        token.type = type;
+        assertTrue(token.toString().contains(type.name()));
+        token.content.setLength(1000);
+        assertTrue(token.toString().contains(type.name()));
+    }
+}
diff --git a/src/test/java/org/apache/commons/csv/UserGuideTest.java b/src/test/java/org/apache/commons/csv/UserGuideTest.java
new file mode 100644
index 0000000000..6cd8c72d7f
--- /dev/null
+++ b/src/test/java/org/apache/commons/csv/UserGuideTest.java
@@ -0,0 +1,94 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *
+ *   https://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 org.apache.commons.csv;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.Reader;
+import java.io.UnsupportedEncodingException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+import org.apache.commons.io.input.BOMInputStream;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+/**
+ * Tests for the user guide.
+ */
+class UserGuideTest {
+
+    @TempDir
+    Path tempDir;
+
+    /**
+     * Creates a reader capable of handling BOMs.
+     *
+     * @param path The path to read.
+     * @return a new InputStreamReader for UTF-8 bytes.
+     * @throws IOException if an I/O error occurs.
+     */
+    public InputStreamReader newReader(final Path path) throws IOException {
+        return new InputStreamReader(BOMInputStream.builder()
+                .setPath(path)
+                .get(), StandardCharsets.UTF_8);
+    }
+
+    @Test
+    void testBomFull() throws UnsupportedEncodingException, IOException {
+        final Path path = tempDir.resolve("test1.csv");
+        Files.copy(Utils.createUtf8Input("ColumnA, ColumnB, ColumnC\r\nA, B, C\r\n".getBytes(StandardCharsets.UTF_8), true), path);
+        // @formatter:off
+        try (Reader reader = new InputStreamReader(BOMInputStream.builder()
+                .setPath(path)
+                .get(), "UTF-8");
+                CSVParser parser = CSVFormat.EXCEL.builder()
+                        .setHeader()
+                        .get()
+                        .parse(reader)) {
+            // @formatter:off
+            for (final CSVRecord record : parser) {
+                final String string = record.get("ColumnA");
+                assertEquals("A", string);
+            }
+        }
+    }
+
+    @Test
+    void testBomUtil() throws UnsupportedEncodingException, IOException {
+        final Path path = tempDir.resolve("test2.csv");
+        Files.copy(Utils.createUtf8Input("ColumnA, ColumnB, ColumnC\r\nA, B, C\r\n".getBytes(StandardCharsets.UTF_8), true), path);
+        try (Reader reader = newReader(path);
+                // @formatter:off
+                CSVParser parser = CSVFormat.EXCEL.builder()
+                        .setHeader()
+                        .get()
+                        .parse(reader)) {
+            // @formatter:off
+            for (final CSVRecord record : parser) {
+                final String string = record.get("ColumnA");
+                assertEquals("A", string);
+            }
+        }
+    }
+
+}
diff --git a/src/test/java/org/apache/commons/csv/Utils.java b/src/test/java/org/apache/commons/csv/Utils.java
index 289083e7d4..5b5a05e043 100644
--- a/src/test/java/org/apache/commons/csv/Utils.java
+++ b/src/test/java/org/apache/commons/csv/Utils.java
@@ -1,19 +1,20 @@
 /*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.
+ *   https://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 org.apache.commons.csv;
@@ -21,6 +22,8 @@
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
 import java.util.List;
 
 /**
@@ -28,21 +31,37 @@
  */
 final class Utils {
 
-    private Utils() {
-    }
-
     /**
      * Checks if the 2d array has the same contents as the list of records.
      *
-     * @param message the message to be displayed
+     * @param message  the message to be displayed
      * @param expected the 2d array of expected results
-     * @param actual the List of {@link CSVRecord} entries, each containing an array of values
+     * @param actual   the List of {@link CSVRecord} entries, each containing an array of values
+     * @param maxRows  the maximum number of rows expected, less than or equal to zero means no limit.
      */
-    public static void compare(final String message, final String[][] expected, final List actual) {
-        final int expectedLength = expected.length;
+    public static void compare(final String message, final String[][] expected, final List actual, final long maxRows) {
+        final long expectedLength = maxRows > 0 ? Math.min(maxRows, expected.length) : expected.length;
         assertEquals(expectedLength, actual.size(), message + "  - outer array size");
         for (int i = 0; i < expectedLength; i++) {
             assertArrayEquals(expected[i], actual.get(i).values(), message + " (entry " + i + ")");
         }
     }
+
+    /**
+     * Creates an input stream, with or without a BOM.
+     */
+    static InputStream createUtf8Input(final byte[] baseData, final boolean addBom) {
+        byte[] data = baseData;
+        if (addBom) {
+            data = new byte[baseData.length + 3];
+            data[0] = (byte) 0xEF;
+            data[1] = (byte) 0xBB;
+            data[2] = (byte) 0xBF;
+            System.arraycopy(baseData, 0, data, 3, baseData.length);
+        }
+        return new ByteArrayInputStream(data);
+    }
+
+    private Utils() {
+    }
 }
diff --git a/src/test/java/org/apache/commons/csv/issues/JiraCsv148Test.java b/src/test/java/org/apache/commons/csv/issues/JiraCsv148Test.java
new file mode 100644
index 0000000000..67f1b785d5
--- /dev/null
+++ b/src/test/java/org/apache/commons/csv/issues/JiraCsv148Test.java
@@ -0,0 +1,63 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *
+ *   https://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 org.apache.commons.csv.issues;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.apache.commons.csv.CSVFormat;
+import org.apache.commons.csv.QuoteMode;
+import org.junit.jupiter.api.Test;
+
+class JiraCsv148Test {
+
+    @Test
+    void testWithIgnoreSurroundingSpacesEmpty() {
+        // @formatter:off
+        final CSVFormat format = CSVFormat.DEFAULT.builder()
+            .setQuoteMode(QuoteMode.ALL)
+            .setIgnoreSurroundingSpaces(true)
+            .get();
+        // @formatter:on
+        assertEquals(
+                "\"\",\" \",\" Single space on the left\",\"Single space on the right \"," +
+                        "\" Single spaces on both sides \",\"   Multiple spaces on the left\"," +
+                        "\"Multiple spaces on the right   \",\"  Multiple spaces on both sides     \"",
+                format.format("", " ", " Single space on the left", "Single space on the right ", " Single spaces on both sides ",
+                        "   Multiple spaces on the left", "Multiple spaces on the right   ", "  Multiple spaces on both sides     "));
+    }
+
+    /**
+     * The difference between withTrim()and withIgnoreSurroundingSpace()： difference: withTrim() can remove the leading and trailing spaces and newlines in
+     * quotation marks, while withIgnoreSurroundingSpace() cannot The same point: you can remove the leading and trailing spaces, tabs and other symbols.
+     */
+    @Test
+    void testWithTrimEmpty() {
+        // @formatter:off
+        final CSVFormat format = CSVFormat.DEFAULT.builder()
+            .setQuoteMode(QuoteMode.ALL)
+            .setTrim(true)
+            .get();
+        // @formatter:on
+        assertEquals(
+                "\"\",\"\",\"Single space on the left\",\"Single space on the right\",\"Single spaces on both sides\",\"Multiple spaces on the left\"," +
+                        "\"Multiple spaces on the right\",\"Multiple spaces on both sides\"",
+                format.format("", " ", " Single space on the left", "Single space on the right ", " Single spaces on both sides ",
+                        "   Multiple spaces on the left", "Multiple spaces on the right   ", "  Multiple spaces on both sides     "));
+    }
+}
diff --git a/src/test/java/org/apache/commons/csv/issues/JiraCsv149Test.java b/src/test/java/org/apache/commons/csv/issues/JiraCsv149Test.java
index 38394ba57d..b32e965665 100644
--- a/src/test/java/org/apache/commons/csv/issues/JiraCsv149Test.java
+++ b/src/test/java/org/apache/commons/csv/issues/JiraCsv149Test.java
@@ -1,22 +1,25 @@
 /*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *   https://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.
+ * 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 org.apache.commons.csv.issues;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 import java.io.IOException;
 import java.io.StringReader;
@@ -26,12 +29,12 @@
 import org.apache.commons.csv.CSVRecord;
 import org.junit.jupiter.api.Test;
 
-public class JiraCsv149Test {
+class JiraCsv149Test {
 
     private static final String CR_LF = "\r\n";
 
     @Test
-    public void testJiraCsv149EndWithEOL() throws IOException {
+    void testJiraCsv149EndWithEOL() throws IOException {
         testJiraCsv149EndWithEolAtEof(true);
     }
 
@@ -40,18 +43,25 @@ private void testJiraCsv149EndWithEolAtEof(final boolean eolAtEof) throws IOExce
         if (eolAtEof) {
             source += CR_LF;
         }
-        final StringReader records = new StringReader(source);
-        final CSVFormat format = CSVFormat.RFC4180.withFirstRecordAsHeader().withQuote('"');
+        final StringReader reader = new StringReader(source);
+        // @formatter:off
+        final CSVFormat format = CSVFormat.RFC4180.builder()
+            .setHeader()
+            .setSkipHeaderRecord(true)
+            .setQuote('"')
+            .get();
+        // @formatter:on
         int lineCounter = 2;
-        try (final CSVParser parser = new CSVParser(records, format)) {
+        try (CSVParser parser = CSVParser.builder().setReader(reader).setFormat(format).get()) {
             for (final CSVRecord record : parser) {
+                assertNotNull(record);
                 assertEquals(lineCounter++, parser.getCurrentLineNumber());
             }
         }
     }
 
     @Test
-    public void testJiraCsv149EndWithoutEOL() throws IOException {
+    void testJiraCsv149EndWithoutEOL() throws IOException {
         testJiraCsv149EndWithEolAtEof(false);
     }
 }
diff --git a/src/test/java/org/apache/commons/csv/issues/JiraCsv150Test.java b/src/test/java/org/apache/commons/csv/issues/JiraCsv150Test.java
new file mode 100644
index 0000000000..eec91d52d0
--- /dev/null
+++ b/src/test/java/org/apache/commons/csv/issues/JiraCsv150Test.java
@@ -0,0 +1,55 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *
+ *   https://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 org.apache.commons.csv.issues;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.io.IOException;
+import java.io.StringReader;
+
+import org.apache.commons.csv.CSVFormat;
+import org.apache.commons.csv.CSVParser;
+import org.junit.jupiter.api.Test;
+
+class JiraCsv150Test {
+
+    private void testDisable(final CSVFormat format, final StringReader reader) throws IOException {
+        try (CSVParser csvParser = CSVParser.builder().setReader(reader).setFormat(format).get()) {
+            assertEquals(1, csvParser.getRecords().size());
+        }
+    }
+
+    @Test
+    void testDisableComment() throws IOException {
+        final StringReader stringReader = new StringReader("\"66\u2441\",,\"\",\"DeutscheBK\ufffe\",\"000\"\r\n");
+        testDisable(CSVFormat.DEFAULT.builder().setCommentMarker(null).get(), stringReader);
+    }
+
+    @Test
+    void testDisableEncapsulation() throws IOException {
+        final StringReader stringReader = new StringReader("66\u2441,,\"\",\ufffeDeutscheBK,\"000\"\r\n");
+        testDisable(CSVFormat.DEFAULT.builder().setQuote(null).get(), stringReader);
+    }
+
+    @Test
+    void testDisableEscaping() throws IOException {
+        final StringReader stringReader = new StringReader("\"66\u2441\",,\"\",\"DeutscheBK\ufffe\",\"000\"\r\n");
+        testDisable(CSVFormat.DEFAULT.builder().setEscape(null).get(), stringReader);
+    }
+}
diff --git a/src/test/java/org/apache/commons/csv/issues/JiraCsv154Test.java b/src/test/java/org/apache/commons/csv/issues/JiraCsv154Test.java
index 9710bed91f..90d657fcd1 100644
--- a/src/test/java/org/apache/commons/csv/issues/JiraCsv154Test.java
+++ b/src/test/java/org/apache/commons/csv/issues/JiraCsv154Test.java
@@ -1,18 +1,20 @@
 /*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *   https://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.
+ * 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 org.apache.commons.csv.issues;
 
@@ -24,15 +26,20 @@
 import org.apache.commons.csv.CSVPrinter;
 import org.junit.jupiter.api.Test;
 
-public class JiraCsv154Test {
+class JiraCsv154Test {
 
     @Test
-    public void testJiraCsv154_withCommentMarker() throws IOException {
+    void testJiraCsv154_withCommentMarker() throws IOException {
         final String comment = "This is a header comment";
-        final CSVFormat format = CSVFormat.EXCEL.withHeader("H1", "H2").withCommentMarker('#')
-                .withHeaderComments(comment);
+        // @formatter:off
+        final CSVFormat format = CSVFormat.EXCEL.builder()
+            .setHeader("H1", "H2")
+            .setCommentMarker('#')
+            .setHeaderComments(comment)
+            .get();
+        // @formatter:on
         final StringBuilder out = new StringBuilder();
-        try (final CSVPrinter printer = format.print(out)) {
+        try (CSVPrinter printer = format.print(out)) {
             printer.print("A");
             printer.print("B");
         }
@@ -41,12 +48,17 @@ public void testJiraCsv154_withCommentMarker() throws IOException {
     }
 
     @Test
-    public void testJiraCsv154_withHeaderComments() throws IOException {
+    void testJiraCsv154_withHeaderComments() throws IOException {
         final String comment = "This is a header comment";
-        final CSVFormat format = CSVFormat.EXCEL.withHeader("H1", "H2").withHeaderComments(comment)
-                .withCommentMarker('#');
+        // @formatter:off
+        final CSVFormat format = CSVFormat.EXCEL.builder()
+            .setHeader("H1", "H2")
+            .setHeaderComments(comment)
+            .setCommentMarker('#')
+            .get();
+        // @formatter:on
         final StringBuilder out = new StringBuilder();
-        try (final CSVPrinter printer = format.print(out)) {
+        try (CSVPrinter printer = format.print(out)) {
             printer.print("A");
             printer.print("B");
         }
diff --git a/src/test/java/org/apache/commons/csv/issues/JiraCsv167Test.java b/src/test/java/org/apache/commons/csv/issues/JiraCsv167Test.java
index 5b8a20e542..607d0cf2a3 100644
--- a/src/test/java/org/apache/commons/csv/issues/JiraCsv167Test.java
+++ b/src/test/java/org/apache/commons/csv/issues/JiraCsv167Test.java
@@ -1,18 +1,20 @@
 /*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *   https://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.
+ * 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 org.apache.commons.csv.issues;
 
@@ -20,7 +22,6 @@
 
 import java.io.BufferedReader;
 import java.io.IOException;
-import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.Reader;
 
@@ -30,13 +31,18 @@
 import org.apache.commons.csv.QuoteMode;
 import org.junit.jupiter.api.Test;
 
-public class JiraCsv167Test {
+class JiraCsv167Test {
+
+    private Reader getTestReader() {
+        return new InputStreamReader(
+            ClassLoader.getSystemClassLoader().getResourceAsStream("org/apache/commons/csv/csv-167/sample1.csv"));
+    }
 
     @Test
-    public void parse() throws IOException {
+    void testParse() throws IOException {
         int totcomment = 0;
         int totrecs = 0;
-        try (final BufferedReader br = new BufferedReader(getTestInput())) {
+        try (Reader reader = getTestReader(); BufferedReader br = new BufferedReader(reader)) {
             String s = null;
             boolean lastWasComment = false;
             while ((s = br.readLine()) != null) {
@@ -51,25 +57,26 @@ public void parse() throws IOException {
                 }
             }
         }
-        CSVFormat format = CSVFormat.DEFAULT;
-        //
-        format = format.withAllowMissingColumnNames(false);
-        format = format.withCommentMarker('#');
-        format = format.withDelimiter(',');
-        format = format.withEscape('\\');
-        format = format.withHeader("author", "title", "publishDate");
-        format = format.withHeaderComments("headerComment");
-        format = format.withNullString("NULL");
-        format = format.withIgnoreEmptyLines(true);
-        format = format.withIgnoreSurroundingSpaces(true);
-        format = format.withQuote('"');
-        format = format.withQuoteMode(QuoteMode.ALL);
-        format = format.withRecordSeparator('\n');
-        format = format.withSkipHeaderRecord(false);
-        //
+        final CSVFormat format = CSVFormat.DEFAULT.builder()
+        // @formatter:off
+            .setAllowMissingColumnNames(false)
+            .setCommentMarker('#')
+            .setDelimiter(',')
+            .setEscape('\\')
+            .setHeader("author", "title", "publishDate")
+            .setHeaderComments("headerComment")
+            .setNullString("NULL")
+            .setIgnoreEmptyLines(true)
+            .setIgnoreSurroundingSpaces(true)
+            .setQuote('"')
+            .setQuoteMode(QuoteMode.ALL)
+            .setRecordSeparator('\n')
+            .setSkipHeaderRecord(false)
+            .get();
+        // @formatter:on
         int comments = 0;
         int records = 0;
-        try (final CSVParser parser = format.parse(getTestInput())) {
+        try (Reader reader = getTestReader(); CSVParser parser = format.parse(reader)) {
             for (final CSVRecord csvRecord : parser) {
                 records++;
                 if (csvRecord.hasComment()) {
@@ -81,9 +88,4 @@ public void parse() throws IOException {
         assertEquals(totcomment, comments);
         assertEquals(totrecs, records); // records includes the header
     }
-
-    private Reader getTestInput() {
-        final InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("org/apache/commons/csv/csv-167/sample1.csv");
-        return new InputStreamReader(is);
-    }
 }
diff --git a/src/test/java/org/apache/commons/csv/issues/JiraCsv198Test.java b/src/test/java/org/apache/commons/csv/issues/JiraCsv198Test.java
index 8e73447b3e..1117c12ac9 100644
--- a/src/test/java/org/apache/commons/csv/issues/JiraCsv198Test.java
+++ b/src/test/java/org/apache/commons/csv/issues/JiraCsv198Test.java
@@ -1,19 +1,22 @@
 /*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *   https://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.
+ * 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 org.apache.commons.csv.issues;
 
 import static org.junit.jupiter.api.Assertions.assertNotNull;
@@ -26,24 +29,26 @@
 
 import org.apache.commons.csv.CSVFormat;
 import org.apache.commons.csv.CSVParser;
-import org.apache.commons.csv.CSVRecord;
 import org.junit.jupiter.api.Test;
 
-public class JiraCsv198Test {
+class JiraCsv198Test {
 
-    private static final CSVFormat CSV_FORMAT = CSVFormat.EXCEL.withDelimiter('^').withFirstRecordAsHeader();
+    // @formatter:off
+    private static final CSVFormat CSV_FORMAT = CSVFormat.EXCEL.builder()
+        .setDelimiter('^')
+        .setHeader()
+        .setSkipHeaderRecord(true)
+        .get();
+    // @formatter:on
 
     @Test
-    public void test() throws UnsupportedEncodingException, IOException {
+    void test() throws UnsupportedEncodingException, IOException {
         final InputStream pointsOfReference = getClass().getResourceAsStream("/org/apache/commons/csv/CSV-198/optd_por_public.csv");
         assertNotNull(pointsOfReference);
         try (@SuppressWarnings("resource")
         CSVParser parser = CSV_FORMAT.parse(new InputStreamReader(pointsOfReference, StandardCharsets.UTF_8))) {
-            for (final CSVRecord record : parser) {
-                final String locationType = record.get("location_type");
-                assertNotNull(locationType);
-            }
+            parser.forEach(record -> assertNotNull(record.get("location_type")));
         }
     }
 
-}
\ No newline at end of file
+}
diff --git a/src/test/java/org/apache/commons/csv/issues/JiraCsv203Test.java b/src/test/java/org/apache/commons/csv/issues/JiraCsv203Test.java
index 9c887bd11a..2c9226506c 100644
--- a/src/test/java/org/apache/commons/csv/issues/JiraCsv203Test.java
+++ b/src/test/java/org/apache/commons/csv/issues/JiraCsv203Test.java
@@ -1,18 +1,20 @@
 /*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *   https://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.
+ * 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 org.apache.commons.csv.issues;
 
@@ -24,105 +26,120 @@
 import org.junit.jupiter.api.Test;
 
 /**
- * JIRA: withNullString value is printed without quotes when QuoteMode.ALL is specified
+ * JIRA: withNullString value is printed without quotes when
+ * QuoteMode.ALL is specified
  */
-public class JiraCsv203Test {
+class JiraCsv203Test {
 
     @Test
-    public void testQuoteModeAll() throws Exception {
-        final CSVFormat format = CSVFormat.EXCEL
-                .withNullString("N/A")
-                .withIgnoreSurroundingSpaces(true)
-                .withQuoteMode(QuoteMode.ALL);
-
-        final StringBuffer buffer = new StringBuffer();
-        try (final CSVPrinter printer = new CSVPrinter(buffer, format)) {
+    void testQuoteModeAll() throws Exception {
+        // @formatter:off
+        final CSVFormat format = CSVFormat.EXCEL.builder()
+                .setNullString("N/A")
+                .setIgnoreSurroundingSpaces(true)
+                .setQuoteMode(QuoteMode.ALL)
+                .get();
+        // @formatter:on
+        final StringBuilder buffer = new StringBuilder();
+        try (CSVPrinter printer = new CSVPrinter(buffer, format)) {
             printer.printRecord(null, "Hello", null, "World");
         }
         assertEquals("\"N/A\",\"Hello\",\"N/A\",\"World\"\r\n", buffer.toString());
     }
 
     @Test
-    public void testQuoteModeAllNonNull() throws Exception {
-        final CSVFormat format = CSVFormat.EXCEL
-                .withNullString("N/A")
-                .withIgnoreSurroundingSpaces(true)
-                .withQuoteMode(QuoteMode.ALL_NON_NULL);
-
-        final StringBuffer buffer = new StringBuffer();
-        try (final CSVPrinter printer = new CSVPrinter(buffer, format)) {
+    void testQuoteModeAllNonNull() throws Exception {
+        // @formatter:off
+        final CSVFormat format = CSVFormat.EXCEL.builder()
+                .setNullString("N/A")
+                .setIgnoreSurroundingSpaces(true)
+                .setQuoteMode(QuoteMode.ALL_NON_NULL)
+                .get();
+        // @formatter:on
+        final StringBuilder buffer = new StringBuilder();
+        try (CSVPrinter printer = new CSVPrinter(buffer, format)) {
             printer.printRecord(null, "Hello", null, "World");
         }
         assertEquals("N/A,\"Hello\",N/A,\"World\"\r\n", buffer.toString());
     }
 
     @Test
-    public void testWithoutQuoteMode() throws Exception {
-        final CSVFormat format = CSVFormat.EXCEL
-                .withNullString("N/A")
-                .withIgnoreSurroundingSpaces(true);
-
-        final StringBuffer buffer = new StringBuffer();
-        try (final CSVPrinter printer = new CSVPrinter(buffer, format)) {
+    void testQuoteModeMinimal() throws Exception {
+        // @formatter:off
+        final CSVFormat format = CSVFormat.EXCEL.builder()
+                .setNullString("N/A")
+                .setIgnoreSurroundingSpaces(true)
+                .setQuoteMode(QuoteMode.MINIMAL)
+                .get();
+        // @formatter:on
+        final StringBuilder buffer = new StringBuilder();
+        try (CSVPrinter printer = new CSVPrinter(buffer, format)) {
             printer.printRecord(null, "Hello", null, "World");
         }
         assertEquals("N/A,Hello,N/A,World\r\n", buffer.toString());
     }
 
     @Test
-    public void testQuoteModeMinimal() throws Exception {
-        final CSVFormat format = CSVFormat.EXCEL
-                .withNullString("N/A")
-                .withIgnoreSurroundingSpaces(true)
-                .withQuoteMode(QuoteMode.MINIMAL);
-
-        final StringBuffer buffer = new StringBuffer();
-        try (final CSVPrinter printer = new CSVPrinter(buffer, format)) {
+    void testQuoteModeNonNumeric() throws Exception {
+        // @formatter:off
+        final CSVFormat format = CSVFormat.EXCEL.builder()
+                .setNullString("N/A")
+                .setIgnoreSurroundingSpaces(true)
+                .setQuoteMode(QuoteMode.NON_NUMERIC)
+                .get();
+        // @formatter:on
+        final StringBuilder buffer = new StringBuilder();
+        try (CSVPrinter printer = new CSVPrinter(buffer, format)) {
             printer.printRecord(null, "Hello", null, "World");
         }
-        assertEquals("N/A,Hello,N/A,World\r\n", buffer.toString());
+        assertEquals("N/A,\"Hello\",N/A,\"World\"\r\n", buffer.toString());
     }
 
     @Test
-    public void testQuoteModeNonNumeric() throws Exception {
-        final CSVFormat format = CSVFormat.EXCEL
-                .withNullString("N/A")
-                .withIgnoreSurroundingSpaces(true)
-                .withQuoteMode(QuoteMode.NON_NUMERIC);
-
-        final StringBuffer buffer = new StringBuffer();
-        try (final CSVPrinter printer = new CSVPrinter(buffer, format)) {
-            printer.printRecord(null, "Hello", null, "World");
+    void testWithEmptyValues() throws Exception {
+        // @formatter:off
+        final CSVFormat format = CSVFormat.EXCEL.builder()
+                .setNullString("N/A")
+                .setIgnoreSurroundingSpaces(true)
+                .setQuoteMode(QuoteMode.ALL)
+                .get();
+        // @formatter:on
+        final StringBuilder buffer = new StringBuilder();
+        try (CSVPrinter printer = new CSVPrinter(buffer, format)) {
+            printer.printRecord("", "Hello", "", "World");
+            // printer.printRecord(new Object[] { null, "Hello", null, "World" });
         }
-        assertEquals("N/A,\"Hello\",N/A,\"World\"\r\n", buffer.toString());
+        assertEquals("\"\",\"Hello\",\"\",\"World\"\r\n", buffer.toString());
     }
 
     @Test
-    public void testWithoutNullString() throws Exception {
-        final CSVFormat format = CSVFormat.EXCEL
-                //.withNullString("N/A")
-                .withIgnoreSurroundingSpaces(true)
-                .withQuoteMode(QuoteMode.ALL);
-
-        final StringBuffer buffer = new StringBuffer();
-        try (final CSVPrinter printer = new CSVPrinter(buffer, format)) {
+    void testWithoutNullString() throws Exception {
+        // @formatter:off
+        final CSVFormat format = CSVFormat.EXCEL.builder()
+                //.setNullString("N/A")
+                .setIgnoreSurroundingSpaces(true)
+                .setQuoteMode(QuoteMode.ALL)
+                .get();
+        // @formatter:on
+        final StringBuilder buffer = new StringBuilder();
+        try (CSVPrinter printer = new CSVPrinter(buffer, format)) {
             printer.printRecord(null, "Hello", null, "World");
         }
         assertEquals(",\"Hello\",,\"World\"\r\n", buffer.toString());
     }
 
     @Test
-    public void testWithEmptyValues() throws Exception {
-        final CSVFormat format = CSVFormat.EXCEL
-                .withNullString("N/A")
-                .withIgnoreSurroundingSpaces(true)
-                .withQuoteMode(QuoteMode.ALL);
-
-        final StringBuffer buffer = new StringBuffer();
-        try (final CSVPrinter printer = new CSVPrinter(buffer, format)) {
-            printer.printRecord("", "Hello", "", "World");
-            //printer.printRecord(new Object[] { null, "Hello", null, "World" });
+    void testWithoutQuoteMode() throws Exception {
+        // @formatter:off
+        final CSVFormat format = CSVFormat.EXCEL.builder()
+                .setNullString("N/A")
+                .setIgnoreSurroundingSpaces(true)
+                .get();
+        // @formatter:on
+        final StringBuilder buffer = new StringBuilder();
+        try (CSVPrinter printer = new CSVPrinter(buffer, format)) {
+            printer.printRecord(null, "Hello", null, "World");
         }
-        assertEquals("\"\",\"Hello\",\"\",\"World\"\r\n", buffer.toString());
+        assertEquals("N/A,Hello,N/A,World\r\n", buffer.toString());
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/java/org/apache/commons/csv/issues/JiraCsv206Test.java b/src/test/java/org/apache/commons/csv/issues/JiraCsv206Test.java
new file mode 100644
index 0000000000..2fecd10f16
--- /dev/null
+++ b/src/test/java/org/apache/commons/csv/issues/JiraCsv206Test.java
@@ -0,0 +1,76 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *
+ *   https://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 org.apache.commons.csv.issues;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.io.IOException;
+import java.io.StringReader;
+import java.util.Iterator;
+
+import org.apache.commons.csv.CSVFormat;
+import org.apache.commons.csv.CSVParser;
+import org.apache.commons.csv.CSVPrinter;
+import org.apache.commons.csv.CSVRecord;
+import org.junit.jupiter.api.Test;
+
+class JiraCsv206Test {
+
+    @Test
+    void testJiraCsv206MultipleCharacterDelimiter() throws IOException {
+        // Read with multiple character delimiter
+        final String source = "FirstName[|]LastName[|]Address\r\nJohn[|]Smith[|]123 Main St.";
+        final StringReader reader = new StringReader(source);
+        final CSVFormat format = CSVFormat.DEFAULT.builder().setDelimiter("[|]").get();
+        CSVRecord record = null;
+        try (CSVParser csvParser = CSVParser.builder().setReader(reader).setFormat(format).get()) {
+            final Iterator iterator = csvParser.iterator();
+            record = iterator.next();
+            assertEquals("FirstName", record.get(0));
+            assertEquals("LastName", record.get(1));
+            assertEquals("Address", record.get(2));
+            record = iterator.next();
+            assertEquals("John", record.get(0));
+            assertEquals("Smith", record.get(1));
+            assertEquals("123 Main St.", record.get(2));
+        }
+        // Write with multiple character delimiter
+        // @formatter:off
+        final String outString =
+                "# Change delimiter to [I]\r\n" +
+                "first name[I]last name[I]address\r\n" +
+                "John[I]Smith[I]123 Main St.";
+        // @formatter:on
+        final String comment = "Change delimiter to [I]";
+        // @formatter:off
+        final CSVFormat formatExcel = CSVFormat.EXCEL.builder()
+                .setDelimiter("[I]").setHeader("first name", "last name", "address")
+                .setCommentMarker('#')
+                .setHeaderComments(comment).get();
+        // @formatter:on
+        final StringBuilder out = new StringBuilder();
+        try (CSVPrinter printer = formatExcel.print(out)) {
+            printer.print(record.get(0));
+            printer.print(record.get(1));
+            printer.print(record.get(2));
+        }
+        final String s = out.toString();
+        assertEquals(outString, s);
+    }
+}
diff --git a/src/test/java/org/apache/commons/csv/issues/JiraCsv211Test.java b/src/test/java/org/apache/commons/csv/issues/JiraCsv211Test.java
index d341c2520f..28b559d1e1 100644
--- a/src/test/java/org/apache/commons/csv/issues/JiraCsv211Test.java
+++ b/src/test/java/org/apache/commons/csv/issues/JiraCsv211Test.java
@@ -1,48 +1,54 @@
 /*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *   https://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.
+ * 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 org.apache.commons.csv.issues;
 
-import org.apache.commons.csv.CSVFormat;
-import org.apache.commons.csv.CSVParser;
-import org.apache.commons.csv.CSVRecord;
-import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 import java.io.IOException;
 import java.io.StringReader;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import org.apache.commons.csv.CSVFormat;
+import org.apache.commons.csv.CSVParser;
+import org.junit.jupiter.api.Test;
 
-public class JiraCsv211Test {
+class JiraCsv211Test {
 
     @Test
-    public void testJiraCsv211Format() throws IOException {
-        final String[] values = new String[] { "1", "Jane Doe", "USA", "" };
-
-        final CSVFormat printFormat = CSVFormat.DEFAULT.withDelimiter('\t').withHeader("ID", "Name", "Country", "Age");
-        final String formatted = printFormat.format(values);
+    void testJiraCsv211Format() throws IOException {
+        // @formatter:off
+        final CSVFormat printFormat = CSVFormat.DEFAULT.builder()
+            .setDelimiter('\t')
+            .setHeader("ID", "Name", "Country", "Age")
+            .get();
+        // @formatter:on
+        final String formatted = printFormat.format("1", "Jane Doe", "USA", "");
         assertEquals("ID\tName\tCountry\tAge\r\n1\tJane Doe\tUSA\t", formatted);
 
-        final CSVFormat parseFormat = CSVFormat.DEFAULT.withDelimiter('\t').withFirstRecordAsHeader();
-        final CSVParser parser = parseFormat.parse(new StringReader(formatted));
-        for (final CSVRecord record : parser) {
-            assertEquals("1", record.get(0));
-            assertEquals("Jane Doe", record.get(1));
-            assertEquals("USA", record.get(2));
-            assertEquals("", record.get(3));
+        final CSVFormat parseFormat = CSVFormat.DEFAULT.builder().setDelimiter('\t').setHeader().setSkipHeaderRecord(true).get();
+        try (CSVParser parser = parseFormat.parse(new StringReader(formatted))) {
+            parser.forEach(record -> {
+                assertEquals("1", record.get(0));
+                assertEquals("Jane Doe", record.get(1));
+                assertEquals("USA", record.get(2));
+                assertEquals("", record.get(3));
+            });
         }
     }
 }
diff --git a/src/test/java/org/apache/commons/csv/issues/JiraCsv213Test.java b/src/test/java/org/apache/commons/csv/issues/JiraCsv213Test.java
index ada58b79ad..90f5da4c5a 100644
--- a/src/test/java/org/apache/commons/csv/issues/JiraCsv213Test.java
+++ b/src/test/java/org/apache/commons/csv/issues/JiraCsv213Test.java
@@ -1,55 +1,57 @@
 /*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *   https://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.
+ * 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 org.apache.commons.csv.issues;
 
 import java.io.File;
-import java.io.FileInputStream;
 import java.io.IOException;
-import java.io.InputStreamReader;
+import java.io.Reader;
 import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
 
 import org.apache.commons.csv.CSVFormat;
 import org.apache.commons.csv.CSVParser;
 import org.apache.commons.csv.QuoteMode;
-import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 
 /**
  * Tests https://issues.apache.org/jira/browse/CSV-213
- *
+ * 

  * This is normal behavior with the current architecture: The iterator() API presents an object that is backed by data
  * in the CSVParser as the parser is streaming over the file. The CSVParser is like a forward-only stream. When you
  * create a new Iterator you are only created a new view on the same position in the parser's stream. For the behavior
  * you want, you need to open a new CSVParser.
+ * 
  */
-@Disabled
-public class JiraCsv213Test {
+class JiraCsv213Test {
 
     private void createEndChannel(final File csvFile) {
         // @formatter:off
-        final CSVFormat csvFormat =
-                CSVFormat.DEFAULT
-                    .withDelimiter(';')
-                    .withFirstRecordAsHeader()
-                    .withRecordSeparator('\n')
-                    .withQuoteMode(QuoteMode.ALL);
+        final CSVFormat csvFormat = CSVFormat.DEFAULT.builder()
+                    .setDelimiter(';')
+                    .setHeader()
+                    .setSkipHeaderRecord(true)
+                    .setRecordSeparator('\n')
+                    .setQuoteMode(QuoteMode.ALL)
+                    .get();
         // @formatter:on
-        try (CSVParser parser = csvFormat
-                .parse(new InputStreamReader(new FileInputStream(csvFile), StandardCharsets.UTF_8))) {
+        try (Reader reader = Files.newBufferedReader(csvFile.toPath(), StandardCharsets.UTF_8);
+            CSVParser parser = csvFormat.parse(reader)) {
             if (parser.iterator().hasNext()) {
                 // System.out.println(parser.getCurrentLineNumber());
                 // System.out.println(parser.getRecordNumber());
@@ -62,7 +64,7 @@ private void createEndChannel(final File csvFile) {
     }
 
     @Test
-    public void test() {
-        createEndChannel(new File("src/test/resources/CSV-213/999751170.patch.csv"));
+    void test() {
+        createEndChannel(new File("src/test/resources/org/apache/commons/csv/CSV-213/999751170.patch.csv"));
     }
 }
diff --git a/src/test/java/org/apache/commons/csv/issues/JiraCsv227Test.java b/src/test/java/org/apache/commons/csv/issues/JiraCsv227Test.java
new file mode 100644
index 0000000000..2b9e335a8f
--- /dev/null
+++ b/src/test/java/org/apache/commons/csv/issues/JiraCsv227Test.java
@@ -0,0 +1,49 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *
+ *   https://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 org.apache.commons.csv.issues;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.io.IOException;
+
+import org.apache.commons.csv.CSVFormat;
+import org.apache.commons.csv.CSVPrinter;
+import org.apache.commons.csv.QuoteMode;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Tests https://issues.apache.org/jira/browse/CSV-227
+ */
+class JiraCsv227Test {
+
+    @Test
+    public void test() throws IOException {
+        final StringBuilder out = new StringBuilder();
+        try (CSVPrinter printer = new CSVPrinter(out, CSVFormat.DEFAULT.withQuoteMode(QuoteMode.MINIMAL))) {
+            printer.printRecord("ㅁㅎㄷㄹ", "ㅁㅎㄷㄹ", "", "test2");
+            printer.printRecord("한글3", "hello3", "3한글3", "test3");
+            printer.printRecord("", "hello4", "", "test4");
+        }
+        // ㅁㅎㄷㄹ,ㅁㅎㄷㄹ,,test2
+        // 한글3,hello3,3한글3,test3
+        // "",hello4,,test4
+        assertEquals("ㅁㅎㄷㄹ,ㅁㅎㄷㄹ,,test2\r\n한글3,hello3,3한글3,test3\r\n\"\",hello4,,test4\r\n", out.toString());
+    }
+}
diff --git a/src/test/java/org/apache/commons/csv/issues/JiraCsv247Test.java b/src/test/java/org/apache/commons/csv/issues/JiraCsv247Test.java
index daa66be54a..c2d9ac5910 100644
--- a/src/test/java/org/apache/commons/csv/issues/JiraCsv247Test.java
+++ b/src/test/java/org/apache/commons/csv/issues/JiraCsv247Test.java
@@ -1,18 +1,20 @@
 /*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *   https://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.
+ * 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 org.apache.commons.csv.issues;
@@ -32,17 +34,16 @@
 import org.apache.commons.csv.CSVRecord;
 import org.junit.jupiter.api.Test;
 
-public class JiraCsv247Test {
+class JiraCsv247Test {
 
     @Test
-    public void testHeadersMissingOneColumnWhenAllowingMissingColumnNames() throws Exception {
-        final CSVFormat format = CSVFormat.DEFAULT.withHeader().withAllowMissingColumnNames(true);
+    void testHeadersMissingOneColumnWhenAllowingMissingColumnNames() throws Exception {
+        final CSVFormat format = CSVFormat.DEFAULT.builder().setHeader().setAllowMissingColumnNames(true).get();
 
-        assertTrue(format.getAllowMissingColumnNames(),
-            "We should allow missing column names");
+        assertTrue(format.getAllowMissingColumnNames(), "We should allow missing column names");
 
         final Reader in = new StringReader("a,,c,d,e\n1,2,3,4,5\nv,w,x,y,z");
-        try (final CSVParser parser = format.parse(in)) {
+        try (CSVParser parser = format.parse(in)) {
             assertEquals(Arrays.asList("a", "", "c", "d", "e"), parser.getHeaderNames());
             final Iterator iterator = parser.iterator();
             CSVRecord record = iterator.next();
@@ -62,20 +63,23 @@ record = iterator.next();
     }
 
     @Test
-    public void testHeadersMissingThrowsWhenNotAllowingMissingColumnNames() throws Exception {
-        final CSVFormat format = CSVFormat.DEFAULT.withHeader();
+    void testHeadersMissingThrowsWhenNotAllowingMissingColumnNames() {
+        final CSVFormat format = CSVFormat.DEFAULT.builder().setHeader().get();
 
-        assertFalse(format.getAllowMissingColumnNames(),
-            "By default we should not allow missing column names");
+        assertFalse(format.getAllowMissingColumnNames(), "By default we should not allow missing column names");
 
         assertThrows(IllegalArgumentException.class, () -> {
-            final Reader in = new StringReader("a,,c,d,e\n1,2,3,4,5\nv,w,x,y,z");
-            format.parse(in);
+            try (Reader reader = new StringReader("a,,c,d,e\n1,2,3,4,5\nv,w,x,y,z");
+                CSVParser parser = format.parse(reader);) {
+                // should fail
+            }
         }, "1 missing column header is not allowed");
 
         assertThrows(IllegalArgumentException.class, () -> {
-            final Reader in = new StringReader("a,,c,d,\n1,2,3,4,5\nv,w,x,y,z");
-            format.parse(in);
+            try (Reader reader = new StringReader("a,,c,d,\n1,2,3,4,5\nv,w,x,y,z");
+                CSVParser parser = format.parse(reader);) {
+                // should fail
+            }
         }, "2+ missing column headers is not allowed!");
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/java/org/apache/commons/csv/issues/JiraCsv248Test.java b/src/test/java/org/apache/commons/csv/issues/JiraCsv248Test.java
index 7b53b75878..480a9dffa9 100644
--- a/src/test/java/org/apache/commons/csv/issues/JiraCsv248Test.java
+++ b/src/test/java/org/apache/commons/csv/issues/JiraCsv248Test.java
@@ -1,54 +1,64 @@
 /*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *   https://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.
+ * 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 org.apache.commons.csv.issues;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
 import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
-import org.apache.commons.csv.CSVRecord;
-import org.junit.jupiter.api.Test;
-
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.ObjectInputStream;
 
-public class JiraCsv248Test {
+import org.apache.commons.csv.CSVRecord;
+import org.junit.jupiter.api.Test;
+
+class JiraCsv248Test {
+
+    private static InputStream getTestInput() {
+        return ClassLoader.getSystemClassLoader().getResourceAsStream("org/apache/commons/csv/CSV-248/csvRecord.bin");
+    }
+
     /**
-     * Test deserialisation of a CSVRecord created using version 1.6.
+     * Test deserialization of a CSVRecord created using version 1.6.
      *
-     * 
This test asserts that serialization from 1.8 onwards is consistent with
-     * previous versions. Serialization was broken in version 1.7.
+     * 

+     * This test asserts that serialization from 1.8 onwards is consistent with previous versions. Serialization was
+     * broken in version 1.7.
      *
      * @throws IOException Signals that an I/O exception has occurred.
      * @throws ClassNotFoundException If the CSVRecord cannot be deserialized
      */
     @Test
-    public void testJiraCsv248() throws IOException, ClassNotFoundException {
+    void testJiraCsv248() throws IOException, ClassNotFoundException {
         // Record was originally created using CSV version 1.6 with the following code:
-        //try (final CSVParser parser = CSVParser.parse("A,B\n#my comment\nOne,Two", CSVFormat.DEFAULT.withHeader().withCommentMarker('#'))) {
-        //    CSVRecord rec = parser.iterator().next();
-        //}
-        try (InputStream in = getTestInput();
-             final ObjectInputStream ois = new ObjectInputStream(in)) {
+        // try (CSVParser parser = CSVParser.parse("A,B\n#my comment\nOne,Two",
+        // CSVFormat.DEFAULT.builder().setHeader().setCommentMarker('#'))) {
+        // CSVRecord rec = parser.iterator().next();
+        // }
+        try (InputStream in = getTestInput(); ObjectInputStream ois = new ObjectInputStream(in)) {
             final Object object = ois.readObject();
-            assertTrue(object instanceof CSVRecord);
+            assertInstanceOf(CSVRecord.class, object);
             final CSVRecord rec = (CSVRecord) object;
             assertEquals(1L, rec.getRecordNumber());
             assertEquals("One", rec.get(0));
@@ -65,16 +75,7 @@ public void testJiraCsv248() throws IOException, ClassNotFoundException {
             assertFalse(rec.isSet("A"));
             assertEquals(0, rec.toMap().size());
             // This will throw
-            try {
-                rec.get("A");
-                org.junit.jupiter.api.Assertions.fail("Access by name is not expected after deserialisation");
-            } catch (final IllegalStateException expected) {
-                // OK
-            }
+            assertThrows(IllegalStateException.class, () -> rec.get("A"));
         }
     }
-
-    private static InputStream getTestInput() {
-        return ClassLoader.getSystemClassLoader().getResourceAsStream("org/apache/commons/csv/CSV-248/csvRecord.bin");
-    }
 }
diff --git a/src/test/java/org/apache/commons/csv/issues/JiraCsv249Test.java b/src/test/java/org/apache/commons/csv/issues/JiraCsv249Test.java
index 5ba838ca9c..4034b04bd7 100644
--- a/src/test/java/org/apache/commons/csv/issues/JiraCsv249Test.java
+++ b/src/test/java/org/apache/commons/csv/issues/JiraCsv249Test.java
@@ -1,18 +1,20 @@
 /*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *   https://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.
+ * 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 org.apache.commons.csv.issues;
@@ -30,18 +32,18 @@
 import org.apache.commons.csv.CSVRecord;
 import org.junit.jupiter.api.Test;
 
-public class JiraCsv249Test {
+class JiraCsv249Test {
 
     @Test
-    public void testJiraCsv249() throws IOException {
-        final CSVFormat csvFormat = CSVFormat.DEFAULT.withEscape('\\');
+    void testJiraCsv249() throws IOException {
+        final CSVFormat format = CSVFormat.DEFAULT.builder().setEscape('\\').get();
         final StringWriter stringWriter = new StringWriter();
-        try (CSVPrinter printer = new CSVPrinter(stringWriter, csvFormat)) {
+        try (CSVPrinter printer = new CSVPrinter(stringWriter, format)) {
             printer.printRecord("foo \\", "bar");
         }
-        final StringReader stringReader = new StringReader(stringWriter.toString());
+        final StringReader reader = new StringReader(stringWriter.toString());
         final List records;
-        try (CSVParser parser = new CSVParser(stringReader, csvFormat)) {
+        try (CSVParser parser = CSVParser.builder().setReader(reader).setFormat(format).get()) {
             records = parser.getRecords();
         }
         records.forEach(record -> {
@@ -50,4 +52,4 @@ public void testJiraCsv249() throws IOException {
         });
 
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/java/org/apache/commons/csv/issues/JiraCsv253Test.java b/src/test/java/org/apache/commons/csv/issues/JiraCsv253Test.java
new file mode 100644
index 0000000000..13bb6a8270
--- /dev/null
+++ b/src/test/java/org/apache/commons/csv/issues/JiraCsv253Test.java
@@ -0,0 +1,56 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *
+ *   https://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 org.apache.commons.csv.issues;
+
+import static org.apache.commons.csv.CsvAssertions.assertValuesEquals;
+
+import java.io.IOException;
+import java.io.StringReader;
+import java.util.Iterator;
+
+import org.apache.commons.csv.CSVFormat;
+import org.apache.commons.csv.CSVParser;
+import org.apache.commons.csv.CSVRecord;
+import org.apache.commons.csv.QuoteMode;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Setting QuoteMode:ALL_NON_NULL or NON_NUMERIC can distinguish between empty string columns and absent value columns.
+ */
+class JiraCsv253Test {
+
+    @Test
+    void testHandleAbsentValues() throws IOException {
+        // @formatter:off
+        final String source =
+                "\"John\",,\"Doe\"\n" +
+                ",\"AA\",123\n" +
+                "\"John\",90,\n" +
+                "\"\",,90";
+        // @formatter:on
+        final CSVFormat csvFormat = CSVFormat.DEFAULT.builder().setQuoteMode(QuoteMode.NON_NUMERIC).get();
+        try (CSVParser parser = csvFormat.parse(new StringReader(source))) {
+            final Iterator csvRecords = parser.iterator();
+            assertValuesEquals(new String[] {"John", null, "Doe"}, csvRecords.next());
+            assertValuesEquals(new String[] {null, "AA", "123"}, csvRecords.next());
+            assertValuesEquals(new String[] {"John", "90", null}, csvRecords.next());
+            assertValuesEquals(new String[] {"", null, "90"}, csvRecords.next());
+        }
+    }
+}
diff --git a/src/test/java/org/apache/commons/csv/issues/JiraCsv254Test.java b/src/test/java/org/apache/commons/csv/issues/JiraCsv254Test.java
new file mode 100644
index 0000000000..629b42ee6b
--- /dev/null
+++ b/src/test/java/org/apache/commons/csv/issues/JiraCsv254Test.java
@@ -0,0 +1,52 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *
+ *   https://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 org.apache.commons.csv.issues;
+
+import static org.apache.commons.csv.CsvAssertions.assertValuesEquals;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.Iterator;
+
+import org.apache.commons.csv.CSVFormat;
+import org.apache.commons.csv.CSVParser;
+import org.apache.commons.csv.CSVRecord;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Tests https://issues.apache.org/jira/browse/CSV-254.
+ */
+class JiraCsv254Test {
+
+    @Test
+    void test() throws IOException {
+        final CSVFormat csvFormat = CSVFormat.POSTGRESQL_CSV;
+        try (BufferedReader reader = Files.newBufferedReader(Paths.get("src/test/resources/org/apache/commons/csv/CSV-254/csv-254.csv"),
+                StandardCharsets.UTF_8); CSVParser parser = csvFormat.parse(reader)) {
+            final Iterator csvRecords = parser.iterator();
+            assertValuesEquals(new String[] { "AA", "33", null }, csvRecords.next());
+            assertValuesEquals(new String[] { "AA", null, "" }, csvRecords.next());
+            assertValuesEquals(new String[] { null, "33", "CC" }, csvRecords.next());
+        }
+    }
+}
diff --git a/src/test/java/org/apache/commons/csv/issues/JiraCsv257Test.java b/src/test/java/org/apache/commons/csv/issues/JiraCsv257Test.java
new file mode 100644
index 0000000000..4234a7a0fa
--- /dev/null
+++ b/src/test/java/org/apache/commons/csv/issues/JiraCsv257Test.java
@@ -0,0 +1,84 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *
+ *   https://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 org.apache.commons.csv.issues;
+
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.io.IOException;
+import java.io.StringReader;
+
+import org.apache.commons.csv.CSVFormat;
+import org.apache.commons.csv.CSVParser;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Tests https://issues.apache.org/jira/browse/CSV-257
+ */
+class JiraCsv257Test {
+
+    private static final String INPUT = ",";
+
+    @Test
+    void testHeaderBuilder() throws IOException {
+        // @formatter:off
+        final CSVFormat format = CSVFormat.RFC4180.builder()
+                .setDelimiter(INPUT.charAt(0))
+                .setHeader()
+                .setSkipHeaderRecord(true)
+                .setIgnoreSurroundingSpaces(true)
+                .get();
+        // @formatter:on
+        // Document the current behavior: Throw a IllegalArgumentException is a header name is missing.
+        assertThrows(IllegalArgumentException.class, () -> {
+            try (CSVParser parser = CSVParser.parse(INPUT, format)) {
+                // empty
+            }
+        });
+    }
+
+    @Test
+    void testHeaderDepreacted() throws IOException {
+        // @formatter:off
+        final CSVFormat format = CSVFormat.RFC4180
+                .withDelimiter(INPUT.charAt(0))
+                .withFirstRecordAsHeader()
+                .withIgnoreSurroundingSpaces();
+        // @formatter:on
+        // Document the current behavior: Throw a IllegalArgumentException is a header name is missing.
+        assertThrows(IllegalArgumentException.class, () -> {
+            try (CSVParser parser = new CSVParser(new StringReader(INPUT), format)) {
+                // empty
+            }
+        });
+    }
+
+    @Test
+    void testNoHeaderBuilder() throws IOException {
+        // @formatter:off
+        final CSVFormat format = CSVFormat.RFC4180.builder()
+                .setDelimiter(INPUT.charAt(0))
+                .setIgnoreSurroundingSpaces(true)
+                .get();
+        // @formatter:on
+        try (CSVParser parser = CSVParser.parse(INPUT, format)) {
+            // empty
+        }
+    }
+}
diff --git a/src/test/java/org/apache/commons/csv/issues/JiraCsv263Test.java b/src/test/java/org/apache/commons/csv/issues/JiraCsv263Test.java
new file mode 100644
index 0000000000..18bb9580a3
--- /dev/null
+++ b/src/test/java/org/apache/commons/csv/issues/JiraCsv263Test.java
@@ -0,0 +1,79 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *
+ *   https://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 org.apache.commons.csv.issues;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.io.IOException;
+import java.io.Reader;
+import java.io.StringReader;
+
+import org.apache.commons.csv.CSVFormat;
+import org.apache.commons.csv.QuoteMode;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Tests [CSV-263] Print from Reader with embedded quotes generates incorrect output.
+ */
+class JiraCsv263Test {
+
+    @Test
+    void testPrintFromReaderWithQuotes() throws IOException {
+        // @formatter:off
+        final CSVFormat format = CSVFormat.RFC4180.builder()
+            .setDelimiter(',')
+            .setQuote('"')
+            .setEscape('?')
+            .setQuoteMode(QuoteMode.NON_NUMERIC)
+            .get();
+        // @formatter:on
+        final StringBuilder out = new StringBuilder();
+
+        final Reader atStartOnly = new StringReader("\"a,b,c\r\nx,y,z");
+        format.print(atStartOnly, out, true);
+        assertEquals("\"\"\"a,b,c\r\nx,y,z\"", out.toString());
+
+        final Reader atEndOnly = new StringReader("a,b,c\r\nx,y,z\"");
+        out.setLength(0);
+        format.print(atEndOnly, out, true);
+        assertEquals("\"a,b,c\r\nx,y,z\"\"\"", out.toString());
+
+        final Reader atBeginEnd = new StringReader("\"a,b,c\r\nx,y,z\"");
+        out.setLength(0);
+        format.print(atBeginEnd, out, true);
+        assertEquals("\"\"\"a,b,c\r\nx,y,z\"\"\"", out.toString());
+
+        final Reader embeddedBeginMiddle = new StringReader("\"a\",b,c\r\nx,\"y\",z");
+        out.setLength(0);
+        format.print(embeddedBeginMiddle, out, true);
+        assertEquals("\"\"\"a\"\",b,c\r\nx,\"\"y\"\",z\"", out.toString());
+
+        final Reader embeddedMiddleEnd = new StringReader("a,\"b\",c\r\nx,y,\"z\"");
+        out.setLength(0);
+        format.print(embeddedMiddleEnd, out, true);
+        assertEquals("\"a,\"\"b\"\",c\r\nx,y,\"\"z\"\"\"", out.toString());
+
+        final Reader nested = new StringReader("a,\"b \"and\" c\",d");
+        out.setLength(0);
+        format.print(nested, out, true);
+        assertEquals("\"a,\"\"b \"\"and\"\" c\"\",d\"", out.toString());
+    }
+
+}
diff --git a/src/test/java/org/apache/commons/csv/issues/JiraCsv264Test.java b/src/test/java/org/apache/commons/csv/issues/JiraCsv264Test.java
new file mode 100644
index 0000000000..857e42cb8f
--- /dev/null
+++ b/src/test/java/org/apache/commons/csv/issues/JiraCsv264Test.java
@@ -0,0 +1,89 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *
+ *   https://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 org.apache.commons.csv.issues;
+
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.io.IOException;
+import java.io.StringReader;
+
+import org.apache.commons.csv.CSVFormat;
+import org.apache.commons.csv.CSVParser;
+import org.apache.commons.csv.DuplicateHeaderMode;
+import org.junit.jupiter.api.Test;
+
+/**
+ * When {@link CSVFormat#withHeader(String...)} is not null; duplicate headers
+ * with empty strings should not be allowed.
+ *
+ * @see Jira Ticker
+ */
+class JiraCsv264Test {
+
+    private static final String CSV_STRING = "\"\",\"B\",\"\"\n" +
+                                             "\"1\",\"2\",\"3\"\n" +
+                                             "\"4\",\"5\",\"6\"";
+
+    /**
+     * A CSV file with a random gap in the middle.
+     */
+    private static final String CSV_STRING_GAP = "\"A\",\"B\",\"\",\"\",\"E\"\n" +
+                                                 "\"1\",\"2\",\"\",\"\",\"5\"\n" +
+                                                 "\"6\",\"7\",\"\",\"\",\"10\"";
+
+    @Test
+    void testJiraCsv264() {
+        final CSVFormat csvFormat = CSVFormat.DEFAULT
+            .builder()
+            .setHeader()
+            .setDuplicateHeaderMode(DuplicateHeaderMode.DISALLOW)
+            .setAllowMissingColumnNames(true)
+            .get();
+        try (StringReader reader = new StringReader(CSV_STRING)) {
+            assertThrows(IllegalArgumentException.class, () -> csvFormat.parse(reader));
+        }
+    }
+
+    @Test
+    void testJiraCsv264WithGapAllowEmpty() throws IOException {
+        final CSVFormat csvFormat = CSVFormat.DEFAULT
+            .builder()
+            .setHeader()
+            .setDuplicateHeaderMode(DuplicateHeaderMode.ALLOW_EMPTY)
+            .setAllowMissingColumnNames(true)
+            .get();
+        try (StringReader reader = new StringReader(CSV_STRING_GAP); CSVParser parser = csvFormat.parse(reader)) {
+            // empty
+        }
+    }
+
+    @Test
+    void testJiraCsv264WithGapDisallow() {
+        final CSVFormat csvFormat = CSVFormat.DEFAULT
+            .builder()
+            .setHeader()
+            .setDuplicateHeaderMode(DuplicateHeaderMode.DISALLOW)
+            .setAllowMissingColumnNames(true)
+            .get();
+        try (StringReader reader = new StringReader(CSV_STRING_GAP)) {
+            assertThrows(IllegalArgumentException.class, () -> csvFormat.parse(reader));
+        }
+    }
+}
diff --git a/src/test/java/org/apache/commons/csv/issues/JiraCsv265Test.java b/src/test/java/org/apache/commons/csv/issues/JiraCsv265Test.java
new file mode 100644
index 0000000000..1bccad702f
--- /dev/null
+++ b/src/test/java/org/apache/commons/csv/issues/JiraCsv265Test.java
@@ -0,0 +1,92 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *
+ *   https://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 org.apache.commons.csv.issues;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.io.IOException;
+import java.io.StringReader;
+import java.util.Iterator;
+
+import org.apache.commons.csv.CSVFormat;
+import org.apache.commons.csv.CSVParser;
+import org.apache.commons.csv.CSVRecord;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Tests [CSV-265] {@link CSVRecord#getCharacterPosition()} returns the correct position after encountering a comment.
+ */
+class JiraCsv265Test {
+
+    @Test
+    void testCharacterPositionWithComments() throws IOException {
+        // @formatter:off
+        final String csv =
+                "# Comment1\n" +
+                "Header1,Header2\n" +
+                "# Comment2\n" +
+                "Value1,Value2\n" +
+                "# Comment3\n" +
+                "Value3,Value4\n" +
+                "# Comment4\n";
+        final CSVFormat csvFormat = CSVFormat.DEFAULT.builder()
+            .setCommentMarker('#')
+            .setHeader()
+            .setSkipHeaderRecord(true)
+            .get();
+        // @formatter:on
+        try (CSVParser parser = csvFormat.parse(new StringReader(csv))) {
+            final Iterator itr = parser.iterator();
+            final CSVRecord record1 = itr.next();
+            assertEquals(csv.indexOf("# Comment2"), record1.getCharacterPosition());
+            final CSVRecord record2 = itr.next();
+            assertEquals(csv.indexOf("# Comment3"), record2.getCharacterPosition());
+        }
+    }
+
+    @Test
+    void testCharacterPositionWithCommentsSpanningMultipleLines() throws IOException {
+        // @formatter:off
+        final String csv =
+                "# Comment1\n" +
+                "# Comment2\n" +
+                "Header1,Header2\n" +
+                "# Comment3\n" +
+                "# Comment4\n" +
+                "Value1,Value2\n" +
+                "# Comment5\n" +
+                "# Comment6\n" +
+                "Value3,Value4";
+        final CSVFormat csvFormat = CSVFormat.DEFAULT.builder()
+            .setCommentMarker('#')
+            .setHeader()
+            .setSkipHeaderRecord(true)
+            .get();
+        // @formatter:on
+        try (CSVParser parser = csvFormat.parse(new StringReader(csv))) {
+            final Iterator itr = parser.iterator();
+            final CSVRecord record1 = itr.next();
+            assertEquals(csv.indexOf("# Comment3"), record1.getCharacterPosition());
+            final CSVRecord record2 = itr.next();
+            assertEquals(csv.indexOf("# Comment5"), record2.getCharacterPosition());
+        }
+    }
+
+}
diff --git a/src/test/java/org/apache/commons/csv/issues/JiraCsv271Test.java b/src/test/java/org/apache/commons/csv/issues/JiraCsv271Test.java
new file mode 100644
index 0000000000..0269dec5d1
--- /dev/null
+++ b/src/test/java/org/apache/commons/csv/issues/JiraCsv271Test.java
@@ -0,0 +1,56 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *
+ *   https://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 org.apache.commons.csv.issues;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.io.IOException;
+import java.io.StringWriter;
+import java.util.Arrays;
+
+import org.apache.commons.csv.CSVFormat;
+import org.apache.commons.csv.CSVPrinter;
+import org.junit.jupiter.api.Test;
+
+class JiraCsv271Test {
+
+    @Test
+    void testJiraCsv271_withArray() throws IOException {
+        final CSVFormat csvFormat = CSVFormat.DEFAULT;
+        final StringWriter stringWriter = new StringWriter();
+        try (CSVPrinter printer = new CSVPrinter(stringWriter, csvFormat)) {
+            printer.print("a");
+            printer.printRecord("b", "c");
+        }
+        assertEquals("a,b,c\r\n", stringWriter.toString());
+    }
+
+    @Test
+    void testJiraCsv271_withList() throws IOException {
+        final CSVFormat csvFormat = CSVFormat.DEFAULT;
+        final StringWriter stringWriter = new StringWriter();
+        try (CSVPrinter printer = new CSVPrinter(stringWriter, csvFormat)) {
+            printer.print("a");
+            printer.printRecord(Arrays.asList("b", "c"));
+        }
+        assertEquals("a,b,c\r\n", stringWriter.toString());
+    }
+
+}
diff --git a/src/test/java/org/apache/commons/csv/issues/JiraCsv288Test.java b/src/test/java/org/apache/commons/csv/issues/JiraCsv288Test.java
new file mode 100644
index 0000000000..065ee6bb37
--- /dev/null
+++ b/src/test/java/org/apache/commons/csv/issues/JiraCsv288Test.java
@@ -0,0 +1,216 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *
+ *   https://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 org.apache.commons.csv.issues;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.io.IOException;
+import java.io.Reader;
+import java.io.StringReader;
+
+import org.apache.commons.csv.CSVFormat;
+import org.apache.commons.csv.CSVParser;
+import org.apache.commons.csv.CSVPrinter;
+import org.apache.commons.csv.CSVRecord;
+import org.junit.jupiter.api.Test;
+
+class JiraCsv288Test {
+
+    private void print(final CSVRecord csvRecord, final CSVPrinter csvPrinter) throws IOException {
+        for (final String value : csvRecord) {
+            csvPrinter.print(value);
+        }
+    }
+
+    @Test
+    // Before fix:
+    // expected:  but was: 
+    void testParseWithABADelimiter() throws Exception {
+        final Reader in = new StringReader("a|~|b|~|c|~|d|~||~|f");
+        final StringBuilder stringBuilder = new StringBuilder();
+        try (CSVPrinter csvPrinter = new CSVPrinter(stringBuilder, CSVFormat.EXCEL);
+                CSVParser parser = CSVParser.parse(in, CSVFormat.Builder.create().setDelimiter("|~|").get())) {
+            for (final CSVRecord csvRecord : parser) {
+                print(csvRecord, csvPrinter);
+                assertEquals("a,b,c,d,,f", stringBuilder.toString());
+            }
+        }
+    }
+
+    @Test
+    // Before fix:
+    // expected:  but was: 
+    void testParseWithDoublePipeDelimiter() throws Exception {
+        final Reader in = new StringReader("a||b||c||d||||f");
+        final StringBuilder stringBuilder = new StringBuilder();
+        try (CSVPrinter csvPrinter = new CSVPrinter(stringBuilder, CSVFormat.EXCEL);
+                CSVParser csvParser = CSVParser.parse(in, CSVFormat.Builder.create().setDelimiter("||").get())) {
+            for (final CSVRecord csvRecord : csvParser) {
+                print(csvRecord, csvPrinter);
+                assertEquals("a,b,c,d,,f", stringBuilder.toString());
+            }
+        }
+    }
+
+    @Test
+    // Regression, already passed before fix
+
+    void testParseWithDoublePipeDelimiterDoubleCharValue() throws Exception {
+        final Reader in = new StringReader("a||bb||cc||dd||f");
+        final StringBuilder stringBuilder = new StringBuilder();
+        try (CSVPrinter csvPrinter = new CSVPrinter(stringBuilder, CSVFormat.EXCEL);
+                CSVParser csvParser = CSVParser.parse(in, CSVFormat.Builder.create().setDelimiter("||").get())) {
+            for (final CSVRecord csvRecord : csvParser) {
+                print(csvRecord, csvPrinter);
+                assertEquals("a,bb,cc,dd,f", stringBuilder.toString());
+            }
+        }
+    }
+
+    @Test
+    // Before fix:
+    // expected:  but was: 
+    void testParseWithDoublePipeDelimiterEndsWithDelimiter() throws Exception {
+        final Reader in = new StringReader("a||b||c||d||||f||");
+        final StringBuilder stringBuilder = new StringBuilder();
+        try (CSVPrinter csvPrinter = new CSVPrinter(stringBuilder, CSVFormat.EXCEL);
+                CSVParser csvParser = CSVParser.parse(in, CSVFormat.Builder.create().setDelimiter("||").get())) {
+            for (final CSVRecord csvRecord : csvParser) {
+                print(csvRecord, csvPrinter);
+                assertEquals("a,b,c,d,,f,", stringBuilder.toString());
+            }
+        }
+    }
+
+    @Test
+    // Before fix:
+    // expected:  but was: 
+    void testParseWithDoublePipeDelimiterQuoted() throws Exception {
+        final Reader in = new StringReader("a||\"b||c\"||d||||f");
+        final StringBuilder stringBuilder = new StringBuilder();
+        try (CSVPrinter csvPrinter = new CSVPrinter(stringBuilder, CSVFormat.EXCEL);
+                CSVParser csvParser = CSVParser.parse(in, CSVFormat.Builder.create().setDelimiter("||").get())) {
+            for (final CSVRecord csvRecord : csvParser) {
+                print(csvRecord, csvPrinter);
+                assertEquals("a,b||c,d,,f", stringBuilder.toString());
+            }
+        }
+    }
+
+    @Test
+    // Regression, already passed before fix
+    void testParseWithSinglePipeDelimiterEndsWithDelimiter() throws Exception {
+        final Reader in = new StringReader("a|b|c|d||f|");
+        final StringBuilder stringBuilder = new StringBuilder();
+        try (CSVPrinter csvPrinter = new CSVPrinter(stringBuilder, CSVFormat.EXCEL);
+                CSVParser csvParser = CSVParser.parse(in, CSVFormat.Builder.create().setDelimiter("|").get())) {
+            for (final CSVRecord csvRecord : csvParser) {
+                print(csvRecord, csvPrinter);
+                assertEquals("a,b,c,d,,f,", stringBuilder.toString());
+            }
+        }
+    }
+
+    @Test
+    // Before fix:
+    // expected:  but was: 
+    void testParseWithTriplePipeDelimiter() throws Exception {
+        final Reader in = new StringReader("a|||b|||c|||d||||||f");
+        final StringBuilder stringBuilder = new StringBuilder();
+        try (CSVPrinter csvPrinter = new CSVPrinter(stringBuilder, CSVFormat.EXCEL);
+                CSVParser csvParser = CSVParser.parse(in, CSVFormat.Builder.create().setDelimiter("|||").get())) {
+            for (final CSVRecord csvRecord : csvParser) {
+                print(csvRecord, csvPrinter);
+                assertEquals("a,b,c,d,,f", stringBuilder.toString());
+            }
+        }
+    }
+
+    @Test
+    // Regression, already passed before fix
+    void testParseWithTwoCharDelimiter1() throws Exception {
+        final Reader in = new StringReader("a~|b~|c~|d~|~|f");
+        final StringBuilder stringBuilder = new StringBuilder();
+        try (CSVPrinter csvPrinter = new CSVPrinter(stringBuilder, CSVFormat.EXCEL);
+                CSVParser csvParser = CSVParser.parse(in, CSVFormat.Builder.create().setDelimiter("~|").get())) {
+            for (final CSVRecord csvRecord : csvParser) {
+                print(csvRecord, csvPrinter);
+                assertEquals("a,b,c,d,,f", stringBuilder.toString());
+            }
+        }
+    }
+
+    @Test
+    // Regression, already passed before fix
+    void testParseWithTwoCharDelimiter2() throws Exception {
+        final Reader in = new StringReader("a~|b~|c~|d~|~|f~");
+        final StringBuilder stringBuilder = new StringBuilder();
+        try (CSVPrinter csvPrinter = new CSVPrinter(stringBuilder, CSVFormat.EXCEL);
+                CSVParser csvParser = CSVParser.parse(in, CSVFormat.Builder.create().setDelimiter("~|").get())) {
+            for (final CSVRecord csvRecord : csvParser) {
+                print(csvRecord, csvPrinter);
+                assertEquals("a,b,c,d,,f~", stringBuilder.toString());
+            }
+        }
+    }
+
+    @Test
+    // Regression, already passed before fix
+    void testParseWithTwoCharDelimiter3() throws Exception {
+        final Reader in = new StringReader("a~|b~|c~|d~|~|f|");
+        final StringBuilder stringBuilder = new StringBuilder();
+        try (CSVPrinter csvPrinter = new CSVPrinter(stringBuilder, CSVFormat.EXCEL);
+                CSVParser csvParser = CSVParser.parse(in, CSVFormat.Builder.create().setDelimiter("~|").get())) {
+            for (final CSVRecord csvRecord : csvParser) {
+                print(csvRecord, csvPrinter);
+                assertEquals("a,b,c,d,,f|", stringBuilder.toString());
+            }
+        }
+    }
+
+    @Test
+    // Regression, already passed before fix
+    void testParseWithTwoCharDelimiter4() throws Exception {
+        final Reader in = new StringReader("a~|b~|c~|d~|~|f~~||g");
+        final StringBuilder stringBuilder = new StringBuilder();
+        try (CSVPrinter csvPrinter = new CSVPrinter(stringBuilder, CSVFormat.EXCEL);
+                CSVParser csvParser = CSVParser.parse(in, CSVFormat.Builder.create().setDelimiter("~|").get())) {
+            for (final CSVRecord csvRecord : csvParser) {
+                print(csvRecord, csvPrinter);
+                assertEquals("a,b,c,d,,f~,|g", stringBuilder.toString());
+            }
+        }
+    }
+
+    @Test
+    // Before fix:
+    // expected:  but was: 
+    void testParseWithTwoCharDelimiterEndsWithDelimiter() throws Exception {
+        final Reader in = new StringReader("a~|b~|c~|d~|~|f~|");
+        final StringBuilder stringBuilder = new StringBuilder();
+        try (CSVPrinter csvPrinter = new CSVPrinter(stringBuilder, CSVFormat.EXCEL);
+                CSVParser csvParser = CSVParser.parse(in, CSVFormat.Builder.create().setDelimiter("~|").get())) {
+            for (final CSVRecord csvRecord : csvParser) {
+                print(csvRecord, csvPrinter);
+                assertEquals("a,b,c,d,,f,", stringBuilder.toString());
+            }
+        }
+    }
+}
diff --git a/src/test/java/org/apache/commons/csv/issues/JiraCsv290Test.java b/src/test/java/org/apache/commons/csv/issues/JiraCsv290Test.java
new file mode 100644
index 0000000000..f251eeb7a5
--- /dev/null
+++ b/src/test/java/org/apache/commons/csv/issues/JiraCsv290Test.java
@@ -0,0 +1,113 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *
+ *   https://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 org.apache.commons.csv.issues;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+import java.io.InputStreamReader;
+import java.io.StringReader;
+import java.io.StringWriter;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.apache.commons.csv.CSVFormat;
+import org.apache.commons.csv.CSVParser;
+import org.apache.commons.csv.CSVPrinter;
+import org.apache.commons.csv.CSVRecord;
+import org.junit.jupiter.api.Test;
+
+// psql (14.5 (Homebrew))
+//
+// create table COMMONS_CSV_PSQL_TEST (ID INTEGER, COL1 VARCHAR, COL2 VARCHAR, COL3 VARCHAR, COL4 VARCHAR);
+// insert into COMMONS_CSV_PSQL_TEST select 1, 'abc', 'test line 1' || chr(10) || 'test line 2', null, '';
+// insert into COMMONS_CSV_PSQL_TEST select 2, 'xyz', '\b:' || chr(8) || ' \t:' || chr(9) || ' \n:' || chr(10) || ' \r:' || chr(13), 'a', 'b';
+// insert into COMMONS_CSV_PSQL_TEST values (3, 'a', 'b,c,d', '"quoted"', 'e');
+// copy COMMONS_CSV_PSQL_TEST TO '/tmp/psql.csv' WITH (FORMAT CSV);
+// copy COMMONS_CSV_PSQL_TEST TO '/tmp/psql.tsv';
+//
+// cat /tmp/psql.csv
+// 1,abc,"test line 1
+// test line 2",,""
+// 2,xyz,"\b:^H \t:         \n:
+//  \r:^M",a,b
+// 3,a,"b,c,d","""quoted""",e
+//
+// cat /tmp/psql.tsv
+// 1    abc    test line 1\ntest line 2                  \N
+// 2    xyz    \\b:\b \\t:\t \\n:\n \\r:\r    a          b
+// 3    a      b,c,d                         "quoted"    e
+//
+class JiraCsv290Test {
+
+    private void testHelper(final String fileName, final CSVFormat format) throws Exception {
+        List> content = new ArrayList<>();
+        try (CSVParser csvParser = CSVParser.parse(new InputStreamReader(this.getClass().getResourceAsStream("/org/apache/commons/csv/CSV-290/" + fileName)),
+                format)) {
+            content = csvParser.stream().collect(Collectors.mapping(CSVRecord::toList, Collectors.toList()));
+        }
+
+        assertEquals(3, content.size());
+
+        assertEquals("1", content.get(0).get(0));
+        assertEquals("abc", content.get(0).get(1));
+        assertEquals("test line 1\ntest line 2", content.get(0).get(2)); // new line
+        assertNull(content.get(0).get(3)); // null
+        assertEquals("", content.get(0).get(4));
+
+        assertEquals("2", content.get(1).get(0));
+        assertEquals("\\b:\b \\t:\t \\n:\n \\r:\r", content.get(1).get(2)); // \b, \t, \n, \r
+
+        assertEquals("3", content.get(2).get(0));
+        assertEquals("b,c,d", content.get(2).get(2)); // value has comma
+        assertEquals("\"quoted\"", content.get(2).get(3)); // quoted
+    }
+
+    @Test
+    void testPostgresqlCsv() throws Exception {
+        testHelper("psql.csv", CSVFormat.POSTGRESQL_CSV);
+    }
+
+    @Test
+    void testPostgresqlText() throws Exception {
+        testHelper("psql.tsv", CSVFormat.POSTGRESQL_TEXT);
+    }
+
+    @Test
+    void testWriteThenRead() throws Exception {
+        final StringWriter sw = new StringWriter();
+        final CSVFormat format = CSVFormat.POSTGRESQL_CSV.builder().setHeader().setSkipHeaderRecord(true).get();
+        try (CSVPrinter printer = new CSVPrinter(sw, format)) {
+            printer.printRecord("column1", "column2");
+            printer.printRecord("v11", "v12");
+            printer.printRecord("v21", "v22");
+            printer.close();
+            try (CSVParser parser = CSVParser.builder().setReader(new StringReader(sw.toString())).setFormat(format).get()) {
+                assertArrayEquals(new Object[] { "column1", "column2" }, parser.getHeaderNames().toArray());
+                final Iterator i = parser.iterator();
+                assertArrayEquals(new String[] { "v11", "v12" }, i.next().toList().toArray());
+                assertArrayEquals(new String[] { "v21", "v22" }, i.next().toList().toArray());
+            }
+        }
+    }
+}
diff --git a/src/test/java/org/apache/commons/csv/issues/JiraCsv294Test.java b/src/test/java/org/apache/commons/csv/issues/JiraCsv294Test.java
new file mode 100644
index 0000000000..0e5de0751b
--- /dev/null
+++ b/src/test/java/org/apache/commons/csv/issues/JiraCsv294Test.java
@@ -0,0 +1,81 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *
+ *   https://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 org.apache.commons.csv.issues;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+
+import org.apache.commons.csv.CSVFormat;
+import org.apache.commons.csv.CSVParser;
+import org.apache.commons.csv.CSVPrinter;
+import org.apache.commons.csv.CSVRecord;
+import org.junit.jupiter.api.Test;
+
+class JiraCsv294Test {
+
+    private static void testInternal(final CSVFormat format, final String expectedSubstring) throws IOException {
+        final ByteArrayOutputStream bos = new ByteArrayOutputStream();
+        try (CSVPrinter printer = new CSVPrinter(new OutputStreamWriter(bos, StandardCharsets.UTF_8), format)) {
+            printer.printRecord("a", "b \"\"", "c");
+        }
+        final byte[] written = bos.toByteArray();
+        final String writtenString = new String(written, StandardCharsets.UTF_8);
+        assertTrue(writtenString.contains(expectedSubstring));
+        try (CSVParser parser = CSVParser.builder().setReader(new InputStreamReader(new ByteArrayInputStream(written), StandardCharsets.UTF_8))
+                .setFormat(format).get()) {
+            final List records = parser.getRecords();
+            assertEquals(1, records.size());
+            final CSVRecord record = records.get(0);
+            assertEquals("a", record.get(0));
+            assertEquals("b \"\"", record.get(1));
+            assertEquals("c", record.get(2));
+        }
+    }
+
+    @Test
+    void testDefaultCsvFormatWithBackslashEscapeWorks() throws IOException {
+        testInternal(CSVFormat.Builder.create().setEscape('\\').get(), ",\"b \\\"\\\"\",");
+    }
+
+    @Test
+    void testDefaultCsvFormatWithNullEscapeWorks() throws IOException {
+        testInternal(CSVFormat.Builder.create().setEscape(null).get(), ",\"b \"\"\"\"\",");
+    }
+
+    @Test
+    void testDefaultCsvFormatWithQuoteEscapeWorks() throws IOException {
+        // this one doesn't actually work but should behave like setEscape(null)
+        // Printer is writing the expected content but Parser is unable to consume it
+        testInternal(CSVFormat.Builder.create().setEscape('"').get(), ",\"b \"\"\"\"\",");
+    }
+
+    @Test
+    void testDefaultCsvFormatWorks() throws IOException {
+        testInternal(CSVFormat.Builder.create().get(), ",\"b \"\"\"\"\",");
+    }
+}
diff --git a/src/test/java/org/apache/commons/csv/issues/JiraCsv93Test.java b/src/test/java/org/apache/commons/csv/issues/JiraCsv93Test.java
new file mode 100644
index 0000000000..7816412265
--- /dev/null
+++ b/src/test/java/org/apache/commons/csv/issues/JiraCsv93Test.java
@@ -0,0 +1,152 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *
+ *   https://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 org.apache.commons.csv.issues;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.io.IOException;
+import java.io.StringReader;
+
+import org.apache.commons.csv.CSVFormat;
+import org.apache.commons.csv.CSVParser;
+import org.apache.commons.csv.CSVRecord;
+import org.apache.commons.csv.QuoteMode;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Add more tests about null value.
+ * 

+ * QuoteMode:ALL_NON_NULL (Quotes all non-null fields, null will not be quoted but not null will be quoted). when
+ * withNullString("NULL"), NULL String value ("NULL") and null value (null) will be formatted as '"NULL",NULL'. So it
+ * also should be parsed as NULL String value and null value (["NULL", null]), It should be distinguish in parsing. And
+ * when don't set nullString in CSVFormat, String '"",' should be parsed as "" and null (["", null]) according to null
+ * will not be quoted but not null will be quoted. QuoteMode:NON_NUMERIC, same as ALL_NON_NULL.
+ * 
+ * 

+ * This can solve the problem of distinguishing between empty string columns and absent value columns which just like
+ * Jira CSV-253 to a certain extent.
+ * 
+ */
+class JiraCsv93Test {
+    private static Object[] objects1 = {"abc", "", null, "a,b,c", 123};
+
+    private static Object[] objects2 = {"abc", "NULL", null, "a,b,c", 123};
+
+    private void every(final CSVFormat csvFormat, final Object[] objects, final String format, final String[] data)
+        throws IOException {
+        final String source = csvFormat.format(objects);
+        assertEquals(format, csvFormat.format(objects));
+        try (CSVParser csvParser = csvFormat.parse(new StringReader(source))) {
+            final CSVRecord csvRecord = csvParser.iterator().next();
+            for (int i = 0; i < data.length; i++) {
+                assertEquals(csvRecord.get(i), data[i]);
+            }
+        }
+    }
+
+    @Test
+    void testWithNotSetNullString() throws IOException {
+        // @formatter:off
+        every(CSVFormat.DEFAULT,
+                objects1,
+                "abc,,,\"a,b,c\",123",
+                new String[]{"abc", "", "", "a,b,c", "123"});
+        every(CSVFormat.DEFAULT.builder().setQuoteMode(QuoteMode.ALL).get(),
+                objects1,
+                "\"abc\",\"\",,\"a,b,c\",\"123\"",
+                new String[]{"abc", "", "", "a,b,c", "123"});
+        every(CSVFormat.DEFAULT.builder().setQuoteMode(QuoteMode.ALL_NON_NULL).get(),
+                objects1,
+                "\"abc\",\"\",,\"a,b,c\",\"123\"",
+                new String[]{"abc", "", null, "a,b,c", "123"});
+        every(CSVFormat.DEFAULT.builder().setQuoteMode(QuoteMode.MINIMAL).get(),
+                objects1,
+                "abc,,,\"a,b,c\",123",
+                new String[]{"abc", "", "", "a,b,c", "123"});
+        every(CSVFormat.DEFAULT.builder().setEscape('?').setQuoteMode(QuoteMode.NONE).get(),
+                objects1,
+                "abc,,,a?,b?,c,123",
+                new String[]{"abc", "", "", "a,b,c", "123"});
+        every(CSVFormat.DEFAULT.builder().setQuoteMode(QuoteMode.NON_NUMERIC).get(),
+                objects1,
+                "\"abc\",\"\",,\"a,b,c\",123",
+                new String[]{"abc", "", null, "a,b,c", "123"});
+        // @formatter:on
+    }
+
+    @Test
+    void testWithSetNullStringEmptyString() throws IOException {
+        // @formatter:off
+        every(CSVFormat.DEFAULT.builder().setNullString("").get(),
+                objects1,
+                "abc,,,\"a,b,c\",123",
+                new String[]{"abc", null, null, "a,b,c", "123"});
+        every(CSVFormat.DEFAULT.builder().setNullString("").setQuoteMode(QuoteMode.ALL).get(),
+                objects1,
+                "\"abc\",\"\",\"\",\"a,b,c\",\"123\"",
+                new String[]{"abc", null, null, "a,b,c", "123"});
+        every(CSVFormat.DEFAULT.builder().setNullString("").setQuoteMode(QuoteMode.ALL_NON_NULL).get(),
+                objects1,
+                "\"abc\",\"\",,\"a,b,c\",\"123\"",
+                new String[]{"abc", "", null, "a,b,c", "123"});
+        every(CSVFormat.DEFAULT.builder().setNullString("").setQuoteMode(QuoteMode.MINIMAL).get(),
+                objects1,
+                "abc,,,\"a,b,c\",123",
+                new String[]{"abc", null, null, "a,b,c", "123"});
+        every(CSVFormat.DEFAULT.builder().setNullString("").setEscape('?').setQuoteMode(QuoteMode.NONE).get(),
+                objects1,
+                "abc,,,a?,b?,c,123",
+                new String[]{"abc", null, null, "a,b,c", "123"});
+        every(CSVFormat.DEFAULT.builder().setNullString("").setQuoteMode(QuoteMode.NON_NUMERIC).get(),
+                objects1,
+                "\"abc\",\"\",,\"a,b,c\",123",
+                new String[]{"abc", "", null, "a,b,c", "123"});
+        // @formatter:on
+    }
+
+    @Test
+    void testWithSetNullStringNULL() throws IOException {
+        // @formatter:off
+        every(CSVFormat.DEFAULT.builder().setNullString("NULL").get(),
+                objects2,
+                "abc,NULL,NULL,\"a,b,c\",123",
+                new String[]{"abc", null, null, "a,b,c", "123"});
+        every(CSVFormat.DEFAULT.builder().setNullString("NULL").setQuoteMode(QuoteMode.ALL).get(),
+                objects2,
+                "\"abc\",\"NULL\",\"NULL\",\"a,b,c\",\"123\"",
+                new String[]{"abc", null, null, "a,b,c", "123"});
+        every(CSVFormat.DEFAULT.builder().setNullString("NULL").setQuoteMode(QuoteMode.ALL_NON_NULL).get(),
+                objects2,
+                "\"abc\",\"NULL\",NULL,\"a,b,c\",\"123\"",
+                new String[]{"abc", "NULL", null, "a,b,c", "123"});
+        every(CSVFormat.DEFAULT.builder().setNullString("NULL").setQuoteMode(QuoteMode.MINIMAL).get(),
+                objects2,
+                "abc,NULL,NULL,\"a,b,c\",123",
+                new String[]{"abc", null, null, "a,b,c", "123"});
+        every(CSVFormat.DEFAULT.builder().setNullString("NULL").setEscape('?').setQuoteMode(QuoteMode.NONE).get(),
+                objects2,
+                "abc,NULL,NULL,a?,b?,c,123",
+                new String[]{"abc", null, null, "a,b,c", "123"});
+        every(CSVFormat.DEFAULT.builder().setNullString("NULL").setQuoteMode(QuoteMode.NON_NUMERIC).get(),
+                objects2,
+                "\"abc\",\"NULL\",NULL,\"a,b,c\",123",
+                new String[]{"abc", "NULL", null, "a,b,c", "123"});
+        // @formatter:on
+    }
+}
diff --git a/src/test/java/org/apache/commons/csv/perf/PerformanceTest.java b/src/test/java/org/apache/commons/csv/perf/PerformanceTest.java
index 37613253c3..bead12378d 100644
--- a/src/test/java/org/apache/commons/csv/perf/PerformanceTest.java
+++ b/src/test/java/org/apache/commons/csv/perf/PerformanceTest.java
@@ -1,25 +1,26 @@
 /*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *   https://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.
+ * 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 org.apache.commons.csv.perf;
 
 import java.io.BufferedReader;
 import java.io.File;
-import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.FileReader;
@@ -30,7 +31,9 @@
 import java.util.zip.GZIPInputStream;
 
 import org.apache.commons.csv.CSVFormat;
+import org.apache.commons.csv.CSVParser;
 import org.apache.commons.csv.CSVRecord;
+import org.apache.commons.io.FileUtils;
 import org.apache.commons.io.IOUtils;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
@@ -40,12 +43,11 @@
  *
  * To run this test, use: mvn test -Dtest=PerformanceTest
  */
-@SuppressWarnings("boxing") // test code
-public class PerformanceTest {
+class PerformanceTest {
 
-    private final int max = 10;
+    private static final String TEST_RESRC = "org/apache/commons/csv/perf/worldcitiespop.txt.gz";
 
-    private static final File BIG_FILE = new File(System.getProperty("java.io.tmpdir"), "worldcitiespop.txt");
+    private static final File BIG_FILE = new File(FileUtils.getTempDirectoryPath(), "worldcitiespop.txt");
 
     @BeforeAll
     public static void setUpClass() throws FileNotFoundException, IOException {
@@ -53,27 +55,31 @@ public static void setUpClass() throws FileNotFoundException, IOException {
             System.out.println(String.format("Found test fixture %s: %,d bytes.", BIG_FILE, BIG_FILE.length()));
             return;
         }
-        System.out.println("Decompressing test fixture " + BIG_FILE + "...");
-        try (final InputStream input = new GZIPInputStream(
-                new FileInputStream("src/test/resources/perf/worldcitiespop.txt.gz"));
-                final OutputStream output = new FileOutputStream(BIG_FILE)) {
+        System.out.println("Decompressing test fixture to: " + BIG_FILE + "...");
+        try (InputStream input = new GZIPInputStream(PerformanceTest.class.getClassLoader().getResourceAsStream(TEST_RESRC));
+                OutputStream output = new FileOutputStream(BIG_FILE)) {
             IOUtils.copy(input, output);
             System.out.println(String.format("Decompressed test fixture %s: %,d bytes.", BIG_FILE, BIG_FILE.length()));
         }
     }
 
+    private final int max = 10;
+
     private BufferedReader createBufferedReader() throws IOException {
         return new BufferedReader(new FileReader(BIG_FILE));
     }
 
-    private long parse(final Reader in, final boolean traverseColumns) throws IOException {
-        final CSVFormat format = CSVFormat.DEFAULT.withIgnoreSurroundingSpaces(false);
+    private long parse(final Reader reader, final boolean traverseColumns) throws IOException {
+        final CSVFormat format = CSVFormat.DEFAULT.builder().setIgnoreSurroundingSpaces(false).get();
         long recordCount = 0;
-        for (final CSVRecord record : format.parse(in)) {
-            recordCount++;
-            if (traverseColumns) {
-                for (@SuppressWarnings("unused") final String value : record) {
-                    // do nothing for now
+        try (CSVParser parser = format.parse(reader)) {
+            for (final CSVRecord record : parser) {
+                recordCount++;
+                if (traverseColumns) {
+                    for (@SuppressWarnings("unused")
+                    final String value : record) {
+                        // do nothing for now
+                    }
                 }
             }
         }
@@ -84,7 +90,7 @@ private void println(final String s) {
         System.out.println(s);
     }
 
-    private long readAll(final BufferedReader in) throws IOException {
+    private long readLines(final BufferedReader in) throws IOException {
         long count = 0;
         while (in.readLine() != null) {
             count++;
@@ -94,35 +100,38 @@ private long readAll(final BufferedReader in) throws IOException {
 
     public long testParseBigFile(final boolean traverseColumns) throws Exception {
         final long startMillis = System.currentTimeMillis();
-        final long count = this.parse(this.createBufferedReader(), traverseColumns);
-        final long totalMillis = System.currentTimeMillis() - startMillis;
-        this.println(String.format("File parsed in %,d milliseconds with Commons CSV: %,d lines.", totalMillis, count));
-        return totalMillis;
+        try (BufferedReader reader = createBufferedReader()) {
+            final long count = parse(reader, traverseColumns);
+            final long totalMillis = System.currentTimeMillis() - startMillis;
+            println(
+                String.format("File parsed in %,d milliseconds with Commons CSV: %,d lines.", totalMillis, count));
+            return totalMillis;
+        }
     }
 
     @Test
-    public void testParseBigFileRepeat() throws Exception {
+    void testParseBigFileRepeat() throws Exception {
         long bestTime = Long.MAX_VALUE;
         for (int i = 0; i < this.max; i++) {
-            bestTime = Math.min(this.testParseBigFile(false), bestTime);
+            bestTime = Math.min(testParseBigFile(false), bestTime);
         }
-        this.println(String.format("Best time out of %,d is %,d milliseconds.", this.max, bestTime));
+        println(String.format("Best time out of %,d is %,d milliseconds.", this.max, bestTime));
     }
 
     @Test
-    public void testReadBigFile() throws Exception {
+    void testReadBigFile() throws Exception {
         long bestTime = Long.MAX_VALUE;
         long count;
         for (int i = 0; i < this.max; i++) {
             final long startMillis;
-            try (final BufferedReader in = this.createBufferedReader()) {
+            try (BufferedReader in = createBufferedReader()) {
                 startMillis = System.currentTimeMillis();
-                count = this.readAll(in);
+                count = readLines(in);
             }
             final long totalMillis = System.currentTimeMillis() - startMillis;
             bestTime = Math.min(totalMillis, bestTime);
-            this.println(String.format("File read in %,d milliseconds: %,d lines.", totalMillis, count));
+            println(String.format("File read in %,d milliseconds: %,d lines.", totalMillis, count));
         }
-        this.println(String.format("Best time out of %,d is %,d milliseconds.", this.max, bestTime));
+        println(String.format("Best time out of %,d is %,d milliseconds.", this.max, bestTime));
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/resources/org/apache/commons/csv/CSV-141/csv-141.csv b/src/test/resources/org/apache/commons/csv/CSV-141/csv-141.csv
new file mode 100644
index 0000000000..e685adc88f
--- /dev/null
+++ b/src/test/resources/org/apache/commons/csv/CSV-141/csv-141.csv
@@ -0,0 +1,4 @@
+"1414770317901","android.widget.EditText","pass sem1 _84*|*","0","pass sem1 _8"
+"1414770318470","android.widget.EditText","pass sem1 _84:|","0","pass sem1 _84:\"
+"1414770318327","android.widget.EditText","pass sem1
+"1414770318628","android.widget.EditText","pass sem1 _84*|*","0","pass sem1
diff --git a/src/test/resources/org/apache/commons/csv/CSV-196/emoji.csv b/src/test/resources/org/apache/commons/csv/CSV-196/emoji.csv
new file mode 100644
index 0000000000..0bff7a44f3
--- /dev/null
+++ b/src/test/resources/org/apache/commons/csv/CSV-196/emoji.csv
@@ -0,0 +1,5 @@
+id,val1,val2,val3,val4,val5,val6,val7,val8,val9,val10,val11,val12,val13,val14,val15
+1,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄
+2,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄
+3,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄
+4,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄,😄😄😄😄😄😄😄😄😄😄
\ No newline at end of file
diff --git a/src/test/resources/org/apache/commons/csv/CSV-196/japanese.csv b/src/test/resources/org/apache/commons/csv/CSV-196/japanese.csv
new file mode 100644
index 0000000000..b06e04bd6a
--- /dev/null
+++ b/src/test/resources/org/apache/commons/csv/CSV-196/japanese.csv
@@ -0,0 +1,4 @@
+id,date,val1,val2,val3,val4,val5,val6,val7,val8,val9,val10,val11,val12,val13,val14,val15
+00000000000001,2017-01-01,きちんと節分近くには咲いてる。自然の力ってすごいな～,v2,v3,v4,v5,v6,v7,v8,v9,v10,v11,v12,v13,v14,v15
+00000000000002,2017-01-01,きちんと節分近くには咲いてる。自然の力ってすごいな～,v2,v3,v4,v5,v6,v7,v8,v9,v10,v11,v12,v13,v14,v15
+00000000000003,2017-01-01,きちんと節分近くには咲いてる。自然の力ってすごいな～,v2,v3,v4,v5,v6,v7,v8,v9,v10,v11,v12,v13,v14,v15
\ No newline at end of file
diff --git a/src/test/resources/org/apache/commons/csv/CSV-254/csv-254.csv b/src/test/resources/org/apache/commons/csv/CSV-254/csv-254.csv
new file mode 100644
index 0000000000..e7d2972c5a
--- /dev/null
+++ b/src/test/resources/org/apache/commons/csv/CSV-254/csv-254.csv
@@ -0,0 +1,3 @@
+AA,33,
+AA,,""
+,33,CC
diff --git a/src/test/resources/org/apache/commons/csv/CSV-290/psql.csv b/src/test/resources/org/apache/commons/csv/CSV-290/psql.csv
new file mode 100644
index 0000000000..dd50f5a642
--- /dev/null
+++ b/src/test/resources/org/apache/commons/csv/CSV-290/psql.csv
@@ -0,0 +1,5 @@
+1,abc,"test line 1
+test line 2",,""
+2,xyz,"\b: \t:	 \n:
+ \r:
",a,b
+3,a,"b,c,d","""quoted""",e
diff --git a/src/test/resources/org/apache/commons/csv/CSV-290/psql.tsv b/src/test/resources/org/apache/commons/csv/CSV-290/psql.tsv
new file mode 100644
index 0000000000..5358d8eac6
--- /dev/null
+++ b/src/test/resources/org/apache/commons/csv/CSV-290/psql.tsv
@@ -0,0 +1,3 @@
+1	abc	test line 1\ntest line 2	\N	
+2	xyz	\\b:\b \\t:\t \\n:\n \\r:\r	a	b
+3	a	b,c,d	"quoted"	e
diff --git a/src/test/resources/org/apache/commons/csv/CSVFormat.java b/src/test/resources/org/apache/commons/csv/CSVFormat.java
deleted file mode 100644
index c00f993f29..0000000000
--- a/src/test/resources/org/apache/commons/csv/CSVFormat.java
+++ /dev/null
@@ -1,2330 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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 org.apache.commons.csv;
-
-import static org.apache.commons.csv.Constants.BACKSLASH;
-import static org.apache.commons.csv.Constants.COMMA;
-import static org.apache.commons.csv.Constants.COMMENT;
-import static org.apache.commons.csv.Constants.CR;
-import static org.apache.commons.csv.Constants.CRLF;
-import static org.apache.commons.csv.Constants.DOUBLE_QUOTE_CHAR;
-import static org.apache.commons.csv.Constants.EMPTY;
-import static org.apache.commons.csv.Constants.LF;
-import static org.apache.commons.csv.Constants.PIPE;
-import static org.apache.commons.csv.Constants.SP;
-import static org.apache.commons.csv.Constants.TAB;
-
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.OutputStreamWriter;
-import java.io.Reader;
-import java.io.Serializable;
-import java.io.StringWriter;
-import java.io.Writer;
-import java.nio.charset.Charset;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.sql.ResultSet;
-import java.sql.ResultSetMetaData;
-import java.sql.SQLException;
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.Set;
-
-/**
- * Specifies the format of a CSV file and parses input.
- *
- * 
Using predefined formats
- *
- * 

- * You can use one of the predefined formats:
- * 
- *
- * 

- * 
{@link #DEFAULT}
- * 
{@link #EXCEL}
- * 
{@link #INFORMIX_UNLOAD}
- * 
{@link #INFORMIX_UNLOAD_CSV}
- * 
{@link #MYSQL}
- * 
{@link #RFC4180}
- * 
{@link #ORACLE}
- * 
{@link #POSTGRESQL_CSV}
- * 
{@link #POSTGRESQL_TEXT}
- * 
{@link #TDF}
- * 
- *
- * 

- * For example:
- * 
- *
- * 
- * CSVParser parser = CSVFormat.EXCEL.parse(reader);
- * 
- *
- * 

- * The {@link CSVParser} provides static methods to parse other input types, for example:
- * 
- *
- * 
- * CSVParser parser = CSVParser.parse(file, StandardCharsets.US_ASCII, CSVFormat.EXCEL);
- * 
- *
- * 
Defining formats
- *
- * 

- * You can extend a format by calling the {@code with} methods. For example:
- * 
- *
- * 
- * CSVFormat.EXCEL.withNullString("N/A").withIgnoreSurroundingSpaces(true);
- * 
- *
- * 
Defining column names
- *
- * 

- * To define the column names you want to use to access records, write:
- * 
- *
- * 
- * CSVFormat.EXCEL.withHeader("Col1", "Col2", "Col3");
- * 
- *
- * 

- * Calling {@link #withHeader(String...)} lets you use the given names to address values in a {@link CSVRecord}, and
- * assumes that your CSV source does not contain a first record that also defines column names.
- *
- * If it does, then you are overriding this metadata with your names and you should skip the first record by calling
- * {@link #withSkipHeaderRecord(boolean)} with {@code true}.
- * 
- *
- * 
Parsing
- *
- * 

- * You can use a format directly to parse a reader. For example, to parse an Excel file with columns header, write:
- * 
- *
- * 
- * Reader in = ...;
- * CSVFormat.EXCEL.withHeader("Col1", "Col2", "Col3").parse(in);
- * 
- *
- * 

- * For other input types, like resources, files, and URLs, use the static methods on {@link CSVParser}.
- * 
- *
- * 
Referencing columns safely
- *
- * 

- * If your source contains a header record, you can simplify your code and safely reference columns, by using
- * {@link #withHeader(String...)} with no arguments:
- * 
- *
- * 
- * CSVFormat.EXCEL.withHeader();
- * 
- *
- * 

- * This causes the parser to read the first record and use its values as column names.
- *
- * Then, call one of the {@link CSVRecord} get method that takes a String column name argument:
- * 
- *
- * 
- * String value = record.get("Col1");
- * 
- *
- * 

- * This makes your code impervious to changes in column order in the CSV file.
- * 
- *
- * 
Notes
- *
- * 

- * This class is immutable.
- * 
- */
-public final class CSVFormat implements Serializable {
-
-    /**
-     * Predefines formats.
-     *
-     * @since 1.2
-     */
-    public enum Predefined {
-
-        /**
-         * @see CSVFormat#DEFAULT
-         */
-        Default(CSVFormat.DEFAULT),
-
-        /**
-         * @see CSVFormat#EXCEL
-         */
-        Excel(CSVFormat.EXCEL),
-
-        /**
-         * @see CSVFormat#INFORMIX_UNLOAD
-         * @since 1.3
-         */
-        InformixUnload(CSVFormat.INFORMIX_UNLOAD),
-
-        /**
-         * @see CSVFormat#INFORMIX_UNLOAD_CSV
-         * @since 1.3
-         */
-        InformixUnloadCsv(CSVFormat.INFORMIX_UNLOAD_CSV),
-
-        /**
-         * @see CSVFormat#MONGODB_CSV
-         * @since 1.7
-         */
-        MongoDBCsv(CSVFormat.MONGODB_CSV),
-
-        /**
-         * @see CSVFormat#MONGODB_TSV
-         * @since 1.7
-         */
-        MongoDBTsv(CSVFormat.MONGODB_TSV),
-
-        /**
-         * @see CSVFormat#MYSQL
-         */
-        MySQL(CSVFormat.MYSQL),
-
-        /**
-         * @see CSVFormat#ORACLE
-         */
-        Oracle(CSVFormat.ORACLE),
-
-        /**
-         * @see CSVFormat#POSTGRESQL_CSV
-         * @since 1.5
-         */
-        PostgreSQLCsv(CSVFormat.POSTGRESQL_CSV),
-
-        /**
-         * @see CSVFormat#POSTGRESQL_CSV
-         */
-        PostgreSQLText(CSVFormat.POSTGRESQL_TEXT),
-
-        /**
-         * @see CSVFormat#RFC4180
-         */
-        RFC4180(CSVFormat.RFC4180),
-
-        /**
-         * @see CSVFormat#TDF
-         */
-        TDF(CSVFormat.TDF);
-
-        private final CSVFormat format;
-
-        Predefined(final CSVFormat format) {
-            this.format = format;
-        }
-
-        /**
-         * Gets the format.
-         *
-         * @return the format.
-         */
-        public CSVFormat getFormat() {
-            return format;
-        }
-    }
-
-    /**
-     * Standard Comma Separated Value format, as for {@link #RFC4180} but allowing empty lines.
-     *
-     * 

-     * Settings are:
-     * 
-     * 

-     * 
{@code withDelimiter(',')}
-     * 
{@code withQuote('"')}
-     * 
{@code withRecordSeparator("\r\n")}
-     * 
{@code withIgnoreEmptyLines(true)}
-     * 
{@code withAllowDuplicateHeaderNames(true)}
-     * 
-     *
-     * @see Predefined#Default
-     */
-    public static final CSVFormat DEFAULT = new CSVFormat(COMMA, DOUBLE_QUOTE_CHAR, null, null, null, false, true, CRLF,
-            null, null, null, false, false, false, false, false, false, true);
-
-    /**
-     * Excel file format (using a comma as the value delimiter). Note that the actual value delimiter used by Excel is
-     * locale dependent, it might be necessary to customize this format to accommodate to your regional settings.
-     *
-     * 

-     * For example for parsing or generating a CSV file on a French system the following format will be used:
-     * 
-     *
-     * 
-     * CSVFormat fmt = CSVFormat.EXCEL.withDelimiter(';');
-     * 
-     *
-     * 

-     * Settings are:
-     * 
-     * 

-     * 
{@code withDelimiter(',')}
-     * 
{@code withQuote('"')}
-     * 
{@code withRecordSeparator("\r\n")}
-     * 
{@code withIgnoreEmptyLines(false)}
-     * 
{@code withAllowMissingColumnNames(true)}
-     * 
{@code withAllowDuplicateHeaderNames(true)}
-     * 
-     * 

-     * Note: This is currently like {@link #RFC4180} plus {@link #withAllowMissingColumnNames(boolean)
-     * withAllowMissingColumnNames(true)} and {@link #withIgnoreEmptyLines(boolean) withIgnoreEmptyLines(false)}.
-     * 
-     *
-     * @see Predefined#Excel
-     */
-    // @formatter:off
-    public static final CSVFormat EXCEL = DEFAULT
-            .withIgnoreEmptyLines(false)
-            .withAllowMissingColumnNames();
-    // @formatter:on
-
-    /**
-     * Default Informix CSV UNLOAD format used by the {@code UNLOAD TO file_name} operation.
-     *
-     * 

-     * This is a comma-delimited format with a LF character as the line separator. Values are not quoted and special
-     * characters are escaped with {@code '\'}. The default NULL string is {@code "\\N"}.
-     * 
-     *
-     * 

-     * Settings are:
-     * 
-     * 

-     * 
{@code withDelimiter(',')}
-     * 
{@code withEscape('\\')}
-     * 
{@code withQuote("\"")}
-     * 
{@code withRecordSeparator('\n')}
-     * 
-     *
-     * @see Predefined#MySQL
-     * @see 
-     *      http://www.ibm.com/support/knowledgecenter/SSBJG3_2.5.0/com.ibm.gen_busug.doc/c_fgl_InOutSql_UNLOAD.htm
-     * @since 1.3
-     */
-    // @formatter:off
-    public static final CSVFormat INFORMIX_UNLOAD = DEFAULT
-            .withDelimiter(PIPE)
-            .withEscape(BACKSLASH)
-            .withQuote(DOUBLE_QUOTE_CHAR)
-            .withRecordSeparator(LF);
-    // @formatter:on
-
-    /**
-     * Default Informix CSV UNLOAD format used by the {@code UNLOAD TO file_name} operation (escaping is disabled.)
-     *
-     * 

-     * This is a comma-delimited format with a LF character as the line separator. Values are not quoted and special
-     * characters are escaped with {@code '\'}. The default NULL string is {@code "\\N"}.
-     * 
-     *
-     * 

-     * Settings are:
-     * 
-     * 

-     * 
{@code withDelimiter(',')}
-     * 
{@code withQuote("\"")}
-     * 
{@code withRecordSeparator('\n')}
-     * 
-     *
-     * @see Predefined#MySQL
-     * @see 
-     *      http://www.ibm.com/support/knowledgecenter/SSBJG3_2.5.0/com.ibm.gen_busug.doc/c_fgl_InOutSql_UNLOAD.htm
-     * @since 1.3
-     */
-    // @formatter:off
-    public static final CSVFormat INFORMIX_UNLOAD_CSV = DEFAULT
-            .withDelimiter(COMMA)
-            .withQuote(DOUBLE_QUOTE_CHAR)
-            .withRecordSeparator(LF);
-    // @formatter:on
-
-    /**
-     * Default MongoDB CSV format used by the {@code mongoexport} operation.
-     * 

-     * Parsing is not supported yet.
-     * 
-     *
-     * 

-     * This is a comma-delimited format. Values are double quoted only if needed and special characters are escaped with
-     * {@code '"'}. A header line with field names is expected.
-     * 
-     *
-     * 

-     * Settings are:
-     * 
-     * 

-     * 
{@code withDelimiter(',')}
-     * 
{@code withEscape('"')}
-     * 
{@code withQuote('"')}
-     * 
{@code withQuoteMode(QuoteMode.ALL_NON_NULL)}
-     * 
{@code withSkipHeaderRecord(false)}
-     * 
-     *
-     * @see Predefined#MongoDBCsv
-     * @see MongoDB mongoexport command
-     *      documentation
-     * @since 1.7
-     */
-    // @formatter:off
-    public static final CSVFormat MONGODB_CSV = DEFAULT
-            .withDelimiter(COMMA)
-            .withEscape(DOUBLE_QUOTE_CHAR)
-            .withQuote(DOUBLE_QUOTE_CHAR)
-            .withQuoteMode(QuoteMode.MINIMAL)
-            .withSkipHeaderRecord(false);
-    // @formatter:off
-
-    /**
-     * Default MongoDB TSV format used by the {@code mongoexport} operation.
-     * 

-     * Parsing is not supported yet.
-     * 
-     *
-     * 

-     * This is a tab-delimited format. Values are double quoted only if needed and special
-     * characters are escaped with {@code '"'}. A header line with field names is expected.
-     * 
-     *
-     * 

-     * Settings are:
-     * 
-     * 

-     * 
{@code withDelimiter('\t')}
-     * 
{@code withEscape('"')}
-     * 
{@code withQuote('"')}
-     * 
{@code withQuoteMode(QuoteMode.ALL_NON_NULL)}
-     * 
{@code withSkipHeaderRecord(false)}
-     * 
-     *
-     * @see Predefined#MongoDBCsv
-     * @see MongoDB mongoexport command
-     *          documentation
-     * @since 1.7
-     */
-    // @formatter:off
-    public static final CSVFormat MONGODB_TSV = DEFAULT
-            .withDelimiter(TAB)
-            .withEscape(DOUBLE_QUOTE_CHAR)
-            .withQuote(DOUBLE_QUOTE_CHAR)
-            .withQuoteMode(QuoteMode.MINIMAL)
-            .withSkipHeaderRecord(false);
-    // @formatter:off
-
-    /**
-     * Default MySQL format used by the {@code SELECT INTO OUTFILE} and {@code LOAD DATA INFILE} operations.
-     *
-     * 

-     * This is a tab-delimited format with a LF character as the line separator. Values are not quoted and special
-     * characters are escaped with {@code '\'}. The default NULL string is {@code "\\N"}.
-     * 
-     *
-     * 

-     * Settings are:
-     * 
-     * 

-     * 
{@code withDelimiter('\t')}
-     * 
{@code withEscape('\\')}
-     * 
{@code withIgnoreEmptyLines(false)}
-     * 
{@code withQuote(null)}
-     * 
{@code withRecordSeparator('\n')}
-     * 
{@code withNullString("\\N")}
-     * 
{@code withQuoteMode(QuoteMode.ALL_NON_NULL)}
-     * 
-     *
-     * @see Predefined#MySQL
-     * @see  http://dev.mysql.com/doc/refman/5.1/en/load
-     *      -data.html
-     */
-    // @formatter:off
-    public static final CSVFormat MYSQL = DEFAULT
-            .withDelimiter(TAB)
-            .withEscape(BACKSLASH)
-            .withIgnoreEmptyLines(false)
-            .withQuote(null)
-            .withRecordSeparator(LF)
-            .withNullString("\\N")
-            .withQuoteMode(QuoteMode.ALL_NON_NULL);
-    // @formatter:off
-
-    /**
-     * Default Oracle format used by the SQL*Loader utility.
-     *
-     * 

-     * This is a comma-delimited format with the system line separator character as the record separator.Values are
-     * double quoted when needed and special characters are escaped with {@code '"'}. The default NULL string is
-     * {@code ""}. Values are trimmed.
-     * 
-     *
-     * 

-     * Settings are:
-     * 
-     * 

-     * 
{@code withDelimiter(',') // default is {@code FIELDS TERMINATED BY ','}}
-     * 
{@code withEscape('\\')}
-     * 
{@code withIgnoreEmptyLines(false)}
-     * 
{@code withQuote('"')  // default is {@code OPTIONALLY ENCLOSED BY '"'}}
-     * 
{@code withNullString("\\N")}
-     * 
{@code withTrim()}
-     * 
{@code withSystemRecordSeparator()}
-     * 
{@code withQuoteMode(QuoteMode.MINIMAL)}
-     * 
-     *
-     * @see Predefined#Oracle
-     * @see Oracle CSV Format Specification
-     * @since 1.6
-     */
-    // @formatter:off
-    public static final CSVFormat ORACLE = DEFAULT
-            .withDelimiter(COMMA)
-            .withEscape(BACKSLASH)
-            .withIgnoreEmptyLines(false)
-            .withQuote(DOUBLE_QUOTE_CHAR)
-            .withNullString("\\N")
-            .withTrim()
-            .withSystemRecordSeparator()
-            .withQuoteMode(QuoteMode.MINIMAL);
-    // @formatter:off
-
-    /**
-     * Default PostgreSQL CSV format used by the {@code COPY} operation.
-     *
-     * 

-     * This is a comma-delimited format with a LF character as the line separator. Values are double quoted and special
-     * characters are escaped with {@code '"'}. The default NULL string is {@code ""}.
-     * 
-     *
-     * 

-     * Settings are:
-     * 
-     * 

-     * 
{@code withDelimiter(',')}
-     * 
{@code withEscape('"')}
-     * 
{@code withIgnoreEmptyLines(false)}
-     * 
{@code withQuote('"')}
-     * 
{@code withRecordSeparator('\n')}
-     * 
{@code withNullString("")}
-     * 
{@code withQuoteMode(QuoteMode.ALL_NON_NULL)}
-     * 
-     *
-     * @see Predefined#MySQL
-     * @see PostgreSQL COPY command
-     *          documentation
-     * @since 1.5
-     */
-    // @formatter:off
-    public static final CSVFormat POSTGRESQL_CSV = DEFAULT
-            .withDelimiter(COMMA)
-            .withEscape(DOUBLE_QUOTE_CHAR)
-            .withIgnoreEmptyLines(false)
-            .withQuote(DOUBLE_QUOTE_CHAR)
-            .withRecordSeparator(LF)
-            .withNullString(EMPTY)
-            .withQuoteMode(QuoteMode.ALL_NON_NULL);
-    // @formatter:off
-
-    /**
-     * Default PostgreSQL text format used by the {@code COPY} operation.
-     *
-     * 

-     * This is a tab-delimited format with a LF character as the line separator. Values are double quoted and special
-     * characters are escaped with {@code '"'}. The default NULL string is {@code "\\N"}.
-     * 
-     *
-     * 

-     * Settings are:
-     * 
-     * 

-     * 
{@code withDelimiter('\t')}
-     * 
{@code withEscape('\\')}
-     * 
{@code withIgnoreEmptyLines(false)}
-     * 
{@code withQuote('"')}
-     * 
{@code withRecordSeparator('\n')}
-     * 
{@code withNullString("\\N")}
-     * 
{@code withQuoteMode(QuoteMode.ALL_NON_NULL)}
-     * 
-     *
-     * @see Predefined#MySQL
-     * @see PostgreSQL COPY command
-     *          documentation
-     * @since 1.5
-     */
-    // @formatter:off
-    public static final CSVFormat POSTGRESQL_TEXT = DEFAULT
-            .withDelimiter(TAB)
-            .withEscape(BACKSLASH)
-            .withIgnoreEmptyLines(false)
-            .withQuote(DOUBLE_QUOTE_CHAR)
-            .withRecordSeparator(LF)
-            .withNullString("\\N")
-            .withQuoteMode(QuoteMode.ALL_NON_NULL);
-    // @formatter:off
-
-    /**
-     * Comma separated format as defined by RFC 4180.
-     *
-     * 

-     * Settings are:
-     * 
-     * 

-     * 
{@code withDelimiter(',')}
-     * 
{@code withQuote('"')}
-     * 
{@code withRecordSeparator("\r\n")}
-     * 
{@code withIgnoreEmptyLines(false)}
-     * 
-     *
-     * @see Predefined#RFC4180
-     */
-    public static final CSVFormat RFC4180 = DEFAULT.withIgnoreEmptyLines(false);
-
-    private static final long serialVersionUID = 1L;
-
-    /**
-     * Tab-delimited format.
-     *
-     * 

-     * Settings are:
-     * 
-     * 

-     * 
{@code withDelimiter('\t')}
-     * 
{@code withQuote('"')}
-     * 
{@code withRecordSeparator("\r\n")}
-     * 
{@code withIgnoreSurroundingSpaces(true)}
-     * 
-     *
-     * @see Predefined#TDF
-     */
-    // @formatter:off
-    public static final CSVFormat TDF = DEFAULT
-            .withDelimiter(TAB)
-            .withIgnoreSurroundingSpaces();
-    // @formatter:on
-
-    /**
-     * Returns true if the given character is a line break character.
-     *
-     * @param c
-     *            the character to check
-     *
-     * @return true if {@code c} is a line break character
-     */
-    private static boolean isLineBreak(final char c) {
-        return c == LF || c == CR;
-    }
-
-    /**
-     * Returns true if the given character is a line break character.
-     *
-     * @param c
-     *            the character to check, may be null
-     *
-     * @return true if {@code c} is a line break character (and not null)
-     */
-    private static boolean isLineBreak(final Character c) {
-        return c != null && isLineBreak(c.charValue());
-    }
-
-    /**
-     * Creates a new CSV format with the specified delimiter.
-     *
-     * 

-     * Use this method if you want to create a CSVFormat from scratch. All fields but the delimiter will be initialized
-     * with null/false.
-     * 
-     *
-     * @param delimiter
-     *            the char used for value separation, must not be a line break character
-     * @return a new CSV format.
-     * @throws IllegalArgumentException
-     *             if the delimiter is a line break character
-     *
-     * @see #DEFAULT
-     * @see #RFC4180
-     * @see #MYSQL
-     * @see #EXCEL
-     * @see #TDF
-     */
-    public static CSVFormat newFormat(final char delimiter) {
-        return new CSVFormat(delimiter, null, null, null, null, false, false, null, null, null, null, false, false,
-                false, false, false, false, true);
-    }
-
-    /**
-     * Gets one of the predefined formats from {@link CSVFormat.Predefined}.
-     *
-     * @param format
-     *            name
-     * @return one of the predefined formats
-     * @since 1.2
-     */
-    public static CSVFormat valueOf(final String format) {
-        return CSVFormat.Predefined.valueOf(format).getFormat();
-    }
-
-    private final boolean allowDuplicateHeaderNames;
-
-    private final boolean allowMissingColumnNames;
-
-    private final boolean autoFlush;
-
-    private final Character commentMarker; // null if commenting is disabled
-
-    private final char delimiter;
-
-    private final Character escapeCharacter; // null if escaping is disabled
-
-    private final String[] header; // array of header column names
-
-    private final String[] headerComments; // array of header comment lines
-
-    private final boolean ignoreEmptyLines;
-
-    private final boolean ignoreHeaderCase; // should ignore header names case
-
-    private final boolean ignoreSurroundingSpaces; // Should leading/trailing spaces be ignored around values?
-
-    private final String nullString; // the string to be used for null values
-
-    private final Character quoteCharacter; // null if quoting is disabled
-
-    private final String quotedNullString;
-
-    private final QuoteMode quoteMode;
-
-    private final String recordSeparator; // for outputs
-
-    private final boolean skipHeaderRecord;
-
-    private final boolean trailingDelimiter;
-
-    private final boolean trim;
-
-    /**
-     * Creates a customized CSV format.
-     *
-     * @param delimiter
-     *            the char used for value separation, must not be a line break character
-     * @param quoteChar
-     *            the Character used as value encapsulation marker, may be {@code null} to disable
-     * @param quoteMode
-     *            the quote mode
-     * @param commentStart
-     *            the Character used for comment identification, may be {@code null} to disable
-     * @param escape
-     *            the Character used to escape special characters in values, may be {@code null} to disable
-     * @param ignoreSurroundingSpaces
-     *            {@code true} when whitespaces enclosing values should be ignored
-     * @param ignoreEmptyLines
-     *            {@code true} when the parser should skip empty lines
-     * @param recordSeparator
-     *            the line separator to use for output
-     * @param nullString
-     *            the line separator to use for output
-     * @param headerComments
-     *            the comments to be printed by the Printer before the actual CSV data
-     * @param header
-     *            the header
-     * @param skipHeaderRecord
-     *            TODO
-     * @param allowMissingColumnNames
-     *            TODO
-     * @param ignoreHeaderCase
-     *            TODO
-     * @param trim
-     *            TODO
-     * @param trailingDelimiter
-     *            TODO
-     * @param autoFlush
-     * @throws IllegalArgumentException
-     *             if the delimiter is a line break character
-     */
-    private CSVFormat(final char delimiter, final Character quoteChar, final QuoteMode quoteMode,
-            final Character commentStart, final Character escape, final boolean ignoreSurroundingSpaces,
-            final boolean ignoreEmptyLines, final String recordSeparator, final String nullString,
-            final Object[] headerComments, final String[] header, final boolean skipHeaderRecord,
-            final boolean allowMissingColumnNames, final boolean ignoreHeaderCase, final boolean trim,
-            final boolean trailingDelimiter, final boolean autoFlush, final boolean allowDuplicateHeaderNames) {
-        this.delimiter = delimiter;
-        this.quoteCharacter = quoteChar;
-        this.quoteMode = quoteMode;
-        this.commentMarker = commentStart;
-        this.escapeCharacter = escape;
-        this.ignoreSurroundingSpaces = ignoreSurroundingSpaces;
-        this.allowMissingColumnNames = allowMissingColumnNames;
-        this.ignoreEmptyLines = ignoreEmptyLines;
-        this.recordSeparator = recordSeparator;
-        this.nullString = nullString;
-        this.headerComments = toStringArray(headerComments);
-        this.header = header == null ? null : header.clone();
-        this.skipHeaderRecord = skipHeaderRecord;
-        this.ignoreHeaderCase = ignoreHeaderCase;
-        this.trailingDelimiter = trailingDelimiter;
-        this.trim = trim;
-        this.autoFlush = autoFlush;
-        this.quotedNullString = quoteCharacter + nullString + quoteCharacter;
-        this.allowDuplicateHeaderNames = allowDuplicateHeaderNames;
-        validate();
-    }
-
-    @Override
-    public boolean equals(final Object obj) {
-        if (this == obj) {
-            return true;
-        }
-        if (obj == null) {
-            return false;
-        }
-        if (getClass() != obj.getClass()) {
-            return false;
-        }
-
-        final CSVFormat other = (CSVFormat) obj;
-        if (delimiter != other.delimiter) {
-            return false;
-        }
-        if (trailingDelimiter != other.trailingDelimiter) {
-            return false;
-        }
-        if (autoFlush != other.autoFlush) {
-            return false;
-        }
-        if (trim != other.trim) {
-            return false;
-        }
-        if (allowMissingColumnNames != other.allowMissingColumnNames) {
-            return false;
-        }
-        if (allowDuplicateHeaderNames != other.allowDuplicateHeaderNames) {
-            return false;
-        }
-        if (ignoreHeaderCase != other.ignoreHeaderCase) {
-            return false;
-        }
-        if (quoteMode != other.quoteMode) {
-            return false;
-        }
-        if (quoteCharacter == null) {
-            if (other.quoteCharacter != null) {
-                return false;
-            }
-        } else if (!quoteCharacter.equals(other.quoteCharacter)) {
-            return false;
-        }
-        if (commentMarker == null) {
-            if (other.commentMarker != null) {
-                return false;
-            }
-        } else if (!commentMarker.equals(other.commentMarker)) {
-            return false;
-        }
-        if (escapeCharacter == null) {
-            if (other.escapeCharacter != null) {
-                return false;
-            }
-        } else if (!escapeCharacter.equals(other.escapeCharacter)) {
-            return false;
-        }
-        if (nullString == null) {
-            if (other.nullString != null) {
-                return false;
-            }
-        } else if (!nullString.equals(other.nullString)) {
-            return false;
-        }
-        if (!Arrays.equals(header, other.header)) {
-            return false;
-        }
-        if (ignoreSurroundingSpaces != other.ignoreSurroundingSpaces) {
-            return false;
-        }
-        if (ignoreEmptyLines != other.ignoreEmptyLines) {
-            return false;
-        }
-        if (skipHeaderRecord != other.skipHeaderRecord) {
-            return false;
-        }
-        if (recordSeparator == null) {
-            if (other.recordSeparator != null) {
-                return false;
-            }
-        } else if (!recordSeparator.equals(other.recordSeparator)) {
-            return false;
-        }
-        if (!Arrays.equals(headerComments, other.headerComments)) {
-            return false;
-        }
-        return true;
-    }
-
-    /**
-     * Formats the specified values.
-     *
-     * @param values
-     *            the values to format
-     * @return the formatted values
-     */
-    public String format(final Object... values) {
-        final StringWriter out = new StringWriter();
-        try (CSVPrinter csvPrinter = new CSVPrinter(out, this)) {
-            csvPrinter.printRecord(values);
-            String res = out.toString();
-            int len = recordSeparator != null ? res.length() - recordSeparator.length() : res.length();
-            return res.substring(0, len);
-        } catch (final IOException e) {
-            // should not happen because a StringWriter does not do IO.
-            throw new IllegalStateException(e);
-        }
-    }
-
-    /**
-     * Returns true if and only if duplicate names are allowed in the headers.
-     *
-     * @return whether duplicate header names are allowed
-     * @since 1.7
-     */
-    public boolean getAllowDuplicateHeaderNames() {
-        return allowDuplicateHeaderNames;
-    }
-
-    /**
-     * Specifies whether missing column names are allowed when parsing the header line.
-     *
-     * @return {@code true} if missing column names are allowed when parsing the header line, {@code false} to throw an
-     *         {@link IllegalArgumentException}.
-     */
-    public boolean getAllowMissingColumnNames() {
-        return allowMissingColumnNames;
-    }
-
-    /**
-     * Returns whether to flush on close.
-     *
-     * @return whether to flush on close.
-     * @since 1.6
-     */
-    public boolean getAutoFlush() {
-        return autoFlush;
-    }
-
-    /**
-     * Returns the character marking the start of a line comment.
-     *
-     * @return the comment start marker, may be {@code null}
-     */
-    public Character getCommentMarker() {
-        return commentMarker;
-    }
-
-    /**
-     * Returns the character delimiting the values (typically ';', ',' or '\t').
-     *
-     * @return the delimiter character
-     */
-    public char getDelimiter() {
-        return delimiter;
-    }
-
-    /**
-     * Returns the escape character.
-     *
-     * @return the escape character, may be {@code null}
-     */
-    public Character getEscapeCharacter() {
-        return escapeCharacter;
-    }
-
-    /**
-     * Returns a copy of the header array.
-     *
-     * @return a copy of the header array; {@code null} if disabled, the empty array if to be read from the file
-     */
-    public String[] getHeader() {
-        return header != null ? header.clone() : null;
-    }
-
-    /**
-     * Returns a copy of the header comment array.
-     *
-     * @return a copy of the header comment array; {@code null} if disabled.
-     */
-    public String[] getHeaderComments() {
-        return headerComments != null ? headerComments.clone() : null;
-    }
-
-    /**
-     * Specifies whether empty lines between records are ignored when parsing input.
-     *
-     * @return {@code true} if empty lines between records are ignored, {@code false} if they are turned into empty
-     *         records.
-     */
-    public boolean getIgnoreEmptyLines() {
-        return ignoreEmptyLines;
-    }
-
-    /**
-     * Specifies whether header names will be accessed ignoring case.
-     *
-     * @return {@code true} if header names cases are ignored, {@code false} if they are case sensitive.
-     * @since 1.3
-     */
-    public boolean getIgnoreHeaderCase() {
-        return ignoreHeaderCase;
-    }
-
-    /**
-     * Specifies whether spaces around values are ignored when parsing input.
-     *
-     * @return {@code true} if spaces around values are ignored, {@code false} if they are treated as part of the value.
-     */
-    public boolean getIgnoreSurroundingSpaces() {
-        return ignoreSurroundingSpaces;
-    }
-
-    /**
-     * Gets the String to convert to and from {@code null}.
-     * 

-     * 
Reading: Converts strings equal to the given {@code nullString} to {@code null} when reading
-     * records.
-     * 
Writing: Writes {@code null} as the given {@code nullString} when writing records.
-     * 
-     *
-     * @return the String to convert to and from {@code null}. No substitution occurs if {@code null}
-     */
-    public String getNullString() {
-        return nullString;
-    }
-
-    /**
-     * Returns the character used to encapsulate values containing special characters.
-     *
-     * @return the quoteChar character, may be {@code null}
-     */
-    public Character getQuoteCharacter() {
-        return quoteCharacter;
-    }
-
-    /**
-     * Returns the quote policy output fields.
-     *
-     * @return the quote policy
-     */
-    public QuoteMode getQuoteMode() {
-        return quoteMode;
-    }
-
-    /**
-     * Returns the record separator delimiting output records.
-     *
-     * @return the record separator
-     */
-    public String getRecordSeparator() {
-        return recordSeparator;
-    }
-
-    /**
-     * Returns whether to skip the header record.
-     *
-     * @return whether to skip the header record.
-     */
-    public boolean getSkipHeaderRecord() {
-        return skipHeaderRecord;
-    }
-
-    /**
-     * Returns whether to add a trailing delimiter.
-     *
-     * @return whether to add a trailing delimiter.
-     * @since 1.3
-     */
-    public boolean getTrailingDelimiter() {
-        return trailingDelimiter;
-    }
-
-    /**
-     * Returns whether to trim leading and trailing blanks.
-     * This is used by {@link #print(Object, Appendable, boolean)}
-     * Also by {@link CSVParser#addRecordValue(boolean)}
-     *
-     * @return whether to trim leading and trailing blanks.
-     */
-    public boolean getTrim() {
-        return trim;
-    }
-
-    @Override
-    public int hashCode() {
-        final int prime = 31;
-        int result = 1;
-
-        result = prime * result + delimiter;
-        result = prime * result + ((quoteMode == null) ? 0 : quoteMode.hashCode());
-        result = prime * result + ((quoteCharacter == null) ? 0 : quoteCharacter.hashCode());
-        result = prime * result + ((commentMarker == null) ? 0 : commentMarker.hashCode());
-        result = prime * result + ((escapeCharacter == null) ? 0 : escapeCharacter.hashCode());
-        result = prime * result + ((nullString == null) ? 0 : nullString.hashCode());
-        result = prime * result + (ignoreSurroundingSpaces ? 1231 : 1237);
-        result = prime * result + (ignoreHeaderCase ? 1231 : 1237);
-        result = prime * result + (ignoreEmptyLines ? 1231 : 1237);
-        result = prime * result + (skipHeaderRecord ? 1231 : 1237);
-        result = prime * result + (allowDuplicateHeaderNames ? 1231 : 1237);
-        result = prime * result + (trim ? 1231 : 1237);
-        result = prime * result + (autoFlush ? 1231 : 1237);
-        result = prime * result + (trailingDelimiter ? 1231 : 1237);
-        result = prime * result + (allowMissingColumnNames ? 1231 : 1237);
-        result = prime * result + ((recordSeparator == null) ? 0 : recordSeparator.hashCode());
-        result = prime * result + Arrays.hashCode(header);
-        result = prime * result + Arrays.hashCode(headerComments);
-        return result;
-    }
-
-    /**
-     * Specifies whether comments are supported by this format.
-     *
-     * Note that the comment introducer character is only recognized at the start of a line.
-     *
-     * @return {@code true} is comments are supported, {@code false} otherwise
-     */
-    public boolean isCommentMarkerSet() {
-        return commentMarker != null;
-    }
-
-    /**
-     * Returns whether escape are being processed.
-     *
-     * @return {@code true} if escapes are processed
-     */
-    public boolean isEscapeCharacterSet() {
-        return escapeCharacter != null;
-    }
-
-    /**
-     * Returns whether a nullString has been defined.
-     *
-     * @return {@code true} if a nullString is defined
-     */
-    public boolean isNullStringSet() {
-        return nullString != null;
-    }
-
-    /**
-     * Returns whether a quoteChar has been defined.
-     *
-     * @return {@code true} if a quoteChar is defined
-     */
-    public boolean isQuoteCharacterSet() {
-        return quoteCharacter != null;
-    }
-
-    /**
-     * Parses the specified content.
-     *
-     * 

-     * See also the various static parse methods on {@link CSVParser}.
-     * 
-     *
-     * @param in
-     *            the input stream
-     * @return a parser over a stream of {@link CSVRecord}s.
-     * @throws IOException
-     *             If an I/O error occurs
-     */
-    public CSVParser parse(final Reader in) throws IOException {
-        return new CSVParser(in, this);
-    }
-
-    /**
-     * Prints to the specified output.
-     *
-     * 

-     * See also {@link CSVPrinter}.
-     * 
-     *
-     * @param out
-     *            the output.
-     * @return a printer to an output.
-     * @throws IOException
-     *             thrown if the optional header cannot be printed.
-     */
-    public CSVPrinter print(final Appendable out) throws IOException {
-        return new CSVPrinter(out, this);
-    }
-
-    /**
-     * Prints to the specified output.
-     *
-     * 

-     * See also {@link CSVPrinter}.
-     * 
-     *
-     * @param out
-     *            the output.
-     * @param charset
-     *            A charset.
-     * @return a printer to an output.
-     * @throws IOException
-     *             thrown if the optional header cannot be printed.
-     * @since 1.5
-     */
-    @SuppressWarnings("resource")
-    public CSVPrinter print(final File out, final Charset charset) throws IOException {
-        // The writer will be closed when close() is called.
-        return new CSVPrinter(new OutputStreamWriter(new FileOutputStream(out), charset), this);
-    }
-
-    /**
-     * Prints the {@code value} as the next value on the line to {@code out}. The value will be escaped or encapsulated
-     * as needed. Useful when one wants to avoid creating CSVPrinters.
-     * Trims the value if {@link #getTrim()} is true
-     * @param value
-     *            value to output.
-     * @param out
-     *            where to print the value.
-     * @param newRecord
-     *            if this a new record.
-     * @throws IOException
-     *             If an I/O error occurs.
-     * @since 1.4
-     */
-    public void print(final Object value, final Appendable out, final boolean newRecord) throws IOException {
-        // null values are considered empty
-        // Only call CharSequence.toString() if you have to, helps GC-free use cases.
-        CharSequence charSequence;
-        if (value == null) {
-            // https://issues.apache.org/jira/browse/CSV-203
-            if (null == nullString) {
-                charSequence = EMPTY;
-            } else {
-                if (QuoteMode.ALL == quoteMode) {
-                    charSequence = quotedNullString;
-                } else {
-                    charSequence = nullString;
-                }
-            }
-        } else {
-            if (value instanceof CharSequence) {
-                charSequence = (CharSequence) value;
-            } else if (value instanceof Reader) {
-                print((Reader) value, out, newRecord);
-                return;
-            } else {
-                charSequence = value.toString();
-            }
-        }
-        charSequence = getTrim() ? trim(charSequence) : charSequence;
-        print(value, charSequence, out, newRecord);
-    }
-
-    private void print(final Object object, final CharSequence value, final Appendable out, final boolean newRecord)
-            throws IOException {
-        final int offset = 0;
-        final int len = value.length();
-        if (!newRecord) {
-            out.append(getDelimiter());
-        }
-        if (object == null) {
-            out.append(value);
-        } else if (isQuoteCharacterSet()) {
-            // the original object is needed so can check for Number
-            printWithQuotes(object, value, out, newRecord);
-        } else if (isEscapeCharacterSet()) {
-            printWithEscapes(value, out);
-        } else {
-            out.append(value, offset, len);
-        }
-    }
-
-    /**
-     * Prints to the specified output, returns a {@code CSVPrinter} which the caller MUST close.
-     *
-     * 

-     * See also {@link CSVPrinter}.
-     * 
-     *
-     * @param out the output.
-     * @param charset A charset.
-     * @return a printer to an output.
-     * @throws IOException thrown if the optional header cannot be printed.
-     * @since 1.5
-     */
-    @SuppressWarnings("resource")
-    public CSVPrinter print(final Path out, final Charset charset) throws IOException {
-        return print(Files.newBufferedWriter(out, charset));
-    }
-
-    private void print(final Reader reader, final Appendable out, final boolean newRecord) throws IOException {
-        // Reader is never null
-        if (!newRecord) {
-            out.append(getDelimiter());
-        }
-        if (isQuoteCharacterSet()) {
-            printWithQuotes(reader, out);
-        } else if (isEscapeCharacterSet()) {
-            printWithEscapes(reader, out);
-        } else if (out instanceof Writer) {
-            IOUtils.copyLarge(reader, (Writer) out);
-        } else {
-            IOUtils.copy(reader, out);
-        }
-
-    }
-
-    /**
-     * Prints to the {@link System#out}.
-     *
-     * 

-     * See also {@link CSVPrinter}.
-     * 
-     *
-     * @return a printer to {@link System#out}.
-     * @throws IOException
-     *             thrown if the optional header cannot be printed.
-     * @since 1.5
-     */
-    public CSVPrinter printer() throws IOException {
-        return new CSVPrinter(System.out, this);
-    }
-
-    /**
-     * Outputs the trailing delimiter (if set) followed by the record separator (if set).
-     *
-     * @param out
-     *            where to write
-     * @throws IOException
-     *             If an I/O error occurs
-     * @since 1.4
-     */
-    public void println(final Appendable out) throws IOException {
-        if (getTrailingDelimiter()) {
-            out.append(getDelimiter());
-        }
-        if (recordSeparator != null) {
-            out.append(recordSeparator);
-        }
-    }
-
-    /**
-     * Prints the given {@code values} to {@code out} as a single record of delimiter separated values followed by the
-     * record separator.
-     *
-     * 

-     * The values will be quoted if needed. Quotes and new-line characters will be escaped. This method adds the record
-     * separator to the output after printing the record, so there is no need to call {@link #println(Appendable)}.
-     * 
-     *
-     * @param out
-     *            where to write.
-     * @param values
-     *            values to output.
-     * @throws IOException
-     *             If an I/O error occurs.
-     * @since 1.4
-     */
-    public void printRecord(final Appendable out, final Object... values) throws IOException {
-        for (int i = 0; i < values.length; i++) {
-            print(values[i], out, i == 0);
-        }
-        println(out);
-    }
-
-    /*
-     * Note: must only be called if escaping is enabled, otherwise will generate NPE
-     */
-    private void printWithEscapes(final CharSequence value, final Appendable out) throws IOException {
-        int start = 0;
-        int pos = 0;
-        final int len = value.length();
-        final int end = len;
-
-        final char delim = getDelimiter();
-        final char escape = getEscapeCharacter().charValue();
-
-        while (pos < end) {
-            char c = value.charAt(pos);
-            if (c == CR || c == LF || c == delim || c == escape) {
-                // write out segment up until this char
-                if (pos > start) {
-                    out.append(value, start, pos);
-                }
-                if (c == LF) {
-                    c = 'n';
-                } else if (c == CR) {
-                    c = 'r';
-                }
-
-                out.append(escape);
-                out.append(c);
-
-                start = pos + 1; // start on the current char after this one
-            }
-            pos++;
-        }
-
-        // write last segment
-        if (pos > start) {
-            out.append(value, start, pos);
-        }
-    }
-
-    private void printWithEscapes(final Reader reader, final Appendable out) throws IOException {
-        int start = 0;
-        int pos = 0;
-
-        final char delim = getDelimiter();
-        final char escape = getEscapeCharacter().charValue();
-        final StringBuilder builder = new StringBuilder(IOUtils.DEFAULT_BUFFER_SIZE);
-
-        int c;
-        while (-1 != (c = reader.read())) {
-            builder.append((char) c);
-            if (c == CR || c == LF || c == delim || c == escape) {
-                // write out segment up until this char
-                if (pos > start) {
-                    out.append(builder.substring(start, pos));
-                    builder.setLength(0);
-                    pos = -1;
-                }
-                if (c == LF) {
-                    c = 'n';
-                } else if (c == CR) {
-                    c = 'r';
-                }
-
-                out.append(escape);
-                out.append((char) c);
-
-                start = pos + 1; // start on the current char after this one
-            }
-            pos++;
-        }
-
-        // write last segment
-        if (pos > start) {
-            out.append(builder.substring(start, pos));
-        }
-    }
-
-    /*
-     * Note: must only be called if quoting is enabled, otherwise will generate NPE
-     */
-    // the original object is needed so can check for Number
-    private void printWithQuotes(final Object object, final CharSequence value, final Appendable out,
-            final boolean newRecord) throws IOException {
-        boolean quote = false;
-        int start = 0;
-        int pos = 0;
-        final int len = value.length();
-        final int end = len;
-
-        final char delimChar = getDelimiter();
-        final char quoteChar = getQuoteCharacter().charValue();
-        // If escape char not specified, default to the quote char
-        // This avoids having to keep checking whether there is an escape character
-        // at the cost of checking against quote twice
-        final char escapeChar = isEscapeCharacterSet() ? getEscapeCharacter().charValue() : quoteChar;
-
-        QuoteMode quoteModePolicy = getQuoteMode();
-        if (quoteModePolicy == null) {
-            quoteModePolicy = QuoteMode.MINIMAL;
-        }
-        switch (quoteModePolicy) {
-        case ALL:
-        case ALL_NON_NULL:
-            quote = true;
-            break;
-        case NON_NUMERIC:
-            quote = !(object instanceof Number);
-            break;
-        case NONE:
-            // Use the existing escaping code
-            printWithEscapes(value, out);
-            return;
-        case MINIMAL:
-            if (len <= 0) {
-                // always quote an empty token that is the first
-                // on the line, as it may be the only thing on the
-                // line. If it were not quoted in that case,
-                // an empty line has no tokens.
-                if (newRecord) {
-                    quote = true;
-                }
-            } else {
-                char c = value.charAt(pos);
-
-                if (c <= COMMENT) {
-                    // Some other chars at the start of a value caused the parser to fail, so for now
-                    // encapsulate if we start in anything less than '#'. We are being conservative
-                    // by including the default comment char too.
-                    quote = true;
-                } else {
-                    while (pos < end) {
-                        c = value.charAt(pos);
-                        if (c == LF || c == CR || c == quoteChar || c == delimChar || c == escapeChar) {
-                            quote = true;
-                            break;
-                        }
-                        pos++;
-                    }
-
-                    if (!quote) {
-                        pos = end - 1;
-                        c = value.charAt(pos);
-                        // Some other chars at the end caused the parser to fail, so for now
-                        // encapsulate if we end in anything less than ' '
-                        if (c <= SP) {
-                            quote = true;
-                        }
-                    }
-                }
-            }
-
-            if (!quote) {
-                // no encapsulation needed - write out the original value
-                out.append(value, start, end);
-                return;
-            }
-            break;
-        default:
-            throw new IllegalStateException("Unexpected Quote value: " + quoteModePolicy);
-        }
-
-        if (!quote) {
-            // no encapsulation needed - write out the original value
-            out.append(value, start, end);
-            return;
-        }
-
-        // we hit something that needed encapsulation
-        out.append(quoteChar);
-
-        // Pick up where we left off: pos should be positioned on the first character that caused
-        // the need for encapsulation.
-        while (pos < end) {
-            final char c = value.charAt(pos);
-            if (c == quoteChar || c == escapeChar) {
-                // write out the chunk up until this point
-                out.append(value, start, pos);
-                out.append(escapeChar); // now output the escape
-                start = pos; // and restart with the matched char
-            }
-            pos++;
-        }
-
-        // write the last segment
-        out.append(value, start, pos);
-        out.append(quoteChar);
-    }
-
-    /**
-     * Always use quotes unless QuoteMode is NONE, so we not have to look ahead.
-     *
-     * @throws IOException
-     */
-    private void printWithQuotes(final Reader reader, final Appendable out) throws IOException {
-
-        if (getQuoteMode() == QuoteMode.NONE) {
-            printWithEscapes(reader, out);
-            return;
-        }
-
-        int pos = 0;
-
-        final char quote = getQuoteCharacter().charValue();
-        final StringBuilder builder = new StringBuilder(IOUtils.DEFAULT_BUFFER_SIZE);
-
-        out.append(quote);
-
-        int c;
-        while (-1 != (c = reader.read())) {
-            builder.append((char) c);
-            if (c == quote) {
-                // write out segment up until this char
-                if (pos > 0) {
-                    out.append(builder.substring(0, pos));
-                    builder.setLength(0);
-                    pos = -1;
-                }
-
-                out.append(quote);
-                out.append((char) c);
-            }
-            pos++;
-        }
-
-        // write last segment
-        if (pos > 0) {
-            out.append(builder.substring(0, pos));
-        }
-
-        out.append(quote);
-    }
-
-    @Override
-    public String toString() {
-        final StringBuilder sb = new StringBuilder();
-        sb.append("Delimiter=<").append(delimiter).append('>');
-        if (isEscapeCharacterSet()) {
-            sb.append(' ');
-            sb.append("Escape=<").append(escapeCharacter).append('>');
-        }
-        if (isQuoteCharacterSet()) {
-            sb.append(' ');
-            sb.append("QuoteChar=<").append(quoteCharacter).append('>');
-        }
-        if (quoteMode != null) {
-            sb.append(' ');
-            sb.append("QuoteMode=<").append(quoteMode).append('>');
-        }
-        if (isCommentMarkerSet()) {
-            sb.append(' ');
-            sb.append("CommentStart=<").append(commentMarker).append('>');
-        }
-        if (isNullStringSet()) {
-            sb.append(' ');
-            sb.append("NullString=<").append(nullString).append('>');
-        }
-        if (recordSeparator != null) {
-            sb.append(' ');
-            sb.append("RecordSeparator=<").append(recordSeparator).append('>');
-        }
-        if (getIgnoreEmptyLines()) {
-            sb.append(" EmptyLines:ignored");
-        }
-        if (getIgnoreSurroundingSpaces()) {
-            sb.append(" SurroundingSpaces:ignored");
-        }
-        if (getIgnoreHeaderCase()) {
-            sb.append(" IgnoreHeaderCase:ignored");
-        }
-        sb.append(" SkipHeaderRecord:").append(skipHeaderRecord);
-        if (headerComments != null) {
-            sb.append(' ');
-            sb.append("HeaderComments:").append(Arrays.toString(headerComments));
-        }
-        if (header != null) {
-            sb.append(' ');
-            sb.append("Header:").append(Arrays.toString(header));
-        }
-        return sb.toString();
-    }
-
-    private String[] toStringArray(final Object[] values) {
-        if (values == null) {
-            return null;
-        }
-        final String[] strings = new String[values.length];
-        for (int i = 0; i < values.length; i++) {
-            final Object value = values[i];
-            strings[i] = value == null ? null : value.toString();
-        }
-        return strings;
-    }
-
-    private CharSequence trim(final CharSequence charSequence) {
-        if (charSequence instanceof String) {
-            return ((String) charSequence).trim();
-        }
-        final int count = charSequence.length();
-        int len = count;
-        int pos = 0;
-
-        while (pos < len && charSequence.charAt(pos) <= SP) {
-            pos++;
-        }
-        while (pos < len && charSequence.charAt(len - 1) <= SP) {
-            len--;
-        }
-        return pos > 0 || len < count ? charSequence.subSequence(pos, len) : charSequence;
-    }
-
-    /**
-     * Verifies the consistency of the parameters and throws an IllegalArgumentException if necessary.
-     *
-     * @throws IllegalArgumentException
-     */
-    private void validate() throws IllegalArgumentException {
-        if (isLineBreak(delimiter)) {
-            throw new IllegalArgumentException("The delimiter cannot be a line break");
-        }
-
-        if (quoteCharacter != null && delimiter == quoteCharacter.charValue()) {
-            throw new IllegalArgumentException(
-                    "The quoteChar character and the delimiter cannot be the same ('" + quoteCharacter + "')");
-        }
-
-        if (escapeCharacter != null && delimiter == escapeCharacter.charValue()) {
-            throw new IllegalArgumentException(
-                    "The escape character and the delimiter cannot be the same ('" + escapeCharacter + "')");
-        }
-
-        if (commentMarker != null && delimiter == commentMarker.charValue()) {
-            throw new IllegalArgumentException(
-                    "The comment start character and the delimiter cannot be the same ('" + commentMarker + "')");
-        }
-
-        if (quoteCharacter != null && quoteCharacter.equals(commentMarker)) {
-            throw new IllegalArgumentException(
-                    "The comment start character and the quoteChar cannot be the same ('" + commentMarker + "')");
-        }
-
-        if (escapeCharacter != null && escapeCharacter.equals(commentMarker)) {
-            throw new IllegalArgumentException(
-                    "The comment start and the escape character cannot be the same ('" + commentMarker + "')");
-        }
-
-        if (escapeCharacter == null && quoteMode == QuoteMode.NONE) {
-            throw new IllegalArgumentException("No quotes mode set but no escape character is set");
-        }
-
-        // validate header
-        if (header != null && !allowDuplicateHeaderNames) {
-            final Set dupCheck = new HashSet<>();
-            for (final String hdr : header) {
-                if (!dupCheck.add(hdr)) {
-                    throw new IllegalArgumentException(
-                            "The header contains a duplicate entry: '" + hdr + "' in " + Arrays.toString(header));
-                }
-            }
-        }
-    }
-
-    /**
-     * Returns a new {@code CSVFormat} that allows duplicate header names.
-     *
-     * @return a new {@code CSVFormat} that allows duplicate header names
-     * @since 1.7
-     */
-    public CSVFormat withAllowDuplicateHeaderNames() {
-        return withAllowDuplicateHeaderNames(true);
-    }
-
-    /**
-     * Returns a new {@code CSVFormat} with duplicate header names behavior set to the given value.
-     *
-     * @param allowDuplicateHeaderNames the duplicate header names behavior, true to allow, false to disallow.
-     * @return a new {@code CSVFormat} with duplicate header names behavior set to the given value.
-     * @since 1.7
-     */
-    public CSVFormat withAllowDuplicateHeaderNames(final boolean allowDuplicateHeaderNames) {
-        return new CSVFormat(delimiter, quoteCharacter, quoteMode, commentMarker, escapeCharacter,
-                ignoreSurroundingSpaces, ignoreEmptyLines, recordSeparator, nullString, headerComments, header,
-                skipHeaderRecord, allowMissingColumnNames, ignoreHeaderCase, trim, trailingDelimiter, autoFlush,
-                allowDuplicateHeaderNames);
-    }
-
-    /**
-     * Returns a new {@code CSVFormat} with the missing column names behavior of the format set to {@code true}
-     *
-     * @return A new CSVFormat that is equal to this but with the specified missing column names behavior.
-     * @see #withAllowMissingColumnNames(boolean)
-     * @since 1.1
-     */
-    public CSVFormat withAllowMissingColumnNames() {
-        return this.withAllowMissingColumnNames(true);
-    }
-
-    /**
-     * Returns a new {@code CSVFormat} with the missing column names behavior of the format set to the given value.
-     *
-     * @param allowMissingColumnNames
-     *            the missing column names behavior, {@code true} to allow missing column names in the header line,
-     *            {@code false} to cause an {@link IllegalArgumentException} to be thrown.
-     * @return A new CSVFormat that is equal to this but with the specified missing column names behavior.
-     */
-    public CSVFormat withAllowMissingColumnNames(final boolean allowMissingColumnNames) {
-        return new CSVFormat(delimiter, quoteCharacter, quoteMode, commentMarker, escapeCharacter,
-                ignoreSurroundingSpaces, ignoreEmptyLines, recordSeparator, nullString, headerComments, header,
-                skipHeaderRecord, allowMissingColumnNames, ignoreHeaderCase, trim, trailingDelimiter, autoFlush,
-                allowDuplicateHeaderNames);
-    }
-
-    /**
-     * Returns a new {@code CSVFormat} with whether to flush on close.
-     *
-     * @param autoFlush
-     *            whether to flush on close.
-     *
-     * @return A new CSVFormat that is equal to this but with the specified autoFlush setting.
-     * @since 1.6
-     */
-    public CSVFormat withAutoFlush(final boolean autoFlush) {
-        return new CSVFormat(delimiter, quoteCharacter, quoteMode, commentMarker, escapeCharacter,
-                ignoreSurroundingSpaces, ignoreEmptyLines, recordSeparator, nullString, headerComments, header,
-                skipHeaderRecord, allowMissingColumnNames, ignoreHeaderCase, trim, trailingDelimiter, autoFlush,
-                allowDuplicateHeaderNames);
-    }
-
-    /**
-     * Returns a new {@code CSVFormat} with the comment start marker of the format set to the specified character.
-     *
-     * Note that the comment start character is only recognized at the start of a line.
-     *
-     * @param commentMarker
-     *            the comment start marker
-     * @return A new CSVFormat that is equal to this one but with the specified character as the comment start marker
-     * @throws IllegalArgumentException
-     *             thrown if the specified character is a line break
-     */
-    public CSVFormat withCommentMarker(final char commentMarker) {
-        return withCommentMarker(Character.valueOf(commentMarker));
-    }
-
-    /**
-     * Returns a new {@code CSVFormat} with the comment start marker of the format set to the specified character.
-     *
-     * Note that the comment start character is only recognized at the start of a line.
-     *
-     * @param commentMarker
-     *            the comment start marker, use {@code null} to disable
-     * @return A new CSVFormat that is equal to this one but with the specified character as the comment start marker
-     * @throws IllegalArgumentException
-     *             thrown if the specified character is a line break
-     */
-    public CSVFormat withCommentMarker(final Character commentMarker) {
-        if (isLineBreak(commentMarker)) {
-            throw new IllegalArgumentException("The comment start marker character cannot be a line break");
-        }
-        return new CSVFormat(delimiter, quoteCharacter, quoteMode, commentMarker, escapeCharacter,
-                ignoreSurroundingSpaces, ignoreEmptyLines, recordSeparator, nullString, headerComments, header,
-                skipHeaderRecord, allowMissingColumnNames, ignoreHeaderCase, trim, trailingDelimiter, autoFlush,
-                allowDuplicateHeaderNames);
-    }
-
-    /**
-     * Returns a new {@code CSVFormat} with the delimiter of the format set to the specified character.
-     *
-     * @param delimiter
-     *            the delimiter character
-     * @return A new CSVFormat that is equal to this with the specified character as delimiter
-     * @throws IllegalArgumentException
-     *             thrown if the specified character is a line break
-     */
-    public CSVFormat withDelimiter(final char delimiter) {
-        if (isLineBreak(delimiter)) {
-            throw new IllegalArgumentException("The delimiter cannot be a line break");
-        }
-        return new CSVFormat(delimiter, quoteCharacter, quoteMode, commentMarker, escapeCharacter,
-                ignoreSurroundingSpaces, ignoreEmptyLines, recordSeparator, nullString, headerComments, header,
-                skipHeaderRecord, allowMissingColumnNames, ignoreHeaderCase, trim, trailingDelimiter, autoFlush,
-                allowDuplicateHeaderNames);
-    }
-
-    /**
-     * Returns a new {@code CSVFormat} with the escape character of the format set to the specified character.
-     *
-     * @param escape
-     *            the escape character
-     * @return A new CSVFormat that is equal to his but with the specified character as the escape character
-     * @throws IllegalArgumentException
-     *             thrown if the specified character is a line break
-     */
-    public CSVFormat withEscape(final char escape) {
-        return withEscape(Character.valueOf(escape));
-    }
-
-    /**
-     * Returns a new {@code CSVFormat} with the escape character of the format set to the specified character.
-     *
-     * @param escape
-     *            the escape character, use {@code null} to disable
-     * @return A new CSVFormat that is equal to this but with the specified character as the escape character
-     * @throws IllegalArgumentException
-     *             thrown if the specified character is a line break
-     */
-    public CSVFormat withEscape(final Character escape) {
-        if (isLineBreak(escape)) {
-            throw new IllegalArgumentException("The escape character cannot be a line break");
-        }
-        return new CSVFormat(delimiter, quoteCharacter, quoteMode, commentMarker, escape, ignoreSurroundingSpaces,
-                ignoreEmptyLines, recordSeparator, nullString, headerComments, header, skipHeaderRecord,
-                allowMissingColumnNames, ignoreHeaderCase, trim, trailingDelimiter, autoFlush,
-                allowDuplicateHeaderNames);
-    }
-
-    /**
-     * Returns a new {@code CSVFormat} using the first record as header.
-     *
-     * 

-     * Calling this method is equivalent to calling:
-     * 
-     *
-     * 
-     * CSVFormat format = aFormat.withHeader().withSkipHeaderRecord();
-     * 
-     *
-     * @return A new CSVFormat that is equal to this but using the first record as header.
-     * @see #withSkipHeaderRecord(boolean)
-     * @see #withHeader(String...)
-     * @since 1.3
-     */
-    public CSVFormat withFirstRecordAsHeader() {
-        return withHeader().withSkipHeaderRecord();
-    }
-
-    /**
-     * Returns a new {@code CSVFormat} with the header of the format defined by the enum class.
-     *
-     * 

-     * Example:
-     * 
-     *
-     * 
-     * public enum Header {
-     *     Name, Email, Phone
-     * }
-     *
-     * CSVFormat format = aformat.withHeader(Header.class);
-     * 
-     * 

-     * The header is also used by the {@link CSVPrinter}.
-     * 
-     *
-     * @param headerEnum
-     *            the enum defining the header, {@code null} if disabled, empty if parsed automatically, user specified
-     *            otherwise.
-     *
-     * @return A new CSVFormat that is equal to this but with the specified header
-     * @see #withHeader(String...)
-     * @see #withSkipHeaderRecord(boolean)
-     * @since 1.3
-     */
-    public CSVFormat withHeader(final Class> headerEnum) {
-        String[] header = null;
-        if (headerEnum != null) {
-            final Enum[] enumValues = headerEnum.getEnumConstants();
-            header = new String[enumValues.length];
-            for (int i = 0; i < enumValues.length; i++) {
-                header[i] = enumValues[i].name();
-            }
-        }
-        return withHeader(header);
-    }
-
-    /**
-     * Returns a new {@code CSVFormat} with the header of the format set from the result set metadata. The header can
-     * either be parsed automatically from the input file with:
-     *
-     * 
-     * CSVFormat format = aformat.withHeader();
-     * 
-     *
-     * or specified manually with:
-     *
-     * 
-     * CSVFormat format = aformat.withHeader(resultSet);
-     * 
-     * 

-     * The header is also used by the {@link CSVPrinter}.
-     * 
-     *
-     * @param resultSet
-     *            the resultSet for the header, {@code null} if disabled, empty if parsed automatically, user specified
-     *            otherwise.
-     *
-     * @return A new CSVFormat that is equal to this but with the specified header
-     * @throws SQLException
-     *             SQLException if a database access error occurs or this method is called on a closed result set.
-     * @since 1.1
-     */
-    public CSVFormat withHeader(final ResultSet resultSet) throws SQLException {
-        return withHeader(resultSet != null ? resultSet.getMetaData() : null);
-    }
-
-    /**
-     * Returns a new {@code CSVFormat} with the header of the format set from the result set metadata. The header can
-     * either be parsed automatically from the input file with:
-     *
-     * 
-     * CSVFormat format = aformat.withHeader();
-     * 
-     *
-     * or specified manually with:
-     *
-     * 
-     * CSVFormat format = aformat.withHeader(metaData);
-     * 
-     * 

-     * The header is also used by the {@link CSVPrinter}.
-     * 
-     *
-     * @param metaData
-     *            the metaData for the header, {@code null} if disabled, empty if parsed automatically, user specified
-     *            otherwise.
-     *
-     * @return A new CSVFormat that is equal to this but with the specified header
-     * @throws SQLException
-     *             SQLException if a database access error occurs or this method is called on a closed result set.
-     * @since 1.1
-     */
-    public CSVFormat withHeader(final ResultSetMetaData metaData) throws SQLException {
-        String[] labels = null;
-        if (metaData != null) {
-            final int columnCount = metaData.getColumnCount();
-            labels = new String[columnCount];
-            for (int i = 0; i < columnCount; i++) {
-                labels[i] = metaData.getColumnLabel(i + 1);
-            }
-        }
-        return withHeader(labels);
-    }
-
-    /**
-     * Returns a new {@code CSVFormat} with the header of the format set to the given values. The header can either be
-     * parsed automatically from the input file with:
-     *
-     * 
-     * CSVFormat format = aformat.withHeader();
-     * 
-     *
-     * or specified manually with:
-     *
-     * 
-     * CSVFormat format = aformat.withHeader("name", "email", "phone");
-     * 
-     * 

-     * The header is also used by the {@link CSVPrinter}.
-     * 
-     *
-     * @param header
-     *            the header, {@code null} if disabled, empty if parsed automatically, user specified otherwise.
-     *
-     * @return A new CSVFormat that is equal to this but with the specified header
-     * @see #withSkipHeaderRecord(boolean)
-     */
-    public CSVFormat withHeader(final String... header) {
-        return new CSVFormat(delimiter, quoteCharacter, quoteMode, commentMarker, escapeCharacter,
-                ignoreSurroundingSpaces, ignoreEmptyLines, recordSeparator, nullString, headerComments, header,
-                skipHeaderRecord, allowMissingColumnNames, ignoreHeaderCase, trim, trailingDelimiter, autoFlush,
-                allowDuplicateHeaderNames);
-    }
-
-    /**
-     * Returns a new {@code CSVFormat} with the header comments of the format set to the given values. The comments will
-     * be printed first, before the headers. This setting is ignored by the parser.
-     *
-     * 
-     * CSVFormat format = aformat.withHeaderComments("Generated by Apache Commons CSV 1.1.", new Date());
-     * 
-     *
-     * @param headerComments
-     *            the headerComments which will be printed by the Printer before the actual CSV data.
-     *
-     * @return A new CSVFormat that is equal to this but with the specified header
-     * @see #withSkipHeaderRecord(boolean)
-     * @since 1.1
-     */
-    public CSVFormat withHeaderComments(final Object... headerComments) {
-        return new CSVFormat(delimiter, quoteCharacter, quoteMode, commentMarker, escapeCharacter,
-                ignoreSurroundingSpaces, ignoreEmptyLines, recordSeparator, nullString, headerComments, header,
-                skipHeaderRecord, allowMissingColumnNames, ignoreHeaderCase, trim, trailingDelimiter, autoFlush,
-                allowDuplicateHeaderNames);
-    }
-
-    /**
-     * Returns a new {@code CSVFormat} with the empty line skipping behavior of the format set to {@code true}.
-     *
-     * @return A new CSVFormat that is equal to this but with the specified empty line skipping behavior.
-     * @since {@link #withIgnoreEmptyLines(boolean)}
-     * @since 1.1
-     */
-    public CSVFormat withIgnoreEmptyLines() {
-        return this.withIgnoreEmptyLines(true);
-    }
-
-    /**
-     * Returns a new {@code CSVFormat} with the empty line skipping behavior of the format set to the given value.
-     *
-     * @param ignoreEmptyLines
-     *            the empty line skipping behavior, {@code true} to ignore the empty lines between the records,
-     *            {@code false} to translate empty lines to empty records.
-     * @return A new CSVFormat that is equal to this but with the specified empty line skipping behavior.
-     */
-    public CSVFormat withIgnoreEmptyLines(final boolean ignoreEmptyLines) {
-        return new CSVFormat(delimiter, quoteCharacter, quoteMode, commentMarker, escapeCharacter,
-                ignoreSurroundingSpaces, ignoreEmptyLines, recordSeparator, nullString, headerComments, header,
-                skipHeaderRecord, allowMissingColumnNames, ignoreHeaderCase, trim, trailingDelimiter, autoFlush,
-                allowDuplicateHeaderNames);
-    }
-
-    /**
-     * Returns a new {@code CSVFormat} with the header ignore case behavior set to {@code true}.
-     *
-     * @return A new CSVFormat that will ignore case header name.
-     * @see #withIgnoreHeaderCase(boolean)
-     * @since 1.3
-     */
-    public CSVFormat withIgnoreHeaderCase() {
-        return this.withIgnoreHeaderCase(true);
-    }
-
-    /**
-     * Returns a new {@code CSVFormat} with whether header names should be accessed ignoring case.
-     *
-     * @param ignoreHeaderCase
-     *            the case mapping behavior, {@code true} to access name/values, {@code false} to leave the mapping as
-     *            is.
-     * @return A new CSVFormat that will ignore case header name if specified as {@code true}
-     * @since 1.3
-     */
-    public CSVFormat withIgnoreHeaderCase(final boolean ignoreHeaderCase) {
-        return new CSVFormat(delimiter, quoteCharacter, quoteMode, commentMarker, escapeCharacter,
-                ignoreSurroundingSpaces, ignoreEmptyLines, recordSeparator, nullString, headerComments, header,
-                skipHeaderRecord, allowMissingColumnNames, ignoreHeaderCase, trim, trailingDelimiter, autoFlush,
-                allowDuplicateHeaderNames);
-    }
-
-    /**
-     * Returns a new {@code CSVFormat} with the parser trimming behavior of the format set to {@code true}.
-     *
-     * @return A new CSVFormat that is equal to this but with the specified parser trimming behavior.
-     * @see #withIgnoreSurroundingSpaces(boolean)
-     * @since 1.1
-     */
-    public CSVFormat withIgnoreSurroundingSpaces() {
-        return this.withIgnoreSurroundingSpaces(true);
-    }
-
-    /**
-     * Returns a new {@code CSVFormat} with the parser trimming behavior of the format set to the given value.
-     *
-     * @param ignoreSurroundingSpaces the parser trimming behavior, {@code true} to remove the surrounding spaces,
-     *        {@code false} to leave the spaces as is.
-     * @return A new CSVFormat that is equal to this but with the specified trimming behavior.
-     */
-    public CSVFormat withIgnoreSurroundingSpaces(final boolean ignoreSurroundingSpaces) {
-        return new CSVFormat(delimiter, quoteCharacter, quoteMode, commentMarker, escapeCharacter,
-                ignoreSurroundingSpaces, ignoreEmptyLines, recordSeparator, nullString, headerComments, header,
-                skipHeaderRecord, allowMissingColumnNames, ignoreHeaderCase, trim, trailingDelimiter, autoFlush,
-                allowDuplicateHeaderNames);
-    }
-
-    /**
-     * Returns a new {@code CSVFormat} with conversions to and from null for strings on input and output.
-     * 

-     * 
Reading: Converts strings equal to the given {@code nullString} to {@code null} when reading
-     * records.
-     * 
Writing: Writes {@code null} as the given {@code nullString} when writing records.
-     * 
-     *
-     * @param nullString
-     *            the String to convert to and from {@code null}. No substitution occurs if {@code null}
-     *
-     * @return A new CSVFormat that is equal to this but with the specified null conversion string.
-     */
-    public CSVFormat withNullString(final String nullString) {
-        return new CSVFormat(delimiter, quoteCharacter, quoteMode, commentMarker, escapeCharacter,
-                ignoreSurroundingSpaces, ignoreEmptyLines, recordSeparator, nullString, headerComments, header,
-                skipHeaderRecord, allowMissingColumnNames, ignoreHeaderCase, trim, trailingDelimiter, autoFlush,
-                allowDuplicateHeaderNames);
-    }
-
-    /**
-     * Returns a new {@code CSVFormat} with the quoteChar of the format set to the specified character.
-     *
-     * @param quoteChar
-     *            the quoteChar character
-     * @return A new CSVFormat that is equal to this but with the specified character as quoteChar
-     * @throws IllegalArgumentException
-     *             thrown if the specified character is a line break
-     */
-    public CSVFormat withQuote(final char quoteChar) {
-        return withQuote(Character.valueOf(quoteChar));
-    }
-
-    /**
-     * Returns a new {@code CSVFormat} with the quoteChar of the format set to the specified character.
-     *
-     * @param quoteChar
-     *            the quoteChar character, use {@code null} to disable
-     * @return A new CSVFormat that is equal to this but with the specified character as quoteChar
-     * @throws IllegalArgumentException
-     *             thrown if the specified character is a line break
-     */
-    public CSVFormat withQuote(final Character quoteChar) {
-        if (isLineBreak(quoteChar)) {
-            throw new IllegalArgumentException("The quoteChar cannot be a line break");
-        }
-        return new CSVFormat(delimiter, quoteChar, quoteMode, commentMarker, escapeCharacter, ignoreSurroundingSpaces,
-                ignoreEmptyLines, recordSeparator, nullString, headerComments, header, skipHeaderRecord,
-                allowMissingColumnNames, ignoreHeaderCase, trim, trailingDelimiter, autoFlush,
-                allowDuplicateHeaderNames);
-    }
-
-    /**
-     * Returns a new {@code CSVFormat} with the output quote policy of the format set to the specified value.
-     *
-     * @param quoteModePolicy
-     *            the quote policy to use for output.
-     *
-     * @return A new CSVFormat that is equal to this but with the specified quote policy
-     */
-    public CSVFormat withQuoteMode(final QuoteMode quoteModePolicy) {
-        return new CSVFormat(delimiter, quoteCharacter, quoteModePolicy, commentMarker, escapeCharacter,
-                ignoreSurroundingSpaces, ignoreEmptyLines, recordSeparator, nullString, headerComments, header,
-                skipHeaderRecord, allowMissingColumnNames, ignoreHeaderCase, trim, trailingDelimiter, autoFlush,
-                allowDuplicateHeaderNames);
-    }
-
-    /**
-     * Returns a new {@code CSVFormat} with the record separator of the format set to the specified character.
-     *
-     * 

-     * Note: This setting is only used during printing and does not affect parsing. Parsing currently
-     * only works for inputs with '\n', '\r' and "\r\n"
-     * 
-     *
-     * @param recordSeparator
-     *            the record separator to use for output.
-     *
-     * @return A new CSVFormat that is equal to this but with the specified output record separator
-     */
-    public CSVFormat withRecordSeparator(final char recordSeparator) {
-        return withRecordSeparator(String.valueOf(recordSeparator));
-    }
-
-    /**
-     * Returns a new {@code CSVFormat} with the record separator of the format set to the specified String.
-     *
-     * 

-     * Note: This setting is only used during printing and does not affect parsing. Parsing currently
-     * only works for inputs with '\n', '\r' and "\r\n"
-     * 
-     *
-     * @param recordSeparator
-     *            the record separator to use for output.
-     *
-     * @return A new CSVFormat that is equal to this but with the specified output record separator
-     * @throws IllegalArgumentException
-     *             if recordSeparator is none of CR, LF or CRLF
-     */
-    public CSVFormat withRecordSeparator(final String recordSeparator) {
-        return new CSVFormat(delimiter, quoteCharacter, quoteMode, commentMarker, escapeCharacter,
-                ignoreSurroundingSpaces, ignoreEmptyLines, recordSeparator, nullString, headerComments, header,
-                skipHeaderRecord, allowMissingColumnNames, ignoreHeaderCase, trim, trailingDelimiter, autoFlush,
-                allowDuplicateHeaderNames);
-    }
-
-    /**
-     * Returns a new {@code CSVFormat} with skipping the header record set to {@code true}.
-     *
-     * @return A new CSVFormat that is equal to this but with the specified skipHeaderRecord setting.
-     * @see #withSkipHeaderRecord(boolean)
-     * @see #withHeader(String...)
-     * @since 1.1
-     */
-    public CSVFormat withSkipHeaderRecord() {
-        return this.withSkipHeaderRecord(true);
-    }
-
-    /**
-     * Returns a new {@code CSVFormat} with whether to skip the header record.
-     *
-     * @param skipHeaderRecord
-     *            whether to skip the header record.
-     *
-     * @return A new CSVFormat that is equal to this but with the specified skipHeaderRecord setting.
-     * @see #withHeader(String...)
-     */
-    public CSVFormat withSkipHeaderRecord(final boolean skipHeaderRecord) {
-        return new CSVFormat(delimiter, quoteCharacter, quoteMode, commentMarker, escapeCharacter,
-                ignoreSurroundingSpaces, ignoreEmptyLines, recordSeparator, nullString, headerComments, header,
-                skipHeaderRecord, allowMissingColumnNames, ignoreHeaderCase, trim, trailingDelimiter, autoFlush,
-                allowDuplicateHeaderNames);
-    }
-
-    /**
-     * Returns a new {@code CSVFormat} with the record separator of the format set to the operating system's line
-     * separator string, typically CR+LF on Windows and LF on Linux.
-     *
-     * 

-     * Note: This setting is only used during printing and does not affect parsing. Parsing currently
-     * only works for inputs with '\n', '\r' and "\r\n"
-     * 
-     *
-     * @return A new CSVFormat that is equal to this but with the operating system's line separator string.
-     * @since 1.6
-     */
-    public CSVFormat withSystemRecordSeparator() {
-        return withRecordSeparator(System.getProperty("line.separator"));
-    }
-
-    /**
-     * Returns a new {@code CSVFormat} to add a trailing delimiter.
-     *
-     * @return A new CSVFormat that is equal to this but with the trailing delimiter setting.
-     * @since 1.3
-     */
-    public CSVFormat withTrailingDelimiter() {
-        return withTrailingDelimiter(true);
-    }
-
-    /**
-     * Returns a new {@code CSVFormat} with whether to add a trailing delimiter.
-     *
-     * @param trailingDelimiter
-     *            whether to add a trailing delimiter.
-     *
-     * @return A new CSVFormat that is equal to this but with the specified trailing delimiter setting.
-     * @since 1.3
-     */
-    public CSVFormat withTrailingDelimiter(final boolean trailingDelimiter) {
-        return new CSVFormat(delimiter, quoteCharacter, quoteMode, commentMarker, escapeCharacter,
-                ignoreSurroundingSpaces, ignoreEmptyLines, recordSeparator, nullString, headerComments, header,
-                skipHeaderRecord, allowMissingColumnNames, ignoreHeaderCase, trim, trailingDelimiter, autoFlush,
-                allowDuplicateHeaderNames);
-    }
-
-    /**
-     * Returns a new {@code CSVFormat} to trim leading and trailing blanks.
-     * See {@link #getTrim()} for details of where this is used.
-     *
-     * @return A new CSVFormat that is equal to this but with the trim setting on.
-     * @since 1.3
-     */
-    public CSVFormat withTrim() {
-        return withTrim(true);
-    }
-
-    /**
-     * Returns a new {@code CSVFormat} with whether to trim leading and trailing blanks.
-     * See {@link #getTrim()} for details of where this is used.
-     *
-     * @param trim
-     *            whether to trim leading and trailing blanks.
-     *
-     * @return A new CSVFormat that is equal to this but with the specified trim setting.
-     * @since 1.3
-     */
-    public CSVFormat withTrim(final boolean trim) {
-        return new CSVFormat(delimiter, quoteCharacter, quoteMode, commentMarker, escapeCharacter,
-                ignoreSurroundingSpaces, ignoreEmptyLines, recordSeparator, nullString, headerComments, header,
-                skipHeaderRecord, allowMissingColumnNames, ignoreHeaderCase, trim, trailingDelimiter, autoFlush,
-                allowDuplicateHeaderNames);
-    }
-}
diff --git a/src/test/resources/org/apache/commons/csv/CSVParser.java b/src/test/resources/org/apache/commons/csv/CSVParser.java
deleted file mode 100644
index bf6eb6d6e5..0000000000
--- a/src/test/resources/org/apache/commons/csv/CSVParser.java
+++ /dev/null
@@ -1,715 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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 org.apache.commons.csv;
-
-import static org.apache.commons.csv.Token.Type.TOKEN;
-
-import java.io.Closeable;
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.io.Reader;
-import java.io.StringReader;
-import java.net.URL;
-import java.nio.charset.Charset;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.Iterator;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.NoSuchElementException;
-import java.util.Objects;
-import java.util.TreeMap;
-
-/**
- * Parses CSV files according to the specified format.
- *
- * Because CSV appears in many different dialects, the parser supports many formats by allowing the
- * specification of a {@link CSVFormat}.
- *
- * The parser works record wise. It is not possible to go back, once a record has been parsed from the input stream.
- *
- * 
Creating instances
- * 

- * There are several static factory methods that can be used to create instances for various types of resources:
- * 
- * 

- *     
{@link #parse(java.io.File, Charset, CSVFormat)}
- *     
{@link #parse(String, CSVFormat)}
- *     
{@link #parse(java.net.URL, java.nio.charset.Charset, CSVFormat)}
- * 
- * 

- * Alternatively parsers can also be created by passing a {@link Reader} directly to the sole constructor.
- *
- * For those who like fluent APIs, parsers can be created using {@link CSVFormat#parse(java.io.Reader)} as a shortcut:
- * 
- * 
- * for(CSVRecord record : CSVFormat.EXCEL.parse(in)) {
- *     ...
- * }
- * 
- *
- * 
Parsing record wise
- * 

- * To parse a CSV input from a file, you write:
- * 
- *
- * 
- * File csvData = new File("/path/to/csv");
- * CSVParser parser = CSVParser.parse(csvData, CSVFormat.RFC4180);
- * for (CSVRecord csvRecord : parser) {
- *     ...
- * }
- * 
- *
- * 

- * This will read the parse the contents of the file using the
- * RFC 4180 format.
- * 
- *
- * 

- * To parse CSV input in a format like Excel, you write:
- * 
- *
- * 
- * CSVParser parser = CSVParser.parse(csvData, CSVFormat.EXCEL);
- * for (CSVRecord csvRecord : parser) {
- *     ...
- * }
- * 
- *
- * 

- * If the predefined formats don't match the format at hands, custom formats can be defined. More information about
- * customising CSVFormats is available in {@link CSVFormat CSVFormat Javadoc}.
- * 
- *
- * 
Parsing into memory
- * 

- * If parsing record wise is not desired, the contents of the input can be read completely into memory.
- * 
- *
- * 
- * Reader in = new StringReader("a;b\nc;d");
- * CSVParser parser = new CSVParser(in, CSVFormat.EXCEL);
- * List<CSVRecord> list = parser.getRecords();
- * 
- *
- * 

- * There are two constraints that have to be kept in mind:
- * 
- *
- * 

- *     
Parsing into memory starts at the current position of the parser. If you have already parsed records from
- *     the input, those records will not end up in the in memory representation of your CSV data.
- *     
Parsing into memory may consume a lot of system resources depending on the input. For example if you're
- *     parsing a 150MB file of CSV data the contents will be read completely into memory.
- * 
- *
- * 
Notes
- * 

- * Internal parser state is completely covered by the format and the reader-state.
- * 
- *
- * @see package documentation for more details
- */
-public final class CSVParser implements Iterable, Closeable {
-
-    class CSVRecordIterator implements Iterator {
-        private CSVRecord current;
-
-        private CSVRecord getNextRecord() {
-            try {
-                return CSVParser.this.nextRecord();
-            } catch (final IOException e) {
-                throw new IllegalStateException(
-                        e.getClass().getSimpleName() + " reading next record: " + e.toString(), e);
-            }
-        }
-
-        @Override
-        public boolean hasNext() {
-            if (CSVParser.this.isClosed()) {
-                return false;
-            }
-            if (this.current == null) {
-                this.current = this.getNextRecord();
-            }
-
-            return this.current != null;
-        }
-
-        @Override
-        public CSVRecord next() {
-            if (CSVParser.this.isClosed()) {
-                throw new NoSuchElementException("CSVParser has been closed");
-            }
-            CSVRecord next = this.current;
-            this.current = null;
-
-            if (next == null) {
-                // hasNext() wasn't called before
-                next = this.getNextRecord();
-                if (next == null) {
-                    throw new NoSuchElementException("No more CSV records available");
-                }
-            }
-
-            return next;
-        }
-
-        @Override
-        public void remove() {
-            throw new UnsupportedOperationException();
-        }
-    }
-
-    /**
-     * Header information based on name and position.
-     */
-    private static final class Headers {
-        /**
-         * Header column positions (0-based)
-         */
-        final Map headerMap;
-
-        /**
-         * Header names in column order
-         */
-        final List headerNames;
-
-        Headers(final Map headerMap, final List headerNames) {
-            this.headerMap = headerMap;
-            this.headerNames = headerNames;
-        }
-    }
-
-    /**
-     * Creates a parser for the given {@link File}.
-     *
-     * @param file
-     *            a CSV file. Must not be null.
-     * @param charset
-     *            The Charset to decode the given file.
-     * @param format
-     *            the CSVFormat used for CSV parsing. Must not be null.
-     * @return a new parser
-     * @throws IllegalArgumentException
-     *             If the parameters of the format are inconsistent or if either file or format are null.
-     * @throws IOException
-     *             If an I/O error occurs
-     */
-    @SuppressWarnings("resource")
-    public static CSVParser parse(final File file, final Charset charset, final CSVFormat format) throws IOException {
-        Objects.requireNonNull(file, "file");
-        Objects.requireNonNull(format, "format");
-        return new CSVParser(new InputStreamReader(new FileInputStream(file), charset), format);
-    }
-
-    /**
-     * Creates a CSV parser using the given {@link CSVFormat}.
-     *
-     * 

-     * If you do not read all records from the given {@code reader}, you should call {@link #close()} on the parser,
-     * unless you close the {@code reader}.
-     * 
-     *
-     * @param inputStream
-     *            an InputStream containing CSV-formatted input. Must not be null.
-     * @param charset
-     *            The Charset to decode the given file.
-     * @param format
-     *            the CSVFormat used for CSV parsing. Must not be null.
-     * @return a new CSVParser configured with the given reader and format.
-     * @throws IllegalArgumentException
-     *             If the parameters of the format are inconsistent or if either reader or format are null.
-     * @throws IOException
-     *             If there is a problem reading the header or skipping the first record
-     * @since 1.5
-     */
-    @SuppressWarnings("resource")
-    public static CSVParser parse(final InputStream inputStream, final Charset charset, final CSVFormat format)
-            throws IOException {
-        Objects.requireNonNull(inputStream, "inputStream");
-        Objects.requireNonNull(format, "format");
-        return parse(new InputStreamReader(inputStream, charset), format);
-    }
-
-    /**
-     * Creates and returns a parser for the given {@link Path}, which the caller MUST close.
-     *
-     * @param path
-     *            a CSV file. Must not be null.
-     * @param charset
-     *            The Charset to decode the given file.
-     * @param format
-     *            the CSVFormat used for CSV parsing. Must not be null.
-     * @return a new parser
-     * @throws IllegalArgumentException
-     *             If the parameters of the format are inconsistent or if either file or format are null.
-     * @throws IOException
-     *             If an I/O error occurs
-     * @since 1.5
-     */
-    @SuppressWarnings("resource")
-    public static CSVParser parse(final Path path, final Charset charset, final CSVFormat format) throws IOException {
-        Objects.requireNonNull(path, "path");
-        Objects.requireNonNull(format, "format");
-        return parse(Files.newInputStream(path), charset, format);
-    }
-
-    /**
-     * Creates a CSV parser using the given {@link CSVFormat}
-     *
-     * 

-     * If you do not read all records from the given {@code reader}, you should call {@link #close()} on the parser,
-     * unless you close the {@code reader}.
-     * 
-     *
-     * @param reader
-     *            a Reader containing CSV-formatted input. Must not be null.
-     * @param format
-     *            the CSVFormat used for CSV parsing. Must not be null.
-     * @return a new CSVParser configured with the given reader and format.
-     * @throws IllegalArgumentException
-     *             If the parameters of the format are inconsistent or if either reader or format are null.
-     * @throws IOException
-     *             If there is a problem reading the header or skipping the first record
-     * @since 1.5
-     */
-    public static CSVParser parse(final Reader reader, final CSVFormat format) throws IOException {
-        return new CSVParser(reader, format);
-    }
-
-    // the following objects are shared to reduce garbage
-
-    /**
-     * Creates a parser for the given {@link String}.
-     *
-     * @param string
-     *            a CSV string. Must not be null.
-     * @param format
-     *            the CSVFormat used for CSV parsing. Must not be null.
-     * @return a new parser
-     * @throws IllegalArgumentException
-     *             If the parameters of the format are inconsistent or if either string or format are null.
-     * @throws IOException
-     *             If an I/O error occurs
-     */
-    public static CSVParser parse(final String string, final CSVFormat format) throws IOException {
-        Objects.requireNonNull(string, "string");
-        Objects.requireNonNull(format, "format");
-
-        return new CSVParser(new StringReader(string), format);
-    }
-
-    /**
-     * Creates and returns a parser for the given URL, which the caller MUST close.
-     *
-     * 

-     * If you do not read all records from the given {@code url}, you should call {@link #close()} on the parser, unless
-     * you close the {@code url}.
-     * 
-     *
-     * @param url
-     *            a URL. Must not be null.
-     * @param charset
-     *            the charset for the resource. Must not be null.
-     * @param format
-     *            the CSVFormat used for CSV parsing. Must not be null.
-     * @return a new parser
-     * @throws IllegalArgumentException
-     *             If the parameters of the format are inconsistent or if either url, charset or format are null.
-     * @throws IOException
-     *             If an I/O error occurs
-     */
-    @SuppressWarnings("resource")
-    public static CSVParser parse(final URL url, final Charset charset, final CSVFormat format) throws IOException {
-        Objects.requireNonNull(url, "url");
-        Objects.requireNonNull(charset, "charset");
-        Objects.requireNonNull(format, "format");
-
-        return new CSVParser(new InputStreamReader(url.openStream(), charset), format);
-    }
-
-    private final CSVFormat format;
-
-    /** A mapping of column names to column indices */
-    private final Map headerMap;
-
-    /** The column order to avoid re-computing it. */
-    private final List headerNames;
-
-    private final Lexer lexer;
-
-    private final CSVRecordIterator csvRecordIterator;
-
-    /** A record buffer for getRecord(). Grows as necessary and is reused. */
-    private final List recordList = new ArrayList<>();
-
-    /**
-     * The next record number to assign.
-     */
-    private long recordNumber;
-
-    /**
-     * Lexer offset when the parser does not start parsing at the beginning of the source. Usually used in combination
-     * with {@link #recordNumber}.
-     */
-    private final long characterOffset;
-
-    private final Token reusableToken = new Token();
-
-    /**
-     * Customized CSV parser using the given {@link CSVFormat}
-     *
-     * 

-     * If you do not read all records from the given {@code reader}, you should call {@link #close()} on the parser,
-     * unless you close the {@code reader}.
-     * 
-     *
-     * @param reader
-     *            a Reader containing CSV-formatted input. Must not be null.
-     * @param format
-     *            the CSVFormat used for CSV parsing. Must not be null.
-     * @throws IllegalArgumentException
-     *             If the parameters of the format are inconsistent or if either reader or format are null.
-     * @throws IOException
-     *             If there is a problem reading the header or skipping the first record
-     */
-    public CSVParser(final Reader reader, final CSVFormat format) throws IOException {
-        this(reader, format, 0, 1);
-    }
-
-    /**
-     * Customized CSV parser using the given {@link CSVFormat}
-     *
-     * 

-     * If you do not read all records from the given {@code reader}, you should call {@link #close()} on the parser,
-     * unless you close the {@code reader}.
-     * 
-     *
-     * @param reader
-     *            a Reader containing CSV-formatted input. Must not be null.
-     * @param format
-     *            the CSVFormat used for CSV parsing. Must not be null.
-     * @param characterOffset
-     *            Lexer offset when the parser does not start parsing at the beginning of the source.
-     * @param recordNumber
-     *            The next record number to assign
-     * @throws IllegalArgumentException
-     *             If the parameters of the format are inconsistent or if either reader or format are null.
-     * @throws IOException
-     *             If there is a problem reading the header or skipping the first record
-     * @since 1.1
-     */
-    @SuppressWarnings("resource")
-    public CSVParser(final Reader reader, final CSVFormat format, final long characterOffset, final long recordNumber)
-        throws IOException {
-        Objects.requireNonNull(reader, "reader");
-        Objects.requireNonNull(format, "format");
-
-        this.format = format;
-        this.lexer = new Lexer(format, new ExtendedBufferedReader(reader));
-        this.csvRecordIterator = new CSVRecordIterator();
-        final Headers headers = createHeaders();
-        this.headerMap = headers.headerMap;
-        this.headerNames = headers.headerNames;
-        this.characterOffset = characterOffset;
-        this.recordNumber = recordNumber - 1;
-    }
-
-    private void addRecordValue(final boolean lastRecord) {
-        final String input = this.reusableToken.content.toString();
-        final String inputClean = this.format.getTrim() ? input.trim() : input;
-        if (lastRecord && inputClean.isEmpty() && this.format.getTrailingDelimiter()) {
-            return;
-        }
-        final String nullString = this.format.getNullString();
-        this.recordList.add(inputClean.equals(nullString) ? null : inputClean);
-    }
-
-    /**
-     * Closes resources.
-     *
-     * @throws IOException
-     *             If an I/O error occurs
-     */
-    @Override
-    public void close() throws IOException {
-        if (this.lexer != null) {
-            this.lexer.close();
-        }
-    }
-
-    private Map createEmptyHeaderMap() {
-        return this.format.getIgnoreHeaderCase() ?
-                new TreeMap<>(String.CASE_INSENSITIVE_ORDER) :
-                new LinkedHashMap<>();
-    }
-
-    /**
-     * Creates the name to index mapping if the format defines a header.
-     *
-     * @return null if the format has no header.
-     * @throws IOException if there is a problem reading the header or skipping the first record
-     */
-    private Headers createHeaders() throws IOException {
-        Map hdrMap = null;
-        List headerNames = null;
-        final String[] formatHeader = this.format.getHeader();
-        if (formatHeader != null) {
-            hdrMap = createEmptyHeaderMap();
-            String[] headerRecord = null;
-            if (formatHeader.length == 0) {
-                // read the header from the first line of the file
-                final CSVRecord nextRecord = this.nextRecord();
-                if (nextRecord != null) {
-                    headerRecord = nextRecord.values();
-                }
-            } else {
-                if (this.format.getSkipHeaderRecord()) {
-                    this.nextRecord();
-                }
-                headerRecord = formatHeader;
-            }
-
-            // build the name to index mappings
-            if (headerRecord != null) {
-                for (int i = 0; i < headerRecord.length; i++) {
-                    final String header = headerRecord[i];
-                    final boolean emptyHeader = header == null || header.trim().isEmpty();
-                    if (emptyHeader && !this.format.getAllowMissingColumnNames()) {
-                        throw new IllegalArgumentException(
-                            "A header name is missing in " + Arrays.toString(headerRecord));
-                    }
-                    // Note: This will always allow a duplicate header if the header is empty
-                    final boolean containsHeader = header != null && hdrMap.containsKey(header);
-                    if (containsHeader && !emptyHeader && !this.format.getAllowDuplicateHeaderNames()) {
-                        throw new IllegalArgumentException(
-                            String.format(
-                                "The header contains a duplicate name: \"%s\" in %s. If this is valid then use CSVFormat.withAllowDuplicateHeaderNames().",
-                                header, Arrays.toString(headerRecord)));
-                    }
-                    if (header != null) {
-                        hdrMap.put(header, Integer.valueOf(i));
-                        if (headerNames == null) {
-                            headerNames = new ArrayList<>(headerRecord.length);
-                        }
-                        headerNames.add(header);
-                    }
-                }
-            }
-        }
-        if (headerNames == null) {
-            headerNames = Collections.emptyList(); //immutable
-        } else {
-            headerNames = Collections.unmodifiableList(headerNames);
-        }
-        return new Headers(hdrMap, headerNames);
-    }
-
-    /**
-     * Returns the current line number in the input stream.
-     *
-     * 

-     * ATTENTION: If your CSV input has multi-line values, the returned number does not correspond to
-     * the record number.
-     * 
-     *
-     * @return current line number
-     */
-    public long getCurrentLineNumber() {
-        return this.lexer.getCurrentLineNumber();
-    }
-
-    /**
-     * Gets the first end-of-line string encountered.
-     *
-     * @return the first end-of-line string
-     * @since 1.5
-     */
-    public String getFirstEndOfLine() {
-        return lexer.getFirstEol();
-    }
-
-    /**
-     * Returns a copy of the header map.
-     * 

-     * The map keys are column names. The map values are 0-based indices.
-     * 
-     * 

-     * Note: The map can only provide a one-to-one mapping when the format did not
-     * contain null or duplicate column names.
-     * 
-     *
-     * @return a copy of the header map.
-     */
-    public Map getHeaderMap() {
-        if (this.headerMap == null) {
-            return null;
-        }
-        final Map map = createEmptyHeaderMap();
-        map.putAll(this.headerMap);
-        return map;
-    }
-
-    /**
-     * Returns the header map.
-     *
-     * @return the header map.
-     */
-    Map getHeaderMapRaw() {
-        return this.headerMap;
-    }
-
-    /**
-     * Returns a read-only list of header names that iterates in column order.
-     * 

-     * Note: The list provides strings that can be used as keys in the header map.
-     * The list will not contain null column names if they were present in the input
-     * format.
-     * 
-     *
-     * @return read-only list of header names that iterates in column order.
-     * @see #getHeaderMap()
-     * @since 1.7
-     */
-    public List getHeaderNames() {
-        return headerNames;
-    }
-
-    /**
-     * Returns the current record number in the input stream.
-     *
-     * 

-     * ATTENTION: If your CSV input has multi-line values, the returned number does not correspond to
-     * the line number.
-     * 
-     *
-     * @return current record number
-     */
-    public long getRecordNumber() {
-        return this.recordNumber;
-    }
-
-    /**
-     * Parses the CSV input according to the given format and returns the content as a list of
-     * {@link CSVRecord CSVRecords}.
-     *
-     * 

-     * The returned content starts at the current parse-position in the stream.
-     * 
-     *
-     * @return list of {@link CSVRecord CSVRecords}, may be empty
-     * @throws IOException
-     *             on parse error or input read-failure
-     */
-    public List getRecords() throws IOException {
-        CSVRecord rec;
-        final List records = new ArrayList<>();
-        while ((rec = this.nextRecord()) != null) {
-            records.add(rec);
-        }
-        return records;
-    }
-
-    /**
-     * Gets whether this parser is closed.
-     *
-     * @return whether this parser is closed.
-     */
-    public boolean isClosed() {
-        return this.lexer.isClosed();
-    }
-
-    /**
-     * Returns an iterator on the records.
-     *
-     * 

-     * An {@link IOException} caught during the iteration are re-thrown as an
-     * {@link IllegalStateException}.
-     * 
-     * 

-     * If the parser is closed a call to {@link Iterator#next()} will throw a
-     * {@link NoSuchElementException}.
-     * 
-     */
-    @Override
-    public Iterator iterator() {
-        return csvRecordIterator;
-    }
-
-    /**
-     * Parses the next record from the current point in the stream.
-     *
-     * @return the record as an array of values, or {@code null} if the end of the stream has been reached
-     * @throws IOException
-     *             on parse error or input read-failure
-     */
-    CSVRecord nextRecord() throws IOException {
-        CSVRecord result = null;
-        this.recordList.clear();
-        StringBuilder sb = null;
-        final long startCharPosition = lexer.getCharacterPosition() + this.characterOffset;
-        do {
-            this.reusableToken.reset();
-            this.lexer.nextToken(this.reusableToken);
-            switch (this.reusableToken.type) {
-            case TOKEN:
-                this.addRecordValue(false);
-                break;
-            case EORECORD:
-                this.addRecordValue(true);
-                break;
-            case EOF:
-                if (this.reusableToken.isReady) {
-                    this.addRecordValue(true);
-                }
-                break;
-            case INVALID:
-                throw new IOException("(line " + this.getCurrentLineNumber() + ") invalid parse sequence");
-            case COMMENT: // Ignored currently
-                if (sb == null) { // first comment for this record
-                    sb = new StringBuilder();
-                } else {
-                    sb.append(Constants.LF);
-                }
-                sb.append(this.reusableToken.content);
-                this.reusableToken.type = TOKEN; // Read another token
-                break;
-            default:
-                throw new IllegalStateException("Unexpected Token type: " + this.reusableToken.type);
-            }
-        } while (this.reusableToken.type == TOKEN);
-
-        if (!this.recordList.isEmpty()) {
-            this.recordNumber++;
-            final String comment = sb == null ? null : sb.toString();
-            result = new CSVRecord(this, this.recordList.toArray(new String[this.recordList.size()]),
-                comment, this.recordNumber, startCharPosition);
-        }
-        return result;
-    }
-
-}
diff --git a/src/test/resources/org/apache/commons/csv/CSVPrinter.java b/src/test/resources/org/apache/commons/csv/CSVPrinter.java
deleted file mode 100644
index c7377101b5..0000000000
--- a/src/test/resources/org/apache/commons/csv/CSVPrinter.java
+++ /dev/null
@@ -1,392 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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 org.apache.commons.csv;
-
-import static org.apache.commons.csv.Constants.CR;
-import static org.apache.commons.csv.Constants.LF;
-import static org.apache.commons.csv.Constants.SP;
-
-import java.io.Closeable;
-import java.io.Flushable;
-import java.io.IOException;
-import java.sql.Clob;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.util.Arrays;
-import java.util.Objects;
-
-/**
- * Prints values in a {@link CSVFormat CSV format}.
- *
- * 
Values can be appended to the output by calling the {@link #print(Object)} method.
- * Values are printed according to {@link String#valueOf(Object)}.
- * To complete a record the {@link #println()} method has to be called.
- * Comments can be appended by calling {@link #printComment(String)}.
- * However a comment will only be written to the output if the {@link CSVFormat} supports comments.
- * 
- *
- * 
The printer also supports appending a complete record at once by calling {@link #printRecord(Object...)}
- * or {@link #printRecord(Iterable)}.
- * Furthermore {@link #printRecords(Object...)}, {@link #printRecords(Iterable)} and {@link #printRecords(ResultSet)}
- * methods can be used to print several records at once.
- * 
- *
- * 
Example:
- *
- * 
- * try (CSVPrinter printer = new CSVPrinter(new FileWriter("csv.txt"), CSVFormat.EXCEL)) {
- *     printer.printRecord("id", "userName", "firstName", "lastName", "birthday");
- *     printer.printRecord(1, "john73", "John", "Doe", LocalDate.of(1973, 9, 15));
- *     printer.println();
- *     printer.printRecord(2, "mary", "Mary", "Meyer", LocalDate.of(1985, 3, 29));
- * } catch (IOException ex) {
- *     ex.printStackTrace();
- * }
- * 
- *
- * 
This code will write the following to csv.txt:
- * 
- * id,userName,firstName,lastName,birthday
- * 1,john73,John,Doe,1973-09-15
- *
- * 2,mary,Mary,Meyer,1985-03-29
- * 
- */
-public final class CSVPrinter implements Flushable, Closeable {
-
-    /** The place that the values get written. */
-    private final Appendable out;
-    private final CSVFormat format;
-
-    /** True if we just began a new record. */
-    private boolean newRecord = true;
-
-    /**
-     * Creates a printer that will print values to the given stream following the CSVFormat.
-     * 

-     * Currently, only a pure encapsulation format or a pure escaping format is supported. Hybrid formats (encapsulation
-     * and escaping with a different character) are not supported.
-     * 
-     *
-     * @param out
-     *            stream to which to print. Must not be null.
-     * @param format
-     *            the CSV format. Must not be null.
-     * @throws IOException
-     *             thrown if the optional header cannot be printed.
-     * @throws IllegalArgumentException
-     *             thrown if the parameters of the format are inconsistent or if either out or format are null.
-     */
-    public CSVPrinter(final Appendable out, final CSVFormat format) throws IOException {
-        Objects.requireNonNull(out, "out");
-        Objects.requireNonNull(format, "format");
-
-        this.out = out;
-        this.format = format;
-        // TODO: Is it a good idea to do this here instead of on the first call to a print method?
-        // It seems a pain to have to track whether the header has already been printed or not.
-        if (format.getHeaderComments() != null) {
-            for (final String line : format.getHeaderComments()) {
-                if (line != null) {
-                    this.printComment(line);
-                }
-            }
-        }
-        if (format.getHeader() != null && !format.getSkipHeaderRecord()) {
-            this.printRecord((Object[]) format.getHeader());
-        }
-    }
-
-    // ======================================================
-    // printing implementation
-    // ======================================================
-
-    @Override
-    public void close() throws IOException {
-        close(false);
-    }
-
-    /**
-     * Closes the underlying stream with an optional flush first.
-     * @param flush whether to flush before the actual close.
-     *
-     * @throws IOException
-     *             If an I/O error occurs
-     * @since 1.6
-     */
-    public void close(final boolean flush) throws IOException {
-        if (flush || format.getAutoFlush()) {
-            flush();
-        }
-        if (out instanceof Closeable) {
-            ((Closeable) out).close();
-        }
-    }
-
-    /**
-     * Flushes the underlying stream.
-     *
-     * @throws IOException
-     *             If an I/O error occurs
-     */
-    @Override
-    public void flush() throws IOException {
-        if (out instanceof Flushable) {
-            ((Flushable) out).flush();
-        }
-    }
-
-    /**
-     * Gets the target Appendable.
-     *
-     * @return the target Appendable.
-     */
-    public Appendable getOut() {
-        return this.out;
-    }
-
-    /**
-     * Prints the string as the next value on the line. The value will be escaped or encapsulated as needed.
-     *
-     * @param value
-     *            value to be output.
-     * @throws IOException
-     *             If an I/O error occurs
-     */
-    public void print(final Object value) throws IOException {
-        format.print(value, out, newRecord);
-        newRecord = false;
-    }
-
-    /**
-     * Prints a comment on a new line among the delimiter separated values.
-     *
-     * 

-     * Comments will always begin on a new line and occupy at least one full line. The character specified to start
-     * comments and a space will be inserted at the beginning of each new line in the comment.
-     * 
-     *
-     * 

-     * If comments are disabled in the current CSV format this method does nothing.
-     * 
-     *
-     * 
This method detects line breaks inside the comment string and inserts {@link CSVFormat#getRecordSeparator()}
-     * to start a new line of the comment. Note that this might produce unexpected results for formats that do not use
-     * line breaks as record separator.
-     *
-     * @param comment
-     *            the comment to output
-     * @throws IOException
-     *             If an I/O error occurs
-     */
-    public void printComment(final String comment) throws IOException {
-        if (!format.isCommentMarkerSet()) {
-            return;
-        }
-        if (!newRecord) {
-            println();
-        }
-        out.append(format.getCommentMarker().charValue());
-        out.append(SP);
-        final int commentLength = comment.length();
-        for (int i = 0; i < commentLength; i++) {
-            final char c = comment.charAt(i);
-            switch (c) {
-            case CR:
-                if (i + 1 < commentLength && comment.charAt(i + 1) == LF) {
-                    i++;
-                }
-                //$FALL-THROUGH$ break intentionally excluded.
-            case LF:
-                println();
-                out.append(format.getCommentMarker().charValue());
-                out.append(SP);
-                break;
-            default:
-                out.append(c);
-                break;
-            }
-        }
-        println();
-    }
-
-    /**
-     * Outputs the record separator.
-     *
-     * @throws IOException
-     *             If an I/O error occurs
-     */
-    public void println() throws IOException {
-        format.println(out);
-        newRecord = true;
-    }
-
-    /**
-     * Prints the given values a single record of delimiter separated values followed by the record separator.
-     *
-     * 

-     * The values will be quoted if needed. Quotes and newLine characters will be escaped. This method adds the record
-     * separator to the output after printing the record, so there is no need to call {@link #println()}.
-     * 
-     *
-     * @param values
-     *            values to output.
-     * @throws IOException
-     *             If an I/O error occurs
-     */
-    public void printRecord(final Iterable values) throws IOException {
-        for (final Object value : values) {
-            print(value);
-        }
-        println();
-    }
-
-    /**
-     * Prints the given values a single record of delimiter separated values followed by the record separator.
-     *
-     * 

-     * The values will be quoted if needed. Quotes and newLine characters will be escaped. This method adds the record
-     * separator to the output after printing the record, so there is no need to call {@link #println()}.
-     * 
-     *
-     * @param values
-     *            values to output.
-     * @throws IOException
-     *             If an I/O error occurs
-     */
-    public void printRecord(final Object... values) throws IOException {
-        format.printRecord(out, values);
-        newRecord = true;
-    }
-
-    /**
-     * Prints all the objects in the given collection handling nested collections/arrays as records.
-     *
-     * 

-     * If the given collection only contains simple objects, this method will print a single record like
-     * {@link #printRecord(Iterable)}. If the given collections contains nested collections/arrays those nested elements
-     * will each be printed as records using {@link #printRecord(Object...)}.
-     * 
-     *
-     * 

-     * Given the following data structure:
-     * 
-     *
-     * 
-     * 
-     * List<String[]> data = ...
-     * data.add(new String[]{ "A", "B", "C" });
-     * data.add(new String[]{ "1", "2", "3" });
-     * data.add(new String[]{ "A1", "B2", "C3" });
-     * 
-     * 
-     *
-     * 

-     * Calling this method will print:
-     * 
-     *
-     * 
-     * 
-     * A, B, C
-     * 1, 2, 3
-     * A1, B2, C3
-     * 
-     * 
-     *
-     * @param values
-     *            the values to print.
-     * @throws IOException
-     *             If an I/O error occurs
-     */
-    public void printRecords(final Iterable values) throws IOException {
-        for (final Object value : values) {
-            if (value instanceof Object[]) {
-                this.printRecord((Object[]) value);
-            } else if (value instanceof Iterable) {
-                this.printRecord((Iterable) value);
-            } else {
-                this.printRecord(value);
-            }
-        }
-    }
-
-    /**
-     * Prints all the objects in the given array handling nested collections/arrays as records.
-     *
-     * 

-     * If the given array only contains simple objects, this method will print a single record like
-     * {@link #printRecord(Object...)}. If the given collections contains nested collections/arrays those nested
-     * elements will each be printed as records using {@link #printRecord(Object...)}.
-     * 
-     *
-     * 

-     * Given the following data structure:
-     * 
-     *
-     * 
-     * 
-     * String[][] data = new String[3][]
-     * data[0] = String[]{ "A", "B", "C" };
-     * data[1] = new String[]{ "1", "2", "3" };
-     * data[2] = new String[]{ "A1", "B2", "C3" };
-     * 
-     * 
-     *
-     * 

-     * Calling this method will print:
-     * 
-     *
-     * 
-     * 
-     * A, B, C
-     * 1, 2, 3
-     * A1, B2, C3
-     * 
-     * 
-     *
-     * @param values
-     *            the values to print.
-     * @throws IOException
-     *             If an I/O error occurs
-     */
-    public void printRecords(final Object... values) throws IOException {
-        printRecords(Arrays.asList(values));
-    }
-
-    /**
-     * Prints all the objects in the given JDBC result set.
-     *
-     * @param resultSet
-     *            result set the values to print.
-     * @throws IOException
-     *             If an I/O error occurs
-     * @throws SQLException
-     *             if a database access error occurs
-     */
-    public void printRecords(final ResultSet resultSet) throws SQLException, IOException {
-        final int columnCount = resultSet.getMetaData().getColumnCount();
-        while (resultSet.next()) {
-            for (int i = 1; i <= columnCount; i++) {
-                final Object object = resultSet.getObject(i);
-                // TODO Who manages the Clob? The JDBC driver or must we close it? Is it driver-dependent?
-                print(object instanceof Clob ? ((Clob) object).getCharacterStream() : object);
-            }
-            println();
-        }
-    }
-}
diff --git a/src/test/resources/org/apache/commons/csv/CSVRecord.java b/src/test/resources/org/apache/commons/csv/CSVRecord.java
deleted file mode 100644
index 5181bc9aeb..0000000000
--- a/src/test/resources/org/apache/commons/csv/CSVRecord.java
+++ /dev/null
@@ -1,329 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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 org.apache.commons.csv;
-
-import java.io.Serializable;
-import java.util.Arrays;
-import java.util.Iterator;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Objects;
-
-/**
- * A CSV record parsed from a CSV file.
- *
- * 

- * Note: Support for {@link Serializable} is scheduled to be removed in version 2.0.
- * In version 1.8 the mapping between the column header and the column index was
- * removed from the serialised state. The class maintains serialization compatibility
- * with versions pre-1.8 for the record values; these must be accessed by index
- * following deserialization. There will be loss of any functionally linked to the header
- * mapping when transferring serialised forms pre-1.8 to 1.8 and vice versa.
- * 
- */
-public final class CSVRecord implements Serializable, Iterable {
-
-    private static final String[] EMPTY_STRING_ARRAY = new String[0];
-
-    private static final long serialVersionUID = 1L;
-
-    private final long characterPosition;
-
-    /** The accumulated comments (if any) */
-    private final String comment;
-
-    /** The record number. */
-    private final long recordNumber;
-
-    /** The values of the record */
-    private final String[] values;
-
-    /** The parser that originates this record. This is not serialized. */
-    private final transient CSVParser parser;
-
-    CSVRecord(final CSVParser parser, final String[] values, final String comment, final long recordNumber,
-            final long characterPosition) {
-        this.recordNumber = recordNumber;
-        this.values = values != null ? values : EMPTY_STRING_ARRAY;
-        this.parser = parser;
-        this.comment = comment;
-        this.characterPosition = characterPosition;
-    }
-
-    /**
-     * Returns a value by {@link Enum}.
-     *
-     * @param e
-     *            an enum
-     * @return the String at the given enum String
-     */
-    public String get(final Enum e) {
-        return get(Objects.toString(e, null));
-    }
-
-    /**
-     * Returns a value by index.
-     *
-     * @param i
-     *            a column index (0-based)
-     * @return the String at the given index
-     */
-    public String get(final int i) {
-        return values[i];
-    }
-
-    /**
-     * Returns a value by name.
-     *
-     * 

-     * Note: This requires a field mapping obtained from the original parser.
-     * A check using {@link #isMapped(String)} should be used to determine if a
-     * mapping exists from the provided {@code name} to a field index. In this case an
-     * exception will only be thrown if the record does not contain a field corresponding
-     * to the mapping, that is the record length is not consistent with the mapping size.
-     * 
-     *
-     * @param name
-     *            the name of the column to be retrieved.
-     * @return the column value, maybe null depending on {@link CSVFormat#getNullString()}.
-     * @throws IllegalStateException
-     *             if no header mapping was provided
-     * @throws IllegalArgumentException
-     *             if {@code name} is not mapped or if the record is inconsistent
-     * @see #isMapped(String)
-     * @see #isConsistent()
-     * @see #getParser()
-     * @see CSVFormat#withNullString(String)
-     */
-    public String get(final String name) {
-        final Map headerMap = getHeaderMapRaw();
-        if (headerMap == null) {
-            throw new IllegalStateException(
-                "No header mapping was specified, the record values can't be accessed by name");
-        }
-        final Integer index = headerMap.get(name);
-        if (index == null) {
-            throw new IllegalArgumentException(String.format("Mapping for %s not found, expected one of %s", name,
-                headerMap.keySet()));
-        }
-        try {
-            return values[index.intValue()];
-        } catch (final ArrayIndexOutOfBoundsException e) {
-            throw new IllegalArgumentException(String.format(
-                "Index for header '%s' is %d but CSVRecord only has %d values!", name, index,
-                Integer.valueOf(values.length)));
-        }
-    }
-
-    /**
-     * Returns the start position of this record as a character position in the source stream. This may or may not
-     * correspond to the byte position depending on the character set.
-     *
-     * @return the position of this record in the source stream.
-     */
-    public long getCharacterPosition() {
-        return characterPosition;
-    }
-
-    /**
-     * Returns the comment for this record, if any.
-     * Note that comments are attached to the following record.
-     * If there is no following record (i.e. the comment is at EOF)
-     * the comment will be ignored.
-     *
-     * @return the comment for this record, or null if no comment for this record is available.
-     */
-    public String getComment() {
-        return comment;
-    }
-
-    private Map getHeaderMapRaw() {
-        return parser == null ? null : parser.getHeaderMapRaw();
-    }
-
-    /**
-     * Returns the parser.
-     *
-     * 

-     * Note: The parser is not part of the serialized state of the record. A null check
-     * should be used when the record may have originated from a serialized form.
-     * 
-     *
-     * @return the parser.
-     * @since 1.7
-     */
-    public CSVParser getParser() {
-        return parser;
-    }
-
-    /**
-     * Returns the number of this record in the parsed CSV file.
-     *
-     * 

-     * ATTENTION: If your CSV input has multi-line values, the returned number does not correspond to
-     * the current line number of the parser that created this record.
-     * 
-     *
-     * @return the number of this record.
-     * @see CSVParser#getCurrentLineNumber()
-     */
-    public long getRecordNumber() {
-        return recordNumber;
-    }
-
-    /**
-     * Checks whether this record has a comment, false otherwise.
-     * Note that comments are attached to the following record.
-     * If there is no following record (i.e. the comment is at EOF)
-     * the comment will be ignored.
-     *
-     * @return true if this record has a comment, false otherwise
-     * @since 1.3
-     */
-    public boolean hasComment() {
-        return comment != null;
-    }
-
-    /**
-     * Tells whether the record size matches the header size.
-     *
-     * 

-     * Returns true if the sizes for this record match and false if not. Some programs can export files that fail this
-     * test but still produce parsable files.
-     * 
-     *
-     * @return true of this record is valid, false if not
-     */
-    public boolean isConsistent() {
-        final Map headerMap = getHeaderMapRaw();
-        return headerMap == null || headerMap.size() == values.length;
-    }
-
-    /**
-     * Checks whether a given column is mapped, i.e. its name has been defined to the parser.
-     *
-     * @param name
-     *            the name of the column to be retrieved.
-     * @return whether a given column is mapped.
-     */
-    public boolean isMapped(final String name) {
-        final Map headerMap = getHeaderMapRaw();
-        return headerMap != null && headerMap.containsKey(name);
-    }
-
-    /**
-     * Checks whether a column with given index has a value.
-     *
-     * @param index
-     *         a column index (0-based)
-     * @return whether a column with given index has a value
-     */
-    public boolean isSet(final int index) {
-        return 0 <= index && index < values.length;
-    }
-
-    /**
-     * Checks whether a given columns is mapped and has a value.
-     *
-     * @param name
-     *            the name of the column to be retrieved.
-     * @return whether a given columns is mapped and has a value
-     */
-    public boolean isSet(final String name) {
-        return isMapped(name) && getHeaderMapRaw().get(name).intValue() < values.length;
-    }
-
-    /**
-     * Returns an iterator over the values of this record.
-     *
-     * @return an iterator over the values of this record.
-     */
-    @Override
-    public Iterator iterator() {
-        return toList().iterator();
-    }
-
-    /**
-     * Puts all values of this record into the given Map.
-     *
-     * @param map
-     *            The Map to populate.
-     * @return the given map.
-     * @since 1.9
-     */
-    public > M putIn(final M map) {
-        if (getHeaderMapRaw() == null) {
-            return map;
-        }
-        for (final Entry entry : getHeaderMapRaw().entrySet()) {
-            final int col = entry.getValue().intValue();
-            if (col < values.length) {
-                map.put(entry.getKey(), values[col]);
-            }
-        }
-        return map;
-    }
-
-    /**
-     * Returns the number of values in this record.
-     *
-     * @return the number of values.
-     */
-    public int size() {
-        return values.length;
-    }
-
-    /**
-     * Converts the values to a List.
-     *
-     * TODO: Maybe make this public?
-     *
-     * @return a new List
-     */
-    private List toList() {
-        return Arrays.asList(values);
-    }
-
-    /**
-     * Copies this record into a new Map of header name to record value.
-     *
-     * @return A new Map. The map is empty if the record has no headers.
-     */
-    public Map toMap() {
-        return putIn(new LinkedHashMap(values.length));
-    }
-
-    /**
-     * Returns a string representation of the contents of this record. The result is constructed by comment, mapping,
-     * recordNumber and by passing the internal values array to {@link Arrays#toString(Object[])}.
-     *
-     * @return a String representation of this record.
-     */
-    @Override
-    public String toString() {
-        return "CSVRecord [comment='" + comment + "', recordNumber=" + recordNumber + ", values=" +
-            Arrays.toString(values) + "]";
-    }
-
-    String[] values() {
-        return values;
-    }
-
-}
diff --git a/src/test/resources/org/apache/commons/csv/Constants.java b/src/test/resources/org/apache/commons/csv/Constants.java
deleted file mode 100644
index b7dc770ac4..0000000000
--- a/src/test/resources/org/apache/commons/csv/Constants.java
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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 org.apache.commons.csv;
-
-/**
- * Constants for this package.
- */
-final class Constants {
-
-    static final char BACKSLASH = '\\';
-
-    static final char BACKSPACE = '\b';
-
-    static final char COMMA = ',';
-
-    /**
-     * Starts a comment, the remainder of the line is the comment.
-     */
-    static final char COMMENT = '#';
-
-    static final char CR = '\r';
-
-    /** RFC 4180 defines line breaks as CRLF */
-    static final String CRLF = "\r\n";
-
-    static final Character DOUBLE_QUOTE_CHAR = Character.valueOf('"');
-
-    static final String EMPTY = "";
-
-    /** The end of stream symbol */
-    static final int END_OF_STREAM = -1;
-
-    static final char FF = '\f';
-
-    static final char LF = '\n';
-
-    /**
-     * Unicode line separator.
-     */
-    static final String LINE_SEPARATOR = "\u2028";
-
-    /**
-     * Unicode next line.
-     */
-    static final String NEXT_LINE = "\u0085";
-
-    /**
-     * Unicode paragraph separator.
-     */
-    static final String PARAGRAPH_SEPARATOR = "\u2029";
-
-    static final char PIPE = '|';
-
-    /** ASCII record separator */
-    static final char RS = 30;
-
-    static final char SP = ' ';
-
-    static final char TAB = '\t';
-
-    /** Undefined state for the lookahead char */
-    static final int UNDEFINED = -2;
-
-    /** ASCII unit separator */
-    static final char US = 31;
-
-}
diff --git a/src/test/resources/org/apache/commons/csv/ExtendedBufferedReader.java b/src/test/resources/org/apache/commons/csv/ExtendedBufferedReader.java
deleted file mode 100644
index b9ca79df9c..0000000000
--- a/src/test/resources/org/apache/commons/csv/ExtendedBufferedReader.java
+++ /dev/null
@@ -1,191 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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 org.apache.commons.csv;
-
-import static org.apache.commons.csv.Constants.CR;
-import static org.apache.commons.csv.Constants.END_OF_STREAM;
-import static org.apache.commons.csv.Constants.LF;
-import static org.apache.commons.csv.Constants.UNDEFINED;
-
-import java.io.BufferedReader;
-import java.io.IOException;
-import java.io.Reader;
-
-/**
- * A special buffered reader which supports sophisticated read access.
- * 

- * In particular the reader supports a look-ahead option, which allows you to see the next char returned by
- * {@link #read()}. This reader also tracks how many characters have been read with {@link #getPosition()}.
- * 
- */
-final class ExtendedBufferedReader extends BufferedReader {
-
-    /** The last char returned */
-    private int lastChar = UNDEFINED;
-
-    /** The count of EOLs (CR/LF/CRLF) seen so far */
-    private long eolCounter;
-
-    /** The position, which is number of characters read so far */
-    private long position;
-
-    private boolean closed;
-
-    /**
-     * Created extended buffered reader using default buffer-size
-     */
-    ExtendedBufferedReader(final Reader reader) {
-        super(reader);
-    }
-
-    /**
-     * Closes the stream.
-     *
-     * @throws IOException
-     *             If an I/O error occurs
-     */
-    @Override
-    public void close() throws IOException {
-        // Set ivars before calling super close() in case close() throws an IOException.
-        closed = true;
-        lastChar = END_OF_STREAM;
-        super.close();
-    }
-
-    /**
-     * Returns the current line number
-     *
-     * @return the current line number
-     */
-    long getCurrentLineNumber() {
-        // Check if we are at EOL or EOF or just starting
-        if (lastChar == CR || lastChar == LF || lastChar == UNDEFINED || lastChar == END_OF_STREAM) {
-            return eolCounter; // counter is accurate
-        }
-        return eolCounter + 1; // Allow for counter being incremented only at EOL
-    }
-
-    /**
-     * Returns the last character that was read as an integer (0 to 65535). This will be the last character returned by
-     * any of the read methods. This will not include a character read using the {@link #lookAhead()} method. If no
-     * character has been read then this will return {@link Constants#UNDEFINED}. If the end of the stream was reached
-     * on the last read then this will return {@link Constants#END_OF_STREAM}.
-     *
-     * @return the last character that was read
-     */
-    int getLastChar() {
-        return lastChar;
-    }
-
-    /**
-     * Gets the character position in the reader.
-     *
-     * @return the current position in the reader (counting characters, not bytes since this is a Reader)
-     */
-    long getPosition() {
-        return this.position;
-    }
-
-    public boolean isClosed() {
-        return closed;
-    }
-
-    /**
-     * Returns the next character in the current reader without consuming it. So the next call to {@link #read()} will
-     * still return this value. Does not affect line number or last character.
-     *
-     * @return the next character
-     *
-     * @throws IOException
-     *             if there is an error in reading
-     */
-    int lookAhead() throws IOException {
-        super.mark(1);
-        final int c = super.read();
-        super.reset();
-
-        return c;
-    }
-
-    @Override
-    public int read() throws IOException {
-        final int current = super.read();
-        if (current == CR || current == LF && lastChar != CR) {
-            eolCounter++;
-        }
-        lastChar = current;
-        this.position++;
-        return lastChar;
-    }
-
-    @Override
-    public int read(final char[] buf, final int offset, final int length) throws IOException {
-        if (length == 0) {
-            return 0;
-        }
-
-        final int len = super.read(buf, offset, length);
-
-        if (len > 0) {
-
-            for (int i = offset; i < offset + len; i++) {
-                final char ch = buf[i];
-                if (ch == LF) {
-                    if (CR != (i > 0 ? buf[i - 1] : lastChar)) {
-                        eolCounter++;
-                    }
-                } else if (ch == CR) {
-                    eolCounter++;
-                }
-            }
-
-            lastChar = buf[offset + len - 1];
-
-        } else if (len == -1) {
-            lastChar = END_OF_STREAM;
-        }
-
-        position += len;
-        return len;
-    }
-
-    /**
-     * Calls {@link BufferedReader#readLine()} which drops the line terminator(s). This method should only be called
-     * when processing a comment, otherwise information can be lost.
-     * 

-     * Increments {@link #eolCounter}
-     * 

-     * Sets {@link #lastChar} to {@link Constants#END_OF_STREAM} at EOF, otherwise to LF
-     *
-     * @return the line that was read, or null if reached EOF.
-     */
-    @Override
-    public String readLine() throws IOException {
-        final String line = super.readLine();
-
-        if (line != null) {
-            lastChar = LF; // needed for detecting start of line
-            eolCounter++;
-        } else {
-            lastChar = END_OF_STREAM;
-        }
-
-        return line;
-    }
-
-}
diff --git a/src/test/resources/org/apache/commons/csv/IOUtils.java b/src/test/resources/org/apache/commons/csv/IOUtils.java
deleted file mode 100644
index 1771d4dc3c..0000000000
--- a/src/test/resources/org/apache/commons/csv/IOUtils.java
+++ /dev/null
@@ -1,139 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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 org.apache.commons.csv;
-
-import java.io.IOException;
-import java.io.Reader;
-import java.io.Writer;
-import java.nio.CharBuffer;
-
-/** Copied from Apache Commons IO. */
-class IOUtils {
-
-    /**
-     * 

-     * Copied from Apache Commons IO.
-     * 
-     * The default buffer size ({@value}).
-     */
-    static final int DEFAULT_BUFFER_SIZE = 1024 * 4;
-
-    /**
-     * 

-     * Copied from Apache Commons IO.
-     * 
-     * Represents the end-of-file (or stream).
-     * @since 2.5 (made public)
-     */
-    private static final int EOF = -1;
-
-    /**
-     * Copies chars from a large (over 2GB) {@code Reader} to an {@code Appendable}.
-     * 

-     * This method buffers the input internally, so there is no need to use a
-     * {@code BufferedReader}.
-     * 
-     * The buffer size is given by {@link #DEFAULT_BUFFER_SIZE}.
-     *
-     * @param input the {@code Reader} to read from
-     * @param output the {@code Appendable} to append to
-     * @return the number of characters copied
-     * @throws NullPointerException if the input or output is null
-     * @throws IOException          if an I/O error occurs
-     * @since 2.7
-     */
-    static long copy(final Reader input, final Appendable output) throws IOException {
-        return copy(input, output, CharBuffer.allocate(DEFAULT_BUFFER_SIZE));
-    }
-
-    /**
-     * Copies chars from a large (over 2GB) {@code Reader} to an {@code Appendable}.
-     * 

-     * This method uses the provided buffer, so there is no need to use a
-     * {@code BufferedReader}.
-     * 
-     *
-     * @param input the {@code Reader} to read from
-     * @param output the {@code Appendable} to write to
-     * @param buffer the buffer to be used for the copy
-     * @return the number of characters copied
-     * @throws NullPointerException if the input or output is null
-     * @throws IOException          if an I/O error occurs
-     * @since 2.7
-     */
-    static long copy(final Reader input, final Appendable output, final CharBuffer buffer) throws IOException {
-        long count = 0;
-        int n;
-        while (EOF != (n = input.read(buffer))) {
-            buffer.flip();
-            output.append(buffer, 0, n);
-            count += n;
-        }
-        return count;
-    }
-
-    /**
-     * 

-     * Copied from Apache Commons IO.
-     * 
-     * Copies chars from a large (over 2GB) {@code Reader} to a {@code Writer}.
-     * 

-     * This method buffers the input internally, so there is no need to use a
-     * {@code BufferedReader}.
-     * 

-     * The buffer size is given by {@link #DEFAULT_BUFFER_SIZE}.
-     *
-     * @param input the {@code Reader} to read from
-     * @param output the {@code Writer} to write to
-     * @return the number of characters copied
-     * @throws NullPointerException if the input or output is null
-     * @throws IOException          if an I/O error occurs
-     * @since 1.3
-     */
-    static long copyLarge(final Reader input, final Writer output) throws IOException {
-        return copyLarge(input, output, new char[DEFAULT_BUFFER_SIZE]);
-    }
-
-    /**
-     * 

-     * Copied from Apache Commons IO.
-     * 
-     * Copies chars from a large (over 2GB) {@code Reader} to a {@code Writer}.
-     * 

-     * This method uses the provided buffer, so there is no need to use a
-     * {@code BufferedReader}.
-     * 

-     *
-     * @param input the {@code Reader} to read from
-     * @param output the {@code Writer} to write to
-     * @param buffer the buffer to be used for the copy
-     * @return the number of characters copied
-     * @throws NullPointerException if the input or output is null
-     * @throws IOException          if an I/O error occurs
-     * @since 2.2
-     */
-    static long copyLarge(final Reader input, final Writer output, final char[] buffer) throws IOException {
-        long count = 0;
-        int n;
-        while (EOF != (n = input.read(buffer))) {
-            output.write(buffer, 0, n);
-            count += n;
-        }
-        return count;
-    }
-
-}
diff --git a/src/test/resources/org/apache/commons/csv/Lexer.java b/src/test/resources/org/apache/commons/csv/Lexer.java
deleted file mode 100644
index 2795ca29b7..0000000000
--- a/src/test/resources/org/apache/commons/csv/Lexer.java
+++ /dev/null
@@ -1,461 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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 org.apache.commons.csv;
-
-import static org.apache.commons.csv.Constants.BACKSPACE;
-import static org.apache.commons.csv.Constants.CR;
-import static org.apache.commons.csv.Constants.END_OF_STREAM;
-import static org.apache.commons.csv.Constants.FF;
-import static org.apache.commons.csv.Constants.LF;
-import static org.apache.commons.csv.Constants.TAB;
-import static org.apache.commons.csv.Constants.UNDEFINED;
-import static org.apache.commons.csv.Token.Type.COMMENT;
-import static org.apache.commons.csv.Token.Type.EOF;
-import static org.apache.commons.csv.Token.Type.EORECORD;
-import static org.apache.commons.csv.Token.Type.INVALID;
-import static org.apache.commons.csv.Token.Type.TOKEN;
-
-import java.io.Closeable;
-import java.io.IOException;
-
-/**
- * Lexical analyzer.
- */
-final class Lexer implements Closeable {
-
-    private static final String CR_STRING = Character.toString(CR);
-    private static final String LF_STRING = Character.toString(LF);
-
-    /**
-     * Constant char to use for disabling comments, escapes and encapsulation. The value -2 is used because it
-     * won't be confused with an EOF signal (-1), and because the Unicode value {@code FFFE} would be encoded as two
-     * chars (using surrogates) and thus there should never be a collision with a real text char.
-     */
-    private static final char DISABLED = '\ufffe';
-
-    private final char delimiter;
-    private final char escape;
-    private final char quoteChar;
-    private final char commentStart;
-
-    private final boolean ignoreSurroundingSpaces;
-    private final boolean ignoreEmptyLines;
-
-    /** The input stream */
-    private final ExtendedBufferedReader reader;
-    private String firstEol;
-
-    Lexer(final CSVFormat format, final ExtendedBufferedReader reader) {
-        this.reader = reader;
-        this.delimiter = format.getDelimiter();
-        this.escape = mapNullToDisabled(format.getEscapeCharacter());
-        this.quoteChar = mapNullToDisabled(format.getQuoteCharacter());
-        this.commentStart = mapNullToDisabled(format.getCommentMarker());
-        this.ignoreSurroundingSpaces = format.getIgnoreSurroundingSpaces();
-        this.ignoreEmptyLines = format.getIgnoreEmptyLines();
-    }
-
-    /**
-     * Closes resources.
-     *
-     * @throws IOException
-     *             If an I/O error occurs
-     */
-    @Override
-    public void close() throws IOException {
-        reader.close();
-    }
-
-    /**
-     * Returns the current character position
-     *
-     * @return the current character position
-     */
-    long getCharacterPosition() {
-        return reader.getPosition();
-    }
-
-    /**
-     * Returns the current line number
-     *
-     * @return the current line number
-     */
-    long getCurrentLineNumber() {
-        return reader.getCurrentLineNumber();
-    }
-
-    String getFirstEol(){
-        return firstEol;
-    }
-
-    boolean isClosed() {
-        return reader.isClosed();
-    }
-
-    boolean isCommentStart(final int ch) {
-        return ch == commentStart;
-    }
-
-    boolean isDelimiter(final int ch) {
-        return ch == delimiter;
-    }
-
-    /**
-     * @return true if the given character indicates end of file
-     */
-    boolean isEndOfFile(final int ch) {
-        return ch == END_OF_STREAM;
-    }
-
-    boolean isEscape(final int ch) {
-        return ch == escape;
-    }
-
-    private boolean isMetaChar(final int ch) {
-        return ch == delimiter ||
-               ch == escape ||
-               ch == quoteChar ||
-               ch == commentStart;
-    }
-
-    boolean isQuoteChar(final int ch) {
-        return ch == quoteChar;
-    }
-
-    /**
-     * Checks if the current character represents the start of a line: a CR, LF or is at the start of the file.
-     *
-     * @param ch the character to check
-     * @return true if the character is at the start of a line.
-     */
-    boolean isStartOfLine(final int ch) {
-        return ch == LF || ch == CR || ch == UNDEFINED;
-    }
-
-    /**
-     * @return true if the given char is a whitespace character
-     */
-    boolean isWhitespace(final int ch) {
-        return !isDelimiter(ch) && Character.isWhitespace((char) ch);
-    }
-
-    private char mapNullToDisabled(final Character c) {
-        return c == null ? DISABLED : c.charValue();
-    }
-
-    /**
-     * Returns the next token.
-     * 

-     * A token corresponds to a term, a record change or an end-of-file indicator.
-     * 
-     *
-     * @param token
-     *            an existing Token object to reuse. The caller is responsible to initialize the Token.
-     * @return the next token found
-     * @throws java.io.IOException
-     *             on stream access error
-     */
-    Token nextToken(final Token token) throws IOException {
-
-        // get the last read char (required for empty line detection)
-        int lastChar = reader.getLastChar();
-
-        // read the next char and set eol
-        int c = reader.read();
-        /*
-         * Note: The following call will swallow LF if c == CR. But we don't need to know if the last char was CR or LF
-         * - they are equivalent here.
-         */
-        boolean eol = readEndOfLine(c);
-
-        // empty line detection: eol AND (last char was EOL or beginning)
-        if (ignoreEmptyLines) {
-            while (eol && isStartOfLine(lastChar)) {
-                // go on char ahead ...
-                lastChar = c;
-                c = reader.read();
-                eol = readEndOfLine(c);
-                // reached end of file without any content (empty line at the end)
-                if (isEndOfFile(c)) {
-                    token.type = EOF;
-                    // don't set token.isReady here because no content
-                    return token;
-                }
-            }
-        }
-
-        // did we reach eof during the last iteration already ? EOF
-        if (isEndOfFile(lastChar) || !isDelimiter(lastChar) && isEndOfFile(c)) {
-            token.type = EOF;
-            // don't set token.isReady here because no content
-            return token;
-        }
-
-        if (isStartOfLine(lastChar) && isCommentStart(c)) {
-            final String line = reader.readLine();
-            if (line == null) {
-                token.type = EOF;
-                // don't set token.isReady here because no content
-                return token;
-            }
-            final String comment = line.trim();
-            token.content.append(comment);
-            token.type = COMMENT;
-            return token;
-        }
-
-        // important: make sure a new char gets consumed in each iteration
-        while (token.type == INVALID) {
-            // ignore whitespaces at beginning of a token
-            if (ignoreSurroundingSpaces) {
-                while (isWhitespace(c) && !eol) {
-                    c = reader.read();
-                    eol = readEndOfLine(c);
-                }
-            }
-
-            // ok, start of token reached: encapsulated, or token
-            if (isDelimiter(c)) {
-                // empty token return TOKEN("")
-                token.type = TOKEN;
-            } else if (eol) {
-                // empty token return EORECORD("")
-                // noop: token.content.append("");
-                token.type = EORECORD;
-            } else if (isQuoteChar(c)) {
-                // consume encapsulated token
-                parseEncapsulatedToken(token);
-            } else if (isEndOfFile(c)) {
-                // end of file return EOF()
-                // noop: token.content.append("");
-                token.type = EOF;
-                token.isReady = true; // there is data at EOF
-            } else {
-                // next token must be a simple token
-                // add removed blanks when not ignoring whitespace chars...
-                parseSimpleToken(token, c);
-            }
-        }
-        return token;
-    }
-
-    /**
-     * Parses an encapsulated token.
-     * 

-     * Encapsulated tokens are surrounded by the given encapsulating-string. The encapsulator itself might be included
-     * in the token using a doubling syntax (as "", '') or using escaping (as in \", \'). Whitespaces before and after
-     * an encapsulated token are ignored. The token is finished when one of the following conditions become true:
-     * 

-     * 
an unescaped encapsulator has been reached, and is followed by optional whitespace then:
-     * 

-     * 
delimiter (TOKEN)
-     * 
end of line (EORECORD)
-     * 
-     * 
end of stream has been reached (EOF)
 
-     *
-     * @param token
-     *            the current token
-     * @return a valid token object
-     * @throws IOException
-     *             on invalid state: EOF before closing encapsulator or invalid character before delimiter or EOL
-     */
-    private Token parseEncapsulatedToken(final Token token) throws IOException {
-        // save current line number in case needed for IOE
-        final long startLineNumber = getCurrentLineNumber();
-        int c;
-        while (true) {
-            c = reader.read();
-
-            if (isEscape(c)) {
-                final int unescaped = readEscape();
-                if (unescaped == END_OF_STREAM) { // unexpected char after escape
-                    token.content.append((char) c).append((char) reader.getLastChar());
-                } else {
-                    token.content.append((char) unescaped);
-                }
-            } else if (isQuoteChar(c)) {
-                if (isQuoteChar(reader.lookAhead())) {
-                    // double or escaped encapsulator -> add single encapsulator to token
-                    c = reader.read();
-                    token.content.append((char) c);
-                } else {
-                    // token finish mark (encapsulator) reached: ignore whitespace till delimiter
-                    while (true) {
-                        c = reader.read();
-                        if (isDelimiter(c)) {
-                            token.type = TOKEN;
-                            return token;
-                        } else if (isEndOfFile(c)) {
-                            token.type = EOF;
-                            token.isReady = true; // There is data at EOF
-                            return token;
-                        } else if (readEndOfLine(c)) {
-                            token.type = EORECORD;
-                            return token;
-                        } else if (!isWhitespace(c)) {
-                            // error invalid char between token and next delimiter
-                            throw new IOException("(line " + getCurrentLineNumber() +
-                                    ") invalid char between encapsulated token and delimiter");
-                        }
-                    }
-                }
-            } else if (isEndOfFile(c)) {
-                // error condition (end of file before end of token)
-                throw new IOException("(startline " + startLineNumber +
-                        ") EOF reached before encapsulated token finished");
-            } else {
-                // consume character
-                token.content.append((char) c);
-            }
-        }
-    }
-
-    /**
-     * Parses a simple token.
-     * 

-     * Simple token are tokens which are not surrounded by encapsulators. A simple token might contain escaped
-     * delimiters (as \, or \;). The token is finished when one of the following conditions become true:
-     * 

-     * 
end of line has been reached (EORECORD)
-     * 
end of stream has been reached (EOF)
-     * 
an unescaped delimiter has been reached (TOKEN)
-     * 
-     *
-     * @param token
-     *            the current token
-     * @param ch
-     *            the current character
-     * @return the filled token
-     * @throws IOException
-     *             on stream access error
-     */
-    private Token parseSimpleToken(final Token token, int ch) throws IOException {
-        // Faster to use while(true)+break than while(token.type == INVALID)
-        while (true) {
-            if (readEndOfLine(ch)) {
-                token.type = EORECORD;
-                break;
-            } else if (isEndOfFile(ch)) {
-                token.type = EOF;
-                token.isReady = true; // There is data at EOF
-                break;
-            } else if (isDelimiter(ch)) {
-                token.type = TOKEN;
-                break;
-            } else if (isEscape(ch)) {
-                final int unescaped = readEscape();
-                if (unescaped == END_OF_STREAM) { // unexpected char after escape
-                    token.content.append((char) ch).append((char) reader.getLastChar());
-                } else {
-                    token.content.append((char) unescaped);
-                }
-                ch = reader.read(); // continue
-            } else {
-                token.content.append((char) ch);
-                ch = reader.read(); // continue
-            }
-        }
-
-        if (ignoreSurroundingSpaces) {
-            trimTrailingSpaces(token.content);
-        }
-
-        return token;
-    }
-
-    /**
-     * Greedily accepts \n, \r and \r\n This checker consumes silently the second control-character...
-     *
-     * @return true if the given or next character is a line-terminator
-     */
-    boolean readEndOfLine(int ch) throws IOException {
-        // check if we have \r\n...
-        if (ch == CR && reader.lookAhead() == LF) {
-            // note: does not change ch outside of this method!
-            ch = reader.read();
-            // Save the EOL state
-            if (firstEol == null) {
-                this.firstEol = Constants.CRLF;
-            }
-        }
-        // save EOL state here.
-        if (firstEol == null) {
-            if (ch == LF) {
-                this.firstEol = LF_STRING;
-            } else if (ch == CR) {
-                this.firstEol = CR_STRING;
-            }
-        }
-
-        return ch == LF || ch == CR;
-    }
-
-    // TODO escape handling needs more work
-    /**
-     * Handle an escape sequence.
-     * The current character must be the escape character.
-     * On return, the next character is available by calling {@link ExtendedBufferedReader#getLastChar()}
-     * on the input stream.
-     *
-     * @return the unescaped character (as an int) or {@link Constants#END_OF_STREAM} if char following the escape is
-     *      invalid.
-     * @throws IOException if there is a problem reading the stream or the end of stream is detected:
-     *      the escape character is not allowed at end of stream
-     */
-    int readEscape() throws IOException {
-        // the escape char has just been read (normally a backslash)
-        final int ch = reader.read();
-        switch (ch) {
-        case 'r':
-            return CR;
-        case 'n':
-            return LF;
-        case 't':
-            return TAB;
-        case 'b':
-            return BACKSPACE;
-        case 'f':
-            return FF;
-        case CR:
-        case LF:
-        case FF: // TODO is this correct?
-        case TAB: // TODO is this correct? Do tabs need to be escaped?
-        case BACKSPACE: // TODO is this correct?
-            return ch;
-        case END_OF_STREAM:
-            throw new IOException("EOF whilst processing escape sequence");
-        default:
-            // Now check for meta-characters
-            if (isMetaChar(ch)) {
-                return ch;
-            }
-            // indicate unexpected char - available from in.getLastChar()
-            return END_OF_STREAM;
-        }
-    }
-
-    void trimTrailingSpaces(final StringBuilder buffer) {
-        int length = buffer.length();
-        while (length > 0 && Character.isWhitespace(buffer.charAt(length - 1))) {
-            length = length - 1;
-        }
-        if (length != buffer.length()) {
-            buffer.setLength(length);
-        }
-    }
-}
diff --git a/src/test/resources/org/apache/commons/csv/QuoteMode.java b/src/test/resources/org/apache/commons/csv/QuoteMode.java
deleted file mode 100644
index 272deb7383..0000000000
--- a/src/test/resources/org/apache/commons/csv/QuoteMode.java
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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 org.apache.commons.csv;
-
-/**
- * Defines quoting behavior when printing.
- */
-public enum QuoteMode {
-
-    /**
-     * Quotes all fields.
-     */
-    ALL,
-
-    /**
-     * Quotes all non-null fields.
-     */
-    ALL_NON_NULL,
-
-    /**
-     * Quotes fields which contain special characters such as a the field delimiter, quote character or any of the
-     * characters in the line separator string.
-     */
-    MINIMAL,
-
-    /**
-     * Quotes all non-numeric fields.
-     */
-    NON_NUMERIC,
-
-    /**
-     * Never quotes fields. When the delimiter occurs in data, the printer prefixes it with the escape character. If the
-     * escape character is not set, format validation throws an exception.
-     */
-    NONE
-}
diff --git a/src/test/resources/org/apache/commons/csv/Token.java b/src/test/resources/org/apache/commons/csv/Token.java
deleted file mode 100644
index dff7d0181a..0000000000
--- a/src/test/resources/org/apache/commons/csv/Token.java
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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 org.apache.commons.csv;
-
-import static org.apache.commons.csv.Token.Type.INVALID;
-
-/**
- * Internal token representation.
- * 

- * It is used as contract between the lexer and the parser.
- */
-final class Token {
-
-    enum Type {
-        /** Token has no valid content, i.e. is in its initialized state. */
-        INVALID,
-
-        /** Token with content, at beginning or in the middle of a line. */
-        TOKEN,
-
-        /** Token (which can have content) when the end of file is reached. */
-        EOF,
-
-        /** Token with content when the end of a line is reached. */
-        EORECORD,
-
-        /** Token is a comment line. */
-        COMMENT
-    }
-
-    /** length of the initial token (content-)buffer */
-    private static final int INITIAL_TOKEN_LENGTH = 50;
-
-    /** Token type */
-    Token.Type type = INVALID;
-
-    /** The content buffer. */
-    final StringBuilder content = new StringBuilder(INITIAL_TOKEN_LENGTH);
-
-    /** Token ready flag: indicates a valid token with content (ready for the parser). */
-    boolean isReady;
-
-    void reset() {
-        content.setLength(0);
-        type = INVALID;
-        isReady = false;
-    }
-
-    /**
-     * Eases IDE debugging.
-     *
-     * @return a string helpful for debugging.
-     */
-    @Override
-    public String toString() {
-        return type.name() + " [" + content.toString() + "]";
-    }
-}
diff --git a/src/test/resources/org/apache/commons/csv/empty.txt b/src/test/resources/org/apache/commons/csv/empty.txt
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/src/test/resources/org/apache/commons/csv/package-info.java b/src/test/resources/org/apache/commons/csv/package-info.java
deleted file mode 100644
index 29e7fef612..0000000000
--- a/src/test/resources/org/apache/commons/csv/package-info.java
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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.
- */
-
-/**
- * Apache Commons CSV Format Support.
- *
- * 
CSV are widely used as interfaces to legacy systems or manual data-imports.
- *    CSV stands for "Comma Separated Values" (or sometimes "Character Separated
- *    Values"). The CSV data format is defined in
- *    RFC 4180
- *    but many dialects exist.
- *
- * 
Common to all file dialects is its basic structure: The CSV data-format
- *    is record oriented, whereas each record starts on a new textual line. A
- *    record is build of a list of values. Keep in mind that not all records
- *    must have an equal number of values:
- * 
- *       csv    := records*
- *       record := values*
- * 
- *
- * 
The following list contains the CSV aspects the Commons CSV parser supports:
- * 

- *   
Separators (for lines)
- *   
The record separators are hardcoded and cannot be changed. The must be '\r', '\n' or '\r\n'.
- *
- *   
Delimiter (for values)
- *   
The delimiter for values is freely configurable (default ',').
- *
- *   
Comments
- *   
Some CSV-dialects support a simple comment syntax. A comment is a record
- *       which must start with a designated character (the commentStarter). A record
- *       of this kind is treated as comment and gets removed from the input (default none)
- *
- *   
Encapsulator
- *  
Two encapsulator characters (default '"') are used to enclose -> complex values.
- *
- *   
Simple values
- *   
A simple value consist of all characters (except the delimiter) until
- *       (but not including) the next delimiter or a record-terminator. Optionally
- *       all surrounding whitespaces of a simple value can be ignored (default: true).
- *
- *   
Complex values
- *   
Complex values are encapsulated within a pair of the defined encapsulator characters.
- *       The encapsulator itself must be escaped or doubled when used inside complex values.
- *       Complex values preserve all kind of formatting (including newlines -> multiline-values)
- *
- *  
Empty line skipping
- *   
Optionally empty lines in CSV files can be skipped.
- *       Otherwise, empty lines will return a record with a single empty value.
- * 
- *
- * 
In addition to individually defined dialects, two predefined dialects (strict-csv, and excel-csv)
- *    can be set directly.
 
- *
- * 
Example usage:
- * 
- * Reader in = new StringReader("a,b,c");
- * for (CSVRecord record : CSVFormat.DEFAULT.parse(in)) {
- *     for (String field : record) {
- *         System.out.print("\"" + field + "\", ");
- *     }
- *     System.out.println();
- * }
- * 
- */
-
-package org.apache.commons.csv;