Merge pull request #25 from box/bump_version_to_1.0.5

Bump version to 1.0.5

.editorconfig

@@ -0,0 +1,15 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_style = space
+indent_size = 4
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[{.travis.yml}]
+indent_size = 2
+
+[*.md]
+trim_trailing_whitespace = false

.gitignore

@@ -1,4 +1,5 @@
 /tests/resources/generated
+/tests/coverage
 /vendor
 composer.lock
 /.idea

.travis.yml

@@ -4,6 +4,8 @@ php:
   - 5.4
   - 5.5
   - 5.6
+  - nightly
+  - hhvm
 
 install:
   - composer self-update

composer.json

@@ -2,7 +2,7 @@
     "name": "box/spout",
     "description": "PHP Library to read and write CSV and XLSX files, in a fast and scalable way",
     "type": "library",
-    "version": "1.0.2",
+    "version": "1.0.5",
     "keywords": ["php","read","write","csv","xlsx","excel","spreadsheet","scale","memory","stream","ooxml"],
     "license": "Apache-2.0",
     "homepage": "https://www.github.com/box/spout",

phpunit.xml

@@ -14,4 +14,14 @@
         </testsuite>
     </testsuites>
 
+    <logging>
+        <log type="coverage-html" target="tests/coverage/"/>
+    </logging>
+
+    <filter>
+        <whitelist>
+            <directory suffix=".php">src/</directory>
+        </whitelist>
+    </filter>
+
 </phpunit>

src/Spout/Common/Escaper/CSV.php

@@ -13,6 +13,8 @@ class CSV implements EscaperInterface
     /**
      * Escapes the given string to make it compatible with CSV
      *
+     * @codeCoverageIgnore
+     *
      * @param string $string The string to escape
      * @return string The escaped string
      */
@@ -24,6 +26,8 @@ class CSV implements EscaperInterface
     /**
      * Unescapes the given string to make it compatible with CSV
      *
+     * @codeCoverageIgnore
+     *
      * @param string $string The string to unescape
      * @return string The unescaped string
      */

src/Spout/Common/Helper/GlobalFunctionsHelper.php

@@ -6,6 +6,8 @@ namespace Box\Spout\Common\Helper;
  * Class GlobalFunctionsHelper
  * This class wraps global functions to facilitate testing
  *
+ * @codeCoverageIgnore
+ *
  * @package Box\Spout\Common\Helper
  */
 class GlobalFunctionsHelper

src/Spout/Reader/Helper/XLSX/CellHelper.php

@@ -25,7 +25,7 @@ class CellHelper
     {
         $existingIndexes = array_keys($dataArray);
 
-        $newIndexes = array_fill_keys(range(min($existingIndexes), max($existingIndexes)), $fillValue);
+        $newIndexes = array_fill_keys(range(0, max($existingIndexes)), $fillValue);
         $dataArray += $newIndexes;
 
         ksort($dataArray);

src/Spout/Reader/Helper/XLSX/SharedStringsHelper.php

@@ -257,7 +257,7 @@ class SharedStringsHelper
             $sharedString = $this->unescapeLineFeed($escapedSharedString);
         }
 
-        if (!$sharedString) {
+        if ($sharedString === null) {
             throw new SharedStringNotFoundException("Shared string not found for index: $sharedStringIndex");
         }
 

src/Spout/Writer/AbstractWriter.php

@@ -89,6 +89,8 @@ abstract class AbstractWriter implements WriterInterface
      * Inits the writer and opens it to accept data.
      * By using this method, the data will be outputted directly to the browser.
      *
+     * @codeCoverageIgnore
+     *
      * @param  string $outputFileName Name of the output file that will contain the data. If a path is passed in, only the file name will be kept
      * @return \Box\Spout\Writer\AbstractWriter
      * @throws \Box\Spout\Common\Exception\IOException If the writer cannot be opened

src/Spout/Writer/Helper/XLSX/CellHelper.php

@@ -34,4 +34,38 @@ class CellHelper
 
         return $cellIndex;
     }
+
+    /**
+     * @param $value
+     * @return bool Whether the given value is a non empty string
+     */
+    public static function isNonEmptyString($value)
+    {
+        return (gettype($value) === 'string' && $value !== '');
+    }
+
+    /**
+     * Returns whether the given value is numeric.
+     * A numeric value is from type "integer" or "double" ("float" is not returned by gettype).
+     *
+     * @param $value
+     * @return bool Whether the given value is numeric
+     */
+    public static function isNumeric($value)
+    {
+        $valueType = gettype($value);
+        return ($valueType === 'integer' || $valueType === 'double');
+    }
+
+    /**
+     * Returns whether the given value is boolean.
+     * "true"/"false" and 0/1 are not booleans.
+     *
+     * @param $value
+     * @return bool Whether the given value is boolean
+     */
+    public static function isBoolean($value)
+    {
+        return gettype($value) === 'boolean';
+    }
 }

src/Spout/Writer/Internal/XLSX/Worksheet.php

@@ -2,6 +2,7 @@
 
 namespace Box\Spout\Writer\Internal\XLSX;
 
+use Box\Spout\Common\Exception\InvalidArgumentException;
 use Box\Spout\Common\Exception\IOException;
 use Box\Spout\Writer\Helper\XLSX\CellHelper;
 
@@ -119,6 +120,7 @@ EOD;
      *          Example $dataRow = ['data1', 1234, null, '', 'data5'];
      * @return void
      * @throws \Box\Spout\Common\Exception\IOException If the data cannot be written
+     * @throws \Box\Spout\Common\Exception\InvalidArgumentException If a cell value's type is not supported
      */
     public function addRow($dataRow)
     {
@@ -132,19 +134,19 @@ EOD;
             $columnIndex = CellHelper::getCellIndexFromColumnIndex($cellNumber);
             $data .= '            <c r="' . $columnIndex . $rowIndex . '"';
 
-            if (empty($cellValue)) {
+            if (CellHelper::isNonEmptyString($cellValue)) {
+                if ($this->shouldUseInlineStrings) {
+                    $data .= ' t="inlineStr"><is><t>' . $this->stringsEscaper->escape($cellValue) . '</t></is></c>' . PHP_EOL;
+                } else {
+                    $sharedStringId = $this->sharedStringsHelper->writeString($cellValue);
+                    $data .= ' t="s"><v>' . $sharedStringId . '</v></c>' . PHP_EOL;
+                }
+            } else if (CellHelper::isNumeric($cellValue) || CellHelper::isBoolean($cellValue)) {
+                $data .= '><v>' . $cellValue . '</v></c>' . PHP_EOL;
+            } else if (empty($cellValue)) {
                 $data .= '/>' . PHP_EOL;
             } else {
-                if (is_numeric($cellValue)) {
-                    $data .= '><v>' . $cellValue . '</v></c>' . PHP_EOL;
-                } else {
-                    if ($this->shouldUseInlineStrings) {
-                        $data .= ' t="inlineStr"><is><t>' . $this->stringsEscaper->escape($cellValue) . '</t></is></c>' . PHP_EOL;
-                    } else {
-                        $sharedStringId = $this->sharedStringsHelper->writeString($cellValue);
-                        $data .= ' t="s"><v>' . $sharedStringId . '</v></c>' . PHP_EOL;
-                    }
-                }
+                throw new InvalidArgumentException('Trying to add a value with an unsupported type: ' . gettype($cellValue));
             }
 
             $cellNumber++;

tests/Spout/Reader/Helper/XLSX/CellHelperTest.php

@@ -0,0 +1,60 @@
+<?php
+
+namespace Box\Spout\Reader\Helper\XLSX;
+
+/**
+ * Class CellHelperTest
+ *
+ * @package Box\Spout\Reader\Helper\XLSX
+ */
+class CellHelperTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @return void
+     */
+    public function testFillMissingArrayIndexes()
+    {
+        $arrayToFill = [1 => 1, 3 => 3];
+        $filledArray = CellHelper::fillMissingArrayIndexes($arrayToFill, 'FILL');
+
+        $expectedFilledArray = ['FILL', 1, 'FILL', 3];
+        $this->assertEquals($expectedFilledArray, $filledArray);
+    }
+
+    /**
+     * @return array
+     */
+    public function dataProviderForTestGetColumnIndexFromCellIndex()
+    {
+        return [
+            ['A1', 0],
+            ['Z3', 25],
+            ['AA5', 26],
+            ['AB24', 27],
+            ['BC5', 54],
+            ['BCZ99', 1455],
+        ];
+    }
+
+    /**
+     * @dataProvider dataProviderForTestGetColumnIndexFromCellIndex
+     *
+     * @param string $cellIndex
+     * @param int $expectedColumnIndex
+     * @return void
+     */
+    public function testGetColumnIndexFromCellIndex($cellIndex, $expectedColumnIndex)
+    {
+        $this->assertEquals($expectedColumnIndex, CellHelper::getColumnIndexFromCellIndex($cellIndex));
+    }
+
+    /**
+     * @expectedException \Box\Spout\Common\Exception\InvalidArgumentException
+     *
+     * @return void
+     */
+    public function testGetColumnIndexFromCellIndexShouldThrowIfInvalidCellIndex()
+    {
+        CellHelper::getColumnIndexFromCellIndex('InvalidCellIndex');
+    }
+}

tests/Spout/Reader/ReaderFactoryTest.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace Box\Spout\Reader;
+
+/**
+ * Class ReaderFactoryTest
+ *
+ * @package Box\Spout\Writer
+ */
+class ReaderFactoryTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @expectedException \Box\Spout\Common\Exception\UnsupportedTypeException
+     *
+     * @return void
+     */
+    public function testCreateReaderShouldThrowWithUnsupportedType()
+    {
+        ReaderFactory::create('unsupportedType');
+    }
+}

tests/Spout/Reader/XLSXTest.php

@@ -140,6 +140,32 @@ class XLSXTest extends \PHPUnit_Framework_TestCase
         $this->assertEquals($expectedRows, $allRows);
     }
 
+    /**
+     * @return void
+     */
+    public function testReadShouldSupportEmptySharedString()
+    {
+        $allRows = $this->getAllRowsForFile('sheet_with_empty_shared_string.xlsx');
+
+        $expectedRows = [
+            ['s1--A1', '', 's1--C1'],
+        ];
+        $this->assertEquals($expectedRows, $allRows);
+    }
+
+    /**
+     * @return void
+     */
+    public function testReadShouldPreserveSpaceIfSpecified()
+    {
+        $allRows = $this->getAllRowsForFile('sheet_with_preserve_space_shared_strings.xlsx');
+
+        $expectedRows = [
+            ['  s1--A1', 's1--B1  ', '  s1--C1  '],
+        ];
+        $this->assertEquals($expectedRows, $allRows);
+    }
+
     /**
      * @return void
      */
@@ -158,7 +184,7 @@ class XLSXTest extends \PHPUnit_Framework_TestCase
     {
         $allRows = $this->getAllRowsForFile('billion_laughs_test_file.xlsx');
 
-        $expectedMaxMemoryUsage = 10 * 1024 * 1024; // 10MB
+        $expectedMaxMemoryUsage = 20 * 1024 * 1024; // 20MB
         $this->assertLessThan($expectedMaxMemoryUsage, memory_get_peak_usage(true), 'Entities should not be expanded and therefore consume all the memory.');
 
         $expectedFirstRow = ['s1--A1', 's1--B1', 's1--C1', 's1--D1', 's1--E1'];

tests/Spout/Writer/CSVTest.php

@@ -49,6 +49,16 @@ class CSVTest extends \PHPUnit_Framework_TestCase
         $writer->close();
     }
 
+    /**
+     * @expectedException \Box\Spout\Common\Exception\InvalidArgumentException
+     */
+    public function testAddRowsShouldThrowExceptionIfRowsAreNotArrayOfArrays()
+    {
+        $writer = WriterFactory::create(Type::CSV);
+        $writer->addRows(['csv--11', 'csv--12']);
+        $writer->close();
+    }
+
     /**
      * @return void
      */

tests/Spout/Writer/Helper/XLSX/CellHelperTest.php

@@ -34,4 +34,62 @@ class CellHelperTest extends \PHPUnit_Framework_TestCase
     {
         $this->assertEquals($expectedCellIndex, CellHelper::getCellIndexFromColumnIndex($columnIndex));
     }
+
+    /**
+     * @return array
+     */
+    public function testIsNonEmptyString()
+    {
+        $this->assertTrue(CellHelper::isNonEmptyString("string"));
+
+        $this->assertFalse(CellHelper::isNonEmptyString(""));
+        $this->assertFalse(CellHelper::isNonEmptyString(0));
+        $this->assertFalse(CellHelper::isNonEmptyString(1));
+        $this->assertFalse(CellHelper::isNonEmptyString(true));
+        $this->assertFalse(CellHelper::isNonEmptyString(false));
+        $this->assertFalse(CellHelper::isNonEmptyString(["string"]));
+        $this->assertFalse(CellHelper::isNonEmptyString(new \stdClass()));
+        $this->assertFalse(CellHelper::isNonEmptyString(null));
+    }
+
+    /**
+     * @return array
+     */
+    public function testIsNumeric()
+    {
+        $this->assertTrue(CellHelper::isNumeric(0));
+        $this->assertTrue(CellHelper::isNumeric(10));
+        $this->assertTrue(CellHelper::isNumeric(10.1));
+        $this->assertTrue(CellHelper::isNumeric(10.10000000000000000000001));
+        $this->assertTrue(CellHelper::isNumeric(0x539));
+        $this->assertTrue(CellHelper::isNumeric(02471));
+        $this->assertTrue(CellHelper::isNumeric(0b10100111001));
+        $this->assertTrue(CellHelper::isNumeric(1337e0));
+
+        $this->assertFalse(CellHelper::isNumeric("0"));
+        $this->assertFalse(CellHelper::isNumeric("42"));
+        $this->assertFalse(CellHelper::isNumeric(true));
+        $this->assertFalse(CellHelper::isNumeric([2]));
+        $this->assertFalse(CellHelper::isNumeric(new \stdClass()));
+        $this->assertFalse(CellHelper::isNumeric(null));
+    }
+
+    /**
+     * @return array
+     */
+    public function testIsBoolean()
+    {
+        $this->assertTrue(CellHelper::isBoolean(true));
+        $this->assertTrue(CellHelper::isBoolean(false));
+
+        $this->assertFalse(CellHelper::isBoolean(0));
+        $this->assertFalse(CellHelper::isBoolean(1));
+        $this->assertFalse(CellHelper::isBoolean("0"));
+        $this->assertFalse(CellHelper::isBoolean("1"));
+        $this->assertFalse(CellHelper::isBoolean("true"));
+        $this->assertFalse(CellHelper::isBoolean("false"));
+        $this->assertFalse(CellHelper::isBoolean([true]));
+        $this->assertFalse(CellHelper::isBoolean(new \stdClass()));
+        $this->assertFalse(CellHelper::isBoolean(null));
+    }
 }

tests/Spout/Writer/WriterFactoryTest.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace Box\Spout\Writer;
+
+/**
+ * Class WriterFactoryTest
+ *
+ * @package Box\Spout\Writer
+ */
+class WriterFactoryTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @expectedException \Box\Spout\Common\Exception\UnsupportedTypeException
+     *
+     * @return void
+     */
+    public function testCreateWriterShouldThrowWithUnsupportedType()
+    {
+        WriterFactory::create('unsupportedType');
+    }
+}

tests/Spout/Writer/XLSXTest.php

@@ -49,6 +49,19 @@ class XLSXTest extends \PHPUnit_Framework_TestCase
         $writer->close();
     }
 
+    /**
+     * @expectedException \Box\Spout\Common\Exception\InvalidArgumentException
+     */
+    public function testAddRowShouldThrowExceptionIfUnsupportedDataTypePassedIn()
+    {
+        $fileName = 'test_add_row_should_throw_exception_if_unsupported_data_type_passed_in.xlsx';
+        $dataRows = [
+            [new \stdClass()],
+        ];
+
+        $this->writeToXLSXFile($dataRows, $fileName);
+    }
+
     /**
      * @return void
      */
@@ -96,7 +109,7 @@ class XLSXTest extends \PHPUnit_Framework_TestCase
      */
     public function testAddRowShouldWriteGivenDataToSheetUsingInlineStrings()
     {
-        $fileName = 'test_add_row_should_write_given_data_to_sheet.xlsx';
+        $fileName = 'test_add_row_should_write_given_data_to_sheet_using_inline_strings.xlsx';
         $dataRows = [
             ['xlsx--11', 'xlsx--12'],
             ['xlsx--21', 'xlsx--22', 'xlsx--23'],
@@ -106,7 +119,7 @@ class XLSXTest extends \PHPUnit_Framework_TestCase
 
         foreach ($dataRows as $dataRow) {
             foreach ($dataRow as $cellValue) {
-                $this->assertInlineStringWasWrittenToSheet($fileName, 1, $cellValue);
+                $this->assertInlineDataWasWrittenToSheet($fileName, 1, $cellValue);
             }
         }
     }
@@ -116,7 +129,7 @@ class XLSXTest extends \PHPUnit_Framework_TestCase
      */
     public function testAddRowShouldWriteGivenDataToTwoSheetUsingInlineStrings()
     {
-        $fileName = 'test_add_row_should_write_given_data_to_sheet.xlsx';
+        $fileName = 'test_add_row_should_write_given_data_to_two_sheets_using_inline_strings.xlsx';
         $dataRows = [
             ['xlsx--11', 'xlsx--12'],
             ['xlsx--21', 'xlsx--22', 'xlsx--23'],
@@ -128,7 +141,7 @@ class XLSXTest extends \PHPUnit_Framework_TestCase
         for ($i = 1; $i <= $numSheets; $i++) {
             foreach ($dataRows as $dataRow) {
                 foreach ($dataRow as $cellValue) {
-                    $this->assertInlineStringWasWrittenToSheet($fileName, $numSheets, $cellValue);
+                    $this->assertInlineDataWasWrittenToSheet($fileName, $numSheets, $cellValue);
                 }
             }
         }
@@ -139,7 +152,7 @@ class XLSXTest extends \PHPUnit_Framework_TestCase
      */
     public function testAddRowShouldWriteGivenDataToSheetUsingSharedStrings()
     {
-        $fileName = 'test_add_row_should_write_given_data_to_sheet.xlsx';
+        $fileName = 'test_add_row_should_write_given_data_to_sheet_using_shared_strings.xlsx';
         $dataRows = [
             ['xlsx--11', 'xlsx--12'],
             ['xlsx--21', 'xlsx--22', 'xlsx--23'],
@@ -159,7 +172,7 @@ class XLSXTest extends \PHPUnit_Framework_TestCase
      */
     public function testAddRowShouldWriteGivenDataToTwoSheetUsingSharedStrings()
     {
-        $fileName = 'test_add_row_should_write_given_data_to_two_sheet_using_shared_strings.xlsx';
+        $fileName = 'test_add_row_should_write_given_data_to_two_sheets_using_shared_strings.xlsx';
         $dataRows = [
             ['xlsx--11', 'xlsx--12'],
             ['xlsx--21', 'xlsx--22', 'xlsx--23'],
@@ -177,6 +190,24 @@ class XLSXTest extends \PHPUnit_Framework_TestCase
         }
     }
 
+    /**
+     * @return void
+     */
+    public function testAddRowShouldSupportMultipleTypesOfData()
+    {
+        $fileName = 'test_add_row_should_support_multiple_types_of_data.xlsx';
+        $dataRows = [
+            ['xlsx--11', true, '', 0, 10.2, null],
+        ];
+
+        $this->writeToXLSXFile($dataRows, $fileName, $shouldUseInlineStrings = false);
+
+        $this->assertSharedStringWasWritten($fileName, 'xlsx--11');
+        $this->assertInlineDataWasWrittenToSheet($fileName, 1, 1); // true is converted to 1
+        $this->assertInlineDataWasWrittenToSheet($fileName, 1, 0);
+        $this->assertInlineDataWasWrittenToSheet($fileName, 1, 10.2);
+    }
+
     /**
      * @return void
      */
@@ -219,17 +250,17 @@ class XLSXTest extends \PHPUnit_Framework_TestCase
 
         foreach ($dataRowsSheet1 as $dataRow) {
             foreach ($dataRow as $cellValue) {
-                $this->assertInlineStringWasWrittenToSheet($fileName, 1, $cellValue, 'Data should have been written in Sheet 1');
+                $this->assertInlineDataWasWrittenToSheet($fileName, 1, $cellValue, 'Data should have been written in Sheet 1');
             }
         }
         foreach ($dataRowsSheet2 as $dataRow) {
             foreach ($dataRow as $cellValue) {
-                $this->assertInlineStringWasWrittenToSheet($fileName, 2, $cellValue, 'Data should have been written in Sheet 2');
+                $this->assertInlineDataWasWrittenToSheet($fileName, 2, $cellValue, 'Data should have been written in Sheet 2');
             }
         }
         foreach ($dataRowsSheet1Again as $dataRow) {
             foreach ($dataRow as $cellValue) {
-                $this->assertInlineStringWasWrittenToSheet($fileName, 1, $cellValue, 'Data should have been written in Sheet 1');
+                $this->assertInlineDataWasWrittenToSheet($fileName, 1, $cellValue, 'Data should have been written in Sheet 1');
             }
         }
     }
@@ -252,8 +283,8 @@ class XLSXTest extends \PHPUnit_Framework_TestCase
         $writer = $this->writeToXLSXFile($dataRows, $fileName, true, $shouldCreateSheetsAutomatically = true);
         $this->assertEquals(2, count($writer->getSheets()), '2 sheets should have been created.');
 
-        $this->assertInlineStringWasNotWrittenToSheet($fileName, 1, 'xlsx--sheet2--11');
-        $this->assertInlineStringWasWrittenToSheet($fileName, 2, 'xlsx--sheet2--11');
+        $this->assertInlineDataWasNotWrittenToSheet($fileName, 1, 'xlsx--sheet2--11');
+        $this->assertInlineDataWasWrittenToSheet($fileName, 2, 'xlsx--sheet2--11');
 
         \ReflectionHelper::reset();
     }
@@ -276,7 +307,7 @@ class XLSXTest extends \PHPUnit_Framework_TestCase
         $writer = $this->writeToXLSXFile($dataRows, $fileName, true, $shouldCreateSheetsAutomatically = false);
         $this->assertEquals(1, count($writer->getSheets()), 'Only 1 sheet should have been created.');
 
-        $this->assertInlineStringWasNotWrittenToSheet($fileName, 1, 'xlsx--sheet1--31');
+        $this->assertInlineDataWasNotWrittenToSheet($fileName, 1, 'xlsx--sheet1--31');
 
         \ReflectionHelper::reset();
     }
@@ -293,8 +324,8 @@ class XLSXTest extends \PHPUnit_Framework_TestCase
 
         $this->writeToXLSXFile($dataRows, $fileName);
 
-        $this->assertInlineStringWasWrittenToSheet($fileName, 1, 'I&#039;m in &quot;great&quot; mood', 'Quotes should be escaped');
-        $this->assertInlineStringWasWrittenToSheet($fileName, 1, 'This &lt;must&gt; be escaped &amp; tested', '<, > and & should be escaped');
+        $this->assertInlineDataWasWrittenToSheet($fileName, 1, 'I&#039;m in &quot;great&quot; mood', 'Quotes should be escaped');
+        $this->assertInlineDataWasWrittenToSheet($fileName, 1, 'This &lt;must&gt; be escaped &amp; tested', '<, > and & should be escaped');
     }
 
     /**
@@ -309,7 +340,7 @@ class XLSXTest extends \PHPUnit_Framework_TestCase
 
         $this->writeToXLSXFile($dataRows, $fileName);
 
-        $this->assertInlineStringWasWrittenToSheet($fileName, 1, 'control&#039;s _x0015_ &quot;character&quot;');
+        $this->assertInlineDataWasWrittenToSheet($fileName, 1, 'control&#039;s _x0015_ &quot;character&quot;');
     }
 
 
@@ -371,33 +402,33 @@ class XLSXTest extends \PHPUnit_Framework_TestCase
     /**
      * @param string $fileName
      * @param int $sheetNumber
-     * @param string $inlineString
+     * @param mixed $inlineData
      * @param string $message
      * @return void
      */
-    private function assertInlineStringWasWrittenToSheet($fileName, $sheetNumber, $inlineString, $message = '')
+    private function assertInlineDataWasWrittenToSheet($fileName, $sheetNumber, $inlineData, $message = '')
     {
         $resourcePath = $this->getGeneratedResourcePath($fileName);
         $pathToSheetFile = $resourcePath . '#xl/worksheets/sheet' . $sheetNumber . '.xml';
         $xmlContents = file_get_contents('zip://' . $pathToSheetFile);
 
-        $this->assertContains($inlineString, $xmlContents, $message);
+        $this->assertContains((string)$inlineData, $xmlContents, $message);
     }
 
     /**
      * @param string $fileName
      * @param int $sheetNumber
-     * @param string $inlineString
+     * @param mixed $inlineData
      * @param string $message
      * @return void
      */
-    private function assertInlineStringWasNotWrittenToSheet($fileName, $sheetNumber, $inlineString, $message = '')
+    private function assertInlineDataWasNotWrittenToSheet($fileName, $sheetNumber, $inlineData, $message = '')
     {
         $resourcePath = $this->getGeneratedResourcePath($fileName);
         $pathToSheetFile = $resourcePath . '#xl/worksheets/sheet' . $sheetNumber . '.xml';
         $xmlContents = file_get_contents('zip://' . $pathToSheetFile);
 
-        $this->assertNotContains($inlineString, $xmlContents, $message);
+        $this->assertNotContains((string)$inlineData, $xmlContents, $message);
     }
 
     /**