OXIESEC PANEL

Name	Size	Modified	Perms
📁 ..	-	08/12/2024 10:33:33 AM	rwxr-xr-x
📄 CollectionManipulationTest.php	26.22 KB	08/12/2024 10:33:33 AM	rw-r--r--
📄 CollectionTest.php	9.2 KB	08/12/2024 10:33:33 AM	rw-r--r--
📄 DoubleEndedQueueTest.php	16.31 KB	08/12/2024 10:33:33 AM	rw-r--r--
📄 GenericArrayTest.php	3.43 KB	08/12/2024 10:33:33 AM	rw-r--r--
📁 Map	-	08/12/2024 10:34:29 AM	rwxr-xr-x
📁 Mock	-	08/12/2024 10:34:29 AM	rwxr-xr-x
📄 QueueTest.php	7.51 KB	08/12/2024 10:33:33 AM	rw-r--r--
📄 SetTest.php	5.9 KB	08/12/2024 10:33:33 AM	rw-r--r--
📄 TestCase.php	415 bytes	08/12/2024 10:33:33 AM	rw-r--r--
📁 Tool	-	08/12/2024 10:36:07 AM	rwxr-xr-x
📄 TypesTest.php	858 bytes	08/12/2024 10:33:33 AM	rw-r--r--
📁 stubs	-	08/12/2024 10:34:29 AM	rwxr-xr-x
📁 types	-	08/12/2024 10:34:30 AM	rwxr-xr-x

Editing: CollectionTest.php

<?php

declare(strict_types=1);

namespace Ramsey\Collection\Test;

use Ramsey\Collection\Collection;
use Ramsey\Collection\Exception\InvalidArgumentException;
use Ramsey\Collection\Exception\InvalidPropertyOrMethod;
use Ramsey\Collection\Exception\NoSuchElementException;
use Ramsey\Collection\Exception\UnsupportedOperationException;
use Ramsey\Collection\Test\Mock\Bar;
use Ramsey\Collection\Test\Mock\BarCollection;
use Ramsey\Collection\Test\Mock\Foo;
use Ramsey\Collection\Test\Mock\FooCollection;
use stdClass;

use function serialize;
use function unserialize;

/**
 * Tests for Collection, as well as coverage for AbstractCollection
 */
class CollectionTest extends TestCase
{
    public function testConstructorSetsType(): void
    {
        $collection = new Collection('string');

$this->assertSame('string', $collection->getType());
    }

public function testConstructorWithData(): void
    {
        $collection = new Collection('string', ['foo', 'bar']);

$this->assertCount(2, $collection);
    }

public function testOffsetSet(): void
    {
        /** @var Collection<int> $collection */
        $collection = new Collection('integer');
        $collection[] = $this->faker->numberBetween();

// Ensure that an exception is thrown when attempting to add
        // an invalid type for this collection
        $this->expectException(InvalidArgumentException::class);
        $this->expectExceptionMessage('Value must be of type integer');

/**
         * @phpstan-ignore-next-line
         * @psalm-suppress InvalidArgument
         */
        $collection[] = $this->faker->text();
    }

public function testOffsetSetPosition(): void
    {
        $offset = $this->faker->numberBetween(0, 100);
        $value = $this->faker->numberBetween(0, 100);

/** @var Collection<int> $collection */
        $collection = new Collection('int');
        $collection->offsetSet($offset, $value);

$this->assertSame($value, $collection->offsetGet($offset));
    }

public function testAdd(): void
    {
        /** @var Collection<int> $collection */
        $collection = new Collection('integer');

$this->assertTrue($collection->add($this->faker->numberBetween()));
    }

public function testAddMayAddSameObjectMultipleTimes(): void
    {
        $expectedCount = 4;

$obj1 = new stdClass();
        $obj1->name = $this->faker->name();

/** @var Collection<stdClass> $collection1 */
        $collection1 = new Collection('stdClass');

/** @var Collection<stdClass> $collection2 */
        $collection2 = new Collection('stdClass');

// Add the same object multiple times
        for ($i = 0; $i < $expectedCount; $i++) {
            $collection1[] = $obj1;
        }

// Test the add() method
        for ($i = 0; $i < $expectedCount; $i++) {
            $collection2->add($obj1);
        }

$this->assertCount($expectedCount, $collection1);
        $this->assertCount($expectedCount, $collection2);
    }

public function testContains(): void
    {
        $name = $this->faker->name();

$obj1 = new stdClass();
        $obj1->name = $name;

// Object with same properties but different identity
        $obj2 = new stdClass();
        $obj2->name = $name;

/** @var Collection<stdClass> $collection */
        $collection = new Collection('stdClass');
        $collection->add($obj1);

$this->assertTrue($collection->contains($obj1));
        $this->assertFalse($collection->contains($obj2));
    }

public function testContainsNonStrict(): void
    {
        $name = $this->faker->name();

$obj1 = new stdClass();
        $obj1->name = $name;

// Object with same properties but different identity
        $obj2 = new stdClass();
        $obj2->name = $name;

/** @var Collection<stdClass> $collection */
        $collection = new Collection('stdClass');
        $collection->add($obj1);

$this->assertTrue($collection->contains($obj1, false));
        $this->assertTrue($collection->contains($obj2, false));
    }

public function testRemove(): void
    {
        $obj1 = new stdClass();
        $obj1->name = $this->faker->name();

/** @var Collection<stdClass> $collection */
        $collection = new Collection('stdClass');

// Add the same object multiple times
        $collection->add($obj1);
        $collection->add($obj1);
        $collection->add($obj1);

$this->assertTrue($collection->remove($obj1));
        $this->assertTrue($collection->remove($obj1));
        $this->assertTrue($collection->remove($obj1));
        $this->assertFalse($collection->remove($obj1));
    }

public function testSubclassBehavior(): void
    {
        $fooCollection = new FooCollection();

$fooCollection[] = new Foo();
        $fooCollection[] = new Foo();
        $fooCollection[] = new Foo();

$this->expectException(InvalidArgumentException::class);
        $this->expectExceptionMessage('Value must be of type ' . Foo::class);

/**
         * @phpstan-ignore-next-line
         * @psalm-suppress InvalidArgument
         */
        $fooCollection[] = new stdClass();
    }

public function testColumnByProperty(): void
    {
        $bar1 = new Bar(1, 'a');
        $bar2 = new Bar(2, 'b');
        $bar3 = new Bar(3, 'c');
        $barCollection = new BarCollection([$bar1, $bar2, $bar3]);

$this->assertSame(['a', 'b', 'c'], $barCollection->column('name'));
    }

public function testColumnByMethod(): void
    {
        $bar1 = new Bar(1, 'a');
        $bar2 = new Bar(2, 'b');
        $bar3 = new Bar(3, 'c');
        $barCollection = new BarCollection([$bar1, $bar2, $bar3]);

$this->assertSame([1, 2, 3], $barCollection->column('getId'));
    }

public function testColumnByArrayKey(): void
    {
        /** @var Collection<array{id: int, name: string}> $collection */
        $collection = new Collection('array', [
            ['id' => 1, 'name' => 'a'],
            ['id' => 2, 'name' => 'b'],
            ['id' => 3, 'name' => 'c'],
        ]);

$this->assertSame([1, 2, 3], $collection->column('id'));
        $this->assertSame(['a', 'b', 'c'], $collection->column('name'));
    }

public function testColumnShouldRaiseExceptionOnUndefinedPropertyOrMethod(): void
    {
        $bar1 = new Bar(1, 'a');
        $barCollection = new BarCollection([$bar1]);

$this->expectException(InvalidPropertyOrMethod::class);
        $this->expectExceptionMessage('Method or property "fu" not defined in Ramsey\Collection\Test\Mock\Bar');

$barCollection->column('fu');
    }

public function testColumnShouldRaiseExceptionWhenNotSupported(): void
    {
        /** @var Collection<int> $collection */
        $collection = new Collection('int', [1, 2, 3, 4]);

$this->expectException(UnsupportedOperationException::class);
        $this->expectExceptionMessage('The collection type "int" does not support the $propertyOrMethod parameter');

$collection->column('foo');
    }

public function testFirstShouldRaiseExceptionOnEmptyCollection(): void
    {
        $barCollection = new BarCollection();

$this->expectException(NoSuchElementException::class);
        $this->expectExceptionMessage('Can\'t determine first item. Collection is empty');
        $barCollection->first();
    }

public function testFirst(): void
    {
        $bar1 = new Bar(1, 'a');
        $bar2 = new Bar(2, 'b');
        $bar3 = new Bar(3, 'c');
        $barCollection = new BarCollection([$bar1, $bar2, $bar3]);

$this->assertSame($bar1, $barCollection->first());
        // Make sure the collection stays unchanged
        $this->assertSame([$bar1, $bar2, $bar3], $barCollection->toArray());
    }

public function testLastShouldRaiseExceptionOnEmptyCollection(): void
    {
        $barCollection = new BarCollection();

$this->expectException(NoSuchElementException::class);
        $this->expectExceptionMessage('Can\'t determine last item. Collection is empty');
        $barCollection->last();
    }

public function testLast(): void
    {
        $bar1 = new Bar(1, 'a');
        $bar2 = new Bar(2, 'b');
        $bar3 = new Bar(3, 'c');
        $barCollection = new BarCollection([$bar1, $bar2, $bar3]);

$this->assertSame($bar3, $barCollection->last());
        // Make sure the collection stays unchanged
        $this->assertSame([$bar1, $bar2, $bar3], $barCollection->toArray());
    }

public function testSerializable(): void
    {
        $bar1 = new Bar(1, 'a');
        $bar2 = new Bar(2, 'b');
        $bar3 = new Bar(3, 'c');
        $barCollection = new BarCollection([$bar1, $bar2, $bar3]);

$collectionSerialized = serialize($barCollection);
        $barCollection2 = unserialize($collectionSerialized);

$this->assertInstanceOf(BarCollection::class, $barCollection2);
        $this->assertContainsOnlyInstancesOf(Bar::class, $barCollection2);
        $this->assertEquals($barCollection, $barCollection2);
    }
}