diff --git a/src/Spout/Writer/CSV/Writer.php b/src/Spout/Writer/CSV/Writer.php
index 7f9c814..0f75ecd 100644
--- a/src/Spout/Writer/CSV/Writer.php
+++ b/src/Spout/Writer/CSV/Writer.php
@@ -5,6 +5,7 @@ namespace Box\Spout\Writer\CSV;
 use Box\Spout\Common\Exception\IOException;
 use Box\Spout\Common\Helper\EncodingHelper;
 use Box\Spout\Writer\Common\Entity\Options;
+use Box\Spout\Writer\Common\Entity\Row;
 use Box\Spout\Writer\WriterAbstract;
 
 /**
@@ -78,20 +79,18 @@ class Writer extends WriterAbstract
     }
 
     /**
-     * Adds data to the currently opened writer.
+     * Adds a row to the currently opened writer.
      *
-     * @param  array $dataRow Array containing data to be written.
-     *          Example $dataRow = ['data1', 1234, null, '', 'data5'];
-     * @param \Box\Spout\Writer\Common\Entity\Style\Style $style Ignored here since CSV does not support styling.
-     * @throws \Box\Spout\Common\Exception\IOException If unable to write data
+     * @param Row $row The row containing cells and styles
+     * @throws IOException If unable to write data
      * @return void
      */
-    protected function addRowToWriter(array $dataRow, $style)
+    protected function addRowToWriter(Row $row)
     {
         $fieldDelimiter = $this->optionsManager->getOption(Options::FIELD_DELIMITER);
         $fieldEnclosure = $this->optionsManager->getOption(Options::FIELD_ENCLOSURE);
 
-        $wasWriteSuccessful = $this->globalFunctionsHelper->fputcsv($this->filePointer, $dataRow, $fieldDelimiter, $fieldEnclosure);
+        $wasWriteSuccessful = $this->globalFunctionsHelper->fputcsv($this->filePointer, $row->getCells(), $fieldDelimiter, $fieldEnclosure);
         if ($wasWriteSuccessful === false) {
             throw new IOException('Unable to write data');
         }
diff --git a/src/Spout/Writer/Common/Creator/EntityFactory.php b/src/Spout/Writer/Common/Creator/EntityFactory.php
index 04324aa..b9ebef4 100644
--- a/src/Spout/Writer/Common/Creator/EntityFactory.php
+++ b/src/Spout/Writer/Common/Creator/EntityFactory.php
@@ -3,10 +3,14 @@
 namespace Box\Spout\Writer\Common\Creator;
 
 use Box\Spout\Writer\Common\Entity\Cell;
+use Box\Spout\Writer\Common\Entity\Row;
 use Box\Spout\Writer\Common\Entity\Sheet;
+use Box\Spout\Writer\Common\Entity\Style\Style;
 use Box\Spout\Writer\Common\Entity\Workbook;
 use Box\Spout\Writer\Common\Entity\Worksheet;
+use Box\Spout\Writer\Common\Manager\RowManager;
 use Box\Spout\Writer\Common\Manager\SheetManager;
+use Box\Spout\Writer\Common\Manager\Style\StyleMerger;
 
 /**
  * Class EntityFactory
@@ -47,7 +51,7 @@ class EntityFactory
      * @param mixed $cellValue
      * @return Cell
      */
-    public function createCell($cellValue)
+    public static function createCell($cellValue)
     {
         return new Cell($cellValue);
     }
@@ -59,4 +63,17 @@ class EntityFactory
     {
         return new \ZipArchive();
     }
+
+    /**
+     * @param array $cells
+     * @param Style|null $style
+     * @return Row
+     */
+    public static function createRow(array $cells, Style $style = null)
+    {
+        $styleMerger = new StyleMerger();
+        $rowManager = new RowManager($styleMerger);
+
+        return new Row($cells, $style, $rowManager);
+    }
 }
diff --git a/src/Spout/Writer/Common/Entity/Cell.php b/src/Spout/Writer/Common/Entity/Cell.php
index f869e2c..9660b42 100644
--- a/src/Spout/Writer/Common/Entity/Cell.php
+++ b/src/Spout/Writer/Common/Entity/Cell.php
@@ -2,7 +2,9 @@
 
 namespace Box\Spout\Writer\Common\Entity;
 
+use Box\Spout\Writer\Common\Entity\Style\Style;
 use Box\Spout\Writer\Common\Helper\CellHelper;
+use Box\Spout\Writer\Common\Manager\Style\StyleMerger;
 
 /**
  * Class Cell
@@ -53,16 +55,29 @@ class Cell
     protected $type;
 
     /**
-     * Cell constructor.
-     * @param $value mixed
+     * The cell style
+     * @var Style
      */
-    public function __construct($value)
+    protected $style;
+
+    /**
+     * @var StyleMerger
+     */
+    protected $styleMerger;
+
+    /**
+     * @param $value mixed
+     * @param Style|null $style
+     */
+    public function __construct($value, Style $style = null)
     {
         $this->setValue($value);
+        $this->setStyle($style);
+        $this->styleMerger = new StyleMerger();
     }
 
     /**
-     * @param $value mixed|null
+     * @param mixed|null $value
      */
     public function setValue($value)
     {
@@ -78,6 +93,22 @@ class Cell
         return $this->value;
     }
 
+    /**
+     * @param Style|null $style
+     */
+    public function setStyle($style)
+    {
+        $this->style = $style ?: new Style();
+    }
+
+    /**
+     * @return Style
+     */
+    public function getStyle()
+    {
+        return $this->style;
+    }
+
     /**
      * @return int|null
      */
@@ -88,6 +119,7 @@ class Cell
 
     /**
      * Get the current value type
+     *
      * @param mixed|null $value
      * @return int
      */
@@ -127,6 +159,7 @@ class Cell
 
     /**
      * Not used at the moment
+     *
      * @return bool
      */
     public function isFormula()
@@ -165,4 +198,20 @@ class Cell
     {
         return (string) $this->value;
     }
+
+    /**
+     * @param Style|null $style
+     * @return Cell
+     */
+    public function applyStyle($style)
+    {
+        if ($style === null) {
+            return $this;
+        }
+
+        $mergedStyle = $this->styleMerger->merge($this->style, $style);
+        $this->setStyle($mergedStyle);
+
+        return $this;
+    }
 }
diff --git a/src/Spout/Writer/Common/Entity/Row.php b/src/Spout/Writer/Common/Entity/Row.php
new file mode 100644
index 0000000..fae771f
--- /dev/null
+++ b/src/Spout/Writer/Common/Entity/Row.php
@@ -0,0 +1,126 @@
+<?php
+
+namespace Box\Spout\Writer\Common\Entity;
+
+use Box\Spout\Writer\Common\Entity\Style\Style;
+use Box\Spout\Writer\Common\Manager\RowManager;
+
+class Row
+{
+    /**
+     * The cells in this row
+     * @var Cell[]
+     */
+    protected $cells = [];
+
+    /**
+     * The row style
+     * @var Style
+     */
+    protected $style;
+
+    /**
+     * Thw row manager
+     * @var RowManager
+     */
+    protected $rowManager;
+
+    /**
+     * Row constructor.
+     * @param Cell[] $cells
+     * @param Style|null $style
+     * @param RowManager $rowManager
+     */
+    public function __construct(array $cells, $style, RowManager $rowManager)
+    {
+        $this
+            ->setCells($cells)
+            ->setStyle($style);
+
+        $this->rowManager = $rowManager;
+    }
+
+    /**
+     * @return Cell[] $cells
+     */
+    public function getCells()
+    {
+        return $this->cells;
+    }
+
+    /**
+     * @param Cell[] $cells
+     * @return $this
+     */
+    public function setCells(array $cells)
+    {
+        $this->cells = [];
+        foreach ($cells as $cell) {
+            $this->addCell($cell);
+        }
+
+        return $this;
+    }
+
+    /**
+     * @return Style
+     */
+    public function getStyle()
+    {
+        return $this->style;
+    }
+
+    /**
+     * @param Style|null $style
+     * @return Row
+     */
+    public function setStyle($style)
+    {
+        $this->style = $style ?: new Style();
+
+        return $this;
+    }
+
+    /**
+     * @param Style $style
+     * @return Row
+     */
+    public function applyStyle($style)
+    {
+        $this->rowManager->applyStyle($this, $style);
+
+        return $this;
+    }
+
+    /**
+     * @param Cell $cell
+     * @return Row
+     */
+    public function addCell(Cell $cell)
+    {
+        $this->cells[] = $cell;
+
+        return $this;
+    }
+
+    /**
+     * Returns whether a row has cells
+     *
+     * @return bool
+     */
+    public function hasCells()
+    {
+        return $this->rowManager->hasCells($this);
+    }
+
+    /**
+     * Detect whether this row is considered empty.
+     * An empty row has either no cells at all - or only empty cells
+     *
+     * @return bool
+     */
+    public function isEmpty()
+    {
+        return $this->rowManager->isEmpty($this);
+    }
+}
diff --git a/src/Spout/Writer/Common/Manager/CellManager.php b/src/Spout/Writer/Common/Manager/CellManager.php
new file mode 100644
index 0000000..855c498
--- /dev/null
+++ b/src/Spout/Writer/Common/Manager/CellManager.php
@@ -0,0 +1,36 @@
+<?php
+
+namespace Box\Spout\Writer\Common\Manager;
+
+use Box\Spout\Writer\Common\Entity\Cell;
+use Box\Spout\Writer\Common\Entity\Style\Style;
+use Box\Spout\Writer\Common\Manager\Style\StyleMerger;
+
+class CellManager
+{
+    /**
+     * @var StyleMerger
+     */
+    protected $styleMerger;
+
+    /**
+     * @param StyleMerger $styleMerger
+     */
+    public function __construct(StyleMerger $styleMerger)
+    {
+        $this->styleMerger = $styleMerger;
+    }
+
+    /**
+     * Merges a Style into a cell's Style.
+     *
+     * @param Cell $cell
+     * @param Style $style
+     * @return void
+     */
+    public function applyStyle(Cell $cell, Style $style)
+    {
+        $mergedStyle = $this->styleMerger->merge($cell->getStyle(), $style);
+        $cell->setStyle($mergedStyle);
+    }
+}
diff --git a/src/Spout/Writer/Common/Manager/RowManager.php b/src/Spout/Writer/Common/Manager/RowManager.php
new file mode 100644
index 0000000..109fa06
--- /dev/null
+++ b/src/Spout/Writer/Common/Manager/RowManager.php
@@ -0,0 +1,59 @@
+<?php
+
+namespace Box\Spout\Writer\Common\Manager;
+
+use Box\Spout\Writer\Common\Entity\Row;
+use Box\Spout\Writer\Common\Entity\Style\Style;
+use Box\Spout\Writer\Common\Manager\Style\StyleMerger;
+
+class RowManager
+{
+    /**
+     * @var StyleMerger
+     */
+    protected $styleMerger;
+
+    /**
+     * @param StyleMerger $styleMerger
+     */
+    public function __construct(StyleMerger $styleMerger)
+    {
+        $this->styleMerger = $styleMerger;
+    }
+
+    /**
+     * @param Row $row
+     * @param Style $style
+     * @return $this
+     */
+    public function applyStyle(Row $row, Style $style)
+    {
+        $mergedStyle = $this->styleMerger->merge($row->getStyle(), $style);
+        $row->setStyle($mergedStyle);
+    }
+
+    /**
+     * Returns whether a row has cells
+     *
+     * @param Row $row
+     * @return bool
+     */
+    public function hasCells(Row $row)
+    {
+        return count($row->getCells()) !== 0;
+    }
+
+    /**
+     * Detect whether a row is considered empty.
+     * An empty row has either no cells at all - or only one empty cell
+     *
+     * @param Row $row
+     * @return bool
+     */
+    public function isEmpty(Row $row)
+    {
+        $cells = $row->getCells();
+
+        return count($cells) === 0 || (count($cells) === 1 && $cells[0]->isEmpty());
+    }
+}
diff --git a/src/Spout/Writer/Common/Manager/Style/StyleManager.php b/src/Spout/Writer/Common/Manager/Style/StyleManager.php
index 14a4c7e..9006d02 100644
--- a/src/Spout/Writer/Common/Manager/Style/StyleManager.php
+++ b/src/Spout/Writer/Common/Manager/Style/StyleManager.php
@@ -2,6 +2,7 @@
 
 namespace Box\Spout\Writer\Common\Manager\Style;
 
+use Box\Spout\Writer\Common\Entity\Cell;
 use Box\Spout\Writer\Common\Entity\Style\Style;
 
 /**
@@ -48,13 +49,12 @@ class StyleManager implements StyleManagerInterface
      * Apply additional styles if the given row needs it.
      * Typically, set "wrap text" if a cell contains a new line.
      *
-     * @param Style $style The original style
-     * @param array $dataRow The row the style will be applied to
-     * @return Style The updated style
+     * @param Cell $cell
+     * @return Style
      */
-    public function applyExtraStylesIfNeeded($style, $dataRow)
+    public function applyExtraStylesIfNeeded(Cell $cell)
     {
-        $updatedStyle = $this->applyWrapTextIfCellContainsNewLine($style, $dataRow);
+        $updatedStyle = $this->applyWrapTextIfCellContainsNewLine($cell);
 
         return $updatedStyle;
     }
@@ -68,24 +68,22 @@ class StyleManager implements StyleManagerInterface
      *        A workaround would be to encode "\n" as "_x000D_" but it does not work
      *        on the Windows version of Excel...
      *
-     * @param Style $style The original style
-     * @param array $dataRow The row the style will be applied to
-     * @return Style The eventually updated style
+     * @param Cell $cell The cell the style should be applied to
+     * @return \Box\Spout\Writer\Common\Entity\Style\Style The eventually updated style
      */
-    protected function applyWrapTextIfCellContainsNewLine($style, $dataRow)
+    protected function applyWrapTextIfCellContainsNewLine(Cell $cell)
     {
+        $cellStyle = $cell->getStyle();
+
         // if the "wrap text" option is already set, no-op
-        if ($style->hasSetWrapText()) {
-            return $style;
+        if ($cellStyle->hasSetWrapText()) {
+            return $cellStyle;
         }
 
-        foreach ($dataRow as $cell) {
-            if (is_string($cell) && strpos($cell, "\n") !== false) {
-                $style->setShouldWrapText();
-                break;
-            }
+        if ($cell->isString() && strpos($cell->getValue(), "\n") !== false) {
+            $cellStyle->setShouldWrapText();
         }
 
-        return $style;
+        return $cellStyle;
     }
 }
diff --git a/src/Spout/Writer/Common/Manager/Style/StyleManagerInterface.php b/src/Spout/Writer/Common/Manager/Style/StyleManagerInterface.php
index 70de0ef..216b981 100644
--- a/src/Spout/Writer/Common/Manager/Style/StyleManagerInterface.php
+++ b/src/Spout/Writer/Common/Manager/Style/StyleManagerInterface.php
@@ -2,6 +2,7 @@
 
 namespace Box\Spout\Writer\Common\Manager\Style;
 
+use Box\Spout\Writer\Common\Entity\Cell;
 use Box\Spout\Writer\Common\Entity\Style\Style;
 
 /**
@@ -22,9 +23,8 @@ interface StyleManagerInterface
      * Apply additional styles if the given row needs it.
      * Typically, set "wrap text" if a cell contains a new line.
      *
-     * @param Style $style The original style
-     * @param array $dataRow The row the style will be applied to
+     * @param Cell $cell
      * @return Style The updated style
      */
-    public function applyExtraStylesIfNeeded($style, $dataRow);
+    public function applyExtraStylesIfNeeded(Cell $cell);
 }
diff --git a/src/Spout/Writer/Common/Manager/WorkbookManagerAbstract.php b/src/Spout/Writer/Common/Manager/WorkbookManagerAbstract.php
index b4308bb..89b0c00 100644
--- a/src/Spout/Writer/Common/Manager/WorkbookManagerAbstract.php
+++ b/src/Spout/Writer/Common/Manager/WorkbookManagerAbstract.php
@@ -7,8 +7,8 @@ use Box\Spout\Common\Manager\OptionsManagerInterface;
 use Box\Spout\Writer\Common\Creator\EntityFactory;
 use Box\Spout\Writer\Common\Creator\ManagerFactoryInterface;
 use Box\Spout\Writer\Common\Entity\Options;
+use Box\Spout\Writer\Common\Entity\Row;
 use Box\Spout\Writer\Common\Entity\Sheet;
-use Box\Spout\Writer\Common\Entity\Style\Style;
 use Box\Spout\Writer\Common\Entity\Workbook;
 use Box\Spout\Writer\Common\Entity\Worksheet;
 use Box\Spout\Writer\Common\Helper\FileSystemWithRootFolderHelperInterface;
@@ -198,21 +198,19 @@ abstract class WorkbookManagerAbstract implements WorkbookManagerInterface
     }
 
     /**
-     * Adds data to the current sheet.
+     * Adds a row to the current sheet.
      * If shouldCreateNewSheetsAutomatically option is set to true, it will handle pagination
      * with the creation of new worksheets if one worksheet has reached its maximum capicity.
      *
-     * @param array $dataRow Array containing data to be written. Cannot be empty.
-     *          Example $dataRow = ['data1', 1234, null, '', 'data5'];
-     * @param Style $style Style to be applied to the row.
+     * @param Row $row The row to be added
      * @throws IOException If trying to create a new sheet and unable to open the sheet for writing
      * @throws WriterException If unable to write data
      * @return void
      */
-    public function addRowToCurrentWorksheet($dataRow, Style $style)
+    public function addRowToCurrentWorksheet(Row $row)
     {
         $currentWorksheet = $this->getCurrentWorksheet();
-        $hasReachedMaxRows = $this->hasCurrentWorkseetReachedMaxRows();
+        $hasReachedMaxRows = $this->hasCurrentWorksheetReachedMaxRows();
 
         // if we reached the maximum number of rows for the current sheet...
         if ($hasReachedMaxRows) {
@@ -220,19 +218,19 @@ abstract class WorkbookManagerAbstract implements WorkbookManagerInterface
             if ($this->optionManager->getOption(Options::SHOULD_CREATE_NEW_SHEETS_AUTOMATICALLY)) {
                 $currentWorksheet = $this->addNewSheetAndMakeItCurrent();
 
-                $this->addRowWithStyleToWorksheet($currentWorksheet, $dataRow, $style);
+                $this->addRowToWorksheet($currentWorksheet, $row);
             } else {
                 // otherwise, do nothing as the data won't be written anyways
             }
         } else {
-            $this->addRowWithStyleToWorksheet($currentWorksheet, $dataRow, $style);
+            $this->addRowToWorksheet($currentWorksheet, $row);
         }
     }
 
     /**
      * @return bool Whether the current worksheet has reached the maximum number of rows per sheet.
      */
-    private function hasCurrentWorkseetReachedMaxRows()
+    private function hasCurrentWorksheetReachedMaxRows()
     {
         $currentWorksheet = $this->getCurrentWorksheet();
 
@@ -240,24 +238,20 @@ abstract class WorkbookManagerAbstract implements WorkbookManagerInterface
     }
 
     /**
-     * Adds data with the given style to the given sheet.
+     * Adds a row to the given sheet.
      *
      * @param Worksheet $worksheet Worksheet to write the row to
-     * @param array $dataRow Array containing data to be written. Cannot be empty.
-     *          Example $dataRow = ['data1', 1234, null, '', 'data5'];
-     * @param Style $style Style to be applied to the row.
+     * @param Row $row The row to be added
      * @throws WriterException If unable to write data
      * @return void
      */
-    private function addRowWithStyleToWorksheet(Worksheet $worksheet, $dataRow, Style $style)
+    private function addRowToWorksheet(Worksheet $worksheet, Row $row)
     {
-        $updatedStyle = $this->styleManager->applyExtraStylesIfNeeded($style, $dataRow);
-        $registeredStyle = $this->styleManager->registerStyle($updatedStyle);
-        $this->worksheetManager->addRow($worksheet, $dataRow, $registeredStyle);
+        $this->worksheetManager->addRow($worksheet, $row);
 
         // update max num columns for the worksheet
         $currentMaxNumColumns = $worksheet->getMaxNumColumns();
-        $cellsCount = count($dataRow);
+        $cellsCount = count($row->getCells());
         $worksheet->setMaxNumColumns(max($currentMaxNumColumns, $cellsCount));
     }
 
diff --git a/src/Spout/Writer/Common/Manager/WorkbookManagerInterface.php b/src/Spout/Writer/Common/Manager/WorkbookManagerInterface.php
index dbc5780..85b68f5 100644
--- a/src/Spout/Writer/Common/Manager/WorkbookManagerInterface.php
+++ b/src/Spout/Writer/Common/Manager/WorkbookManagerInterface.php
@@ -3,8 +3,8 @@
 namespace Box\Spout\Writer\Common\Manager;
 
 use Box\Spout\Common\Exception\IOException;
+use Box\Spout\Writer\Common\Entity\Row;
 use Box\Spout\Writer\Common\Entity\Sheet;
-use Box\Spout\Writer\Common\Entity\Style\Style;
 use Box\Spout\Writer\Common\Entity\Workbook;
 use Box\Spout\Writer\Common\Entity\Worksheet;
 use Box\Spout\Writer\Exception\SheetNotFoundException;
@@ -53,18 +53,16 @@ interface WorkbookManagerInterface
     public function setCurrentSheet(Sheet $sheet);
 
     /**
-     * Adds data to the current sheet.
+     * Adds a row to the current sheet.
      * If shouldCreateNewSheetsAutomatically option is set to true, it will handle pagination
      * with the creation of new worksheets if one worksheet has reached its maximum capicity.
      *
-     * @param array $dataRow Array containing data to be written. Cannot be empty.
-     *          Example $dataRow = ['data1', 1234, null, '', 'data5'];
-     * @param Style $style Style to be applied to the row.
+     * @param Row $row The row to be added
      * @throws IOException If trying to create a new sheet and unable to open the sheet for writing
      * @throws WriterException If unable to write data
      * @return void
      */
-    public function addRowToCurrentWorksheet($dataRow, Style $style);
+    public function addRowToCurrentWorksheet(Row $row);
 
     /**
      * Closes the workbook and all its associated sheets.
diff --git a/src/Spout/Writer/Common/Manager/WorksheetManagerInterface.php b/src/Spout/Writer/Common/Manager/WorksheetManagerInterface.php
index 70e6bd5..4131af3 100644
--- a/src/Spout/Writer/Common/Manager/WorksheetManagerInterface.php
+++ b/src/Spout/Writer/Common/Manager/WorksheetManagerInterface.php
@@ -2,7 +2,7 @@
 
 namespace Box\Spout\Writer\Common\Manager;
 
-use Box\Spout\Writer\Common\Entity\Style\Style;
+use Box\Spout\Writer\Common\Entity\Row;
 use Box\Spout\Writer\Common\Entity\Worksheet;
 
 /**
@@ -12,17 +12,15 @@ use Box\Spout\Writer\Common\Entity\Worksheet;
 interface WorksheetManagerInterface
 {
     /**
-     * Adds data to the worksheet.
+     * Adds a row to the worksheet.
      *
      * @param Worksheet $worksheet The worksheet to add the row to
-     * @param array $dataRow Array containing data to be written. Cannot be empty.
-     *          Example $dataRow = ['data1', 1234, null, '', 'data5'];
-     * @param Style $rowStyle Style to be applied to the row. NULL means use default style.
+     * @param Row $row The row to be added
      * @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
      * @return void
      */
-    public function addRow(Worksheet $worksheet, $dataRow, $rowStyle);
+    public function addRow(Worksheet $worksheet, Row $row);
 
     /**
      * Prepares the worksheet to accept data
diff --git a/src/Spout/Writer/ODS/Creator/ManagerFactory.php b/src/Spout/Writer/ODS/Creator/ManagerFactory.php
index ca84657..7624c4c 100644
--- a/src/Spout/Writer/ODS/Creator/ManagerFactory.php
+++ b/src/Spout/Writer/ODS/Creator/ManagerFactory.php
@@ -46,7 +46,7 @@ class ManagerFactory implements ManagerFactoryInterface
         $fileSystemHelper->createBaseFilesAndFolders();
 
         $styleManager = $this->createStyleManager($optionsManager);
-        $worksheetManager = $this->createWorksheetManager();
+        $worksheetManager = $this->createWorksheetManager($styleManager);
 
         return new WorkbookManager(
             $workbook,
@@ -60,14 +60,15 @@ class ManagerFactory implements ManagerFactoryInterface
     }
 
     /**
+     * @param StyleManager $styleManager
      * @return WorksheetManager
      */
-    private function createWorksheetManager()
+    private function createWorksheetManager(StyleManager $styleManager)
     {
         $stringsEscaper = $this->helperFactory->createStringsEscaper();
         $stringsHelper = $this->helperFactory->createStringHelper();
 
-        return new WorksheetManager($stringsEscaper, $stringsHelper, $this->entityFactory);
+        return new WorksheetManager($styleManager, $stringsEscaper, $stringsHelper);
     }
 
     /**
diff --git a/src/Spout/Writer/ODS/Manager/WorksheetManager.php b/src/Spout/Writer/ODS/Manager/WorksheetManager.php
index a0562b2..7b44e35 100644
--- a/src/Spout/Writer/ODS/Manager/WorksheetManager.php
+++ b/src/Spout/Writer/ODS/Manager/WorksheetManager.php
@@ -4,12 +4,14 @@ namespace Box\Spout\Writer\ODS\Manager;
 
 use Box\Spout\Common\Exception\InvalidArgumentException;
 use Box\Spout\Common\Exception\IOException;
+use Box\Spout\Common\Helper\Escaper\ODS as ODSEscaper;
 use Box\Spout\Common\Helper\StringHelper;
-use Box\Spout\Writer\Common\Creator\EntityFactory;
 use Box\Spout\Writer\Common\Entity\Cell;
+use Box\Spout\Writer\Common\Entity\Row;
 use Box\Spout\Writer\Common\Entity\Style\Style;
 use Box\Spout\Writer\Common\Entity\Worksheet;
 use Box\Spout\Writer\Common\Manager\WorksheetManagerInterface;
+use Box\Spout\Writer\ODS\Manager\Style\StyleManager;
 
 /**
  * Class WorksheetManager
@@ -23,24 +25,24 @@ class WorksheetManager implements WorksheetManagerInterface
     /** @var StringHelper String helper */
     private $stringHelper;
 
-    /** @var EntityFactory Factory to create entities */
-    private $entityFactory;
+    /** @var StyleManager Manages styles */
+    private $styleManager;
 
     /**
      * WorksheetManager constructor.
      *
-     * @param \Box\Spout\Common\Helper\Escaper\ODS $stringsEscaper
+     * @param StyleManager $styleManager
+     * @param ODSEscaper $stringsEscaper
      * @param StringHelper $stringHelper
-     * @param EntityFactory $entityFactory
      */
     public function __construct(
-        \Box\Spout\Common\Helper\Escaper\ODS $stringsEscaper,
-        StringHelper $stringHelper,
-        EntityFactory $entityFactory
+        StyleManager $styleManager,
+        ODSEscaper $stringsEscaper,
+        StringHelper $stringHelper
     ) {
+        $this->styleManager = $styleManager;
         $this->stringsEscaper = $stringsEscaper;
         $this->stringHelper = $stringHelper;
-        $this->entityFactory = $entityFactory;
     }
 
     /**
@@ -91,24 +93,19 @@ class WorksheetManager implements WorksheetManagerInterface
     }
 
     /**
-     * Adds data to the given worksheet.
+     * Adds a row to the given worksheet.
      *
      * @param Worksheet $worksheet The worksheet to add the row to
-     * @param array $dataRow Array containing data to be written. Cannot be empty.
-     *          Example $dataRow = ['data1', 1234, null, '', 'data5'];
-     * @param Style $rowStyle Style to be applied to the row. NULL means use default style.
+     * @param Row $row The row to be added
      * @throws IOException If the data cannot be written
      * @throws InvalidArgumentException If a cell value's type is not supported
      * @return void
      */
-    public function addRow(Worksheet $worksheet, $dataRow, $rowStyle)
+    public function addRow(Worksheet $worksheet, Row $row)
     {
-        // $dataRow can be an associative array. We need to transform
-        // it into a regular array, as we'll use the numeric indexes.
-        $dataRowWithNumericIndexes = array_values($dataRow);
-
-        $styleIndex = ($rowStyle->getId() + 1); // 1-based
-        $cellsCount = count($dataRow);
+        $cells = $row->getCells();
+        $cellsCount = count($cells);
+        $rowStyle = $row->getStyle();
 
         $data = '<table:table-row table:style-name="ro1">';
 
@@ -116,14 +113,13 @@ class WorksheetManager implements WorksheetManagerInterface
         $nextCellIndex = 1;
 
         for ($i = 0; $i < $cellsCount; $i++) {
-            $currentCellValue = $dataRowWithNumericIndexes[$currentCellIndex];
-
-            // Using isset here because it is way faster than array_key_exists...
-            if (!isset($dataRowWithNumericIndexes[$nextCellIndex]) ||
-                $currentCellValue !== $dataRowWithNumericIndexes[$nextCellIndex]) {
-                $numTimesValueRepeated = ($nextCellIndex - $currentCellIndex);
-                $data .= $this->getCellXML($currentCellValue, $styleIndex, $numTimesValueRepeated);
+            /** @var Cell $cell */
+            $cell = $cells[$currentCellIndex];
+            /** @var Cell|null $nextCell */
+            $nextCell = isset($cells[$nextCellIndex]) ? $cells[$nextCellIndex] : null;
 
+            if ($nextCell === null || $cell->getValue() !== $nextCell->getValue()) {
+                $data .= $this->applyStyleAndGetCellXML($cell, $rowStyle, $currentCellIndex, $nextCellIndex);
                 $currentCellIndex = $nextCellIndex;
             }
 
@@ -142,16 +138,40 @@ class WorksheetManager implements WorksheetManagerInterface
         $worksheet->setLastWrittenRowIndex($lastWrittenRowIndex + 1);
     }
 
+    /**
+     * Applies styles to the given style, merging the cell's style with its row's style
+     * Then builds and returns xml for the cell.
+     *
+     * @param Cell $cell
+     * @param Style $rowStyle
+     * @param int $currentCellIndex
+     * @param int $nextCellIndex
+     * @throws InvalidArgumentException If a cell value's type is not supported
+     * @return string
+     */
+    private function applyStyleAndGetCellXML(Cell $cell, Style $rowStyle, $currentCellIndex, $nextCellIndex)
+    {
+        // Apply styles - the row style is merged at this point
+        $cell->applyStyle($rowStyle);
+        $this->styleManager->applyExtraStylesIfNeeded($cell);
+        $registeredStyle = $this->styleManager->registerStyle($cell->getStyle());
+        $styleIndex = $registeredStyle->getId() + 1; // 1-based
+
+        $numTimesValueRepeated = ($nextCellIndex - $currentCellIndex);
+
+        return $this->getCellXML($cell, $styleIndex, $numTimesValueRepeated);
+    }
+
     /**
      * Returns the cell XML content, given its value.
      *
-     * @param mixed $cellValue The value to be written
+     * @param Cell $cell The cell to be written
      * @param int $styleIndex Index of the used style
      * @param int $numTimesValueRepeated Number of times the value is consecutively repeated
-     * @throws \Box\Spout\Common\Exception\InvalidArgumentException If a cell value's type is not supported
+     * @throws InvalidArgumentException If a cell value's type is not supported
      * @return string The cell XML content
      */
-    private function getCellXML($cellValue, $styleIndex, $numTimesValueRepeated)
+    private function getCellXML(Cell $cell, $styleIndex, $numTimesValueRepeated)
     {
         $data = '<table:table-cell table:style-name="ce' . $styleIndex . '"';
 
@@ -159,13 +179,6 @@ class WorksheetManager implements WorksheetManagerInterface
             $data .= ' table:number-columns-repeated="' . $numTimesValueRepeated . '"';
         }
 
-        /* @TODO Remove code duplication with XLSX writer: https://github.com/box/spout/pull/383#discussion_r113292746 */
-        if ($cellValue instanceof Cell) {
-            $cell = $cellValue;
-        } else {
-            $cell = $this->entityFactory->createCell($cellValue);
-        }
-
         if ($cell->isString()) {
             $data .= ' office:value-type="string" calcext:value-type="string">';
 
diff --git a/src/Spout/Writer/WriterAbstract.php b/src/Spout/Writer/WriterAbstract.php
index 0cdebf4..062d71c 100644
--- a/src/Spout/Writer/WriterAbstract.php
+++ b/src/Spout/Writer/WriterAbstract.php
@@ -9,6 +9,7 @@ use Box\Spout\Common\Exception\SpoutException;
 use Box\Spout\Common\Helper\GlobalFunctionsHelper;
 use Box\Spout\Common\Manager\OptionsManagerInterface;
 use Box\Spout\Writer\Common\Entity\Options;
+use Box\Spout\Writer\Common\Entity\Row;
 use Box\Spout\Writer\Common\Entity\Style\Style;
 use Box\Spout\Writer\Common\Manager\Style\StyleMerger;
 use Box\Spout\Writer\Exception\WriterAlreadyOpenedException;
@@ -42,9 +43,6 @@ abstract class WriterAbstract implements WriterInterface
     /** @var StyleMerger Helps merge styles together */
     protected $styleMerger;
 
-    /** @var Style Style to be applied to the next written row(s) */
-    protected $rowStyle;
-
     /** @var string Content-Type value for the header - to be defined by child class */
     protected static $headerContentType;
 
@@ -64,27 +62,25 @@ abstract class WriterAbstract implements WriterInterface
         $this->styleMerger = $styleMerger;
         $this->globalFunctionsHelper = $globalFunctionsHelper;
         $this->helperFactory = $helperFactory;
-
-        $this->resetRowStyleToDefault();
     }
 
     /**
      * Opens the streamer and makes it ready to accept data.
      *
-     * @throws \Box\Spout\Common\Exception\IOException If the writer cannot be opened
+     * @throws IOException If the writer cannot be opened
      * @return void
      */
     abstract protected function openWriter();
 
     /**
-     * Adds data to the currently openned writer.
+     * Adds a row to the currently opened writer.
      *
-     * @param  array $dataRow Array containing data to be streamed.
-     *          Example $dataRow = ['data1', 1234, null, '', 'data5'];
-     * @param Style $style Style to be applied to the written row
+     * @param Row $row The row containing cells and styles
+     * @throws WriterNotOpenedException If the workbook is not created yet
+     * @throws IOException If unable to write data
      * @return void
      */
-    abstract protected function addRowToWriter(array $dataRow, $style);
+    abstract protected function addRowToWriter(Row $row);
 
     /**
      * Closes the streamer, preventing any additional writing.
@@ -94,29 +90,17 @@ abstract class WriterAbstract implements WriterInterface
     abstract protected function closeWriter();
 
     /**
-     * Sets the default styles for all rows added with "addRow".
-     * Overriding the default style instead of using "addRowWithStyle" improves performance by 20%.
-     * @see https://github.com/box/spout/issues/272
-     *
-     * @param Style $defaultStyle
-     * @return WriterAbstract
+     * {@inheritdoc}
      */
-    public function setDefaultRowStyle($defaultStyle)
+    public function setDefaultRowStyle(Style $defaultStyle)
     {
         $this->optionsManager->setOption(Options::DEFAULT_ROW_STYLE, $defaultStyle);
-        $this->resetRowStyleToDefault();
 
         return $this;
     }
 
     /**
-     * Inits the writer and opens it to accept data.
-     * By using this method, the data will be written to a file.
-     *
-     * @api
-     * @param  string $outputFilePath Path of the output file that will contain the data
-     * @throws \Box\Spout\Common\Exception\IOException If the writer cannot be opened or if the given path is not writable
-     * @return WriterAbstract
+     * {@inheritdoc}
      */
     public function openToFile($outputFilePath)
     {
@@ -132,15 +116,8 @@ abstract class WriterAbstract 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
-     *
-     * @api
-     * @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
-     * @throws \Box\Spout\Common\Exception\IOException If the writer cannot be opened
-     * @return WriterAbstract
+     * {@inheritdoc}
      */
     public function openToBrowser($outputFileName)
     {
@@ -177,7 +154,7 @@ abstract class WriterAbstract implements WriterInterface
      * Checks if the pointer to the file/stream to write to is available.
      * Will throw an exception if not available.
      *
-     * @throws \Box\Spout\Common\Exception\IOException If the pointer is not available
+     * @throws IOException If the pointer is not available
      * @return void
      */
     protected function throwIfFilePointerIsNotAvailable()
@@ -192,7 +169,7 @@ abstract class WriterAbstract implements WriterInterface
      * Throws an exception if already opened.
      *
      * @param string $message Error message
-     * @throws \Box\Spout\Writer\Exception\WriterAlreadyOpenedException If the writer was already opened and must not be.
+     * @throws WriterAlreadyOpenedException If the writer was already opened and must not be.
      * @return void
      */
     protected function throwIfWriterAlreadyOpened($message)
@@ -203,24 +180,16 @@ abstract class WriterAbstract implements WriterInterface
     }
 
     /**
-     * Write given data to the output. New data will be appended to end of stream.
-     *
-     * @param  array $dataRow Array containing data to be streamed.
-     *                        If empty, no data is added (i.e. not even as a blank row)
-     *                        Example: $dataRow = ['data1', 1234, null, '', 'data5', false];
-     * @api
-     * @throws \Box\Spout\Writer\Exception\WriterNotOpenedException If this function is called before opening the writer
-     * @throws \Box\Spout\Common\Exception\IOException If unable to write data
-     * @throws \Box\Spout\Common\Exception\SpoutException If anything else goes wrong while writing data
-     * @return WriterAbstract
+     * {@inheritdoc}
      */
-    public function addRow(array $dataRow)
+    public function addRow(Row $row)
     {
         if ($this->isWriterOpened) {
             // empty $dataRow should not add an empty line
-            if (!empty($dataRow)) {
+            if ($row->hasCells()) {
                 try {
-                    $this->addRowToWriter($dataRow, $this->rowStyle);
+                    $this->applyDefaultRowStyle($row);
+                    $this->addRowToWriter($row);
                 } catch (SpoutException $e) {
                     // if an exception occurs while writing data,
                     // close the writer and remove all files created so far.
@@ -238,116 +207,41 @@ abstract class WriterAbstract implements WriterInterface
     }
 
     /**
-     * Write given data to the output and apply the given style.
-     * @see addRow
-     *
-     * @api
-     * @param array $dataRow Array of array containing data to be streamed.
-     * @param Style $style Style to be applied to the row.
-     * @throws \Box\Spout\Common\Exception\InvalidArgumentException If the input param is not valid
-     * @throws \Box\Spout\Writer\Exception\WriterNotOpenedException If this function is called before opening the writer
-     * @throws \Box\Spout\Common\Exception\IOException If unable to write data
-     * @return WriterAbstract
+     * {@inheritdoc}
      */
-    public function addRowWithStyle(array $dataRow, $style)
+    public function addRows(array $rows)
     {
-        if (!$style instanceof Style) {
-            throw new InvalidArgumentException('The "$style" argument must be a Style instance and cannot be NULL.');
-        }
-
-        $this->setRowStyle($style);
-        $this->addRow($dataRow);
-        $this->resetRowStyleToDefault();
-
-        return $this;
-    }
-
-    /**
-     * Write given data to the output. New data will be appended to end of stream.
-     *
-     * @api
-     * @param  array $dataRows Array of array containing data to be streamed.
-     *                         If a row is empty, it won't be added (i.e. not even as a blank row)
-     *                         Example: $dataRows = [
-     *                             ['data11', 12, , '', 'data13'],
-     *                             ['data21', 'data22', null, false],
-     *                         ];
-     * @throws \Box\Spout\Common\Exception\InvalidArgumentException If the input param is not valid
-     * @throws \Box\Spout\Writer\Exception\WriterNotOpenedException If this function is called before opening the writer
-     * @throws \Box\Spout\Common\Exception\IOException If unable to write data
-     * @return WriterAbstract
-     */
-    public function addRows(array $dataRows)
-    {
-        if (!empty($dataRows)) {
-            $firstRow = reset($dataRows);
-            if (!is_array($firstRow)) {
-                throw new InvalidArgumentException('The input should be an array of arrays');
+        foreach ($rows as $row) {
+            if (!$row instanceof Row) {
+                $this->closeAndAttemptToCleanupAllFiles();
+                throw new InvalidArgumentException('The input should be an array of Row');
             }
 
-            foreach ($dataRows as $dataRow) {
-                $this->addRow($dataRow);
-            }
+            $this->addRow($row);
         }
 
         return $this;
     }
 
     /**
-     * Write given data to the output and apply the given style.
-     * @see addRows
+     * @TODO: Move this into styleMerger
      *
-     * @api
-     * @param array $dataRows Array of array containing data to be streamed.
-     * @param Style $style Style to be applied to the rows.
-     * @throws \Box\Spout\Common\Exception\InvalidArgumentException If the input param is not valid
-     * @throws \Box\Spout\Writer\Exception\WriterNotOpenedException If this function is called before opening the writer
-     * @throws \Box\Spout\Common\Exception\IOException If unable to write data
-     * @return WriterAbstract
+     * @param Row $row
+     * @return $this
      */
-    public function addRowsWithStyle(array $dataRows, $style)
+    private function applyDefaultRowStyle(Row $row)
     {
-        if (!$style instanceof Style) {
-            throw new InvalidArgumentException('The "$style" argument must be a Style instance and cannot be NULL.');
-        }
-
-        $this->setRowStyle($style);
-        $this->addRows($dataRows);
-        $this->resetRowStyleToDefault();
-
-        return $this;
-    }
-
-    /**
-     * Sets the style to be applied to the next written rows
-     * until it is changed or reset.
-     *
-     * @param Style $style
-     * @return void
-     */
-    private function setRowStyle($style)
-    {
-        // Merge given style with the default one to inherit custom properties
         $defaultRowStyle = $this->optionsManager->getOption(Options::DEFAULT_ROW_STYLE);
-        $this->rowStyle = $this->styleMerger->merge($style, $defaultRowStyle);
+        if ($defaultRowStyle === null) {
+            return $this;
+        }
+
+        $mergedStyle = $this->styleMerger->merge($row->getStyle(), $defaultRowStyle);
+        $row->setStyle($mergedStyle);
     }
 
     /**
-     * Resets the style to be applied to the next written rows.
-     *
-     * @return void
-     */
-    private function resetRowStyleToDefault()
-    {
-        $this->rowStyle = $this->optionsManager->getOption(Options::DEFAULT_ROW_STYLE);
-    }
-
-    /**
-     * Closes the writer. This will close the streamer as well, preventing new data
-     * to be written to the file.
-     *
-     * @api
-     * @return void
+     * {@inheritdoc}
      */
     public function close()
     {
diff --git a/src/Spout/Writer/WriterInterface.php b/src/Spout/Writer/WriterInterface.php
index 375dbd9..4e14e8e 100644
--- a/src/Spout/Writer/WriterInterface.php
+++ b/src/Spout/Writer/WriterInterface.php
@@ -2,6 +2,7 @@
 
 namespace Box\Spout\Writer;
 
+use Box\Spout\Writer\Common\Entity\Row;
 use Box\Spout\Writer\Common\Entity\Style\Style;
 
 /**
@@ -10,7 +11,7 @@ use Box\Spout\Writer\Common\Entity\Style\Style;
 interface WriterInterface
 {
     /**
-     * Inits the writer and opens it to accept data.
+     * Initializes the writer and opens it to accept data.
      * By using this method, the data will be written to a file.
      *
      * @param  string $outputFilePath Path of the output file that will contain the data
@@ -20,7 +21,7 @@ interface WriterInterface
     public function openToFile($outputFilePath);
 
     /**
-     * Inits the writer and opens it to accept data.
+     * Initializes the writer and opens it to accept data.
      * By using this method, the data will be outputted directly to the browser.
      *
      * @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
@@ -30,56 +31,35 @@ interface WriterInterface
     public function openToBrowser($outputFileName);
 
     /**
-     * Write given data to the output. New data will be appended to end of stream.
+     * Sets the default styles for all rows added with "addRow".
+     * Overriding the default style instead of using "addRowWithStyle" improves performance by 20%.
+     * @see https://github.com/box/spout/issues/272
      *
-     * @param  array $dataRow Array containing data to be streamed.
-     *          Example $dataRow = ['data1', 1234, null, '', 'data5'];
+     * @param Style $defaultStyle
+     * @return WriterInterface
+     */
+    public function setDefaultRowStyle(Style $defaultStyle);
+
+    /**
+     * Appends a row to the end of the stream.
+     *
+     * @param Row $row The row to be appended to the stream
      * @throws \Box\Spout\Writer\Exception\WriterNotOpenedException If the writer has not been opened yetthe writer
      * @throws \Box\Spout\Common\Exception\IOException If unable to write data
      * @return WriterInterface
      */
-    public function addRow(array $dataRow);
+    public function addRow(Row $row);
 
     /**
-     * Write given data to the output and apply the given style.
-     * @see addRow
+     * Appends the rows to the end of the stream.
      *
-     * @param array $dataRow Array of array containing data to be streamed.
-     * @param Style $style Style to be applied to the row.
-     * @throws \Box\Spout\Common\Exception\InvalidArgumentException If the input param is not valid
-     * @throws \Box\Spout\Writer\Exception\WriterNotOpenedException If this function is called before opening the writer
-     * @throws \Box\Spout\Common\Exception\IOException If unable to write data
-     * @return WriterInterface
-     */
-    public function addRowWithStyle(array $dataRow, $style);
-
-    /**
-     * Write given data to the output. New data will be appended to end of stream.
-     *
-     * @param  array $dataRows Array of array containing data to be streamed.
-     *          Example $dataRow = [
-     *              ['data11', 12, , '', 'data13'],
-     *              ['data21', 'data22', null],
-     *          ];
+     * @param Row[] $rows The rows to be appended to the stream
      * @throws \Box\Spout\Common\Exception\InvalidArgumentException If the input param is not valid
      * @throws \Box\Spout\Writer\Exception\WriterNotOpenedException If the writer has not been opened yet
      * @throws \Box\Spout\Common\Exception\IOException If unable to write data
      * @return WriterInterface
      */
-    public function addRows(array $dataRows);
-
-    /**
-     * Write given data to the output and apply the given style.
-     * @see addRows
-     *
-     * @param array $dataRows Array of array containing data to be streamed.
-     * @param Style $style Style to be applied to the rows.
-     * @throws \Box\Spout\Common\Exception\InvalidArgumentException If the input param is not valid
-     * @throws \Box\Spout\Writer\Exception\WriterNotOpenedException If this function is called before opening the writer
-     * @throws \Box\Spout\Common\Exception\IOException If unable to write data
-     * @return WriterInterface
-     */
-    public function addRowsWithStyle(array $dataRows, $style);
+    public function addRows(array $rows);
 
     /**
      * Closes the writer. This will close the streamer as well, preventing new data
diff --git a/src/Spout/Writer/WriterMultiSheetsAbstract.php b/src/Spout/Writer/WriterMultiSheetsAbstract.php
index 763df12..5082f09 100644
--- a/src/Spout/Writer/WriterMultiSheetsAbstract.php
+++ b/src/Spout/Writer/WriterMultiSheetsAbstract.php
@@ -7,6 +7,7 @@ use Box\Spout\Common\Helper\GlobalFunctionsHelper;
 use Box\Spout\Common\Manager\OptionsManagerInterface;
 use Box\Spout\Writer\Common\Creator\ManagerFactoryInterface;
 use Box\Spout\Writer\Common\Entity\Options;
+use Box\Spout\Writer\Common\Entity\Row;
 use Box\Spout\Writer\Common\Entity\Sheet;
 use Box\Spout\Writer\Common\Entity\Worksheet;
 use Box\Spout\Writer\Common\Manager\Style\StyleMerger;
@@ -65,10 +66,7 @@ abstract class WriterMultiSheetsAbstract extends WriterAbstract
     }
 
     /**
-     * Configures the write and sets the current sheet pointer to a new sheet.
-     *
-     * @throws \Box\Spout\Common\Exception\IOException If unable to open the file for writing
-     * @return void
+     * {@inheritdoc}
      */
     protected function openWriter()
     {
@@ -159,27 +157,16 @@ abstract class WriterMultiSheetsAbstract extends WriterAbstract
     }
 
     /**
-     * Adds data to the currently opened writer.
-     * If shouldCreateNewSheetsAutomatically option is set to true, it will handle pagination
-     * with the creation of new worksheets if one worksheet has reached its maximum capicity.
-     *
-     * @param array $dataRow Array containing data to be written.
-     *          Example $dataRow = ['data1', 1234, null, '', 'data5'];
-     * @param \Box\Spout\Writer\Common\Entity\Style\Style $style Style to be applied to the row.
-     * @throws WriterNotOpenedException If the book is not created yet
-     * @throws \Box\Spout\Common\Exception\IOException If unable to write data
-     * @return void
+     * {@inheritdoc}
      */
-    protected function addRowToWriter(array $dataRow, $style)
+    protected function addRowToWriter(Row $row)
     {
         $this->throwIfWorkbookIsNotAvailable();
-        $this->workbookManager->addRowToCurrentWorksheet($dataRow, $style);
+        $this->workbookManager->addRowToCurrentWorksheet($row);
     }
 
     /**
-     * Closes the writer, preventing any additional writing.
-     *
-     * @return void
+     * {@inheritdoc}
      */
     protected function closeWriter()
     {
diff --git a/src/Spout/Writer/XLSX/Manager/WorksheetManager.php b/src/Spout/Writer/XLSX/Manager/WorksheetManager.php
index 8eb39f2..0363f7c 100644
--- a/src/Spout/Writer/XLSX/Manager/WorksheetManager.php
+++ b/src/Spout/Writer/XLSX/Manager/WorksheetManager.php
@@ -4,11 +4,13 @@ namespace Box\Spout\Writer\XLSX\Manager;
 
 use Box\Spout\Common\Exception\InvalidArgumentException;
 use Box\Spout\Common\Exception\IOException;
+use Box\Spout\Common\Helper\Escaper\XLSX as XLSXEscaper;
 use Box\Spout\Common\Helper\StringHelper;
 use Box\Spout\Common\Manager\OptionsManagerInterface;
 use Box\Spout\Writer\Common\Creator\EntityFactory;
 use Box\Spout\Writer\Common\Entity\Cell;
 use Box\Spout\Writer\Common\Entity\Options;
+use Box\Spout\Writer\Common\Entity\Row;
 use Box\Spout\Writer\Common\Entity\Style\Style;
 use Box\Spout\Writer\Common\Entity\Worksheet;
 use Box\Spout\Writer\Common\Helper\CellHelper;
@@ -43,7 +45,7 @@ EOD;
     /** @var SharedStringsManager Helper to write shared strings */
     private $sharedStringsManager;
 
-    /** @var \Box\Spout\Common\Helper\Escaper\XLSX Strings escaper */
+    /** @var XLSXEscaper Strings escaper */
     private $stringsEscaper;
 
     /** @var StringHelper String helper */
@@ -58,7 +60,7 @@ EOD;
      * @param OptionsManagerInterface $optionsManager
      * @param StyleManager $styleManager
      * @param SharedStringsManager $sharedStringsManager
-     * @param \Box\Spout\Common\Helper\Escaper\XLSX $stringsEscaper
+     * @param XLSXEscaper $stringsEscaper
      * @param StringHelper $stringHelper
      * @param EntityFactory $entityFactory
      */
@@ -66,7 +68,7 @@ EOD;
         OptionsManagerInterface $optionsManager,
         StyleManager $styleManager,
         SharedStringsManager $sharedStringsManager,
-        \Box\Spout\Common\Helper\Escaper\XLSX $stringsEscaper,
+        XLSXEscaper $stringsEscaper,
         StringHelper $stringHelper,
         EntityFactory $entityFactory
     ) {
@@ -87,11 +89,7 @@ EOD;
     }
 
     /**
-     * Prepares the worksheet to accept data
-     *
-     * @param Worksheet $worksheet The worksheet to start
-     * @throws \Box\Spout\Common\Exception\IOException If the sheet data file cannot be opened for writing
-     * @return void
+     * {@inheritdoc}
      */
     public function startSheet(Worksheet $worksheet)
     {
@@ -119,61 +117,38 @@ EOD;
     }
 
     /**
-     * Adds data to the given worksheet.
-     *
-     * @param Worksheet $worksheet The worksheet to add the row to
-     * @param array $dataRow Array containing data to be written. Cannot be empty.
-     *          Example $dataRow = ['data1', 1234, null, '', 'data5'];
-     * @param Style $rowStyle Style to be applied to the row. NULL means use default style.
-     * @throws IOException If the data cannot be written
-     * @throws InvalidArgumentException If a cell value's type is not supported
-     * @return void
+     * {@inheritdoc}
      */
-    public function addRow(Worksheet $worksheet, $dataRow, $rowStyle)
+    public function addRow(Worksheet $worksheet, Row $row)
     {
-        if (!$this->isEmptyRow($dataRow)) {
-            $this->addNonEmptyRow($worksheet, $dataRow, $rowStyle);
+        if (!$row->isEmpty()) {
+            $this->addNonEmptyRow($worksheet, $row);
         }
 
         $worksheet->setLastWrittenRowIndex($worksheet->getLastWrittenRowIndex() + 1);
     }
 
-    /**
-     * Returns whether the given row is empty
-     *
-     * @param array $dataRow Array containing data to be written. Cannot be empty.
-     *          Example $dataRow = ['data1', 1234, null, '', 'data5'];
-     * @return bool Whether the given row is empty
-     */
-    private function isEmptyRow($dataRow)
-    {
-        $numCells = count($dataRow);
-        // using "reset()" instead of "$dataRow[0]" because $dataRow can be an associative array
-        return ($numCells === 1 && CellHelper::isEmpty(reset($dataRow)));
-    }
-
     /**
      * Adds non empty row to the worksheet.
      *
      * @param Worksheet $worksheet The worksheet to add the row to
-     * @param array $dataRow Array containing data to be written. Cannot be empty.
-     *          Example $dataRow = ['data1', 1234, null, '', 'data5'];
-     * @param \Box\Spout\Writer\Common\Entity\Style\Style $style Style to be applied to the row. NULL means use default style.
-     * @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
+     * @param Row $row The row to be written
+     * @throws IOException If the data cannot be written
+     * @throws InvalidArgumentException If a cell value's type is not supported
      * @return void
      */
-    private function addNonEmptyRow(Worksheet $worksheet, $dataRow, $style)
+    private function addNonEmptyRow(Worksheet $worksheet, Row $row)
     {
-        $cellNumber = 0;
+        $cellIndex = 0;
+        $rowStyle = $row->getStyle();
         $rowIndex = $worksheet->getLastWrittenRowIndex() + 1;
-        $numCells = count($dataRow);
+        $numCells = count($row->getCells());
 
         $rowXML = '<row r="' . $rowIndex . '" spans="1:' . $numCells . '">';
 
-        foreach ($dataRow as $cellValue) {
-            $rowXML .= $this->getCellXML($rowIndex, $cellNumber, $cellValue, $style->getId());
-            $cellNumber++;
+        foreach ($row->getCells() as $cell) {
+            $rowXML .= $this->applyStyleAndGetCellXML($cell, $rowStyle, $rowIndex, $cellIndex);
+            $cellIndex++;
         }
 
         $rowXML .= '</row>';
@@ -185,28 +160,42 @@ EOD;
     }
 
     /**
-     * Build and return xml for a single cell.
+     * Applies styles to the given style, merging the cell's style with its row's style
+     * Then builds and returns xml for the cell.
+     *
+     * @param Cell $cell
+     * @param Style $rowStyle
+     * @param int $rowIndex
+     * @param int $cellIndex
+     * @throws InvalidArgumentException If the given value cannot be processed
+     * @return string
+     */
+    private function applyStyleAndGetCellXML(Cell $cell, Style $rowStyle, $rowIndex, $cellIndex)
+    {
+        // Apply styles - the row style is merged at this point
+        $cell->applyStyle($rowStyle);
+        $this->styleManager->applyExtraStylesIfNeeded($cell);
+        $registeredStyle = $this->styleManager->registerStyle($cell->getStyle());
+
+        return $this->getCellXML($rowIndex, $cellIndex, $cell, $registeredStyle->getId());
+    }
+
+    /**
+     * Builds and returns xml for a single cell.
      *
      * @param int $rowIndex
      * @param int $cellNumber
-     * @param mixed $cellValue
+     * @param Cell $cell
      * @param int $styleId
      * @throws InvalidArgumentException If the given value cannot be processed
      * @return string
      */
-    private function getCellXML($rowIndex, $cellNumber, $cellValue, $styleId)
+    private function getCellXML($rowIndex, $cellNumber, Cell $cell, $styleId)
     {
         $columnIndex = CellHelper::getCellIndexFromColumnIndex($cellNumber);
         $cellXML = '<c r="' . $columnIndex . $rowIndex . '"';
         $cellXML .= ' s="' . $styleId . '"';
 
-        /* @TODO Remove code duplication with ODS writer: https://github.com/box/spout/pull/383#discussion_r113292746 */
-        if ($cellValue instanceof Cell) {
-            $cell = $cellValue;
-        } else {
-            $cell = $this->entityFactory->createCell($cellValue);
-        }
-
         if ($cell->isString()) {
             $cellXML .= $this->getCellXMLFragmentForNonEmptyString($cell->getValue());
         } elseif ($cell->isBoolean()) {
@@ -252,10 +241,7 @@ EOD;
     }
 
     /**
-     * Closes the worksheet
-     *
-     * @param Worksheet $worksheet
-     * @return void
+     * {@inheritdoc}
      */
     public function close(Worksheet $worksheet)
     {
diff --git a/tests/Spout/Reader/XLSX/Helper/CellValueFormatterTest.php b/tests/Spout/Reader/XLSX/Helper/CellValueFormatterTest.php
index 4167cf8..31bebd5 100644
--- a/tests/Spout/Reader/XLSX/Helper/CellValueFormatterTest.php
+++ b/tests/Spout/Reader/XLSX/Helper/CellValueFormatterTest.php
@@ -3,6 +3,7 @@
 namespace Box\Spout\Reader\XLSX\Helper;
 
 use Box\Spout\Common\Helper\Escaper;
+use Box\Spout\Reader\XLSX\Manager\StyleManager;
 
 /**
  * Class CellValueFormatterTest
@@ -61,7 +62,7 @@ class CellValueFormatterTest extends \PHPUnit_Framework_TestCase
      */
     public function testExcelDate($shouldUse1904Dates, $nodeValue, $expectedDateAsString)
     {
-        $nodeListMock = $this->getMockBuilder('DOMNodeList')->disableOriginalConstructor()->getMock();
+        $nodeListMock = $this->createMock(\DOMNodeList::class);
 
         $nodeListMock
             ->expects($this->atLeastOnce())
@@ -69,7 +70,7 @@ class CellValueFormatterTest extends \PHPUnit_Framework_TestCase
             ->with(0)
             ->will($this->returnValue((object) ['nodeValue' => $nodeValue]));
 
-        $nodeMock = $this->getMockBuilder('DOMElement')->disableOriginalConstructor()->getMock();
+        $nodeMock = $this->createMock(\DOMElement::class);
 
         $nodeMock
             ->expects($this->atLeastOnce())
@@ -85,8 +86,8 @@ class CellValueFormatterTest extends \PHPUnit_Framework_TestCase
             ->with(CellValueFormatter::XML_NODE_VALUE)
             ->will($this->returnValue($nodeListMock));
 
-        /** @var \Box\Spout\Reader\XLSX\Manager\StyleManager|\PHPUnit_Framework_MockObject_MockObject $styleManagerMock */
-        $styleManagerMock = $this->getMockBuilder('Box\Spout\Reader\XLSX\Manager\StyleManager')->disableOriginalConstructor()->getMock();
+        /** @var StyleManager|\PHPUnit_Framework_MockObject_MockObject $styleManagerMock */
+        $styleManagerMock = $this->createMock(StyleManager::class);
 
         $styleManagerMock
             ->expects($this->once())
@@ -141,8 +142,8 @@ class CellValueFormatterTest extends \PHPUnit_Framework_TestCase
      */
     public function testFormatNumericCellValueWithNumbers($value, $expectedFormattedValue, $expectedType)
     {
-        /** @var \Box\Spout\Reader\XLSX\Manager\StyleManager|\PHPUnit_Framework_MockObject_MockObject $styleManagerMock */
-        $styleManagerMock = $this->getMockBuilder('Box\Spout\Reader\XLSX\Manager\StyleManager')->disableOriginalConstructor()->getMock();
+        /** @var StyleManager|\PHPUnit_Framework_MockObject_MockObject $styleManagerMock */
+        $styleManagerMock = $this->createMock(StyleManager::class);
         $styleManagerMock
             ->expects($this->once())
             ->method('shouldFormatNumericValueAsDate')
@@ -177,14 +178,14 @@ class CellValueFormatterTest extends \PHPUnit_Framework_TestCase
      */
     public function testFormatInlineStringCellValue($value, $expectedFormattedValue)
     {
-        $nodeListMock = $this->getMockBuilder('DOMNodeList')->disableOriginalConstructor()->getMock();
+        $nodeListMock = $this->createMock(\DOMNodeList::class);
         $nodeListMock
             ->expects($this->atLeastOnce())
             ->method('item')
             ->with(0)
             ->will($this->returnValue((object) ['nodeValue' => $value]));
 
-        $nodeMock = $this->getMockBuilder('DOMElement')->disableOriginalConstructor()->getMock();
+        $nodeMock = $this->createMock(\DOMElement::class);
         $nodeMock
             ->expects($this->atLeastOnce())
             ->method('getElementsByTagName')
diff --git a/tests/Spout/Writer/CSV/WriterTest.php b/tests/Spout/Writer/CSV/WriterTest.php
index 4f679c0..f895108 100644
--- a/tests/Spout/Writer/CSV/WriterTest.php
+++ b/tests/Spout/Writer/CSV/WriterTest.php
@@ -5,7 +5,8 @@ namespace Box\Spout\Writer\CSV;
 use Box\Spout\Common\Helper\EncodingHelper;
 use Box\Spout\Common\Type;
 use Box\Spout\TestUsingResource;
-use Box\Spout\Writer\Common\Entity\Cell;
+use Box\Spout\Writer\Common\Entity\Row;
+use Box\Spout\Writer\RowCreationHelper;
 use Box\Spout\Writer\WriterFactory;
 
 /**
@@ -14,6 +15,7 @@ use Box\Spout\Writer\WriterFactory;
 class WriterTest extends \PHPUnit_Framework_TestCase
 {
     use TestUsingResource;
+    use RowCreationHelper;
 
     /**
      * @expectedException \Box\Spout\Common\Exception\IOException
@@ -26,7 +28,7 @@ class WriterTest extends \PHPUnit_Framework_TestCase
 
         $writer = WriterFactory::create(Type::CSV);
         @$writer->openToFile($filePath);
-        $writer->addRow(['csv--11', 'csv--12']);
+        $writer->addRow($this->createRowFromValues(['csv--11', 'csv--12']));
         $writer->close();
     }
 
@@ -36,7 +38,7 @@ class WriterTest extends \PHPUnit_Framework_TestCase
     public function testWriteShouldThrowExceptionIfCallAddRowBeforeOpeningWriter()
     {
         $writer = WriterFactory::create(Type::CSV);
-        $writer->addRow(['csv--11', 'csv--12']);
+        $writer->addRow($this->createRowFromValues(['csv--11', 'csv--12']));
         $writer->close();
     }
 
@@ -46,7 +48,7 @@ class WriterTest extends \PHPUnit_Framework_TestCase
     public function testWriteShouldThrowExceptionIfCallAddRowsBeforeOpeningWriter()
     {
         $writer = WriterFactory::create(Type::CSV);
-        $writer->addRows([['csv--11', 'csv--12']]);
+        $writer->addRow($this->createRowFromValues(['csv--11', 'csv--12']));
         $writer->close();
     }
 
@@ -56,7 +58,7 @@ class WriterTest extends \PHPUnit_Framework_TestCase
     public function testAddRowsShouldThrowExceptionIfRowsAreNotArrayOfArrays()
     {
         $writer = WriterFactory::create(Type::CSV);
-        $writer->addRows(['csv--11', 'csv--12']);
+        $writer->addRows([['csv--11', 'csv--12']]);
         $writer->close();
     }
 
@@ -82,9 +84,9 @@ class WriterTest extends \PHPUnit_Framework_TestCase
      */
     public function testWriteShouldAddUtf8Bom()
     {
-        $allRows = [
+        $allRows = $this->createRowsFromValues([
             ['csv--11', 'csv--12'],
-        ];
+        ]);
         $writtenContent = $this->writeToCsvFileAndReturnWrittenContent($allRows, 'csv_with_utf8_bom.csv');
 
         $this->assertContains(EncodingHelper::BOM_UTF8, $writtenContent, 'The CSV file should contain a UTF-8 BOM');
@@ -95,36 +97,22 @@ class WriterTest extends \PHPUnit_Framework_TestCase
      */
     public function testWriteShouldNotAddUtf8Bom()
     {
-        $allRows = [
+        $allRows = $this->createRowsFromValues([
             ['csv--11', 'csv--12'],
-        ];
+        ]);
         $writtenContent = $this->writeToCsvFileAndReturnWrittenContent($allRows, 'csv_no_bom.csv', ',', '"', false);
 
         $this->assertNotContains(EncodingHelper::BOM_UTF8, $writtenContent, 'The CSV file should not contain a UTF-8 BOM');
     }
 
-    /**
-     * @return void
-     */
-    public function testWriteShouldSupportAssociativeArrays()
-    {
-        $allRows = [
-            ['foo' => 'csv--11', 'bar' => 'csv--12'],
-        ];
-        $writtenContent = $this->writeToCsvFileAndReturnWrittenContent($allRows, 'csv_from_associative_arrays.csv');
-        $writtenContent = $this->trimWrittenContent($writtenContent);
-
-        $this->assertEquals('csv--11,csv--12', $writtenContent, 'Values from associative arrays should be written');
-    }
-
     /**
      * @return void
      */
     public function testWriteShouldSupportNullValues()
     {
-        $allRows = [
+        $allRows = $this->createRowsFromValues([
             ['csv--11', null, 'csv--13'],
-        ];
+        ]);
         $writtenContent = $this->writeToCsvFileAndReturnWrittenContent($allRows, 'csv_with_null_values.csv');
         $writtenContent = $this->trimWrittenContent($writtenContent);
 
@@ -136,11 +124,11 @@ class WriterTest extends \PHPUnit_Framework_TestCase
      */
     public function testWriteShouldSkipEmptyRows()
     {
-        $allRows = [
+        $allRows = $this->createRowsFromValues([
             ['csv--11', 'csv--12'],
             [],
             ['csv--31', 'csv--32'],
-        ];
+        ]);
         $writtenContent = $this->writeToCsvFileAndReturnWrittenContent($allRows, 'csv_with_empty_rows.csv');
         $writtenContent = $this->trimWrittenContent($writtenContent);
 
@@ -152,10 +140,10 @@ class WriterTest extends \PHPUnit_Framework_TestCase
      */
     public function testWriteShouldSupportCustomFieldDelimiter()
     {
-        $allRows = [
+        $allRows = $this->createRowsFromValues([
             ['csv--11', 'csv--12', 'csv--13'],
             ['csv--21', 'csv--22', 'csv--23'],
-        ];
+        ]);
         $writtenContent = $this->writeToCsvFileAndReturnWrittenContent($allRows, 'csv_with_pipe_delimiters.csv', '|');
         $writtenContent = $this->trimWrittenContent($writtenContent);
 
@@ -167,9 +155,9 @@ class WriterTest extends \PHPUnit_Framework_TestCase
      */
     public function testWriteShouldSupportCustomFieldEnclosure()
     {
-        $allRows = [
+        $allRows = $this->createRowsFromValues([
             ['This is, a comma', 'csv--12', 'csv--13'],
-        ];
+        ]);
         $writtenContent = $this->writeToCsvFileAndReturnWrittenContent($allRows, 'csv_with_pound_enclosures.csv', ',', '#');
         $writtenContent = $this->trimWrittenContent($writtenContent);
 
@@ -177,20 +165,7 @@ class WriterTest extends \PHPUnit_Framework_TestCase
     }
 
     /**
-     * @return void
-     */
-    public function testWriteShouldAcceptCellObjects()
-    {
-        $allRows = [
-            [new Cell('String Value'), new Cell(1)],
-        ];
-        $writtenContent = $this->writeToCsvFileAndReturnWrittenContent($allRows, 'csv_with_cell_objects.csv');
-        $writtenContent = $this->trimWrittenContent($writtenContent);
-        $this->assertEquals('"String Value",1', $writtenContent);
-    }
-
-    /**
-     * @param array  $allRows
+     * @param Row[]  $allRows
      * @param string $fileName
      * @param string $fieldDelimiter
      * @param string $fieldEnclosure
diff --git a/tests/Spout/Writer/Common/Entity/CellTest.php b/tests/Spout/Writer/Common/Entity/CellTest.php
new file mode 100644
index 0000000..e31a0b2
--- /dev/null
+++ b/tests/Spout/Writer/Common/Entity/CellTest.php
@@ -0,0 +1,68 @@
+<?php
+
+namespace Box\Spout\Writer\Common\Entity;
+
+use Box\Spout\Writer\Common\Entity\Style\Style;
+use PHPUnit\Framework\TestCase;
+
+class CellTest extends TestCase
+{
+    /**
+     * @return void
+     */
+    public function testValidInstance()
+    {
+        $this->assertInstanceOf(Cell::class, new Cell('cell'));
+        $this->assertInstanceOf(Cell::class, new Cell('cell-with-style', $this->createMock(Style::class)));
+    }
+
+    /**
+     * @return void
+     */
+    public function testCellTypeNumeric()
+    {
+        $this->assertTrue((new Cell(0))->isNumeric());
+        $this->assertTrue((new Cell(1))->isNumeric());
+    }
+
+    /**
+     * @return void
+     */
+    public function testCellTypeString()
+    {
+        $this->assertTrue((new Cell('String!'))->isString());
+    }
+
+    /**
+     * @return void
+     */
+    public function testCellTypeEmptyString()
+    {
+        $this->assertTrue((new Cell(''))->isEmpty());
+    }
+
+    /**
+     * @return void
+     */
+    public function testCellTypeEmptyNull()
+    {
+        $this->assertTrue((new Cell(null))->isEmpty());
+    }
+
+    /**
+     * @return void
+     */
+    public function testCellTypeBool()
+    {
+        $this->assertTrue((new Cell(true))->isBoolean());
+        $this->assertTrue((new Cell(false))->isBoolean());
+    }
+
+    /**
+     * @return void
+     */
+    public function testCellTypeError()
+    {
+        $this->assertTrue((new Cell([]))->isError());
+    }
+}
diff --git a/tests/Spout/Writer/Common/Entity/RowTest.php b/tests/Spout/Writer/Common/Entity/RowTest.php
new file mode 100644
index 0000000..ff9a1c7
--- /dev/null
+++ b/tests/Spout/Writer/Common/Entity/RowTest.php
@@ -0,0 +1,114 @@
+<?php
+
+namespace Box\Spout\Writer\Common\Entity;
+
+use Box\Spout\Writer\Common\Entity\Style\Style;
+use Box\Spout\Writer\Common\Manager\RowManager;
+use PHPUnit\Framework\TestCase;
+
+class RowTest extends TestCase
+{
+    /**
+     * @return \PHPUnit_Framework_MockObject_MockObject|Style
+     */
+    private function getStyleMock()
+    {
+        return $this->createMock(Style::class);
+    }
+
+    /**
+     * @return \PHPUnit_Framework_MockObject_MockObject|Cell
+     */
+    private function getCellMock()
+    {
+        return $this->createMock(Cell::class);
+    }
+
+    /**
+     * @return \PHPUnit_Framework_MockObject_MockObject|RowManager
+     */
+    private function getRowManagerMock()
+    {
+        return $this->createMock(RowManager::class);
+    }
+
+    /**
+     * @return void
+     */
+    public function testValidInstance()
+    {
+        $this->assertInstanceOf(
+            Row::class,
+            new Row([], null, $this->getRowManagerMock())
+        );
+    }
+
+    /**
+     * @return void
+     */
+    public function testSetCells()
+    {
+        $row = new Row([], null, $this->getRowManagerMock());
+        $row->setCells([$this->getCellMock(), $this->getCellMock()]);
+
+        $this->assertEquals(2, count($row->getCells()));
+    }
+
+    /**
+     * @return void
+     */
+    public function testSetCellsResets()
+    {
+        $row = new Row([], null, $this->getRowManagerMock());
+        $row->setCells([$this->getCellMock(), $this->getCellMock()]);
+
+        $this->assertEquals(2, count($row->getCells()));
+
+        $row->setCells([$this->getCellMock()]);
+
+        $this->assertEquals(1, count($row->getCells()));
+    }
+
+    /**
+     * @return void
+     */
+    public function testGetCells()
+    {
+        $row = new Row([], null, $this->getRowManagerMock());
+
+        $this->assertEquals(0, count($row->getCells()));
+
+        $row->setCells([$this->getCellMock(), $this->getCellMock()]);
+
+        $this->assertEquals(2, count($row->getCells()));
+    }
+
+    /**
+     * @return void
+     */
+    public function testAddCell()
+    {
+        $row = new Row([], null, $this->getRowManagerMock());
+        $row->setCells([$this->getCellMock(), $this->getCellMock()]);
+
+        $this->assertEquals(2, count($row->getCells()));
+
+        $row->addCell($this->getCellMock());
+
+        $this->assertEquals(3, count($row->getCells()));
+    }
+
+    /**
+     * @return void
+     */
+    public function testFluentInterface()
+    {
+        $row = new Row([], null, $this->getRowManagerMock());
+        $row
+            ->addCell($this->getCellMock())
+            ->setStyle($this->getStyleMock())
+            ->setCells([]);
+
+        $this->assertTrue(is_object($row));
+    }
+}
diff --git a/tests/Spout/Writer/Common/Manager/CellManagerTest.php b/tests/Spout/Writer/Common/Manager/CellManagerTest.php
new file mode 100644
index 0000000..f10eefd
--- /dev/null
+++ b/tests/Spout/Writer/Common/Manager/CellManagerTest.php
@@ -0,0 +1,28 @@
+<?php
+
+namespace Spout\Writer\Common\Manager;
+
+use Box\Spout\Writer\Common\Creator\Style\StyleBuilder;
+use Box\Spout\Writer\Common\Entity\Cell;
+use Box\Spout\Writer\Common\Manager\CellManager;
+use Box\Spout\Writer\Common\Manager\Style\StyleMerger;
+use PHPUnit\Framework\TestCase;
+
+class CellManagerTest extends TestCase
+{
+    /**
+     * @return void
+     */
+    public function testApplyStyle()
+    {
+        $cellManager = new CellManager(new StyleMerger());
+        $cell = new Cell('test');
+
+        $this->assertFalse($cell->getStyle()->isFontBold());
+
+        $style = (new StyleBuilder())->setFontBold()->build();
+        $cellManager->applyStyle($cell, $style);
+
+        $this->assertTrue($cell->getStyle()->isFontBold());
+    }
+}
diff --git a/tests/Spout/Writer/Common/Manager/RowManagerTest.php b/tests/Spout/Writer/Common/Manager/RowManagerTest.php
new file mode 100644
index 0000000..93c6844
--- /dev/null
+++ b/tests/Spout/Writer/Common/Manager/RowManagerTest.php
@@ -0,0 +1,86 @@
+<?php
+
+namespace Spout\Writer\Common\Manager;
+
+use Box\Spout\Writer\Common\Creator\Style\StyleBuilder;
+use Box\Spout\Writer\Common\Entity\Cell;
+use Box\Spout\Writer\Common\Entity\Row;
+use Box\Spout\Writer\Common\Manager\RowManager;
+use Box\Spout\Writer\Common\Manager\Style\StyleMerger;
+use PHPUnit\Framework\TestCase;
+
+class RowManagerTest extends TestCase
+{
+    /**
+     * @return void
+     */
+    public function testApplyStyle()
+    {
+        $rowManager = new RowManager(new StyleMerger());
+        $row = new Row([new Cell('test')], null, $rowManager);
+
+        $this->assertFalse($row->getStyle()->isFontBold());
+
+        $style = (new StyleBuilder())->setFontBold()->build();
+        $rowManager->applyStyle($row, $style);
+
+        $this->assertTrue($row->getStyle()->isFontBold());
+    }
+
+    /**
+     * @return array
+     */
+    public function dataProviderForTestHasCells()
+    {
+        return [
+            // cells, expected hasCells
+            [[], false],
+            [[new Cell('')], true],
+            [[new Cell(null)], true],
+            [[new Cell('test')], true],
+        ];
+    }
+
+    /**
+     * @dataProvider dataProviderForTestHasCells
+     *
+     * @param array $cells
+     * @param bool $expectedHasCells
+     * @return void
+     */
+    public function testHasCells(array $cells, $expectedHasCells)
+    {
+        $rowManager = new RowManager(new StyleMerger());
+
+        $row = new Row($cells, null, $rowManager);
+        $this->assertEquals($expectedHasCells, $rowManager->hasCells($row));
+    }
+
+    /**
+     * @return array
+     */
+    public function dataProviderForTestIsEmptyRow()
+    {
+        return [
+            // cells, expected isEmpty
+            [[], true],
+            [[new Cell('')], true],
+            [[new Cell(''), new Cell(''), new Cell('Okay')], false],
+        ];
+    }
+
+    /**
+     * @dataProvider dataProviderForTestIsEmptyRow
+     *
+     * @param array $cells
+     * @param bool $expectedIsEmpty
+     * @return void
+     */
+    public function testIsEmptyRow(array $cells, $expectedIsEmpty)
+    {
+        $rowManager = new RowManager(new StyleMerger());
+
+        $row = new Row($cells, null, $rowManager);
+        $this->assertEquals($expectedIsEmpty, $rowManager->isEmpty($row));
+    }
+}
diff --git a/tests/Spout/Writer/Common/Manager/Style/StyleManagerTest.php b/tests/Spout/Writer/Common/Manager/Style/StyleManagerTest.php
index 7e2a117..f1faae1 100644
--- a/tests/Spout/Writer/Common/Manager/Style/StyleManagerTest.php
+++ b/tests/Spout/Writer/Common/Manager/Style/StyleManagerTest.php
@@ -3,6 +3,7 @@
 namespace Box\Spout\Writer\Common\Manager\Style;
 
 use Box\Spout\Writer\Common\Creator\Style\StyleBuilder;
+use Box\Spout\Writer\Common\Entity\Cell;
 
 /**
  * Class StyleManagerTest
@@ -29,7 +30,7 @@ class StyleManagerTest extends \PHPUnit_Framework_TestCase
         $this->assertFalse($style->shouldWrapText());
 
         $styleManager = $this->getStyleManager();
-        $updatedStyle = $styleManager->applyExtraStylesIfNeeded($style, [12, 'single line', "multi\nlines", null]);
+        $updatedStyle = $styleManager->applyExtraStylesIfNeeded(new Cell("multi\nlines", $style));
 
         $this->assertTrue($updatedStyle->shouldWrapText());
     }
@@ -43,7 +44,7 @@ class StyleManagerTest extends \PHPUnit_Framework_TestCase
         $this->assertTrue($style->shouldWrapText());
 
         $styleManager = $this->getStyleManager();
-        $updatedStyle = $styleManager->applyExtraStylesIfNeeded($style, ["multi\nlines"]);
+        $updatedStyle = $styleManager->applyExtraStylesIfNeeded(new Cell("multi\nlines", $style));
 
         $this->assertTrue($updatedStyle->shouldWrapText());
     }
diff --git a/tests/Spout/Writer/ODS/SheetTest.php b/tests/Spout/Writer/ODS/SheetTest.php
index 685fddb..df7ba16 100644
--- a/tests/Spout/Writer/ODS/SheetTest.php
+++ b/tests/Spout/Writer/ODS/SheetTest.php
@@ -5,6 +5,7 @@ namespace Box\Spout\Writer\ODS;
 use Box\Spout\Common\Type;
 use Box\Spout\TestUsingResource;
 use Box\Spout\Writer\Common\Entity\Sheet;
+use Box\Spout\Writer\RowCreationHelper;
 use Box\Spout\Writer\WriterFactory;
 
 /**
@@ -13,6 +14,7 @@ use Box\Spout\Writer\WriterFactory;
 class SheetTest extends \PHPUnit_Framework_TestCase
 {
     use TestUsingResource;
+    use RowCreationHelper;
 
     /**
      * @return void
@@ -91,7 +93,7 @@ class SheetTest extends \PHPUnit_Framework_TestCase
         $sheet = $writer->getCurrentSheet();
         $sheet->setName($sheetName);
 
-        $writer->addRow(['ods--11', 'ods--12']);
+        $writer->addRow($this->createRowFromValues(['ods--11', 'ods--12']));
         $writer->close();
     }
 
@@ -108,9 +110,9 @@ class SheetTest extends \PHPUnit_Framework_TestCase
         $writer = WriterFactory::create(Type::ODS);
         $writer->openToFile($resourcePath);
 
-        $writer->addRow(['ods--sheet1--11', 'ods--sheet1--12']);
+        $writer->addRow($this->createRowFromValues(['ods--sheet1--11', 'ods--sheet1--12']));
         $writer->addNewSheetAndMakeItCurrent();
-        $writer->addRow(['ods--sheet2--11', 'ods--sheet2--12', 'ods--sheet2--13']);
+        $writer->addRow($this->createRowFromValues(['ods--sheet2--11', 'ods--sheet2--12', 'ods--sheet2--13']));
 
         $writer->close();
 
diff --git a/tests/Spout/Writer/ODS/WriterTest.php b/tests/Spout/Writer/ODS/WriterTest.php
index e42226b..a6d8ad3 100644
--- a/tests/Spout/Writer/ODS/WriterTest.php
+++ b/tests/Spout/Writer/ODS/WriterTest.php
@@ -7,7 +7,9 @@ use Box\Spout\Common\Type;
 use Box\Spout\Reader\Wrapper\XMLReader;
 use Box\Spout\TestUsingResource;
 use Box\Spout\Writer\Common\Entity\Cell;
+use Box\Spout\Writer\Common\Entity\Row;
 use Box\Spout\Writer\Common\Helper\ZipHelper;
+use Box\Spout\Writer\RowCreationHelper;
 use Box\Spout\Writer\WriterFactory;
 
 /**
@@ -16,6 +18,7 @@ use Box\Spout\Writer\WriterFactory;
 class WriterTest extends \PHPUnit_Framework_TestCase
 {
     use TestUsingResource;
+    use RowCreationHelper;
 
     /**
      * @expectedException \Box\Spout\Common\Exception\IOException
@@ -36,7 +39,7 @@ class WriterTest extends \PHPUnit_Framework_TestCase
     public function testAddRowShouldThrowExceptionIfCallAddRowBeforeOpeningWriter()
     {
         $writer = WriterFactory::create(Type::ODS);
-        $writer->addRow(['ods--11', 'ods--12']);
+        $writer->addRow($this->createRowFromValues(['ods--11', 'ods--12']));
     }
 
     /**
@@ -45,7 +48,7 @@ class WriterTest extends \PHPUnit_Framework_TestCase
     public function testAddRowShouldThrowExceptionIfCalledBeforeOpeningWriter()
     {
         $writer = WriterFactory::create(Type::ODS);
-        $writer->addRows([['ods--11', 'ods--12']]);
+        $writer->addRows([$this->createRowFromValues(['ods--11', 'ods--12'])]);
     }
 
     /**
@@ -85,7 +88,7 @@ class WriterTest extends \PHPUnit_Framework_TestCase
     {
         $fileName = 'test_add_row_should_throw_exception_if_unsupported_data_type_passed_in.ods';
         $dataRows = [
-            [new \stdClass()],
+            $this->createRowFromValues([new \stdClass()]),
         ];
 
         $this->writeToODSFile($dataRows, $fileName);
@@ -98,8 +101,8 @@ class WriterTest extends \PHPUnit_Framework_TestCase
     {
         $fileName = 'test_add_row_should_cleanup_all_files_if_exception_thrown.ods';
         $dataRows = [
-            ['wrong'],
-            [new \stdClass()],
+            $this->createRowFromValues(['wrong']),
+            $this->createRowFromValues([new \stdClass()]),
         ];
 
         $this->createGeneratedFolderIfNeeded($fileName);
@@ -191,10 +194,10 @@ class WriterTest extends \PHPUnit_Framework_TestCase
     public function testAddRowShouldWriteGivenDataToSheet()
     {
         $fileName = 'test_add_row_should_write_given_data_to_sheet.ods';
-        $dataRows = [
+        $dataRows = $this->createRowsFromValues([
             ['ods--11', 'ods--12'],
             ['ods--21', 'ods--22', 'ods--23'],
-        ];
+        ]);
 
         $this->writeToODSFile($dataRows, $fileName);
 
@@ -211,10 +214,10 @@ class WriterTest extends \PHPUnit_Framework_TestCase
     public function testAddRowShouldWriteGivenDataToTwoSheets()
     {
         $fileName = 'test_add_row_should_write_given_data_to_two_sheets.ods';
-        $dataRows = [
+        $dataRows = $this->createRowsFromValues([
             ['ods--11', 'ods--12'],
             ['ods--21', 'ods--22', 'ods--23'],
-        ];
+        ]);
 
         $numSheets = 2;
         $this->writeToMultipleSheetsInODSFile($dataRows, $numSheets, $fileName);
@@ -234,9 +237,9 @@ class WriterTest extends \PHPUnit_Framework_TestCase
     public function testAddRowShouldSupportAssociativeArrays()
     {
         $fileName = 'test_add_row_should_support_associative_arrays.ods';
-        $dataRows = [
+        $dataRows = $this->createRowsFromValues([
             ['foo' => 'ods--11', 'bar' => 'ods--12'],
-        ];
+        ]);
 
         $this->writeToODSFile($dataRows, $fileName);
 
@@ -253,9 +256,9 @@ class WriterTest extends \PHPUnit_Framework_TestCase
     public function testAddRowShouldSupportMultipleTypesOfData()
     {
         $fileName = 'test_add_row_should_support_multiple_types_of_data.ods';
-        $dataRows = [
+        $dataRows = $this->createRowsFromValues([
             ['ods--11', true, '', 0, 10.2, null],
-        ];
+        ]);
 
         $this->writeToODSFile($dataRows, $fileName);
 
@@ -290,7 +293,7 @@ class WriterTest extends \PHPUnit_Framework_TestCase
     public function testAddRowShouldUseNumberColumnsRepeatedForRepeatedValues($dataRow, $expectedNumTableCells, $expectedNumColumnsRepeated)
     {
         $fileName = 'test_add_row_should_use_number_columns_repeated.ods';
-        $this->writeToODSFile([$dataRow], $fileName);
+        $this->writeToODSFile($this->createRowsFromValues([$dataRow]), $fileName);
 
         $sheetXmlNode = $this->getSheetXmlNode($fileName, 1);
         $tableCellNodes = $sheetXmlNode->getElementsByTagName('table-cell');
@@ -314,18 +317,18 @@ class WriterTest extends \PHPUnit_Framework_TestCase
     public function testAddRowShouldWriteGivenDataToTheCorrectSheet()
     {
         $fileName = 'test_add_row_should_write_given_data_to_the_correct_sheet.ods';
-        $dataRowsSheet1 = [
+        $dataRowsSheet1 = $this->createRowsFromValues([
             ['ods--sheet1--11', 'ods--sheet1--12'],
             ['ods--sheet1--21', 'ods--sheet1--22', 'ods--sheet1--23'],
-        ];
-        $dataRowsSheet2 = [
+        ]);
+        $dataRowsSheet2 = $this->createRowsFromValues([
             ['ods--sheet2--11', 'ods--sheet2--12'],
             ['ods--sheet2--21', 'ods--sheet2--22', 'ods--sheet2--23'],
-        ];
-        $dataRowsSheet1Again = [
+        ]);
+        $dataRowsSheet1Again = $this->createRowsFromValues([
             ['ods--sheet1--31', 'ods--sheet1--32'],
             ['ods--sheet1--41', 'ods--sheet1--42', 'ods--sheet1--43'],
-        ];
+        ]);
 
         $this->createGeneratedFolderIfNeeded($fileName);
         $resourcePath = $this->getGeneratedResourcePath($fileName);
@@ -369,11 +372,11 @@ class WriterTest extends \PHPUnit_Framework_TestCase
     public function testAddRowShouldAutomaticallyCreateNewSheetsIfMaxRowsReachedAndOptionTurnedOn()
     {
         $fileName = 'test_add_row_should_automatically_create_new_sheets_if_max_rows_reached_and_option_turned_on.ods';
-        $dataRows = [
+        $dataRows = $this->createRowsFromValues([
             ['ods--sheet1--11', 'ods--sheet1--12'],
             ['ods--sheet1--21', 'ods--sheet1--22', 'ods--sheet1--23'],
             ['ods--sheet2--11', 'ods--sheet2--12'], // this should be written in a new sheet
-        ];
+        ]);
 
         // set the maxRowsPerSheet limit to 2
         \ReflectionHelper::setStaticValue('\Box\Spout\Writer\ODS\Manager\WorkbookManager', 'maxRowsPerWorksheet', 2);
@@ -393,11 +396,11 @@ class WriterTest extends \PHPUnit_Framework_TestCase
     public function testAddRowShouldNotCreateNewSheetsIfMaxRowsReachedAndOptionTurnedOff()
     {
         $fileName = 'test_add_row_should_not_create_new_sheets_if_max_rows_reached_and_option_turned_off.ods';
-        $dataRows = [
+        $dataRows = $this->createRowsFromValues([
             ['ods--sheet1--11', 'ods--sheet1--12'],
             ['ods--sheet1--21', 'ods--sheet1--22', 'ods--sheet1--23'],
             ['ods--sheet1--31', 'ods--sheet1--32'], // this should NOT be written in a new sheet
-        ];
+        ]);
 
         // set the maxRowsPerSheet limit to 2
         \ReflectionHelper::setStaticValue('\Box\Spout\Writer\ODS\Manager\WorkbookManager', 'maxRowsPerWorksheet', 2);
@@ -416,9 +419,9 @@ class WriterTest extends \PHPUnit_Framework_TestCase
     public function testAddRowShouldEscapeHtmlSpecialCharacters()
     {
         $fileName = 'test_add_row_should_escape_html_special_characters.ods';
-        $dataRows = [
+        $dataRows = $this->createRowsFromValues([
             ['I\'m in "great" mood', 'This <must> be escaped & tested'],
-        ];
+        ]);
 
         $this->writeToODSFile($dataRows, $fileName);
 
@@ -434,7 +437,7 @@ class WriterTest extends \PHPUnit_Framework_TestCase
         $fileName = 'test_add_row_should_keep_new_lines.ods';
         $dataRow = ["I have\na dream"];
 
-        $this->writeToODSFile([$dataRow], $fileName);
+        $this->writeToODSFile($this->createRowsFromValues([$dataRow]), $fileName);
 
         $this->assertValueWasWrittenToSheet($fileName, 1, 'I have');
         $this->assertValueWasWrittenToSheet($fileName, 1, 'a dream');
@@ -458,55 +461,14 @@ class WriterTest extends \PHPUnit_Framework_TestCase
         $resourcePath = $this->getGeneratedResourcePath($fileName);
         $dataRow = ['foo'];
 
-        $this->writeToODSFile([$dataRow], $fileName);
+        $this->writeToODSFile($this->createRowsFromValues([$dataRow]), $fileName);
 
         $finfo = new \finfo(FILEINFO_MIME_TYPE);
         $this->assertEquals('application/vnd.oasis.opendocument.spreadsheet', $finfo->file($resourcePath));
     }
 
     /**
-     * @return void
-     */
-    public function testWriteShouldAcceptCellObjects()
-    {
-        $fileName = 'test_writer_should_accept_cell_objects.ods';
-        $dataRows = [
-            [new Cell('ods--11'), new Cell('ods--12')],
-            [new Cell('ods--21'), new Cell('ods--22'), new Cell('ods--23')],
-        ];
-
-        $this->writeToODSFile($dataRows, $fileName);
-
-        foreach ($dataRows as $dataRow) {
-            /** @var Cell $cell */
-            foreach ($dataRow as $cell) {
-                $this->assertValueWasWritten($fileName, $cell->getValue());
-            }
-        }
-    }
-
-    /**
-     * @return void
-     */
-    public function testWriteShouldAcceptCellObjectsWithDifferentValueTypes()
-    {
-        $fileName = 'test_writer_should_accept_cell_objects_with_types.ods';
-        $dataRows = [
-            [new Cell('i am a string'), new Cell(51465), new Cell(true), new Cell(51465.5)],
-        ];
-
-        $this->writeToODSFile($dataRows, $fileName);
-
-        foreach ($dataRows as $dataRow) {
-            /** @var Cell $cell */
-            foreach ($dataRow as $cell) {
-                $this->assertValueWasWritten($fileName, (string) $cell->getValue(), '');
-            }
-        }
-    }
-
-    /**
-     * @param array $allRows
+     * @param Row[] $allRows
      * @param string $fileName
      * @param bool $shouldCreateSheetsAutomatically
      * @return Writer
@@ -528,7 +490,7 @@ class WriterTest extends \PHPUnit_Framework_TestCase
     }
 
     /**
-     * @param array $allRows
+     * @param Row[] $allRows
      * @param int $numSheets
      * @param string $fileName
      * @param bool $shouldCreateSheetsAutomatically
diff --git a/tests/Spout/Writer/ODS/WriterWithStyleTest.php b/tests/Spout/Writer/ODS/WriterWithStyleTest.php
index cd6e21e..575dd3c 100644
--- a/tests/Spout/Writer/ODS/WriterWithStyleTest.php
+++ b/tests/Spout/Writer/ODS/WriterWithStyleTest.php
@@ -7,9 +7,11 @@ use Box\Spout\Reader\Wrapper\XMLReader;
 use Box\Spout\TestUsingResource;
 use Box\Spout\Writer\Common\Creator\Style\BorderBuilder;
 use Box\Spout\Writer\Common\Creator\Style\StyleBuilder;
+use Box\Spout\Writer\Common\Entity\Row;
 use Box\Spout\Writer\Common\Entity\Style\Border;
 use Box\Spout\Writer\Common\Entity\Style\Color;
 use Box\Spout\Writer\Common\Entity\Style\Style;
+use Box\Spout\Writer\RowCreationHelper;
 use Box\Spout\Writer\WriterFactory;
 
 /**
@@ -18,6 +20,7 @@ use Box\Spout\Writer\WriterFactory;
 class WriterWithStyleTest extends \PHPUnit_Framework_TestCase
 {
     use TestUsingResource;
+    use RowCreationHelper;
 
     /** @var Style */
     private $defaultStyle;
@@ -36,7 +39,7 @@ class WriterWithStyleTest extends \PHPUnit_Framework_TestCase
     public function testAddRowWithStyleShouldThrowExceptionIfCallAddRowBeforeOpeningWriter()
     {
         $writer = WriterFactory::create(Type::ODS);
-        $writer->addRowWithStyle(['ods--11', 'ods--12'], $this->defaultStyle);
+        $writer->addRow($this->createStyledRowFromValues(['ods--11', 'ods--12'], $this->defaultStyle));
     }
 
     /**
@@ -45,53 +48,7 @@ class WriterWithStyleTest extends \PHPUnit_Framework_TestCase
     public function testAddRowWithStyleShouldThrowExceptionIfCalledBeforeOpeningWriter()
     {
         $writer = WriterFactory::create(Type::ODS);
-        $writer->addRowWithStyle(['ods--11', 'ods--12'], $this->defaultStyle);
-    }
-
-    /**
-     * @return array
-     */
-    public function dataProviderForInvalidStyle()
-    {
-        return [
-            ['style'],
-            [new \stdClass()],
-            [null],
-        ];
-    }
-
-    /**
-     * @dataProvider dataProviderForInvalidStyle
-     * @expectedException \Box\Spout\Common\Exception\InvalidArgumentException
-     *
-     * @param \Box\Spout\Writer\Common\Entity\Style\Style $style
-     */
-    public function testAddRowWithStyleShouldThrowExceptionIfInvalidStyleGiven($style)
-    {
-        $fileName = 'test_add_row_with_style_should_throw_exception.ods';
-        $this->createGeneratedFolderIfNeeded($fileName);
-        $resourcePath = $this->getGeneratedResourcePath($fileName);
-
-        $writer = WriterFactory::create(Type::ODS);
-        $writer->openToFile($resourcePath);
-        $writer->addRowWithStyle(['ods--11', 'ods--12'], $style);
-    }
-
-    /**
-     * @dataProvider dataProviderForInvalidStyle
-     * @expectedException \Box\Spout\Common\Exception\InvalidArgumentException
-     *
-     * @param \Box\Spout\Writer\Common\Entity\Style\Style $style
-     */
-    public function testAddRowsWithStyleShouldThrowExceptionIfInvalidStyleGiven($style)
-    {
-        $fileName = 'test_add_row_with_style_should_throw_exception.ods';
-        $this->createGeneratedFolderIfNeeded($fileName);
-        $resourcePath = $this->getGeneratedResourcePath($fileName);
-
-        $writer = WriterFactory::create(Type::ODS);
-        $writer->openToFile($resourcePath);
-        $writer->addRowsWithStyle([['ods--11', 'ods--12']], $style);
+        $writer->addRow($this->createStyledRowFromValues(['ods--11', 'ods--12'], $this->defaultStyle));
     }
 
     /**
@@ -100,10 +57,6 @@ class WriterWithStyleTest extends \PHPUnit_Framework_TestCase
     public function testAddRowWithStyleShouldListAllUsedStylesInCreatedContentXmlFile()
     {
         $fileName = 'test_add_row_with_style_should_list_all_used_fonts.ods';
-        $dataRows = [
-            ['ods--11', 'ods--12'],
-            ['ods--21', 'ods--22'],
-        ];
 
         $style = (new StyleBuilder())
             ->setFontBold()
@@ -118,7 +71,12 @@ class WriterWithStyleTest extends \PHPUnit_Framework_TestCase
             ->setBackgroundColor(Color::GREEN)
             ->build();
 
-        $this->writeToODSFileWithMultipleStyles($dataRows, $fileName, [$style, $style2]);
+        $dataRows = [
+            $this->createRowFromValues(['ods--11', 'ods--12'], $style),
+            $this->createRowFromValues(['ods--21', 'ods--22'], $style2),
+        ];
+
+        $this->writeToODSFile($dataRows, $fileName);
 
         $cellStyleElements = $this->getCellStyleElementsFromContentXmlFile($fileName);
         $this->assertEquals(3, count($cellStyleElements), 'There should be 3 separate cell styles, including the default one.');
@@ -144,9 +102,9 @@ class WriterWithStyleTest extends \PHPUnit_Framework_TestCase
     public function testAddRowWithStyleShouldWriteDefaultStyleSettings()
     {
         $fileName = 'test_add_row_with_style_should_write_default_style_settings.ods';
-        $dataRow = ['ods--11', 'ods--12'];
+        $dataRow = $this->createStyledRowFromValues(['ods--11', 'ods--12'], $this->defaultStyle);
 
-        $this->writeToODSFile([$dataRow], $fileName, $this->defaultStyle);
+        $this->writeToODSFile([$dataRow], $fileName);
 
         $textPropertiesElement = $this->getXmlSectionFromStylesXmlFile($fileName, 'style:text-properties');
         $this->assertEquals(Style::DEFAULT_FONT_SIZE . 'pt', $textPropertiesElement->getAttribute('fo:font-size'));
@@ -160,15 +118,16 @@ class WriterWithStyleTest extends \PHPUnit_Framework_TestCase
     public function testAddRowWithStyleShouldApplyStyleToCells()
     {
         $fileName = 'test_add_row_with_style_should_apply_style_to_cells.ods';
-        $dataRows = [
-            ['ods--11'],
-            ['ods--21'],
-            ['ods--31'],
-        ];
+
         $style = (new StyleBuilder())->setFontBold()->build();
         $style2 = (new StyleBuilder())->setFontSize(15)->build();
+        $dataRows = [
+            $this->createStyledRowFromValues(['ods--11'], $style),
+            $this->createStyledRowFromValues(['ods--21'], $style2),
+            $this->createRowFromValues(['ods--31']),
+        ];
 
-        $this->writeToODSFileWithMultipleStyles($dataRows, $fileName, [$style, $style2, null]);
+        $this->writeToODSFile($dataRows, $fileName);
 
         $cellDomElements = $this->getCellElementsFromContentXmlFile($fileName);
         $this->assertEquals(3, count($cellDomElements), 'There should be 3 cells with content');
@@ -184,13 +143,14 @@ class WriterWithStyleTest extends \PHPUnit_Framework_TestCase
     public function testAddRowWithStyleShouldReuseDuplicateStyles()
     {
         $fileName = 'test_add_row_with_style_should_reuse_duplicate_styles.ods';
-        $dataRows = [
+
+        $style = (new StyleBuilder())->setFontBold()->build();
+        $dataRows = $this->createStyledRowsFromValues([
             ['ods--11'],
             ['ods--21'],
-        ];
-        $style = (new StyleBuilder())->setFontBold()->build();
+        ], $style);
 
-        $this->writeToODSFile($dataRows, $fileName, $style);
+        $this->writeToODSFile($dataRows, $fileName);
 
         $cellDomElements = $this->getCellElementsFromContentXmlFile($fileName);
         $this->assertEquals(2, count($cellDomElements), 'There should be 2 cells with content');
@@ -205,12 +165,13 @@ class WriterWithStyleTest extends \PHPUnit_Framework_TestCase
     public function testAddRowWithStyleShouldAddWrapTextAlignmentInfoInStylesXmlFileIfSpecified()
     {
         $fileName = 'test_add_row_with_style_should_add_wrap_text_alignment.ods';
-        $dataRows = [
-            ['ods--11', 'ods--12'],
-        ];
-        $style = (new StyleBuilder())->setShouldWrapText()->build();
 
-        $this->writeToODSFile($dataRows, $fileName, $style);
+        $style = (new StyleBuilder())->setShouldWrapText()->build();
+        $dataRows = $this->createStyledRowsFromValues([
+            ['ods--11', 'ods--12'],
+        ], $style);
+
+        $this->writeToODSFile($dataRows, $fileName);
 
         $styleElements = $this->getCellStyleElementsFromContentXmlFile($fileName);
         $this->assertEquals(2, count($styleElements), 'There should be 2 styles (default and custom)');
@@ -225,11 +186,11 @@ class WriterWithStyleTest extends \PHPUnit_Framework_TestCase
     public function testAddRowWithStyleShouldApplyWrapTextIfCellContainsNewLine()
     {
         $fileName = 'test_add_row_with_style_should_apply_wrap_text_if_new_lines.ods';
-        $dataRows = [
+        $dataRows = $this->createStyledRowsFromValues([
             ["ods--11\nods--11"],
-        ];
+        ], $this->defaultStyle);
 
-        $this->writeToODSFile($dataRows, $fileName, $this->defaultStyle);
+        $this->writeToODSFile($dataRows, $fileName);
 
         $styleElements = $this->getCellStyleElementsFromContentXmlFile($fileName);
         $this->assertEquals(2, count($styleElements), 'There should be 2 styles (default and custom)');
@@ -244,12 +205,13 @@ class WriterWithStyleTest extends \PHPUnit_Framework_TestCase
     public function testAddBackgroundColor()
     {
         $fileName = 'test_default_background_style.ods';
-        $dataRows = [
-            ['defaultBgColor'],
-        ];
 
         $style = (new StyleBuilder())->setBackgroundColor(Color::WHITE)->build();
-        $this->writeToODSFile($dataRows, $fileName, $style);
+        $dataRows = $this->createStyledRowsFromValues([
+            ['defaultBgColor'],
+        ], $style);
+
+        $this->writeToODSFile($dataRows, $fileName);
 
         $styleElements = $this->getCellStyleElementsFromContentXmlFile($fileName);
         $this->assertEquals(2, count($styleElements), 'There should be 2 styles (default and custom)');
@@ -265,12 +227,6 @@ class WriterWithStyleTest extends \PHPUnit_Framework_TestCase
     {
         $fileName = 'test_borders.ods';
 
-        $dataRows = [
-            ['row-with-border-bottom-green-thick-solid'],
-            ['row-without-border'],
-            ['row-with-border-top-red-thin-dashed'],
-        ];
-
         $borderBottomGreenThickSolid = (new BorderBuilder())
             ->setBorderBottom(Color::GREEN, Border::WIDTH_THICK, Border::STYLE_SOLID)->build();
 
@@ -283,7 +239,13 @@ class WriterWithStyleTest extends \PHPUnit_Framework_TestCase
             (new StyleBuilder())->setBorder($borderTopRedThinDashed)->build(),
         ];
 
-        $this->writeToODSFileWithMultipleStyles($dataRows, $fileName, $styles);
+        $dataRows = [
+            $this->createStyledRowFromValues(['row-with-border-bottom-green-thick-solid'], $styles[0]),
+            $this->createStyledRowFromValues(['row-without-border'], $styles[1]),
+            $this->createStyledRowFromValues(['row-with-border-top-red-thin-dashed'], $styles[2]),
+        ];
+
+        $this->writeToODSFile($dataRows, $fileName);
 
         $styleElements = $this->getCellStyleElementsFromContentXmlFile($fileName);
 
@@ -328,7 +290,10 @@ class WriterWithStyleTest extends \PHPUnit_Framework_TestCase
     public function testSetDefaultRowStyle()
     {
         $fileName = 'test_set_default_row_style.ods';
-        $dataRows = [['ods--11']];
+
+        $dataRows = $this->createRowsFromValues([
+            ['ods--11'],
+        ]);
 
         $defaultFontSize = 50;
         $defaultStyle = (new StyleBuilder())->setFontSize($defaultFontSize)->build();
@@ -340,12 +305,11 @@ class WriterWithStyleTest extends \PHPUnit_Framework_TestCase
     }
 
     /**
-     * @param array $allRows
+     * @param Row[] $allRows
      * @param string $fileName
-     * @param \Box\Spout\Writer\Common\Entity\Style\Style $style
      * @return Writer
      */
-    private function writeToODSFile($allRows, $fileName, $style)
+    private function writeToODSFile($allRows, $fileName)
     {
         $this->createGeneratedFolderIfNeeded($fileName);
         $resourcePath = $this->getGeneratedResourcePath($fileName);
@@ -354,16 +318,16 @@ class WriterWithStyleTest extends \PHPUnit_Framework_TestCase
         $writer = WriterFactory::create(Type::ODS);
 
         $writer->openToFile($resourcePath);
-        $writer->addRowsWithStyle($allRows, $style);
+        $writer->addRows($allRows);
         $writer->close();
 
         return $writer;
     }
 
     /**
-     * @param array $allRows
+     * @param Row[] $allRows
      * @param string $fileName
-     * @param \Box\Spout\Writer\Common\Entity\Style\Style|null $defaultStyle
+     * @param Style $defaultStyle
      * @return Writer
      */
     private function writeToODSFileWithDefaultStyle($allRows, $fileName, $defaultStyle)
@@ -382,36 +346,6 @@ class WriterWithStyleTest extends \PHPUnit_Framework_TestCase
         return $writer;
     }
 
-    /**
-     * @param array $allRows
-     * @param string $fileName
-     * @param \Box\Spout\Writer\Common\Entity\Style\Style|null[] $styles
-     * @return Writer
-     */
-    private function writeToODSFileWithMultipleStyles($allRows, $fileName, $styles)
-    {
-        // there should be as many rows as there are styles passed in
-        $this->assertEquals(count($allRows), count($styles));
-
-        $this->createGeneratedFolderIfNeeded($fileName);
-        $resourcePath = $this->getGeneratedResourcePath($fileName);
-
-        /** @var \Box\Spout\Writer\ODS\Writer $writer */
-        $writer = WriterFactory::create(Type::ODS);
-
-        $writer->openToFile($resourcePath);
-        for ($i = 0; $i < count($allRows); $i++) {
-            if ($styles[$i] === null) {
-                $writer->addRow($allRows[$i]);
-            } else {
-                $writer->addRowWithStyle($allRows[$i], $styles[$i]);
-            }
-        }
-        $writer->close();
-
-        return $writer;
-    }
-
     /**
      * @param string $fileName
      * @return \DOMNode[]
diff --git a/tests/Spout/Writer/RowCreationHelper.php b/tests/Spout/Writer/RowCreationHelper.php
new file mode 100644
index 0000000..421481b
--- /dev/null
+++ b/tests/Spout/Writer/RowCreationHelper.php
@@ -0,0 +1,65 @@
+<?php
+
+namespace Box\Spout\Writer;
+
+use Box\Spout\Writer\Common\Creator\EntityFactory;
+use Box\Spout\Writer\Common\Entity\Row;
+use Box\Spout\Writer\Common\Entity\Style\Style;
+
+/**
+ * Trait RowCreationHelper
+ */
+trait RowCreationHelper
+{
+    /**
+     * @param array $cellValues
+     * @param Style|null $rowStyle
+     * @return Row
+     */
+    protected function createRowFromValues(array $cellValues, Style $rowStyle = null)
+    {
+        $row = EntityFactory::createRow([], $rowStyle);
+
+        foreach ($cellValues as $cellValue) {
+            $row->addCell(EntityFactory::createCell($cellValue));
+        }
+
+        return $row;
+    }
+
+    /**
+     * @param array $cellValues
+     * @param Style $rowStyle
+     * @return Row
+     */
+    protected function createStyledRowFromValues(array $cellValues, Style $rowStyle)
+    {
+        return $this->createRowFromValues($cellValues, $rowStyle);
+    }
+
+    /**
+     * @param array $rowValues
+     * @param Style|null $rowsStyle
+     * @return Row[]
+     */
+    protected function createRowsFromValues(array $rowValues, Style $rowsStyle = null)
+    {
+        $rows = [];
+
+        foreach ($rowValues as $cellValues) {
+            $rows[] = $this->createRowFromValues($cellValues, $rowsStyle);
+        }
+
+        return $rows;
+    }
+
+    /**
+     * @param array $rowValues
+     * @param Style $rowsStyle
+     * @return Row[]
+     */
+    protected function createStyledRowsFromValues(array $rowValues, Style $rowsStyle)
+    {
+        return $this->createRowsFromValues($rowValues, $rowsStyle);
+    }
+}
diff --git a/tests/Spout/Writer/XLSX/SheetTest.php b/tests/Spout/Writer/XLSX/SheetTest.php
index 5df4d57..a06cbbe 100644
--- a/tests/Spout/Writer/XLSX/SheetTest.php
+++ b/tests/Spout/Writer/XLSX/SheetTest.php
@@ -5,6 +5,7 @@ namespace Box\Spout\Writer\XLSX;
 use Box\Spout\Common\Type;
 use Box\Spout\TestUsingResource;
 use Box\Spout\Writer\Common\Entity\Sheet;
+use Box\Spout\Writer\RowCreationHelper;
 use Box\Spout\Writer\WriterFactory;
 
 /**
@@ -13,6 +14,7 @@ use Box\Spout\Writer\WriterFactory;
 class SheetTest extends \PHPUnit_Framework_TestCase
 {
     use TestUsingResource;
+    use RowCreationHelper;
 
     /**
      * @return void
@@ -91,7 +93,7 @@ class SheetTest extends \PHPUnit_Framework_TestCase
         $sheet = $writer->getCurrentSheet();
         $sheet->setName($sheetName);
 
-        $writer->addRow(['xlsx--11', 'xlsx--12']);
+        $writer->addRow($this->createRowFromValues(['xlsx--11', 'xlsx--12']));
         $writer->close();
 
         return $sheet;
@@ -110,9 +112,9 @@ class SheetTest extends \PHPUnit_Framework_TestCase
         $writer = WriterFactory::create(Type::XLSX);
         $writer->openToFile($resourcePath);
 
-        $writer->addRow(['xlsx--sheet1--11', 'xlsx--sheet1--12']);
+        $writer->addRow($this->createRowFromValues(['xlsx--sheet1--11', 'xlsx--sheet1--12']));
         $writer->addNewSheetAndMakeItCurrent();
-        $writer->addRow(['xlsx--sheet2--11', 'xlsx--sheet2--12', 'xlsx--sheet2--13']);
+        $writer->addRow($this->createRowFromValues(['xlsx--sheet2--11', 'xlsx--sheet2--12', 'xlsx--sheet2--13']));
 
         $writer->close();
 
diff --git a/tests/Spout/Writer/XLSX/WriterTest.php b/tests/Spout/Writer/XLSX/WriterTest.php
index 18dfd70..d12edff 100644
--- a/tests/Spout/Writer/XLSX/WriterTest.php
+++ b/tests/Spout/Writer/XLSX/WriterTest.php
@@ -5,7 +5,8 @@ namespace Box\Spout\Writer\XLSX;
 use Box\Spout\Common\Exception\SpoutException;
 use Box\Spout\Common\Type;
 use Box\Spout\TestUsingResource;
-use Box\Spout\Writer\Common\Entity\Cell;
+use Box\Spout\Writer\Common\Entity\Row;
+use Box\Spout\Writer\RowCreationHelper;
 use Box\Spout\Writer\WriterFactory;
 use Box\Spout\Writer\XLSX\Manager\WorksheetManager;
 
@@ -15,6 +16,7 @@ use Box\Spout\Writer\XLSX\Manager\WorksheetManager;
 class WriterTest extends \PHPUnit_Framework_TestCase
 {
     use TestUsingResource;
+    use RowCreationHelper;
 
     /**
      * @expectedException \Box\Spout\Common\Exception\IOException
@@ -35,7 +37,7 @@ class WriterTest extends \PHPUnit_Framework_TestCase
     public function testAddRowShouldThrowExceptionIfCallAddRowBeforeOpeningWriter()
     {
         $writer = WriterFactory::create(Type::XLSX);
-        $writer->addRow(['xlsx--11', 'xlsx--12']);
+        $writer->addRow($this->createRowFromValues(['xlsx--11', 'xlsx--12']));
     }
 
     /**
@@ -44,7 +46,7 @@ class WriterTest extends \PHPUnit_Framework_TestCase
     public function testAddRowShouldThrowExceptionIfCalledBeforeOpeningWriter()
     {
         $writer = WriterFactory::create(Type::XLSX);
-        $writer->addRows([['xlsx--11', 'xlsx--12']]);
+        $writer->addRows($this->createRowsFromValues([['xlsx--11', 'xlsx--12']]));
     }
 
     /**
@@ -111,9 +113,9 @@ class WriterTest extends \PHPUnit_Framework_TestCase
     public function testAddRowShouldThrowExceptionIfWritingStringExceedingMaxNumberOfCharactersAllowedPerCell()
     {
         $fileName = 'test_add_row_should_throw_exception_if_string_exceeds_max_num_chars_allowed_per_cell.xlsx';
-        $dataRows = [
+        $dataRows = $this->createRowsFromValues([
             [new \stdClass()],
-        ];
+        ]);
 
         $this->writeToXLSXFile($dataRows, $fileName);
     }
@@ -124,10 +126,10 @@ class WriterTest extends \PHPUnit_Framework_TestCase
     public function testAddRowShouldCleanupAllFilesIfExceptionIsThrown()
     {
         $fileName = 'test_add_row_should_cleanup_all_files_if_exception_thrown.xlsx';
-        $dataRows = [
+        $dataRows = $this->createRowsFromValues([
             ['wrong'],
             [new \stdClass()],
-        ];
+        ]);
 
         $this->createGeneratedFolderIfNeeded($fileName);
         $resourcePath = $this->getGeneratedResourcePath($fileName);
@@ -160,6 +162,7 @@ class WriterTest extends \PHPUnit_Framework_TestCase
         $this->createGeneratedFolderIfNeeded($fileName);
         $resourcePath = $this->getGeneratedResourcePath($fileName);
 
+        /** @var \Box\Spout\Writer\XLSX\Writer $writer */
         $writer = WriterFactory::create(Type::XLSX);
         $writer->openToFile($resourcePath);
         $writer->addNewSheetAndMakeItCurrent();
@@ -179,6 +182,7 @@ class WriterTest extends \PHPUnit_Framework_TestCase
         $this->createGeneratedFolderIfNeeded($fileName);
         $resourcePath = $this->getGeneratedResourcePath($fileName);
 
+        /** @var \Box\Spout\Writer\XLSX\Writer $writer */
         $writer = WriterFactory::create(Type::XLSX);
         $writer->openToFile($resourcePath);
 
@@ -216,10 +220,10 @@ class WriterTest extends \PHPUnit_Framework_TestCase
     public function testAddRowShouldWriteGivenDataToSheetUsingInlineStrings()
     {
         $fileName = 'test_add_row_should_write_given_data_to_sheet_using_inline_strings.xlsx';
-        $dataRows = [
+        $dataRows = $this->createRowsFromValues([
             ['xlsx--11', 'xlsx--12'],
             ['xlsx--21', 'xlsx--22', 'xlsx--23'],
-        ];
+        ]);
 
         $this->writeToXLSXFile($dataRows, $fileName, $shouldUseInlineStrings = true);
 
@@ -236,10 +240,10 @@ class WriterTest extends \PHPUnit_Framework_TestCase
     public function testAddRowShouldWriteGivenDataToTwoSheetsUsingInlineStrings()
     {
         $fileName = 'test_add_row_should_write_given_data_to_two_sheets_using_inline_strings.xlsx';
-        $dataRows = [
+        $dataRows = $this->createRowsFromValues([
             ['xlsx--11', 'xlsx--12'],
             ['xlsx--21', 'xlsx--22', 'xlsx--23'],
-        ];
+        ]);
 
         $numSheets = 2;
         $this->writeToMultipleSheetsInXLSXFile($dataRows, $numSheets, $fileName, $shouldUseInlineStrings = true);
@@ -259,10 +263,10 @@ class WriterTest extends \PHPUnit_Framework_TestCase
     public function testAddRowShouldWriteGivenDataToSheetUsingSharedStrings()
     {
         $fileName = 'test_add_row_should_write_given_data_to_sheet_using_shared_strings.xlsx';
-        $dataRows = [
+        $dataRows = $this->createRowsFromValues([
             ['xlsx--11', 'xlsx--12'],
             ['xlsx--21', 'xlsx--22', 'xlsx--23'],
-        ];
+        ]);
 
         $this->writeToXLSXFile($dataRows, $fileName, $shouldUseInlineStrings = false);
 
@@ -279,10 +283,10 @@ class WriterTest extends \PHPUnit_Framework_TestCase
     public function testAddRowShouldWriteGivenDataToTwoSheetsUsingSharedStrings()
     {
         $fileName = 'test_add_row_should_write_given_data_to_two_sheets_using_shared_strings.xlsx';
-        $dataRows = [
+        $dataRows = $this->createRowsFromValues([
             ['xlsx--11', 'xlsx--12'],
             ['xlsx--21', 'xlsx--22', 'xlsx--23'],
-        ];
+        ]);
 
         $numSheets = 2;
         $this->writeToMultipleSheetsInXLSXFile($dataRows, $numSheets, $fileName, $shouldUseInlineStrings = false);
@@ -302,9 +306,9 @@ class WriterTest extends \PHPUnit_Framework_TestCase
     public function testAddRowShouldSupportAssociativeArrays()
     {
         $fileName = 'test_add_row_should_support_associative_arrays.xlsx';
-        $dataRows = [
+        $dataRows = $this->createRowsFromValues([
             ['foo' => 'xlsx--11', 'bar' => 'xlsx--12'],
-        ];
+        ]);
 
         $this->writeToXLSXFile($dataRows, $fileName);
 
@@ -321,13 +325,13 @@ class WriterTest extends \PHPUnit_Framework_TestCase
     public function testAddRowShouldNotWriteEmptyRows()
     {
         $fileName = 'test_add_row_should_not_write_empty_rows.xlsx';
-        $dataRows = [
+        $dataRows = $this->createRowsFromValues([
             [''],
             ['xlsx--21', 'xlsx--22'],
             ['key' => ''],
             [''],
             ['xlsx--51', 'xlsx--52'],
-        ];
+        ]);
 
         $this->writeToXLSXFile($dataRows, $fileName);
 
@@ -344,9 +348,9 @@ class WriterTest extends \PHPUnit_Framework_TestCase
     public function testAddRowShouldSupportMultipleTypesOfData()
     {
         $fileName = 'test_add_row_should_support_multiple_types_of_data.xlsx';
-        $dataRows = [
+        $dataRows = $this->createRowsFromValues([
             ['xlsx--11', true, '', 0, 10.2, null],
-        ];
+        ]);
 
         $this->writeToXLSXFile($dataRows, $fileName, $shouldUseInlineStrings = false);
 
@@ -362,18 +366,18 @@ class WriterTest extends \PHPUnit_Framework_TestCase
     public function testAddRowShouldWriteGivenDataToTheCorrectSheet()
     {
         $fileName = 'test_add_row_should_write_given_data_to_the_correct_sheet.xlsx';
-        $dataRowsSheet1 = [
+        $dataRowsSheet1 = $this->createRowsFromValues([
             ['xlsx--sheet1--11', 'xlsx--sheet1--12'],
             ['xlsx--sheet1--21', 'xlsx--sheet1--22', 'xlsx--sheet1--23'],
-        ];
-        $dataRowsSheet2 = [
+        ]);
+        $dataRowsSheet2 = $this->createRowsFromValues([
             ['xlsx--sheet2--11', 'xlsx--sheet2--12'],
             ['xlsx--sheet2--21', 'xlsx--sheet2--22', 'xlsx--sheet2--23'],
-        ];
-        $dataRowsSheet1Again = [
+        ]);
+        $dataRowsSheet1Again = $this->createRowsFromValues([
             ['xlsx--sheet1--31', 'xlsx--sheet1--32'],
             ['xlsx--sheet1--41', 'xlsx--sheet1--42', 'xlsx--sheet1--43'],
-        ];
+        ]);
 
         $this->createGeneratedFolderIfNeeded($fileName);
         $resourcePath = $this->getGeneratedResourcePath($fileName);
@@ -419,11 +423,11 @@ class WriterTest extends \PHPUnit_Framework_TestCase
     public function testAddRowShouldAutomaticallyCreateNewSheetsIfMaxRowsReachedAndOptionTurnedOn()
     {
         $fileName = 'test_add_row_should_automatically_create_new_sheets_if_max_rows_reached_and_option_turned_on.xlsx';
-        $dataRows = [
+        $dataRows = $this->createRowsFromValues([
             ['xlsx--sheet1--11', 'xlsx--sheet1--12'],
             ['xlsx--sheet1--21', 'xlsx--sheet1--22', 'xlsx--sheet1--23'],
             ['xlsx--sheet2--11', 'xlsx--sheet2--12'], // this should be written in a new sheet
-        ];
+        ]);
 
         // set the maxRowsPerSheet limit to 2
         \ReflectionHelper::setStaticValue('\Box\Spout\Writer\XLSX\Manager\WorkbookManager', 'maxRowsPerWorksheet', 2);
@@ -443,11 +447,11 @@ class WriterTest extends \PHPUnit_Framework_TestCase
     public function testAddRowShouldNotCreateNewSheetsIfMaxRowsReachedAndOptionTurnedOff()
     {
         $fileName = 'test_add_row_should_not_create_new_sheets_if_max_rows_reached_and_option_turned_off.xlsx';
-        $dataRows = [
+        $dataRows = $this->createRowsFromValues([
             ['xlsx--sheet1--11', 'xlsx--sheet1--12'],
             ['xlsx--sheet1--21', 'xlsx--sheet1--22', 'xlsx--sheet1--23'],
             ['xlsx--sheet1--31', 'xlsx--sheet1--32'], // this should NOT be written in a new sheet
-        ];
+        ]);
 
         // set the maxRowsPerSheet limit to 2
         \ReflectionHelper::setStaticValue('\Box\Spout\Writer\XLSX\Manager\WorkbookManager', 'maxRowsPerWorksheet', 2);
@@ -466,9 +470,9 @@ class WriterTest extends \PHPUnit_Framework_TestCase
     public function testAddRowShouldEscapeHtmlSpecialCharacters()
     {
         $fileName = 'test_add_row_should_escape_html_special_characters.xlsx';
-        $dataRows = [
+        $dataRows = $this->createRowsFromValues([
             ['I\'m in "great" mood', 'This <must> be escaped & tested'],
-        ];
+        ]);
 
         $this->writeToXLSXFile($dataRows, $fileName);
 
@@ -482,9 +486,9 @@ class WriterTest extends \PHPUnit_Framework_TestCase
     public function testAddRowShouldEscapeControlCharacters()
     {
         $fileName = 'test_add_row_should_escape_control_characters.xlsx';
-        $dataRows = [
+        $dataRows = $this->createRowsFromValues([
             ['control ' . chr(21) . ' character'],
-        ];
+        ]);
 
         $this->writeToXLSXFile($dataRows, $fileName);
 
@@ -498,7 +502,7 @@ class WriterTest extends \PHPUnit_Framework_TestCase
     {
         $fileName = 'test_mime_type.xlsx';
         $resourcePath = $this->getGeneratedResourcePath($fileName);
-        $dataRows = [['foo']];
+        $dataRows = $this->createRowsFromValues([['foo']]);
 
         $this->writeToXLSXFile($dataRows, $fileName);
 
@@ -507,61 +511,7 @@ class WriterTest extends \PHPUnit_Framework_TestCase
     }
 
     /**
-     * @return  void
-     */
-    public function testWriterShouldAcceptCellObjects()
-    {
-        $fileName = 'test_writer_should_accept_cell_objects.xlsx';
-        $dataRows = [
-            [new Cell('xlsx--11'), new Cell('xlsx--12')],
-            [new Cell('xlsx--21'), new Cell('xlsx--22'), new Cell('xlsx--23')],
-        ];
-
-        $this->writeToXLSXFile($dataRows, $fileName, $shouldUseInlineStrings = false);
-
-        foreach ($dataRows as $dataRow) {
-            /** @var Cell $cell */
-            foreach ($dataRow as $cell) {
-                $this->assertSharedStringWasWritten($fileName, $cell->getValue());
-            }
-        }
-    }
-
-    /**
-     * @return  void
-     */
-    public function testWriteShouldAcceptCellObjectsWithDifferentValueTypes()
-    {
-        $fileName = 'test_writer_should_accept_cell_objects_with_types.xlsx';
-
-        $dataRowsShared = [
-            [new Cell('i am a string')],
-        ];
-        $dataRowsInline = [
-            [new Cell(51465), new Cell(true), new Cell(51465.5)],
-        ];
-
-        $dataRows = array_merge($dataRowsShared, $dataRowsInline);
-
-        $this->writeToXLSXFile($dataRows, $fileName, $shouldUseInlineStrings = false);
-
-        foreach ($dataRowsShared as $dataRow) {
-            /** @var Cell $cell */
-            foreach ($dataRow as $cell) {
-                $this->assertSharedStringWasWritten($fileName, (string) $cell->getValue());
-            }
-        }
-
-        foreach ($dataRowsInline as $dataRow) {
-            /** @var Cell $cell */
-            foreach ($dataRow as $cell) {
-                $this->assertInlineDataWasWrittenToSheet($fileName, 1, $cell->getValue());
-            }
-        }
-    }
-
-    /**
-     * @param array $allRows
+     * @param Row[] $allRows
      * @param string $fileName
      * @param bool $shouldUseInlineStrings
      * @param bool $shouldCreateSheetsAutomatically
@@ -585,7 +535,7 @@ class WriterTest extends \PHPUnit_Framework_TestCase
     }
 
     /**
-     * @param array $allRows
+     * @param Row[] $allRows
      * @param int $numSheets
      * @param string $fileName
      * @param bool $shouldUseInlineStrings
diff --git a/tests/Spout/Writer/XLSX/WriterWithStyleTest.php b/tests/Spout/Writer/XLSX/WriterWithStyleTest.php
index 84b8440..56eff58 100644
--- a/tests/Spout/Writer/XLSX/WriterWithStyleTest.php
+++ b/tests/Spout/Writer/XLSX/WriterWithStyleTest.php
@@ -7,10 +7,12 @@ use Box\Spout\Reader\Wrapper\XMLReader;
 use Box\Spout\TestUsingResource;
 use Box\Spout\Writer\Common\Creator\Style\BorderBuilder;
 use Box\Spout\Writer\Common\Creator\Style\StyleBuilder;
+use Box\Spout\Writer\Common\Entity\Row;
 use Box\Spout\Writer\Common\Entity\Style\Border;
 use Box\Spout\Writer\Common\Entity\Style\Color;
 use Box\Spout\Writer\Common\Entity\Style\Style;
 use Box\Spout\Writer\Common\Manager\Style\StyleMerger;
+use Box\Spout\Writer\RowCreationHelper;
 use Box\Spout\Writer\WriterFactory;
 use Box\Spout\Writer\XLSX\Manager\OptionsManager;
 
@@ -20,6 +22,7 @@ use Box\Spout\Writer\XLSX\Manager\OptionsManager;
 class WriterWithStyleTest extends \PHPUnit_Framework_TestCase
 {
     use TestUsingResource;
+    use RowCreationHelper;
 
     /** @var \Box\Spout\Writer\Common\Entity\Style\Style */
     private $defaultStyle;
@@ -38,7 +41,7 @@ class WriterWithStyleTest extends \PHPUnit_Framework_TestCase
     public function testAddRowWithStyleShouldThrowExceptionIfCallAddRowBeforeOpeningWriter()
     {
         $writer = WriterFactory::create(Type::XLSX);
-        $writer->addRowWithStyle(['xlsx--11', 'xlsx--12'], $this->defaultStyle);
+        $writer->addRow($this->createStyledRowFromValues(['xlsx--11', 'xlsx--12'], $this->defaultStyle));
     }
 
     /**
@@ -47,53 +50,7 @@ class WriterWithStyleTest extends \PHPUnit_Framework_TestCase
     public function testAddRowWithStyleShouldThrowExceptionIfCalledBeforeOpeningWriter()
     {
         $writer = WriterFactory::create(Type::XLSX);
-        $writer->addRowWithStyle(['xlsx--11', 'xlsx--12'], $this->defaultStyle);
-    }
-
-    /**
-     * @return array
-     */
-    public function dataProviderForInvalidStyle()
-    {
-        return [
-            ['style'],
-            [new \stdClass()],
-            [null],
-        ];
-    }
-
-    /**
-     * @dataProvider dataProviderForInvalidStyle
-     * @expectedException \Box\Spout\Common\Exception\InvalidArgumentException
-     *
-     * @param \Box\Spout\Writer\Common\Entity\Style\Style $style
-     */
-    public function testAddRowWithStyleShouldThrowExceptionIfInvalidStyleGiven($style)
-    {
-        $fileName = 'test_add_row_with_style_should_throw_exception.xlsx';
-        $this->createGeneratedFolderIfNeeded($fileName);
-        $resourcePath = $this->getGeneratedResourcePath($fileName);
-
-        $writer = WriterFactory::create(Type::XLSX);
-        $writer->openToFile($resourcePath);
-        $writer->addRowWithStyle(['xlsx--11', 'xlsx--12'], $style);
-    }
-
-    /**
-     * @dataProvider dataProviderForInvalidStyle
-     * @expectedException \Box\Spout\Common\Exception\InvalidArgumentException
-     *
-     * @param \Box\Spout\Writer\Common\Entity\Style\Style $style
-     */
-    public function testAddRowsWithStyleShouldThrowExceptionIfInvalidStyleGiven($style)
-    {
-        $fileName = 'test_add_row_with_style_should_throw_exception.xlsx';
-        $this->createGeneratedFolderIfNeeded($fileName);
-        $resourcePath = $this->getGeneratedResourcePath($fileName);
-
-        $writer = WriterFactory::create(Type::XLSX);
-        $writer->openToFile($resourcePath);
-        $writer->addRowsWithStyle([['xlsx--11', 'xlsx--12']], $style);
+        $writer->addRow($this->createStyledRowFromValues(['xlsx--11', 'xlsx--12'], $this->defaultStyle));
     }
 
     /**
@@ -102,10 +59,6 @@ class WriterWithStyleTest extends \PHPUnit_Framework_TestCase
     public function testAddRowWithStyleShouldListAllUsedFontsInCreatedStylesXmlFile()
     {
         $fileName = 'test_add_row_with_style_should_list_all_used_fonts.xlsx';
-        $dataRows = [
-            ['xlsx--11', 'xlsx--12'],
-            ['xlsx--21', 'xlsx--22'],
-        ];
 
         $style = (new StyleBuilder())
             ->setFontBold()
@@ -119,13 +72,19 @@ class WriterWithStyleTest extends \PHPUnit_Framework_TestCase
             ->setFontName('Cambria')
             ->build();
 
-        $this->writeToXLSXFileWithMultipleStyles($dataRows, $fileName, [$style, $style2]);
+        $dataRows = [
+            $this->createStyledRowFromValues(['xlsx--11', 'xlsx--12'], $style),
+            $this->createStyledRowFromValues(['xlsx--21', 'xlsx--22'], $style2),
+        ];
+
+        $this->writeToXLSXFile($dataRows, $fileName);
 
         $fontsDomElement = $this->getXmlSectionFromStylesXmlFile($fileName, 'fonts');
         $this->assertEquals(3, $fontsDomElement->getAttribute('count'), 'There should be 3 fonts, including the default one.');
 
         $fontElements = $fontsDomElement->getElementsByTagName('font');
         $this->assertEquals(3, $fontElements->length, 'There should be 3 associated "font" elements, including the default one.');
+
         // First font should be the default one
         $defaultFontElement = $fontElements->item(0);
         $this->assertChildrenNumEquals(3, $defaultFontElement, 'The default font should only have 3 properties.');
@@ -158,15 +117,17 @@ class WriterWithStyleTest extends \PHPUnit_Framework_TestCase
     public function testAddRowWithStyleShouldApplyStyleToCells()
     {
         $fileName = 'test_add_row_with_style_should_apply_style_to_cells.xlsx';
-        $dataRows = [
-            ['xlsx--11'],
-            ['xlsx--21'],
-            ['xlsx--31'],
-        ];
+
         $style = (new StyleBuilder())->setFontBold()->build();
         $style2 = (new StyleBuilder())->setFontSize(15)->build();
 
-        $this->writeToXLSXFileWithMultipleStyles($dataRows, $fileName, [$style, $style2, null]);
+        $dataRows = [
+            $this->createStyledRowFromValues(['xlsx--11'], $style),
+            $this->createStyledRowFromValues(['xlsx--21'], $style2),
+            $this->createRowFromValues(['xlsx--31']),
+        ];
+
+        $this->writeToXLSXFile($dataRows, $fileName);
 
         $cellDomElements = $this->getCellElementsFromSheetXmlFile($fileName);
         $this->assertEquals(3, count($cellDomElements), 'There should be 3 cells.');
@@ -182,12 +143,6 @@ class WriterWithStyleTest extends \PHPUnit_Framework_TestCase
     public function testAddRowWithStyleShouldApplyStyleToEmptyCellsIfNeeded()
     {
         $fileName = 'test_add_row_with_style_should_apply_style_to_empty_cells_if_needed.xlsx';
-        $dataRows = [
-            ['xlsx--11', '', 'xlsx--13'],
-            ['xlsx--21', '', 'xlsx--23'],
-            ['xlsx--31', '', 'xlsx--33'],
-            ['xlsx--41', '', 'xlsx--43'],
-        ];
 
         $styleWithFont = (new StyleBuilder())->setFontBold()->build();
         $styleWithBackground = (new StyleBuilder())->setBackgroundColor(Color::BLUE)->build();
@@ -195,7 +150,14 @@ class WriterWithStyleTest extends \PHPUnit_Framework_TestCase
         $border = (new BorderBuilder())->setBorderBottom(Color::GREEN)->build();
         $styleWithBorder = (new StyleBuilder())->setBorder($border)->build();
 
-        $this->writeToXLSXFileWithMultipleStyles($dataRows, $fileName, [null, $styleWithFont, $styleWithBackground, $styleWithBorder]);
+        $dataRows = [
+            $this->createRowFromValues(['xlsx--11', '', 'xlsx--13']),
+            $this->createStyledRowFromValues(['xlsx--21', '', 'xlsx--23'], $styleWithFont),
+            $this->createStyledRowFromValues(['xlsx--31', '', 'xlsx--33'], $styleWithBackground),
+            $this->createStyledRowFromValues(['xlsx--41', '', 'xlsx--43'], $styleWithBorder),
+        ];
+
+        $this->writeToXLSXFile($dataRows, $fileName);
 
         $cellDomElements = $this->getCellElementsFromSheetXmlFile($fileName);
 
@@ -229,13 +191,14 @@ class WriterWithStyleTest extends \PHPUnit_Framework_TestCase
     public function testAddRowWithStyleShouldReuseDuplicateStyles()
     {
         $fileName = 'test_add_row_with_style_should_reuse_duplicate_styles.xlsx';
-        $dataRows = [
+
+        $style = (new StyleBuilder())->setFontBold()->build();
+        $dataRows = $this->createStyledRowsFromValues([
             ['xlsx--11'],
             ['xlsx--21'],
-        ];
-        $style = (new StyleBuilder())->setFontBold()->build();
+        ], $style);
 
-        $this->writeToXLSXFile($dataRows, $fileName, $style);
+        $this->writeToXLSXFile($dataRows, $fileName);
 
         $cellDomElements = $this->getCellElementsFromSheetXmlFile($fileName);
         $this->assertEquals('1', $cellDomElements[0]->getAttribute('s'));
@@ -248,12 +211,13 @@ class WriterWithStyleTest extends \PHPUnit_Framework_TestCase
     public function testAddRowWithStyleShouldAddWrapTextAlignmentInfoInStylesXmlFileIfSpecified()
     {
         $fileName = 'test_add_row_with_style_should_add_wrap_text_alignment.xlsx';
-        $dataRows = [
-            ['xlsx--11', 'xlsx--12'],
-        ];
-        $style = (new StyleBuilder())->setShouldWrapText()->build();
 
-        $this->writeToXLSXFile($dataRows, $fileName, $style);
+        $style = (new StyleBuilder())->setShouldWrapText()->build();
+        $dataRows = $this->createStyledRowsFromValues([
+            ['xlsx--11', 'xlsx--12'],
+        ], $style);
+
+        $this->writeToXLSXFile($dataRows, $fileName);
 
         $cellXfsDomElement = $this->getXmlSectionFromStylesXmlFile($fileName, 'cellXfs');
         $xfElement = $cellXfsDomElement->getElementsByTagName('xf')->item(1);
@@ -267,12 +231,13 @@ class WriterWithStyleTest extends \PHPUnit_Framework_TestCase
     public function testAddRowWithStyleShouldApplyWrapTextIfCellContainsNewLine()
     {
         $fileName = 'test_add_row_with_style_should_apply_wrap_text_if_new_lines.xlsx';
-        $dataRows = [
+
+        $dataRows = $this->createStyledRowsFromValues([
             ["xlsx--11\nxlsx--11"],
             ['xlsx--21'],
-        ];
+        ], $this->defaultStyle);
 
-        $this->writeToXLSXFile($dataRows, $fileName, $this->defaultStyle);
+        $this->writeToXLSXFile($dataRows, $fileName);
 
         $cellXfsDomElement = $this->getXmlSectionFromStylesXmlFile($fileName, 'cellXfs');
         $xfElement = $cellXfsDomElement->getElementsByTagName('xf')->item(1);
@@ -286,11 +251,14 @@ class WriterWithStyleTest extends \PHPUnit_Framework_TestCase
     public function testAddBackgroundColor()
     {
         $fileName = 'test_add_background_color.xlsx';
-        $dataRows = [
-            ['BgColor'],
-        ];
+
         $style = (new StyleBuilder())->setBackgroundColor(Color::WHITE)->build();
-        $this->writeToXLSXFile($dataRows, $fileName, $style);
+        $dataRows = $this->createStyledRowsFromValues([
+            ['BgColor'],
+        ], $style);
+
+        $this->writeToXLSXFile($dataRows, $fileName);
+
         $fillsDomElement = $this->getXmlSectionFromStylesXmlFile($fileName, 'fills');
         $this->assertEquals(3, $fillsDomElement->getAttribute('count'), 'There should be 3 fills, including the 2 default ones');
 
@@ -314,17 +282,16 @@ class WriterWithStyleTest extends \PHPUnit_Framework_TestCase
     public function testReuseBackgroundColorSharedDefinition()
     {
         $fileName = 'test_add_background_color_shared_definition.xlsx';
+
+        $style = (new StyleBuilder())->setBackgroundColor(Color::RED)->setFontBold()->build();
+        $style2 = (new StyleBuilder())->setBackgroundColor(Color::RED)->build();
+
         $dataRows = [
-            ['row-bold-background-red'],
-            ['row-background-red'],
+            $this->createStyledRowFromValues(['row-bold-background-red'], $style),
+            $this->createStyledRowFromValues(['row-background-red'], $style2),
         ];
 
-        $styles = [
-            (new StyleBuilder())->setBackgroundColor(Color::RED)->setFontBold()->build(),
-            (new StyleBuilder())->setBackgroundColor(Color::RED)->build(),
-        ];
-
-        $this->writeToXLSXFileWithMultipleStyles($dataRows, $fileName, $styles);
+        $this->writeToXLSXFile($dataRows, $fileName);
 
         $fillsDomElement = $this->getXmlSectionFromStylesXmlFile($fileName, 'fills');
         $this->assertEquals(
@@ -354,12 +321,6 @@ class WriterWithStyleTest extends \PHPUnit_Framework_TestCase
     {
         $fileName = 'test_borders.xlsx';
 
-        $dataRows = [
-            ['row-with-border-bottom-green-thick-solid'],
-            ['row-without-border'],
-            ['row-with-border-top-red-thin-dashed'],
-        ];
-
         $borderBottomGreenThickSolid = (new BorderBuilder())
             ->setBorderBottom(Color::GREEN, Border::WIDTH_THICK, Border::STYLE_SOLID)->build();
 
@@ -372,7 +333,14 @@ class WriterWithStyleTest extends \PHPUnit_Framework_TestCase
             (new StyleBuilder())->setBorder($borderTopRedThinDashed)->build(),
         ];
 
-        $this->writeToXLSXFileWithMultipleStyles($dataRows, $fileName, $styles);
+        $dataRows = [
+            $this->createStyledRowFromValues(['row-with-border-bottom-green-thick-solid'], $styles[0]),
+            $this->createStyledRowFromValues(['row-without-border'], $styles[1]),
+            $this->createStyledRowFromValues(['row-with-border-top-red-thin-dashed'], $styles[2]),
+        ];
+
+        $this->writeToXLSXFile($dataRows, $fileName);
+
         $borderElements = $this->getXmlSectionFromStylesXmlFile($fileName, 'borders');
         $this->assertEquals(3, $borderElements->getAttribute('count'), '3 borders present');
 
@@ -388,10 +356,6 @@ class WriterWithStyleTest extends \PHPUnit_Framework_TestCase
         // Border should be Left, Right, Top, Bottom
         $fileName = 'test_borders_correct_order.xlsx';
 
-        $dataRows = [
-            ['I am a teapot'],
-        ];
-
         $borders = (new BorderBuilder())
             ->setBorderRight()
             ->setBorderTop()
@@ -400,7 +364,12 @@ class WriterWithStyleTest extends \PHPUnit_Framework_TestCase
             ->build();
 
         $style = (new StyleBuilder())->setBorder($borders)->build();
-        $this->writeToXLSXFile($dataRows, $fileName, $style);
+
+        $dataRows = $this->createStyledRowsFromValues([
+            ['I am a teapot'],
+        ], $style);
+
+        $this->writeToXLSXFile($dataRows, $fileName);
         $borderElements = $this->getXmlSectionFromStylesXmlFile($fileName, 'borders');
 
         $correctOrdering = [
@@ -429,7 +398,7 @@ class WriterWithStyleTest extends \PHPUnit_Framework_TestCase
     public function testSetDefaultRowStyle()
     {
         $fileName = 'test_set_default_row_style.xlsx';
-        $dataRows = [['xlsx--11']];
+        $dataRows = $this->createRowsFromValues([['xlsx--11']]);
 
         $defaultFontSize = 50;
         $defaultStyle = (new StyleBuilder())->setFontSize($defaultFontSize)->build();
@@ -463,22 +432,15 @@ class WriterWithStyleTest extends \PHPUnit_Framework_TestCase
         $borderRightFontBoldStyle = (new StyleMerger())->merge($borderRightStyle, $fontStyle);
 
         $dataRows = [
-            ['Border-Left'],
-            ['Empty'],
-            ['Font-Bold'],
-            ['Border-Right'],
-            ['Border-Right-Font-Bold'],
+            $this->createStyledRowFromValues(['Border-Left'], $borderLeftStyle),
+            $this->createStyledRowFromValues(['Empty'], $emptyStyle),
+            $this->createStyledRowFromValues(['Font-Bold'], $fontStyle),
+            $this->createStyledRowFromValues(['Border-Right'], $borderRightStyle),
+            $this->createStyledRowFromValues(['Border-Right-Font-Bold'], $borderRightFontBoldStyle),
         ];
 
-        $styles = [
-            $borderLeftStyle,
-            $emptyStyle,
-            $fontStyle,
-            $borderRightStyle,
-            $borderRightFontBoldStyle,
-        ];
+        $this->writeToXLSXFile($dataRows, $fileName);
 
-        $this->writeToXLSXFileWithMultipleStyles($dataRows, $fileName, $styles);
         $borderElements = $this->getXmlSectionFromStylesXmlFile($fileName, 'borders');
 
         $this->assertEquals(3, $borderElements->getAttribute('count'), '3 borders in count attribute');
@@ -514,12 +476,11 @@ class WriterWithStyleTest extends \PHPUnit_Framework_TestCase
     }
 
     /**
-     * @param array $allRows
+     * @param Row[] $allRows
      * @param string $fileName
-     * @param \Box\Spout\Writer\Common\Entity\Style\Style $style
      * @return Writer
      */
-    private function writeToXLSXFile($allRows, $fileName, $style)
+    private function writeToXLSXFile($allRows, $fileName)
     {
         $this->createGeneratedFolderIfNeeded($fileName);
         $resourcePath = $this->getGeneratedResourcePath($fileName);
@@ -529,14 +490,14 @@ class WriterWithStyleTest extends \PHPUnit_Framework_TestCase
         $writer->setShouldUseInlineStrings(true);
 
         $writer->openToFile($resourcePath);
-        $writer->addRowsWithStyle($allRows, $style);
+        $writer->addRows($allRows);
         $writer->close();
 
         return $writer;
     }
 
     /**
-     * @param array $allRows
+     * @param Row[] $allRows
      * @param string $fileName
      * @param \Box\Spout\Writer\Common\Entity\Style\Style|null $defaultStyle
      * @return Writer
@@ -558,37 +519,6 @@ class WriterWithStyleTest extends \PHPUnit_Framework_TestCase
         return $writer;
     }
 
-    /**
-     * @param array $allRows
-     * @param string $fileName
-     * @param \Box\Spout\Writer\Common\Entity\Style\Style|null[] $styles
-     * @return Writer
-     */
-    private function writeToXLSXFileWithMultipleStyles($allRows, $fileName, $styles)
-    {
-        // there should be as many rows as there are styles passed in
-        $this->assertEquals(count($allRows), count($styles));
-
-        $this->createGeneratedFolderIfNeeded($fileName);
-        $resourcePath = $this->getGeneratedResourcePath($fileName);
-
-        /** @var \Box\Spout\Writer\XLSX\Writer $writer */
-        $writer = WriterFactory::create(Type::XLSX);
-        $writer->setShouldUseInlineStrings(true);
-
-        $writer->openToFile($resourcePath);
-        for ($i = 0; $i < count($allRows); $i++) {
-            if ($styles[$i] === null) {
-                $writer->addRow($allRows[$i]);
-            } else {
-                $writer->addRowWithStyle($allRows[$i], $styles[$i]);
-            }
-        }
-        $writer->close();
-
-        return $writer;
-    }
-
     /**
      * @param string $fileName
      * @param string $section
diff --git a/tests/bootstrap.php b/tests/bootstrap.php
index df50f53..853ad56 100644
--- a/tests/bootstrap.php
+++ b/tests/bootstrap.php
@@ -5,6 +5,7 @@ require_once dirname(__DIR__) . '/vendor/autoload.php';
 require_once dirname(__DIR__) . '/tests/Spout/TestUsingResource.php';
 require_once dirname(__DIR__) . '/tests/Spout/ReflectionHelper.php';
 require_once dirname(__DIR__) . '/tests/Spout/Reader/CSV/SpoutTestStream.php';
+require_once dirname(__DIR__) . '/tests/Spout/Writer/RowCreationHelper.php';
 
 // Make sure a timezone is set to be able to work with dates
 date_default_timezone_set('UTC');