PHP Classes
elePHPant
Icontem

File: test/enumerableTest.php

Recommend this page to a friend!
  Classes of Eustaquio Rangel de Oliveira Jr.  >  PHPR  >  test/enumerableTest.php  >  Download  
File: test/enumerableTest.php
Role: Unit test script
Content type: text/plain
Description: Unit test script
Class: PHPR
Provide functional interfaces to manipulate arrays
Author: By
Last change: Null index test.
Date: 3 years ago
Size: 9,382 bytes
 

Contents

Class file image Download
<?php
/**
 * Enumerable class tests
 *
 * PHP version 5.5
 *
 * @category Tests
 * @package PHPR
 * @author Eustáquio Rangel <taq@bluefish.com.br>
 * @license http://www.gnu.org/copyleft/gpl.html GPL
 * @link http://github.com/taq/torm
 */
require_once "../vendor/autoload.php";

/**
 * Cache test main class
 *
 * PHP version 5.5
 *
 * @category Tests
 * @package PHPR
 * @author Eustáquio Rangel <taq@bluefish.com.br>
 * @license http://www.gnu.org/copyleft/gpl.html GPL
 * @link http://github.com/taq/torm
 */
class EnumerableTest extends PHPUnit_Framework_TestCase
{
    private static
$_col = null;

   
/**
     * Run before initialization
     *
     * @return null
     */
   
public static function setUpBeforeClass()
    {
       
self::$_col = new PHPR\Collection([0 => "zero", 1 => "one", 2 => "two"]);
    }

   
/**
     * Test the each method
     *
     * @return null
     */
   
public function testEach()
    {
       
$str = "";
       
self::$_col->each(function($e) use (&$str) {
           
$str .= $e;
        });
       
$this->assertEquals("zeroonetwo", $str);
    }

   
/**
     * Test the each method, with key
     *
     * @return null
     */
   
public function testEachWithKey()
    {
       
$str = "";
       
self::$_col->each(function($key, $val) use (&$str) {
           
$str .= "$key$val";
        });
       
$this->assertEquals("0zero1one2two", $str);
    }

   
/**
     * Test if an element is inside the collection
     *
     * @return null
     */
   
public function testInclude()
    {
       
$this->assertTrue(self::$_col->includes("one"));
       
$this->assertFalse(self::$_col->includes("three"));
    }

   
/**
     * Test the collection sorting
     *
     * @return null
     */
   
public function testSort()
    {
       
$sorted = self::$_col->sort();
       
$this->assertEquals("one", $sorted[0]);
       
$this->assertEquals("two", $sorted[1]);
       
$this->assertEquals("zero", $sorted[2]);
    }

   
/**
     * Test chainable sort
     *
     * @return null
     */
   
public function testSortChain()
    {
       
$selected = self::$_col->sort()->select(function($e) { return strlen($e) <= 3; });;
       
$this->assertEquals(2, sizeof($selected->values()));
       
$this->assertEquals("one", $selected[0]);
       
$this->assertEquals("two", $selected[1]);
    }

   
/**
     * Test minimum value
     *
     * @return null
     */
   
public function testMin()
    {
       
$this->assertEquals("one", self::$_col->min());
    }

   
/**
     * Test maximum value
     *
     * @return null
     */
   
public function testMax()
    {
       
$this->assertEquals("zero", self::$_col->max());
    }

   
/**
     * Test selected elements
     *
     * @return null
     */
   
public function testSelect()
    {
       
$selected = self::$_col->select(function($e) {
            return
strlen($e) > 3;
        });
       
$this->assertEquals(1, sizeof($selected->values()));
       
$this->assertEquals("zero", $selected[0]);
    }

   
/**
     * Test selected elements, ordered
     *
     * @return null
     */
   
public function testSelectOrdered()
    {
       
$selected = self::$_col->select(function($e) {
            return
strlen($e) <= 3;
        });
       
$this->assertEquals(2, sizeof($selected->values()));
       
$this->assertEquals("one", $selected[0]);
       
$this->assertEquals("two", $selected[1]);
    }

   
/**
     * Test chainable select
     *
     * @return null
     */
   
public function testSelectChain()
    {
       
$sorted = self::$_col->select(function($e) {
            return
strlen($e) <= 3;
        })->
sort();
       
$this->assertEquals(2, sizeof($sorted->values()));
       
$this->assertEquals("one", $sorted[0]);
       
$this->assertEquals("two", $sorted[1]);
    }

   
/**
     * Test rejected elements
     *
     * @return null
     */
   
public function testReject()
    {
       
$rejected = self::$_col->reject(function($e) {
            return
strlen($e) > 3;
        });
       
$this->assertEquals(2, sizeof($rejected->values()));
       
$this->assertEquals("one", $rejected[0]);
       
$this->assertEquals("two", $rejected[1]);
    }

   
/**
     * Test chainable reject
     *
     * @return null
     */
   
public function testRejectChain()
    {
       
$rst = self::$_col->reject(function($e) {
            return
strlen($e) <= 3;
        })->
map(function($e) {
            return
strrev($e);
        });
       
$this->assertEquals(1, sizeof($rst->values()));
       
$this->assertEquals("orez", $rst[0]);
    }

   
/**
     * Test changing elements
     *
     * @return null
     */
   
public function testMap()
    {
       
$changed = self::$_col->map(function($e) {
            return
strrev($e);
        });
       
$this->assertEquals(3, sizeof($changed->values()));
       
$this->assertEquals("orez", $changed[0]);
       
$this->assertEquals("eno", $changed[1]);
       
$this->assertEquals("owt", $changed[2]);
    }

   
/**
     * Test chainable map
     *
     * @return null
     */
   
public function testMapChain()
    {
       
$changed = self::$_col->map(function($e) {
            return
strrev($e);
        })->
select(function($e) { return strlen($e) <= 3; });
       
$this->assertEquals(2, sizeof($changed->values()));
       
$this->assertEquals("eno", $changed[0]);
       
$this->assertEquals("owt", $changed[1]);
    }

   
/**
     * Test if all elements satisfy a condition
     *
     * @return null
     */
   
public function testAll()
    {
       
$this->assertTrue(self::$_col->all(function($e) { return strlen($e) > 2; }));
       
$this->assertFalse(self::$_col->all(function($e) { return strlen($e) > 3; }));
    }

   
/**
     * Test if any elements satisfy a condition
     *
     * @return null
     */
   
public function testAny()
    {
       
$this->assertTrue(self::$_col->any(function($e) { return strlen($e) > 3; }));
       
$this->assertFalse(self::$_col->any(function($e) { return strlen($e) > 4; }));
    }

   
/**
     * Test partition
     *
     * @return null
     */
   
public function testPartition()
    {
       
$part = self::$_col->partition(function($e) {
            return
strlen($e) > 3;
        });
       
$this->assertEquals(2, sizeof($part));

       
$pos = $part[0];
       
$neg = $part[1];

       
$this->assertEquals(1, sizeof($pos->values()));
       
$this->assertEquals("zero", $pos[0]);

       
$this->assertEquals(2, sizeof($neg->values()));
       
$this->assertEquals("one", $neg[0]);
       
$this->assertEquals("two", $neg[1]);
    }

   
/**
     * Test associative partition
     *
     * @return null
     */
   
public function testPartitionAssoc()
    {
       
$ass = new PHPR\Collection(["1" => "one", "2" => "two", "3" => "three"]);
       
$part = $ass->partition(function($e) {
            return
strlen($e) > 3;
        });
       
$this->assertEquals(2, sizeof($part));

       
$pos = $part[0];
       
$neg = $part[1];

       
$this->assertEquals(1, sizeof($pos->values()));
       
$this->assertEquals("3", array_keys($pos->values())[0]);
       
$this->assertEquals("three", array_values($pos->values())[0]);

       
$this->assertEquals(2, sizeof($neg->values()));
       
$this->assertEquals("1", array_keys($neg->values())[0]);
       
$this->assertEquals("2", array_keys($neg->values())[1]);

       
$this->assertEquals("one", array_values($neg->values())[0]);
       
$this->assertEquals("two", array_values($neg->values())[1]);
    }

   
/**
     * Test inject
     *
     * @return null
     */
   
public function testInject()
    {
       
$col = new PHPR\Collection([1, 2, 3, 4, 5]);
       
$this->assertEquals(15, $col->inject(function($memo, $value) { return $memo + $value; }));
    }

   
/**
     * Test inject with start value
     *
     * @return null
     */
   
public function testInjectStart()
    {
       
$col = new PHPR\Collection([1, 2, 3, 4, 5]);
       
$this->assertEquals(25, $col->inject(function($memo, $value) { return $memo + $value; }, 10));
    }

   
/**
     * Test if found when searching for a valid element
     *
     * @return null
     */
   
public function testFound()
    {
       
$found = self::$_col->find(function($e) { return strlen($e) <= 3; });
       
$this->assertEquals("one", $found);
    }

   
/**
     * Test if not found when searching for a invalid element
     *
     * @return null
     */
   
public function testNotFound()
    {
       
$found = self::$_col->find(function($e) { return strlen($e) > 5; });
       
$this->assertNull($found);
    }

   
/**
     * Test group by method
     *
     * @return null
     */
   
public function testGroupBy()
    {
       
$grouped = self::$_col->groupBy(function($e) { return strlen($e); });

       
$keys = array_keys($grouped->values());
       
sort($keys);

       
$this->assertEquals(2, sizeof($keys));
       
$this->assertEquals(3, $keys[0]);
       
$this->assertEquals(4, $keys[1]);

       
$this->assertEquals(2, sizeof($grouped->values()));
       
$this->assertEquals("one", $grouped[3][0]);
       
$this->assertEquals("two", $grouped[3][1]);
       
$this->assertEquals("zero", $grouped[4][0]);
    }

   
/**
     * Test null index
     *
     * @return null
     */
   
public function testNullIndex()
    {
       
$this->assertNull(self::$_col[10]);
    }
}