<?php

namespace Illuminate\Tests\Support;

use ArrayAccess;

use ArrayIterator;

use ArrayObject;

use CachingIterator;

use Exception;

use Illuminate\Contracts\Support\Arrayable;

use Illuminate\Contracts\Support\Jsonable;

use Illuminate\Support\Collection;

use Illuminate\Support\HtmlString;

use Illuminate\Support\LazyCollection;

use InvalidArgumentException;

use JsonSerializable;

use Mockery as m;

use PHPUnit\Framework\TestCase;

use ReflectionClass;

use stdClass;

class SupportCollectionTest extends TestCase

{

/**

* @dataProvider collectionClassProvider

*/

public function testFirstReturnsFirstItemInCollection($collection)

{

$c = new $collection(['foo', 'bar']);

$this->assertSame('foo', $c->first());

}

/**

* @dataProvider collectionClassProvider

*/

public function testFirstWithCallback($collection)

{

$data = new $collection(['foo', 'bar', 'baz']);

$result = $data->first(function ($value) {

return $value === 'bar';

});

$this->assertSame('bar', $result);

}

/**

* @dataProvider collectionClassProvider

*/

public function testFirstWithCallbackAndDefault($collection)

{

$data = new $collection(['foo', 'bar']);

$result = $data->first(function ($value) {

return $value === 'baz';

}, 'default');

$this->assertSame('default', $result);

}

/**

* @dataProvider collectionClassProvider

*/

public function testFirstWithDefaultAndWithoutCallback($collection)

{

$data = new $collection;

$result = $data->first(null, 'default');

$this->assertSame('default', $result);

}

/**

* @dataProvider collectionClassProvider

*/

public function testFirstWhere($collection)

{

$data = new $collection([

['material' => 'paper', 'type' => 'book'],

['material' => 'rubber', 'type' => 'gasket'],

]);

$this->assertSame('book', $data->firstWhere('material', 'paper')['type']);

$this->assertSame('gasket', $data->firstWhere('material', 'rubber')['type']);

$this->assertNull($data->firstWhere('material', 'nonexistant'));

$this->assertNull($data->firstWhere('nonexistant', 'key'));

}

/**

* @dataProvider collectionClassProvider

*/

public function testLastReturnsLastItemInCollection($collection)

{

$c = new $collection(['foo', 'bar']);

$this->assertSame('bar', $c->last());

}

/**

* @dataProvider collectionClassProvider

*/

public function testLastWithCallback($collection)

{

$data = new $collection([100, 200, 300]);

$result = $data->last(function ($value) {

return $value < 250;

});

$this->assertEquals(200, $result);

$result = $data->last(function ($value, $key) {

return $key < 2;

});

$this->assertEquals(200, $result);

}

/**

* @dataProvider collectionClassProvider

*/

public function testLastWithCallbackAndDefault($collection)

{

$data = new $collection(['foo', 'bar']);

$result = $data->last(function ($value) {

return $value === 'baz';

}, 'default');

$this->assertSame('default', $result);

}

/**

* @dataProvider collectionClassProvider

*/

public function testLastWithDefaultAndWithoutCallback($collection)

{

$data = new $collection;

$result = $data->last(null, 'default');

$this->assertSame('default', $result);

}

public function testPopReturnsAndRemovesLastItemInCollection()

{

$c = new Collection(['foo', 'bar']);

$this->assertSame('bar', $c->pop());

$this->assertSame('foo', $c->first());

}

public function testShiftReturnsAndRemovesFirstItemInCollection()

{

$data = new Collection(['Taylor', 'Otwell']);

$this->assertSame('Taylor', $data->shift());

$this->assertSame('Otwell', $data->first());

$this->assertSame('Otwell', $data->shift());

$this->assertEquals(null, $data->first());

}

/**

* @dataProvider collectionClassProvider

*/

public function testEmptyCollectionIsEmpty($collection)

{

$c = new $collection;

$this->assertTrue($c->isEmpty());

}

/**

* @dataProvider collectionClassProvider

*/

public function testEmptyCollectionIsNotEmpty($collection)

{

$c = new $collection(['foo', 'bar']);

$this->assertFalse($c->isEmpty());

$this->assertTrue($c->isNotEmpty());

}

/**

* @dataProvider collectionClassProvider

*/

public function testCollectionIsConstructed($collection)

{

$data = new $collection('foo');

$this->assertSame(['foo'], $data->all());

$data = new $collection(2);

$this->assertSame([2], $data->all());

$data = new $collection(false);

$this->assertSame([false], $data->all());

$data = new $collection(null);

$this->assertEmpty($data->all());

$data = new $collection;

$this->assertEmpty($data->all());

}

/**

* @dataProvider collectionClassProvider

*/

public function testCollectionShuffleWithSeed($collection)

{

$data = new $collection(range(0, 100, 10));

$firstRandom = $data->shuffle(1234);

$secondRandom = $data->shuffle(1234);

$this->assertEquals($firstRandom, $secondRandom);

}

/**

* @dataProvider collectionClassProvider

*/

public function testSkipMethod($collection)

{

$data = new $collection([1, 2, 3, 4, 5, 6]);

$data = $data->skip(4)->values();

$this->assertSame([5, 6], $data->all());

}

/**

* @dataProvider collectionClassProvider

*/

public function testGetArrayableItems($collection)

{

$data = new $collection;

$class = new ReflectionClass($collection);

$method = $class->getMethod('getArrayableItems');

$method->setAccessible(true);

$items = new TestArrayableObject;

$array = $method->invokeArgs($data, [$items]);

$this->assertSame(['foo' => 'bar'], $array);

$items = new TestJsonableObject;

$array = $method->invokeArgs($data, [$items]);

$this->assertSame(['foo' => 'bar'], $array);

$items = new TestJsonSerializeObject;

$array = $method->invokeArgs($data, [$items]);

$this->assertSame(['foo' => 'bar'], $array);

$items = new TestJsonSerializeWithScalarValueObject;

$array = $method->invokeArgs($data, [$items]);

$this->assertSame(['foo'], $array);

$items = new $collection(['foo' => 'bar']);

$array = $method->invokeArgs($data, [$items]);

$this->assertSame(['foo' => 'bar'], $array);

$items = ['foo' => 'bar'];

$array = $method->invokeArgs($data, [$items]);

$this->assertSame(['foo' => 'bar'], $array);

}

/**

* @dataProvider collectionClassProvider

*/

public function testToArrayCallsToArrayOnEachItemInCollection($collection)

{

$item1 = m::mock(Arrayable::class);

$item1->shouldReceive('toArray')->once()->andReturn('foo.array');

$item2 = m::mock(Arrayable::class);

$item2->shouldReceive('toArray')->once()->andReturn('bar.array');

$c = new $collection([$item1, $item2]);

$results = $c->toArray();

$this->assertEquals(['foo.array', 'bar.array'], $results);

}

public function testLazyReturnsLazyCollection()

{

$data = new Collection([1, 2, 3, 4, 5]);

$lazy = $data->lazy();

$data->add(6);

$this->assertInstanceOf(LazyCollection::class, $lazy);

$this->assertSame([1, 2, 3, 4, 5], $lazy->all());

}

/**

* @dataProvider collectionClassProvider

*/

public function testJsonSerializeCallsToArrayOrJsonSerializeOnEachItemInCollection($collection)

{

$item1 = m::mock(JsonSerializable::class);

$item1->shouldReceive('jsonSerialize')->once()->andReturn('foo.json');

$item2 = m::mock(Arrayable::class);

$item2->shouldReceive('toArray')->once()->andReturn('bar.array');

$c = new $collection([$item1, $item2]);

$results = $c->jsonSerialize();

$this->assertEquals(['foo.json', 'bar.array'], $results);

}

/**

* @dataProvider collectionClassProvider

*/

public function testToJsonEncodesTheJsonSerializeResult($collection)

{

$c = $this->getMockBuilder($collection)->setMethods(['jsonSerialize'])->getMock();

$c->expects($this->once())->method('jsonSerialize')->willReturn('foo');

$results = $c->toJson();

$this->assertJsonStringEqualsJsonString(json_encode('foo'), $results);

}

/**

* @dataProvider collectionClassProvider

*/

public function testCastingToStringJsonEncodesTheToArrayResult($collection)

{

$c = $this->getMockBuilder($collection)->setMethods(['jsonSerialize'])->getMock();

$c->expects($this->once())->method('jsonSerialize')->willReturn('foo');

$this->assertJsonStringEqualsJsonString(json_encode('foo'), (string) $c);

}

public function testOffsetAccess()

{

$c = new Collection(['name' => 'taylor']);

$this->assertSame('taylor', $c['name']);

$c['name'] = 'dayle';

$this->assertSame('dayle', $c['name']);

$this->assertTrue(isset($c['name']));

unset($c['name']);

$this->assertFalse(isset($c['name']));

$c[] = 'jason';

$this->assertSame('jason', $c[0]);

}

public function testArrayAccessOffsetExists()

{

$c = new Collection(['foo', 'bar']);

$this->assertTrue($c->offsetExists(0));

$this->assertTrue($c->offsetExists(1));

$this->assertFalse($c->offsetExists(1000));

}

public function testArrayAccessOffsetGet()

{

$c = new Collection(['foo', 'bar']);

$this->assertSame('foo', $c->offsetGet(0));

$this->assertSame('bar', $c->offsetGet(1));

}

public function testArrayAccessOffsetSet()

{

$c = new Collection(['foo', 'foo']);

$c->offsetSet(1, 'bar');

$this->assertSame('bar', $c[1]);

$c->offsetSet(null, 'qux');

$this->assertSame('qux', $c[2]);

}

public function testArrayAccessOffsetUnset()

{

$c = new Collection(['foo', 'bar']);

$c->offsetUnset(1);

$this->assertFalse(isset($c[1]));

}

public function testForgetSingleKey()

{

$c = new Collection(['foo', 'bar']);

$c = $c->forget(0)->all();

$this->assertFalse(isset($c['foo']));

$c = new Collection(['foo' => 'bar', 'baz' => 'qux']);

$c = $c->forget('foo')->all();

$this->assertFalse(isset($c['foo']));

}

public function testForgetArrayOfKeys()

{

$c = new Collection(['foo', 'bar', 'baz']);

$c = $c->forget([0, 2])->all();

$this->assertFalse(isset($c[0]));

$this->assertFalse(isset($c[2]));

$this->assertTrue(isset($c[1]));

$c = new Collection(['name' => 'taylor', 'foo' => 'bar', 'baz' => 'qux']);

$c = $c->forget(['foo', 'baz'])->all();

$this->assertFalse(isset($c['foo']));

$this->assertFalse(isset($c['baz']));

$this->assertTrue(isset($c['name']));

}

/**

* @dataProvider collectionClassProvider

*/

public function testCountable($collection)

{

$c = new $collection(['foo', 'bar']);

$this->assertCount(2, $c);

}

/**

* @dataProvider collectionClassProvider

*/

public function testCountableByWithoutPredicate($collection)

{

$c = new $collection(['foo', 'foo', 'foo', 'bar', 'bar', 'foobar']);

$this->assertEquals(['foo' => 3, 'bar' => 2, 'foobar' => 1], $c->countBy()->all());

$c = new $collection([true, true, false, false, false]);

$this->assertEquals([true => 2, false => 3], $c->countBy()->all());

$c = new $collection([1, 5, 1, 5, 5, 1]);

$this->assertEquals([1 => 3, 5 => 3], $c->countBy()->all());

}

/**

* @dataProvider collectionClassProvider

*/

public function testCountableByWithPredicate($collection)

{

$c = new $collection(['alice', 'aaron', 'bob', 'carla']);

$this->assertEquals(['a' => 2, 'b' => 1, 'c' => 1], $c->countBy(function ($name) {

return substr($name, 0, 1);

})->all());

$c = new $collection([1, 2, 3, 4, 5]);

$this->assertEquals([true => 2, false => 3], $c->countBy(function ($i) {

return $i % 2 === 0;

})->all());

}

public function testIterable()

{

$c = new Collection(['foo']);

$this->assertInstanceOf(ArrayIterator::class, $c->getIterator());

$this->assertEquals(['foo'], $c->getIterator()->getArrayCopy());

}

/**

* @dataProvider collectionClassProvider

*/

public function testCachingIterator($collection)

{

$c = new $collection(['foo']);

$this->assertInstanceOf(CachingIterator::class, $c->getCachingIterator());

}

/**

* @dataProvider collectionClassProvider

*/

public function testFilter($collection)

{

$c = new $collection([['id' => 1, 'name' => 'Hello'], ['id' => 2, 'name' => 'World']]);

$this->assertEquals([1 => ['id' => 2, 'name' => 'World']], $c->filter(function ($item) {

return $item['id'] == 2;

})->all());

$c = new $collection(['', 'Hello', '', 'World']);

$this->assertEquals(['Hello', 'World'], $c->filter()->values()->toArray());

$c = new $collection(['id' => 1, 'first' => 'Hello', 'second' => 'World']);

$this->assertEquals(['first' => 'Hello', 'second' => 'World'], $c->filter(function ($item, $key) {

return $key != 'id';

})->all());

}

/**

* @dataProvider collectionClassProvider

*/

public function testHigherOrderKeyBy($collection)

{

$c = new $collection([

['id' => 'id1', 'name' => 'first'],

['id' => 'id2', 'name' => 'second'],

]);

$this->assertEquals(['id1' => 'first', 'id2' => 'second'], $c->keyBy->id->map->name->all());

}

/**

* @dataProvider collectionClassProvider

*/

public function testHigherOrderUnique($collection)

{

$c = new $collection([

['id' => '1', 'name' => 'first'],

['id' => '1', 'name' => 'second'],

]);

$this->assertCount(1, $c->unique->id);

}

/**

* @dataProvider collectionClassProvider

*/

public function testHigherOrderFilter($collection)

{

$c = new $collection([

new class {

public $name = 'Alex';

public function active()

{

return true;

}

},

new class {

public $name = 'John';

public function active()

{

return false;

}

},

]);

$this->assertCount(1, $c->filter->active());

}

/**

* @dataProvider collectionClassProvider

*/

public function testWhere($collection)

{

$c = new $collection([['v' => 1], ['v' => 2], ['v' => 3], ['v' => '3'], ['v' => 4]]);

$this->assertEquals(

[['v' => 3], ['v' => '3']],

$c->where('v', 3)->values()->all()

);

$this->assertEquals(

[['v' => 3], ['v' => '3']],

$c->where('v', '=', 3)->values()->all()

);

$this->assertEquals(

[['v' => 3], ['v' => '3']],

$c->where('v', '==', 3)->values()->all()

);

$this->assertEquals(

[['v' => 3], ['v' => '3']],

$c->where('v', 'garbage', 3)->values()->all()

);

$this->assertEquals(

[['v' => 3]],

$c->where('v', '===', 3)->values()->all()

);

$this->assertEquals(

[['v' => 1], ['v' => 2], ['v' => 4]],

$c->where('v', '<>', 3)->values()->all()

);

$this->assertEquals(

[['v' => 1], ['v' => 2], ['v' => 4]],

$c->where('v', '!=', 3)->values()->all()

);

$this->assertEquals(

[['v' => 1], ['v' => 2], ['v' => '3'], ['v' => 4]],

$c->where('v', '!==', 3)->values()->all()

);

$this->assertEquals(

[['v' => 1], ['v' => 2], ['v' => 3], ['v' => '3']],

$c->where('v', '<=', 3)->values()->all()

);

$this->assertEquals(

[['v' => 3], ['v' => '3'], ['v' => 4]],

$c->where('v', '>=', 3)->values()->all()

);

$this->assertEquals(

[['v' => 1], ['v' => 2]],

$c->where('v', '<', 3)->values()->all()

);

$this->assertEquals(

[['v' => 4]],

$c->where('v', '>', 3)->values()->all()

);

$object = (object) ['foo' => 'bar'];

$this->assertEquals(

[],

$c->where('v', $object)->values()->all()

);

$this->assertEquals(

[['v' => 1], ['v' => 2], ['v' => 3], ['v' => '3'], ['v' => 4]],

$c->where('v', '<>', $object)->values()->all()

);

$this->assertEquals(

[['v' => 1], ['v' => 2], ['v' => 3], ['v' => '3'], ['v' => 4]],

$c->where('v', '!=', $object)->values()->all()

);

$this->assertEquals(

[['v' => 1], ['v' => 2], ['v' => 3], ['v' => '3'], ['v' => 4]],

$c->where('v', '!==', $object)->values()->all()

);

$this->assertEquals(

[],

$c->where('v', '>', $object)->values()->all()

);

$c = new $collection([['v' => 1], ['v' => $object]]);

$this->assertEquals(

[['v' => $object]],

$c->where('v', $object)->values()->all()

);

$this->assertEquals(

[['v' => 1], ['v' => $object]],

$c->where('v', '<>', null)->values()->all()

);

$this->assertEquals(

[],

$c->where('v', '<', null)->values()->all()

);

$c = new $collection([['v' => 1], ['v' => new HtmlString('hello')]]);

$this->assertEquals(

[['v' => new HtmlString('hello')]],

$c->where('v', 'hello')->values()->all()

);

$c = new $collection([['v' => 1], ['v' => 'hello']]);

$this->assertEquals(

[['v' => 'hello']],

$c->where('v', new HtmlString('hello'))->values()->all()

);

$c = new $collection([['v' => 1], ['v' => 2], ['v' => null]]);

$this->assertEquals(

[['v' => 1], ['v' => 2]],

$c->where('v')->values()->all()

);

}

/**

* @dataProvider collectionClassProvider

*/

public function testWhereStrict($collection)

{

$c = new $collection([['v' => 3], ['v' => '3']]);

$this->assertEquals(

[['v' => 3]],

$c->whereStrict('v', 3)->values()->all()

);

}

/**

* @dataProvider collectionClassProvider

*/

public function testWhereInstanceOf($collection)

{

$c = new $collection([new stdClass, new stdClass, new $collection, new stdClass]);

$this->assertCount(3, $c->whereInstanceOf(stdClass::class));

}

/**

* @dataProvider collectionClassProvider

*/

public function testWhereIn($collection)

{

$c = new $collection([['v' => 1], ['v' => 2], ['v' => 3], ['v' => '3'], ['v' => 4]]);

$this->assertEquals([['v' => 1], ['v' => 3], ['v' => '3']], $c->whereIn('v', [1, 3])->values()->all());

}

/**

* @dataProvider collectionClassProvider

*/

public function testWhereInStrict($collection)

{

$c = new $collection([['v' => 1], ['v' => 2], ['v' => 3], ['v' => '3'], ['v' => 4]]);

$this->assertEquals([['v' => 1], ['v' => 3]], $c->whereInStrict('v', [1, 3])->values()->all());

}

/**

* @dataProvider collectionClassProvider

*/

public function testWhereNotIn($collection)

{

$c = new $collection([['v' => 1], ['v' => 2], ['v' => 3], ['v' => '3'], ['v' => 4]]);

$this->assertEquals([['v' => 2], ['v' => 4]], $c->whereNotIn('v', [1, 3])->values()->all());

}

/**

* @dataProvider collectionClassProvider

*/

public function testWhereNotInStrict($collection)

{

$c = new $collection([['v' => 1], ['v' => 2], ['v' => 3], ['v' => '3'], ['v' => 4]]);

$this->assertEquals([['v' => 2], ['v' => '3'], ['v' => 4]], $c->whereNotInStrict('v', [1, 3])->values()->all());

}

/**

* @dataProvider collectionClassProvider

*/

public function testValues($collection)

{

$c = new $collection([['id' => 1, 'name' => 'Hello'], ['id' => 2, 'name' => 'World']]);

$this->assertEquals([['id' => 2, 'name' => 'World']], $c->filter(function ($item) {

return $item['id'] == 2;

})->values()->all());

}

/**

* @dataProvider collectionClassProvider

*/

public function testBetween($collection)

{

$c = new $collection([['v' => 1], ['v' => 2], ['v' => 3], ['v' => '3'], ['v' => 4]]);

$this->assertEquals([['v' => 2], ['v' => 3], ['v' => '3'], ['v' => 4]],

$c->whereBetween('v', [2, 4])->values()->all());

$this->assertEquals([['v' => 1]], $c->whereBetween('v', [-1, 1])->all());

$this->assertEquals([['v' => 3], ['v' => '3']], $c->whereBetween('v', [3, 3])->values()->all());

}

/**

* @dataProvider collectionClassProvider

*/

public function testWhereNotBetween($collection)

{

$c = new $collection([['v' => 1], ['v' => 2], ['v' => 3], ['v' => '3'], ['v' => 4]]);

$this->assertEquals([['v' => 1]], $c->whereNotBetween('v', [2, 4])->values()->all());

$this->assertEquals([['v' => 2], ['v' => 3], ['v' => 3], ['v' => 4]], $c->whereNotBetween('v', [-1, 1])->values()->all());

$this->assertEquals([['v' => 1], ['v' => '2'], ['v' => '4']], $c->whereNotBetween('v', [3, 3])->values()->all());

}

/**

* @dataProvider collectionClassProvider

*/

public function testFlatten($collection)

{

// Flat arrays are unaffected

$c = new $collection(['#foo', '#bar', '#baz']);

$this->assertEquals(['#foo', '#bar', '#baz'], $c->flatten()->all());

// Nested arrays are flattened with existing flat items

$c = new $collection([['#foo', '#bar'], '#baz']);

$this->assertEquals(['#foo', '#bar', '#baz'], $c->flatten()->all());

// Sets of nested arrays are flattened

$c = new $collection([['#foo', '#bar'], ['#baz']]);

$this->assertEquals(['#foo', '#bar', '#baz'], $c->flatten()->all());

// Deeply nested arrays are flattened

$c = new $collection([['#foo', ['#bar']], ['#baz']]);

$this->assertEquals(['#foo', '#bar', '#baz'], $c->flatten()->all());

// Nested collections are flattened alongside arrays

$c = new $collection([new $collection(['#foo', '#bar']), ['#baz']]);

$this->assertEquals(['#foo', '#bar', '#baz'], $c->flatten()->all());

// Nested collections containing plain arrays are flattened

$c = new $collection([new $collection(['#foo', ['#bar']]), ['#baz']]);

$this->assertEquals(['#foo', '#bar', '#baz'], $c->flatten()->all());

// Nested arrays containing collections are flattened

$c = new $collection([['#foo', new $collection(['#bar'])], ['#baz']]);

$this->assertEquals(['#foo', '#bar', '#baz'], $c->flatten()->all());

// Nested arrays containing collections containing arrays are flattened

$c = new $collection([['#foo', new $collection(['#bar', ['#zap']])], ['#baz']]);

$this->assertEquals(['#foo', '#bar', '#zap', '#baz'], $c->flatten()->all());

}

/**

* @dataProvider collectionClassProvider

*/

public function testFlattenWithDepth($collection)

{

// No depth flattens recursively

$c = new $collection([['#foo', ['#bar', ['#baz']]], '#zap']);

$this->assertEquals(['#foo', '#bar', '#baz', '#zap'], $c->flatten()->all());

// Specifying a depth only flattens to that depth

$c = new $collection([['#foo', ['#bar', ['#baz']]], '#zap']);

$this->assertEquals(['#foo', ['#bar', ['#baz']], '#zap'], $c->flatten(1)->all());

$c = new $collection([['#foo', ['#bar', ['#baz']]], '#zap']);

$this->assertEquals(['#foo', '#bar', ['#baz'], '#zap'], $c->flatten(2)->all());

}

/**

* @dataProvider collectionClassProvider

*/

public function testFlattenIgnoresKeys($collection)

{

// No depth ignores keys

$c = new $collection(['#foo', ['key' => '#bar'], ['key' => '#baz'], 'key' => '#zap']);

$this->assertEquals(['#foo', '#bar', '#baz', '#zap'], $c->flatten()->all());

// Depth of 1 ignores keys

$c = new $collection(['#foo', ['key' => '#bar'], ['key' => '#baz'], 'key' => '#zap']);

$this->assertEquals(['#foo', '#bar', '#baz', '#zap'], $c->flatten(1)->all());

}

/**

* @dataProvider collectionClassProvider

*/

public function testMergeNull($collection)

{

$c = new $collection(['name' => 'Hello']);

$this->assertEquals(['name' => 'Hello'], $c->merge(null)->all());

}

/**

* @dataProvider collectionClassProvider

*/

public function testMergeArray($collection)

{

$c = new $collection(['name' => 'Hello']);

$this->assertEquals(['name' => 'Hello', 'id' => 1], $c->merge(['id' => 1])->all());

}

/**

* @dataProvider collectionClassProvider

*/

public function testMergeCollection($collection)

{

$c = new $collection(['name' => 'Hello']);

$this->assertEquals(['name' => 'World', 'id' => 1], $c->merge(new $collection(['name' => 'World', 'id' => 1]))->all());

}

/**

* @dataProvider collectionClassProvider

*/

public function testMergeRecursiveNull($collection)

{

$c = new $collection(['name' => 'Hello']);

$this->assertEquals(['name' => 'Hello'], $c->mergeRecursive(null)->all());

}

/**

* @dataProvider collectionClassProvider

*/

public function testMergeRecursiveArray($collection)

{

$c = new $collection(['name' => 'Hello', 'id' => 1]);

$this->assertEquals(['name' => 'Hello', 'id' => [1, 2]], $c->mergeRecursive(['id' => 2])->all());

}

/**

* @dataProvider collectionClassProvider

*/

public function testMergeRecursiveCollection($collection)

{

$c = new $collection(['name' => 'Hello', 'id' => 1, 'meta' => ['tags' => ['a', 'b'], 'roles' => 'admin']]);

$this->assertEquals(

['name' => 'Hello', 'id' => 1, 'meta' => ['tags' => ['a', 'b', 'c'], 'roles' => ['admin', 'editor']]],

$c->mergeRecursive(new $collection(['meta' => ['tags' => ['c'], 'roles' => 'editor']]))->all()

);

}

/**

* @dataProvider collectionClassProvider

*/

public function testReplaceNull($collection)

{

$c = new $collection(['a', 'b', 'c']);

$this->assertEquals(['a', 'b', 'c'], $c->replace(null)->all());

}

/**

* @dataProvider collectionClassProvider

*/

public function testReplaceArray($collection)

{

$c = new $collection(['a', 'b', 'c']);

$this->assertEquals(['a', 'd', 'e'], $c->replace([1 => 'd', 2 => 'e'])->all());

}

/**

* @dataProvider collectionClassProvider

*/

public function testReplaceCollection($collection)

{

$c = new $collection(['a', 'b', 'c']);

$this->assertEquals(

['a', 'd', 'e'],

$c->replace(new $collection([1 => 'd', 2 => 'e']))->all()

);

}

/**

* @dataProvider collectionClassProvider

*/

public function testReplaceRecursiveNull($collection)

{

$c = new $collection(['a', 'b', ['c', 'd']]);

$this->assertEquals(['a', 'b', ['c', 'd']], $c->replaceRecursive(null)->all());

}

/**

* @dataProvider collectionClassProvider

*/

public function testReplaceRecursiveArray($collection)

{

$c = new $collection(['a', 'b', ['c', 'd']]);

$this->assertEquals(['z', 'b', ['c', 'e']], $c->replaceRecursive(['z', 2 => [1 => 'e']])->all());

}

/**

* @dataProvider collectionClassProvider

*/

public function testReplaceRecursiveCollection($collection)

{

$c = new $collection(['a', 'b', ['c', 'd']]);

$this->assertEquals(

['z', 'b', ['c', 'e']],

$c->replaceRecursive(new $collection(['z', 2 => [1 => 'e']]))->all()

);

}

/**

* @dataProvider collectionClassProvider

*/

public function testUnionNull($collection)

{

$c = new $collection(['name' => 'Hello']);

$this->assertEquals(['name' => 'Hello'], $c->union(null)->all());

}

/**

* @dataProvider collectionClassProvider

*/

public function testUnionArray($collection)

{

$c = new $collection(['name' => 'Hello']);

$this->assertEquals(['name' => 'Hello', 'id' => 1], $c->union(['id' => 1])->all());

}

/**

* @dataProvider collectionClassProvider

*/

public function testUnionCollection($collection)

{

$c = new $collection(['name' => 'Hello']);

$this->assertEquals(['name' => 'Hello', 'id' => 1], $c->union(new $collection(['name' => 'World', 'id' => 1]))->all());

}

/**

* @dataProvider collectionClassProvider

*/

public function testDiffCollection($collection)

{

$c = new $collection(['id' => 1, 'first_word' => 'Hello']);

$this->assertEquals(['id' => 1], $c->diff(new $collection(['first_word' => 'Hello', 'last_word' => 'World']))->all());

}

/**

* @dataProvider collectionClassProvider

*/

public function testDiffUsingWithCollection($collection)

{

$c = new $collection(['en_GB', 'fr', 'HR']);

// demonstrate that diffKeys wont support case insensitivity

$this->assertEquals(['en_GB', 'fr', 'HR'], $c->diff(new $collection(['en_gb', 'hr']))->values()->toArray());

// allow for case insensitive difference

$this->assertEquals(['fr'], $c->diffUsing(new $collection(['en_gb', 'hr']), 'strcasecmp')->values()->toArray());

}

/**

* @dataProvider collectionClassProvider

*/

public function testDiffUsingWithNull($collection)

{

$c = new $collection(['en_GB', 'fr', 'HR']);

$this->assertEquals(['en_GB', 'fr', 'HR'], $c->diffUsing(null, 'strcasecmp')->values()->toArray());

}

/**

* @dataProvider collectionClassProvider

*/

public function testDiffNull($collection)

{

$c = new $collection(['id' => 1, 'first_word' => 'Hello']);

$this->assertEquals(['id' => 1, 'first_word' => 'Hello'], $c->diff(null)->all());

}

/**

* @dataProvider collectionClassProvider

*/

public function testDiffKeys($collection)

{

$c1 = new $collection(['id' => 1, 'first_word' => 'Hello']);

$c2 = new $collection(['id' => 123, 'foo_bar' => 'Hello']);

$this->assertEquals(['first_word' => 'Hello'], $c1->diffKeys($c2)->all());

}

/**

* @dataProvider collectionClassProvider

*/

public function testDiffKeysUsing($collection)

{

$c1 = new $collection(['id' => 1, 'first_word' => 'Hello']);

$c2 = new $collection(['ID' => 123, 'foo_bar' => 'Hello']);

// demonstrate that diffKeys wont support case insensitivity

$this->assertEquals(['id'=>1, 'first_word'=> 'Hello'], $c1->diffKeys($c2)->all());

// allow for case insensitive difference