class AutoFilterTest in Loft Data Grids 7.2

Hierarchy

• class \AutoFilterTest extends \PHPUnit_Framework_TestCase

File

vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Worksheet/AutoFilterTest.php, line 4

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);
  }

}

Members

Name	Modifiers	Type	Description	Overrides
AutoFilterTest::$_testAutoFilterObject	private	property
AutoFilterTest::$_testInitialRange	private	property
AutoFilterTest::setUp	public	function
AutoFilterTest::testClearRange	public	function
AutoFilterTest::testClearRangeWithExistingColumns	public	function
AutoFilterTest::testClone	public	function
AutoFilterTest::testGetColumn	public	function
AutoFilterTest::testGetColumnByOffset	public	function
AutoFilterTest::testGetColumnIfNotSet	public	function
AutoFilterTest::testGetColumnOffset	public	function
AutoFilterTest::testGetColumns	public	function
AutoFilterTest::testGetColumnsEmpty	public	function
AutoFilterTest::testGetColumnWithoutRangeSet	public	function	@expectedException PHPExcel_Exception
AutoFilterTest::testGetInvalidColumnOffset	public	function	@expectedException PHPExcel_Exception
AutoFilterTest::testGetParent	public	function
AutoFilterTest::testGetRange	public	function
AutoFilterTest::testSetColumnWithColumnObject	public	function
AutoFilterTest::testSetColumnWithInvalidDataType	public	function	@expectedException PHPExcel_Exception
AutoFilterTest::testSetColumnWithString	public	function
AutoFilterTest::testSetInvalidColumnWithObject	public	function	@expectedException PHPExcel_Exception
AutoFilterTest::testSetInvalidColumnWithString	public	function	@expectedException PHPExcel_Exception
AutoFilterTest::testSetParent	public	function
AutoFilterTest::testSetRange	public	function
AutoFilterTest::testSetRangeInvalidRange	public	function	@expectedException PHPExcel_Exception
AutoFilterTest::testSetRangeWithExistingColumns	public	function
AutoFilterTest::testToString	public	function