update 1.0.8.0

Commits for version update

vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/AutoloaderTest.php

@@ -0,0 +1,56 @@
+<?php
+
+
+class AutoloaderTest extends PHPUnit_Framework_TestCase
+{
+
+    public function setUp()
+    {
+        if (!defined('PHPEXCEL_ROOT'))
+        {
+            define('PHPEXCEL_ROOT', APPLICATION_PATH . '/');
+        }
+        require_once(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+    }
+
+    public function testAutoloaderNonPHPExcelClass()
+    {
+        $className = 'InvalidClass';
+
+        $result = PHPExcel_Autoloader::Load($className);
+        //    Must return a boolean...
+        $this->assertTrue(is_bool($result));
+        //    ... indicating failure
+        $this->assertFalse($result);
+    }
+
+    public function testAutoloaderInvalidPHPExcelClass()
+    {
+        $className = 'PHPExcel_Invalid_Class';
+
+        $result = PHPExcel_Autoloader::Load($className);
+        //    Must return a boolean...
+        $this->assertTrue(is_bool($result));
+        //    ... indicating failure
+        $this->assertFalse($result);
+    }
+
+    public function testAutoloadValidPHPExcelClass()
+    {
+        $className = 'PHPExcel_IOFactory';
+
+        $result = PHPExcel_Autoloader::Load($className);
+        //    Check that class has been loaded
+        $this->assertTrue(class_exists($className));
+    }
+
+    public function testAutoloadInstantiateSuccess()
+    {
+        $result = new PHPExcel_Calculation_Function(1,2,3);
+        //    Must return an object...
+        $this->assertTrue(is_object($result));
+        //    ... of the correct type
+        $this->assertTrue(is_a($result,'PHPExcel_Calculation_Function'));
+    }
+
+}

vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Calculation/DateTimeTest.php

@@ -0,0 +1,466 @@
+<?php
+
+
+require_once 'testDataFileIterator.php';
+
+class DateTimeTest extends PHPUnit_Framework_TestCase
+{
+
+    public function setUp()
+    {
+        if (!defined('PHPEXCEL_ROOT'))
+        {
+            define('PHPEXCEL_ROOT', APPLICATION_PATH . '/');
+        }
+        require_once(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+
+        PHPExcel_Calculation_Functions::setCompatibilityMode(PHPExcel_Calculation_Functions::COMPATIBILITY_EXCEL);
+	}
+
+    /**
+     * @dataProvider providerDATE
+     */
+	public function testDATE()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_DateTime','DATE'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerDATE()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/DateTime/DATE.data');
+	}
+
+	public function testDATEtoPHP()
+	{
+		PHPExcel_Calculation_Functions::setReturnDateType(PHPExcel_Calculation_Functions::RETURNDATE_PHP_NUMERIC);
+		$result = PHPExcel_Calculation_DateTime::DATE(2012,1,31);
+		PHPExcel_Calculation_Functions::setReturnDateType(PHPExcel_Calculation_Functions::RETURNDATE_EXCEL);
+		$this->assertEquals(1327968000, $result, NULL, 1E-8);
+	}
+
+	public function testDATEtoPHPObject()
+	{
+		PHPExcel_Calculation_Functions::setReturnDateType(PHPExcel_Calculation_Functions::RETURNDATE_PHP_OBJECT);
+		$result = PHPExcel_Calculation_DateTime::DATE(2012,1,31);
+		PHPExcel_Calculation_Functions::setReturnDateType(PHPExcel_Calculation_Functions::RETURNDATE_EXCEL);
+        //    Must return an object...
+        $this->assertTrue(is_object($result));
+        //    ... of the correct type
+        $this->assertTrue(is_a($result,'DateTime'));
+        //    ... with the correct value
+        $this->assertEquals($result->format('d-M-Y'),'31-Jan-2012');
+	}
+
+	public function testDATEwith1904Calendar()
+	{
+		PHPExcel_Shared_Date::setExcelCalendar(PHPExcel_Shared_Date::CALENDAR_MAC_1904);
+		$result = PHPExcel_Calculation_DateTime::DATE(1918,11,11);
+		PHPExcel_Shared_Date::setExcelCalendar(PHPExcel_Shared_Date::CALENDAR_WINDOWS_1900);
+        $this->assertEquals($result,5428);
+	}
+
+	public function testDATEwith1904CalendarError()
+	{
+		PHPExcel_Shared_Date::setExcelCalendar(PHPExcel_Shared_Date::CALENDAR_MAC_1904);
+		$result = PHPExcel_Calculation_DateTime::DATE(1901,1,31);
+		PHPExcel_Shared_Date::setExcelCalendar(PHPExcel_Shared_Date::CALENDAR_WINDOWS_1900);
+        $this->assertEquals($result,'#NUM!');
+	}
+
+    /**
+     * @dataProvider providerDATEVALUE
+     */
+	public function testDATEVALUE()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_DateTime','DATEVALUE'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerDATEVALUE()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/DateTime/DATEVALUE.data');
+	}
+
+	public function testDATEVALUEtoPHP()
+	{
+		PHPExcel_Calculation_Functions::setReturnDateType(PHPExcel_Calculation_Functions::RETURNDATE_PHP_NUMERIC);
+		$result = PHPExcel_Calculation_DateTime::DATEVALUE('2012-1-31');
+		PHPExcel_Calculation_Functions::setReturnDateType(PHPExcel_Calculation_Functions::RETURNDATE_EXCEL);
+		$this->assertEquals(1327968000, $result, NULL, 1E-8);
+	}
+
+	public function testDATEVALUEtoPHPObject()
+	{
+		PHPExcel_Calculation_Functions::setReturnDateType(PHPExcel_Calculation_Functions::RETURNDATE_PHP_OBJECT);
+		$result = PHPExcel_Calculation_DateTime::DATEVALUE('2012-1-31');
+		PHPExcel_Calculation_Functions::setReturnDateType(PHPExcel_Calculation_Functions::RETURNDATE_EXCEL);
+        //    Must return an object...
+        $this->assertTrue(is_object($result));
+        //    ... of the correct type
+        $this->assertTrue(is_a($result,'DateTime'));
+        //    ... with the correct value
+        $this->assertEquals($result->format('d-M-Y'),'31-Jan-2012');
+	}
+
+    /**
+     * @dataProvider providerYEAR
+     */
+	public function testYEAR()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_DateTime','YEAR'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerYEAR()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/DateTime/YEAR.data');
+	}
+
+    /**
+     * @dataProvider providerMONTH
+     */
+	public function testMONTH()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_DateTime','MONTHOFYEAR'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerMONTH()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/DateTime/MONTH.data');
+	}
+
+    /**
+     * @dataProvider providerWEEKNUM
+     */
+	public function testWEEKNUM()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_DateTime','WEEKOFYEAR'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerWEEKNUM()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/DateTime/WEEKNUM.data');
+	}
+
+    /**
+     * @dataProvider providerWEEKDAY
+     */
+	public function testWEEKDAY()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_DateTime','DAYOFWEEK'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerWEEKDAY()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/DateTime/WEEKDAY.data');
+	}
+
+    /**
+     * @dataProvider providerDAY
+     */
+	public function testDAY()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_DateTime','DAYOFMONTH'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerDAY()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/DateTime/DAY.data');
+	}
+
+    /**
+     * @dataProvider providerTIME
+     */
+	public function testTIME()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_DateTime','TIME'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerTIME()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/DateTime/TIME.data');
+	}
+
+	public function testTIMEtoPHP()
+	{
+		PHPExcel_Calculation_Functions::setReturnDateType(PHPExcel_Calculation_Functions::RETURNDATE_PHP_NUMERIC);
+		$result = PHPExcel_Calculation_DateTime::TIME(7,30,20);
+		PHPExcel_Calculation_Functions::setReturnDateType(PHPExcel_Calculation_Functions::RETURNDATE_EXCEL);
+		$this->assertEquals(27020, $result, NULL, 1E-8);
+	}
+
+	public function testTIMEtoPHPObject()
+	{
+		PHPExcel_Calculation_Functions::setReturnDateType(PHPExcel_Calculation_Functions::RETURNDATE_PHP_OBJECT);
+		$result = PHPExcel_Calculation_DateTime::TIME(7,30,20);
+		PHPExcel_Calculation_Functions::setReturnDateType(PHPExcel_Calculation_Functions::RETURNDATE_EXCEL);
+        //    Must return an object...
+        $this->assertTrue(is_object($result));
+        //    ... of the correct type
+        $this->assertTrue(is_a($result,'DateTime'));
+        //    ... with the correct value
+        $this->assertEquals($result->format('H:i:s'),'07:30:20');
+	}
+
+    /**
+     * @dataProvider providerTIMEVALUE
+     */
+	public function testTIMEVALUE()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_DateTime','TIMEVALUE'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerTIMEVALUE()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/DateTime/TIMEVALUE.data');
+	}
+
+	public function testTIMEVALUEtoPHP()
+	{
+		PHPExcel_Calculation_Functions::setReturnDateType(PHPExcel_Calculation_Functions::RETURNDATE_PHP_NUMERIC);
+		$result = PHPExcel_Calculation_DateTime::TIMEVALUE('7:30:20');
+		PHPExcel_Calculation_Functions::setReturnDateType(PHPExcel_Calculation_Functions::RETURNDATE_EXCEL);
+		$this->assertEquals(23420, $result, NULL, 1E-8);
+	}
+
+	public function testTIMEVALUEtoPHPObject()
+	{
+		PHPExcel_Calculation_Functions::setReturnDateType(PHPExcel_Calculation_Functions::RETURNDATE_PHP_OBJECT);
+		$result = PHPExcel_Calculation_DateTime::TIMEVALUE('7:30:20');
+		PHPExcel_Calculation_Functions::setReturnDateType(PHPExcel_Calculation_Functions::RETURNDATE_EXCEL);
+        //    Must return an object...
+        $this->assertTrue(is_object($result));
+        //    ... of the correct type
+        $this->assertTrue(is_a($result,'DateTime'));
+        //    ... with the correct value
+        $this->assertEquals($result->format('H:i:s'),'07:30:20');
+	}
+
+    /**
+     * @dataProvider providerHOUR
+     */
+	public function testHOUR()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_DateTime','HOUROFDAY'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerHOUR()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/DateTime/HOUR.data');
+	}
+
+    /**
+     * @dataProvider providerMINUTE
+     */
+	public function testMINUTE()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_DateTime','MINUTEOFHOUR'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerMINUTE()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/DateTime/MINUTE.data');
+	}
+
+    /**
+     * @dataProvider providerSECOND
+     */
+	public function testSECOND()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_DateTime','SECONDOFMINUTE'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerSECOND()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/DateTime/SECOND.data');
+	}
+
+    /**
+     * @dataProvider providerNETWORKDAYS
+     */
+	public function testNETWORKDAYS()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_DateTime','NETWORKDAYS'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerNETWORKDAYS()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/DateTime/NETWORKDAYS.data');
+	}
+
+    /**
+     * @dataProvider providerWORKDAY
+     */
+	public function testWORKDAY()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_DateTime','WORKDAY'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerWORKDAY()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/DateTime/WORKDAY.data');
+	}
+
+    /**
+     * @dataProvider providerEDATE
+     */
+	public function testEDATE()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_DateTime','EDATE'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerEDATE()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/DateTime/EDATE.data');
+	}
+
+	public function testEDATEtoPHP()
+	{
+		PHPExcel_Calculation_Functions::setReturnDateType(PHPExcel_Calculation_Functions::RETURNDATE_PHP_NUMERIC);
+		$result = PHPExcel_Calculation_DateTime::EDATE('2012-1-26',-1);
+		PHPExcel_Calculation_Functions::setReturnDateType(PHPExcel_Calculation_Functions::RETURNDATE_EXCEL);
+		$this->assertEquals(1324857600, $result, NULL, 1E-8);
+	}
+
+	public function testEDATEtoPHPObject()
+	{
+		PHPExcel_Calculation_Functions::setReturnDateType(PHPExcel_Calculation_Functions::RETURNDATE_PHP_OBJECT);
+		$result = PHPExcel_Calculation_DateTime::EDATE('2012-1-26',-1);
+		PHPExcel_Calculation_Functions::setReturnDateType(PHPExcel_Calculation_Functions::RETURNDATE_EXCEL);
+        //    Must return an object...
+        $this->assertTrue(is_object($result));
+        //    ... of the correct type
+        $this->assertTrue(is_a($result,'DateTime'));
+        //    ... with the correct value
+        $this->assertEquals($result->format('d-M-Y'),'26-Dec-2011');
+	}
+
+    /**
+     * @dataProvider providerEOMONTH
+     */
+	public function testEOMONTH()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_DateTime','EOMONTH'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerEOMONTH()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/DateTime/EOMONTH.data');
+	}
+
+	public function testEOMONTHtoPHP()
+	{
+		PHPExcel_Calculation_Functions::setReturnDateType(PHPExcel_Calculation_Functions::RETURNDATE_PHP_NUMERIC);
+		$result = PHPExcel_Calculation_DateTime::EOMONTH('2012-1-26',-1);
+		PHPExcel_Calculation_Functions::setReturnDateType(PHPExcel_Calculation_Functions::RETURNDATE_EXCEL);
+		$this->assertEquals(1325289600, $result, NULL, 1E-8);
+	}
+
+	public function testEOMONTHtoPHPObject()
+	{
+		PHPExcel_Calculation_Functions::setReturnDateType(PHPExcel_Calculation_Functions::RETURNDATE_PHP_OBJECT);
+		$result = PHPExcel_Calculation_DateTime::EOMONTH('2012-1-26',-1);
+		PHPExcel_Calculation_Functions::setReturnDateType(PHPExcel_Calculation_Functions::RETURNDATE_EXCEL);
+        //    Must return an object...
+        $this->assertTrue(is_object($result));
+        //    ... of the correct type
+        $this->assertTrue(is_a($result,'DateTime'));
+        //    ... with the correct value
+        $this->assertEquals($result->format('d-M-Y'),'31-Dec-2011');
+	}
+
+    /**
+     * @dataProvider providerDATEDIF
+     */
+	public function testDATEDIF()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_DateTime','DATEDIF'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerDATEDIF()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/DateTime/DATEDIF.data');
+	}
+
+    /**
+     * @dataProvider providerDAYS360
+     */
+	public function testDAYS360()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_DateTime','DAYS360'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerDAYS360()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/DateTime/DAYS360.data');
+	}
+
+    /**
+     * @dataProvider providerYEARFRAC
+     */
+	public function testYEARFRAC()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_DateTime','YEARFRAC'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerYEARFRAC()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/DateTime/YEARFRAC.data');
+	}
+
+}

vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Calculation/EngineeringTest.php

@@ -0,0 +1,698 @@
+<?php
+
+//  Custom assertion class for handling precision of Complex numbers
+require_once 'custom/complexAssert.php';
+
+//  Data Provider handler
+require_once 'testDataFileIterator.php';
+
+
+class EngineeringTest extends PHPUnit_Framework_TestCase
+{
+
+    public function setUp()
+    {
+        if (!defined('PHPEXCEL_ROOT'))
+        {
+            define('PHPEXCEL_ROOT', APPLICATION_PATH . '/');
+        }
+        require_once(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+
+        PHPExcel_Calculation_Functions::setCompatibilityMode(PHPExcel_Calculation_Functions::COMPATIBILITY_EXCEL);
+	}
+
+    /**
+     * @dataProvider providerBESSELI
+     */
+	public function testBESSELI()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Engineering','BESSELI'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerBESSELI()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Engineering/BESSELI.data');
+	}
+
+    /**
+     * @dataProvider providerBESSELJ
+     */
+	public function testBESSELJ()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Engineering','BESSELJ'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerBESSELJ()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Engineering/BESSELJ.data');
+	}
+
+    /**
+     * @dataProvider providerBESSELK
+     */
+	public function testBESSELK()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Engineering','BESSELK'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerBESSELK()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Engineering/BESSELK.data');
+	}
+
+    /**
+     * @dataProvider providerBESSELY
+     */
+	public function testBESSELY()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Engineering','BESSELY'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerBESSELY()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Engineering/BESSELY.data');
+	}
+
+    /**
+     * @dataProvider providerCOMPLEX
+     */
+	public function testCOMPLEX()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Engineering','COMPLEX'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerCOMPLEX()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Engineering/COMPLEX.data');
+	}
+
+    /**
+     * @dataProvider providerIMAGINARY
+     */
+	public function testIMAGINARY()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Engineering','IMAGINARY'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerIMAGINARY()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Engineering/IMAGINARY.data');
+	}
+
+    /**
+     * @dataProvider providerIMREAL
+     */
+	public function testIMREAL()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Engineering','IMREAL'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerIMREAL()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Engineering/IMREAL.data');
+	}
+
+    /**
+     * @dataProvider providerIMABS
+     */
+	public function testIMABS()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Engineering','IMABS'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerIMABS()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Engineering/IMABS.data');
+	}
+
+    /**
+     * @dataProvider providerIMARGUMENT
+     */
+	public function testIMARGUMENT()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Engineering','IMARGUMENT'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerIMARGUMENT()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Engineering/IMARGUMENT.data');
+	}
+
+    /**
+     * @dataProvider providerIMCONJUGATE
+     */
+	public function testIMCONJUGATE()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Engineering','IMCONJUGATE'),$args);
+		$complexAssert = new complexAssert();
+		$this->assertTrue($complexAssert->assertComplexEquals($expectedResult, $result, 1E-8),
+						  $complexAssert->getErrorMessage());
+	}
+
+    public function providerIMCONJUGATE()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Engineering/IMCONJUGATE.data');
+	}
+
+    /**
+     * @dataProvider providerIMCOS
+     */
+	public function testIMCOS()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Engineering','IMCOS'),$args);
+		$complexAssert = new complexAssert();
+		$this->assertTrue($complexAssert->assertComplexEquals($expectedResult, $result, 1E-8),
+						  $complexAssert->getErrorMessage());
+	}
+
+    public function providerIMCOS()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Engineering/IMCOS.data');
+	}
+
+    /**
+     * @dataProvider providerIMDIV
+     */
+	public function testIMDIV()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Engineering','IMDIV'),$args);
+		$complexAssert = new complexAssert();
+		$this->assertTrue($complexAssert->assertComplexEquals($expectedResult, $result, 1E-8),
+						  $complexAssert->getErrorMessage());
+	}
+
+    public function providerIMDIV()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Engineering/IMDIV.data');
+	}
+
+    /**
+     * @dataProvider providerIMEXP
+     */
+	public function testIMEXP()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Engineering','IMEXP'),$args);
+		$complexAssert = new complexAssert();
+		$this->assertTrue($complexAssert->assertComplexEquals($expectedResult, $result, 1E-8),
+						  $complexAssert->getErrorMessage());
+	}
+
+    public function providerIMEXP()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Engineering/IMEXP.data');
+	}
+
+    /**
+     * @dataProvider providerIMLN
+     */
+	public function testIMLN()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Engineering','IMLN'),$args);
+		$complexAssert = new complexAssert();
+		$this->assertTrue($complexAssert->assertComplexEquals($expectedResult, $result, 1E-8),
+						  $complexAssert->getErrorMessage());
+	}
+
+    public function providerIMLN()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Engineering/IMLN.data');
+	}
+
+    /**
+     * @dataProvider providerIMLOG2
+     */
+	public function testIMLOG2()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Engineering','IMLOG2'),$args);
+		$complexAssert = new complexAssert();
+		$this->assertTrue($complexAssert->assertComplexEquals($expectedResult, $result, 1E-8),
+						  $complexAssert->getErrorMessage());
+	}
+
+    public function providerIMLOG2()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Engineering/IMLOG2.data');
+	}
+
+    /**
+     * @dataProvider providerIMLOG10
+     */
+	public function testIMLOG10()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Engineering','IMLOG10'),$args);
+		$complexAssert = new complexAssert();
+		$this->assertTrue($complexAssert->assertComplexEquals($expectedResult, $result, 1E-8),
+						  $complexAssert->getErrorMessage());
+	}
+
+    public function providerIMLOG10()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Engineering/IMLOG10.data');
+	}
+
+    /**
+     * @dataProvider providerIMPOWER
+     */
+	public function testIMPOWER()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Engineering','IMPOWER'),$args);
+		$complexAssert = new complexAssert();
+		$this->assertTrue($complexAssert->assertComplexEquals($expectedResult, $result, 1E-8),
+						  $complexAssert->getErrorMessage());
+	}
+
+    public function providerIMPOWER()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Engineering/IMPOWER.data');
+	}
+
+    /**
+     * @dataProvider providerIMPRODUCT
+     */
+	public function testIMPRODUCT()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Engineering','IMPRODUCT'),$args);
+		$complexAssert = new complexAssert();
+		$this->assertTrue($complexAssert->assertComplexEquals($expectedResult, $result, 1E-8),
+						  $complexAssert->getErrorMessage());
+	}
+
+    public function providerIMPRODUCT()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Engineering/IMPRODUCT.data');
+	}
+
+    /**
+     * @dataProvider providerIMSIN
+     */
+	public function testIMSIN()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Engineering','IMSIN'),$args);
+		$complexAssert = new complexAssert();
+		$this->assertTrue($complexAssert->assertComplexEquals($expectedResult, $result, 1E-8),
+						  $complexAssert->getErrorMessage());
+	}
+
+    public function providerIMSIN()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Engineering/IMSIN.data');
+	}
+
+    /**
+     * @dataProvider providerIMSQRT
+     */
+	public function testIMSQRT()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Engineering','IMSQRT'),$args);
+		$complexAssert = new complexAssert();
+		$this->assertTrue($complexAssert->assertComplexEquals($expectedResult, $result, 1E-8),
+						  $complexAssert->getErrorMessage());
+	}
+
+    public function providerIMSQRT()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Engineering/IMSQRT.data');
+	}
+
+    /**
+     * @dataProvider providerIMSUB
+     */
+	public function testIMSUB()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Engineering','IMSUB'),$args);
+		$complexAssert = new complexAssert();
+		$this->assertTrue($complexAssert->assertComplexEquals($expectedResult, $result, 1E-8),
+						  $complexAssert->getErrorMessage());
+	}
+
+    public function providerIMSUB()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Engineering/IMSUB.data');
+	}
+
+    /**
+     * @dataProvider providerIMSUM
+     */
+	public function testIMSUM()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Engineering','IMSUM'),$args);
+		$complexAssert = new complexAssert();
+		$this->assertTrue($complexAssert->assertComplexEquals($expectedResult, $result, 1E-8),
+						  $complexAssert->getErrorMessage());
+	}
+
+    public function providerIMSUM()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Engineering/IMSUM.data');
+	}
+
+    /**
+     * @dataProvider providerERF
+     */
+	public function testERF()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Engineering','ERF'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-12);
+	}
+
+    public function providerERF()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Engineering/ERF.data');
+	}
+
+    /**
+     * @dataProvider providerERFC
+     */
+	public function testERFC()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Engineering','ERFC'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-12);
+	}
+
+    public function providerERFC()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Engineering/ERFC.data');
+	}
+
+    /**
+     * @dataProvider providerBIN2DEC
+     */
+	public function testBIN2DEC()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Engineering','BINTODEC'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerBIN2DEC()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Engineering/BIN2DEC.data');
+	}
+
+    /**
+     * @dataProvider providerBIN2HEX
+     */
+	public function testBIN2HEX()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Engineering','BINTOHEX'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerBIN2HEX()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Engineering/BIN2HEX.data');
+	}
+
+    /**
+     * @dataProvider providerBIN2OCT
+     */
+	public function testBIN2OCT()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Engineering','BINTOOCT'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerBIN2OCT()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Engineering/BIN2OCT.data');
+	}
+
+    /**
+     * @dataProvider providerDEC2BIN
+     */
+	public function testDEC2BIN()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Engineering','DECTOBIN'),$args);
+		$this->assertEquals($expectedResult, $result, NULL);
+	}
+
+    public function providerDEC2BIN()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Engineering/DEC2BIN.data');
+	}
+
+    /**
+     * @dataProvider providerDEC2HEX
+     */
+	public function testDEC2HEX()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Engineering','DECTOHEX'),$args);
+		$this->assertEquals($expectedResult, $result, NULL);
+	}
+
+    public function providerDEC2HEX()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Engineering/DEC2HEX.data');
+	}
+
+    /**
+     * @dataProvider providerDEC2OCT
+     */
+	public function testDEC2OCT()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Engineering','DECTOOCT'),$args);
+		$this->assertEquals($expectedResult, $result, NULL);
+	}
+
+    public function providerDEC2OCT()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Engineering/DEC2OCT.data');
+	}
+
+    /**
+     * @dataProvider providerHEX2BIN
+     */
+	public function testHEX2BIN()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Engineering','HEXTOBIN'),$args);
+		$this->assertEquals($expectedResult, $result, NULL);
+	}
+
+    public function providerHEX2BIN()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Engineering/HEX2BIN.data');
+	}
+
+    /**
+     * @dataProvider providerHEX2DEC
+     */
+	public function testHEX2DEC()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Engineering','HEXTODEC'),$args);
+		$this->assertEquals($expectedResult, $result, NULL);
+	}
+
+    public function providerHEX2DEC()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Engineering/HEX2DEC.data');
+	}
+
+    /**
+     * @dataProvider providerHEX2OCT
+     */
+	public function testHEX2OCT()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Engineering','HEXTOOCT'),$args);
+		$this->assertEquals($expectedResult, $result, NULL);
+	}
+
+    public function providerHEX2OCT()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Engineering/HEX2OCT.data');
+	}
+
+    /**
+     * @dataProvider providerOCT2BIN
+     */
+	public function testOCT2BIN()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Engineering','OCTTOBIN'),$args);
+		$this->assertEquals($expectedResult, $result, NULL);
+	}
+
+    public function providerOCT2BIN()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Engineering/OCT2BIN.data');
+	}
+
+    /**
+     * @dataProvider providerOCT2DEC
+     */
+	public function testOCT2DEC()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Engineering','OCTTODEC'),$args);
+		$this->assertEquals($expectedResult, $result, NULL);
+	}
+
+    public function providerOCT2DEC()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Engineering/OCT2DEC.data');
+	}
+
+    /**
+     * @dataProvider providerOCT2HEX
+     */
+	public function testOCT2HEX()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Engineering','OCTTOHEX'),$args);
+		$this->assertEquals($expectedResult, $result, NULL);
+	}
+
+    public function providerOCT2HEX()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Engineering/OCT2HEX.data');
+	}
+
+    /**
+     * @dataProvider providerDELTA
+     */
+	public function testDELTA()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Engineering','DELTA'),$args);
+		$this->assertEquals($expectedResult, $result, NULL);
+	}
+
+    public function providerDELTA()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Engineering/DELTA.data');
+	}
+
+    /**
+     * @dataProvider providerGESTEP
+     */
+	public function testGESTEP()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Engineering','GESTEP'),$args);
+		$this->assertEquals($expectedResult, $result, NULL);
+	}
+
+    public function providerGESTEP()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Engineering/GESTEP.data');
+	}
+
+	public function testGetConversionGroups()
+	{
+		$result = PHPExcel_Calculation_Engineering::getConversionGroups();
+		$this->assertInternalType('array', $result);
+	}
+
+	public function testGetConversionGroupUnits()
+	{
+		$result = PHPExcel_Calculation_Engineering::getConversionGroupUnits();
+		$this->assertInternalType('array', $result);
+	}
+
+	public function testGetConversionGroupUnitDetails()
+	{
+		$result = PHPExcel_Calculation_Engineering::getConversionGroupUnitDetails();
+		$this->assertInternalType('array', $result);
+	}
+
+	public function testGetConversionMultipliers()
+	{
+		$result = PHPExcel_Calculation_Engineering::getConversionMultipliers();
+		$this->assertInternalType('array', $result);
+	}
+
+    /**
+     * @dataProvider providerCONVERTUOM
+     */
+	public function testCONVERTUOM()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Engineering','CONVERTUOM'),$args);
+		$this->assertEquals($expectedResult, $result, NULL);
+	}
+
+    public function providerCONVERTUOM()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Engineering/CONVERTUOM.data');
+	}
+
+}

vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Calculation/FinancialTest.php

@@ -0,0 +1,516 @@
+<?php
+
+
+require_once 'testDataFileIterator.php';
+
+class FinancialTest extends PHPUnit_Framework_TestCase
+{
+
+    public function setUp()
+    {
+        if (!defined('PHPEXCEL_ROOT'))
+        {
+            define('PHPEXCEL_ROOT', APPLICATION_PATH . '/');
+        }
+        require_once(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+
+        PHPExcel_Calculation_Functions::setCompatibilityMode(PHPExcel_Calculation_Functions::COMPATIBILITY_EXCEL);
+	}
+
+    /**
+     * @dataProvider providerACCRINT
+     */
+	public function testACCRINT()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Financial','ACCRINT'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerACCRINT()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Financial/ACCRINT.data');
+	}
+
+    /**
+     * @dataProvider providerACCRINTM
+     */
+	public function testACCRINTM()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Financial','ACCRINTM'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerACCRINTM()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Financial/ACCRINTM.data');
+	}
+
+    /**
+     * @dataProvider providerAMORDEGRC
+     */
+	public function testAMORDEGRC()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Financial','AMORDEGRC'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerAMORDEGRC()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Financial/AMORDEGRC.data');
+	}
+
+    /**
+     * @dataProvider providerAMORLINC
+     */
+	public function testAMORLINC()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Financial','AMORLINC'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerAMORLINC()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Financial/AMORLINC.data');
+	}
+
+    /**
+     * @dataProvider providerCOUPDAYBS
+     */
+	public function testCOUPDAYBS()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Financial','COUPDAYBS'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerCOUPDAYBS()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Financial/COUPDAYBS.data');
+	}
+
+    /**
+     * @dataProvider providerCOUPDAYS
+     */
+	public function testCOUPDAYS()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Financial','COUPDAYS'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerCOUPDAYS()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Financial/COUPDAYS.data');
+	}
+
+    /**
+     * @dataProvider providerCOUPDAYSNC
+     */
+	public function testCOUPDAYSNC()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Financial','COUPDAYSNC'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerCOUPDAYSNC()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Financial/COUPDAYSNC.data');
+	}
+
+    /**
+     * @dataProvider providerCOUPNCD
+     */
+	public function testCOUPNCD()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Financial','COUPNCD'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerCOUPNCD()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Financial/COUPNCD.data');
+	}
+
+    /**
+     * @dataProvider providerCOUPNUM
+     */
+	public function testCOUPNUM()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Financial','COUPNUM'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerCOUPNUM()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Financial/COUPNUM.data');
+	}
+
+    /**
+     * @dataProvider providerCOUPPCD
+     */
+	public function testCOUPPCD()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Financial','COUPPCD'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerCOUPPCD()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Financial/COUPPCD.data');
+	}
+
+    /**
+     * @dataProvider providerCUMIPMT
+     */
+	public function testCUMIPMT()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Financial','CUMIPMT'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerCUMIPMT()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Financial/CUMIPMT.data');
+	}
+
+    /**
+     * @dataProvider providerCUMPRINC
+     */
+	public function testCUMPRINC()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Financial','CUMPRINC'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerCUMPRINC()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Financial/CUMPRINC.data');
+	}
+
+    /**
+     * @dataProvider providerDB
+     */
+	public function testDB()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Financial','DB'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerDB()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Financial/DB.data');
+	}
+
+    /**
+     * @dataProvider providerDDB
+     */
+	public function testDDB()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Financial','DDB'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerDDB()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Financial/DDB.data');
+	}
+
+    /**
+     * @dataProvider providerDISC
+     */
+	public function testDISC()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Financial','DISC'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerDISC()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Financial/DISC.data');
+	}
+
+    /**
+     * @dataProvider providerDOLLARDE
+     */
+	public function testDOLLARDE()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Financial','DOLLARDE'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerDOLLARDE()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Financial/DOLLARDE.data');
+	}
+
+    /**
+     * @dataProvider providerDOLLARFR
+     */
+	public function testDOLLARFR()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Financial','DOLLARFR'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerDOLLARFR()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Financial/DOLLARFR.data');
+	}
+
+    /**
+     * @dataProvider providerEFFECT
+     */
+	public function testEFFECT()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Financial','EFFECT'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerEFFECT()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Financial/EFFECT.data');
+	}
+
+    /**
+     * @dataProvider providerFV
+     */
+	public function testFV()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Financial','FV'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerFV()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Financial/FV.data');
+	}
+
+    /**
+     * @dataProvider providerFVSCHEDULE
+     */
+	public function testFVSCHEDULE()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Financial','FVSCHEDULE'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerFVSCHEDULE()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Financial/FVSCHEDULE.data');
+	}
+
+    /**
+     * @dataProvider providerINTRATE
+     */
+	public function testINTRATE()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Financial','INTRATE'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerINTRATE()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Financial/INTRATE.data');
+	}
+
+    /**
+     * @dataProvider providerIPMT
+     */
+	public function testIPMT()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Financial','IPMT'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerIPMT()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Financial/IPMT.data');
+	}
+
+    /**
+     * @dataProvider providerIRR
+     */
+	public function testIRR()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Financial','IRR'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerIRR()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Financial/IRR.data');
+	}
+
+    /**
+     * @dataProvider providerISPMT
+     */
+	public function testISPMT()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Financial','ISPMT'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerISPMT()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Financial/ISPMT.data');
+	}
+
+    /**
+     * @dataProvider providerMIRR
+     */
+	public function testMIRR()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Financial','MIRR'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerMIRR()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Financial/MIRR.data');
+	}
+
+    /**
+     * @dataProvider providerNOMINAL
+     */
+	public function testNOMINAL()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Financial','NOMINAL'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerNOMINAL()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Financial/NOMINAL.data');
+	}
+
+    /**
+     * @dataProvider providerNPER
+     */
+	public function testNPER()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Financial','NPER'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerNPER()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Financial/NPER.data');
+	}
+
+    /**
+     * @dataProvider providerNPV
+     */
+	public function testNPV()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Financial','NPV'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerNPV()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Financial/NPV.data');
+	}
+
+    /**
+     * @dataProvider providerPRICE
+     */
+	public function testPRICE()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Financial','PRICE'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerPRICE()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Financial/PRICE.data');
+	}
+
+    /**
+     * @dataProvider providerRATE
+     */
+	public function testRATE()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Financial','RATE'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerRATE()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Financial/RATE.data');
+	}
+
+    /**
+     * @dataProvider providerXIRR
+     */
+	public function testXIRR()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Financial','XIRR'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerXIRR()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Financial/XIRR.data');
+	}
+
+}

vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Calculation/FunctionsTest.php

@@ -0,0 +1,276 @@
+<?php
+
+
+require_once 'testDataFileIterator.php';
+
+class FunctionsTest extends PHPUnit_Framework_TestCase
+{
+
+    public function setUp()
+    {
+        if (!defined('PHPEXCEL_ROOT'))
+        {
+            define('PHPEXCEL_ROOT', APPLICATION_PATH . '/');
+        }
+        require_once(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+
+        PHPExcel_Calculation_Functions::setCompatibilityMode(PHPExcel_Calculation_Functions::COMPATIBILITY_EXCEL);
+	}
+
+	public function testDUMMY()
+	{
+		$result = PHPExcel_Calculation_Functions::DUMMY();
+		$this->assertEquals('#Not Yet Implemented', $result);
+	}
+
+	public function testDIV0()
+	{
+		$result = PHPExcel_Calculation_Functions::DIV0();
+		$this->assertEquals('#DIV/0!', $result);
+	}
+
+	public function testNA()
+	{
+		$result = PHPExcel_Calculation_Functions::NA();
+		$this->assertEquals('#N/A', $result);
+	}
+
+	public function testNaN()
+	{
+		$result = PHPExcel_Calculation_Functions::NaN();
+		$this->assertEquals('#NUM!', $result);
+	}
+
+	public function testNAME()
+	{
+		$result = PHPExcel_Calculation_Functions::NAME();
+		$this->assertEquals('#NAME?', $result);
+	}
+
+	public function testREF()
+	{
+		$result = PHPExcel_Calculation_Functions::REF();
+		$this->assertEquals('#REF!', $result);
+	}
+
+	public function testNULL()
+	{
+		$result = PHPExcel_Calculation_Functions::NULL();
+		$this->assertEquals('#NULL!', $result);
+	}
+
+	public function testVALUE()
+	{
+		$result = PHPExcel_Calculation_Functions::VALUE();
+		$this->assertEquals('#VALUE!', $result);
+	}
+
+    /**
+     * @dataProvider providerIS_BLANK
+     */
+	public function testIS_BLANK()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Functions','IS_BLANK'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerIS_BLANK()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Functions/IS_BLANK.data');
+	}
+
+    /**
+     * @dataProvider providerIS_ERR
+     */
+	public function testIS_ERR()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Functions','IS_ERR'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerIS_ERR()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Functions/IS_ERR.data');
+	}
+
+    /**
+     * @dataProvider providerIS_ERROR
+     */
+	public function testIS_ERROR()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Functions','IS_ERROR'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerIS_ERROR()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Functions/IS_ERROR.data');
+	}
+
+    /**
+     * @dataProvider providerERROR_TYPE
+     */
+	public function testERROR_TYPE()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Functions','ERROR_TYPE'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerERROR_TYPE()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Functions/ERROR_TYPE.data');
+	}
+
+    /**
+     * @dataProvider providerIS_LOGICAL
+     */
+	public function testIS_LOGICAL()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Functions','IS_LOGICAL'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerIS_LOGICAL()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Functions/IS_LOGICAL.data');
+	}
+
+    /**
+     * @dataProvider providerIS_NA
+     */
+	public function testIS_NA()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Functions','IS_NA'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerIS_NA()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Functions/IS_NA.data');
+	}
+
+    /**
+     * @dataProvider providerIS_NUMBER
+     */
+	public function testIS_NUMBER()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Functions','IS_NUMBER'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerIS_NUMBER()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Functions/IS_NUMBER.data');
+	}
+
+    /**
+     * @dataProvider providerIS_TEXT
+     */
+	public function testIS_TEXT()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Functions','IS_TEXT'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerIS_TEXT()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Functions/IS_TEXT.data');
+	}
+
+    /**
+     * @dataProvider providerIS_NONTEXT
+     */
+	public function testIS_NONTEXT()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Functions','IS_NONTEXT'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerIS_NONTEXT()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Functions/IS_NONTEXT.data');
+	}
+
+    /**
+     * @dataProvider providerIS_EVEN
+     */
+	public function testIS_EVEN()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Functions','IS_EVEN'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerIS_EVEN()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Functions/IS_EVEN.data');
+	}
+
+    /**
+     * @dataProvider providerIS_ODD
+     */
+	public function testIS_ODD()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Functions','IS_ODD'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerIS_ODD()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Functions/IS_ODD.data');
+	}
+
+    /**
+     * @dataProvider providerTYPE
+     */
+	public function testTYPE()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Functions','TYPE'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerTYPE()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Functions/TYPE.data');
+	}
+
+    /**
+     * @dataProvider providerN
+     */
+	public function testN()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Functions','N'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerN()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Functions/N.data');
+	}
+
+}

vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Calculation/LogicalTest.php

@@ -0,0 +1,112 @@
+<?php
+
+
+require_once 'testDataFileIterator.php';
+
+class LogicalTest extends PHPUnit_Framework_TestCase
+{
+
+    public function setUp()
+    {
+        if (!defined('PHPEXCEL_ROOT'))
+        {
+            define('PHPEXCEL_ROOT', APPLICATION_PATH . '/');
+        }
+        require_once(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+
+        PHPExcel_Calculation_Functions::setCompatibilityMode(PHPExcel_Calculation_Functions::COMPATIBILITY_EXCEL);
+	}
+
+	public function testTRUE()
+	{
+		$result = PHPExcel_Calculation_Logical::TRUE();
+		$this->assertEquals(TRUE, $result);
+	}
+
+	public function testFALSE()
+	{
+		$result = PHPExcel_Calculation_Logical::FALSE();
+		$this->assertEquals(FALSE, $result);
+	}
+
+    /**
+     * @dataProvider providerAND
+     */
+	public function testAND()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Logical','LOGICAL_AND'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerAND()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Logical/AND.data');
+	}
+
+    /**
+     * @dataProvider providerOR
+     */
+	public function testOR()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Logical','LOGICAL_OR'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerOR()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Logical/OR.data');
+	}
+
+    /**
+     * @dataProvider providerNOT
+     */
+    public function testNOT()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Logical','NOT'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerNOT()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Logical/NOT.data');
+    }
+
+    /**
+     * @dataProvider providerIF
+     */
+    public function testIF()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Logical','STATEMENT_IF'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerIF()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/Logical/IF.data');
+	}
+
+    /**
+     * @dataProvider providerIFERROR
+     */
+    public function testIFERROR()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_Logical','IFERROR'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerIFERROR()
+    {
+        return new testDataFileIterator('rawTestData/Calculation/Logical/IFERROR.data');
+	}
+
+}

vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Calculation/LookupRefTest.php

@@ -0,0 +1,52 @@
+<?php
+
+
+require_once 'testDataFileIterator.php';
+
+class LookupRefTest extends PHPUnit_Framework_TestCase
+{
+
+    public function setUp()
+    {
+        if (!defined('PHPEXCEL_ROOT'))
+        {
+            define('PHPEXCEL_ROOT', APPLICATION_PATH . '/');
+        }
+        require_once(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+
+        PHPExcel_Calculation_Functions::setCompatibilityMode(PHPExcel_Calculation_Functions::COMPATIBILITY_EXCEL);
+	}
+
+    /**
+     * @dataProvider providerHLOOKUP
+     */
+	public function testHLOOKUP()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_LookupRef','HLOOKUP'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerHLOOKUP()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/LookupRef/HLOOKUP.data');
+	}
+
+    /**
+     * @dataProvider providerVLOOKUP
+     */
+	public function testVLOOKUP()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_LookupRef','VLOOKUP'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerVLOOKUP()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/LookupRef/VLOOKUP.data');
+	}
+
+}

vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Calculation/MathTrigTest.php

@@ -0,0 +1,560 @@
+<?php
+
+
+require_once 'testDataFileIterator.php';
+
+class MathTrigTest extends PHPUnit_Framework_TestCase
+{
+
+    public function setUp()
+    {
+        if (!defined('PHPEXCEL_ROOT'))
+        {
+            define('PHPEXCEL_ROOT', APPLICATION_PATH . '/');
+        }
+        require_once(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+
+        PHPExcel_Calculation_Functions::setCompatibilityMode(PHPExcel_Calculation_Functions::COMPATIBILITY_EXCEL);
+	}
+
+    /**
+     * @dataProvider providerATAN2
+     */
+	public function testATAN2()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_MathTrig','ATAN2'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-12);
+	}
+
+    public function providerATAN2()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/MathTrig/ATAN2.data');
+	}
+
+    /**
+     * @dataProvider providerCEILING
+     */
+	public function testCEILING()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_MathTrig','CEILING'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-12);
+	}
+
+    public function providerCEILING()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/MathTrig/CEILING.data');
+	}
+
+    /**
+     * @dataProvider providerCOMBIN
+     */
+	public function testCOMBIN()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_MathTrig','COMBIN'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-12);
+	}
+
+    public function providerCOMBIN()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/MathTrig/COMBIN.data');
+	}
+
+    /**
+     * @dataProvider providerEVEN
+     */
+	public function testEVEN()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_MathTrig','EVEN'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-12);
+	}
+
+    public function providerEVEN()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/MathTrig/EVEN.data');
+	}
+
+    /**
+     * @dataProvider providerODD
+     */
+	public function testODD()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_MathTrig','ODD'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-12);
+	}
+
+    public function providerODD()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/MathTrig/ODD.data');
+	}
+
+    /**
+     * @dataProvider providerFACT
+     */
+	public function testFACT()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_MathTrig','FACT'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-12);
+	}
+
+    public function providerFACT()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/MathTrig/FACT.data');
+	}
+
+    /**
+     * @dataProvider providerFACTDOUBLE
+     */
+	public function testFACTDOUBLE()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_MathTrig','FACTDOUBLE'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-12);
+	}
+
+    public function providerFACTDOUBLE()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/MathTrig/FACTDOUBLE.data');
+	}
+
+    /**
+     * @dataProvider providerFLOOR
+     */
+	public function testFLOOR()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_MathTrig','FLOOR'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-12);
+	}
+
+    public function providerFLOOR()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/MathTrig/FLOOR.data');
+	}
+
+    /**
+     * @dataProvider providerGCD
+     */
+	public function testGCD()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_MathTrig','GCD'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-12);
+	}
+
+    public function providerGCD()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/MathTrig/GCD.data');
+	}
+
+    /**
+     * @dataProvider providerLCM
+     */
+	public function testLCM()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_MathTrig','LCM'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-12);
+	}
+
+    public function providerLCM()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/MathTrig/LCM.data');
+	}
+
+    /**
+     * @dataProvider providerINT
+     */
+	public function testINT()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_MathTrig','INT'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerINT()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/MathTrig/INT.data');
+	}
+
+    /**
+     * @dataProvider providerSIGN
+     */
+	public function testSIGN()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_MathTrig','SIGN'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-12);
+	}
+
+    public function providerSIGN()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/MathTrig/SIGN.data');
+	}
+
+    /**
+     * @dataProvider providerPOWER
+     */
+	public function testPOWER()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_MathTrig','POWER'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-12);
+	}
+
+    public function providerPOWER()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/MathTrig/POWER.data');
+	}
+
+    /**
+     * @dataProvider providerLOG
+     */
+	public function testLOG()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_MathTrig','LOG_BASE'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-12);
+	}
+
+    public function providerLOG()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/MathTrig/LOG.data');
+	}
+
+    /**
+     * @dataProvider providerMOD
+     */
+	public function testMOD()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_MathTrig','MOD'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-12);
+	}
+
+    public function providerMOD()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/MathTrig/MOD.data');
+	}
+
+    /**
+     * @dataProvider providerMDETERM
+     */
+	public function testMDETERM()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_MathTrig','MDETERM'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-12);
+	}
+
+    public function providerMDETERM()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/MathTrig/MDETERM.data');
+	}
+
+    /**
+     * @dataProvider providerMINVERSE
+     */
+	public function testMINVERSE()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_MathTrig','MINVERSE'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-12);
+	}
+
+    public function providerMINVERSE()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/MathTrig/MINVERSE.data');
+	}
+
+    /**
+     * @dataProvider providerMMULT
+     */
+	public function testMMULT()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_MathTrig','MMULT'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-12);
+	}
+
+    public function providerMMULT()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/MathTrig/MMULT.data');
+	}
+
+    /**
+     * @dataProvider providerMULTINOMIAL
+     */
+	public function testMULTINOMIAL()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_MathTrig','MULTINOMIAL'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-12);
+	}
+
+    public function providerMULTINOMIAL()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/MathTrig/MULTINOMIAL.data');
+	}
+
+    /**
+     * @dataProvider providerMROUND
+     */
+	public function testMROUND()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		PHPExcel_Calculation::setArrayReturnType(PHPExcel_Calculation::RETURN_ARRAY_AS_VALUE);
+		$result = call_user_func_array(array('PHPExcel_Calculation_MathTrig','MROUND'),$args);
+		PHPExcel_Calculation::setArrayReturnType(PHPExcel_Calculation::RETURN_ARRAY_AS_ARRAY);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-12);
+	}
+
+    public function providerMROUND()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/MathTrig/MROUND.data');
+	}
+
+    /**
+     * @dataProvider providerPRODUCT
+     */
+	public function testPRODUCT()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_MathTrig','PRODUCT'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-12);
+	}
+
+    public function providerPRODUCT()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/MathTrig/PRODUCT.data');
+	}
+
+    /**
+     * @dataProvider providerQUOTIENT
+     */
+	public function testQUOTIENT()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_MathTrig','QUOTIENT'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-12);
+	}
+
+    public function providerQUOTIENT()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/MathTrig/QUOTIENT.data');
+	}
+
+    /**
+     * @dataProvider providerROUNDUP
+     */
+	public function testROUNDUP()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_MathTrig','ROUNDUP'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-12);
+	}
+
+    public function providerROUNDUP()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/MathTrig/ROUNDUP.data');
+	}
+
+    /**
+     * @dataProvider providerROUNDDOWN
+     */
+	public function testROUNDDOWN()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_MathTrig','ROUNDDOWN'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-12);
+	}
+
+    public function providerROUNDDOWN()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/MathTrig/ROUNDDOWN.data');
+	}
+
+    /**
+     * @dataProvider providerSERIESSUM
+     */
+	public function testSERIESSUM()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_MathTrig','SERIESSUM'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-12);
+	}
+
+    public function providerSERIESSUM()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/MathTrig/SERIESSUM.data');
+	}
+
+    /**
+     * @dataProvider providerSUMSQ
+     */
+	public function testSUMSQ()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_MathTrig','SUMSQ'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-12);
+	}
+
+    public function providerSUMSQ()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/MathTrig/SUMSQ.data');
+	}
+
+    /**
+     * @dataProvider providerTRUNC
+     */
+	public function testTRUNC()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_MathTrig','TRUNC'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-12);
+	}
+
+    public function providerTRUNC()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/MathTrig/TRUNC.data');
+	}
+
+    /**
+     * @dataProvider providerROMAN
+     */
+	public function testROMAN()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_MathTrig','ROMAN'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerROMAN()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/MathTrig/ROMAN.data');
+	}
+
+    /**
+     * @dataProvider providerSQRTPI
+     */
+	public function testSQRTPI()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_MathTrig','SQRTPI'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-12);
+	}
+
+    public function providerSQRTPI()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/MathTrig/SQRTPI.data');
+    }
+
+    /**
+     * @dataProvider providerSUMIF
+     */
+    public function testSUMIF()
+    {
+        $args = func_get_args();
+        $expectedResult = array_pop($args);
+        $result = call_user_func_array(array('PHPExcel_Calculation_MathTrig', 'SUMIF'), $args);
+        $this->assertEquals($expectedResult, $result, NULL, 1E-12);
+    }
+
+    public function providerSUMIF()
+    {
+        return array(
+            array(
+                array(
+                    array(1),
+                    array(5),
+                    array(10),
+                ),
+                '>=5',
+                15,
+            ),
+            array(
+                array(
+                    array('text'),
+                    array(2),
+                ),
+                '=text',
+                array(
+                    array(10),
+                    array(100),
+                ),
+                10,
+            ),
+            array(
+                array(
+                    array('"text with quotes"'),
+                    array(2),
+                ),
+                '="text with quotes"',
+                array(
+                    array(10),
+                    array(100),
+                ),
+                10,
+            ),
+            array(
+                array(
+                    array('"text with quotes"'),
+                    array(''),
+                ),
+                '>"', // Compare to the single characater " (double quote)
+                array(
+                    array(10),
+                    array(100),
+                ),
+                10
+            ),
+            array(
+                array(
+                    array(''),
+                    array('anything'),
+                ),
+                '>"', // Compare to the single characater " (double quote)
+                array(
+                    array(10),
+                    array(100),
+                ),
+                100
+            ),
+        );
+	}
+
+}

vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Calculation/TextDataTest.php

@@ -0,0 +1,365 @@
+<?php
+
+
+require_once 'testDataFileIterator.php';
+
+class TextDataTest extends PHPUnit_Framework_TestCase
+{
+
+    public function setUp()
+    {
+        if (!defined('PHPEXCEL_ROOT'))
+        {
+            define('PHPEXCEL_ROOT', APPLICATION_PATH . '/');
+        }
+        require_once(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+
+        PHPExcel_Calculation_Functions::setCompatibilityMode(PHPExcel_Calculation_Functions::COMPATIBILITY_EXCEL);
+	}
+
+    /**
+     * @dataProvider providerCHAR
+     */
+	public function testCHAR()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_TextData','CHARACTER'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerCHAR()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/TextData/CHAR.data');
+	}
+
+    /**
+     * @dataProvider providerCODE
+     */
+	public function testCODE()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_TextData','ASCIICODE'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerCODE()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/TextData/CODE.data');
+	}
+
+    /**
+     * @dataProvider providerCONCATENATE
+     */
+	public function testCONCATENATE()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_TextData','CONCATENATE'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerCONCATENATE()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/TextData/CONCATENATE.data');
+	}
+
+    /**
+     * @dataProvider providerLEFT
+     */
+	public function testLEFT()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_TextData','LEFT'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerLEFT()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/TextData/LEFT.data');
+	}
+
+    /**
+     * @dataProvider providerMID
+     */
+	public function testMID()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_TextData','MID'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerMID()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/TextData/MID.data');
+	}
+
+    /**
+     * @dataProvider providerRIGHT
+     */
+	public function testRIGHT()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_TextData','RIGHT'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerRIGHT()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/TextData/RIGHT.data');
+	}
+
+    /**
+     * @dataProvider providerLOWER
+     */
+	public function testLOWER()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_TextData','LOWERCASE'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerLOWER()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/TextData/LOWER.data');
+	}
+
+    /**
+     * @dataProvider providerUPPER
+     */
+	public function testUPPER()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_TextData','UPPERCASE'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerUPPER()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/TextData/UPPER.data');
+	}
+
+    /**
+     * @dataProvider providerPROPER
+     */
+	public function testPROPER()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_TextData','PROPERCASE'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerPROPER()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/TextData/PROPER.data');
+	}
+
+    /**
+     * @dataProvider providerLEN
+     */
+	public function testLEN()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_TextData','STRINGLENGTH'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerLEN()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/TextData/LEN.data');
+	}
+
+    /**
+     * @dataProvider providerSEARCH
+     */
+	public function testSEARCH()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_TextData','SEARCHINSENSITIVE'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerSEARCH()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/TextData/SEARCH.data');
+	}
+
+    /**
+     * @dataProvider providerFIND
+     */
+	public function testFIND()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_TextData','SEARCHSENSITIVE'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerFIND()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/TextData/FIND.data');
+	}
+
+    /**
+     * @dataProvider providerREPLACE
+     */
+	public function testREPLACE()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_TextData','REPLACE'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerREPLACE()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/TextData/REPLACE.data');
+	}
+
+    /**
+     * @dataProvider providerSUBSTITUTE
+     */
+	public function testSUBSTITUTE()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_TextData','SUBSTITUTE'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerSUBSTITUTE()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/TextData/SUBSTITUTE.data');
+	}
+
+    /**
+     * @dataProvider providerTRIM
+     */
+	public function testTRIM()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_TextData','TRIMSPACES'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerTRIM()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/TextData/TRIM.data');
+	}
+
+    /**
+     * @dataProvider providerCLEAN
+     */
+	public function testCLEAN()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_TextData','TRIMNONPRINTABLE'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerCLEAN()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/TextData/CLEAN.data');
+	}
+
+    /**
+     * @dataProvider providerDOLLAR
+     */
+	public function testDOLLAR()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_TextData','DOLLAR'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerDOLLAR()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/TextData/DOLLAR.data');
+	}
+
+    /**
+     * @dataProvider providerFIXED
+     */
+	public function testFIXED()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_TextData','FIXEDFORMAT'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerFIXED()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/TextData/FIXED.data');
+	}
+
+    /**
+     * @dataProvider providerT
+     */
+	public function testT()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_TextData','RETURNSTRING'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerT()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/TextData/T.data');
+	}
+
+    /**
+     * @dataProvider providerTEXT
+     */
+	public function testTEXT()
+	{
+		//	Enforce decimal and thousands separator values to UK/US, and currency code to USD
+		call_user_func(array('PHPExcel_Shared_String','setDecimalSeparator'),'.');
+		call_user_func(array('PHPExcel_Shared_String','setThousandsSeparator'),',');
+		call_user_func(array('PHPExcel_Shared_String','setCurrencyCode'),'$');
+
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_TextData','TEXTFORMAT'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerTEXT()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/TextData/TEXT.data');
+	}
+
+    /**
+     * @dataProvider providerVALUE
+     */
+	public function testVALUE()
+	{
+		call_user_func(array('PHPExcel_Shared_String','setDecimalSeparator'),'.');
+		call_user_func(array('PHPExcel_Shared_String','setThousandsSeparator'),' ');
+		call_user_func(array('PHPExcel_Shared_String','setCurrencyCode'),'$');
+
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Calculation_TextData','VALUE'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-8);
+	}
+
+    public function providerVALUE()
+    {
+    	return new testDataFileIterator('rawTestData/Calculation/TextData/VALUE.data');
+	}
+
+}

vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/CalculationTest.php

@@ -0,0 +1,37 @@
+<?php
+
+require_once 'testDataFileIterator.php';
+
+class CalculationTest extends PHPUnit_Framework_TestCase
+{
+
+    public function setUp()
+    {
+        if (!defined('PHPEXCEL_ROOT')) {
+            define('PHPEXCEL_ROOT', APPLICATION_PATH . '/');
+        }
+        require_once(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+
+        PHPExcel_Calculation_Functions::setCompatibilityMode(PHPExcel_Calculation_Functions::COMPATIBILITY_EXCEL);
+    }
+
+    /**
+     * @dataProvider providerBinaryComparisonOperation
+     */
+    public function testBinaryComparisonOperation($formula, $expectedResultExcel, $expectedResultOpenOffice)
+    {
+        PHPExcel_Calculation_Functions::setCompatibilityMode(PHPExcel_Calculation_Functions::COMPATIBILITY_EXCEL);
+        $resultExcel = \PHPExcel_Calculation::getInstance()->_calculateFormulaValue($formula);
+        $this->assertEquals($expectedResultExcel, $resultExcel, 'should be Excel compatible');
+
+        PHPExcel_Calculation_Functions::setCompatibilityMode(PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE);
+        $resultOpenOffice = \PHPExcel_Calculation::getInstance()->_calculateFormulaValue($formula);
+        $this->assertEquals($expectedResultOpenOffice, $resultOpenOffice, 'should be OpenOffice compatible');
+    }
+
+    public function providerBinaryComparisonOperation()
+    {
+        return new testDataFileIterator('rawTestData/CalculationBinaryComparisonOperation.data');
+    }
+
+}

vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Cell/AdvancedValueBinderTest.php

@@ -0,0 +1,73 @@
+<?php
+
+class AdvancedValueBinderTest extends PHPUnit_Framework_TestCase
+{
+    public function setUp()
+    {
+        if (!defined('PHPEXCEL_ROOT')) {
+            define('PHPEXCEL_ROOT', APPLICATION_PATH . '/');
+        }
+        require_once(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+    }
+
+    public function provider()
+    {
+        if (!class_exists('PHPExcel_Style_NumberFormat')) {
+          $this->setUp();
+        }
+        $currencyUSD = PHPExcel_Style_NumberFormat::FORMAT_CURRENCY_USD_SIMPLE;
+        $currencyEURO = str_replace('$', '€', PHPExcel_Style_NumberFormat::FORMAT_CURRENCY_USD_SIMPLE);
+
+        return array(
+          array('10%', 0.1, PHPExcel_Style_NumberFormat::FORMAT_PERCENTAGE_00, ',', '.', '$'),
+          array('$10.11', 10.11, $currencyUSD, ',', '.', '$'),
+          array('$1,010.12', 1010.12, $currencyUSD, ',', '.', '$'),
+          array('$20,20', 20.2, $currencyUSD, '.', ',', '$'),
+          array('$2.020,20', 2020.2, $currencyUSD, '.', ',', '$'),
+          array('€2.020,20', 2020.2, $currencyEURO, '.', ',', '€'),
+          array('€ 2.020,20', 2020.2, $currencyEURO, '.', ',', '€'),
+          array('€2,020.22', 2020.22, $currencyEURO, ',', '.', '€'),
+        );
+    }
+
+    /**
+     * @dataProvider provider
+     */
+    public function testCurrency($value, $valueBinded, $format, $thousandsSeparator, $decimalSeparator, $currencyCode)
+    {
+        $sheet = $this->getMock(
+			'PHPExcel_Worksheet', 
+			array('getStyle', 'getNumberFormat', 'setFormatCode','getCellCacheController')
+		);
+        $cache = $this->getMockBuilder('PHPExcel_CachedObjectStorage_Memory')
+        	->disableOriginalConstructor()
+        	->getMock();
+        $cache->expects($this->any())
+                 ->method('getParent')
+                 ->will($this->returnValue($sheet));
+
+        $sheet->expects($this->once())
+                 ->method('getStyle')
+                 ->will($this->returnSelf());
+        $sheet->expects($this->once())
+                 ->method('getNumberFormat')
+                 ->will($this->returnSelf());
+        $sheet->expects($this->once())
+                 ->method('setFormatCode')
+                 ->with($format)
+                 ->will($this->returnSelf());
+        $sheet->expects($this->any())
+                 ->method('getCellCacheController')
+                 ->will($this->returnValue($cache));
+
+        PHPExcel_Shared_String::setCurrencyCode($currencyCode);
+        PHPExcel_Shared_String::setDecimalSeparator($decimalSeparator);
+        PHPExcel_Shared_String::setThousandsSeparator($thousandsSeparator);
+
+        $cell = new PHPExcel_Cell(NULL, PHPExcel_Cell_DataType::TYPE_STRING, $sheet);
+
+        $binder = new PHPExcel_Cell_AdvancedValueBinder();
+        $binder->bindValue($cell, $value);
+        $this->assertEquals($valueBinded, $cell->getValue());
+    }
+}

vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Cell/DataTypeTest.php

@@ -0,0 +1,24 @@
+<?php
+
+
+class DataTypeTest extends PHPUnit_Framework_TestCase
+{
+
+    public function setUp()
+    {
+        if (!defined('PHPEXCEL_ROOT'))
+        {
+            define('PHPEXCEL_ROOT', APPLICATION_PATH . '/');
+        }
+        require_once(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+	}
+
+	public function testGetErrorCodes()
+	{
+		$result = call_user_func(array('PHPExcel_Cell_DataType','getErrorCodes'));
+		$this->assertInternalType('array', $result);
+		$this->assertGreaterThan(0, count($result));
+		$this->assertArrayHasKey('#NULL!', $result);
+	}
+
+}

vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Cell/DefaultValueBinderTest.php

@@ -0,0 +1,85 @@
+<?php
+
+require_once 'testDataFileIterator.php';
+
+class DefaultValueBinderTest extends PHPUnit_Framework_TestCase
+{
+    protected $cellStub;
+
+    public function setUp()
+    {
+        if (!defined('PHPEXCEL_ROOT'))
+        {
+            define('PHPEXCEL_ROOT', APPLICATION_PATH . '/');
+        }
+        require_once(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+	}
+
+    protected function createCellStub()
+    {
+        // Create a stub for the Cell class.
+        $this->cellStub = $this->getMockBuilder('PHPExcel_Cell')
+            ->disableOriginalConstructor()
+            ->getMock();
+        // Configure the stub.
+        $this->cellStub->expects($this->any())
+             ->method('setValueExplicit')
+             ->will($this->returnValue(true));
+
+    }
+
+    /**
+     * @dataProvider binderProvider
+     */
+    public function testBindValue($value)
+	{
+		$this->createCellStub();
+        $binder = new PHPExcel_Cell_DefaultValueBinder();
+		$result = $binder->bindValue($this->cellStub, $value);
+		$this->assertTrue($result);
+	}
+
+    public function binderProvider()
+    {
+        return array(
+            array(null),
+            array(''),
+            array('ABC'),
+            array('=SUM(A1:B2)'),
+            array(true),
+            array(false),
+            array(123),
+            array(-123.456),
+            array('123'),
+            array('-123.456'),
+            array('#REF!'),
+            array(new DateTime()),
+        );
+    }
+
+    /**
+     * @dataProvider providerDataTypeForValue
+     */
+	public function testDataTypeForValue()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Cell_DefaultValueBinder','dataTypeForValue'), $args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerDataTypeForValue()
+    {
+    	return new testDataFileIterator('rawTestData/Cell/DefaultValueBinder.data');
+	}
+
+	public function testDataTypeForRichTextObject()
+	{
+        $objRichText = new PHPExcel_RichText();
+        $objRichText->createText('Hello World');
+
+        $expectedResult = PHPExcel_Cell_DataType::TYPE_INLINE;
+		$result = call_user_func(array('PHPExcel_Cell_DefaultValueBinder','dataTypeForValue'), $objRichText);
+		$this->assertEquals($expectedResult, $result);
+	}
+}

vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Cell/HyperlinkTest.php

@@ -0,0 +1,88 @@
+<?php
+
+
+class HyperlinkTest extends PHPUnit_Framework_TestCase
+{
+
+    public function setUp()
+    {
+        if (!defined('PHPEXCEL_ROOT'))
+        {
+            define('PHPEXCEL_ROOT', APPLICATION_PATH . '/');
+        }
+        require_once(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+	}
+
+	public function testGetUrl()
+	{
+		$urlValue = 'http://www.phpexcel.net';
+
+		$testInstance = new PHPExcel_Cell_Hyperlink($urlValue);
+
+		$result = $testInstance->getUrl();
+		$this->assertEquals($urlValue,$result);
+	}
+
+	public function testSetUrl()
+	{
+		$initialUrlValue = 'http://www.phpexcel.net';
+		$newUrlValue = 'http://github.com/PHPOffice/PHPExcel';
+
+		$testInstance = new PHPExcel_Cell_Hyperlink($initialUrlValue);
+		$result = $testInstance->setUrl($newUrlValue);
+		$this->assertTrue($result instanceof PHPExcel_Cell_Hyperlink);
+
+		$result = $testInstance->getUrl();
+		$this->assertEquals($newUrlValue,$result);
+	}
+
+	public function testGetTooltip()
+	{
+		$tooltipValue = 'PHPExcel Web Site';
+
+		$testInstance = new PHPExcel_Cell_Hyperlink(NULL, $tooltipValue);
+
+		$result = $testInstance->getTooltip();
+		$this->assertEquals($tooltipValue,$result);
+	}
+
+	public function testSetTooltip()
+	{
+		$initialTooltipValue = 'PHPExcel Web Site';
+		$newTooltipValue = 'PHPExcel Repository on Github';
+
+		$testInstance = new PHPExcel_Cell_Hyperlink(NULL, $initialTooltipValue);
+		$result = $testInstance->setTooltip($newTooltipValue);
+		$this->assertTrue($result instanceof PHPExcel_Cell_Hyperlink);
+
+		$result = $testInstance->getTooltip();
+		$this->assertEquals($newTooltipValue,$result);
+	}
+
+	public function testIsInternal()
+	{
+		$initialUrlValue = 'http://www.phpexcel.net';
+		$newUrlValue = 'sheet://Worksheet1!A1';
+
+		$testInstance = new PHPExcel_Cell_Hyperlink($initialUrlValue);
+		$result = $testInstance->isInternal();
+		$this->assertFalse($result);
+
+		$testInstance->setUrl($newUrlValue);
+		$result = $testInstance->isInternal();
+		$this->assertTrue($result);
+	}
+
+	public function testGetHashCode()
+	{
+		$urlValue = 'http://www.phpexcel.net';
+		$tooltipValue = 'PHPExcel Web Site';
+		$initialExpectedHash = 'd84d713aed1dbbc8a7c5af183d6c7dbb';
+
+		$testInstance = new PHPExcel_Cell_Hyperlink($urlValue, $tooltipValue);
+
+		$result = $testInstance->getHashCode();
+		$this->assertEquals($initialExpectedHash,$result);
+	}
+
+}

vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/CellTest.php

@@ -0,0 +1,295 @@
+<?php
+
+
+require_once 'testDataFileIterator.php';
+
+class CellTest extends PHPUnit_Framework_TestCase
+{
+
+    public function setUp()
+    {
+        if (!defined('PHPEXCEL_ROOT')) {
+            define('PHPEXCEL_ROOT', APPLICATION_PATH . '/');
+        }
+        require_once(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+	}
+
+    /**
+     * @dataProvider providerColumnString
+     */
+	public function testColumnIndexFromString()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Cell','columnIndexFromString'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerColumnString()
+    {
+    	return new testDataFileIterator('rawTestData/ColumnString.data');
+	}
+
+    public function testColumnIndexFromStringTooLong()
+	{
+		$cellAddress = 'ABCD';
+		try {
+			$result = call_user_func(array('PHPExcel_Cell','columnIndexFromString'),$cellAddress);
+		} catch (PHPExcel_Exception $e) {
+			$this->assertEquals($e->getMessage(), 'Column string index can not be longer than 3 characters');
+			return;
+		}
+		$this->fail('An expected exception has not been raised.');
+	}
+
+    public function testColumnIndexFromStringTooShort()
+	{
+		$cellAddress = '';
+		try {
+			$result = call_user_func(array('PHPExcel_Cell','columnIndexFromString'),$cellAddress);
+		} catch (PHPExcel_Exception $e) {
+			$this->assertEquals($e->getMessage(), 'Column string index can not be empty');
+			return;
+		}
+		$this->fail('An expected exception has not been raised.');
+	}
+
+    /**
+     * @dataProvider providerColumnIndex
+     */
+	public function testStringFromColumnIndex()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Cell','stringFromColumnIndex'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerColumnIndex()
+    {
+    	return new testDataFileIterator('rawTestData/ColumnIndex.data');
+	}
+
+    /**
+     * @dataProvider providerCoordinates
+     */
+	public function testCoordinateFromString()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Cell','coordinateFromString'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerCoordinates()
+    {
+    	return new testDataFileIterator('rawTestData/CellCoordinates.data');
+	}
+
+    public function testCoordinateFromStringWithRangeAddress()
+	{
+		$cellAddress = 'A1:AI2012';
+		try {
+			$result = call_user_func(array('PHPExcel_Cell','coordinateFromString'),$cellAddress);
+		} catch (PHPExcel_Exception $e) {
+			$this->assertEquals($e->getMessage(), 'Cell coordinate string can not be a range of cells');
+			return;
+		}
+		$this->fail('An expected exception has not been raised.');
+	}
+
+    public function testCoordinateFromStringWithEmptyAddress()
+	{
+		$cellAddress = '';
+		try {
+			$result = call_user_func(array('PHPExcel_Cell','coordinateFromString'),$cellAddress);
+		} catch (PHPExcel_Exception $e) {
+			$this->assertEquals($e->getMessage(), 'Cell coordinate can not be zero-length string');
+			return;
+		}
+		$this->fail('An expected exception has not been raised.');
+	}
+
+    public function testCoordinateFromStringWithInvalidAddress()
+	{
+		$cellAddress = 'AI';
+		try {
+			$result = call_user_func(array('PHPExcel_Cell','coordinateFromString'),$cellAddress);
+		} catch (PHPExcel_Exception $e) {
+			$this->assertEquals($e->getMessage(), 'Invalid cell coordinate '.$cellAddress);
+			return;
+		}
+		$this->fail('An expected exception has not been raised.');
+	}
+
+    /**
+     * @dataProvider providerAbsoluteCoordinates
+     */
+	public function testAbsoluteCoordinateFromString()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Cell','absoluteCoordinate'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerAbsoluteCoordinates()
+    {
+    	return new testDataFileIterator('rawTestData/CellAbsoluteCoordinate.data');
+	}
+
+    public function testAbsoluteCoordinateFromStringWithRangeAddress()
+	{
+		$cellAddress = 'A1:AI2012';
+		try {
+			$result = call_user_func(array('PHPExcel_Cell','absoluteCoordinate'),$cellAddress);
+		} catch (PHPExcel_Exception $e) {
+			$this->assertEquals($e->getMessage(), 'Cell coordinate string can not be a range of cells');
+			return;
+		}
+		$this->fail('An expected exception has not been raised.');
+	}
+
+    /**
+     * @dataProvider providerAbsoluteReferences
+     */
+	public function testAbsoluteReferenceFromString()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Cell','absoluteReference'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerAbsoluteReferences()
+    {
+    	return new testDataFileIterator('rawTestData/CellAbsoluteReference.data');
+	}
+
+    public function testAbsoluteReferenceFromStringWithRangeAddress()
+	{
+		$cellAddress = 'A1:AI2012';
+		try {
+			$result = call_user_func(array('PHPExcel_Cell','absoluteReference'),$cellAddress);
+		} catch (PHPExcel_Exception $e) {
+			$this->assertEquals($e->getMessage(), 'Cell coordinate string can not be a range of cells');
+			return;
+		}
+		$this->fail('An expected exception has not been raised.');
+	}
+
+    /**
+     * @dataProvider providerSplitRange
+     */
+	public function testSplitRange()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Cell','splitRange'),$args);
+		foreach($result as $key => $split) {
+			if (!is_array($expectedResult[$key])) {
+				$this->assertEquals($expectedResult[$key], $split[0]);
+			} else {
+				$this->assertEquals($expectedResult[$key], $split);
+			}
+		}
+	}
+
+    public function providerSplitRange()
+    {
+    	return new testDataFileIterator('rawTestData/CellSplitRange.data');
+	}
+
+    /**
+     * @dataProvider providerBuildRange
+     */
+	public function testBuildRange()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Cell','buildRange'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerBuildRange()
+    {
+    	return new testDataFileIterator('rawTestData/CellBuildRange.data');
+	}
+
+    public function testBuildRangeInvalid()
+	{
+		$cellRange = '';
+		try {
+			$result = call_user_func(array('PHPExcel_Cell','buildRange'),$cellRange);
+		} catch (PHPExcel_Exception $e) {
+			$this->assertEquals($e->getMessage(), 'Range does not contain any information');
+			return;
+		}
+		$this->fail('An expected exception has not been raised.');
+	}
+
+    /**
+     * @dataProvider providerRangeBoundaries
+     */
+	public function testRangeBoundaries()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Cell','rangeBoundaries'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerRangeBoundaries()
+    {
+    	return new testDataFileIterator('rawTestData/CellRangeBoundaries.data');
+	}
+
+    /**
+     * @dataProvider providerRangeDimension
+     */
+	public function testRangeDimension()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Cell','rangeDimension'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerRangeDimension()
+    {
+    	return new testDataFileIterator('rawTestData/CellRangeDimension.data');
+	}
+
+    /**
+     * @dataProvider providerGetRangeBoundaries
+     */
+	public function testGetRangeBoundaries()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Cell','getRangeBoundaries'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerGetRangeBoundaries()
+    {
+    	return new testDataFileIterator('rawTestData/CellGetRangeBoundaries.data');
+	}
+
+    /**
+     * @dataProvider providerExtractAllCellReferencesInRange
+     */
+	public function testExtractAllCellReferencesInRange()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Cell','extractAllCellReferencesInRange'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerExtractAllCellReferencesInRange()
+    {
+    	return new testDataFileIterator('rawTestData/CellExtractAllCellReferencesInRange.data');
+	}
+
+}

vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Chart/DataSeriesValuesTest.php

@@ -0,0 +1,55 @@
+<?php
+
+
+class DataSeriesValuesTest extends PHPUnit_Framework_TestCase
+{
+
+    public function setUp()
+    {
+        if (!defined('PHPEXCEL_ROOT'))
+        {
+            define('PHPEXCEL_ROOT', APPLICATION_PATH . '/');
+        }
+        require_once(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+	}
+
+	public function testSetDataType()
+	{
+		$dataTypeValues = array(
+			'Number',
+			'String'
+		);
+
+		$testInstance = new PHPExcel_Chart_DataSeriesValues;
+
+		foreach($dataTypeValues as $dataTypeValue) {
+			$result = $testInstance->setDataType($dataTypeValue);
+			$this->assertTrue($result instanceof PHPExcel_Chart_DataSeriesValues);
+		}
+	}
+
+	public function testSetInvalidDataTypeThrowsException()
+	{
+		$testInstance = new PHPExcel_Chart_DataSeriesValues;
+
+		try {
+			$result = $testInstance->setDataType('BOOLEAN');
+		} catch (Exception $e) {
+			$this->assertEquals($e->getMessage(), 'Invalid datatype for chart data series values');
+			return;
+		}
+		$this->fail('An expected exception has not been raised.');
+	}
+
+	public function testGetDataType()
+	{
+		$dataTypeValue = 'String';
+
+		$testInstance = new PHPExcel_Chart_DataSeriesValues;
+		$setValue = $testInstance->setDataType($dataTypeValue);
+
+		$result = $testInstance->getDataType();
+		$this->assertEquals($dataTypeValue,$result);
+	}
+
+}

vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Chart/LayoutTest.php

@@ -0,0 +1,37 @@
+<?php
+
+
+class LayoutTest extends PHPUnit_Framework_TestCase
+{
+
+    public function setUp()
+    {
+        if (!defined('PHPEXCEL_ROOT'))
+        {
+            define('PHPEXCEL_ROOT', APPLICATION_PATH . '/');
+        }
+        require_once(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+	}
+
+	public function testSetLayoutTarget()
+	{
+		$LayoutTargetValue = 'String';
+
+		$testInstance = new PHPExcel_Chart_Layout;
+
+		$result = $testInstance->setLayoutTarget($LayoutTargetValue);
+		$this->assertTrue($result instanceof PHPExcel_Chart_Layout);
+	}
+
+	public function testGetLayoutTarget()
+	{
+		$LayoutTargetValue = 'String';
+
+		$testInstance = new PHPExcel_Chart_Layout;
+		$setValue = $testInstance->setLayoutTarget($LayoutTargetValue);
+
+		$result = $testInstance->getLayoutTarget();
+		$this->assertEquals($LayoutTargetValue,$result);
+	}
+
+}

vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Chart/LegendTest.php

@@ -0,0 +1,134 @@
+<?php
+
+
+class LegendTest extends PHPUnit_Framework_TestCase
+{
+
+    public function setUp()
+    {
+        if (!defined('PHPEXCEL_ROOT'))
+        {
+            define('PHPEXCEL_ROOT', APPLICATION_PATH . '/');
+        }
+        require_once(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+	}
+
+	public function testSetPosition()
+	{
+		$positionValues = array(
+			PHPExcel_Chart_Legend::POSITION_RIGHT,
+			PHPExcel_Chart_Legend::POSITION_LEFT,
+			PHPExcel_Chart_Legend::POSITION_TOP,
+			PHPExcel_Chart_Legend::POSITION_BOTTOM,
+			PHPExcel_Chart_Legend::POSITION_TOPRIGHT,
+		);
+
+		$testInstance = new PHPExcel_Chart_Legend;
+
+		foreach($positionValues as $positionValue) {
+			$result = $testInstance->setPosition($positionValue);
+			$this->assertTrue($result);
+		}
+	}
+
+	public function testSetInvalidPositionReturnsFalse()
+	{
+		$testInstance = new PHPExcel_Chart_Legend;
+
+		$result = $testInstance->setPosition('BottomLeft');
+		$this->assertFalse($result);
+		//	Ensure that value is unchanged
+		$result = $testInstance->getPosition();
+		$this->assertEquals(PHPExcel_Chart_Legend::POSITION_RIGHT,$result);
+	}
+
+	public function testGetPosition()
+	{
+		$PositionValue = PHPExcel_Chart_Legend::POSITION_BOTTOM;
+
+		$testInstance = new PHPExcel_Chart_Legend;
+		$setValue = $testInstance->setPosition($PositionValue);
+
+		$result = $testInstance->getPosition();
+		$this->assertEquals($PositionValue,$result);
+	}
+
+	public function testSetPositionXL()
+	{
+		$positionValues = array(
+			PHPExcel_Chart_Legend::xlLegendPositionBottom,
+			PHPExcel_Chart_Legend::xlLegendPositionCorner,
+			PHPExcel_Chart_Legend::xlLegendPositionCustom,
+			PHPExcel_Chart_Legend::xlLegendPositionLeft,
+			PHPExcel_Chart_Legend::xlLegendPositionRight,
+			PHPExcel_Chart_Legend::xlLegendPositionTop,
+		);
+
+		$testInstance = new PHPExcel_Chart_Legend;
+
+		foreach($positionValues as $positionValue) {
+			$result = $testInstance->setPositionXL($positionValue);
+			$this->assertTrue($result);
+		}
+	}
+
+	public function testSetInvalidXLPositionReturnsFalse()
+	{
+		$testInstance = new PHPExcel_Chart_Legend;
+
+		$result = $testInstance->setPositionXL(999);
+		$this->assertFalse($result);
+		//	Ensure that value is unchanged
+		$result = $testInstance->getPositionXL();
+		$this->assertEquals(PHPExcel_Chart_Legend::xlLegendPositionRight,$result);
+	}
+
+	public function testGetPositionXL()
+	{
+		$PositionValue = PHPExcel_Chart_Legend::xlLegendPositionCorner;
+
+		$testInstance = new PHPExcel_Chart_Legend;
+		$setValue = $testInstance->setPositionXL($PositionValue);
+
+		$result = $testInstance->getPositionXL();
+		$this->assertEquals($PositionValue,$result);
+	}
+
+	public function testSetOverlay()
+	{
+		$overlayValues = array(
+			TRUE,
+			FALSE,
+		);
+
+		$testInstance = new PHPExcel_Chart_Legend;
+
+		foreach($overlayValues as $overlayValue) {
+			$result = $testInstance->setOverlay($overlayValue);
+			$this->assertTrue($result);
+		}
+	}
+
+	public function testSetInvalidOverlayReturnsFalse()
+	{
+		$testInstance = new PHPExcel_Chart_Legend;
+
+		$result = $testInstance->setOverlay('INVALID');
+		$this->assertFalse($result);
+
+		$result = $testInstance->getOverlay();
+		$this->assertFalse($result);
+	}
+
+	public function testGetOverlay()
+	{
+		$OverlayValue = TRUE;
+
+		$testInstance = new PHPExcel_Chart_Legend;
+		$setValue = $testInstance->setOverlay($OverlayValue);
+
+		$result = $testInstance->getOverlay();
+		$this->assertEquals($OverlayValue,$result);
+	}
+
+}

vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Reader/XEEValidatorTest.php

@@ -0,0 +1,55 @@
+<?php
+
+
+class XEEValidatorTest extends PHPUnit_Framework_TestCase
+{
+
+    public function setUp()
+    {
+        if (!defined('PHPEXCEL_ROOT')) {
+            define('PHPEXCEL_ROOT', APPLICATION_PATH . '/');
+        }
+        require_once(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+	}
+
+    /**
+     * @dataProvider providerInvalidXML
+     * @expectedException PHPExcel_Reader_Exception
+     */
+	public function testInvalidXML($filename)
+	{
+        $reader = $this->getMockForAbstractClass('PHPExcel_Reader_Abstract');
+        $expectedResult = 'FAILURE: Should throw an Exception rather than return a value';
+		$result = $reader->securityScanFile($filename);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerInvalidXML()
+    {
+        $tests = [];
+        foreach(glob('rawTestData/Reader/XEETestInvalid*.xml') as $file) {
+            $tests[] = [realpath($file), true];
+        }
+        return $tests;
+	}
+
+    /**
+     * @dataProvider providerValidXML
+     */
+	public function testValidXML($filename, $expectedResult)
+	{
+        $reader = $this->getMockForAbstractClass('PHPExcel_Reader_Abstract');
+		$result = $reader->securityScanFile($filename);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerValidXML()
+    {
+        $tests = [];
+        foreach(glob('rawTestData/Reader/XEETestValid*.xml') as $file) {
+            $tests[] = [realpath($file), file_get_contents($file)];
+        }
+        return $tests;
+	}
+
+}

vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/ReferenceHelperTest.php

@@ -0,0 +1,58 @@
+<?php
+
+
+class ReferenceHelperTest extends PHPUnit_Framework_TestCase
+{
+
+    public function setUp()
+    {
+        if (!defined('PHPEXCEL_ROOT')) {
+            define('PHPEXCEL_ROOT', APPLICATION_PATH . '/');
+        }
+        require_once(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+	}
+
+	public function testColumnSort()
+	{
+		$columnBase = $columnExpectedResult = array(
+			'A','B','Z',
+			'AA','AB','AZ',
+			'BA','BB','BZ',
+			'ZA','ZB','ZZ',
+			'AAA','AAB','AAZ',
+			'ABA','ABB','ABZ',
+			'AZA','AZB','AZZ',
+			'BAA','BAB','BAZ',
+			'BBA','BBB','BBZ',
+			'BZA','BZB','BZZ'
+		);
+		shuffle($columnBase);
+		usort($columnBase, array('PHPExcel_ReferenceHelper','columnSort'));
+		foreach($columnBase as $key => $value) {
+			$this->assertEquals($columnExpectedResult[$key], $value);
+		}
+	}
+
+	public function testColumnReverseSort()
+	{
+		$columnBase = $columnExpectedResult = array(
+			'A','B','Z',
+			'AA','AB','AZ',
+			'BA','BB','BZ',
+			'ZA','ZB','ZZ',
+			'AAA','AAB','AAZ',
+			'ABA','ABB','ABZ',
+			'AZA','AZB','AZZ',
+			'BAA','BAB','BAZ',
+			'BBA','BBB','BBZ',
+			'BZA','BZB','BZZ'
+		);
+		shuffle($columnBase);
+		$columnExpectedResult = array_reverse($columnExpectedResult);
+		usort($columnBase, array('PHPExcel_ReferenceHelper','columnReverseSort'));
+		foreach($columnBase as $key => $value) {
+			$this->assertEquals($columnExpectedResult[$key], $value);
+		}
+	}
+
+}

vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Shared/CodePageTest.php

@@ -0,0 +1,57 @@
+<?php
+
+
+require_once 'testDataFileIterator.php';
+
+class CodePageTest extends PHPUnit_Framework_TestCase
+{
+
+    public function setUp()
+    {
+        if (!defined('PHPEXCEL_ROOT')) {
+            define('PHPEXCEL_ROOT', APPLICATION_PATH . '/');
+        }
+        require_once(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+	}
+
+    /**
+     * @dataProvider providerCodePage
+     */
+	public function testCodePageNumberToName()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Shared_CodePage','NumberToName'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerCodePage()
+    {
+    	return new testDataFileIterator('rawTestData/Shared/CodePage.data');
+	}
+
+    public function testNumberToNameWithInvalidCodePage()
+	{
+		$invalidCodePage = 12345;
+		try {
+			$result = call_user_func(array('PHPExcel_Shared_CodePage','NumberToName'),$invalidCodePage);
+		} catch (Exception $e) {
+			$this->assertEquals($e->getMessage(), 'Unknown codepage: 12345');
+			return;
+		}
+		$this->fail('An expected exception has not been raised.');
+	}
+
+    public function testNumberToNameWithUnsupportedCodePage()
+	{
+		$unsupportedCodePage = 720;
+		try {
+			$result = call_user_func(array('PHPExcel_Shared_CodePage','NumberToName'),$unsupportedCodePage);
+		} catch (Exception $e) {
+			$this->assertEquals($e->getMessage(), 'Code page 720 not supported.');
+			return;
+		}
+		$this->fail('An expected exception has not been raised.');
+	}
+
+}

vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Shared/DateTest.php

@@ -0,0 +1,188 @@
+<?php
+
+
+require_once 'testDataFileIterator.php';
+
+class DateTest extends PHPUnit_Framework_TestCase
+{
+
+    public function setUp()
+    {
+        if (!defined('PHPEXCEL_ROOT')) {
+            define('PHPEXCEL_ROOT', APPLICATION_PATH . '/');
+        }
+        require_once(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+	}
+
+	public function testSetExcelCalendar()
+	{
+		$calendarValues = array(
+			PHPExcel_Shared_Date::CALENDAR_MAC_1904,
+			PHPExcel_Shared_Date::CALENDAR_WINDOWS_1900,
+		);
+
+		foreach($calendarValues as $calendarValue) {
+			$result = call_user_func(array('PHPExcel_Shared_Date','setExcelCalendar'),$calendarValue);
+			$this->assertTrue($result);
+		}
+	}
+
+    public function testSetExcelCalendarWithInvalidValue()
+	{
+		$unsupportedCalendar = '2012';
+		$result = call_user_func(array('PHPExcel_Shared_Date','setExcelCalendar'),$unsupportedCalendar);
+		$this->assertFalse($result);
+	}
+
+    /**
+     * @dataProvider providerDateTimeExcelToPHP1900
+     */
+	public function testDateTimeExcelToPHP1900()
+	{
+		$result = call_user_func(
+			array('PHPExcel_Shared_Date','setExcelCalendar'),
+			PHPExcel_Shared_Date::CALENDAR_WINDOWS_1900
+		);
+
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		if ($args[0] < 1) {
+			$expectedResult += gmmktime(0,0,0);
+		}
+		$result = call_user_func_array(array('PHPExcel_Shared_Date','ExcelToPHP'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerDateTimeExcelToPHP1900()
+    {
+    	return new testDataFileIterator('rawTestData/Shared/DateTimeExcelToPHP1900.data');
+	}
+
+    /**
+     * @dataProvider providerDateTimePHPToExcel1900
+     */
+	public function testDateTimePHPToExcel1900()
+	{
+		$result = call_user_func(
+			array('PHPExcel_Shared_Date','setExcelCalendar'),
+			PHPExcel_Shared_Date::CALENDAR_WINDOWS_1900
+		);
+
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Shared_Date','PHPToExcel'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-5);
+	}
+
+    public function providerDateTimePHPToExcel1900()
+    {
+    	return new testDataFileIterator('rawTestData/Shared/DateTimePHPToExcel1900.data');
+	}
+
+    /**
+     * @dataProvider providerDateTimeFormattedPHPToExcel1900
+     */
+	public function testDateTimeFormattedPHPToExcel1900()
+	{
+		$result = call_user_func(
+			array('PHPExcel_Shared_Date','setExcelCalendar'),
+			PHPExcel_Shared_Date::CALENDAR_WINDOWS_1900
+		);
+
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Shared_Date','FormattedPHPToExcel'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-5);
+	}
+
+    public function providerDateTimeFormattedPHPToExcel1900()
+    {
+    	return new testDataFileIterator('rawTestData/Shared/DateTimeFormattedPHPToExcel1900.data');
+	}
+
+    /**
+     * @dataProvider providerDateTimeExcelToPHP1904
+     */
+	public function testDateTimeExcelToPHP1904()
+	{
+		$result = call_user_func(
+			array('PHPExcel_Shared_Date','setExcelCalendar'),
+			PHPExcel_Shared_Date::CALENDAR_MAC_1904
+		);
+
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		if ($args[0] < 1) {
+			$expectedResult += gmmktime(0,0,0);
+		}
+		$result = call_user_func_array(array('PHPExcel_Shared_Date','ExcelToPHP'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerDateTimeExcelToPHP1904()
+    {
+    	return new testDataFileIterator('rawTestData/Shared/DateTimeExcelToPHP1904.data');
+	}
+
+    /**
+     * @dataProvider providerDateTimePHPToExcel1904
+     */
+	public function testDateTimePHPToExcel1904()
+	{
+		$result = call_user_func(
+			array('PHPExcel_Shared_Date','setExcelCalendar'),
+			PHPExcel_Shared_Date::CALENDAR_MAC_1904
+		);
+
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Shared_Date','PHPToExcel'),$args);
+		$this->assertEquals($expectedResult, $result, NULL, 1E-5);
+	}
+
+    public function providerDateTimePHPToExcel1904()
+    {
+    	return new testDataFileIterator('rawTestData/Shared/DateTimePHPToExcel1904.data');
+	}
+
+    /**
+     * @dataProvider providerIsDateTimeFormatCode
+     */
+	public function testIsDateTimeFormatCode()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Shared_Date','isDateTimeFormatCode'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerIsDateTimeFormatCode()
+    {
+    	return new testDataFileIterator('rawTestData/Shared/DateTimeFormatCodes.data');
+	}
+
+    /**
+     * @dataProvider providerDateTimeExcelToPHP1900Timezone
+     */
+	public function testDateTimeExcelToPHP1900Timezone()
+	{
+		$result = call_user_func(
+			array('PHPExcel_Shared_Date','setExcelCalendar'),
+			PHPExcel_Shared_Date::CALENDAR_WINDOWS_1900
+		);
+
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		if ($args[0] < 1) {
+			$expectedResult += gmmktime(0,0,0);
+		}
+		$result = call_user_func_array(array('PHPExcel_Shared_Date','ExcelToPHP'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerDateTimeExcelToPHP1900Timezone()
+    {
+    	return new testDataFileIterator('rawTestData/Shared/DateTimeExcelToPHP1900Timezone.data');
+	}
+
+}

vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Shared/FileTest.php

@@ -0,0 +1,39 @@
+<?php
+
+
+require_once 'testDataFileIterator.php';
+
+class FileTest extends PHPUnit_Framework_TestCase
+{
+
+    public function setUp()
+    {
+        if (!defined('PHPEXCEL_ROOT')) {
+            define('PHPEXCEL_ROOT', APPLICATION_PATH . '/');
+        }
+        require_once(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+	}
+
+	public function testGetUseUploadTempDirectory()
+	{
+		$expectedResult = FALSE;
+
+		$result = call_user_func(array('PHPExcel_Shared_File','getUseUploadTempDirectory'));
+		$this->assertEquals($expectedResult, $result);
+	}
+
+	public function testSetUseUploadTempDirectory()
+	{
+		$useUploadTempDirectoryValues = array(
+			TRUE,
+			FALSE,
+		);
+
+		foreach($useUploadTempDirectoryValues as $useUploadTempDirectoryValue) {
+			call_user_func(array('PHPExcel_Shared_File','setUseUploadTempDirectory'),$useUploadTempDirectoryValue);
+
+			$result = call_user_func(array('PHPExcel_Shared_File','getUseUploadTempDirectory'));
+			$this->assertEquals($useUploadTempDirectoryValue, $result);
+		}
+	}
+}

vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Shared/FontTest.php

@@ -0,0 +1,94 @@
+<?php
+
+
+require_once 'testDataFileIterator.php';
+
+class FontTest extends PHPUnit_Framework_TestCase
+{
+
+    public function setUp()
+    {
+        if (!defined('PHPEXCEL_ROOT')) {
+            define('PHPEXCEL_ROOT', APPLICATION_PATH . '/');
+        }
+        require_once(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+	}
+
+	public function testGetAutoSizeMethod()
+	{
+		$expectedResult = PHPExcel_Shared_Font::AUTOSIZE_METHOD_APPROX;
+
+		$result = call_user_func(array('PHPExcel_Shared_Font','getAutoSizeMethod'));
+		$this->assertEquals($expectedResult, $result);
+	}
+
+	public function testSetAutoSizeMethod()
+	{
+		$autosizeMethodValues = array(
+			PHPExcel_Shared_Font::AUTOSIZE_METHOD_EXACT,
+			PHPExcel_Shared_Font::AUTOSIZE_METHOD_APPROX,
+		);
+
+		foreach($autosizeMethodValues as $autosizeMethodValue) {
+			$result = call_user_func(array('PHPExcel_Shared_Font','setAutoSizeMethod'),$autosizeMethodValue);
+			$this->assertTrue($result);
+		}
+	}
+
+    public function testSetAutoSizeMethodWithInvalidValue()
+	{
+		$unsupportedAutosizeMethod = 'guess';
+
+		$result = call_user_func(array('PHPExcel_Shared_Font','setAutoSizeMethod'),$unsupportedAutosizeMethod);
+		$this->assertFalse($result);
+	}
+
+    /**
+     * @dataProvider providerFontSizeToPixels
+     */
+	public function testFontSizeToPixels()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Shared_Font','fontSizeToPixels'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerFontSizeToPixels()
+    {
+    	return new testDataFileIterator('rawTestData/Shared/FontSizeToPixels.data');
+	}
+
+    /**
+     * @dataProvider providerInchSizeToPixels
+     */
+	public function testInchSizeToPixels()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Shared_Font','inchSizeToPixels'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerInchSizeToPixels()
+    {
+    	return new testDataFileIterator('rawTestData/Shared/InchSizeToPixels.data');
+	}
+
+    /**
+     * @dataProvider providerCentimeterSizeToPixels
+     */
+	public function testCentimeterSizeToPixels()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Shared_Font','centimeterSizeToPixels'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerCentimeterSizeToPixels()
+    {
+    	return new testDataFileIterator('rawTestData/Shared/CentimeterSizeToPixels.data');
+	}
+
+}

vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Shared/PasswordHasherTest.php

@@ -0,0 +1,33 @@
+<?php
+
+
+require_once 'testDataFileIterator.php';
+
+class PasswordHasherTest extends PHPUnit_Framework_TestCase
+{
+
+    public function setUp()
+    {
+        if (!defined('PHPEXCEL_ROOT')) {
+            define('PHPEXCEL_ROOT', APPLICATION_PATH . '/');
+        }
+        require_once(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+	}
+
+    /**
+     * @dataProvider providerHashPassword
+     */
+	public function testHashPassword()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Shared_PasswordHasher','hashPassword'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerHashPassword()
+    {
+    	return new testDataFileIterator('rawTestData/Shared/PasswordHashes.data');
+	}
+
+}

vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Shared/StringTest.php

@@ -0,0 +1,83 @@
+<?php
+
+
+require_once 'testDataFileIterator.php';
+
+class StringTest extends PHPUnit_Framework_TestCase
+{
+
+    public function setUp()
+    {
+        if (!defined('PHPEXCEL_ROOT')) {
+            define('PHPEXCEL_ROOT', APPLICATION_PATH . '/');
+        }
+        require_once(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+	}
+
+	public function testGetIsMbStringEnabled()
+	{
+		$result = call_user_func(array('PHPExcel_Shared_String','getIsMbstringEnabled'));
+		$this->assertTrue($result);
+	}
+
+	public function testGetIsIconvEnabled()
+	{
+		$result = call_user_func(array('PHPExcel_Shared_String','getIsIconvEnabled'));
+		$this->assertTrue($result);
+	}
+
+	public function testGetDecimalSeparator()
+	{
+		$localeconv = localeconv();
+
+		$expectedResult = (!empty($localeconv['decimal_point'])) ? $localeconv['decimal_point'] : ',';
+		$result = call_user_func(array('PHPExcel_Shared_String','getDecimalSeparator'));
+		$this->assertEquals($expectedResult, $result);
+	}
+
+	public function testSetDecimalSeparator()
+	{
+		$expectedResult = ',';
+		$result = call_user_func(array('PHPExcel_Shared_String','setDecimalSeparator'),$expectedResult);
+
+		$result = call_user_func(array('PHPExcel_Shared_String','getDecimalSeparator'));
+		$this->assertEquals($expectedResult, $result);
+	}
+
+	public function testGetThousandsSeparator()
+	{
+		$localeconv = localeconv();
+
+		$expectedResult = (!empty($localeconv['thousands_sep'])) ? $localeconv['thousands_sep'] : ',';
+		$result = call_user_func(array('PHPExcel_Shared_String','getThousandsSeparator'));
+		$this->assertEquals($expectedResult, $result);
+	}
+
+	public function testSetThousandsSeparator()
+	{
+		$expectedResult = ' ';
+		$result = call_user_func(array('PHPExcel_Shared_String','setThousandsSeparator'),$expectedResult);
+
+		$result = call_user_func(array('PHPExcel_Shared_String','getThousandsSeparator'));
+		$this->assertEquals($expectedResult, $result);
+	}
+
+	public function testGetCurrencyCode()
+	{
+		$localeconv = localeconv();
+
+		$expectedResult = (!empty($localeconv['currency_symbol'])) ? $localeconv['currency_symbol'] : '$';
+		$result = call_user_func(array('PHPExcel_Shared_String','getCurrencyCode'));
+		$this->assertEquals($expectedResult, $result);
+	}
+
+	public function testSetCurrencyCode()
+	{
+		$expectedResult = '£';
+		$result = call_user_func(array('PHPExcel_Shared_String','setCurrencyCode'),$expectedResult);
+
+		$result = call_user_func(array('PHPExcel_Shared_String','getCurrencyCode'));
+		$this->assertEquals($expectedResult, $result);
+	}
+
+}

vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Shared/TimeZoneTest.php

@@ -0,0 +1,39 @@
+<?php
+
+
+class TimeZoneTest extends PHPUnit_Framework_TestCase
+{
+
+    public function setUp()
+    {
+        if (!defined('PHPEXCEL_ROOT')) {
+            define('PHPEXCEL_ROOT', APPLICATION_PATH . '/');
+        }
+        require_once(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+	}
+
+	public function testSetTimezone()
+	{
+		$timezoneValues = array(
+			'Europe/Prague',
+			'Asia/Tokyo',
+			'America/Indiana/Indianapolis',
+			'Pacific/Honolulu',
+			'Atlantic/St_Helena',
+		);
+
+		foreach($timezoneValues as $timezoneValue) {
+			$result = call_user_func(array('PHPExcel_Shared_TimeZone','setTimezone'),$timezoneValue);
+			$this->assertTrue($result);
+		}
+
+	}
+
+    public function testSetTimezoneWithInvalidValue()
+	{
+		$unsupportedTimezone = 'Etc/GMT+10';
+		$result = call_user_func(array('PHPExcel_Shared_TimeZone','setTimezone'),$unsupportedTimezone);
+		$this->assertFalse($result);
+	}
+
+}

vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Style/ColorTest.php

@@ -0,0 +1,81 @@
+<?php
+
+
+require_once 'testDataFileIterator.php';
+
+class ColorTest extends PHPUnit_Framework_TestCase
+{
+
+    public function setUp()
+    {
+        if (!defined('PHPEXCEL_ROOT')) {
+            define('PHPEXCEL_ROOT', APPLICATION_PATH . '/');
+        }
+        require_once(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+	}
+
+    /**
+     * @dataProvider providerColorGetRed
+     */
+	public function testGetRed()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Style_Color','getRed'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerColorGetRed()
+    {
+    	return new testDataFileIterator('rawTestData/Style/ColorGetRed.data');
+	}
+
+    /**
+     * @dataProvider providerColorGetGreen
+     */
+	public function testGetGreen()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Style_Color','getGreen'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerColorGetGreen()
+    {
+    	return new testDataFileIterator('rawTestData/Style/ColorGetGreen.data');
+	}
+
+    /**
+     * @dataProvider providerColorGetBlue
+     */
+	public function testGetBlue()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Style_Color','getBlue'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerColorGetBlue()
+    {
+    	return new testDataFileIterator('rawTestData/Style/ColorGetBlue.data');
+	}
+
+    /**
+     * @dataProvider providerColorChangeBrightness
+     */
+	public function testChangeBrightness()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Style_Color','changeBrightness'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerColorChangeBrightness()
+    {
+    	return new testDataFileIterator('rawTestData/Style/ColorChangeBrightness.data');
+	}
+
+}

vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Style/NumberFormatTest.php

@@ -0,0 +1,36 @@
+<?php
+
+
+require_once 'testDataFileIterator.php';
+
+class NumberFormatTest extends PHPUnit_Framework_TestCase
+{
+
+    public function setUp()
+    {
+        if (!defined('PHPEXCEL_ROOT')) {
+            define('PHPEXCEL_ROOT', APPLICATION_PATH . '/');
+        }
+        require_once(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+
+		PHPExcel_Shared_String::setDecimalSeparator('.');
+		PHPExcel_Shared_String::setThousandsSeparator(',');
+	}
+
+    /**
+     * @dataProvider providerNumberFormat
+     */
+	public function testFormatValueWithMask()
+	{
+		$args = func_get_args();
+		$expectedResult = array_pop($args);
+		$result = call_user_func_array(array('PHPExcel_Style_NumberFormat','toFormattedString'),$args);
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    public function providerNumberFormat()
+    {
+    	return new testDataFileIterator('rawTestData/Style/NumberFormat.data');
+	}
+
+}

vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Worksheet/AutoFilter/Column/RuleTest.php

@@ -0,0 +1,109 @@
+<?php
+
+
+class RuleTest extends PHPUnit_Framework_TestCase
+{
+	private $_testAutoFilterRuleObject;
+
+	private $_mockAutoFilterColumnObject;
+
+    public function setUp()
+    {
+        if (!defined('PHPEXCEL_ROOT')) {
+            define('PHPEXCEL_ROOT', APPLICATION_PATH . '/');
+        }
+        require_once(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+
+        $this->_mockAutoFilterColumnObject = $this->getMockBuilder('PHPExcel_Worksheet_AutoFilter_Column')
+        	->disableOriginalConstructor()
+        	->getMock();
+
+        $this->_mockAutoFilterColumnObject->expects($this->any())
+        	->method('testColumnInRange')
+        	->will($this->returnValue(3));
+
+		$this->_testAutoFilterRuleObject = new PHPExcel_Worksheet_AutoFilter_Column_Rule(
+			$this->_mockAutoFilterColumnObject
+		);
+    }
+
+	public function testGetRuleType()
+	{
+		$result = $this->_testAutoFilterRuleObject->getRuleType();
+		$this->assertEquals(PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_RULETYPE_FILTER, $result);
+	}
+
+	public function testSetRuleType()
+	{
+		$expectedResult = PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_RULETYPE_DATEGROUP;
+
+		//	Setters return the instance to implement the fluent interface
+		$result = $this->_testAutoFilterRuleObject->setRuleType($expectedResult);
+		$this->assertInstanceOf('PHPExcel_Worksheet_AutoFilter_Column_Rule', $result);
+
+		$result = $this->_testAutoFilterRuleObject->getRuleType();
+		$this->assertEquals($expectedResult, $result);
+	}
+
+	public function testSetValue()
+	{
+		$expectedResult = 100;
+
+		//	Setters return the instance to implement the fluent interface
+		$result = $this->_testAutoFilterRuleObject->setValue($expectedResult);
+		$this->assertInstanceOf('PHPExcel_Worksheet_AutoFilter_Column_Rule', $result);
+
+		$result = $this->_testAutoFilterRuleObject->getValue();
+		$this->assertEquals($expectedResult, $result);
+	}
+
+	public function testGetOperator()
+	{
+		$result = $this->_testAutoFilterRuleObject->getOperator();
+		$this->assertEquals(PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_COLUMN_RULE_EQUAL, $result);
+	}
+
+	public function testSetOperator()
+	{
+		$expectedResult = PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_COLUMN_RULE_LESSTHAN;
+
+		//	Setters return the instance to implement the fluent interface
+		$result = $this->_testAutoFilterRuleObject->setOperator($expectedResult);
+		$this->assertInstanceOf('PHPExcel_Worksheet_AutoFilter_Column_Rule', $result);
+
+		$result = $this->_testAutoFilterRuleObject->getOperator();
+		$this->assertEquals($expectedResult, $result);
+	}
+
+	public function testSetGrouping()
+	{
+		$expectedResult = PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_RULETYPE_DATEGROUP_MONTH;
+
+		//	Setters return the instance to implement the fluent interface
+		$result = $this->_testAutoFilterRuleObject->setGrouping($expectedResult);
+		$this->assertInstanceOf('PHPExcel_Worksheet_AutoFilter_Column_Rule', $result);
+
+		$result = $this->_testAutoFilterRuleObject->getGrouping();
+		$this->assertEquals($expectedResult, $result);
+	}
+
+	public function testGetParent()
+	{
+		$result = $this->_testAutoFilterRuleObject->getParent();
+		$this->assertInstanceOf('PHPExcel_Worksheet_AutoFilter_Column', $result);
+	}
+
+	public function testSetParent()
+	{
+		//	Setters return the instance to implement the fluent interface
+		$result = $this->_testAutoFilterRuleObject->setParent($this->_mockAutoFilterColumnObject);
+		$this->assertInstanceOf('PHPExcel_Worksheet_AutoFilter_Column_Rule', $result);
+	}
+
+	public function testClone()
+	{
+		$result = clone $this->_testAutoFilterRuleObject;
+		$this->assertInstanceOf('PHPExcel_Worksheet_AutoFilter_Column_Rule', $result);
+	}
+
+}

vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Worksheet/AutoFilter/ColumnTest.php

@@ -0,0 +1,173 @@
+<?php
+
+
+class AutofilterColumnTest extends PHPUnit_Framework_TestCase
+{
+	private $_testInitialColumn = 'H';
+
+	private $_testAutoFilterColumnObject;
+
+	private $_mockAutoFilterObject;
+
+    public function setUp()
+    {
+        if (!defined('PHPEXCEL_ROOT')) {
+            define('PHPEXCEL_ROOT', APPLICATION_PATH . '/');
+        }
+        require_once(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+
+        $this->_mockAutoFilterObject = $this->getMockBuilder('PHPExcel_Worksheet_AutoFilter')
+        	->disableOriginalConstructor()
+        	->getMock();
+
+        $this->_mockAutoFilterObject->expects($this->any())
+        	->method('testColumnInRange')
+        	->will($this->returnValue(3));
+
+		$this->_testAutoFilterColumnObject = new PHPExcel_Worksheet_AutoFilter_Column(
+			$this->_testInitialColumn,
+			$this->_mockAutoFilterObject
+		);
+    }
+
+	public function testGetColumnIndex()
+	{
+		$result = $this->_testAutoFilterColumnObject->getColumnIndex();
+		$this->assertEquals($this->_testInitialColumn, $result);
+	}
+
+	public function testSetColumnIndex()
+	{
+		$expectedResult = 'L';
+
+		//	Setters return the instance to implement the fluent interface
+		$result = $this->_testAutoFilterColumnObject->setColumnIndex($expectedResult);
+		$this->assertInstanceOf('PHPExcel_Worksheet_AutoFilter_Column', $result);
+
+		$result = $this->_testAutoFilterColumnObject->getColumnIndex();
+		$this->assertEquals($expectedResult, $result);
+	}
+
+	public function testGetParent()
+	{
+		$result = $this->_testAutoFilterColumnObject->getParent();
+		$this->assertInstanceOf('PHPExcel_Worksheet_AutoFilter', $result);
+	}
+
+	public function testSetParent()
+	{
+		//	Setters return the instance to implement the fluent interface
+		$result = $this->_testAutoFilterColumnObject->setParent($this->_mockAutoFilterObject);
+		$this->assertInstanceOf('PHPExcel_Worksheet_AutoFilter_Column', $result);
+	}
+
+	public function testGetFilterType()
+	{
+		$result = $this->_testAutoFilterColumnObject->getFilterType();
+		$this->assertEquals(PHPExcel_Worksheet_AutoFilter_Column::AUTOFILTER_FILTERTYPE_FILTER, $result);
+	}
+
+	public function testSetFilterType()
+	{
+		$result = $this->_testAutoFilterColumnObject->setFilterType(PHPExcel_Worksheet_AutoFilter_Column::AUTOFILTER_FILTERTYPE_DYNAMICFILTER);
+		$this->assertInstanceOf('PHPExcel_Worksheet_AutoFilter_Column', $result);
+
+		$result = $this->_testAutoFilterColumnObject->getFilterType();
+		$this->assertEquals(PHPExcel_Worksheet_AutoFilter_Column::AUTOFILTER_FILTERTYPE_DYNAMICFILTER, $result);
+	}
+
+    /**
+     * @expectedException PHPExcel_Exception
+     */
+	public function testSetInvalidFilterTypeThrowsException()
+	{
+		$expectedResult = 'Unfiltered';
+
+		$result = $this->_testAutoFilterColumnObject->setFilterType($expectedResult);
+	}
+
+	public function testGetJoin()
+	{
+		$result = $this->_testAutoFilterColumnObject->getJoin();
+		$this->assertEquals(PHPExcel_Worksheet_AutoFilter_Column::AUTOFILTER_COLUMN_JOIN_OR, $result);
+	}
+
+	public function testSetJoin()
+	{
+		$result = $this->_testAutoFilterColumnObject->setJoin(PHPExcel_Worksheet_AutoFilter_Column::AUTOFILTER_COLUMN_JOIN_AND);
+		$this->assertInstanceOf('PHPExcel_Worksheet_AutoFilter_Column', $result);
+
+		$result = $this->_testAutoFilterColumnObject->getJoin();
+		$this->assertEquals(PHPExcel_Worksheet_AutoFilter_Column::AUTOFILTER_COLUMN_JOIN_AND, $result);
+	}
+
+    /**
+     * @expectedException PHPExcel_Exception
+     */
+	public function testSetInvalidJoinThrowsException()
+	{
+		$expectedResult = 'Neither';
+
+		$result = $this->_testAutoFilterColumnObject->setJoin($expectedResult);
+	}
+
+	public function testSetAttributes()
+	{
+		$attributeSet = array(	'val' => 100,
+								'maxVal' => 200
+							 );
+
+		//	Setters return the instance to implement the fluent interface
+		$result = $this->_testAutoFilterColumnObject->setAttributes($attributeSet);
+		$this->assertInstanceOf('PHPExcel_Worksheet_AutoFilter_Column', $result);
+	}
+
+	public function testGetAttributes()
+	{
+		$attributeSet = array(	'val' => 100,
+								'maxVal' => 200
+							 );
+
+		$this->_testAutoFilterColumnObject->setAttributes($attributeSet);
+
+		$result = $this->_testAutoFilterColumnObject->getAttributes();
+		$this->assertTrue(is_array($result));
+		$this->assertEquals(count($attributeSet), count($result));
+	}
+
+	public function testSetAttribute()
+	{
+		$attributeSet = array(	'val' => 100,
+								'maxVal' => 200
+							 );
+
+		foreach($attributeSet as $attributeName => $attributeValue) {
+			//	Setters return the instance to implement the fluent interface
+			$result = $this->_testAutoFilterColumnObject->setAttribute($attributeName,$attributeValue);
+			$this->assertInstanceOf('PHPExcel_Worksheet_AutoFilter_Column', $result);
+		}
+	}
+
+	public function testGetAttribute()
+	{
+		$attributeSet = array(	'val' => 100,
+								'maxVal' => 200
+							 );
+
+		$this->_testAutoFilterColumnObject->setAttributes($attributeSet);
+
+		foreach($attributeSet as $attributeName => $attributeValue) {
+			$result = $this->_testAutoFilterColumnObject->getAttribute($attributeName);
+			$this->assertEquals($attributeValue, $result);
+		}
+		$result = $this->_testAutoFilterColumnObject->getAttribute('nonExistentAttribute');
+		$this->assertNull($result);
+	}
+
+	public function testClone()
+	{
+		$result = clone $this->_testAutoFilterColumnObject;
+		$this->assertInstanceOf('PHPExcel_Worksheet_AutoFilter_Column', $result);
+	}
+
+}

vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Worksheet/AutoFilterTest.php

@@ -0,0 +1,340 @@
+<?php
+
+
+class AutoFilterTest extends PHPUnit_Framework_TestCase
+{
+	private $_testInitialRange = 'H2:O256';
+
+	private $_testAutoFilterObject;
+
+
+    public function setUp()
+    {
+        if (!defined('PHPEXCEL_ROOT')) {
+            define('PHPEXCEL_ROOT', APPLICATION_PATH . '/');
+        }
+        require_once(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+
+        $this->_mockWorksheetObject = $this->getMockBuilder('PHPExcel_Worksheet')
+        	->disableOriginalConstructor()
+        	->getMock();
+        $this->_mockCacheController = $this->getMockBuilder('PHPExcel_CachedObjectStorage_Memory')
+        	->disableOriginalConstructor()
+        	->getMock();
+        $this->_mockWorksheetObject->expects($this->any())
+            ->method('getCellCacheController')
+            ->will($this->returnValue($this->_mockCacheController));
+
+		$this->_testAutoFilterObject = new PHPExcel_Worksheet_AutoFilter(
+			$this->_testInitialRange,
+			$this->_mockWorksheetObject
+		);
+    }
+
+	public function testToString()
+	{
+		$expectedResult = $this->_testInitialRange;
+
+		//	magic __toString should return the active autofilter range
+		$result = $this->_testAutoFilterObject;
+		$this->assertEquals($expectedResult, $result);
+	}
+
+	public function testGetParent()
+	{
+		$result = $this->_testAutoFilterObject->getParent();
+		$this->assertInstanceOf('PHPExcel_Worksheet', $result);
+	}
+
+	public function testSetParent()
+	{
+		//	Setters return the instance to implement the fluent interface
+		$result = $this->_testAutoFilterObject->setParent($this->_mockWorksheetObject);
+		$this->assertInstanceOf('PHPExcel_Worksheet_AutoFilter', $result);
+	}
+
+	public function testGetRange()
+	{
+		$expectedResult = $this->_testInitialRange;
+
+		//	Result should be the active autofilter range
+		$result = $this->_testAutoFilterObject->getRange();
+		$this->assertEquals($expectedResult, $result);
+	}
+
+	public function testSetRange()
+	{
+		$ranges = array('G1:J512' => 'Worksheet1!G1:J512',
+						'K1:N20' => 'K1:N20'
+					   );
+
+		foreach($ranges as $actualRange => $fullRange) {
+			//	Setters return the instance to implement the fluent interface
+			$result = $this->_testAutoFilterObject->setRange($fullRange);
+			$this->assertInstanceOf('PHPExcel_Worksheet_AutoFilter', $result);
+
+			//	Result should be the new autofilter range
+			$result = $this->_testAutoFilterObject->getRange();
+			$this->assertEquals($actualRange, $result);
+		}
+	}
+
+	public function testClearRange()
+	{
+		$expectedResult = '';
+
+		//	Setters return the instance to implement the fluent interface
+		$result = $this->_testAutoFilterObject->setRange();
+		$this->assertInstanceOf('PHPExcel_Worksheet_AutoFilter', $result);
+
+		//	Result should be a clear range
+		$result = $this->_testAutoFilterObject->getRange();
+		$this->assertEquals($expectedResult, $result);
+	}
+
+    /**
+     * @expectedException PHPExcel_Exception
+     */
+	public function testSetRangeInvalidRange()
+	{
+		$expectedResult = 'A1';
+
+		$result = $this->_testAutoFilterObject->setRange($expectedResult);
+	}
+
+	public function testGetColumnsEmpty()
+	{
+		//	There should be no columns yet defined
+		$result = $this->_testAutoFilterObject->getColumns();
+		$this->assertInternalType('array', $result);
+		$this->assertEquals(0, count($result));
+	}
+
+	public function testGetColumnOffset()
+	{
+		$columnIndexes = array(	'H' => 0,
+								'K' => 3,
+								'M' => 5
+							  );
+
+		//	If we request a specific column by its column ID, we should get an
+		//	integer returned representing the column offset within the range
+		foreach($columnIndexes as $columnIndex => $columnOffset) {
+			$result = $this->_testAutoFilterObject->getColumnOffset($columnIndex);
+			$this->assertEquals($columnOffset, $result);
+		}
+	}
+
+    /**
+     * @expectedException PHPExcel_Exception
+     */
+    public function testGetInvalidColumnOffset()
+	{
+		$invalidColumn = 'G';
+
+		$result = $this->_testAutoFilterObject->getColumnOffset($invalidColumn);
+	}
+
+	public function testSetColumnWithString()
+	{
+		$expectedResult = 'L';
+
+		//	Setters return the instance to implement the fluent interface
+		$result = $this->_testAutoFilterObject->setColumn($expectedResult);
+		$this->assertInstanceOf('PHPExcel_Worksheet_AutoFilter', $result);
+
+		$result = $this->_testAutoFilterObject->getColumns();
+		//	Result should be an array of PHPExcel_Worksheet_AutoFilter_Column
+		//	objects for each column we set indexed by the column ID
+		$this->assertInternalType('array', $result);
+		$this->assertEquals(1, count($result));
+		$this->assertArrayHasKey($expectedResult,$result);
+		$this->assertInstanceOf('PHPExcel_Worksheet_AutoFilter_Column', $result[$expectedResult]);
+	}
+
+    /**
+     * @expectedException PHPExcel_Exception
+     */
+    public function testSetInvalidColumnWithString()
+	{
+		$invalidColumn = 'A';
+
+		$result = $this->_testAutoFilterObject->setColumn($invalidColumn);
+	}
+
+	public function testSetColumnWithColumnObject()
+	{
+		$expectedResult = 'M';
+		$columnObject = new PHPExcel_Worksheet_AutoFilter_Column($expectedResult);
+
+		//	Setters return the instance to implement the fluent interface
+		$result = $this->_testAutoFilterObject->setColumn($columnObject);
+		$this->assertInstanceOf('PHPExcel_Worksheet_AutoFilter', $result);
+
+		$result = $this->_testAutoFilterObject->getColumns();
+		//	Result should be an array of PHPExcel_Worksheet_AutoFilter_Column
+		//	objects for each column we set indexed by the column ID
+		$this->assertInternalType('array', $result);
+		$this->assertEquals(1, count($result));
+		$this->assertArrayHasKey($expectedResult,$result);
+		$this->assertInstanceOf('PHPExcel_Worksheet_AutoFilter_Column', $result[$expectedResult]);
+	}
+
+    /**
+     * @expectedException PHPExcel_Exception
+     */
+    public function testSetInvalidColumnWithObject()
+	{
+		$invalidColumn = 'E';
+		$columnObject = new PHPExcel_Worksheet_AutoFilter_Column($invalidColumn);
+
+		$result = $this->_testAutoFilterObject->setColumn($invalidColumn);
+	}
+
+    /**
+     * @expectedException PHPExcel_Exception
+     */
+    public function testSetColumnWithInvalidDataType()
+	{
+		$invalidColumn = 123.456;
+		$columnObject = new PHPExcel_Worksheet_AutoFilter_Column($invalidColumn);
+
+		$result = $this->_testAutoFilterObject->setColumn($invalidColumn);
+	}
+
+	public function testGetColumns()
+	{
+		$columnIndexes = array('L','M');
+
+		foreach($columnIndexes as $columnIndex) {
+			$this->_testAutoFilterObject->setColumn($columnIndex);
+		}
+
+		$result = $this->_testAutoFilterObject->getColumns();
+		//	Result should be an array of PHPExcel_Worksheet_AutoFilter_Column
+		//	objects for each column we set indexed by the column ID
+		$this->assertInternalType('array', $result);
+		$this->assertEquals(count($columnIndexes), count($result));
+		foreach($columnIndexes as $columnIndex) {
+			$this->assertArrayHasKey($columnIndex,$result);
+			$this->assertInstanceOf('PHPExcel_Worksheet_AutoFilter_Column', $result[$columnIndex]);
+		}
+	}
+
+	public function testGetColumn()
+	{
+		$columnIndexes = array('L','M');
+
+		foreach($columnIndexes as $columnIndex) {
+			$this->_testAutoFilterObject->setColumn($columnIndex);
+		}
+
+		//	If we request a specific column by its column ID, we should
+		//	get a PHPExcel_Worksheet_AutoFilter_Column object returned
+		foreach($columnIndexes as $columnIndex) {
+			$result = $this->_testAutoFilterObject->getColumn($columnIndex);
+			$this->assertInstanceOf('PHPExcel_Worksheet_AutoFilter_Column', $result);
+		}
+	}
+
+	public function testGetColumnByOffset()
+	{
+		$columnIndexes = array(	0 => 'H',
+								3 => 'K',
+								5 => 'M'
+							  );
+
+		//	If we request a specific column by its offset, we should
+		//	get a PHPExcel_Worksheet_AutoFilter_Column object returned
+		foreach($columnIndexes as $columnIndex => $columnID) {
+			$result = $this->_testAutoFilterObject->getColumnByOffset($columnIndex);
+			$this->assertInstanceOf('PHPExcel_Worksheet_AutoFilter_Column', $result);
+			$this->assertEquals($result->getColumnIndex(),$columnID);
+		}
+	}
+
+	public function testGetColumnIfNotSet()
+	{
+		//	If we request a specific column by its column ID, we should
+		//	get a PHPExcel_Worksheet_AutoFilter_Column object returned
+		$result = $this->_testAutoFilterObject->getColumn('K');
+		$this->assertInstanceOf('PHPExcel_Worksheet_AutoFilter_Column', $result);
+	}
+
+    /**
+     * @expectedException PHPExcel_Exception
+     */
+	public function testGetColumnWithoutRangeSet()
+	{
+		//	Clear the range
+		$result = $this->_testAutoFilterObject->setRange();
+
+		$result = $this->_testAutoFilterObject->getColumn('A');
+	}
+
+	public function testClearRangeWithExistingColumns()
+	{
+		$expectedResult = '';
+
+		$columnIndexes = array('L','M','N');
+		foreach($columnIndexes as $columnIndex) {
+			$this->_testAutoFilterObject->setColumn($columnIndex);
+		}
+
+		//	Setters return the instance to implement the fluent interface
+		$result = $this->_testAutoFilterObject->setRange();
+		$this->assertInstanceOf('PHPExcel_Worksheet_AutoFilter', $result);
+
+		//	Range should be cleared
+		$result = $this->_testAutoFilterObject->getRange();
+		$this->assertEquals($expectedResult, $result);
+
+		//	Column array should be cleared
+		$result = $this->_testAutoFilterObject->getColumns();
+		$this->assertInternalType('array', $result);
+		$this->assertEquals(0, count($result));
+	}
+
+	public function testSetRangeWithExistingColumns()
+	{
+		$expectedResult = 'G1:J512';
+
+		//	These columns should be retained
+		$columnIndexes1 = array('I','J');
+		foreach($columnIndexes1 as $columnIndex) {
+			$this->_testAutoFilterObject->setColumn($columnIndex);
+		}
+		//	These columns should be discarded
+		$columnIndexes2 = array('K','L','M');
+		foreach($columnIndexes2 as $columnIndex) {
+			$this->_testAutoFilterObject->setColumn($columnIndex);
+		}
+
+		//	Setters return the instance to implement the fluent interface
+		$result = $this->_testAutoFilterObject->setRange($expectedResult);
+		$this->assertInstanceOf('PHPExcel_Worksheet_AutoFilter', $result);
+
+		//	Range should be correctly set
+		$result = $this->_testAutoFilterObject->getRange();
+		$this->assertEquals($expectedResult, $result);
+
+		//	Only columns that existed in the original range and that
+		//		still fall within the new range should be retained
+		$result = $this->_testAutoFilterObject->getColumns();
+		$this->assertInternalType('array', $result);
+		$this->assertEquals(count($columnIndexes1), count($result));
+	}
+
+	public function testClone()
+	{
+		$columnIndexes = array('L','M');
+
+		foreach($columnIndexes as $columnIndex) {
+			$this->_testAutoFilterObject->setColumn($columnIndex);
+		}
+
+		$result = clone $this->_testAutoFilterObject;
+		$this->assertInstanceOf('PHPExcel_Worksheet_AutoFilter', $result);
+	}
+
+}

vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Worksheet/CellCollectionTest.php

@@ -0,0 +1,31 @@
+<?php
+
+class CellCollectionTest extends PHPUnit_Framework_TestCase
+{
+
+	public function setUp()
+	{
+		if (!defined('PHPEXCEL_ROOT'))
+		{
+			define('PHPEXCEL_ROOT', APPLICATION_PATH . '/');
+		}
+		require_once(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+	}
+
+
+	public function testCacheLastCell()
+	{
+		$methods = PHPExcel_CachedObjectStorageFactory::getCacheStorageMethods();
+		foreach ($methods as $method) {
+			PHPExcel_CachedObjectStorageFactory::initialize($method);
+			$workbook = new PHPExcel();
+			$cells = array('A1', 'A2');
+			$worksheet = $workbook->getActiveSheet();
+			$worksheet->setCellValue('A1', 1);
+			$worksheet->setCellValue('A2', 2);
+			$this->assertEquals($cells, $worksheet->getCellCollection(), "Cache method \"$method\".");
+			PHPExcel_CachedObjectStorageFactory::finalize();
+		}
+	}
+
+}

vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Worksheet/ColumnCellIteratorTest.php

@@ -0,0 +1,87 @@
+<?php
+
+class ColumnCellIteratorTest extends PHPUnit_Framework_TestCase
+{
+    public $mockWorksheet;
+    public $mockColumnCell;
+
+	public function setUp()
+	{
+		if (!defined('PHPEXCEL_ROOT')) {
+			define('PHPEXCEL_ROOT', APPLICATION_PATH . '/');
+		}
+		require_once(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+        
+        $this->mockCell = $this->getMockBuilder('PHPExcel_Cell')
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $this->mockWorksheet = $this->getMockBuilder('PHPExcel_Worksheet')
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $this->mockWorksheet->expects($this->any())
+                 ->method('getHighestRow')
+                 ->will($this->returnValue(5));
+        $this->mockWorksheet->expects($this->any())
+                 ->method('getCellByColumnAndRow')
+                 ->will($this->returnValue($this->mockCell));
+    }
+
+
+	public function testIteratorFullRange()
+	{
+        $iterator = new PHPExcel_Worksheet_ColumnCellIterator($this->mockWorksheet, 'A');
+        $ColumnCellIndexResult = 1;
+        $this->assertEquals($ColumnCellIndexResult, $iterator->key());
+        
+        foreach($iterator as $key => $ColumnCell) {
+            $this->assertEquals($ColumnCellIndexResult++, $key);
+            $this->assertInstanceOf('PHPExcel_Cell', $ColumnCell);
+        }
+	}
+
+	public function testIteratorStartEndRange()
+	{
+        $iterator = new PHPExcel_Worksheet_ColumnCellIterator($this->mockWorksheet, 'A', 2, 4);
+        $ColumnCellIndexResult = 2;
+        $this->assertEquals($ColumnCellIndexResult, $iterator->key());
+        
+        foreach($iterator as $key => $ColumnCell) {
+            $this->assertEquals($ColumnCellIndexResult++, $key);
+            $this->assertInstanceOf('PHPExcel_Cell', $ColumnCell);
+        }
+	}
+
+	public function testIteratorSeekAndPrev()
+	{
+        $iterator = new PHPExcel_Worksheet_ColumnCellIterator($this->mockWorksheet, 'A', 2, 4);
+        $columnIndexResult = 4;
+        $iterator->seek(4);
+        $this->assertEquals($columnIndexResult, $iterator->key());
+
+        for($i = 1; $i < $columnIndexResult-1; $i++) {
+            $iterator->prev();
+            $this->assertEquals($columnIndexResult - $i, $iterator->key());
+        }
+	}
+
+    /**
+     * @expectedException PHPExcel_Exception
+     */
+    public function testSeekOutOfRange()
+    {
+        $iterator = new PHPExcel_Worksheet_ColumnCellIterator($this->mockWorksheet, 'A', 2, 4);
+        $iterator->seek(1);
+    }
+
+    /**
+     * @expectedException PHPExcel_Exception
+     */
+    public function testPrevOutOfRange()
+    {
+        $iterator = new PHPExcel_Worksheet_ColumnCellIterator($this->mockWorksheet, 'A', 2, 4);
+        $iterator->prev();
+    }
+
+}

vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Worksheet/ColumnIteratorTest.php

@@ -0,0 +1,89 @@
+<?php
+
+class ColumnIteratorTest extends PHPUnit_Framework_TestCase
+{
+    public $mockWorksheet;
+    public $mockColumn;
+
+	public function setUp()
+	{
+		if (!defined('PHPEXCEL_ROOT')) {
+			define('PHPEXCEL_ROOT', APPLICATION_PATH . '/');
+		}
+		require_once(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+        
+        $this->mockColumn = $this->getMockBuilder('PHPExcel_Worksheet_Column')
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $this->mockWorksheet = $this->getMockBuilder('PHPExcel_Worksheet')
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $this->mockWorksheet->expects($this->any())
+                 ->method('getHighestColumn')
+                 ->will($this->returnValue('E'));
+        $this->mockWorksheet->expects($this->any())
+                 ->method('current')
+                 ->will($this->returnValue($this->mockColumn));
+    }
+
+
+	public function testIteratorFullRange()
+	{
+        $iterator = new PHPExcel_Worksheet_ColumnIterator($this->mockWorksheet);
+        $columnIndexResult = 'A';
+        $this->assertEquals($columnIndexResult, $iterator->key());
+        
+        foreach($iterator as $key => $column) {
+            $this->assertEquals($columnIndexResult++, $key);
+            $this->assertInstanceOf('PHPExcel_Worksheet_Column', $column);
+        }
+	}
+
+	public function testIteratorStartEndRange()
+	{
+        $iterator = new PHPExcel_Worksheet_ColumnIterator($this->mockWorksheet, 'B', 'D');
+        $columnIndexResult = 'B';
+        $this->assertEquals($columnIndexResult, $iterator->key());
+        
+        foreach($iterator as $key => $column) {
+            $this->assertEquals($columnIndexResult++, $key);
+            $this->assertInstanceOf('PHPExcel_Worksheet_Column', $column);
+        }
+	}
+
+	public function testIteratorSeekAndPrev()
+	{
+        $ranges = range('A','E');
+        $iterator = new PHPExcel_Worksheet_ColumnIterator($this->mockWorksheet, 'B', 'D');
+        $columnIndexResult = 'D';
+        $iterator->seek('D');
+        $this->assertEquals($columnIndexResult, $iterator->key());
+
+        for($i = 1; $i < array_search($columnIndexResult, $ranges); $i++) {
+            $iterator->prev();
+            $expectedResult = $ranges[array_search($columnIndexResult, $ranges) - $i];
+            $this->assertEquals($expectedResult, $iterator->key());
+        }
+	}
+
+    /**
+     * @expectedException PHPExcel_Exception
+     */
+    public function testSeekOutOfRange()
+    {
+        $iterator = new PHPExcel_Worksheet_ColumnIterator($this->mockWorksheet, 'B', 'D');
+        $iterator->seek('A');
+    }
+
+    /**
+     * @expectedException PHPExcel_Exception
+     */
+    public function testPrevOutOfRange()
+    {
+        $iterator = new PHPExcel_Worksheet_ColumnIterator($this->mockWorksheet, 'B', 'D');
+        $iterator->prev();
+    }
+
+}

vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Worksheet/RowCellIteratorTest.php

@@ -0,0 +1,89 @@
+<?php
+
+class RowCellIteratorTest extends PHPUnit_Framework_TestCase
+{
+    public $mockWorksheet;
+    public $mockRowCell;
+
+	public function setUp()
+	{
+		if (!defined('PHPEXCEL_ROOT')) {
+			define('PHPEXCEL_ROOT', APPLICATION_PATH . '/');
+		}
+		require_once(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+        
+        $this->mockCell = $this->getMockBuilder('PHPExcel_Cell')
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $this->mockWorksheet = $this->getMockBuilder('PHPExcel_Worksheet')
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $this->mockWorksheet->expects($this->any())
+                 ->method('getHighestColumn')
+                 ->will($this->returnValue('E'));
+        $this->mockWorksheet->expects($this->any())
+                 ->method('getCellByColumnAndRow')
+                 ->will($this->returnValue($this->mockCell));
+    }
+
+
+	public function testIteratorFullRange()
+	{
+        $iterator = new PHPExcel_Worksheet_RowCellIterator($this->mockWorksheet);
+        $RowCellIndexResult = 'A';
+        $this->assertEquals($RowCellIndexResult, $iterator->key());
+        
+        foreach($iterator as $key => $RowCell) {
+            $this->assertEquals($RowCellIndexResult++, $key);
+            $this->assertInstanceOf('PHPExcel_Cell', $RowCell);
+        }
+	}
+
+	public function testIteratorStartEndRange()
+	{
+        $iterator = new PHPExcel_Worksheet_RowCellIterator($this->mockWorksheet, 2, 'B', 'D');
+        $RowCellIndexResult = 'B';
+        $this->assertEquals($RowCellIndexResult, $iterator->key());
+        
+        foreach($iterator as $key => $RowCell) {
+            $this->assertEquals($RowCellIndexResult++, $key);
+            $this->assertInstanceOf('PHPExcel_Cell', $RowCell);
+        }
+	}
+
+	public function testIteratorSeekAndPrev()
+	{
+        $ranges = range('A','E');
+        $iterator = new PHPExcel_Worksheet_RowCellIterator($this->mockWorksheet, 2, 'B', 'D');
+        $RowCellIndexResult = 'D';
+        $iterator->seek('D');
+        $this->assertEquals($RowCellIndexResult, $iterator->key());
+
+        for($i = 1; $i < array_search($RowCellIndexResult, $ranges); $i++) {
+            $iterator->prev();
+            $expectedResult = $ranges[array_search($RowCellIndexResult, $ranges) - $i];
+            $this->assertEquals($expectedResult, $iterator->key());
+        }
+	}
+
+    /**
+     * @expectedException PHPExcel_Exception
+     */
+    public function testSeekOutOfRange()
+    {
+        $iterator = new PHPExcel_Worksheet_RowCellIterator($this->mockWorksheet, 2, 'B', 'D');
+        $iterator->seek(1);
+    }
+
+    /**
+     * @expectedException PHPExcel_Exception
+     */
+    public function testPrevOutOfRange()
+    {
+        $iterator = new PHPExcel_Worksheet_RowCellIterator($this->mockWorksheet, 2, 'B', 'D');
+        $iterator->prev();
+    }
+
+}

vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Worksheet/RowIteratorTest.php

@@ -0,0 +1,87 @@
+<?php
+
+class RowIteratorTest extends PHPUnit_Framework_TestCase
+{
+    public $mockWorksheet;
+    public $mockRow;
+
+	public function setUp()
+	{
+		if (!defined('PHPEXCEL_ROOT')) {
+			define('PHPEXCEL_ROOT', APPLICATION_PATH . '/');
+		}
+		require_once(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+        
+        $this->mockRow = $this->getMockBuilder('PHPExcel_Worksheet_Row')
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $this->mockWorksheet = $this->getMockBuilder('PHPExcel_Worksheet')
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $this->mockWorksheet->expects($this->any())
+                 ->method('getHighestRow')
+                 ->will($this->returnValue(5));
+        $this->mockWorksheet->expects($this->any())
+                 ->method('current')
+                 ->will($this->returnValue($this->mockRow));
+    }
+
+
+	public function testIteratorFullRange()
+	{
+        $iterator = new PHPExcel_Worksheet_RowIterator($this->mockWorksheet);
+        $rowIndexResult = 1;
+        $this->assertEquals($rowIndexResult, $iterator->key());
+        
+        foreach($iterator as $key => $row) {
+            $this->assertEquals($rowIndexResult++, $key);
+            $this->assertInstanceOf('PHPExcel_Worksheet_Row', $row);
+        }
+	}
+
+	public function testIteratorStartEndRange()
+	{
+        $iterator = new PHPExcel_Worksheet_RowIterator($this->mockWorksheet, 2, 4);
+        $rowIndexResult = 2;
+        $this->assertEquals($rowIndexResult, $iterator->key());
+        
+        foreach($iterator as $key => $row) {
+            $this->assertEquals($rowIndexResult++, $key);
+            $this->assertInstanceOf('PHPExcel_Worksheet_Row', $row);
+        }
+	}
+
+	public function testIteratorSeekAndPrev()
+	{
+        $iterator = new PHPExcel_Worksheet_RowIterator($this->mockWorksheet, 2, 4);
+        $columnIndexResult = 4;
+        $iterator->seek(4);
+        $this->assertEquals($columnIndexResult, $iterator->key());
+
+        for($i = 1; $i < $columnIndexResult-1; $i++) {
+            $iterator->prev();
+            $this->assertEquals($columnIndexResult - $i, $iterator->key());
+        }
+	}
+
+    /**
+     * @expectedException PHPExcel_Exception
+     */
+    public function testSeekOutOfRange()
+    {
+        $iterator = new PHPExcel_Worksheet_RowIterator($this->mockWorksheet, 2, 4);
+        $iterator->seek(1);
+    }
+
+    /**
+     * @expectedException PHPExcel_Exception
+     */
+    public function testPrevOutOfRange()
+    {
+        $iterator = new PHPExcel_Worksheet_RowIterator($this->mockWorksheet, 2, 4);
+        $iterator->prev();
+    }
+
+}

vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Worksheet/WorksheetColumnTest.php

@@ -0,0 +1,46 @@
+<?php
+
+class WorksheetColumnTest extends PHPUnit_Framework_TestCase
+{
+    public $mockWorksheet;
+    public $mockColumn;
+
+	public function setUp()
+	{
+		if (!defined('PHPEXCEL_ROOT')) {
+			define('PHPEXCEL_ROOT', APPLICATION_PATH . '/');
+		}
+		require_once(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+        
+        $this->mockWorksheet = $this->getMockBuilder('PHPExcel_Worksheet')
+            ->disableOriginalConstructor()
+            ->getMock();
+        $this->mockWorksheet->expects($this->any())
+                 ->method('getHighestRow')
+                 ->will($this->returnValue(5));
+    }
+
+
+	public function testInstantiateColumnDefault()
+	{
+        $column = new PHPExcel_Worksheet_Column($this->mockWorksheet);
+        $this->assertInstanceOf('PHPExcel_Worksheet_Column', $column);
+        $columnIndex = $column->getColumnIndex();
+        $this->assertEquals('A', $columnIndex);
+	}
+
+	public function testInstantiateColumnSpecified()
+	{
+        $column = new PHPExcel_Worksheet_Column($this->mockWorksheet, 'E');
+        $this->assertInstanceOf('PHPExcel_Worksheet_Column', $column);
+        $columnIndex = $column->getColumnIndex();
+        $this->assertEquals('E', $columnIndex);
+	}
+
+	public function testGetCellIterator()
+	{
+        $column = new PHPExcel_Worksheet_Column($this->mockWorksheet);
+        $cellIterator = $column->getCellIterator();
+        $this->assertInstanceOf('PHPExcel_Worksheet_ColumnCellIterator', $cellIterator);
+	}
+}

vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Worksheet/WorksheetRowTest.php

@@ -0,0 +1,46 @@
+<?php
+
+class WorksheetRowTest extends PHPUnit_Framework_TestCase
+{
+    public $mockWorksheet;
+    public $mockRow;
+
+	public function setUp()
+	{
+		if (!defined('PHPEXCEL_ROOT')) {
+			define('PHPEXCEL_ROOT', APPLICATION_PATH . '/');
+		}
+		require_once(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+        
+        $this->mockWorksheet = $this->getMockBuilder('PHPExcel_Worksheet')
+            ->disableOriginalConstructor()
+            ->getMock();
+        $this->mockWorksheet->expects($this->any())
+                 ->method('getHighestColumn')
+                 ->will($this->returnValue('E'));
+    }
+
+
+	public function testInstantiateRowDefault()
+	{
+        $row = new PHPExcel_Worksheet_Row($this->mockWorksheet);
+        $this->assertInstanceOf('PHPExcel_Worksheet_Row', $row);
+        $rowIndex = $row->getRowIndex();
+        $this->assertEquals(1, $rowIndex);
+	}
+
+	public function testInstantiateRowSpecified()
+	{
+        $row = new PHPExcel_Worksheet_Row($this->mockWorksheet, 5);
+        $this->assertInstanceOf('PHPExcel_Worksheet_Row', $row);
+        $rowIndex = $row->getRowIndex();
+        $this->assertEquals(5, $rowIndex);
+	}
+
+	public function testGetCellIterator()
+	{
+        $row = new PHPExcel_Worksheet_Row($this->mockWorksheet);
+        $cellIterator = $row->getCellIterator();
+        $this->assertInstanceOf('PHPExcel_Worksheet_RowCellIterator', $cellIterator);
+	}
+}