Unit Tests on Section directory

.gitignore

@@ -9,6 +9,7 @@ phpunit.xml
 composer.lock
 composer.phar
 vendor
+/report
 /.settings
 /.buildpath
 /.project

Classes/PHPWord/Section/Footer.php

@@ -196,6 +196,7 @@ class PHPWord_Section_Footer
 
     /**
      * Get all Footer Elements
+     * @return array
      */
     public function getElements()
     {

Classes/PHPWord/Section/Footnote.php

@@ -113,7 +113,7 @@ class PHPWord_Section_Footnote {
   /**
    * Get Footnote content
    *
-   * @return string
+   * @return array
    */
   public function getElements() {
     return $this->_elementCollection;

Classes/PHPWord/Section/PageBreak.php

@@ -36,6 +36,5 @@ class PHPWord_Section_PageBreak
      */
     public function __construct()
     {
-        // nothing
     }
 }

Classes/PHPWord/Section/Settings.php

@@ -150,7 +150,6 @@ class PHPWord_Section_Settings
      */
     private $_borderBottomColor;
 
-
     /**
      * Page Numbering Start
      *
@@ -653,7 +652,7 @@ class PHPWord_Section_Settings
     /**
      * Set Section Columns Count
      *
-     * @param in $pValue
+     * @param int $pValue
      */
     public function setColsNum($pValue = '') {
         $this->_colsNum = $pValue;

Classes/PHPWord/Section/TextBreak.php

@@ -36,6 +36,5 @@ class PHPWord_Section_TextBreak
      */
     public function __construct()
     {
-        // nothing
     }
 }

Tests/PHPWord/Section/Footer/PreserveTextTest.php

@@ -0,0 +1,30 @@
+<?php
+namespace PHPWord\Tests;
+
+use PHPUnit_Framework_TestCase;
+use PHPWord_Section_Footer_PreserveText;
+
+class PHPWord_Section_Footer_PreserveTextTest extends \PHPUnit_Framework_TestCase {
+  public function testConstruct(){
+    $oPreserveText = new PHPWord_Section_Footer_PreserveText();
+
+    $this->assertInstanceOf('PHPWord_Section_Footer_PreserveText', $oPreserveText);
+    $this->assertEquals($oPreserveText->getText(), null);
+    $this->assertEquals($oPreserveText->getFontStyle(), null);
+    $this->assertEquals($oPreserveText->getParagraphStyle(), null);
+  }
+
+  public function testConstructWithString(){
+    $oPreserveText = new PHPWord_Section_Footer_PreserveText('text', 'styleFont', 'styleParagraph');
+    $this->assertEquals($oPreserveText->getText(), 'text');
+    $this->assertEquals($oPreserveText->getFontStyle(), 'styleFont');
+    $this->assertEquals($oPreserveText->getParagraphStyle(), 'styleParagraph');
+  }
+
+  public function testConstructWithArray(){
+    $oPreserveText = new PHPWord_Section_Footer_PreserveText('text', array('align'=>'center'), array('marginLeft'=>600, 'marginRight'=>600, 'marginTop'=>600, 'marginBottom'=>600));
+    $this->assertInstanceOf('PHPWord_Style_Font', $oPreserveText->getFontStyle());
+    $this->assertInstanceOf('PHPWord_Style_Paragraph', $oPreserveText->getParagraphStyle());
+  }
+}
+ 

Tests/PHPWord/Section/FooterTest.php

@@ -0,0 +1,110 @@
+<?php
+namespace PHPWord\Tests;
+
+use PHPUnit_Framework_TestCase;
+use PHPWord_Section_Footer;
+
+class PHPWord_Section_FooterTest extends \PHPUnit_Framework_TestCase {
+
+  public function testConstruct(){
+    $iVal = rand(1, 1000);
+    $oFooter = new PHPWord_Section_Footer($iVal);
+
+    $this->assertInstanceOf('PHPWord_Section_Footer', $oFooter);
+    $this->assertEquals($oFooter->getFooterCount(), $iVal);
+  }
+
+  public function testRelationID(){
+    $oFooter = new PHPWord_Section_Footer(0);
+
+    $iVal = rand(1, 1000);
+    $oFooter->setRelationId($iVal);
+    $this->assertEquals($oFooter->getRelationId(), $iVal);
+  }
+
+  public function testAddText(){
+    $oFooter = new PHPWord_Section_Footer(1);
+    $element = $oFooter->addText('text');
+
+    $this->assertCount(1, $oFooter->getElements());
+    $this->assertInstanceOf('PHPWord_Section_Text', $element);
+
+  }
+
+  public function testAddTextNotUTF8(){
+    $oFooter = new PHPWord_Section_Footer(1);
+    $element = $oFooter->addText(utf8_decode('ééé'));
+
+    $this->assertCount(1, $oFooter->getElements());
+    $this->assertInstanceOf('PHPWord_Section_Text', $element);
+    $this->assertEquals($element->getText(), 'ééé');
+  }
+
+  public function testAddTextBreak(){
+    $oFooter = new PHPWord_Section_Footer(1);
+    $iVal = rand(1, 1000);
+    $oFooter->addTextBreak($iVal);
+
+    $this->assertCount($iVal, $oFooter->getElements());
+  }
+
+  public function testCreateTextRun(){
+    $oFooter = new PHPWord_Section_Footer(1);
+    $element = $oFooter->createTextRun();
+
+    $this->assertCount(1, $oFooter->getElements());
+    $this->assertInstanceOf('PHPWord_Section_TextRun', $element);
+  }
+
+  public function testAddTable(){
+    $oFooter = new PHPWord_Section_Footer(1);
+    $element = $oFooter->addTable();
+
+    $this->assertCount(1, $oFooter->getElements());
+    $this->assertInstanceOf('PHPWord_Section_Table', $element);
+  }
+
+  public function testAddImage(){
+    $src = \join(
+      \DIRECTORY_SEPARATOR,
+      array(\PHPWORD_TESTS_DIR_ROOT, '_files', 'images', 'earth.jpg')
+    );
+    $oFooter = new PHPWord_Section_Footer(1);
+    $element = $oFooter->addImage($src);
+
+    $this->assertCount(1, $oFooter->getElements());
+    $this->assertInstanceOf('PHPWord_Section_Image', $element);
+  }
+
+  public function testAddMemoryImage(){
+    $oFooter = new PHPWord_Section_Footer(1);
+    $element = $oFooter->addMemoryImage('https://assets.mozillalabs.com/Brands-Logos/Thunderbird/logo-only/thunderbird_logo-only_RGB.png');
+
+    $this->assertCount(1, $oFooter->getElements());
+    $this->assertInstanceOf('PHPWord_Section_MemoryImage', $element);
+  }
+
+  public function testAddPreserveText(){
+    $oFooter = new PHPWord_Section_Footer(1);
+    $element = $oFooter->addPreserveText('text');
+
+    $this->assertCount(1, $oFooter->getElements());
+    $this->assertInstanceOf('PHPWord_Section_Footer_PreserveText', $element);
+  }
+
+  public function testAddPreserveTextNotUTF8(){
+    $oFooter = new PHPWord_Section_Footer(1);
+    $element = $oFooter->addPreserveText(utf8_decode('ééé'));
+
+    $this->assertCount(1, $oFooter->getElements());
+    $this->assertInstanceOf('PHPWord_Section_Footer_PreserveText', $element);
+    $this->assertEquals($element->getText(), 'ééé');
+  }
+
+  public function testGetElements(){
+    $oFooter = new PHPWord_Section_Footer(1);
+
+    $this->assertInternalType('array', $oFooter->getElements());
+  }
+}
+ 

Tests/PHPWord/Section/FootnoteTest.php

@@ -0,0 +1,58 @@
+<?php
+namespace PHPWord\Tests;
+
+use PHPUnit_Framework_TestCase;
+use PHPWord_Section_Footnote;
+
+class PHPWord_Section_FootnoteTest extends \PHPUnit_Framework_TestCase {
+
+  public function testConstruct(){
+    $oFootnote = new PHPWord_Section_Footnote();
+
+    $this->assertInstanceOf('PHPWord_Section_Footnote', $oFootnote);
+    $this->assertCount(0, $oFootnote->getElements());
+    $this->assertEquals($oFootnote->getParagraphStyle(), null);
+  }
+
+  public function testConstructString(){
+    $oFootnote = new PHPWord_Section_Footnote('pStyle');
+
+    $this->assertEquals($oFootnote->getParagraphStyle(), 'pStyle');
+  }
+
+  public function testConstructArray(){
+    $oFootnote = new PHPWord_Section_Footnote(array('spacing' => 100));
+
+    $this->assertInstanceOf('PHPWord_Style_Paragraph', $oFootnote->getParagraphStyle());
+  }
+
+  public function testAddText(){
+    $oFootnote = new PHPWord_Section_Footnote();
+    $element = $oFootnote->addText('text');
+
+    $this->assertCount(1, $oFootnote->getElements());
+    $this->assertInstanceOf('PHPWord_Section_Text', $element);
+  }
+
+  public function testAddLink(){
+    $oFootnote = new PHPWord_Section_Footnote();
+    $element = $oFootnote->addLink('http://www.google.fr');
+
+    $this->assertCount(1, $oFootnote->getElements());
+    $this->assertInstanceOf('PHPWord_Section_Link', $element);
+  }
+
+  public function testReferenceId(){
+    $oFootnote = new PHPWord_Section_Footnote();
+
+    $iVal = rand(1, 1000);
+    $oFootnote->setReferenceId($iVal);
+    $this->assertEquals($oFootnote->getReferenceId(), $iVal);
+  }
+
+  public function testGetElements(){
+    $oFootnote = new PHPWord_Section_Footnote();
+    $this->assertInternalType('array', $oFootnote->getElements());
+  }
+}
+ 

Tests/PHPWord/Section/HeaderTest.php

@@ -0,0 +1,146 @@
+<?php
+namespace PHPWord\Tests;
+
+use PHPUnit_Framework_TestCase;
+use PHPWord_Section_Header;
+
+class PHPWord_Section_HeaderTest extends \PHPUnit_Framework_TestCase {
+  public function testConstructDefault() {
+    $iVal = rand(1, 1000);
+    $oHeader = new PHPWord_Section_Header($iVal);
+
+    $this->assertInstanceOf('PHPWord_Section_Header', $oHeader);
+    $this->assertEquals($oHeader->getHeaderCount(), $iVal);
+    $this->assertEquals($oHeader->getType(), PHPWord_Section_Header::AUTO);
+  }
+
+  public function testAddText(){
+    $oHeader = new PHPWord_Section_Header(1);
+    $element = $oHeader->addText('text');
+
+    $this->assertInstanceOf('PHPWord_Section_Text', $element);
+    $this->assertCount(1, $oHeader->getElements());
+    $this->assertEquals($element->getText(), 'text');
+  }
+
+  public function testAddTextNotUTF8(){
+    $oHeader = new PHPWord_Section_Header(1);
+    $element = $oHeader->addText(utf8_decode('ééé'));
+
+    $this->assertInstanceOf('PHPWord_Section_Text', $element);
+    $this->assertCount(1, $oHeader->getElements());
+    $this->assertEquals($element->getText(), 'ééé');
+  }
+
+  public function testAddTextBreak(){
+    $oHeader = new PHPWord_Section_Header(1);
+    $oHeader->addTextBreak();
+    $this->assertCount(1, $oHeader->getElements());
+  }
+
+  public function testAddTextBreakWithParams(){
+    $oHeader = new PHPWord_Section_Header(1);
+    $iVal = rand(1, 1000);
+    $oHeader->addTextBreak($iVal);
+    $this->assertCount($iVal, $oHeader->getElements());
+  }
+
+  public function testCreateTextRun(){
+    $oHeader = new PHPWord_Section_Header(1);
+    $element = $oHeader->createTextRun();
+    $this->assertInstanceOf('PHPWord_Section_TextRun', $element);
+    $this->assertCount(1, $oHeader->getElements());
+  }
+
+  public function testAddTable(){
+    $oHeader = new PHPWord_Section_Header(1);
+    $element = $oHeader->addTable();
+    $this->assertInstanceOf('PHPWord_Section_Table', $element);
+    $this->assertCount(1, $oHeader->getElements());
+  }
+
+  public function testAddImage(){
+    $src = \join(
+      \DIRECTORY_SEPARATOR,
+      array(\PHPWORD_TESTS_DIR_ROOT, '_files', 'images', 'earth.jpg')
+    );
+    $oHeader = new PHPWord_Section_Header(1);
+    $element = $oHeader->addImage($src);
+
+    $this->assertCount(1, $oHeader->getElements());
+    $this->assertInstanceOf('PHPWord_Section_Image', $element);
+  }
+
+  public function testAddMemoryImage(){
+    $oHeader = new PHPWord_Section_Header(1);
+    $element = $oHeader->addMemoryImage('https://assets.mozillalabs.com/Brands-Logos/Thunderbird/logo-only/thunderbird_logo-only_RGB.png');
+
+    $this->assertCount(1, $oHeader->getElements());
+    $this->assertInstanceOf('PHPWord_Section_MemoryImage', $element);
+  }
+
+  public function testAddPreserveText(){
+    $oHeader = new PHPWord_Section_Header(1);
+    $element = $oHeader->addPreserveText('text');
+
+    $this->assertCount(1, $oHeader->getElements());
+    $this->assertInstanceOf('PHPWord_Section_Footer_PreserveText', $element);
+  }
+
+  public function testAddPreserveTextNotUTF8(){
+    $oHeader = new PHPWord_Section_Header(1);
+    $element = $oHeader->addPreserveText(utf8_decode('ééé'));
+
+    $this->assertCount(1, $oHeader->getElements());
+    $this->assertInstanceOf('PHPWord_Section_Footer_PreserveText', $element);
+    $this->assertEquals($element->getText(), 'ééé');
+  }
+
+  public function testAddWatermark(){
+    $src = \join(
+      \DIRECTORY_SEPARATOR,
+      array(\PHPWORD_TESTS_DIR_ROOT, '_files', 'images', 'earth.jpg')
+    );
+    $oHeader = new PHPWord_Section_Header(1);
+    $element = $oHeader->addWatermark($src);
+
+    $this->assertCount(1, $oHeader->getElements());
+    $this->assertInstanceOf('PHPWord_Section_Image', $element);
+  }
+
+  public function testGetElements(){
+    $oHeader = new PHPWord_Section_Header(1);
+
+    $this->assertInternalType('array', $oHeader->getElements());
+  }
+
+  public function testRelationId(){
+    $oHeader = new PHPWord_Section_Header(1);
+
+    $iVal = rand(1, 1000);
+    $oHeader->setRelationId($iVal);
+    $this->assertEquals($oHeader->getRelationId(), $iVal);
+  }
+
+  public function testResetType(){
+    $oHeader = new PHPWord_Section_Header(1);
+    $oHeader->firstPage();
+    $oHeader->resetType();
+
+    $this->assertEquals($oHeader->getType(), PHPWord_Section_Header::AUTO);
+  }
+
+  public function testFirstPage(){
+    $oHeader = new PHPWord_Section_Header(1);
+    $oHeader->firstPage();
+
+    $this->assertEquals($oHeader->getType(), PHPWord_Section_Header::FIRST);
+  }
+
+  public function testEvenPage(){
+    $oHeader = new PHPWord_Section_Header(1);
+    $oHeader->evenPage();
+
+    $this->assertEquals($oHeader->getType(), PHPWord_Section_Header::EVEN);
+  }
+}

Tests/PHPWord/Section/ImageTest.php

@@ -0,0 +1,62 @@
+<?php
+namespace PHPWord\Tests;
+
+use PHPUnit_Framework_TestCase;
+use PHPWord_Section_Image;
+use PHPWord_Style_Image;
+
+class PHPWord_Section_ImageTest extends \PHPUnit_Framework_TestCase {
+  public function testConstruct() {
+    $src = \join(
+      \DIRECTORY_SEPARATOR,
+      array(\PHPWORD_TESTS_DIR_ROOT, '_files', 'images', 'firefox.png')
+    );
+    $oImage = new PHPWord_Section_Image($src);
+
+    $this->assertInstanceOf('PHPWord_Section_Image', $oImage);
+    $this->assertEquals($oImage->getSource(), $src);
+    $this->assertEquals($oImage->getMediaId(), md5($src));
+    $this->assertEquals($oImage->getIsWatermark(), false);
+    $this->assertInstanceOf('PHPWord_Style_Image', $oImage->getStyle());
+  }
+  public function testConstructWithStyle() {
+    $src = \join(
+      \DIRECTORY_SEPARATOR,
+      array(\PHPWORD_TESTS_DIR_ROOT, '_files', 'images', 'firefox.png')
+    );
+    $oImage = new PHPWord_Section_Image($src, array('width'=>210, 'height'=>210, 'align'=>'center', 'wrappingStyle' => \PHPWord_Style_Image::WRAPPING_STYLE_BEHIND));
+
+    $this->assertInstanceOf('PHPWord_Style_Image', $oImage->getStyle());
+  }
+
+  public function testStyle(){
+    $oImage = new PHPWord_Section_Image(\join(
+      \DIRECTORY_SEPARATOR,
+      array(\PHPWORD_TESTS_DIR_ROOT, '_files', 'images', 'earth.jpg')
+    ), array('width'=>210, 'height'=>210, 'align'=>'center'));
+
+    $this->assertInstanceOf('PHPWord_Style_Image', $oImage->getStyle());
+  }
+
+  public function testRelationID(){
+    $oImage = new PHPWord_Section_Image(\join(
+      \DIRECTORY_SEPARATOR,
+      array(\PHPWORD_TESTS_DIR_ROOT, '_files', 'images', 'earth.jpg')
+    ));
+
+    $iVal = rand(1, 1000);
+    $oImage->setRelationId($iVal);
+    $this->assertEquals($oImage->getRelationId(), $iVal);
+  }
+
+  public function testWatermark(){
+    $oImage = new PHPWord_Section_Image(\join(
+      \DIRECTORY_SEPARATOR,
+      array(\PHPWORD_TESTS_DIR_ROOT, '_files', 'images', 'earth.jpg')
+    ));
+
+    $oImage->setIsWatermark(true);
+    $this->assertEquals($oImage->getIsWatermark(), true);
+  }
+}
+ 

Tests/PHPWord/Section/LinkTest.php

@@ -0,0 +1,42 @@
+<?php
+namespace PHPWord\Tests;
+
+use PHPUnit_Framework_TestCase;
+use PHPWord_Section_Link;
+use PHPWord_Style_Font;
+
+class PHPWord_Section_LinkTest extends \PHPUnit_Framework_TestCase {
+  public function testConstructDefault() {
+    $oLink = new PHPWord_Section_Link('http://www.google.com');
+
+    $this->assertInstanceOf('PHPWord_Section_Link', $oLink);
+    $this->assertEquals($oLink->getLinkSrc(), 'http://www.google.com');
+    $this->assertEquals($oLink->getLinkName(), null);
+    $this->assertEquals($oLink->getFontStyle(), null);
+    $this->assertEquals($oLink->getParagraphStyle(), null);
+  }
+  public function testConstructWithParamsArray() {
+    $oLink = new PHPWord_Section_Link('http://www.google.com', 'Search Engine', array('color'=>'0000FF', 'underline'=>PHPWord_Style_Font::UNDERLINE_SINGLE), array('marginLeft'=>600, 'marginRight'=>600, 'marginTop'=>600, 'marginBottom'=>600));
+
+    $this->assertInstanceOf('PHPWord_Section_Link', $oLink);
+    $this->assertEquals($oLink->getLinkSrc(), 'http://www.google.com');
+    $this->assertEquals($oLink->getLinkName(), 'Search Engine');
+    $this->assertInstanceOf('PHPWord_Style_Font', $oLink->getFontStyle());
+    $this->assertInstanceOf('PHPWord_Style_Paragraph', $oLink->getParagraphStyle());
+  }
+  public function testConstructWithParamsString() {
+    $oLink = new PHPWord_Section_Link('http://www.google.com', null, 'fontStyle', 'paragraphStyle');
+
+    $this->assertEquals($oLink->getFontStyle(), 'fontStyle');
+    $this->assertEquals($oLink->getParagraphStyle(), 'paragraphStyle');
+  }
+
+  public function testRelationId(){
+    $oLink = new PHPWord_Section_Link('http://www.google.com');
+
+    $iVal = rand(1, 1000);
+    $oLink->setRelationId($iVal);
+    $this->assertEquals($oLink->getRelationId(), $iVal);
+  }
+}
+ 

Tests/PHPWord/Section/ListItemTest.php

@@ -0,0 +1,29 @@
+<?php
+namespace PHPWord\Tests;
+
+use PHPUnit_Framework_TestCase;
+use PHPWord_Section_ListItem;
+use PHPWord_Style_ListItem;
+
+class PHPWord_Section_ListItemTest extends \PHPUnit_Framework_TestCase {
+
+  public function testText(){
+    $oListItem = new PHPWord_Section_ListItem('text');
+
+    $this->assertInstanceOf('PHPWord_Section_Text', $oListItem->getTextObject());
+  }
+
+  public function testStyle(){
+    $oListItem = new PHPWord_Section_ListItem('text', 1, null, array('listType'=>PHPWord_Style_ListItem::TYPE_NUMBER));
+
+    $this->assertInstanceOf('PHPWord_Style_ListItem', $oListItem->getStyle());
+    $this->assertEquals($oListItem->getStyle()->getListType(), PHPWord_Style_ListItem::TYPE_NUMBER);
+  }
+  public function testDepth(){
+    $iVal = rand(1, 1000);
+    $oListItem = new PHPWord_Section_ListItem('text', $iVal);
+
+    $this->assertEquals($oListItem->getDepth(), $iVal);
+  }
+}
+ 

Tests/PHPWord/Section/MemoryImageTest.php

@@ -0,0 +1,89 @@
+<?php
+namespace PHPWord\Tests;
+
+use PHPUnit_Framework_TestCase;
+use PHPWord_Section_MemoryImage;
+
+class PHPWord_Section_MemoryImageTest extends \PHPUnit_Framework_TestCase {
+  public function testPNG() {
+    $src = \join(
+      \DIRECTORY_SEPARATOR,
+      array(\PHPWORD_TESTS_DIR_ROOT, '_files', 'images', 'firefox.png')
+    );
+    $oMemoryImage = new PHPWord_Section_MemoryImage($src);
+
+    $this->assertInstanceOf('PHPWord_Section_MemoryImage', $oMemoryImage);
+    $this->assertEquals($oMemoryImage->getSource(), $src);
+    $this->assertEquals($oMemoryImage->getMediaId(), md5($src));
+    $this->assertEquals($oMemoryImage->getImageCreateFunction(), 'imagecreatefrompng');
+    $this->assertEquals($oMemoryImage->getImageFunction(), 'imagepng');
+    $this->assertEquals($oMemoryImage->getImageExtension(), 'png');
+    $this->assertEquals($oMemoryImage->getImageType(), 'image/png');
+  }
+
+  public function testGIF() {
+    $src = \join(
+      \DIRECTORY_SEPARATOR,
+      array(\PHPWORD_TESTS_DIR_ROOT, '_files', 'images', 'mario.gif')
+    );
+    $oMemoryImage = new PHPWord_Section_MemoryImage($src);
+
+    $this->assertInstanceOf('PHPWord_Section_MemoryImage', $oMemoryImage);
+    $this->assertEquals($oMemoryImage->getSource(), $src);
+    $this->assertEquals($oMemoryImage->getMediaId(), md5($src));
+    $this->assertEquals($oMemoryImage->getImageCreateFunction(), 'imagecreatefromgif');
+    $this->assertEquals($oMemoryImage->getImageFunction(), 'imagegif');
+    $this->assertEquals($oMemoryImage->getImageExtension(), 'gif');
+    $this->assertEquals($oMemoryImage->getImageType(), 'image/gif');
+  }
+
+  public function testJPG() {
+    $src = \join(
+      \DIRECTORY_SEPARATOR,
+      array(\PHPWORD_TESTS_DIR_ROOT, '_files', 'images', 'earth.jpg')
+    );
+    $oMemoryImage = new PHPWord_Section_MemoryImage($src);
+
+    $this->assertInstanceOf('PHPWord_Section_MemoryImage', $oMemoryImage);
+    $this->assertEquals($oMemoryImage->getSource(), $src);
+    $this->assertEquals($oMemoryImage->getMediaId(), md5($src));
+    $this->assertEquals($oMemoryImage->getImageCreateFunction(), 'imagecreatefromjpeg');
+    $this->assertEquals($oMemoryImage->getImageFunction(), 'imagejpeg');
+    $this->assertEquals($oMemoryImage->getImageExtension(), 'jpg');
+    $this->assertEquals($oMemoryImage->getImageType(), 'image/jpeg');
+  }
+
+  public function testBMP() {
+    $oMemoryImage = new PHPWord_Section_MemoryImage(\join(
+      \DIRECTORY_SEPARATOR,
+      array(\PHPWORD_TESTS_DIR_ROOT, '_files', 'images', 'duke_nukem.bmp')
+    ));
+
+    $this->assertInstanceOf('PHPWord_Section_MemoryImage', $oMemoryImage);
+    $this->assertEquals($oMemoryImage->getImageCreateFunction(), null);
+    $this->assertEquals($oMemoryImage->getImageFunction(), null);
+    $this->assertEquals($oMemoryImage->getImageExtension(), null);
+    $this->assertEquals($oMemoryImage->getImageType(), 'image/x-ms-bmp');
+  }
+
+  public function testStyle(){
+    $oMemoryImage = new PHPWord_Section_MemoryImage(\join(
+      \DIRECTORY_SEPARATOR,
+      array(\PHPWORD_TESTS_DIR_ROOT, '_files', 'images', 'earth.jpg')
+    ), array('width'=>210, 'height'=>210, 'align'=>'center'));
+
+    $this->assertInstanceOf('PHPWord_Style_Image', $oMemoryImage->getStyle());
+  }
+
+  public function testRelationID(){
+    $oMemoryImage = new PHPWord_Section_MemoryImage(\join(
+      \DIRECTORY_SEPARATOR,
+      array(\PHPWORD_TESTS_DIR_ROOT, '_files', 'images', 'earth.jpg')
+    ));
+
+    $iVal = rand(1, 1000);
+    $oMemoryImage->setRelationId($iVal);
+    $this->assertEquals($oMemoryImage->getRelationId(), $iVal);
+  }
+}
+ 

Tests/PHPWord/Section/ObjectTest.php

@@ -0,0 +1,79 @@
+<?php
+namespace PHPWord\Tests;
+
+use PHPUnit_Framework_TestCase;
+use PHPWord_Section_Object;
+
+class PHPWord_Section_ObjectTest extends \PHPUnit_Framework_TestCase {
+  public function testConstructWithSupportedFiles() {
+    $src = \join(
+      \DIRECTORY_SEPARATOR,
+      array(\PHPWORD_TESTS_DIR_ROOT, '_files', 'documents', 'sheet.xls')
+    );
+    $oObject = new PHPWord_Section_Object($src);
+
+    $this->assertInstanceOf('PHPWord_Section_Object', $oObject);
+    $this->assertInstanceOf('PHPWord_Style_Image', $oObject->getStyle());
+    $this->assertEquals($oObject->getSource(), $src);
+  }
+  public function testConstructWithNotSupportedFiles() {
+    $src = \join(
+      \DIRECTORY_SEPARATOR,
+      array(\PHPWORD_TESTS_DIR_ROOT, '_files', 'xsl', 'passthrough.xsl')
+    );
+    $oObject = new PHPWord_Section_Object($src);
+
+    $this->assertInstanceOf('PHPWord_Section_Object', $oObject);
+    $this->assertEquals($oObject->getSource(), null);
+    $this->assertEquals($oObject->getStyle(), null);
+  }
+
+  public function testConstructWithSupportedFilesAndStyle() {
+    $src = \join(
+      \DIRECTORY_SEPARATOR,
+      array(\PHPWORD_TESTS_DIR_ROOT, '_files', 'documents', 'sheet.xls')
+    );
+    $oObject = new PHPWord_Section_Object($src, array('width' => '230px'));
+
+    $this->assertInstanceOf('PHPWord_Section_Object', $oObject);
+    $this->assertInstanceOf('PHPWord_Style_Image', $oObject->getStyle());
+    $this->assertEquals($oObject->getSource(), $src);
+  }
+
+  public function testRelationId(){
+    $src = \join(
+      \DIRECTORY_SEPARATOR,
+      array(\PHPWORD_TESTS_DIR_ROOT, '_files', 'documents', 'sheet.xls')
+    );
+    $oObject = new PHPWord_Section_Object($src);
+
+    $iVal = rand(1, 1000);
+    $oObject->setRelationId($iVal);
+    $this->assertEquals($oObject->getRelationId(), $iVal);
+  }
+
+  public function testImageRelationId(){
+    $src = \join(
+      \DIRECTORY_SEPARATOR,
+      array(\PHPWORD_TESTS_DIR_ROOT, '_files', 'documents', 'sheet.xls')
+    );
+    $oObject = new PHPWord_Section_Object($src);
+
+    $iVal = rand(1, 1000);
+    $oObject->setImageRelationId($iVal);
+    $this->assertEquals($oObject->getImageRelationId(), $iVal);
+  }
+
+  public function testObjectId(){
+    $src = \join(
+      \DIRECTORY_SEPARATOR,
+      array(\PHPWORD_TESTS_DIR_ROOT, '_files', 'documents', 'sheet.xls')
+    );
+    $oObject = new PHPWord_Section_Object($src);
+
+    $iVal = rand(1, 1000);
+    $oObject->setObjectId($iVal);
+    $this->assertEquals($oObject->getObjectId(), $iVal);
+  }
+}
+ 

Tests/PHPWord/Section/PageBreakTest.php

@@ -0,0 +1,18 @@
+<?php
+namespace PHPWord\Tests;
+
+use PHPUnit_Framework_TestCase;
+use PHPWord_Section_PageBreak;
+
+class PHPWord_Section_PageBreakTest extends \PHPUnit_Framework_TestCase {
+  /**
+   * Executed before each method of the class
+   */
+  public function testConstruct() {
+    // Section Settings
+    $oPageBreak = new PHPWord_Section_PageBreak();
+
+    $this->assertInstanceOf('PHPWord_Section_PageBreak', $oPageBreak);
+  }
+}
+ 

Tests/PHPWord/Section/SettingsTest.php

@@ -0,0 +1,224 @@
+<?php
+namespace PHPWord\Tests;
+
+use PHPUnit_Framework_TestCase;
+use PHPWord_Section_Settings;
+
+class PHPWord_Section_SettingsTest extends \PHPUnit_Framework_TestCase {
+  /**
+   * Executed before each method of the class
+   */
+  public function testSettingValue() {
+    // Section Settings
+    $oSettings = new PHPWord_Section_Settings();
+
+    $oSettings->setSettingValue('_orientation', 'landscape');
+    $this->assertEquals($oSettings->getOrientation(), 'landscape');
+    $this->assertEquals($oSettings->getPageSizeW(), 16838);
+    $this->assertEquals($oSettings->getPageSizeH(), 11906);
+
+    $oSettings->setSettingValue('_orientation', null);
+    $this->assertEquals($oSettings->getOrientation(), null);
+    $this->assertEquals($oSettings->getPageSizeW(), 11906);
+    $this->assertEquals($oSettings->getPageSizeH(), 16838);
+
+    $iVal = rand(1, 1000);
+    $oSettings->setSettingValue('_borderSize', $iVal);
+    $this->assertEquals($oSettings->getBorderSize(), array($iVal, $iVal, $iVal, $iVal));
+    $this->assertEquals($oSettings->getBorderBottomSize(), $iVal);
+    $this->assertEquals($oSettings->getBorderLeftSize(), $iVal);
+    $this->assertEquals($oSettings->getBorderRightSize(), $iVal);
+    $this->assertEquals($oSettings->getBorderTopSize(), $iVal);
+
+    $oSettings->setSettingValue('_borderColor', 'FF00AA');
+    $this->assertEquals($oSettings->getBorderColor(), array('FF00AA', 'FF00AA', 'FF00AA', 'FF00AA'));
+    $this->assertEquals($oSettings->getBorderBottomColor(), 'FF00AA');
+    $this->assertEquals($oSettings->getBorderLeftColor(), 'FF00AA');
+    $this->assertEquals($oSettings->getBorderRightColor(), 'FF00AA');
+    $this->assertEquals($oSettings->getBorderTopColor(), 'FF00AA');
+
+    $iVal = rand(1, 1000);
+    $oSettings->setSettingValue('headerHeight', $iVal);
+    $this->assertEquals($oSettings->getHeaderHeight(), $iVal);
+  }
+
+  public function testMargin(){
+    // Section Settings
+    $oSettings = new PHPWord_Section_Settings();
+
+    $iVal = rand(1, 1000);
+    $oSettings->setMarginTop($iVal);
+    $this->assertEquals($oSettings->getMarginTop(), $iVal);
+
+    $iVal = rand(1, 1000);
+    $oSettings->setMarginBottom($iVal);
+    $this->assertEquals($oSettings->getMarginBottom(), $iVal);
+
+    $iVal = rand(1, 1000);
+    $oSettings->setMarginLeft($iVal);
+    $this->assertEquals($oSettings->getMarginLeft(), $iVal);
+
+    $iVal = rand(1, 1000);
+    $oSettings->setMarginRight($iVal);
+    $this->assertEquals($oSettings->getMarginRight(), $iVal);
+  }
+
+  public function testOrientationLandscape(){
+    // Section Settings
+    $oSettings = new PHPWord_Section_Settings();
+
+    $oSettings->setLandscape();
+    $this->assertEquals($oSettings->getOrientation(), 'landscape');
+    $this->assertEquals($oSettings->getPageSizeW(), 16838);
+    $this->assertEquals($oSettings->getPageSizeH(), 11906);
+  }
+
+  public function testOrientationPortrait(){
+    // Section Settings
+    $oSettings = new PHPWord_Section_Settings();
+
+    $oSettings->setPortrait();
+    $this->assertEquals($oSettings->getOrientation(), null);
+    $this->assertEquals($oSettings->getPageSizeW(), 11906);
+    $this->assertEquals($oSettings->getPageSizeH(), 16838);
+  }
+
+  public function testBorderSize(){
+    // Section Settings
+    $oSettings = new PHPWord_Section_Settings();
+
+    $iVal = rand(1, 1000);
+    $oSettings->setBorderSize($iVal);
+    $this->assertEquals($oSettings->getBorderSize(), array($iVal, $iVal, $iVal, $iVal));
+    $this->assertEquals($oSettings->getBorderBottomSize(), $iVal);
+    $this->assertEquals($oSettings->getBorderLeftSize(), $iVal);
+    $this->assertEquals($oSettings->getBorderRightSize(), $iVal);
+    $this->assertEquals($oSettings->getBorderTopSize(), $iVal);
+
+    $iVal = rand(1, 1000);
+    $oSettings->setBorderBottomSize($iVal);
+    $this->assertEquals($oSettings->getBorderBottomSize(), $iVal);
+
+    $iVal = rand(1, 1000);
+    $oSettings->setBorderLeftSize($iVal);
+    $this->assertEquals($oSettings->getBorderLeftSize(), $iVal);
+
+    $iVal = rand(1, 1000);
+    $oSettings->setBorderRightSize($iVal);
+    $this->assertEquals($oSettings->getBorderRightSize(), $iVal);
+
+    $iVal = rand(1, 1000);
+    $oSettings->setBorderTopSize($iVal);
+    $this->assertEquals($oSettings->getBorderTopSize(), $iVal);
+  }
+
+  public function testBorderColor(){
+    // Section Settings
+    $oSettings = new PHPWord_Section_Settings();
+
+    $oSettings->setBorderColor('FF00AA');
+    $this->assertEquals($oSettings->getBorderColor(), array('FF00AA', 'FF00AA', 'FF00AA', 'FF00AA'));
+    $this->assertEquals($oSettings->getBorderBottomColor(), 'FF00AA');
+    $this->assertEquals($oSettings->getBorderLeftColor(), 'FF00AA');
+    $this->assertEquals($oSettings->getBorderRightColor(), 'FF00AA');
+    $this->assertEquals($oSettings->getBorderTopColor(), 'FF00AA');
+
+    $oSettings->setBorderBottomColor('BBCCDD');
+    $this->assertEquals($oSettings->getBorderBottomColor(), 'BBCCDD');
+
+    $oSettings->setBorderLeftColor('CCDDEE');
+    $this->assertEquals($oSettings->getBorderLeftColor(), 'CCDDEE');
+
+    $oSettings->setBorderRightColor('11EE22');
+    $this->assertEquals($oSettings->getBorderRightColor(), '11EE22');
+
+    $oSettings->setBorderTopColor('22FF33');
+    $this->assertEquals($oSettings->getBorderTopColor(), '22FF33');
+  }
+
+  public function testNumberingStart(){
+    // Section Settings
+    $oSettings = new PHPWord_Section_Settings();
+
+    $this->assertEquals($oSettings->getPageNumberingStart(), null);
+
+    $iVal = rand(1, 1000);
+    $oSettings->setPageNumberingStart($iVal);
+    $this->assertEquals($oSettings->getPageNumberingStart(), $iVal);
+
+    $oSettings->setPageNumberingStart();
+    $this->assertEquals($oSettings->getPageNumberingStart(), null);
+  }
+
+  public function testHeader(){
+    // Section Settings
+    $oSettings = new PHPWord_Section_Settings();
+
+    $this->assertEquals($oSettings->getHeaderHeight(), 720);
+
+    $iVal = rand(1, 1000);
+    $oSettings->setHeaderHeight($iVal);
+    $this->assertEquals($oSettings->getHeaderHeight(), $iVal);
+
+    $oSettings->setHeaderHeight();
+    $this->assertEquals($oSettings->getHeaderHeight(), 720);
+  }
+
+  public function testFooter(){
+    // Section Settings
+    $oSettings = new PHPWord_Section_Settings();
+
+    $this->assertEquals($oSettings->getFooterHeight(), 720);
+
+    $iVal = rand(1, 1000);
+    $oSettings->setFooterHeight($iVal);
+    $this->assertEquals($oSettings->getFooterHeight(), $iVal);
+
+    $oSettings->setFooterHeight();
+    $this->assertEquals($oSettings->getFooterHeight(), 720);
+  }
+
+  public function testColumnsNum(){
+    // Section Settings
+    $oSettings = new PHPWord_Section_Settings();
+
+    // Default
+    $this->assertEquals($oSettings->getColsNum(), 1);
+
+    $iVal = rand(1, 1000);
+    $oSettings->setColsNum($iVal);
+    $this->assertEquals($oSettings->getColsNum(), $iVal);
+
+    $oSettings->setColsNum();
+    $this->assertEquals($oSettings->getColsNum(), 1);
+  }
+
+  public function testColumnsSpace(){
+    // Section Settings
+    $oSettings = new PHPWord_Section_Settings();
+
+    // Default
+    $this->assertEquals($oSettings->getColsSpace(), 720);
+
+    $iVal = rand(1, 1000);
+    $this->assertInstanceOf('PHPWord_Section_Settings', $oSettings->setColsSpace($iVal));
+    $this->assertEquals($oSettings->getColsSpace(), $iVal);
+
+    $this->assertInstanceOf('PHPWord_Section_Settings', $oSettings->setColsSpace());
+    $this->assertEquals($oSettings->getColsSpace(), 1);
+  }
+
+  public function testBreakType(){
+    // Section Settings
+    $oSettings = new PHPWord_Section_Settings();
+
+    $this->assertEquals($oSettings->getBreakType(), null);
+
+    $oSettings->setBreakType('continuous');
+    $this->assertEquals($oSettings->getBreakType(), 'continuous');
+
+    $oSettings->setBreakType();
+    $this->assertEquals($oSettings->getBreakType(), null);
+  }
+}
+ 

Tests/PHPWord/Section/Table/CellTest.php

@@ -0,0 +1,184 @@
+<?php
+namespace PHPWord\Tests;
+
+use PHPUnit_Framework_TestCase;
+use PHPWord_Section_Table_Cell;
+
+class PHPWord_Section_Table_CellTest extends \PHPUnit_Framework_TestCase {
+  public function testConstruct(){
+    $iVal = rand(1, 1000);
+    $oCell = new PHPWord_Section_Table_Cell('section', $iVal);
+
+    $this->assertInstanceOf('PHPWord_Section_Table_Cell', $oCell);
+    $this->assertEquals($oCell->getWidth(), null);
+  }
+
+  public function testConstructWithStyleArray(){
+    $iVal = rand(1, 1000);
+    $oCell = new PHPWord_Section_Table_Cell('section', $iVal, null, array('valign'=>'center'));
+
+    $this->assertInstanceOf('PHPWord_Style_Cell', $oCell->getStyle());
+    $this->assertEquals($oCell->getWidth(), null);
+  }
+
+  public function testConstructWithStyleString(){
+    $iVal = rand(1, 1000);
+    $oCell = new PHPWord_Section_Table_Cell('section', $iVal, null, 'cellStyle');
+
+    $this->assertEquals($oCell->getStyle(), 'cellStyle');
+  }
+
+  public function testAddText(){
+    $oCell = new PHPWord_Section_Table_Cell('section', 1);
+    $element = $oCell->addText('text');
+
+    $this->assertCount(1, $oCell->getElements());
+    $this->assertInstanceOf('PHPWord_Section_Text', $element);
+  }
+
+  public function testAddTextNotUTF8(){
+    $oCell = new PHPWord_Section_Table_Cell('section', 1);
+    $element = $oCell->addText(utf8_decode('ééé'));
+
+    $this->assertCount(1, $oCell->getElements());
+    $this->assertInstanceOf('PHPWord_Section_Text', $element);
+    $this->assertEquals($element->getText(), 'ééé');
+  }
+
+  public function testAddLink(){
+    $oCell = new PHPWord_Section_Table_Cell('section', 1);
+    $element = $oCell->addLink('http://www.google.fr', 'Nom');
+
+    $this->assertCount(1, $oCell->getElements());
+    $this->assertInstanceOf('PHPWord_Section_Link', $element);
+  }
+
+  public function testAddTextBreak(){
+    $oCell = new PHPWord_Section_Table_Cell('section', 1);
+    $oCell->addTextBreak();
+
+    $this->assertCount(1, $oCell->getElements());
+  }
+
+  public function testAddListItem(){
+    $oCell = new PHPWord_Section_Table_Cell('section', 1);
+    $element = $oCell->addListItem('text');
+
+    $this->assertCount(1, $oCell->getElements());
+    $this->assertInstanceOf('PHPWord_Section_ListItem', $element);
+    $this->assertEquals($element->getTextObject()->getText(), 'text');
+  }
+
+  public function testAddListItemNotUTF8(){
+    $oCell = new PHPWord_Section_Table_Cell('section', 1);
+    $element = $oCell->addListItem(utf8_decode('ééé'));
+
+    $this->assertCount(1, $oCell->getElements());
+    $this->assertInstanceOf('PHPWord_Section_ListItem', $element);
+    $this->assertEquals($element->getTextObject()->getText(), 'ééé');
+  }
+
+  public function testAddImageSection(){
+    $src = \join(
+      \DIRECTORY_SEPARATOR,
+      array(\PHPWORD_TESTS_DIR_ROOT, '_files', 'images', 'earth.jpg')
+    );
+    $oCell = new PHPWord_Section_Table_Cell('section', 1);
+    $element = $oCell->addImage($src);
+
+    $this->assertCount(1, $oCell->getElements());
+    $this->assertInstanceOf('PHPWord_Section_Image', $element);
+  }
+
+  public function testAddImageHeader(){
+    $src = \join(
+      \DIRECTORY_SEPARATOR,
+      array(\PHPWORD_TESTS_DIR_ROOT, '_files', 'images', 'earth.jpg')
+    );
+    $oCell = new PHPWord_Section_Table_Cell('header', 1);
+    $element = $oCell->addImage($src);
+
+    $this->assertCount(1, $oCell->getElements());
+    $this->assertInstanceOf('PHPWord_Section_Image', $element);
+  }
+
+  public function testAddImageFooter(){
+    $src = \join(
+      \DIRECTORY_SEPARATOR,
+      array(\PHPWORD_TESTS_DIR_ROOT, '_files', 'images', 'earth.jpg')
+    );
+    $oCell = new PHPWord_Section_Table_Cell('footer', 1);
+    $element = $oCell->addImage($src);
+
+    $this->assertCount(1, $oCell->getElements());
+    $this->assertInstanceOf('PHPWord_Section_Image', $element);
+  }
+
+  public function testAddMemoryImageSection(){
+    $oCell = new PHPWord_Section_Table_Cell('section', 1);
+    $element = $oCell->addMemoryImage('https://assets.mozillalabs.com/Brands-Logos/Thunderbird/logo-only/thunderbird_logo-only_RGB.png');
+
+    $this->assertCount(1, $oCell->getElements());
+    $this->assertInstanceOf('PHPWord_Section_MemoryImage', $element);
+  }
+
+  public function testAddMemoryImageHeader(){
+    $oCell = new PHPWord_Section_Table_Cell('header', 1);
+    $element = $oCell->addMemoryImage('https://assets.mozillalabs.com/Brands-Logos/Thunderbird/logo-only/thunderbird_logo-only_RGB.png');
+
+    $this->assertCount(1, $oCell->getElements());
+    $this->assertInstanceOf('PHPWord_Section_MemoryImage', $element);
+  }
+
+  public function testAddMemoryImageFooter(){
+    $oCell = new PHPWord_Section_Table_Cell('footer', 1);
+    $element = $oCell->addMemoryImage('https://assets.mozillalabs.com/Brands-Logos/Thunderbird/logo-only/thunderbird_logo-only_RGB.png');
+
+    $this->assertCount(1, $oCell->getElements());
+    $this->assertInstanceOf('PHPWord_Section_MemoryImage', $element);
+  }
+
+  public function testAddObjectXLS(){
+    $src = \join(
+      \DIRECTORY_SEPARATOR,
+      array(\PHPWORD_TESTS_DIR_ROOT, '_files', 'documents', 'sheet.xls')
+    );
+    $oCell = new PHPWord_Section_Table_Cell('section', 1);
+    $element = $oCell->addObject($src);
+
+    $this->assertCount(1, $oCell->getElements());
+    $this->assertInstanceOf('PHPWord_Section_Object', $element);
+  }
+
+  public function testAddPreserveText(){
+    $oCell = new PHPWord_Section_Table_Cell('header', 1);
+    $element = $oCell->addPreserveText('text');
+
+    $this->assertCount(1, $oCell->getElements());
+    $this->assertInstanceOf('PHPWord_Section_Footer_PreserveText', $element);
+  }
+
+  public function testAddPreserveTextNotUTF8(){
+    $oCell = new PHPWord_Section_Table_Cell('header', 1);
+    $element = $oCell->addPreserveText(utf8_decode('ééé'));
+
+    $this->assertCount(1, $oCell->getElements());
+    $this->assertInstanceOf('PHPWord_Section_Footer_PreserveText', $element);
+    $this->assertEquals($element->getText(), 'ééé');
+  }
+
+  public function testCreateTextRun(){
+    $oCell = new PHPWord_Section_Table_Cell('section', 1);
+    $element = $oCell->createTextRun();
+
+    $this->assertCount(1, $oCell->getElements());
+    $this->assertInstanceOf('PHPWord_Section_TextRun', $element);
+  }
+
+  public function testGetElements(){
+    $oCell = new PHPWord_Section_Table_Cell('section', 1);
+
+    $this->assertInternalType('array', $oCell->getElements());
+  }
+}
+ 

Tests/PHPWord/Section/Table/RowTest.php

@@ -0,0 +1,35 @@
+<?php
+namespace PHPWord\Tests;
+
+use PHPUnit_Framework_TestCase;
+use PHPWord_Section_Table_Row;
+
+class PHPWord_Section_Table_RowTest extends \PHPUnit_Framework_TestCase {
+  public function testConstruct(){
+    $iVal = rand(1, 1000);
+    $oRow = new PHPWord_Section_Table_Row('section', $iVal);
+
+    $this->assertInstanceOf('PHPWord_Section_Table_Row', $oRow);
+    $this->assertEquals($oRow->getHeight(), null);
+    $this->assertInternalType('array', $oRow->getCells());
+    $this->assertCount(0,  $oRow->getCells());
+    $this->assertInstanceOf('PHPWord_Style_Row', $oRow->getStyle());
+  }
+  public function testConstructWithParams(){
+    $iVal = rand(1, 1000);
+    $iVal2 = rand(1, 1000);
+    $oRow = new PHPWord_Section_Table_Row('section', $iVal, $iVal2, array('borderBottomSize'=>18, 'borderBottomColor'=>'0000FF', 'bgColor'=>'66BBFF'));
+
+    $this->assertEquals($oRow->getHeight(), $iVal2);
+    $this->assertInstanceOf('PHPWord_Style_Row', $oRow->getStyle());
+  }
+
+  public function testAddCell(){
+    $oRow = new PHPWord_Section_Table_Row('section', 1);
+    $element = $oRow->addCell();
+
+    $this->assertInstanceOf('PHPWord_Section_Table_Cell', $element);
+    $this->assertCount(1,  $oRow->getCells());
+  }
+}
+ 

Tests/PHPWord/Section/TableTest.php

@@ -0,0 +1,46 @@
+<?php
+namespace PHPWord\Tests;
+
+use PHPUnit_Framework_TestCase;
+use PHPWord_Section_Table;
+
+class PHPWord_Section_TableTest extends \PHPUnit_Framework_TestCase {
+  public function testConstruct() {
+    $oTable = new PHPWord_Section_Table('section', 1);
+
+    $this->assertInstanceOf('PHPWord_Section_Table', $oTable);
+    $this->assertEquals($oTable->getStyle(), null);
+    $this->assertEquals($oTable->getWidth(), null);
+    $this->assertEquals($oTable->getRows(), array());
+    $this->assertCount(0, $oTable->getRows());
+  }
+  public function testStyleText() {
+    $oTable = new PHPWord_Section_Table('section', 1, 'tableStyle');
+
+    $this->assertEquals($oTable->getStyle(), 'tableStyle');
+  }
+  public function testStyleArray() {
+    $oTable = new PHPWord_Section_Table('section', 1, array('borderSize'=>6, 'borderColor'=>'006699', 'cellMargin'=>80));
+
+    $this->assertInstanceOf('PHPWord_Style_Table', $oTable->getStyle());
+  }
+  public function testWidth() {
+    $oTable = new PHPWord_Section_Table('section', 1);
+    $iVal = rand(1, 1000);
+    $oTable->setWidth($iVal);
+    $this->assertEquals($oTable->getWidth(), $iVal);
+  }
+  public function testRow() {
+    $oTable = new PHPWord_Section_Table('section', 1);
+    $element = $oTable->addRow();
+    $this->assertInstanceOf('PHPWord_Section_Table_Row', $element);
+    $this->assertCount(1, $oTable->getRows());
+  }
+  public function testCell() {
+    $oTable = new PHPWord_Section_Table('section', 1);
+    $oTable->addRow();
+    $element = $oTable->addCell();
+    $this->assertInstanceOf('PHPWord_Section_Table_Cell', $element);
+  }
+}
+ 

Tests/PHPWord/Section/TextBreakTest.php

@@ -0,0 +1,18 @@
+<?php
+namespace PHPWord\Tests;
+
+use PHPUnit_Framework_TestCase;
+use PHPWord_Section_TextBreak;
+
+class PHPWord_Section_TextBreakTest extends \PHPUnit_Framework_TestCase {
+  /**
+   * Executed before each method of the class
+   */
+  public function testConstruct() {
+    // Section Settings
+    $oTextBreak = new PHPWord_Section_TextBreak();
+
+    $this->assertInstanceOf('PHPWord_Section_TextBreak', $oTextBreak);
+  }
+}
+ 

Tests/PHPWord/Section/TextRunTest.php

@@ -0,0 +1,81 @@
+<?php
+namespace PHPWord\Tests;
+
+use PHPUnit_Framework_TestCase;
+use PHPWord_Section_TextRun;
+
+class PHPWord_Section_TextRunTest extends \PHPUnit_Framework_TestCase {
+  public function testConstructNull() {
+    $oTextRun = new PHPWord_Section_TextRun();
+
+    $this->assertInstanceOf('PHPWord_Section_TextRun', $oTextRun);
+    $this->assertCount(0, $oTextRun->getElements());
+    $this->assertEquals($oTextRun->getParagraphStyle(), null);
+  }
+  public function testConstructString() {
+    $oTextRun = new PHPWord_Section_TextRun('pStyle');
+
+    $this->assertInstanceOf('PHPWord_Section_TextRun', $oTextRun);
+    $this->assertCount(0, $oTextRun->getElements());
+    $this->assertEquals($oTextRun->getParagraphStyle(), 'pStyle');
+  }
+  public function testConstructArray() {
+    $oTextRun = new PHPWord_Section_TextRun(array('spacing'=>100));
+
+    $this->assertInstanceOf('PHPWord_Section_TextRun', $oTextRun);
+    $this->assertCount(0, $oTextRun->getElements());
+    $this->assertInstanceOf('PHPWord_Style_Paragraph', $oTextRun->getParagraphStyle());
+  }
+  public function testAddText() {
+    $oTextRun = new PHPWord_Section_TextRun();
+    $element = $oTextRun->addText('text');
+
+    $this->assertInstanceOf('PHPWord_Section_Text', $element);
+    $this->assertCount(1, $oTextRun->getElements());
+    $this->assertEquals($element->getText(), 'text');
+  }
+  public function testAddTextNotUTF8() {
+    $oTextRun = new PHPWord_Section_TextRun();
+    $element = $oTextRun->addText(utf8_decode('ééé'));
+
+    $this->assertInstanceOf('PHPWord_Section_Text', $element);
+    $this->assertCount(1, $oTextRun->getElements());
+    $this->assertEquals($element->getText(), 'ééé');
+  }
+  public function testAddLink() {
+    $oTextRun = new PHPWord_Section_TextRun();
+    $element = $oTextRun->addLink('http://www.google.fr');
+
+    $this->assertInstanceOf('PHPWord_Section_Link', $element);
+    $this->assertCount(1, $oTextRun->getElements());
+    $this->assertEquals($element->getLinkSrc(), 'http://www.google.fr');
+  }
+  public function testAddLinkWithName() {
+    $oTextRun = new PHPWord_Section_TextRun();
+    $element = $oTextRun->addLink('http://www.google.fr', utf8_decode('ééé'));
+
+    $this->assertInstanceOf('PHPWord_Section_Link', $element);
+    $this->assertCount(1, $oTextRun->getElements());
+    $this->assertEquals($element->getLinkSrc(), 'http://www.google.fr');
+    $this->assertEquals($element->getLinkName(), 'ééé');
+  }
+  public function testAddImage() {
+    $src = \join(
+      \DIRECTORY_SEPARATOR,
+      array(\PHPWORD_TESTS_DIR_ROOT, '_files', 'images', 'earth.jpg')
+    );
+    $oTextRun = new PHPWord_Section_TextRun();
+    $element = $oTextRun->addImage($src);
+
+    $this->assertInstanceOf('PHPWord_Section_Image', $element);
+    $this->assertCount(1, $oTextRun->getElements());
+  }
+  public function testCreateFootnote() {
+    $oTextRun = new PHPWord_Section_TextRun();
+    $element = $oTextRun->createFootnote();
+
+    $this->assertInstanceOf('PHPWord_Section_Footnote', $element);
+    $this->assertCount(1, $oTextRun->getElements());
+  }
+}
+ 

Tests/PHPWord/Section/TextTest.php

@@ -0,0 +1,36 @@
+<?php
+namespace PHPWord\Tests;
+
+use PHPUnit_Framework_TestCase;
+use PHPWord_Section_Text;
+
+class PHPWord_Section_TextTest extends \PHPUnit_Framework_TestCase {
+  public function testConstruct() {
+    $oText = new PHPWord_Section_Text();
+
+    $this->assertInstanceOf('PHPWord_Section_Text', $oText);
+    $this->assertEquals($oText->getText(), null);
+    $this->assertEquals($oText->getFontStyle(), null);
+    $this->assertEquals($oText->getParagraphStyle(), null);
+  }
+  public function testText() {
+    $oText = new PHPWord_Section_Text('text');
+
+    $this->assertEquals($oText->getText(), 'text');
+  }
+  public function testFont() {
+    $oText = new PHPWord_Section_Text('text', 'fontStyle');
+    $this->assertEquals($oText->getFontStyle(), 'fontStyle');
+
+    $oText->setFontStyle(array('bold'=>true, 'italic'=>true, 'size'=>16));
+    $this->assertInstanceOf('PHPWord_Style_Font', $oText->getFontStyle());
+  }
+  public function testParagraph() {
+    $oText = new PHPWord_Section_Text('text', 'fontStyle', 'paragraphStyle');
+    $this->assertEquals($oText->getParagraphStyle(), 'paragraphStyle');
+
+    $oText->setParagraphStyle(array('align'=>'center', 'spaceAfter'=>100));
+    $this->assertInstanceOf('PHPWord_Style_Paragraph', $oText->getParagraphStyle());
+  }
+}
+ 

Tests/PHPWord/Section/TitleTest.php

@@ -0,0 +1,39 @@
+<?php
+namespace PHPWord\Tests;
+
+use PHPUnit_Framework_TestCase;
+use PHPWord_Section_Title;
+
+class PHPWord_Section_TitleTest extends \PHPUnit_Framework_TestCase {
+  public function testConstruct() {
+    $oTitle = new PHPWord_Section_Title('text');
+
+    $this->assertInstanceOf('PHPWord_Section_Title', $oTitle);
+    $this->assertEquals($oTitle->getText(), 'text');
+  }
+  public function testStyleNull() {
+    $oTitle = new PHPWord_Section_Title('text');
+
+    $this->assertEquals($oTitle->getStyle(), null);
+  }
+  public function testStyleNotNull() {
+    $oTitle = new PHPWord_Section_Title('text', 1, 'style');
+
+    $this->assertEquals($oTitle->getStyle(), 'style');
+  }
+  public function testAnchor() {
+    $oTitle = new PHPWord_Section_Title('text');
+
+    $iVal = rand(1, 1000);
+    $oTitle->setAnchor($iVal);
+    $this->assertEquals($oTitle->getAnchor(), $iVal);
+  }
+  public function testBookmarkID() {
+    $oTitle = new PHPWord_Section_Title('text');
+
+    $iVal = rand(1, 1000);
+    $oTitle->setBookmarkId($iVal);
+    $this->assertEquals($oTitle->getBookmarkId(), $iVal);
+  }
+}
+ 

phpunit.xml.dist

@@ -15,7 +15,7 @@
     </testsuites>
     <filter>
         <whitelist>
-            <directory suffix=".php">../Classes</directory>
+            <directory suffix=".php">./Classes</directory>
         </whitelist>
     </filter>
 </phpunit>