Specify release date

Remove low-value comment
Rename parameter to reduce confusion
2026-02-19 00:36:38 +00:00 · 2021-04-14 20:14:01 +02:00 · 2021-04-14 20:12:43 +02:00 · 2021-04-14 20:12:43 +02:00 · 2021-04-14 20:12:43 +02:00 · 2021-04-14 20:12:43 +02:00
25 changed files with 428 additions and 271 deletions
--- a/.gitattributes
+++ b/.gitattributes
@@ -0,0 +1,9 @@
+/.editorconfig export-ignore
+/.gitattributes export-ignore
+/.gitignore export-ignore
+/.travis.yml export-ignore
+/ChangeLog.txt export-ignore
+/examples export-ignore
+/Makefile export-ignore
+/ruleset.xml export-ignore
+/tests export-ignore
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,7 @@
 *.bak
 /.idea
+/composer.lock
+/coverage_clover.xml
 /phive.xml
 /tools
-composer.lock
-vendor/
+/vendor/
--- a/.travis.yml
+++ b/.travis.yml
@@ -7,9 +7,6 @@ php:
  - '7.3'
  - '7.2'
  - '7.1'
-  - '7.0'
-  - '5.6'
-  - '5.5'

 before_install:
  - composer update
--- a/ChangeLog.txt
+++ b/ChangeLog.txt
@@ -1,3 +1,57 @@
+ParseCSV 1.3.0
+-----------------------------------
+Date: 14-Apr-2021
+
+Breaking changes:
+- Passing file paths to parse() or new Csv() is now deprecated
+  and will be removed in v2.0.0. Use ->parseFile() instead.
+
+  WARNING: It will call trigger_error() for now.
+  This may still break your application, depending on your
+  php.ini config. You can add E_USER_DEPRECATED to the
+  error_reporting mask to avoid breaking your application:
+
+  Example:
+
+  error_reporting = E_ALL & ~E_DEPRECATED & ~E_STRICT & ~E_USER_DEPRECATED
+
+  This change is to avoid security issues: see issue #198.
+
+Non-breaking deprecations:
+- The function load_data() is deprecated.
+  Call loadFile() or loadDataString() instead.
+- Supplying CSV data (file content) to auto() is deprecated.
+  Please use autoDetectionForDataString().
+
+  The motivation is to make subtle gotchas less likely: when the
+  file cannot be found or read by PHP (permissions), its file path
+  would be treated like CSV data.
+- Currently, there is code to parse .php: <?...?> tags are removed
+  before the remaining file content is treated like a .csv file.
+  This rarely-used functionality will be removed in v2.0.0.
+  You are only affected if you use ParseCsv to parse .php files.
+
+New features: none
+Bug fixes: none
+-----------------------------------
+
+
+ParseCSV 1.2.1
+-----------------------------------
+Date: 25-Apr-2020
+
+Breaking changes: none
+New features: none
+Bug fixes: none
+
+Code quality:
+- Switched from PHPUnit 4 to 6 to get rid of
+  wrappers. This will reduce friction for PhpStorm users,
+  because it gets rid of the "Multiple definitions" error
+  See issue #188. Thanks to @SharkMachine for the hint.
+-----------------------------------
+
+
 ParseCSV 1.2.0
 -----------------------------------
 Date: 07-Jan-2020
--- a/README.md
+++ b/README.md
@@ -1,12 +1,12 @@
 # ParseCsv
-[![Financial Contributors on Open Collective](https://opencollective.com/parsecsv/all/badge.svg?label=financial+contributors)](https://opencollective.com/parsecsv) 
+[![Financial Contributors on Open Collective](https://opencollective.com/parsecsv/all/badge.svg?label=financial+contributors)](https://opencollective.com/parsecsv)

 ParseCsv is an easy-to-use PHP class that reads and writes CSV data properly. It
 fully conforms to the specifications outlined on the on the
 [Wikipedia article][CSV] (and thus RFC 4180). It has many advanced features which help make your
 life easier when dealing with CSV data.

-You may not need a library at all: before using ParseCsv, please make sure if PHP's own `str_getcsv()`, ``fgetcvs()`` or `fputcsv()` meets your needs.
+You may not need a library at all: before using ParseCsv, please make sure if PHP's own `str_getcsv()`, ``fgetcsv()`` or `fputcsv()` meets your needs.

 This library was originally created in early 2007 by [jimeh](https://github.com/jimeh) due to the lack of built-in
 and third-party support for handling CSV data in PHP.
@@ -53,27 +53,27 @@ To use ParseCSV, you then have to add a `require 'parsecsv.lib.php';` line.

 ## Example Usage

-**General**
+**General parsing**

 ```php
-$csv = new ParseCsv\Csv('data.csv');
+$csv = new \ParseCsv\Csv('data.csv');
 print_r($csv->data);
 ```

 **Tab delimited, and encoding conversion**

 ```php
-$csv = new ParseCsv\Csv();
+$csv = new \ParseCsv\Csv();
 $csv->encoding('UTF-16', 'UTF-8');
 $csv->delimiter = "\t";
-$csv->parse('data.tsv');
+$csv->parseFile('data.tsv');
 print_r($csv->data);
 ```

 **Auto-detect delimiter character**

 ```php
-$csv = new ParseCsv\Csv();
+$csv = new \ParseCsv\Csv();
 $csv->auto('data.csv');
 print_r($csv->data);
 ```
@@ -81,34 +81,34 @@ print_r($csv->data);
 **Parse data with offset**
 * ignoring the first X (e.g. two) rows
 ```php
-$csv = new ParseCsv\Csv();
+$csv = new \ParseCsv\Csv();
 $csv->offset = 2;
-$csv->parse('data.csv');
+$csv->parseFile('data.csv');
 print_r($csv->data);
 ```

 **Limit the number of returned data rows**
 ```php
-$csv = new ParseCsv\Csv();
+$csv = new \ParseCsv\Csv();
 $csv->limit = 5;
-$csv->parse('data.csv');
+$csv->parseFile('data.csv');
 print_r($csv->data);
 ```

 **Get total number of data rows without parsing whole data**
 * Excluding heading line if present (see $csv->header property)
 ```php
-$csv = new ParseCsv\Csv();
-$csv->load_data('data.csv');
+$csv = new \ParseCsv\Csv();
+$csv->loadFile('data.csv');
 $count = $csv->getTotalDataRowCount();
 print_r($count);
 ```

-**Get most common data type for each column (Requires PHP >= 5.5)**
+**Get most common data type for each column**

 ```php
-$csv = new ParseCsv\Csv('data.csv');
-$csv->getDatatypes()
+$csv = new \ParseCsv\Csv('data.csv');
+$csv->getDatatypes();
 print_r($csv->data_types);
 ```

@@ -116,9 +116,9 @@ print_r($csv->data_types);

 Change data values:
 ```php
-$csv = new ParseCsv\Csv();
+$csv = new \ParseCsv\Csv();
 $csv->sort_by = 'id';
-$csv->parse('data.csv');
+$csv->parseFile('data.csv');
 # "4" is the value of the "id" column of the CSV row
 $csv->data[4] = array('firstname' => 'John', 'lastname' => 'Doe', 'email' => 'john@doe.com');
 $csv->save();
@@ -126,8 +126,8 @@ $csv->save();

 Enclose each data value by quotes:
 ```php
-$csv = new ParseCsv\Csv();
-$csv->parse('data.csv');
+$csv = new \ParseCsv\Csv();
+$csv->parseFile('data.csv');
 $csv->enclose_all = true;
 $csv->save();
 ```
@@ -135,9 +135,9 @@ $csv->save();
 **Replace field names or set ones if missing**

 ```php
-$csv = new ParseCsv\Csv();
-$csv->fields = ['id', 'name', 'category']
-$csv->parse('data.csv');
+$csv = new \ParseCsv\Csv();
+$csv->fields = ['id', 'name', 'category'];
+$csv->parseFile('data.csv');
 ```

 **Add row/entry to end of CSV file**
@@ -145,19 +145,33 @@ $csv->parse('data.csv');
 _Only recommended when you know the exact structure of the file._

 ```php
-$csv = new ParseCsv\Csv();
-$csv->save('data.csv', array(array('1986', 'Home', 'Nowhere', '')), true);
+$csv = new \ParseCsv\Csv();
+$csv->save('data.csv', array(array('1986', 'Home', 'Nowhere', '')), /* append */ true);
 ```

 **Convert 2D array to CSV data and send headers to browser to treat output as
 a file and download it**

 ```php
-$csv = new ParseCsv\Csv();
-$csv->output('movies.csv', $array, array('field 1', 'field 2'), ',');
+$csv = new \ParseCsv\Csv();
+$csv->linefeed = "\n";
+$header = array('field 1', 'field 2');
+$csv->output('movies.csv', $data_array, $header, ',');
 ```

-For more complex examples, see the ``tests`` and `examples` directories. 
+For more complex examples, see the ``tests`` and `examples` directories.
+
+## Test coverage
+
+All tests are located in the `tests` directory. To execute tests, run the following commands:
+
+````bash
+composer install
+composer run test
+````
+
+When pushing code to GitHub, tests will be executed using Travis CI. The relevant configuration is in the
+file `.travis.yml`.

 ## Credits

@@ -170,17 +184,13 @@ For more complex examples, see the ``tests`` and `examples` directories.

 ## Contributors

+### Code Contributors
+
+This project exists thanks to all the people who contribute.
+
 Please find a complete list on the project's [contributors][] page.

 [contributors]: https://github.com/parsecsv/parsecsv-for-php/graphs/contributors
-
-
-
-## Contributors
-
-### Code Contributors
-
-This project exists thanks to all the people who contribute. [[Contribute](CONTRIBUTING.md)].
 <a href="https://github.com/parsecsv/parsecsv-for-php/graphs/contributors"><img src="https://opencollective.com/parsecsv/contributors.svg?width=890&button=false" /></a>

 ### Financial Contributors
--- a/composer.json
+++ b/composer.json
@@ -34,7 +34,8 @@
        "php": ">=5.5"
    },
    "require-dev": {
-        "phpunit/phpunit": "4.1.*"
+        "phpunit/phpunit": "^6",
+        "squizlabs/php_codesniffer": "^3.5"
    },
    "suggest": {
        "illuminate/support": "Fluent array interface for map functions"
@@ -44,6 +45,11 @@
            "dev-master": "1.0.x-dev"
        }
    },
+    "scripts": {
+        "test": [
+            "vendor/bin/phpunit -c tests tests --disallow-test-output --coverage-clover coverage_clover.xml --whitelist src"
+        ]
+    },
    "support": {
        "issues": "https://github.com/parsecsv/parsecsv-for-php/issues",
        "source": "https://github.com/parsecsv/parsecsv-for-php"
--- a/examples/basic.php
+++ b/examples/basic.php
@@ -18,8 +18,8 @@ $csv->auto('_books.csv');
 # if its not the default comma...
 // $csv->delimiter = "\t";   # tab delimited

-# ...and then use the parse() function.
-// $csv->parse('_books.csv');
+# ...and then use the parseFile() function.
+// $csv->parseFile('_books.csv');


 # Output result.
--- a/ruleset.xml
+++ b/ruleset.xml
@@ -0,0 +1,3 @@
+<?xml version="1.0"?>
+<ruleset xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" name="ParseCSV" xsi:noNamespaceSchemaLocation="https://raw.githubusercontent.com/squizlabs/PHP_CodeSniffer/master/phpcs.xsd">
+</ruleset>
--- a/src/Csv.php
+++ b/src/Csv.php
@@ -311,33 +311,37 @@ class Csv {
     * Constructor
     * Class constructor
     *
-     * @param string|null  $input           The CSV string or a direct file path
-     * @param integer|null $offset          Number of rows to ignore from the
-     *                                      beginning of  the data
-     * @param integer|null $limit           Limits the number of returned rows
-     *                                      to specified amount
-     * @param string|null  $conditions      Basic SQL-like conditions for row
-     *                                      matching
-     * @param null|true    $keep_file_data  Keep raw file data in memory after
-     *                                      successful parsing
-     *                                      (useful for debugging)
+     * @param string|null $data            The CSV string or a direct file path.
+     *
+     *                                     WARNING: Supplying file paths here is
+     *                                     deprecated. Use parseFile() instead.
+     *
+     * @param int|null    $offset          Number of rows to ignore from the
+     *                                     beginning of  the data
+     * @param int|null    $limit           Limits the number of returned rows
+     *                                     to specified amount
+     * @param string|null $conditions      Basic SQL-like conditions for row
+     *                                     matching
+     * @param null|true   $keep_file_data  Keep raw file data in memory after
+     *                                     successful parsing
+     *                                     (useful for debugging)
     */
-    public function __construct($input = null, $offset = null, $limit = null, $conditions = null, $keep_file_data = null) {
+    public function __construct($data = null, $offset = null, $limit = null, $conditions = null, $keep_file_data = null) {
        $this->init($offset, $limit, $conditions, $keep_file_data);

-        if (!empty($input)) {
-            $this->parse($input);
+        if (!empty($data)) {
+            $this->parse($data);
        }
    }

    /**
-     * @param integer|null $offset          Number of rows to ignore from the
+     * @param int|null    $offset           Number of rows to ignore from the
     *                                      beginning of  the data
-     * @param integer|null $limit           Limits the number of returned rows
+     * @param int|null    $limit            Limits the number of returned rows
     *                                      to specified amount
-     * @param string|null  $conditions      Basic SQL-like conditions for row
+     * @param string|null $conditions       Basic SQL-like conditions for row
     *                                      matching
-     * @param null|true    $keep_file_data  Keep raw file data in memory after
+     * @param null|true   $keep_file_data   Keep raw file data in memory after
     *                                      successful parsing
     *                                      (useful for debugging)
     */
@@ -367,33 +371,43 @@ class Csv {
     * Parse
     * Parse a CSV file or string
     *
-     * @param string|null $input       The CSV string or a direct file path
-     * @param integer     $offset      Number of rows to ignore from the
+     * @param string|null $dataString  The CSV string or a direct file path
+     *                                 WARNING: Supplying file paths here is
+     *                                 deprecated and will trigger an
+     *                                 E_USER_DEPRECATED error.
+     * @param int|null    $offset      Number of rows to ignore from the
     *                                 beginning of  the data
-     * @param integer     $limit       Limits the number of returned rows to
+     * @param int|null    $limit       Limits the number of returned rows to
     *                                 specified amount
-     * @param string      $conditions  Basic SQL-like conditions for row
+     * @param string|null $conditions  Basic SQL-like conditions for row
     *                                 matching
     *
     * @return bool True on success
     */
-    public function parse($input = null, $offset = null, $limit = null, $conditions = null) {
-        if (is_null($input)) {
-            $input = $this->file;
+    public function parse($dataString = null, $offset = null, $limit = null, $conditions = null) {
+        if (is_null($dataString)) {
+            $this->data = $this->parseFile();
+            return $this->data !== false;
        }

-        if (empty($input)) {
+        if (empty($dataString)) {
            return false;
        }

        $this->init($offset, $limit, $conditions);

-        if (strlen($input) <= PHP_MAXPATHLEN && is_readable($input)) {
-            $this->file = $input;
-            $this->data = $this->_parse_file();
+        if (strlen($dataString) <= PHP_MAXPATHLEN && is_readable($dataString)) {
+            $this->file = $dataString;
+            $this->data = $this->parseFile();
+            trigger_error(
+                'Supplying file paths to parse() will no longer ' .
+                'be supported in a future version of ParseCsv. ' .
+                'Use ->parseFile() instead.',
+                E_USER_DEPRECATED
+            );
        } else {
            $this->file = null;
-            $this->file_data = &$input;
+            $this->file_data = &$dataString;
            $this->data = $this->_parse_string();
        }

@@ -474,8 +488,10 @@ class Csv {
     * Encoding
     * Convert character encoding
     *
-     * @param string $input  Input character encoding, uses default if left blank
-     * @param string $output Output character encoding, uses default if left blank
+     * @param string|null $input  Input character encoding, uses default if left blank
+     * @param string|null $output Output character encoding, uses default if left blank
+     *
+     * @return void
     */
    public function encoding($input = null, $output = null) {
        $this->convert_encoding = true;
@@ -493,13 +509,16 @@ class Csv {
     * Auto-Detect Delimiter: Find delimiter by analyzing a specific number of
     * rows to determine most probable delimiter character
     *
-     * @param string|null $file         Local CSV file
-     * @param bool        $parse        True/false parse file directly
-     * @param int         $search_depth Number of rows to analyze
-     * @param string      $preferred    Preferred delimiter characters
-     * @param string|null $enclosure    Enclosure character, default is double quote (").
+     * @param string|null $file          Local CSV file
+     *                                   Supplying CSV data (file content) here is deprecated.
+     *                                   For CSV data, please use autoDetectionForDataString().
+     *                                   Support for CSV data will be removed in v2.0.0.
+     * @param bool        $parse         True/false parse file directly
+     * @param int|null    $search_depth  Number of rows to analyze
+     * @param string|null $preferred     Preferred delimiter characters
+     * @param string|null $enclosure     Enclosure character, default is double quote (").
     *
-     * @return string The detected field delimiter
+     * @return string|false The detected field delimiter
     */
    public function auto($file = null, $parse = true, $search_depth = null, $preferred = null, $enclosure = null) {
        if (is_null($file)) {
@@ -530,6 +549,13 @@ class Csv {
            $data = &$this->file_data;
        }

+        $this->autoDetectionForDataString($data, $parse, $search_depth, $preferred, $enclosure);
+
+        return $this->delimiter;
+    }
+
+    public function autoDetectionForDataString($data, $parse = true, $search_depth = null, $preferred = null, $enclosure = null) {
+        $this->file_data = &$data;
        if (!$this->_detect_and_remove_sep_row_from_data($data)) {
            $this->_guess_delimiter($search_depth, $preferred, $enclosure, $data);
        }
@@ -572,12 +598,10 @@ class Csv {

        $headingRow = $this->heading ? 1 : 0;

-        $count = substr_count($data, "\r")
+        return substr_count($data, "\r")
            + substr_count($data, "\n")
            - substr_count($data, "\r\n")
            - $headingRow;
-
-        return $count;
    }

    // ==============================================
@@ -588,16 +612,24 @@ class Csv {
     * Parse File
     * Read file to string and call _parse_string()
     *
-     * @param string|null $file Local CSV file
+     * @param string|null $file  Path to a CSV file.
+     *                           If configured in files such as php.ini,
+     *                           the path may also contain a protocol:
+     *                           https://example.org/some/file.csv
     *
     * @return array|bool
     */
-    protected function _parse_file($file = null) {
+    public function parseFile($file = null) {
        if (is_null($file)) {
            $file = $this->file;
        }

        if (empty($this->file_data)) {
+            /**
+             * @see self::keep_file_data
+             * Usually, _parse_string will clean this
+             * Instead of leaving stale data for the next parseFile call behind.
+             */
            $this->load_data($file);
        }

@@ -613,7 +645,7 @@ class Csv {
     *
     * To detect field separators, please use auto() instead.
     *
-     * @param string $data CSV data
+     * @param string|null $data CSV data
     *
     * @return array|false - 2D array with CSV data, or false on failure
     */
@@ -712,9 +744,8 @@ class Csv {
                } else {
                    $enclosed = false;
                }
-
                // end of field/row/csv
-            } elseif (($ch === $this->delimiter || $ch == "\n" || $ch == "\r" || $ch === false) && !$enclosed) {
+            } elseif ((in_array($ch, [$this->delimiter, "\n", "\r", false], true)) && !$enclosed) {
                $key = !empty($head[$col]) ? $head[$col] : $col;
                $row[$key] = $was_enclosed ? $current : trim($current);
                $current = '';
@@ -861,7 +892,12 @@ class Csv {
        return $string;
    }

-    private function _validate_fields_for_unparse($fields) {
+    /**
+     * @param array $fields
+     *
+     * @return array|false
+     */
+    private function _validate_fields_for_unparse(array $fields) {
        if (empty($fields)) {
            $fields = $this->titles;
        }
@@ -909,32 +945,71 @@ class Csv {
     * This function load_data() is able to handle BOMs and encodings. The data
     * is stored within the $this->file_data class field.
     *
-     * @param string|null $input local CSV file or CSV data as a string
+     * @param string|null $input  CSV file path or CSV data as a string
+     *
+     *                            Supplying CSV data (file content) here is deprecated.
+     *                            For CSV data, please use loadDataString().
+     *                            Support for CSV data will be removed in v2.0.0.
+     *
+     * @return bool  True on success
+     * @deprecated Use loadDataString() or loadFile() instead.
+     */
+    public function load_data($input = null) {
+        return $this->loadFile($input);
+    }
+
+    /**
+     * Load a file, but don't parse it.
+     *
+     * Only use this function if auto() and parseFile() don't handle your data well.
+     *
+     * This function is able to handle BOMs and encodings. The data
+     * is stored within the $this->file_data class field.
+     *
+     * @param string|null $file  CSV file path
     *
     * @return bool  True on success
     */
-    public function load_data($input = null) {
+    public function loadFile($file = null) {
        $data = null;
-        $file = null;

-        if (is_null($input)) {
-            $file = $this->file;
-        } elseif (\strlen($input) <= PHP_MAXPATHLEN && file_exists($input)) {
-            $file = $input;
-        } else {
-            // It is CSV data as a string.
-            $data = $input;
-        }
-
-        if (!empty($data) || $data = $this->_rfile($file)) {
+        if (is_null($file)) {
+            $data = $this->_rfile($this->file);
+        } elseif (\strlen($file) <= PHP_MAXPATHLEN && file_exists($file)) {
+            $data = $this->_rfile($file);
            if ($this->file != $file) {
                $this->file = $file;
            }
+        } else {
+            // It is CSV data as a string.

-            if (preg_match('/\.php$/i', $file) && preg_match('/<\?.*?\?>(.*)/ms', $data, $strip)) {
-                $data = ltrim($strip[1]);
-            }
+            // WARNING:
+            // Supplying CSV data to load_data() will no longer
+            // be supported in a future version of ParseCsv.
+            // This function will return false for invalid paths from v2.0.0 onwards.

+            // Use ->loadDataString() instead.
+
+            $data = $file;
+        }
+
+        return $this->loadDataString($data);
+    }
+
+    /**
+     * Load a data string, but don't parse it.
+     *
+     * Only use this function if autoDetectionForDataString() and parse() don't handle your data well.
+     *
+     * This function is able to handle BOMs and encodings. The data
+     * is stored within the $this->file_data class field.
+     *
+     * @param string|null $file_path  CSV file path
+     *
+     * @return bool  True on success
+     */
+    public function loadDataString($data) {
+        if (!empty($data)) {
            if (strpos($data, "\xef\xbb\xbf") === 0) {
                // strip off BOM (UTF-8)
                $data = substr($data, 3);
@@ -984,7 +1059,7 @@ class Csv {
     * @param array       $row        array with values from a row
     * @param string|null $conditions specified conditions that the row must match
     *
-     * @return  true of false
+     * @return bool
     */
    protected function _validate_row_conditions($row = array(), $conditions = null) {
        if (!empty($row)) {
@@ -1111,7 +1186,7 @@ class Csv {
     *
     * @param int $current_row the current row number being processed
     *
-     * @return  true of false
+     * @return bool
     */
    protected function _validate_offset($current_row) {
        return
@@ -1210,16 +1285,23 @@ class Csv {
    /**
     * Read local file.
     *
-     * @param string $file local filename
+     * @param string $filePath  local filename
     *
     * @return string|false Data from file, or false on failure
     */
-    protected function _rfile($file) {
-        if (is_readable($file)) {
-            $data = file_get_contents($file);
+    protected function _rfile($filePath) {
+        if (is_readable($filePath)) {
+            $data = file_get_contents($filePath);
            if ($data === false) {
                return false;
            }
+
+            if (preg_match('/\.php$/i', $filePath) && preg_match('/<\?.*?\?>(.*)/ms', $data, $strip)) {
+                // Return section behind closing tags.
+                // This parsing is deprecated and will be removed in v2.0.0.
+                $data = ltrim($strip[1]);
+            }
+
            return rtrim($data, "\r\n");
        }

@@ -1298,7 +1380,6 @@ class Csv {
        }

        // remove delimiter and its line-end (the data param is by-ref!)
-        /** @noinspection CallableParameterUseCaseInTypeContextInspection */
        $data_string = substr($data_string, $pos);
        return true;
    }
@@ -1309,7 +1390,7 @@ class Csv {
     * @param string $enclosure    Enclosure character, default is double quote
     * @param string $data         The file content
     */
-    protected function _guess_delimiter($search_depth, $preferred, $enclosure, &$data) {
+    protected function _guess_delimiter($search_depth, $preferred, $enclosure, $data) {
        $chars = [];
        $strlen = strlen($data);
        $enclosed = false;
--- a/src/enums/SortEnum.php
+++ b/src/enums/SortEnum.php
@@ -26,5 +26,4 @@ class SortEnum extends AbstractEnum {

        return self::$sorting[self::__DEFAULT];
    }
-
 }
--- a/src/extensions/DatatypeTrait.php
+++ b/src/extensions/DatatypeTrait.php
@@ -19,7 +19,7 @@ trait DatatypeTrait {
     * Check data type for one column.
     * Check for most commonly data type for one column.
     *
-     * @param  array $datatypes
+     * @param array $datatypes
     *
     * @return string|false
     */
@@ -36,7 +36,6 @@ trait DatatypeTrait {
        reset($typesFreq);

        return key($typesFreq);
-
    }

    /**
--- a/tests/Bootstrap.php
+++ b/tests/Bootstrap.php
@@ -1,13 +1,8 @@
 <?php
+
 chdir(__DIR__ . '/..');
 if (!file_exists('vendor/autoload.php')) {
    `composer dump-autoload`;
 }

 require __DIR__ . '/../vendor/autoload.php';
-
-if (!class_exists('PHPUnit\Framework\TestCase') && class_exists('PHPUnit_Framework_TestCase')) {
-    // we run on an older PHPUnit version without namespaces.
-    require_once __DIR__ . '/PHPUnit_Framework_TestCase.inc.php';
-}
-
--- a/tests/PHPUnit_Framework_TestCase.inc.php
+++ b/tests/PHPUnit_Framework_TestCase.inc.php
@@ -1,11 +0,0 @@
-<?php
-
-namespace PHPUnit\Framework;
-
-// Only needed to keep unit test code compatible with older PHPUnit versions
-
-/** @noinspection PhpUndefinedClassInspection */
-/** @noinspection AutoloadingIssuesInspection */
-class TestCase extends \PHPUnit_Framework_TestCase {
-
-}
--- a/tests/methods/DataRowCountTest.php
+++ b/tests/methods/DataRowCountTest.php
@@ -17,13 +17,7 @@ class DataRowCountTest extends TestCase {
     */
    protected $csv;

-    /**
-     * Setup
-     * Setup our test environment objects
-     *
-     * @access public
-     */
-    public function setUp() {
+    protected function setUp(): void {
        $this->csv = new Csv();
    }

@@ -53,22 +47,22 @@ class DataRowCountTest extends TestCase {
    public function testGetTotalRowCountFromFile($file, $expectedRows) {
        $this->csv->heading = true;
        $this->csv->load_data(__DIR__ . '/fixtures/' . $file);
-        $this->assertEquals($expectedRows, $this->csv->getTotalDataRowCount());
+        self::assertEquals($expectedRows, $this->csv->getTotalDataRowCount());
    }

    public function testGetTotalRowCountMissingEndingLineBreak() {
        $this->csv->heading = false;
        $this->csv->enclosure = '"';
        $sInput = "86545235689,a\r\n34365587654,b\r\n13469874576,\"c\r\nd\"";
-        $this->csv->load_data($sInput);
-        $this->assertEquals(3, $this->csv->getTotalDataRowCount());
+        $this->csv->loadDataString($sInput);
+        self::assertEquals(3, $this->csv->getTotalDataRowCount());
    }

    public function testGetTotalRowCountSingleEnclosure() {
        $this->csv->heading = false;
        $this->csv->enclosure = "'";
        $sInput = "86545235689,a\r\n34365587654,b\r\n13469874576,\'c\r\nd\'";
-        $this->csv->load_data($sInput);
+        $this->csv->loadDataString($sInput);
        $this->assertEquals(3, $this->csv->getTotalDataRowCount());
    }

@@ -76,7 +70,11 @@ class DataRowCountTest extends TestCase {
        $this->csv->heading = false;
        $this->csv->enclosure = "'";
        $sInput = "86545235689";
-        $this->csv->load_data($sInput);
+        $this->csv->loadDataString($sInput);
        $this->assertEquals(1, $this->csv->getTotalDataRowCount());
    }
+
+    public function testGetTotalRowCountNoData() {
+        self::assertFalse($this->csv->getTotalDataRowCount());
+    }
 }
--- a/tests/methods/ExampleStream.php
+++ b/tests/methods/ExampleStream.php
@@ -98,4 +98,3 @@ class ExampleStream {
        return false;
    }
 }
-
--- a/tests/methods/OldRequireTest.php
+++ b/tests/methods/OldRequireTest.php
@@ -11,11 +11,11 @@ use PHPUnit\Framework\TestCase;
 */
 class OldRequireTest extends TestCase {

-    protected function setUp() {
+    protected function setUp(): void {
        rename('vendor/autoload.php', '__autoload');
    }

-    protected function tearDown() {
+    protected function tearDown(): void {
        rename('__autoload', 'vendor/autoload.php');
    }

@@ -23,7 +23,6 @@ class OldRequireTest extends TestCase {
     * @runInSeparateProcess so that disabled autoloading has an effect
     */
    public function testOldLibWithoutComposer() {
-
        file_put_contents('__eval.php', '<?php require "parsecsv.lib.php"; new \ParseCsv\Csv;');
        exec("php __eval.php", $output, $return_var);
        unlink('__eval.php');
@@ -35,7 +34,6 @@ class OldRequireTest extends TestCase {
     * @runInSeparateProcess so that disabled autoloading has an effect
     */
    public function testOldLibWithOldClassName() {
-
        file_put_contents('__eval.php', '<?php require "parsecsv.lib.php"; new parseCSV;');
        exec("php __eval.php", $output, $return_var);
        unlink('__eval.php');
--- a/tests/methods/OutputTest.php
+++ b/tests/methods/OutputTest.php
@@ -14,8 +14,10 @@ class OutputTest extends TestCase {
        $csv = new Csv();
        $data = [0 => ['a', 'b', 'c'], 1 => ['d', 'e', 'f']];
        $fields = ['col1', 'col2', 'col3'];
+        ob_start();
        $output = $csv->output('test.csv', $data, $fields, ',');
        $expected = "col1,col2,col3\ra,b,c\rd,e,f\r";
+        self::assertEquals($expected, ob_get_clean());
        self::assertEquals($expected, $output);
    }
 }
--- a/tests/methods/ParseTest.php
+++ b/tests/methods/ParseTest.php
@@ -4,6 +4,7 @@ namespace ParseCsv\tests\methods;

 use ParseCsv\Csv;
 use PHPUnit\Framework\TestCase;
+use ReflectionClass;

 class ParseTest extends TestCase {

@@ -18,7 +19,7 @@ class ParseTest extends TestCase {
     *
     * @access public
     */
-    public function setUp() {
+    protected function setUp(): void {
        $this->csv = new Csv();
    }

@@ -28,16 +29,19 @@ class ParseTest extends TestCase {
        $this->parseRepetitiveString('http://looks/like/an/url');
    }

+    /**
+     * @param string $content
+     */
    private function parseRepetitiveString($content) {
        $this->csv->delimiter = ';';
        $this->csv->heading = false;
        $success = $this->csv->parse(str_repeat($content . ';', 500));
-        $this->assertEquals(true, $success);
+        self::assertEquals(true, $success);

        $row = array_pop($this->csv->data);
        $expected_data = array_fill(0, 500, $content);
-        $expected_data [] = '';
-        $this->assertEquals($expected_data, $row);
+        $expected_data[] = '';
+        self::assertEquals($expected_data, $row);
    }

    /**
@@ -53,9 +57,12 @@ class ParseTest extends TestCase {
        $this->csv->output_encoding = 'UTF-8';

        $this->csv->auto($file);
-        $this->assertEquals($this->_get_magazines_data(), $this->csv->data);
+        self::assertEquals($this->_get_magazines_data(), $this->csv->data);
    }

+    /**
+     * @return array
+     */
    public function autoDetectionProvider() {
        return [
            'UTF8_no_BOM' => [__DIR__ . '/../example_files/UTF-8_sep_row_but_no_BOM.csv'],
@@ -66,20 +73,22 @@ class ParseTest extends TestCase {

    public function testSingleColumnWithZeros() {
        $this->csv->delimiter = null;
-        $this->csv->parse("URL\nhttp://www.amazon.com/ROX-Ice-Ball-Maker-Original/dp/B00MX59NMQ/ref=sr_1_1?ie=UTF8&qid=1435604374&sr=8-1&keywords=rox,+ice+molds");
+        $this->csv->parse(
+            "URL\nhttp://www.amazon.com/ROX-Ice-Ball-Maker-Original/dp/B00MX59NMQ/ref=sr_1_1?ie=UTF8&qid=1435604374&sr=8-1&keywords=rox,+ice+molds"
+        );
        $row = array_pop($this->csv->data);
        $expected_data = ['URL' => 'http://www.amazon.com/ROX-Ice-Ball-Maker-Original/dp/B00MX59NMQ/ref=sr_1_1?ie=UTF8&qid=1435604374&sr=8-1&keywords=rox,+ice+molds'];
-        $this->assertEquals($expected_data, $row);
+        self::assertEquals($expected_data, $row);
    }

    public function testAllNumericalCsv() {
        $this->csv->heading = false;
        $sInput = "86545235689\r\n34365587654\r\n13469874576";
-        $this->assertEquals(false, $this->csv->auto($sInput));
-        $this->assertEquals(null, $this->csv->delimiter);
+        self::assertEquals(false, $this->csv->autoDetectionForDataString($sInput));
+        self::assertEquals(null, $this->csv->delimiter);
        $expected_data = explode("\r\n", $sInput);
        $actual_data = array_map('reset', $this->csv->data);
-        $this->assertEquals($expected_data, $actual_data);
+        self::assertEquals($expected_data, $actual_data);
    }

    public function testMissingEndingLineBreak() {
@@ -88,14 +97,17 @@ class ParseTest extends TestCase {
        $sInput = "86545235689,a\r\n34365587654,b\r\n13469874576,\"c\r\nd\"";
        $expected_data = [86545235689, 34365587654, 13469874576];

-        $actual_data = $this->invokeMethod($this->csv, '_parse_string', array($sInput));
+        $actual_data = $this->invokeMethod($this->csv, '_parse_string', [$sInput]);
        $actual_column = array_map('reset', $actual_data);
-        $this->assertEquals($expected_data, $actual_column);
-        $this->assertEquals([
-            'a',
-            'b',
-            "c\r\nd",
-        ], array_map('next', $actual_data));
+        self::assertEquals($expected_data, $actual_column);
+        self::assertEquals(
+            [
+                'a',
+                'b',
+                "c\r\nd",
+            ],
+            array_map('next', $actual_data)
+        );
    }

    public function testSingleColumn() {
@@ -106,7 +118,7 @@ class ParseTest extends TestCase {
            ['SMS' => '6606'],
            ['SMS' => '7777'],
        ];
-        $this->assertEquals($expected, $this->csv->data);
+        self::assertEquals($expected, $this->csv->data);
    }

    public function testMatomoData() {
@@ -115,18 +127,24 @@ class ParseTest extends TestCase {
        $this->csv->output_encoding = 'UTF-8';
        $this->csv->auto(__DIR__ . '/../example_files/Piwik_API_download.csv');
        $aAction27 = array_column($this->csv->data, 'url (actionDetails 27)');
-        $this->assertEquals([
-            'http://application/_Main/_GraphicMeanSTD_MDI/btnConfBandOptions',
-            '',
-            '',
-        ], $aAction27);
+        self::assertEquals(
+            [
+                'http://application/_Main/_GraphicMeanSTD_MDI/btnConfBandOptions',
+                '',
+                '',
+            ],
+            $aAction27
+        );

        $aCity = array_column($this->csv->data, 'city');
-        $this->assertEquals([
-            'São Paulo',
-            'Johannesburg',
-            '',
-        ], $aCity);
+        self::assertEquals(
+            [
+                'São Paulo',
+                'Johannesburg',
+                '',
+            ],
+            $aCity
+        );
    }

    /**
@@ -135,14 +153,15 @@ class ParseTest extends TestCase {
    public function testStringWithLeadingBOM() {
        $string_with_bom = strtr(
            file_get_contents(__DIR__ . '/../example_files/UTF-8_with_BOM_and_sep_row.csv'),
-            ["sep=;\n" => '']);
+            ["sep=;\n" => '']
+        );

        // Is the BOM still there?
        self::assertSame(0xEF, ord($string_with_bom));

        $this->csv->output_encoding = 'UTF-8';
        $this->csv->delimiter = ';';
-        self::assertTrue($this->csv->load_data($string_with_bom));
+        self::assertTrue($this->csv->loadDataString($string_with_bom));
        self::assertTrue($this->csv->parse($this->csv->file_data));

        // This also tests if ::load_data removed the BOM from the data;
@@ -195,7 +214,7 @@ class ParseTest extends TestCase {
            'price' => 'float',
        ];

-        $this->assertEquals($expected, $this->csv->data_types);
+        self::assertEquals($expected, $this->csv->data_types);
    }

    /**
@@ -203,28 +222,34 @@ class ParseTest extends TestCase {
     */
    public function testAutoDetectFileHasHeading() {
        $this->csv->auto(__DIR__ . '/fixtures/datatype.csv');
-        $this->assertTrue($this->csv->autoDetectFileHasHeading());
+        self::assertTrue($this->csv->autoDetectFileHasHeading());

        $this->csv->heading = false;
        $this->csv->auto(__DIR__ . '/fixtures/datatype.csv');
-        $this->assertTrue($this->csv->autoDetectFileHasHeading());
+        self::assertTrue($this->csv->autoDetectFileHasHeading());

        $this->csv->heading = false;
        $sInput = "86545235689\r\n34365587654\r\n13469874576";
-        $this->csv->auto($sInput);
-        $this->assertFalse($this->csv->autoDetectFileHasHeading());
+        $this->csv->autoDetectionForDataString($sInput);
+        self::assertFalse($this->csv->autoDetectFileHasHeading());

        $this->csv->heading = true;
        $sInput = "86545235689\r\n34365587654\r\n13469874576";
-        $this->csv->auto($sInput);
-        $this->assertFalse($this->csv->autoDetectFileHasHeading());
+        $this->csv->autoDetectionForDataString($sInput);
+        self::assertFalse($this->csv->autoDetectFileHasHeading());
    }

+    /**
+     * @doesNotPerformAssertions
+     */
    public function testVeryLongNonExistingFile() {
        $this->csv->parse(str_repeat('long_string', PHP_MAXPATHLEN));
        $this->csv->auto(str_repeat('long_string', PHP_MAXPATHLEN));
    }

+    /**
+     * @return array
+     */
    protected function _get_magazines_data() {
        return [
            [
@@ -245,7 +270,10 @@ class ParseTest extends TestCase {
        ];
    }

-    public function autoQuotesDataProvider() {
+    /**
+     * @return array
+     */
+    public function autoQuotesDataProvider(): array {
        return array(
            array('auto-double-enclosure.csv', '"'),
            array('auto-single-enclosure.csv', "'"),
@@ -263,21 +291,21 @@ class ParseTest extends TestCase {
    public function testAutoQuotes($file, $enclosure) {
        $csv = new Csv();
        $csv->auto(__DIR__ . '/fixtures/' . $file, true, null, null, $enclosure);
-        $this->assertArrayHasKey('column1', $csv->data[0], 'Data parsed incorrectly with enclosure ' . $enclosure);
-        $this->assertEquals('value1', $csv->data[0]['column1'], 'Data parsed incorrectly with enclosure ' . $enclosure);
+        self::assertArrayHasKey('column1', $csv->data[0], 'Data parsed incorrectly with enclosure ' . $enclosure);
+        self::assertEquals('value1', $csv->data[0]['column1'], 'Data parsed incorrectly with enclosure ' . $enclosure);
    }

    /**
     * Call protected/private method of a class.
     *
-     * @param object &$object     Instantiated object that we will run method on.
-     * @param string  $methodName Method name to call
-     * @param array   $parameters Array of parameters to pass into method.
+     * @param object $object     Instantiated object that we will run method on.
+     * @param string $methodName Method name to call
+     * @param array  $parameters Array of parameters to pass into method.
     *
     * @return mixed Method return.
     */
-    private function invokeMethod(&$object, $methodName, array $parameters = array()) {
-        $reflection = new \ReflectionClass(get_class($object));
+    private function invokeMethod($object, $methodName, $parameters = []) {
+        $reflection = new ReflectionClass(get_class($object));
        $method = $reflection->getMethod($methodName);
        $method->setAccessible(true);

@@ -285,7 +313,7 @@ class ParseTest extends TestCase {
    }

    public function testWaiverFieldSeparator() {
-        $this->assertSame(false, $this->csv->auto(__DIR__ . '/../example_files/waiver_field_separator.csv'));
+        self::assertFalse($this->csv->auto(__DIR__ . '/../example_files/waiver_field_separator.csv'));
        $expected = [
            'liability waiver',
            'release of liability form',
@@ -294,6 +322,13 @@ class ParseTest extends TestCase {
            'sample waiver form',
        ];
        $actual = array_column($this->csv->data, 'keyword');
-        $this->assertSame($expected, $actual);
+        self::assertSame($expected, $actual);
+    }
+
+    public function testEmptyInput() {
+        self::assertFalse($this->csv->parse(''));
+        self::assertFalse($this->csv->parse(null));
+        self::assertFalse($this->csv->parseFile(''));
+        self::assertFalse($this->csv->parseFile(null));
    }
 }
--- a/tests/methods/SaveTest.php
+++ b/tests/methods/SaveTest.php
@@ -15,7 +15,7 @@ class SaveTest extends TestCase {
    /**
     * Setup our test environment objects; will be called before each test.
     */
-    public function setUp() {
+    protected function setUp(): void {
        $this->csv = new Csv();
        $this->csv->auto(__DIR__ . '/../example_files/single_column.csv');

--- a/tests/methods/StreamTest.php
+++ b/tests/methods/StreamTest.php
@@ -11,7 +11,7 @@ use PHPUnit\Framework\TestCase;
 */
 class StreamTest extends TestCase {

-    public function setUp() {
+    protected function setUp(): void {
        static $done;
        if ($done) {
            // Make sure we register the stream just once - or PHP will scream.
--- a/tests/methods/UnparseTest.php
+++ b/tests/methods/UnparseTest.php
@@ -14,7 +14,7 @@ class UnparseTest extends Testcase {
    /**
     * Setup our test environment objects; will be called before each test.
     */
-    public function setUp() {
+    protected function setUp(): void {
        $this->csv = new Csv();
        $this->csv->auto(__DIR__ . '/fixtures/auto-double-enclosure.csv');
    }
@@ -48,7 +48,6 @@ class UnparseTest extends Testcase {
        $this->csv->auto(__DIR__ . '/fixtures/auto-double-enclosure.csv');
        $expected = "column1,column2\rvalue1,value2\rvalue3,value4\r";
        $this->unparseAndCompare($expected);
-
    }

    public function testUnparseRenameFields() {
--- a/tests/properties/BaseClass.php
+++ b/tests/properties/BaseClass.php
@@ -19,7 +19,7 @@ class BaseClass extends TestCase {
     * Setup
     * Setup our test environment objects
     */
-    protected function setUp() {
+    protected function setUp(): void {
        $this->csv = new Csv();
    }

--- a/tests/properties/DefaultValuesPropertiesTest.php
+++ b/tests/properties/DefaultValuesPropertiesTest.php
@@ -16,152 +16,135 @@ class DefaultValuesPropertiesTest extends TestCase {
     */
    protected $csv = null;

-    /**
-     * Setup
-     * Setup our test environment objects
-     *
-     * @access public
-     */
-    public function setUp() {
-        //setup parse CSV
+    protected function setUp(): void {
        $this->csv = new Csv();
    }

-    /**
-     * Tear down
-     * Tear down our test environment objects
-     *
-     * @access public
-     */
-    public function tearDown() {
-        $this->csv = null;
-    }
-
    public function test_heading_default() {
-        $this->assertTrue(is_bool($this->csv->heading));
-        $this->assertTrue($this->csv->heading);
+        self::assertTrue(is_bool($this->csv->heading));
+        self::assertTrue($this->csv->heading);
    }

    public function test_fields_default() {
-        $this->assertTrue(is_array($this->csv->fields));
-        $this->assertCount(0, $this->csv->fields);
+        self::assertTrue(is_array($this->csv->fields));
+        self::assertCount(0, $this->csv->fields);
    }

    public function test_sort_by_default() {
-        $this->assertNull($this->csv->sort_by);
+        self::assertNull($this->csv->sort_by);
    }

    public function test_sort_reverse_default() {
-        $this->assertTrue(is_bool($this->csv->sort_reverse));
-        $this->assertFalse($this->csv->sort_reverse);
+        self::assertTrue(is_bool($this->csv->sort_reverse));
+        self::assertFalse($this->csv->sort_reverse);
    }

    public function test_sort_type_default() {
-        $this->assertEquals('regular', $this->csv->sort_type);
+        self::assertEquals('regular', $this->csv->sort_type);
    }

    public function test_delimiter_default() {
-        $this->assertTrue(is_string($this->csv->delimiter));
-        $this->assertEquals(',', $this->csv->delimiter);
+        self::assertTrue(is_string($this->csv->delimiter));
+        self::assertEquals(',', $this->csv->delimiter);
    }

    public function test_enclosure_default() {
-        $this->assertTrue(is_string($this->csv->enclosure));
-        $this->assertEquals('"', $this->csv->enclosure);
+        self::assertTrue(is_string($this->csv->enclosure));
+        self::assertEquals('"', $this->csv->enclosure);
    }

    public function test_enclose_all_default() {
-        $this->assertTrue(is_bool($this->csv->enclose_all));
-        $this->assertFalse($this->csv->enclose_all);
+        self::assertTrue(is_bool($this->csv->enclose_all));
+        self::assertFalse($this->csv->enclose_all);
    }

    public function test_conditions_default() {
-        $this->assertNull($this->csv->conditions);
+        self::assertNull($this->csv->conditions);
    }

    public function test_offset_default() {
-        $this->assertNull($this->csv->offset);
+        self::assertNull($this->csv->offset);
    }

    public function test_limit_default() {
-        $this->assertNull($this->csv->limit);
+        self::assertNull($this->csv->limit);
    }

    public function test_auto_depth_default() {
-        $this->assertTrue(is_numeric($this->csv->auto_depth));
-        $this->assertEquals(15, $this->csv->auto_depth);
+        self::assertTrue(is_numeric($this->csv->auto_depth));
+        self::assertEquals(15, $this->csv->auto_depth);
    }

    public function test_auto_non_chars_default() {
-        $this->assertTrue(is_string($this->csv->auto_non_chars));
-        $this->assertEquals("a-zA-Z0-9\n\r", $this->csv->auto_non_chars);
+        self::assertTrue(is_string($this->csv->auto_non_chars));
+        self::assertEquals("a-zA-Z0-9\n\r", $this->csv->auto_non_chars);
    }

    public function test_auto_preferred_default() {
-        $this->assertTrue(is_string($this->csv->auto_preferred));
-        $this->assertEquals(",;\t.:|", $this->csv->auto_preferred);
+        self::assertTrue(is_string($this->csv->auto_preferred));
+        self::assertEquals(",;\t.:|", $this->csv->auto_preferred);
    }

    public function test_convert_encoding_default() {
-        $this->assertTrue(is_bool($this->csv->convert_encoding));
-        $this->assertFalse($this->csv->convert_encoding);
+        self::assertTrue(is_bool($this->csv->convert_encoding));
+        self::assertFalse($this->csv->convert_encoding);
    }

    public function test_input_encoding_default() {
-        $this->assertTrue(is_string($this->csv->input_encoding));
-        $this->assertEquals('ISO-8859-1', $this->csv->input_encoding);
+        self::assertTrue(is_string($this->csv->input_encoding));
+        self::assertEquals('ISO-8859-1', $this->csv->input_encoding);
    }

    public function test_output_encoding_default() {
-        $this->assertTrue(is_string($this->csv->output_encoding));
-        $this->assertEquals('ISO-8859-1', $this->csv->output_encoding);
+        self::assertTrue(is_string($this->csv->output_encoding));
+        self::assertEquals('ISO-8859-1', $this->csv->output_encoding);
    }

    public function test_linefeed_default() {
-        $this->assertTrue(is_string($this->csv->linefeed));
-        $this->assertEquals("\r", $this->csv->linefeed);
+        self::assertTrue(is_string($this->csv->linefeed));
+        self::assertEquals("\r", $this->csv->linefeed);
    }

    public function test_output_delimiter_default() {
-        $this->assertTrue(is_string($this->csv->output_delimiter));
-        $this->assertEquals(',', $this->csv->output_delimiter);
+        self::assertTrue(is_string($this->csv->output_delimiter));
+        self::assertEquals(',', $this->csv->output_delimiter);
    }

    public function test_output_filename_default() {
-        $this->assertTrue(is_string($this->csv->output_filename));
-        $this->assertEquals('data.csv', $this->csv->output_filename);
+        self::assertTrue(is_string($this->csv->output_filename));
+        self::assertEquals('data.csv', $this->csv->output_filename);
    }

    public function test_keep_file_data_default() {
-        $this->assertTrue(is_bool($this->csv->keep_file_data));
-        $this->assertFalse($this->csv->keep_file_data);
+        self::assertTrue(is_bool($this->csv->keep_file_data));
+        self::assertFalse($this->csv->keep_file_data);
    }

    public function test_file_default() {
-        $this->assertNull($this->csv->file);
+        self::assertNull($this->csv->file);
    }

    public function test_file_data_default() {
-        $this->assertNull($this->csv->file_data);
+        self::assertNull($this->csv->file_data);
    }

    public function test_error_default() {
-        $this->assertTrue(is_numeric($this->csv->error));
-        $this->assertEquals(0, $this->csv->error);
+        self::assertTrue(is_numeric($this->csv->error));
+        self::assertEquals(0, $this->csv->error);
    }

    public function test_error_info_default() {
-        $this->assertTrue(is_array($this->csv->error_info));
-        $this->assertCount(0, $this->csv->error_info);
+        self::assertTrue(is_array($this->csv->error_info));
+        self::assertCount(0, $this->csv->error_info);
    }

    public function test_titles_default() {
-        $this->assertTrue(is_array($this->csv->titles));
-        $this->assertCount(0, $this->csv->titles);
+        self::assertTrue(is_array($this->csv->titles));
+        self::assertCount(0, $this->csv->titles);
    }

    public function test_data_default() {
-        $this->assertTrue(is_array($this->csv->data));
-        $this->assertCount(0, $this->csv->data);
+        self::assertTrue(is_array($this->csv->data));
+        self::assertCount(0, $this->csv->data);
    }
 }
--- a/tests/properties/OffsetTest.php
+++ b/tests/properties/OffsetTest.php
@@ -34,7 +34,7 @@ class OffsetTest extends BaseClass {
    /**
     * @dataProvider numberRangeZeroToFourProvider
     *
-     * @param integer $offset
+     * @param int $offset
     */
    public function testOffsetOfOneNoHeader($offset) {
        $this->csv->offset = $offset;
--- a/tests/properties/PublicPropertiesTest.php
+++ b/tests/properties/PublicPropertiesTest.php
@@ -41,7 +41,7 @@ class PublicPropertiesTest extends TestCase {
     *
     * @access public
     */
-    public function setUp() {
+    protected function setUp(): void {
        //setup parse CSV
        $this->csv = new Csv();

@@ -58,7 +58,7 @@ class PublicPropertiesTest extends TestCase {
     *
     * @access public
     */
-    public function tearDown() {
+    protected function tearDown(): void {
        $this->csv = null;
        $this->reflection = null;
        $this->properties = null;
Author	SHA1	Message	Date
Fonata	b444afae2f	Specify release date	2021-04-14 20:14:01 +02:00
Fonata	bd6befe01e	Remove low-value comment	2021-04-14 20:12:43 +02:00
Fonata	05ed8ec667	Rename parameter to reduce confusion	2021-04-14 20:12:43 +02:00
Fonata	d21233c0f8	Remove Travis tests for PHP 7.0 It said: > TypeError: Return value of ParseCsv\tests\properties\BaseClass::setUp() must be an instance of void, none returned	2021-04-14 20:12:43 +02:00
Fonata	7a066f9d5e	Add test for empty first parameter	2021-04-14 20:12:43 +02:00
Fonata	2425c1bbda	Deprecation: Stronger language in PHP DocBlock	2021-04-14 20:12:43 +02:00
Fonata	eb502f9dad	PHP DocBlock: use more common type name	2021-04-14 20:12:43 +02:00
Fonata	0af6e98670	Tests should not produce output - capture it	2021-04-14 20:12:43 +02:00
Fonata	b38d0de800	Add test for getTotalDataRowCount without loading data	2021-04-14 20:12:43 +02:00
Fonata	e15d144e27	Adjust call to static function	2021-04-14 20:12:43 +02:00
Fonata	4518e944c4	Adjust function signatures for newer PHPUnit versions Will make an update to PHPUnit 8 or 9 easier.	2021-04-14 20:12:43 +02:00
Fonata	3ce6a82052	Make deprecation clearer	2021-04-14 20:12:43 +02:00
Fonata	abae91a1a2	Make condition easier to read; no change in logic	2021-04-14 20:12:43 +02:00
Fonata	45f079b5dd	Code comment for future me: I was afraid the code would surprise users	2021-04-14 20:12:43 +02:00
Fonata	fba67b84ff	More consistent formatting	2021-04-14 20:12:43 +02:00
Fonata	2a154869b4	Fix PHP DocBlock: some tools thought the function always returns true (Also, there was a spelling mistake)	2021-04-14 20:12:43 +02:00
Fonata	d1186fcafa	Deprecate support for file paths in __construct() and parse() See https://github.com/parsecsv/parsecsv-for-php/issues/198	2021-04-14 20:12:43 +02:00
Fonata	9c5eee23f6	Fix examples in README.md: add missing semicolons	2021-04-14 20:12:43 +02:00
Fonata	6a54a6a509	Move parsing of .php files (sic!) to _rfile for easier refactoring Note that this arcane code comes from v0.2.0 beta: `5f0e6b03d4`	2021-04-14 20:12:43 +02:00
Fonata	8277b9682d	Ignore files on the root directory only	2021-04-14 20:12:43 +02:00
Fonata	0e54a2b9fa	Make testing easier	2021-04-14 20:12:43 +02:00
Fonata	9c35237b1b	README: make sure examples can be used in namespaced files	2020-12-15 16:20:14 +01:00
Fonata	1528a1f6ae	README.md: fix the function name fix from my last commit	2020-12-07 18:13:09 +01:00
Fonata	aadb654edf	Fix incorrect function name in README.md Closes #195	2020-11-12 06:40:58 +01:00
Sergei Morozov	8069409c73	Add .gitattributes	2020-05-10 14:57:29 +02:00
Fonata	947b1c0866	Removed PHPUnit <6 compat wrapper	2020-04-25 19:17:04 +02:00
Petri Haikonen	a3981edb84	Added some annotations to tests	2020-04-25 19:17:04 +02:00
Petri Haikonen	b4e4c14b42	PHPUnit 6 instead of 4, to get rid of wrapper The TestCase wrapper caused PhpStorm to show warnings about multiple implementations Fixes #188 Improved some type hints in DocBlocks	2020-04-25 19:17:04 +02:00
Fonata	89429ebd60	Cleaned up README	2020-04-25 19:17:04 +02:00