| /vendor/fusonic/linq/tests/Fusonic/Linq/Test/LinqTest.php |
|---|
| @@ -0,0 +1,1962 @@ |
|---|
| <?php |
| /** Copyright (C) Fusonic GmbH (http://www.fusonic.net) 2013, All rights reserved. */ |
| |
| use Fusonic\Linq\Linq; |
| |
| /** |
| * Interface for test purposes only. |
| */ |
| interface StubInterface |
| { |
| } |
| |
| /** |
| * Class for test purposes only. |
| */ |
| final class Stub |
| implements |
| StubInterface |
| { |
| } |
| |
| /** |
| * Class for test purposes only. |
| */ |
| final class StubWithoutInterface |
| { |
| } |
| |
| class LinqTest extends PHPUnit_Framework_TestCase |
| { |
| const ExceptionName_UnexpectedValue = "UnexpectedValueException"; |
| const ExceptionName_InvalidArgument = "InvalidArgumentException"; |
| const ExceptionName_OutOfRange = "OutOfRangeException"; |
| const ExceptionName_Runtime = "RuntimeException"; |
| |
| /** Returns the only element of a sequence that satisfies a specified condition, and throws an exception if more than one such element exists. |
| */ |
| public function testSingle_TestBehaviour() |
| { |
| // more than one |
| $items = array(1, 2); |
| $this->assertException(function() use ($items) { |
| Linq::from($items)->single(); |
| }); |
| |
| // no matching elements |
| $items = array(); |
| $this->assertException(function() use ($items) { |
| Linq::from($items)->single(); |
| }); |
| |
| // OK |
| $items = array(77); |
| $this->assertSame(77, Linq::from($items)->single()); |
| |
| // With closure |
| |
| // more than one |
| $items = array(1, 2); |
| $this->assertException(function() use ($items) { |
| Linq::from($items)->single(function($x) { return true; }); |
| }); |
| |
| // no matching elements |
| // because of false closure |
| $this->assertException(function() use ($items) { |
| Linq::from($items)->single(function($x) { return false; }); |
| }); |
| |
| // because of empty array |
| $items = array(); |
| $this->assertException(function() use ($items) { |
| Linq::from($items)->single(function($x) { return true; }); |
| }); |
| |
| // OK |
| $items = array(77); |
| $this->assertSame(77, Linq::from($items)->single(function($x) { return true; })); |
| } |
| |
| public function testCount_ReturnsCorrectAmounts() |
| { |
| $items = array(1, 2); |
| $this->assertEquals(2, Linq::from($items)->count()); |
| |
| $items = array(1, 2); |
| $this->assertEquals(1, Linq::from($items)->where(function($x) { |
| return $x == 2; |
| })->count()); |
| |
| $items = array(1, 2); |
| $this->assertEquals(0, Linq::from($items)->where(function($x) { |
| return false; |
| })->count()); |
| |
| $items = array(); |
| $this->assertEquals(0, Linq::from($items)->count()); |
| } |
| |
| /** Returns the only element of a sequence that satisfies a specified condition or a default value if no such element exists; |
| * this method throws an exception if more than one element satisfies the condition. |
| */ |
| public function testSingleOrNull_TestBehaviour() |
| { |
| // more than one |
| $items = array(1, 2); |
| $this->assertException(function() use ($items) { |
| Linq::from($items)->singleOrNull(); |
| }); |
| |
| // no matching elements |
| $items = array(); |
| $this->assertNull(Linq::from($items)->singleOrNull()); |
| |
| // OK |
| $items = array(77); |
| $this->assertSame(77, Linq::from($items)->singleOrNull()); |
| |
| // With closure |
| |
| // more than one |
| $items = array(1, 2); |
| $this->assertException(function() use ($items) { |
| Linq::from($items)->singleOrNull(function($x) { return true; }); |
| }); |
| |
| // no matching elements |
| // because of false closure |
| $this->assertNull(Linq::from($items)->singleOrNull(function($x) { return false; })); |
| |
| // because of empty array |
| $items = array(); |
| $this->assertNull(Linq::from($items)->singleOrNull()); |
| |
| // OK |
| $items = array(77); |
| $this->assertSame(77, Linq::from($items)->singleOrNull(function($x) { return true; })); |
| } |
| |
| /** Returns the first element in a sequence that satisfies a specified condition. |
| * |
| * Exceptions: |
| * No element satisfies the condition in predicate. |
| -or- |
| The source sequence is empty. |
| */ |
| public function testFirst_TestBehaviour() |
| { |
| $a = new stdClass(); |
| $a->value = "a"; |
| |
| $b1 = new stdClass(); |
| $b1->value = "b"; |
| |
| $b2 = new stdClass(); |
| $b2->value = "b"; |
| |
| $c = new stdClass(); |
| $c->value = "c"; |
| |
| // more than one |
| $items = array($a, $b1, $b2, $c); |
| $this->assertSame($a, Linq::from($items)->first()); |
| |
| // no matching elements |
| $items = array(); |
| $this->assertException(function() use ($items) { |
| Linq::from($items)->first(); |
| }); |
| |
| $items = array($a); |
| $this->assertSame($a, Linq::from($items)->first()); |
| |
| // #### With closures ### |
| |
| // more than one |
| $items = array($a, $b1, $b2, $c); |
| $this->assertSame($b1, Linq::from($items)->first(function($x) { return $x->value == "b"; })); |
| |
| // no matching elements |
| // because of false closure |
| $this->assertException(function() use ($items) { |
| Linq::from($items)->first(function($x) { return false; }); |
| }); |
| |
| // because of empty array |
| $items = array(); |
| $this->assertException(function() use ($items) { |
| Linq::from($items)->first(function($x) { return true; }); |
| }); |
| |
| // OK |
| $items = array($a); |
| $this->assertSame($a, Linq::from($items)->first(function($x) { return true; })); |
| } |
| |
| /** |
| * Returns the first element of a sequence, or a default value if the sequence contains no elements. |
| */ |
| public function testFirstOrNull_DoesReturnTheFirstElement_OrNull_DoesNotThrowExceptions() |
| { |
| $a = new stdClass(); |
| $a->value = "a"; |
| |
| $b1 = new stdClass(); |
| $b1->value = "b"; |
| |
| $b2 = new stdClass(); |
| $b2->value = "b"; |
| |
| $c = new stdClass(); |
| $c->value = "c"; |
| |
| $items = array($a, $b1, $b2, $c); |
| $this->assertSame($a, Linq::from($items)->firstOrNull()); |
| |
| $items = array(); |
| $this->assertNull(Linq::from($items)->firstOrNull()); |
| |
| // #### With closures ### |
| |
| $items = array($a, $b1, $b2, $c); |
| $this->assertSame($b1, Linq::from($items)->firstOrNull(function($x) { return $x->value == "b"; })); |
| |
| $items = array($a, $b1, $b2, $c); |
| $this->assertSame($c, Linq::from($items)->firstOrNull(function($x) { return $x->value == "c"; })); |
| |
| $items = array(); |
| $this->assertNull(Linq::from($items)->firstOrNull(function($x) { return true; })); |
| } |
| |
| |
| public function testLast_DoesReturnTheLastElement_OrThrowsExceptions() |
| { |
| $a = new stdClass(); |
| $a->value = "a"; |
| |
| $b1 = new stdClass(); |
| $b1->value = "b"; |
| |
| $b2 = new stdClass(); |
| $b2->value = "b"; |
| |
| $c = new stdClass(); |
| $c->value = "c"; |
| |
| // more than one |
| $items = array($a, $b1, $b2, $c); |
| $last = Linq::from($items)->last(); |
| $this->assertSame($c, $last); |
| |
| // no matching elements |
| $items = array(); |
| $this->assertException(function() use ($items) { |
| Linq::from($items)->last(); |
| }); |
| |
| $items = array($a); |
| $this->assertSame($a, Linq::from($items)->last()); |
| |
| // #### With closures ### |
| |
| // more than one |
| $items = array($a, $b1, $b2, $c); |
| $this->assertSame($b2, Linq::from($items)->last(function($x) { return $x->value == "b"; })); |
| |
| // no matching elements |
| // because of false closure |
| $this->assertException(function() use ($items) { |
| Linq::from($items)->last(function($x) { return false; }); |
| }); |
| |
| // because of empty array |
| $items = array(); |
| $this->assertException(function() use ($items) { |
| Linq::from($items)->last(function($x) { return true; }); |
| }); |
| |
| // OK |
| $items = array($a); |
| $this->assertSame($a, Linq::from($items)->last(function($x) { return true; })); |
| } |
| |
| public function testLastOrDefault_DoesReturnTheLastElement_OrNull_DoesNotThrowExceptions() |
| { |
| $a = new stdClass(); |
| $a->value = "a"; |
| |
| $b1 = new stdClass(); |
| $b1->value = "b"; |
| |
| $b2 = new stdClass(); |
| $b2->value = "b"; |
| |
| $c = new stdClass(); |
| $c->value = "c"; |
| |
| $items = array($a, $b1, $b2, $c); |
| $this->assertSame($c, Linq::from($items)->lastOrNull()); |
| |
| $items = array(); |
| $this->assertNull(Linq::from($items)->lastOrNull()); |
| |
| // #### With closures ### |
| |
| $items = array($a, $b1, $b2, $c); |
| $this->assertSame($c, Linq::from($items)->lastOrNull(function($x) { return true; })); |
| |
| $items = array($a, $b1, $b2, $c); |
| $this->assertSame($b2, Linq::from($items)->lastOrNull(function($x) { return $x->value == "b"; })); |
| |
| $items = array(); |
| $this->assertNull(Linq::from($items)->lastOrNull(function($x) { return true; })); |
| } |
| |
| public function testWhere_ReturnsOnlyValuesMatching() |
| { |
| $a = new stdClass(); |
| $a->value = "a"; |
| |
| $b1 = new stdClass(); |
| $b1->value = "b"; |
| |
| $b2 = new stdClass(); |
| $b2->value = "b"; |
| |
| $c = new stdClass(); |
| $c->value = "c"; |
| |
| $items = array($a, $b1, $b2, $c); |
| $matching = Linq::from($items)->where(function ($v) { return false; }); |
| $this->assertTrue($matching instanceof Linq); |
| |
| $matching = $matching->toArray(); |
| |
| $this->assertEquals(0, count($matching)); |
| |
| $matching = Linq::from($items)->where(function ($v) { return true; })->toArray(); |
| $this->assertEquals(4, count($matching)); |
| $this->assertTrue(in_array($a, (array)$matching)); |
| $this->assertTrue(in_array($b1, (array)$matching)); |
| $this->assertTrue(in_array($b2, (array)$matching)); |
| $this->assertTrue(in_array($c, (array)$matching)); |
| |
| $matching = Linq::from($items)->where(function ($v) { return $v->value == "b"; })->toArray(); |
| $this->assertEquals(2, count($matching)); |
| $this->assertFalse(in_array($a, (array)$matching)); |
| $this->assertTrue(in_array($b1, (array)$matching)); |
| $this->assertTrue(in_array($b2, (array)$matching)); |
| $this->assertFalse(in_array($c, (array)$matching)); |
| } |
| |
| public function testWhere_ThrowsExceptionIfPredicateDoesNotReturnABoolean() |
| { |
| $this->assertException(function() |
| { |
| $items = array("1", "2", "3"); |
| $matching = Linq::from($items)->where(function ($v) { return "NOT A BOOLEAN"; }); |
| $matching->toArray(); |
| }, self::ExceptionName_UnexpectedValue); |
| } |
| |
| public function testWhere_DoesLazyEvaluation() |
| { |
| $eval = false; |
| $items = array("1", "2", "3"); |
| $matching = Linq::from($items)->where(function ($v) use(&$eval) |
| { |
| $eval = true; |
| return true; |
| }); |
| |
| $this->assertFalse($eval, "SelectMany did execute before iterating!"); |
| $matching->toArray(); |
| $this->assertTrue($eval); |
| } |
| |
| public function testWhere_EmptySequence_ReturnsEmptySequence() |
| { |
| $items = array(); |
| $matching = Linq::from($items)->where(function ($v) |
| { |
| return true; |
| }); |
| |
| $this->assertEquals(0, $matching->count()); |
| $array = $matching->toArray(); |
| $this->assertEquals(0, count($array)); |
| } |
| |
| public function testCountable_implementedSqlInterface() |
| { |
| $items = array(1,2,3); |
| |
| $matching = Linq::from($items); |
| |
| $this->assertEquals(3, count($matching)); |
| $this->assertEquals(3, $matching->count()); |
| } |
| |
| public function testSkipWithTake_Combined_SkipAndTakeValuesByAmount() |
| { |
| $items = array("a", "b", "c", "d", "e", "f"); |
| $matching = Linq::from($items)->skip(2)->take(0); |
| $this->assertEquals(0, $matching->count()); |
| |
| $matching = Linq::from($items)->skip(0)->take(0); |
| $this->assertEquals(0, $matching->count()); |
| |
| $matching = Linq::from($items)->skip(0)->take(2); |
| $this->assertEquals(2, $matching->count()); |
| $array = $matching->toArray(); |
| $this->assertEquals("a", $array[0]); |
| $this->assertEquals("b", $array[1]); |
| |
| $matching = Linq::from($items)->skip(2)->take(2); |
| $this->assertEquals(2, $matching->count()); |
| $array = $matching->toArray(); |
| $this->assertEquals("c", $array[0]); |
| $this->assertEquals("d", $array[1]); |
| |
| $matching = Linq::from($items)->skip(4)->take(99); |
| $this->assertEquals(2, $matching->count()); |
| $array = $matching->toArray(); |
| $this->assertEquals("e", $array[0]); |
| $this->assertEquals("f", $array[1]); |
| } |
| |
| public function testTakeSkip_Combined_TakeAndSkipValuesByAmount() |
| { |
| $items = array("a", "b", "c", "d", "e", "f"); |
| $matching = Linq::from($items)->take(0)->skip(0); |
| $this->assertEquals(0, $matching->count()); |
| |
| $matching = Linq::from($items)->take(2)->skip(2); |
| $this->assertEquals(0, $matching->count()); |
| |
| $matching = Linq::from($items)->take(2)->skip(0); |
| $this->assertEquals(2, $matching->count()); |
| $array = $matching->toArray(); |
| $this->assertEquals("a", $array[0]); |
| $this->assertEquals("b", $array[1]); |
| } |
| |
| public function testSkip_SkipValuesByAmount() |
| { |
| $items = array("a", "b", "c", "d", "e", "f"); |
| $matching = Linq::from($items)->skip(2); |
| $this->assertTrue($matching instanceof Linq); |
| |
| $this->assertEquals(4, $matching->count()); |
| $matching = $matching->toArray(); |
| |
| $this->assertTrue(in_array("c", $matching)); |
| $this->assertTrue(in_array("d", $matching)); |
| $this->assertTrue(in_array("e", $matching)); |
| $this->assertTrue(in_array("f", $matching)); |
| |
| $items = array("a", "b", "c", "d", "e", "f"); |
| |
| $matching = Linq::from($items)->skip(0); |
| $this->assertEquals(6, $matching->count()); |
| $array = $matching->toArray(); |
| $this->assertEquals("a", $array[0]); |
| $this->assertEquals("b", $array[1]); |
| $this->assertEquals("c", $array[2]); |
| $this->assertEquals("d", $array[3]); |
| $this->assertEquals("e", $array[4]); |
| $this->assertEquals("f", $array[5]); |
| |
| $matching = Linq::from($items)->skip(5); |
| $this->assertEquals(1, $matching->count()); |
| $array = $matching->toArray(); |
| $this->assertEquals("f", $array[0]); |
| |
| $matching = Linq::from($items)->skip(6); |
| $this->assertEquals(0, $matching->count()); |
| |
| $matching = Linq::from($items)->skip(7); |
| $this->assertEquals(0, $matching->count()); |
| |
| // Test against empty sequence: |
| |
| $matching = Linq::from(array())->skip(0); |
| $this->assertEquals(0, $matching->count()); |
| |
| $matching = Linq::from(array())->skip(6); |
| $this->assertEquals(0, $matching->count()); |
| } |
| |
| public function testTake_TakeValuesByAmount() |
| { |
| $items = array("a", "b", "c", "d", "e", "f"); |
| $matching = Linq::from($items)->take(4); |
| $this->assertTrue($matching instanceof Linq); |
| |
| $this->assertEquals(4, $matching->count()); |
| $matching = $matching->toArray(); |
| $this->assertTrue(in_array("a", $matching)); |
| $this->assertTrue(in_array("b", $matching)); |
| $this->assertTrue(in_array("c", $matching)); |
| $this->assertTrue(in_array("d", $matching)); |
| |
| $matching = Linq::from($items)->take(0); |
| $this->assertEquals(0, $matching->count()); |
| } |
| |
| public function testAll_WorksCorrectly() |
| { |
| // All must always return true on empty sequences: |
| $items = array(); |
| $all = Linq::from($items)->all(function($v) { return true; }); |
| $this->assertTrue($all); |
| |
| $all = Linq::from($items)->all(function($v) { return false; }); |
| $this->assertTrue($all); |
| |
| // Test with values: |
| $items = array("a", "b"); |
| $all = Linq::from($items)->all(function($v) { return $v == "a"; }); |
| $this->assertFalse($all); |
| |
| $all = Linq::from($items)->all(function($v) { return $v == "a" || $v == "b"; }); |
| $this->assertTrue($all); |
| } |
| |
| public function testAny_WithFunc_CorrectResults() |
| { |
| // Any must always return false on empty sequences: |
| $items = array(); |
| $any = Linq::from($items)->any(function($v) { return true; }); |
| $this->assertFalse($any); |
| |
| $any = Linq::from($items)->any(function($v) { return false; }); |
| $this->assertFalse($any); |
| |
| // Test with values: |
| $items = array("a", "b"); |
| $any = Linq::from($items)->any(function($v) { return $v == "not existing"; }); |
| $this->assertFalse($any); |
| |
| $any = Linq::from($items)->any(function($v) { return $v == "a"; }); |
| $this->assertTrue($any); |
| } |
| |
| public function testAny_WithoutFunc_CorrectResults() |
| { |
| $items = array(); |
| $this->assertFalse(Linq::from($items)->any()); |
| |
| $items = array("a"); |
| $this->assertTrue(Linq::from($items)->any()); |
| |
| $items = array("a", "b", "c"); |
| $this->assertTrue(Linq::from($items)->any()); |
| } |
| |
| public function testAverage_throwsExceptionIfClosureReturnsNotNumericValue() |
| { |
| $this->assertException(function() { |
| $items = array(2, new stdClass()); |
| Linq::from($items)->average(); |
| }, self::ExceptionName_UnexpectedValue); |
| |
| $this->assertException(function() { |
| $items = array(2, "no numeric value"); |
| Linq::from($items)->average(); |
| }, self::ExceptionName_UnexpectedValue); |
| |
| $this->assertException(function() { |
| $cls = new stdClass(); |
| $cls->value = "no numeric value"; |
| $items = array($cls); |
| Linq::from($items)->average(function($x) { return $x->value; }); |
| }, self::ExceptionName_UnexpectedValue); |
| } |
| |
| public function testAverage_CalculatesCorrectAverage() |
| { |
| $items = array(2, 4, 6); |
| $avg = Linq::from($items)->average(); |
| $this->assertEquals(4, $avg); |
| |
| $items = array(2.5, 2.5); |
| $avg = Linq::from($items)->average(); |
| $this->assertEquals(2.5, $avg); |
| |
| $items = array(2, "4", "6"); |
| $avg = Linq::from($items)->average(); |
| $this->assertEquals(4, $avg); |
| |
| $items = array(2, 4, 6); |
| $avg = Linq::from($items)->average(function($v) { return 1; }); |
| $this->assertEquals(1, $avg); |
| |
| $items = array(2.5, 2.5); |
| $avg = Linq::from($items)->average(function($v) { return $v; }); |
| $this->assertEquals(2.5, $avg); |
| |
| $a = new stdClass(); |
| $a->value = 2; |
| |
| $b = new stdClass(); |
| $b->value = "4"; |
| |
| $c = new stdClass(); |
| $c->value = "6"; |
| |
| $items = array($a, $b, $c); |
| $avg = Linq::from($items)->average(function($v) { return $v->value; }); |
| $this->assertEquals(4, $avg); |
| } |
| |
| public function testOrderBy_NumericValues_WithSelector_ReturnsOrderedObjects() |
| { |
| $a = new stdClass(); $a->value = 77; |
| $b = new stdClass(); $b->value = 10; |
| $c = new stdClass(); $c->value = 20; |
| $items = array($a, $b, $c); |
| |
| $ascending = Linq::from($items)->orderBy(function($x) |
| { |
| return $x->value; |
| }); |
| $this->assertEquals(3, $ascending->count()); |
| $items = $ascending->toArray(); |
| |
| $this->assertSame($b, $items[0]); |
| $this->assertSame($c, $items[1]); |
| $this->assertSame($a, $items[2]); |
| |
| $a = new stdClass(); $a->value = 77; |
| $b = new stdClass(); $b->value = 10.44; |
| $c = new stdClass(); $c->value = 20; |
| $d = new stdClass(); $d->value = 20; |
| $items = array($a, $b, $c, $d); |
| |
| $ascending = Linq::from($items)->orderBy(function($x) { return $x->value; }); |
| $this->assertEquals(4, $ascending->count()); |
| $items = $ascending->toArray(); |
| |
| $this->assertSame($b, $items[0]); |
| |
| // It is not predictable in which order objects with the same order key are ordered, both positions are valid: |
| $pos1 = $items[1]; |
| $pos2 = $items[2]; |
| $this->assertTrue($pos1 === $d || $pos1 === $c); |
| $this->assertTrue($pos1 === $d || $pos1 === $c); |
| $this->assertNotsame($pos1, $pos2); |
| |
| $this->assertSame($a, $items[3]); |
| } |
| |
| public function testOrderBy_NumericValues_ReturnsCorrectOrders() |
| { |
| $items = array(77, 10, 20); |
| $ascending = Linq::from($items)->orderBy(function($x) { return $x; }); |
| $this->assertTrue($ascending instanceof Linq); |
| |
| $ascending = $ascending->toArray(); |
| |
| $this->assertEquals(10, $ascending[0]); |
| $this->assertEquals(20, $ascending[1]); |
| $this->assertEquals(77, $ascending[2]); |
| |
| // Verify that original collection is unmodified: |
| $this->assertEquals(77, $items[0]); |
| $this->assertEquals(10, $items[1]); |
| $this->assertEquals(20, $items[2]); |
| |
| $items = array(12.33, 8.21, 11.3, 8.21, 33); |
| $ascending = Linq::from($items)->orderBy(function($x) { return $x; }); |
| |
| $ascending = $ascending->toArray(); |
| $this->assertEquals(8.21, $ascending[0]); |
| $this->assertEquals(8.21, $ascending[1]); |
| $this->assertEquals(11.3, $ascending[2]); |
| $this->assertEquals(12.33, $ascending[3]); |
| $this->assertEquals(33, $ascending[4]); |
| } |
| |
| public function testOrderBy_StringValues_ReturnsCorrectOrders() |
| { |
| $items = array("e", "a", "c"); |
| $ascending = Linq::from($items)->orderBy(function($x) { return $x; }); |
| $this->assertTrue($ascending instanceof Linq); |
| |
| $ascending = $ascending->toArray(); |
| $this->assertEquals("a", $ascending[0]); |
| $this->assertEquals("c", $ascending[1]); |
| $this->assertEquals("e", $ascending[2]); |
| |
| // Verify that original collection is unmodified: |
| $this->assertEquals("e", $items[0]); |
| $this->assertEquals("a", $items[1]); |
| $this->assertEquals("c", $items[2]); |
| } |
| |
| public function testOrderBy_DateTimeValues_ReturnsCorrectOrders() |
| { |
| $items = array(new DateTime("27.10.2011"), new DateTime("03.04.2012"), new DateTime("01.01.2005")); |
| $ascending = Linq::from($items)->orderBy(function($x) { return $x; }); |
| $this->assertTrue($ascending instanceof Linq); |
| $ascending = $ascending->toArray(); |
| |
| $this->assertEquals(new DateTime("01.01.2005"), $ascending[0]); |
| $this->assertEquals(new DateTime("27.10.2011"), $ascending[1]); |
| $this->assertEquals(new DateTime("03.04.2012"), $ascending[2]); |
| |
| // Verify that original collection is unmodified: |
| $this->assertEquals(new DateTime("27.10.2011"), $items[0]); |
| $this->assertEquals(new DateTime("03.04.2012"), $items[1]); |
| $this->assertEquals(new DateTime("01.01.2005"), $items[2]); |
| } |
| |
| public function testOrderByDescending_NumericValues_ReturnsCorrectOrders() |
| { |
| $items = array(77, 10, 20); |
| $desc = Linq::from($items)->orderByDescending(function($x) { return $x; }); |
| $this->assertTrue($desc instanceof Linq); |
| $desc = $desc->toArray(); |
| |
| $this->assertEquals(77, $desc[0]); |
| $this->assertEquals(20, $desc[1]); |
| $this->assertEquals(10, $desc[2]); |
| |
| // Verify that original collection is unmodified: |
| $this->assertEquals(77, $items[0]); |
| $this->assertEquals(10, $items[1]); |
| $this->assertEquals(20, $items[2]); |
| |
| $items = array(12.33, 8.21, 11.3, 8.21, 33); |
| $desc = Linq::from($items)->orderByDescending(function($x) { return $x; }); |
| $desc = $desc->toArray(); |
| $this->assertEquals(33, $desc[0]); |
| $this->assertEquals(12.33, $desc[1]); |
| $this->assertEquals(11.3, $desc[2]); |
| $this->assertEquals(8.21, $desc[3]); |
| $this->assertEquals(8.21, $desc[4]); |
| } |
| |
| public function testOrderByDescending_NumericValues_WithSelector_ReturnsOrderedObjects() |
| { |
| $a = new stdClass(); $a->value = 77; |
| $b = new stdClass(); $b->value = 10; |
| $c = new stdClass(); $c->value = 20; |
| $items = array($a, $b, $c); |
| |
| $ascending = Linq::from($items)->orderByDescending(function($x) { return $x->value; }); |
| $this->assertEquals(3, $ascending->count()); |
| $items = $ascending->toArray(); |
| |
| $this->assertSame($a, $items[0]); |
| $this->assertSame($c, $items[1]); |
| $this->assertSame($b, $items[2]); |
| |
| $a = new stdClass(); $a->value = 77; |
| $b = new stdClass(); $b->value = 10.44; |
| $c = new stdClass(); $c->value = 20; |
| $d = new stdClass(); $d->value = 20; |
| $items = array($a, $b, $c, $d); |
| |
| $ascending = Linq::from($items)->orderByDescending(function($x) { return $x->value; }); |
| $this->assertEquals(4, $ascending->count()); |
| $items = $ascending->toArray(); |
| |
| $this->assertSame($a, $items[0]); |
| $this->assertSame($c, $items[1]); |
| |
| // It is not predictable in which order objects with the same order key are ordered, both positions are valid: |
| $pos1 = $items[2]; |
| $pos2 = $items[3]; |
| $this->assertTrue($pos1 === $d || $pos1 === $c); |
| $this->assertTrue($pos1 === $d || $pos1 === $c); |
| $this->assertNotsame($pos1, $pos2); |
| } |
| |
| public function testOrderByDescending_DateTimeValues_ReturnsCorrectOrders() |
| { |
| $items = array(new DateTime("27.10.2011"), new DateTime("03.04.2012"), new DateTime("01.01.2005")); |
| $desc = Linq::from($items)->orderByDescending(function($x) { return $x; }); |
| $this->assertTrue($desc instanceof Linq); |
| $desc = $desc->toArray(); |
| |
| $this->assertEquals(new DateTime("03.04.2012"), $desc[0]); |
| $this->assertEquals(new DateTime("27.10.2011"), $desc[1]); |
| $this->assertEquals(new DateTime("01.01.2005"), $desc[2]); |
| |
| // Verify that original collection is unmodified: |
| $this->assertEquals(new DateTime("27.10.2011"), $items[0]); |
| $this->assertEquals(new DateTime("03.04.2012"), $items[1]); |
| $this->assertEquals(new DateTime("01.01.2005"), $items[2]); |
| } |
| |
| public function testOrderBy_Descending_StringValues_ReturnsCorrectOrders() |
| { |
| $items = array("e", "a", "c"); |
| $desc = Linq::from($items)->orderByDescending(function($x) { return $x; }); |
| $this->assertTrue($desc instanceof Linq); |
| $desc = $desc->toArray(); |
| |
| $this->assertEquals("e", $desc[0]); |
| $this->assertEquals("c", $desc[1]); |
| $this->assertEquals("a", $desc[2]); |
| |
| // Verify that original collection is unmodified: |
| $this->assertEquals("e", $items[0]); |
| $this->assertEquals("a", $items[1]); |
| $this->assertEquals("c", $items[2]); |
| } |
| |
| public function testOrderBy_DoesMakeLazyEvalution() |
| { |
| $items = array("e", "a", "c"); |
| $eval = false; |
| $linq = Linq::from($items)->orderByDescending(function($x) use(&$eval) |
| { |
| $eval = true; |
| return $x; |
| }); |
| |
| $this->assertFalse($eval, "OrderBy did execute before iterating!"); |
| $result = $linq->toArray(); |
| $this->assertTrue($eval); |
| } |
| |
| public function testGroupBy() |
| { |
| $a1 = new stdClass(); $a1->id = 1; $a1->value = "a"; |
| $a2 = new stdClass(); $a2->id = 2; $a2->value = "a"; |
| $b1 = new stdClass(); $b1->id = 3; $b1->value = "b"; |
| |
| $items = array ($a1, $a2, $b1); |
| $grouped = Linq::from($items)->groupBy(function($x) { |
| return $x->value; |
| }); |
| |
| $this->assertTrue($grouped instanceof Linq); |
| |
| $this->assertEquals(2, $grouped->count()); |
| $aGroup = $grouped->elementAt(0); |
| $this->assertTrue($aGroup instanceof Fusonic\Linq\GroupedLinq); |
| |
| $this->assertEquals("a", $aGroup->key()); |
| $this->assertEquals(2, $aGroup->count()); |
| $this->assertSame($a1, $aGroup->elementAt(0)); |
| $this->assertSame($a2, $aGroup->elementAt(1)); |
| |
| $bGroup = $grouped->elementAt(1); |
| $this->assertEquals("b", $bGroup->key()); |
| $this->assertEquals(1, $bGroup->count()); |
| $this->assertSame($b1, $bGroup->elementAt(0)); |
| } |
| |
| public function testElementAt_ReturnsElementAtPositionOrThrowsException() |
| { |
| $items = array ("a", "b", "c"); |
| $this->assertEquals("a", Linq::from($items)->elementAt(0)); |
| $this->assertEquals("b", Linq::from($items)->elementAt(1)); |
| $this->assertEquals("c", Linq::from($items)->elementAt(2)); |
| |
| $items = array("a" => "aValue", "b" => "bValue"); |
| $this->assertEquals("aValue", Linq::from($items)->elementAt(0)); |
| $this->assertEquals("bValue", Linq::from($items)->elementAt(1)); |
| |
| $this->assertException(function() { |
| $items = array(); |
| Linq::from($items)->elementAt(0); |
| }, self::ExceptionName_OutOfRange); |
| |
| $this->assertException(function() { |
| $items = array(); |
| Linq::from($items)->elementAt(1); |
| }, self::ExceptionName_OutOfRange); |
| |
| $this->assertException(function() { |
| $items = array(); |
| Linq::from($items)->elementAt(-1); |
| }, self::ExceptionName_OutOfRange); |
| |
| $this->assertException(function() { |
| $items = array("a"); |
| Linq::from($items)->elementAt(1); |
| }, self::ExceptionName_OutOfRange); |
| |
| $this->assertException(function() { |
| $items = array("a", "b"); |
| Linq::from($items)->elementAt(2); |
| }, self::ExceptionName_OutOfRange); |
| |
| $this->assertException(function() { |
| $items = array("a", "b"); |
| Linq::from($items)->elementAt(-1); |
| }, self::ExceptionName_OutOfRange); |
| |
| $this->assertException(function() { |
| $items = array("a" => "value", "b" => "bValue"); |
| Linq::from($items)->elementAt(2); |
| }, self::ExceptionName_OutOfRange); |
| } |
| |
| public function testElementAtOrNull_ReturnsElementAtPositionOrNull() |
| { |
| $items = array ("a", "b", "c"); |
| $this->assertEquals("a", Linq::from($items)->elementAtOrNull(0)); |
| $this->assertEquals("b", Linq::from($items)->elementAtOrNull(1)); |
| $this->assertEquals("c", Linq::from($items)->elementAtOrNull(2)); |
| |
| $this->assertNull(Linq::from($items)->elementAtOrNull(3)); |
| $this->assertNull(Linq::from($items)->elementAtOrNull(4)); |
| $this->assertNull(Linq::from($items)->elementAtOrNull(-1)); |
| |
| $items = array(); |
| $this->assertNull(Linq::from($items)->elementAtOrNull(3)); |
| $this->assertNull(Linq::from($items)->elementAtOrNull(4)); |
| $this->assertNull(Linq::from($items)->elementAtOrNull(-1)); |
| |
| $items = array("a" => "value", "b" => "bValue"); |
| $this->assertEquals("value", Linq::from($items)->elementAtOrNull(0)); |
| $this->assertNull(Linq::from($items)->elementAtOrNull(2)); |
| } |
| |
| public function testSelect_ReturnsProjectedSequence() |
| { |
| $a1 = new stdClass(); $a1->value = "a1"; |
| $a2 = new stdClass(); $a2->value = "a2"; |
| $a3 = new stdClass(); $a3->value = "a3"; |
| $a4 = new stdClass(); $a4->value = "a4"; |
| |
| // more than one |
| $items = array($a1, $a2, $a3, $a4); |
| |
| $projected = Linq::from($items)->select(function($v){ |
| return $v->value; |
| }); |
| |
| $this->assertTrue($projected instanceof Linq); |
| $this->assertEquals(4, $projected->count()); |
| |
| $projected = $projected->toArray(); |
| $this->assertEquals("a1", $projected[0]); |
| $this->assertEquals("a2", $projected[1]); |
| $this->assertEquals("a3", $projected[2]); |
| $this->assertEquals("a4", $projected[3]); |
| |
| $items = array(); |
| |
| $projected = Linq::from($items)->select(function($v){ |
| return $v->value; |
| }); |
| |
| $this->assertEquals(0, $projected->count()); |
| } |
| |
| public function testSelectMany_throwsExceptionIfElementIsNotIterable() |
| { |
| $a1 = new stdClass(); $a1->value = "a1"; |
| $items = array($a1); |
| |
| $this->assertException(function() use($items) { |
| Linq::from($items)->selectMany(function($v) { |
| return $v->value; |
| })->toArray(); |
| |
| }, self::ExceptionName_UnexpectedValue); |
| |
| $this->assertException(function() use($items) { |
| Linq::from($items)->selectMany(function($v) { |
| return null; |
| })->toArray(); |
| }, self::ExceptionName_UnexpectedValue); |
| } |
| |
| public function testSelectMany_ReturnsFlattenedSequence() |
| { |
| $a1 = new stdClass(); $a1->value = array("a", "b"); |
| $a2 = new stdClass(); $a2->value = array("c", "d"); |
| $items = array($a1, $a2); |
| |
| $linq = Linq::from($items)->selectMany(function($x) |
| { |
| return $x->value; |
| }); |
| |
| $this->assertTrue($linq instanceof Linq); |
| |
| $this->assertEquals(4, $linq->count()); |
| |
| $array = $linq->toArray(); |
| $this->assertEquals("a", $array[0]); |
| $this->assertEquals("b", $array[1]); |
| $this->assertEquals("c", $array[2]); |
| $this->assertEquals("d", $array[3]); |
| |
| // Try once again to see if rewinding the iterator works: |
| $this->assertEquals(4, $linq->count()); |
| |
| $array = $linq->toArray(); |
| $this->assertEquals("a", $array[0]); |
| $this->assertEquals("b", $array[1]); |
| $this->assertEquals("c", $array[2]); |
| $this->assertEquals("d", $array[3]); |
| } |
| |
| public function testSelectMany_EmptySequence_ReturnsEmptySequence() |
| { |
| $linq = Linq::from(array())->selectMany(function($x) |
| { |
| return $x->value; |
| }); |
| |
| $this->assertEquals(0, $linq->count()); |
| $array = $linq->toArray(); |
| $this->assertEquals(0, count($array)); |
| |
| // Try once again to see if rewinding the iterator works: |
| $this->assertEquals(0, $linq->count()); |
| $array = $linq->toArray(); |
| $this->assertEquals(0, count($array)); |
| } |
| |
| public function testSelectMany_DoesLazyEvaluation() |
| { |
| $a1 = new stdClass(); $a1->value = array("a", "b"); |
| $a2 = new stdClass(); $a2->value = array("c", "d"); |
| $items = array($a1, $a2); |
| |
| $eval = false; |
| $flattened = Linq::from($items)->selectMany(function($x) use(&$eval) |
| { |
| $eval = true; |
| return $x->value; |
| }); |
| |
| $this->assertFalse($eval, "SelectMany did execute before iterating!"); |
| $result = $flattened->toArray(); |
| $this->assertTrue($eval); |
| } |
| |
| public function testConcat_ReturnsConcatenatedElements() |
| { |
| $first = array("a", "b"); |
| $second = array("c", "d"); |
| |
| $all = Linq::from($first)->concat($second); |
| $this->assertTrue($all instanceof Linq); |
| |
| $this->assertEquals(4, $all->count()); |
| |
| $all = $all->toArray(); |
| $this->assertEquals("a", $all[0]); |
| $this->assertEquals("b", $all[1]); |
| $this->assertEquals("c", $all[2]); |
| $this->assertEquals("d", $all[3]); |
| } |
| |
| public function testConcat_ThrowsArgumentExceptionIfNoTraversableArgument() |
| { |
| $this->assertException(function() { |
| $input = array(); |
| $linq = Linq::from($input); |
| $linq->concat(null); |
| },self::ExceptionName_InvalidArgument); |
| |
| $this->assertException(function() { |
| $input = array(); |
| $second = new stdClass(); |
| Linq::from($input)->concat($second); |
| },self::ExceptionName_InvalidArgument); |
| } |
| |
| public function testLinqFrom_WorksWith_Arrays_Iterators_And_IteratorAggregates() |
| { |
| $linq = Linq::from(array(1, 2)); |
| $linq = Linq::from($linq); |
| $linq = Linq::from($linq->getIterator()); |
| } |
| |
| public function testMethodsWithSequencesAsArguments_WorkWith_Arrays_Iterators_And_IteratorAggregates() |
| { |
| $first = Linq::from(array("a", "b")); |
| $secondArray = array("c", "d"); |
| $secondLinq = Linq::from(array("c", "d")); |
| $secondIterator = $secondLinq->getIterator(); |
| |
| $res = $first->concat($secondLinq)->toArray(); |
| $res = $first->intersect($secondLinq)->toArray(); |
| $res = $first->except($secondLinq)->toArray(); |
| |
| $res = $first->concat($secondArray)->toArray(); |
| $res = $first->intersect($secondArray)->toArray(); |
| $res = $first->except($secondArray)->toArray(); |
| |
| $res = $first->concat($secondIterator)->toArray(); |
| $res = $first->intersect($secondIterator)->toArray(); |
| $res = $first->except($secondIterator)->toArray(); |
| } |
| |
| public function testIntersect_ReturnsIntersectedElements() |
| { |
| $first = array("a", "b", "c", "d"); |
| $second = array("b", "c"); |
| |
| $linq = Linq::from($first)->intersect($second); |
| $this->assertEquals(2, $linq->count()); |
| |
| $array = $linq->toArray(); |
| $this->assertEquals("b", $array[0]); |
| $this->assertEquals("c", $array[1]); |
| } |
| |
| public function testIntersect_ThrowsArgumentExceptionIfSecondSequenceIsNotTraversable() |
| { |
| $this->assertException(function() { |
| $input = array(); |
| $linq = Linq::from($input); |
| $linq->intersect(null); |
| },self::ExceptionName_InvalidArgument); |
| |
| $this->assertException(function() { |
| $input = array(); |
| $linq = Linq::from($input); |
| $linq->intersect("Not a sequence"); |
| },self::ExceptionName_InvalidArgument); |
| } |
| |
| public function testIntersect_EmptySequence_ReturnsEmptySequence() |
| { |
| $first = array("a", "b", "c", "d"); |
| $second = array(); |
| |
| $linq = Linq::from($first)->intersect($second); |
| $this->assertEquals(0, $linq->count()); |
| $array = $linq->toArray(); |
| $this->assertEquals(0, count($array)); |
| } |
| |
| public function testExcept_ReturnsAllElementsExceptTheGivenOnes() |
| { |
| $first = array("a", "b", "c", "d"); |
| $second = array("b", "c"); |
| |
| $linq = Linq::from($first)->except($second); |
| $this->assertEquals(2, $linq->count()); |
| |
| $array = $linq->toArray(); |
| $this->assertEquals("a", $array[0]); |
| $this->assertEquals("d", $array[1]); |
| } |
| |
| public function testExcept_ThrowsArgumentExceptionIfSecondSequenceIsNotTraversable() |
| { |
| $this->assertException(function() { |
| $input = array(); |
| $linq = Linq::from($input); |
| $linq->except(null); |
| },self::ExceptionName_InvalidArgument); |
| |
| $this->assertException(function() { |
| $input = array(); |
| $linq = Linq::from($input); |
| $linq->except("Not a sequence"); |
| },self::ExceptionName_InvalidArgument); |
| } |
| |
| public function testExcept_EmptySequence_ReturnsAllElementsFromFirst() |
| { |
| $first = array("a", "b", "c", "d"); |
| $second = array(); |
| |
| $linq = Linq::from($first)->except($second); |
| $this->assertEquals(4, $linq->count()); |
| |
| $array = $linq->toArray(); |
| $this->assertEquals("a", $array[0]); |
| $this->assertEquals("b", $array[1]); |
| $this->assertEquals("c", $array[2]); |
| $this->assertEquals("d", $array[3]); |
| } |
| |
| public function testDistinct_ReturnsDistinctElements() |
| { |
| $items = array("a", "b", "a", "b"); |
| |
| $distinct = Linq::from($items)->distinct(); |
| $this->assertTrue($distinct instanceof Linq); |
| |
| $this->assertEquals(2, $distinct->count()); |
| $distinct = $distinct->toArray(); |
| $this->assertEquals("a", $distinct[0]); |
| $this->assertEquals("b", $distinct[1]); |
| |
| $a1 = new stdClass(); $a1->id = 1; $a1->value = "a"; |
| $a2 = new stdClass(); $a2->id = 2; $a2->value = "a"; |
| $b1 = new stdClass(); $b1->id = 3; $b1->value = "b"; |
| |
| $items = array($a1, $a2, $b1); |
| $distinct = Linq::from($items)->distinct(function($v) { return $v->value; }); |
| $this->assertEquals(2, $distinct->count()); |
| } |
| |
| public function testDistinct_DoesLazyEvaluation() |
| { |
| $eval = false; |
| $a1 = new stdClass(); $a1->id = 1; $a1->value = "a"; |
| $a2 = new stdClass(); $a2->id = 2; $a2->value = "a"; |
| |
| $items = array($a1, $a2); |
| $distinct = Linq::from($items)->distinct(function($v) use(&$eval) |
| { |
| $eval = true; |
| return $v->value; |
| }); |
| |
| $this->assertFalse($eval, "SelectMany did execute before iterating!"); |
| $distinct->toArray(); |
| $this->assertTrue($eval); |
| } |
| |
| public function testMin_ReturnsMinValueFromNumerics() |
| { |
| $items = array(88, 77, 12, 112); |
| $min = Linq::from($items)->min(); |
| $this->assertEquals(12, $min); |
| |
| $items = array(13); |
| $min = Linq::from($items)->min(); |
| $this->assertEquals(13, $min); |
| |
| $items = array(0); |
| $min = Linq::from($items)->min(); |
| $this->assertEquals(0, $min); |
| |
| $items = array(-12); |
| $min = Linq::from($items)->min(); |
| $this->assertEquals(-12, $min); |
| |
| $items = array(-12, 0, 100, -33); |
| $min = Linq::from($items)->min(); |
| $this->assertEquals(-33, $min); |
| } |
| |
| public function testMin_ReturnsMinValueFromStrings() |
| { |
| $items = array("c", "a", "b", "d"); |
| $min = Linq::from($items)->min(); |
| $this->assertEquals("a", $min); |
| |
| $items = array("a"); |
| $min = Linq::from($items)->min(); |
| $this->assertEquals("a", $min); |
| } |
| |
| public function testMin_ReturnsMinValueFromDateTimes() |
| { |
| $items = array( |
| new DateTime("2015-01-01 10:00:00"), |
| new DateTime("2015-02-01 10:00:00"), |
| new DateTime("2015-01-01 09:00:00"), |
| ); |
| $min = Linq::from($items)->min(); |
| $this->assertEquals($items[2], $min); |
| } |
| |
| public function testMin_ThrowsExceptionIfSequenceIsEmpty() |
| { |
| $this->assertException(function() |
| { |
| $data = array(); |
| $min = Linq::from($data)->min(); |
| }); |
| } |
| |
| public function testMin_ThrowsExceptionIfSequenceContainsNoneNumericValuesOrStrings() |
| { |
| $this->assertException(function() |
| { |
| $data = array(null); |
| $max = Linq::from($data)->min(); |
| }, self::ExceptionName_UnexpectedValue); |
| |
| $this->assertException(function() |
| { |
| $data = array(new stdClass()); |
| $min = Linq::from($data)->min(); |
| }, self::ExceptionName_UnexpectedValue); |
| |
| $this->assertException(function() |
| { |
| $data = array("string value", 1, new stdClass()); |
| $min = Linq::from($data)->min(); |
| }, self::ExceptionName_UnexpectedValue); |
| |
| $this->assertException(function() |
| { |
| $a = new stdClass(); $a->nonNumeric = new stdClass(); |
| $data = array($a); |
| $min = Linq::from($data)->min(function($x) |
| { |
| return $x->nonNumeric; |
| }); |
| }, self::ExceptionName_UnexpectedValue); |
| } |
| |
| public function testMax_ReturnsMaxValueFromNumerics() |
| { |
| $items = array(88, 77, 12, 112); |
| $max = Linq::from($items)->max(); |
| $this->assertEquals(112, $max); |
| |
| $items = array(13); |
| $max = Linq::from($items)->max(); |
| $this->assertEquals(13, $max); |
| |
| $items = array(0); |
| $max = Linq::from($items)->max(); |
| $this->assertEquals(0, $max); |
| |
| $items = array(-12); |
| $max = Linq::from($items)->max(); |
| $this->assertEquals(-12, $max); |
| |
| $items = array(-12, 0, 100, -33); |
| $max = Linq::from($items)->max(); |
| $this->assertEquals(100, $max); |
| } |
| |
| public function testMax_ReturnsMaxValueFromDateTimes() |
| { |
| $items = array( |
| new DateTime("2015-01-01 10:00:00"), |
| new DateTime("2015-02-01 10:00:00"), |
| new DateTime("2015-01-01 09:00:00"), |
| ); |
| $max = Linq::from($items)->max(); |
| $this->assertEquals($items[1], $max); |
| } |
| |
| public function testSum_ThrowsExceptionIfSequenceContainsNoneNumericValues() |
| { |
| $this->assertException(function() |
| { |
| $data = array(null); |
| $max = Linq::from($data)->sum(); |
| }, self::ExceptionName_UnexpectedValue); |
| |
| $this->assertException(function() |
| { |
| $data = array(new stdClass()); |
| $min = Linq::from($data)->sum(); |
| }, self::ExceptionName_UnexpectedValue); |
| |
| $this->assertException(function() |
| { |
| $data = array("string value", 1, new stdClass()); |
| $min = Linq::from($data)->sum(); |
| }, self::ExceptionName_UnexpectedValue); |
| |
| $this->assertException(function() |
| { |
| $a = new stdClass(); $a->value = 100; $a->nonNumeric = "asdf"; |
| $b = new stdClass(); $b-> value = 133; $a->nonNumeric = "asdf"; |
| |
| $data = array($a, $b); |
| $sum = Linq::from($data)->sum(function($x) { |
| return $x->nonNumeric; |
| }); |
| }, self::ExceptionName_UnexpectedValue); |
| } |
| |
| public function testSum_GetSumOfValues() |
| { |
| $data = array(); |
| $sum = Linq::from($data)->sum(); |
| $this->assertEquals(0, $sum); |
| |
| $data = array(4, 9, 100.77); |
| $sum = Linq::from($data)->sum(); |
| $this->assertEquals(113.77, $sum); |
| |
| $data = array(12, -12); |
| $sum = Linq::from($data)->sum(); |
| $this->assertEquals(0, $sum); |
| |
| $data = array(12, -24); |
| $sum = Linq::from($data)->sum(); |
| $this->assertEquals(-12, $sum); |
| |
| $a = new stdClass(); $a->value = 100; |
| $b = new stdClass(); $b-> value = 133; |
| |
| $data = array($a, $b); |
| $sum = Linq::from($data)->sum(function($x) { |
| return $x->value; |
| }); |
| |
| $this->assertEquals(233, $sum); |
| } |
| |
| public function testMax_ReturnsMaxValueFromStrings() |
| { |
| $items = array("c", "a", "b", "d"); |
| $max = Linq::from($items)->max(); |
| $this->assertEquals("d", $max); |
| |
| $items = array("a"); |
| $max = Linq::from($items)->max(); |
| $this->assertEquals("a", $max); |
| } |
| |
| public function testMax_ThrowsExceptionIfSequenceIsEmpty() |
| { |
| $this->assertException(function() |
| { |
| $data = array(); |
| $max = Linq::from($data)->max(); |
| }); |
| } |
| |
| public function testMax_ThrowsExceptionIfSequenceContainsNoneNumericValuesOrStrings() |
| { |
| $this->assertException(function() |
| { |
| $data = array(new stdClass()); |
| $max = Linq::from($data)->max(); |
| }, self::ExceptionName_UnexpectedValue); |
| |
| $this->assertException(function() |
| { |
| $data = array(null); |
| $max = Linq::from($data)->max(); |
| }, self::ExceptionName_UnexpectedValue); |
| |
| $this->assertException(function() |
| { |
| $data = array("string value", 1, new stdClass()); |
| $max = Linq::from($data)->max(); |
| }, self::ExceptionName_UnexpectedValue); |
| |
| $this->assertException(function() |
| { |
| $a = new stdClass(); $a->nonNumeric = new stdClass(); |
| $data = array($a); |
| $min = Linq::from($data)->max(function($x) |
| { |
| return $x->nonNumeric; |
| }); |
| }, self::ExceptionName_UnexpectedValue); |
| } |
| |
| public function testEach_PerformsActionOnEachElement() |
| { |
| $items = array("a", "b", "c"); |
| $looped = array(); |
| Linq::from($items) |
| ->each(function($x) use(&$looped) |
| { |
| $looped[] = $x; |
| }); |
| |
| $this->assertEquals(3, count($looped)); |
| $this->assertEquals("a", $looped[0]); |
| $this->assertEquals("b", $looped[1]); |
| $this->assertEquals("c", $looped[2]); |
| } |
| |
| public function testEach_ReturnsOriginalLinqSequence() |
| { |
| $linq = Linq::from(array(1,2,3,4)) |
| ->skip(2)->take(1); |
| |
| $linqAfterEach = $linq->each(function($x) {}); |
| $this->assertSame($linq, $linqAfterEach); |
| } |
| |
| public function testToArray_WithoutKeySelector_ReturnsIteratorValuesAsArray_UsesDefaultNumericArrayKeys() |
| { |
| $linq = Linq::from(array("a", "b", "c")) |
| ->skip(1)->take(3); |
| |
| $array = $linq->toArray(); |
| $this->assertTrue(is_array($array)); |
| $this->assertEquals(2, count($array)); |
| |
| $keys = array_keys($array); |
| $this->assertEquals(0, $keys[0]); |
| $this->assertEquals(1, $keys[1]); |
| |
| $this->assertEquals("b", $array[0]); |
| $this->assertEquals("c", $array[1]); |
| } |
| |
| public function testToArray_WithKeySelector_ReturnsIteratorValuesAsArray_UsesKeySelectorValueAsKey() |
| { |
| $linq = Linq::from(array("a", "b", "c")) |
| ->skip(1)->take(3); |
| |
| $array = $linq->toArray(function($x) { |
| return "keyprefix_" . $x; |
| }); |
| |
| $this->assertTrue(is_array($array)); |
| $this->assertEquals(2, count($array)); |
| |
| $keys = array_keys($array); |
| $this->assertEquals("keyprefix_b", $keys[0]); |
| $this->assertEquals("keyprefix_c", $keys[1]); |
| |
| $this->assertEquals("b", $array["keyprefix_b"]); |
| $this->assertEquals("c", $array["keyprefix_c"]); |
| } |
| |
| public function testToArray_WithKeyAndValueSelector_ReturnsArrayWithKeyValueSetsFromClosures() |
| { |
| $source = array( |
| array("catId" => 11, "name" => "Category11", "additionalcolumn" => "foo"), |
| array("catId" => 12, "name" => "Category12", "additionalcolumn" => "bar"), |
| ); |
| $linq = Linq::from($source); |
| |
| $array = $linq->toArray(function($x) { |
| return $x["catId"]; |
| }, function($y) { |
| return $y["name"]; |
| }); |
| |
| $this->assertTrue(is_array($array)); |
| $this->assertEquals(2, count($array)); |
| |
| $keys = array_keys($array); |
| $this->assertEquals(11, $keys[0]); |
| $this->assertEquals(12, $keys[1]); |
| |
| $this->assertEquals("Category11", $array[11]); |
| $this->assertEquals("Category12", $array[12]); |
| } |
| |
| public function testToArray_WithValueSelector_ReturnsArrayWithDefaultNumericKey_AndValueFromClosure() |
| { |
| $source = array( |
| array("catId" => 11, "name" => "Category11", "additionalcolumn" => "foo"), |
| array("catId" => 12, "name" => "Category12", "additionalcolumn" => "bar"), |
| ); |
| |
| $linq = Linq::from($source); |
| |
| $array = $linq->toArray(null, function($y) { |
| return $y["additionalcolumn"]; |
| }); |
| |
| $this->assertTrue(is_array($array)); |
| $this->assertEquals(2, count($array)); |
| |
| $keys = array_keys($array); |
| $this->assertEquals(0, $keys[0]); |
| $this->assertEquals(1, $keys[1]); |
| |
| $this->assertEquals("foo", $array[0]); |
| $this->assertEquals("bar", $array[1]); |
| } |
| |
| public function testAggregate_novalues_throwsException() |
| { |
| $this->assertException(function() { |
| |
| Linq::from(array())->aggregate(function() {}); |
| }, self::ExceptionName_Runtime); |
| |
| |
| $this->assertException(function() { |
| |
| Linq::from(array())->aggregate(function() {}, null); |
| }, self::ExceptionName_Runtime); |
| } |
| |
| public function testAggregate_returnsCorrectResult() |
| { |
| $this->assertEquals("value", Linq::from(array("value"))->aggregate(function($a, $b) { throw new Exception("Must not becalled"); })); |
| $this->assertEquals(2, Linq::from(array(2))->aggregate(function($a, $b) { throw new Exception("Must not becalled"); })); |
| $this->assertEquals(5, Linq::from(array(2, 3))->aggregate(function($a, $b) { return $a + $b; })); |
| $this->assertEquals(17, Linq::from(array(2, 3, 3, 4, 5))->aggregate(function($a, $b) { return $a + $b; })); |
| $this->assertEquals("abcde", Linq::from(array("a","b","c","d","e"))->aggregate(function($a, $b) { return $a . $b; })); |
| } |
| |
| public function testAggregate_withSeedValue_returnsCorrectResult() |
| { |
| $this->assertEquals(9999, Linq::from(array())->aggregate(function() {}, 9999)); |
| $this->assertEquals(104, Linq::from(array(2))->aggregate(function($a, $b) { return $a + $b; }, 102)); |
| $this->assertEquals(137, Linq::from(array(2, 2, 20, 11))->aggregate(function($a, $b) { return $a + $b; }, 102)); |
| $this->assertEquals("begin_abcde", Linq::from(array("a","b","c","d","e"))->aggregate(function($a, $b) { return $a . $b; }, "begin_")); |
| } |
| |
| public function testRange_throwsExceptionIfCountIsNegative() |
| { |
| $this->assertException(function() { |
| |
| Linq::range(0, -1); |
| }, self::ExceptionName_OutOfRange); |
| } |
| |
| public function testRange_returnsRangeOfIntegers() |
| { |
| $range = Linq::range(0, 3)->toArray(); |
| $this->assertEquals(3, count($range)); |
| $this->assertEquals(0, $range[0]); |
| $this->assertEquals(1, $range[1]); |
| $this->assertEquals(2, $range[2]); |
| |
| $range = Linq::range(6, 3)->toArray(); |
| $this->assertEquals(3, count($range)); |
| $this->assertEquals(6, $range[0]); |
| $this->assertEquals(7, $range[1]); |
| $this->assertEquals(8, $range[2]); |
| |
| $range = Linq::range(-3, 5)->toArray(); |
| $this->assertEquals(5, count($range)); |
| $this->assertEquals(-3, $range[0]); |
| $this->assertEquals(-2, $range[1]); |
| $this->assertEquals(-1, $range[2]); |
| $this->assertEquals(0, $range[3]); |
| $this->assertEquals(1, $range[4]); |
| } |
| |
| public function testContains_defaultComparison() |
| { |
| $items = array("2", 2); |
| $linq = Linq::from($items); |
| $this->assertTrue($linq->contains(2)); |
| $this->assertTrue($linq->contains("2")); |
| $this->assertFalse($linq->contains(true)); |
| |
| $this->assertFalse($linq->contains(3)); |
| $this->assertFalse($linq->contains("3")); |
| |
| $this->assertFalse($linq->contains(3)); |
| $this->assertFalse($linq->contains(null)); |
| |
| $a = new stdClass(); |
| $b = new stdClass(); |
| $c = new stdClass(); |
| $linq = Linq::from(array($a, $b)); |
| $this->assertTrue($linq->contains($a)); |
| $this->assertTrue($linq->contains($b)); |
| $this->assertFalse($linq->contains($c)); |
| } |
| |
| public function testChunk_throwsException_IfchunksizeIsInvalid() |
| { |
| $this->assertException(function() { |
| Linq::from(array())->chunk(0); |
| }, self::ExceptionName_InvalidArgument); |
| |
| $this->assertException(function() { |
| Linq::from(array())->chunk(-1); |
| }, self::ExceptionName_InvalidArgument); |
| } |
| |
| public function testChunk_ReturnsChunkedElementsAccordingToChunksize() |
| { |
| $groups = Linq::from(array())->chunk(2); |
| $this->assertEquals(0, $groups->count()); |
| |
| $groups = Linq::from(array("a"))->chunk(2); |
| $this->assertEquals(1, $groups->count()); |
| $this->assertEquals(1, $groups->ElementAt(0)->count()); |
| $this->assertEquals("a", $groups->ElementAt(0)->ElementAt(0)); |
| |
| $groups = Linq::from(array("a","b","c","d","e"))->chunk(2); |
| $this->assertEquals(3, $groups->count()); |
| $this->assertEquals(2, $groups->ElementAt(0)->count()); |
| $this->assertEquals("a", $groups->ElementAt(0)->ElementAt(0)); |
| $this->assertEquals("b", $groups->ElementAt(0)->ElementAt(1)); |
| |
| $this->assertEquals(2, $groups->ElementAt(1)->count()); |
| $this->assertEquals("c", $groups->ElementAt(1)->ElementAt(0)); |
| $this->assertEquals("d", $groups->ElementAt(1)->ElementAt(1)); |
| |
| $this->assertEquals(1, $groups->ElementAt(2)->count()); |
| $this->assertEquals("e", $groups->ElementAt(2)->ElementAt(0)); |
| |
| $groups = Linq::from(array("a","b","c","d","e"))->chunk(3); |
| $this->assertEquals(2, $groups->count()); |
| |
| $groups = Linq::from(array("a","b","c","d","e"))->chunk(4); |
| $this->assertEquals(2, $groups->count()); |
| |
| $groups = Linq::from(array("a","b","c","d","e"))->chunk(5); |
| $this->assertEquals(1, $groups->count()); |
| |
| $groups = Linq::from(array("a","b","c","d","e"))->chunk(117); |
| $this->assertEquals(1, $groups->count()); |
| } |
| |
| public function testIssue3_emtpyCollectionOrdering() |
| { |
| Linq::from(array()) |
| ->orderBy(function(array $x) { return $x["name"]; }) |
| ->toArray(); |
| } |
| |
| /** |
| * @test |
| */ |
| public function when_ofType_is_called_with_empty_array() |
| { |
| /** @var array $result */ |
| $result = Linq::from(array()) |
| ->ofType('StubInterface') |
| ->toArray(); |
| |
| $this->assertNotNull($result); |
| $this->assertCount(0, $result); |
| } |
| |
| /** |
| * @test |
| */ |
| public function when_ofType_is_called_with_array_containing_expected_interface() |
| { |
| /** @var Stub $expectedResult */ |
| $expectedResult = new Stub(); |
| |
| /** @var array $result */ |
| $result = Linq::from(array($expectedResult, |
| new StubWithoutInterface())) |
| ->ofType('StubInterface') |
| ->toArray(); |
| |
| $this->assertNotNull($result); |
| $this->assertCount(1, $result); |
| $this->assertSame($expectedResult, $result[0]); |
| } |
| |
| /** |
| * @test |
| */ |
| public function when_ofType_is_called_with_array_containing_expected_object_type() |
| { |
| /** @var StubWithoutInterface $expectedResult1 */ |
| $expectedResult1 = new StubWithoutInterface(); |
| |
| /** @var array $result */ |
| $result = Linq::from(array(new Stub(), |
| $expectedResult1)) |
| ->ofType('StubWithoutInterface') |
| ->toArray(); |
| |
| $this->assertNotNull($result); |
| $this->assertCount(1, $result); |
| $this->assertSame($expectedResult1, $result[0]); |
| |
| /** @var StubWithoutInterface $expectedResult2 */ |
| $expectedResult2 = new Stub(); |
| |
| $result = Linq::from(array($expectedResult2, |
| new StubWithoutInterface())) |
| ->ofType('Stub') |
| ->toArray(); |
| |
| $this->assertNotNull($result); |
| $this->assertCount(1, $result); |
| $this->assertSame($expectedResult2, $result[0]); |
| } |
| |
| /** |
| * @test |
| */ |
| public function when_ofType_is_called_with_array_not_containing_expected_interface() |
| { |
| /** @var array $result */ |
| $result = Linq::from(array(new StubWithoutInterface(), |
| new StubWithoutInterface())) |
| ->ofType('StubInterface') |
| ->toArray(); |
| |
| $this->assertNotNull($result); |
| $this->assertCount(0, $result); |
| } |
| |
| /** |
| * @test |
| */ |
| public function when_ofType_is_called_with_array_not_containing_expected_object_type() |
| { |
| /** @var array $result */ |
| $result = Linq::from(array(new Stub(), |
| new Stub())) |
| ->ofType('StubWithoutInterface') |
| ->toArray(); |
| |
| $this->assertNotNull($result); |
| $this->assertCount(0, $result); |
| } |
| |
| /** |
| * @test |
| */ |
| public function when_ofType_is_called_with_unknown_interface() |
| { |
| /** @var array $result */ |
| $result = Linq::from(array(new Stub(), |
| new Stub())) |
| ->ofType('UnknownInterface') |
| ->toArray(); |
| |
| $this->assertNotNull($result); |
| $this->assertCount(0, $result); |
| } |
| |
| /** |
| * @test |
| */ |
| public function when_ofType_is_called_with_unknown_object_type() |
| { |
| /** @var array $result */ |
| $result = Linq::from(array(new Stub(), |
| new Stub())) |
| ->ofType('UnknownObject') |
| ->toArray(); |
| |
| $this->assertNotNull($result); |
| $this->assertCount(0, $result); |
| } |
| |
| /** |
| * @test |
| */ |
| public function when_ofType_is_called_with_int_as_type() |
| { |
| /** @var int[] $expectedResult */ |
| $expectedResult = array(1, |
| 2, |
| 10, |
| 20); |
| |
| $result = Linq::from(array(1, |
| 2, |
| new Stub(), |
| 10, |
| NULL, |
| 20)) |
| ->ofType('int') |
| ->toArray(); |
| |
| $this->assertNotNull($result); |
| $this->assertEquals($expectedResult, $result); |
| } |
| |
| /** |
| * @test |
| */ |
| public function when_ofType_is_called_with_bool_as_type() |
| { |
| /** @var int[] $expectedResult */ |
| $expectedResult = array(TRUE, |
| FALSE); |
| |
| $result = Linq::from(array(0, |
| 'string', |
| 'true', |
| TRUE, |
| 'false', |
| FALSE)) |
| ->ofType('bool') |
| ->toArray(); |
| |
| $this->assertNotNull($result); |
| $this->assertEquals($expectedResult, $result); |
| } |
| |
| /** |
| * @test |
| */ |
| public function when_ofType_is_called_with_string_as_type() |
| { |
| /** @var int[] $expectedResult */ |
| $expectedResult = array('string', |
| 'true', |
| 'false'); |
| |
| $result = Linq::from(array(0, |
| 'string', |
| 'true', |
| TRUE, |
| 'false', |
| FALSE)) |
| ->ofType('string') |
| ->toArray(); |
| |
| $this->assertNotNull($result); |
| $this->assertEquals($expectedResult, $result); |
| } |
| |
| /** |
| * @test |
| */ |
| public function when_ofType_is_called_with_float_as_type() |
| { |
| /** @var int[] $expectedResult */ |
| $expectedResult = array(2.5, |
| 10.0, |
| 0.3); |
| |
| $result = Linq::from(array(0, |
| 'string', |
| 2.5, |
| 10.0, |
| 11, |
| 'false', |
| 0.3)) |
| ->ofType('float') |
| ->toArray(); |
| |
| $this->assertNotNull($result); |
| $this->assertEquals($expectedResult, $result); |
| } |
| |
| /** |
| * @test |
| */ |
| public function when_ofType_is_called_with_double_as_type() |
| { |
| /** @var int[] $expectedResult */ |
| $expectedResult = array(2.5, |
| 10.0, |
| 0.3); |
| |
| $result = Linq::from(array(0, |
| 'string', |
| 2.5, |
| 10.0, |
| NULL, |
| 11, |
| 'false', |
| 0.3)) |
| ->ofType('double') |
| ->toArray(); |
| |
| $this->assertNotNull($result); |
| $this->assertEquals($expectedResult, $result); |
| } |
| |
| private function assertException($closure, $expected = self::ExceptionName_Runtime) |
| { |
| try |
| { |
| $closure(); |
| } |
| catch(Exception $ex) |
| { |
| $exName = get_class($ex); |
| |
| if($exName != $expected) |
| { |
| $this->fail("Wrong exception raised. Expected: '" . $expected . "' Actual: '" . get_class($ex) . "'. Message: " . $ex->getMessage()); |
| } |
| return; |
| } |
| |
| $this->fail($expected .' has not been raised.'); |
| } |
| } |
