Query calls must be immutable and return a new instance with every query call.
Queries should also be executed lazily upon iteration.
/**
* @dataProvider theImplementations
*/
public function testThatMaintainsCorrectSameIteratorScheme(\Pinq\ITraversable $traversable, array $data)
{
$originalScheme = $traversable->getIteratorScheme();
$queriedTraversable = $traversable->where(function () {
throw new \Exception('This should never be executed');
})->append([])->difference([])->except([])->groupBy(function () {
return 1;
})->groupJoin([])->on(function () {
return true;
})->to(function () {
return 1;
})->indexBy(function () {
return 1;
})->intersect([])->join([])->on(function () {
return true;
})->to(function () {
return 1;
})->keys()->orderBy(function () {
return 1;
}, \Pinq\Direction::ASCENDING)->thenByDescending(function () {
return 1;
})->reindex()->select(function () {
return 1;
})->selectMany(function () {
return [];
})->skip(1)->take(5)->union([])->where(function () {
return true;
})->whereIn([]);
//Well that was fun
$this->assertSame($originalScheme, $queriedTraversable->getIteratorScheme());
}
/**
* @dataProvider dateTimes
*/
public function testAggregateValues(\Pinq\ITraversable $traversable, array $data)
{
$this->assertEquals(true, $traversable->all(), 'All');
$this->assertEquals(true, $traversable->any(), 'Any');
$this->assertEquals(max($data), $traversable->maximum(), 'Max');
$this->assertEquals(min($data), $traversable->minimum(), 'Min');
}
/**
* @dataProvider emptyData
*/
public function testThatUniqueMaintainsReferences(\Pinq\ITraversable $traversable)
{
$data = $this->makeRefs(array_merge(range(1, 10, 2), range(1, 10)));
$traversable->append($data)->unique()->iterate(function (&$i) {
$i *= 10;
});
$this->assertSame([10, 30, 50, 70, 90, 1, 20, 3, 40, 5, 60, 7, 80, 9, 100], $data);
}
/**
* @dataProvider emptyData
*/
public function testThatUnionMaintainsReferences(\Pinq\ITraversable $traversable)
{
$data = $this->makeRefs(range('a', 'f'));
$traversable->union($data)->iterate(function (&$i) {
$i = "{$i}-";
});
$this->assertSame('a-b-c-d-e-f-', implode('', $data));
}
/**
* @dataProvider emptyData
*/
public function testThatSliceMaintainsReferences(\Pinq\ITraversable $traversable)
{
$data = $this->makeRefs(range('Z', 'A'));
$traversable->append($data)->skip(10)->take(7)->slice(5, 3)->iterate(function (&$i) {
$i = "-{$i}{$i}-";
});
$this->assertSame('ZYXWVUTSRQPONML-KK--JJ-IHGFEDCBA', implode('', $data));
}
/**
* @dataProvider assocMixedValues
*/
public function testThatKeysSupportNonScalarKeys(\Pinq\ITraversable $traversable, array $data)
{
$keys = $traversable->indexBy(function () {
return new \stdClass();
})->keys();
$expectedKeys = empty($data) ? [] : array_fill_keys(range(0, count($data) - 1), new \stdClass());
$this->assertEquals($expectedKeys, $keys->asArray());
}
/**
* @dataProvider emptyData
*/
public function testThatWhereInMaintainsReferences(\Pinq\ITraversable $traversable)
{
$data = $this->makeRefs(range(100, 50, -10));
$traversable->append($data)->whereIn([70, 90])->iterate(function (&$i) {
$i /= 10;
});
$this->assertSame([100, 9, 80, 7, 60, 50], $data);
}
/**
* @dataProvider everything
*/
public function testThatAppendWithEmptyReturnsSameAsTheOriginalButReindexedKeys(\Pinq\ITraversable $traversable, array $data)
{
$appendedWithTraversable = $traversable->append([]);
$appendedWithArray = $traversable->append([]);
$appendedWithIterator = $traversable->append(new \ArrayObject([]));
$this->assertMatches($appendedWithTraversable, array_values($data));
$this->assertMatches($appendedWithArray, array_values($data));
$this->assertMatches($appendedWithIterator, array_values($data));
}
/**
* @dataProvider emptyData
*/
public function testThatIntersectMaintainsReferences(\Pinq\ITraversable $traversable)
{
$data = $this->makeRefs(range('A', 'Z', 2));
//Every 2nd letter: A, C, E, G...
$traversable->append($data)->intersect(range('A', 'Z', 3))->iterate(function (&$i) {
$i .= ':';
});
$this->assertSame(explode(' ', 'A: C E G: I K M: O Q S: U W Y:'), $data);
}
/**
* @dataProvider theImplementations
*/
public function testThatExecutionIsDeferred(\Pinq\ITraversable $traversable, array $data)
{
$this->assertThatExecutionIsDeferred(function (callable $function) use($traversable) {
return $traversable->join([])->on($function)->to($function);
});
$this->assertThatExecutionIsDeferred(function (callable $function) use($traversable) {
return $traversable->join([])->onEquality($function, $function)->to($function);
});
}
/**
* @dataProvider emptyData
*/
public function testThatWhereMaintainsReferences(\Pinq\ITraversable $traversable)
{
$data = $this->makeRefs(range(0, 30, 2));
$traversable->append($data)->where(function ($i) {
return $i % 3 === 0;
})->iterate(function (&$i) {
$i .= '?';
});
$this->assertSame(['0?', 2, 4, '6?', 8, 10, '12?', 14, 16, '18?', 20, 22, '24?', 26, 28, '30?'], $data);
}
/**
* @dataProvider emptyData
*/
public function testThatSelectDoesNotMaintainReferences(\Pinq\ITraversable $traversable)
{
$data = $this->makeRefs(range('Z', 'A'));
$traversable->append($data)->select(function &(&$i) {
return $i;
})->iterate(function (&$i) {
$i .= $i;
});
$this->assertSame(range('Z', 'A'), $data);
}
/**
* @dataProvider emptyData
*/
public function testThatIndexByMaintainsReferences(\Pinq\ITraversable $traversable)
{
$data = $this->makeRefs(range('A', 'G', 2));
$traversable->append($data)->indexBy(function ($i) {
return $i . '-key';
})->iterate(function (&$i) {
$i .= ':';
});
$this->assertSame(['A:', 'C:', 'E:', 'G:'], $data);
}
/**
* @dataProvider emptyData
*/
public function testThatReindexMaintainsReferences(\Pinq\ITraversable $traversable)
{
$data = $this->makeRefs(range('a', 'z'));
$traversable->append($data)->indexBy(function ($i) {
return $i;
})->reindex()->iterate(function (&$i) {
$i .= ';';
});
$this->assertSame('a;b;c;d;e;f;g;h;i;j;k;l;m;n;o;p;q;r;s;t;u;v;w;x;y;z;', implode('', $data));
}
/**
* @dataProvider emptyData
*/
public function testThatSelectManyMaintainsReferences(\Pinq\ITraversable $traversable)
{
$data = $this->makeRefs(range(100, 1, -1));
$traversable->append($data)->groupBy(function ($i) {
return $i % 3;
})->selectMany(function (\Pinq\ITraversable $group) {
return $group;
})->iterate(function (&$i) {
$i *= 10;
});
$this->assertSame(range(1000, 10, -10), $data);
}
/**
* @dataProvider people
*/
public function testGroupByWithArrayKey(\Pinq\ITraversable $traversable, array $data)
{
$ageGroupData = $traversable->groupBy(function ($i) {
return ['sex' => $i['sex'], 'ageGroup' => floor($i['age'] / 10) * 10];
})->orderByAscending(function (\Pinq\ITraversable $group, $key) {
return $key['ageGroup'];
})->thenByAscending(function (\Pinq\ITraversable $group, $key) {
return $key['sex'];
})->select(function (\Pinq\ITraversable $group, $key) {
$ageGroup = $key['ageGroup'] . '+';
$sex = $key['sex'];
return sprintf('%s(%s){%s}', $ageGroup, $sex, $group->implode(',', function ($i) {
return $i['firstName'];
}));
})->implode(':');
$this->assertEquals('20+(Female){Casy}:20+(Male){Alex,Dave}:30+(Female){Zoe,Sandy,Beth}:30+(Male){Daniel}:' . '40+(Male){Hugo}:50+(Male){Daniel}:60+(Male){David}', $ageGroupData);
}
/**
* @dataProvider assocOneToTen
*/
public function testThatContainsReturnsWhetherItContainsAnIdenticalElement(\Pinq\ITraversable $traversable, array $data)
{
$this->assertTrue($traversable->contains(1));
$this->assertFalse($traversable->contains('1'));
$this->assertTrue($traversable->contains(10));
$this->assertFalse($traversable->contains('10'));
$this->assertFalse($traversable->contains(-1));
$this->assertFalse($traversable->contains(0));
$this->assertFalse($traversable->contains(11));
}
/**
* @dataProvider someStrings
*/
public function testAggregateValuesString(\Pinq\ITraversable $traversable, array $data)
{
$this->assertEquals(true, $traversable->all(), 'All');
$this->assertEquals(true, $traversable->any(), 'Any');
$this->assertEquals(array_sum(array_map('strlen', $data)) / count($data), $traversable->average('strlen'), 'Average string length');
$this->assertEquals(array_sum(array_map('strlen', $data)), $traversable->sum('strlen'), 'Sum string length');
$this->assertEquals(array_unique($data), $traversable->unique()->asArray(), 'Unique');
$this->assertEquals(implode('- -- -', $data), $traversable->implode('- -- -'), 'String implode');
}
/**
* @dataProvider theImplementations
*/
public function testWithNonDeterministicQueryValuesAreNeverCached(\Pinq\ITraversable $traversable, array $data)
{
$query = $traversable->append(range(1, 50))->where(function ($i) {
return (bool) mt_rand(0, 1);
})->orderByDescending(function ($i) {
return (int) ($i / 10);
})->thenByAscending(function ($i) {
return $i;
})->slice(0, 50)->select(function ($i) {
return ++$i;
})->groupBy(function ($i) {
return $i % 3;
})->selectMany(function (\Pinq\ITraversable $group) {
return $group;
})->difference(range(15, 30, 2))->groupJoin(range(2, 10))->on(function ($i, $d) {
return $i % $d === 0;
})->to(function ($i, \Pinq\ITraversable $factors) {
return $i . ':' . $factors->implode(',');
});
$this->assertNotEquals($query->asArray(), $query->asArray());
}
public function visitOperation(Segments\Operation $query)
{
$otherValues = self::evaluateSource($query->getSource(), $this->resolvedParameters);
switch ($query->getOperationType()) {
case Segments\Operation::UNION:
$this->traversable = $this->traversable->union($otherValues);
break;
case Segments\Operation::INTERSECT:
$this->traversable = $this->traversable->intersect($otherValues);
break;
case Segments\Operation::DIFFERENCE:
$this->traversable = $this->traversable->difference($otherValues);
break;
case Segments\Operation::APPEND:
$this->traversable = $this->traversable->append($otherValues);
break;
case Segments\Operation::WHERE_IN:
$this->traversable = $this->traversable->whereIn($otherValues);
break;
case Segments\Operation::EXCEPT:
$this->traversable = $this->traversable->except($otherValues);
break;
}
}
/**
* @dataProvider oneToAHundred
*/
public function testSimpleAggregation(\Pinq\ITraversable $traversable, array $data)
{
$this->assertSame(array_sum($data), $traversable->sum());
$this->assertSame(array_sum($data) / count($data), $traversable->average());
}
/**
* @dataProvider emptyData
*/
public function testThatInterationPassesReferences(\Pinq\ITraversable $traversable)
{
$data = $this->makeRefs(range('A', 'Z'));
$traversable->append($data)->iterate(function (&$i) {
$i = null;
});
$this->assertSame(array_fill_keys(range(0, 25), null), $data);
}
/**
* @dataProvider oneToTenTwice
*/
public function testThatSumOperatesCorrectly(\Pinq\ITraversable $traversable, array $data)
{
$this->assertSame(empty($data) ? null : array_sum($data), $traversable->sum());
}
public function visitImplode(Requests\Implode $request)
{
return $this->traversable->implode($this->resolvedParameters[$request->getDelimiterId()], $this->getOptionalFunction($request));
}
/**
* @dataProvider assocOneToTen
*/
public function testThatExceptUsesStrictEquality(\Pinq\ITraversable $traversable, array $data)
{
$castToStringValues = array_map('strval', $data);
$except = $traversable->except($castToStringValues);
$this->assertMatches($except, $data);
}
/**
* @dataProvider emptyData
*/
public function testThatAggregateOnEmptyReturnsNull(\Pinq\ITraversable $traversable, array $data)
{
$this->assertNull($traversable->aggregate(function () {
return true;
}));
}
/**
* @dataProvider assocTenRandomStrings
*/
public function testImplodeOperatesCorrectly(\Pinq\ITraversable $traversable, array $data)
{
$this->assertSame(implode(',', $data), $traversable->implode(','));
}
protected final function assertMatchesValues(\Pinq\ITraversable $traversable, array $array, $message = '')
{
$firstIterationArray = [];
foreach ($traversable as $key => $value) {
$firstIterationArray[] = $value;
}
$secondIterationArray = [];
foreach ($traversable as $key => $value) {
$secondIterationArray[] = $value;
}
$explicitArray = array_values($traversable->asArray());
$array = array_values($array);
$this->assertSame($array, $firstIterationArray, $message);
$this->assertSame($array, $secondIterationArray, $message);
$this->assertSame($array, $explicitArray, $message);
}
/**
* @dataProvider emptyData
*/
public function testThatFirstReturnsNullWhenThereAreNoValues(\Pinq\ITraversable $empty)
{
$this->assertEquals(null, $empty->first());
}
/**
* @dataProvider emptyData
*/
public function testThatOrderByMaintainsReferences(\Pinq\ITraversable $traversable)
{
$data = $this->makeRefs(range(1, 100));
$traversable->append($data)->orderByAscending(function ($i) {
return (int) ($i / 10);
})->thenByDescending(function ($i) {
return $i;
})->iterate(function (&$i) {
$i *= 10;
});
$this->assertSame(range(10, 1000, 10), $data);
}
