Mirrors/wiosna-dev_common-library
1
0
Fork 1
mirror of https://github.com/wiosna-dev/common-library.git synced 2026-03-12 01:31:45 +01:00
Code Issues Packages Projects Releases Wiki Activity

Minor refactoring

Browse Source
This commit is contained in:
Meritoo
2019-03-04 18:52:56 +01:00
parent 2247000a8a
commit c175fcd126
19 changed files with 82 additions and 80 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/Collection/Collection.php
View File

@@ -263,7 +263,7 @@ class Collection implements Countable, ArrayAccess, IteratorAggregate
} }
/** /**
* Returns an array representation of the collection * Returns representation of object as array
* *
* @return array * @return array
*/ */

2
src/ValueObject/Version.php
View File

@@ -88,7 +88,7 @@ class Version
} }
/** /**
* Returns string representation of instance of this class * Returns representation of object as string
* *
* @return string * @return string
*/ */

98
tests/Collection/CollectionTest.php
View File

@@ -45,12 +45,12 @@ class CollectionTest extends BaseTestCase
public function testEmptyCollection() public function testEmptyCollection()
{ {
static::assertEquals(0, $this->emptyCollection->count()); static::assertSame(0, $this->emptyCollection->count());
static::assertCount(0, $this->emptyCollection); static::assertCount(0, $this->emptyCollection);
static::assertEmpty($this->emptyCollection); static::assertEmpty($this->emptyCollection);
static::assertTrue($this->emptyCollection->isEmpty()); static::assertTrue($this->emptyCollection->isEmpty());
static::assertEquals([], $this->emptyCollection->toArray()); static::assertSame([], $this->emptyCollection->toArray());
static::assertEmpty($this->emptyCollection->toArray()); static::assertEmpty($this->emptyCollection->toArray());
static::assertNull($this->emptyCollection->getFirst()); static::assertNull($this->emptyCollection->getFirst());
@@ -61,23 +61,23 @@ class CollectionTest extends BaseTestCase
public function testNotEmptyCollection() public function testNotEmptyCollection()
{ {
static::assertEquals(4, $this->simpleCollection->count()); static::assertSame(4, $this->simpleCollection->count());
static::assertCount(4, $this->simpleCollection); static::assertCount(4, $this->simpleCollection);
static::assertNotEmpty($this->simpleCollection); static::assertNotEmpty($this->simpleCollection);
static::assertFalse($this->simpleCollection->isEmpty()); static::assertFalse($this->simpleCollection->isEmpty());
static::assertEquals($this->simpleElements, $this->simpleCollection->toArray()); static::assertSame($this->simpleElements, $this->simpleCollection->toArray());
static::assertNotEmpty($this->simpleCollection->toArray()); static::assertNotEmpty($this->simpleCollection->toArray());
static::assertEquals('lorem', $this->simpleCollection->getFirst()); static::assertSame('lorem', $this->simpleCollection->getFirst());
static::assertEquals('sit', $this->simpleCollection->getLast()); static::assertSame('sit', $this->simpleCollection->getLast());
static::assertEquals('dolor', $this->simpleCollection[123]); static::assertSame('dolor', $this->simpleCollection[123]);
} }
public function testCount() public function testCount()
{ {
static::assertEquals(0, $this->emptyCollection->count()); static::assertSame(0, $this->emptyCollection->count());
static::assertEquals(4, $this->simpleCollection->count()); static::assertSame(4, $this->simpleCollection->count());
} }
public function testOffsetExists() public function testOffsetExists()
@@ -94,8 +94,8 @@ class CollectionTest extends BaseTestCase
static::assertNull($this->emptyCollection['abc']); static::assertNull($this->emptyCollection['abc']);
static::assertNull($this->simpleCollection['abc']); static::assertNull($this->simpleCollection['abc']);
static::assertEquals('lorem', $this->simpleCollection[0]); static::assertSame('lorem', $this->simpleCollection[0]);
static::assertEquals('sit', $this->simpleCollection[345]); static::assertSame('sit', $this->simpleCollection[345]);
} }
public function testOffsetSet() public function testOffsetSet()
@@ -104,10 +104,10 @@ class CollectionTest extends BaseTestCase
$this->simpleCollection['test2'] = 5678; $this->simpleCollection['test2'] = 5678;
static::assertTrue($this->emptyCollection->has(1234)); static::assertTrue($this->emptyCollection->has(1234));
static::assertEquals(1234, $this->emptyCollection['test1']); static::assertSame(1234, $this->emptyCollection['test1']);
static::assertTrue($this->simpleCollection->has(5678)); static::assertTrue($this->simpleCollection->has(5678));
static::assertEquals(5678, $this->simpleCollection['test2']); static::assertSame(5678, $this->simpleCollection['test2']);
} }
public function testOffsetUnset() public function testOffsetUnset()
@@ -115,14 +115,14 @@ class CollectionTest extends BaseTestCase
unset($this->simpleCollection[0]); unset($this->simpleCollection[0]);
static::assertFalse($this->simpleCollection->has('lorem')); static::assertFalse($this->simpleCollection->has('lorem'));
static::assertEquals('ipsum', $this->simpleCollection[1]); static::assertSame('ipsum', $this->simpleCollection[1]);
static::assertEquals(3, $this->simpleCollection->count()); static::assertSame(3, $this->simpleCollection->count());
unset($this->simpleCollection[123]); unset($this->simpleCollection[123]);
static::assertFalse($this->simpleCollection->has('dolor')); static::assertFalse($this->simpleCollection->has('dolor'));
static::assertEquals('ipsum', $this->simpleCollection[1]); static::assertSame('ipsum', $this->simpleCollection[1]);
static::assertEquals(2, $this->simpleCollection->count()); static::assertSame(2, $this->simpleCollection->count());
} }
public function testGetIterator() public function testGetIterator()
@@ -143,8 +143,8 @@ class CollectionTest extends BaseTestCase
$collection->add($element); $collection->add($element);
static::assertTrue($collection->has($element)); static::assertTrue($collection->has($element));
static::assertEquals($expectedCount, $collection->count()); static::assertSame($expectedCount, $collection->count());
static::assertEquals($element, $collection[$expectedIndex]); static::assertSame($element, $collection[$expectedIndex]);
} }
/** /**
@@ -161,15 +161,15 @@ class CollectionTest extends BaseTestCase
$collection->add($element, $index); $collection->add($element, $index);
static::assertTrue($collection->has($element)); static::assertTrue($collection->has($element));
static::assertEquals($expectedCount, $collection->count()); static::assertSame($expectedCount, $collection->count());
static::assertEquals($element, $collection[$expectedIndex]); static::assertSame($element, $collection[$expectedIndex]);
} }
public function testAddMultipleUsingEmptyArray() public function testAddMultipleUsingEmptyArray()
{ {
$this->emptyCollection->addMultiple([]); $this->emptyCollection->addMultiple([]);
static::assertEquals(0, $this->emptyCollection->count()); static::assertSame(0, $this->emptyCollection->count());
static::assertTrue($this->emptyCollection->isEmpty()); static::assertTrue($this->emptyCollection->isEmpty());
} }
@@ -185,12 +185,12 @@ class CollectionTest extends BaseTestCase
$this->emptyCollection->addMultiple($elements); $this->emptyCollection->addMultiple($elements);
static::assertFalse($this->emptyCollection->isEmpty()); static::assertFalse($this->emptyCollection->isEmpty());
static::assertEquals(4, $this->emptyCollection->count()); static::assertSame(4, $this->emptyCollection->count());
static::assertEquals('test1', $this->emptyCollection[0]); static::assertSame('test1', $this->emptyCollection[0]);
static::assertEquals('test2', $this->emptyCollection[1]); static::assertSame('test2', $this->emptyCollection[1]);
static::assertEquals('test3', $this->emptyCollection[2]); static::assertSame('test3', $this->emptyCollection[2]);
static::assertEquals('test4', $this->emptyCollection[3]); static::assertSame('test4', $this->emptyCollection[3]);
} }
public function testAddMultipleUsingIndexes() public function testAddMultipleUsingIndexes()
@@ -205,12 +205,12 @@ class CollectionTest extends BaseTestCase
$this->emptyCollection->addMultiple($elements, true); $this->emptyCollection->addMultiple($elements, true);
static::assertFalse($this->emptyCollection->isEmpty()); static::assertFalse($this->emptyCollection->isEmpty());
static::assertEquals(4, $this->emptyCollection->count()); static::assertSame(4, $this->emptyCollection->count());
static::assertEquals('test1', $this->emptyCollection[0]); static::assertSame('test1', $this->emptyCollection[0]);
static::assertEquals('test2', $this->emptyCollection[1]); static::assertSame('test2', $this->emptyCollection[1]);
static::assertEquals('test3', $this->emptyCollection[1234]); static::assertSame('test3', $this->emptyCollection[1234]);
static::assertEquals('test4', $this->emptyCollection[5678]); static::assertSame('test4', $this->emptyCollection[5678]);
} }
public function testPrepend() public function testPrepend()
@@ -218,14 +218,14 @@ class CollectionTest extends BaseTestCase
$this->emptyCollection->prepend('lorem-ipsum'); $this->emptyCollection->prepend('lorem-ipsum');
static::assertFalse($this->emptyCollection->isEmpty()); static::assertFalse($this->emptyCollection->isEmpty());
static::assertEquals(1, $this->emptyCollection->count()); static::assertSame(1, $this->emptyCollection->count());
static::assertEquals('lorem-ipsum', $this->emptyCollection[0]); static::assertSame('lorem-ipsum', $this->emptyCollection[0]);
$this->simpleCollection->prepend('lorem-ipsum'); $this->simpleCollection->prepend('lorem-ipsum');
static::assertFalse($this->simpleCollection->isEmpty()); static::assertFalse($this->simpleCollection->isEmpty());
static::assertEquals(5, $this->simpleCollection->count()); static::assertSame(5, $this->simpleCollection->count());
static::assertEquals('lorem-ipsum', $this->simpleCollection[0]); static::assertSame('lorem-ipsum', $this->simpleCollection[0]);
} }
public function testRemoveNotExistingElement() public function testRemoveNotExistingElement()
@@ -233,24 +233,24 @@ class CollectionTest extends BaseTestCase
$this->emptyCollection->remove('abc'); $this->emptyCollection->remove('abc');
static::assertTrue($this->emptyCollection->isEmpty()); static::assertTrue($this->emptyCollection->isEmpty());
static::assertEquals(0, $this->emptyCollection->count()); static::assertSame(0, $this->emptyCollection->count());
$this->simpleCollection->remove('abc'); $this->simpleCollection->remove('abc');
static::assertFalse($this->simpleCollection->isEmpty()); static::assertFalse($this->simpleCollection->isEmpty());
static::assertEquals(4, $this->simpleCollection->count()); static::assertSame(4, $this->simpleCollection->count());
} }
public function testRemove() public function testRemove()
{ {
static::assertFalse($this->simpleCollection->isEmpty()); static::assertFalse($this->simpleCollection->isEmpty());
static::assertEquals(4, $this->simpleCollection->count()); static::assertSame(4, $this->simpleCollection->count());
static::assertEquals('ipsum', $this->simpleCollection[1]); static::assertSame('ipsum', $this->simpleCollection[1]);
$this->simpleCollection->remove('ipsum'); $this->simpleCollection->remove('ipsum');
static::assertFalse($this->simpleCollection->isEmpty()); static::assertFalse($this->simpleCollection->isEmpty());
static::assertEquals(3, $this->simpleCollection->count()); static::assertSame(3, $this->simpleCollection->count());
static::assertNull($this->simpleCollection[1]); static::assertNull($this->simpleCollection[1]);
} }
@@ -290,8 +290,8 @@ class CollectionTest extends BaseTestCase
static::assertNull($this->simpleCollection->getPrevious('abc')); static::assertNull($this->simpleCollection->getPrevious('abc'));
static::assertNull($this->simpleCollection->getPrevious('lorem')); static::assertNull($this->simpleCollection->getPrevious('lorem'));
static::assertEquals('lorem', $this->simpleCollection->getPrevious('ipsum')); static::assertSame('lorem', $this->simpleCollection->getPrevious('ipsum'));
static::assertEquals('dolor', $this->simpleCollection->getPrevious('sit')); static::assertSame('dolor', $this->simpleCollection->getPrevious('sit'));
} }
public function testGetNext() public function testGetNext()
@@ -300,26 +300,26 @@ class CollectionTest extends BaseTestCase
static::assertNull($this->simpleCollection->getNext('abc')); static::assertNull($this->simpleCollection->getNext('abc'));
static::assertNull($this->simpleCollection->getNext('sit')); static::assertNull($this->simpleCollection->getNext('sit'));
static::assertEquals('dolor', $this->simpleCollection->getNext('ipsum')); static::assertSame('dolor', $this->simpleCollection->getNext('ipsum'));
static::assertEquals('sit', $this->simpleCollection->getNext('dolor')); static::assertSame('sit', $this->simpleCollection->getNext('dolor'));
} }
public function testGetFirst() public function testGetFirst()
{ {
static::assertNull($this->emptyCollection->getFirst()); static::assertNull($this->emptyCollection->getFirst());
static::assertEquals('lorem', $this->simpleCollection->getFirst()); static::assertSame('lorem', $this->simpleCollection->getFirst());
} }
public function testGetLast() public function testGetLast()
{ {
static::assertNull($this->emptyCollection->getLast()); static::assertNull($this->emptyCollection->getLast());
static::assertEquals('sit', $this->simpleCollection->getLast()); static::assertSame('sit', $this->simpleCollection->getLast());
} }
public function testToArray() public function testToArray()
{ {
static::assertEquals([], $this->emptyCollection->toArray()); static::assertSame([], $this->emptyCollection->toArray());
static::assertEquals($this->simpleElements, $this->simpleCollection->toArray()); static::assertSame($this->simpleElements, $this->simpleCollection->toArray());
} }
public function testExistsVisibilityAndArguments() public function testExistsVisibilityAndArguments()

2
tests/Exception/Date/UnknownDatePartTypeExceptionTest.php
View File

@@ -37,7 +37,7 @@ class UnknownDatePartTypeExceptionTest extends BaseTestCase
public function testMessage($unknownDatePart, $value, $expectedMessage) public function testMessage($unknownDatePart, $value, $expectedMessage)
{ {
$exception = UnknownDatePartTypeException::createException($unknownDatePart, $value); $exception = UnknownDatePartTypeException::createException($unknownDatePart, $value);
static::assertEquals($expectedMessage, $exception->getMessage()); static::assertSame($expectedMessage, $exception->getMessage());
} }
/** /**

2
tests/Exception/File/EmptyFileExceptionTest.php
View File

@@ -35,7 +35,7 @@ class EmptyFileExceptionTest extends BaseTestCase
public function testMessage($emptyFilePath, $expectedMessage) public function testMessage($emptyFilePath, $expectedMessage)
{ {
$exception = EmptyFileException::create($emptyFilePath); $exception = EmptyFileException::create($emptyFilePath);
static::assertEquals($expectedMessage, $exception->getMessage()); static::assertSame($expectedMessage, $exception->getMessage());
} }
/** /**

2
tests/Exception/File/EmptyFilePathExceptionTest.php
View File

@@ -28,6 +28,6 @@ class EmptyFilePathExceptionTest extends BaseTestCase
public function testConstructorMessage() public function testConstructorMessage()
{ {
$exception = EmptyFilePathException::create(); $exception = EmptyFilePathException::create();
static::assertEquals('Path of the file is empty. Did you provide path of proper file?', $exception->getMessage()); static::assertSame('Path of the file is empty. Did you provide path of proper file?', $exception->getMessage());
} }
} }

2
tests/Exception/File/NotExistingFileExceptionTest.php
View File

@@ -35,7 +35,7 @@ class NotExistingFileExceptionTest extends BaseTestCase
public function testConstructorMessage($notExistingFilePath, $expectedMessage) public function testConstructorMessage($notExistingFilePath, $expectedMessage)
{ {
$exception = NotExistingFileException::create($notExistingFilePath); $exception = NotExistingFileException::create($notExistingFilePath);
static::assertEquals($expectedMessage, $exception->getMessage()); static::assertSame($expectedMessage, $exception->getMessage());
} }
/** /**

2
tests/Exception/Method/DisabledMethodExceptionTest.php
View File

@@ -37,7 +37,7 @@ class DisabledMethodExceptionTest extends BaseTestCase
public function testConstructorMessage($disabledMethod, $alternativeMethod, $expectedMessage) public function testConstructorMessage($disabledMethod, $alternativeMethod, $expectedMessage)
{ {
$exception = DisabledMethodException::create($disabledMethod, $alternativeMethod); $exception = DisabledMethodException::create($disabledMethod, $alternativeMethod);
static::assertEquals($expectedMessage, $exception->getMessage()); static::assertSame($expectedMessage, $exception->getMessage());
} }
/** /**

2
tests/Exception/Reflection/CannotResolveClassNameExceptionTest.php
View File

@@ -38,7 +38,7 @@ class CannotResolveClassNameExceptionTest extends BaseTestCase
public function testConstructorMessage($source, $forClass, $expectedMessage) public function testConstructorMessage($source, $forClass, $expectedMessage)
{ {
$exception = CannotResolveClassNameException::create($source, $forClass); $exception = CannotResolveClassNameException::create($source, $forClass);
static::assertEquals($expectedMessage, $exception->getMessage()); static::assertSame($expectedMessage, $exception->getMessage());
} }
/** /**

2
tests/Exception/Reflection/MissingChildClassesExceptionTest.php
View File

@@ -36,7 +36,7 @@ class MissingChildClassesExceptionTest extends BaseTestCase
public function testConstructorMessage($parentClass, $expectedMessage) public function testConstructorMessage($parentClass, $expectedMessage)
{ {
$exception = MissingChildClassesException::create($parentClass); $exception = MissingChildClassesException::create($parentClass);
static::assertEquals($expectedMessage, $exception->getMessage()); static::assertSame($expectedMessage, $exception->getMessage());
} }
/** /**

2
tests/Exception/Reflection/TooManyChildClassesExceptionTest.php
View File

@@ -37,7 +37,7 @@ class TooManyChildClassesExceptionTest extends BaseTestCase
public function testConstructorMessage($parentClass, array $childClasses, $expectedMessage) public function testConstructorMessage($parentClass, array $childClasses, $expectedMessage)
{ {
$exception = TooManyChildClassesException::create($parentClass, $childClasses); $exception = TooManyChildClassesException::create($parentClass, $childClasses);
static::assertEquals($expectedMessage, $exception->getMessage()); static::assertSame($expectedMessage, $exception->getMessage());
} }
/** /**

2
tests/Exception/Regex/IncorrectColorHexLengthExceptionTest.php
View File

@@ -35,7 +35,7 @@ class IncorrectColorHexLengthExceptionTest extends BaseTestCase
public function testConstructorMessage($color, $expectedMessage) public function testConstructorMessage($color, $expectedMessage)
{ {
$exception = IncorrectColorHexLengthException::create($color); $exception = IncorrectColorHexLengthException::create($color);
static::assertEquals($expectedMessage, $exception->getMessage()); static::assertSame($expectedMessage, $exception->getMessage());
} }
/** /**

2
tests/Exception/Regex/InvalidColorHexValueExceptionTest.php
View File

@@ -35,7 +35,7 @@ class InvalidColorHexValueExceptionTest extends BaseTestCase
public function testConstructorMessage($color, $expectedMessage) public function testConstructorMessage($color, $expectedMessage)
{ {
$exception = InvalidColorHexValueException::create($color); $exception = InvalidColorHexValueException::create($color);
static::assertEquals($expectedMessage, $exception->getMessage()); static::assertSame($expectedMessage, $exception->getMessage());
} }
/** /**

2
tests/Exception/Regex/InvalidHtmlAttributesExceptionTest.php
View File

@@ -35,7 +35,7 @@ class InvalidHtmlAttributesExceptionTest extends BaseTestCase
public function testConstructorMessage($htmlAttributes, $expectedMessage) public function testConstructorMessage($htmlAttributes, $expectedMessage)
{ {
$exception = InvalidHtmlAttributesException::create($htmlAttributes); $exception = InvalidHtmlAttributesException::create($htmlAttributes);
static::assertEquals($expectedMessage, $exception->getMessage()); static::assertSame($expectedMessage, $exception->getMessage());
} }
/** /**

2
tests/Exception/Regex/InvalidUrlExceptionTest.php
View File

@@ -35,7 +35,7 @@ class InvalidUrlExceptionTest extends BaseTestCase
public function testConstructorMessage($url, $expectedMessage) public function testConstructorMessage($url, $expectedMessage)
{ {
$exception = InvalidUrlException::create($url); $exception = InvalidUrlException::create($url);
static::assertEquals($expectedMessage, $exception->getMessage()); static::assertSame($expectedMessage, $exception->getMessage());
} }
/** /**

2
tests/Exception/Type/UnknownOopVisibilityTypeExceptionTest.php
View File

@@ -36,7 +36,7 @@ class UnknownOopVisibilityTypeExceptionTest extends BaseTestCase
public function testConstructorMessage($unknownType, $expectedMessage) public function testConstructorMessage($unknownType, $expectedMessage)
{ {
$exception = UnknownOopVisibilityTypeException::createException($unknownType); $exception = UnknownOopVisibilityTypeException::createException($unknownType);
static::assertEquals($expectedMessage, $exception->getMessage()); static::assertSame($expectedMessage, $exception->getMessage());
} }
/** /**

4
tests/Utilities/Arrays/SimpleToString.php
View File

@@ -35,7 +35,9 @@ class SimpleToString
} }
/** /**
* {@inheritdoc} * Returns representation of object as string
*
* @return string
*/ */
public function __toString() public function __toString()
{ {

8
tests/Utilities/ReflectionTest.php
View File

@@ -410,7 +410,7 @@ class ReflectionTest extends BaseTestCase
public function testGetMaxNumberConstant() public function testGetMaxNumberConstant()
{ {
static::assertEquals(5, Reflection::getMaxNumberConstant(H::class)); static::assertSame(5, Reflection::getMaxNumberConstant(H::class));
} }
public function testHasMethodUsingClassWithoutMethod() public function testHasMethodUsingClassWithoutMethod()
@@ -450,7 +450,7 @@ class ReflectionTest extends BaseTestCase
public function testGetConstantValue() public function testGetConstantValue()
{ {
static::assertEquals(H::LOREM, Reflection::getConstantValue(H::class, 'LOREM')); static::assertSame(H::LOREM, Reflection::getConstantValue(H::class, 'LOREM'));
} }
public function testIsInterfaceImplementedUsingClassWithoutInterface() public function testIsInterfaceImplementedUsingClassWithoutInterface()
@@ -484,7 +484,7 @@ class ReflectionTest extends BaseTestCase
static::assertInstanceOf(ReflectionProperty::class, $property); static::assertInstanceOf(ReflectionProperty::class, $property);
static::assertTrue($property->isPrivate()); static::assertTrue($property->isPrivate());
static::assertEquals('count', $property->getName()); static::assertSame('count', $property->getName());
} }
public function testGetPropertyUsingClassWithProtectedProperty() public function testGetPropertyUsingClassWithProtectedProperty()
@@ -493,7 +493,7 @@ class ReflectionTest extends BaseTestCase
static::assertInstanceOf(ReflectionProperty::class, $property); static::assertInstanceOf(ReflectionProperty::class, $property);
static::assertTrue($property->isProtected()); static::assertTrue($property->isProtected());
static::assertEquals('name', $property->getName()); static::assertSame('name', $property->getName());
} }
/** /**

22
tests/Utilities/RepositoryTest.php
View File

@@ -36,7 +36,7 @@ class RepositoryTest extends BaseTestCase
$items = []; $items = [];
Repository::replenishPositions($items); Repository::replenishPositions($items);
static::assertEquals([], $items); static::assertSame([], $items);
} }
public function testReplenishPositionsUsingNotSortableObjects() public function testReplenishPositionsUsingNotSortableObjects()
@@ -85,10 +85,10 @@ class RepositoryTest extends BaseTestCase
public function testReplenishPositionsUsingArraysWithoutExtremePosition(array $items) public function testReplenishPositionsUsingArraysWithoutExtremePosition(array $items)
{ {
Repository::replenishPositions($items); Repository::replenishPositions($items);
static::assertEquals($items, $items); static::assertSame($items, $items);
Repository::replenishPositions($items, false); Repository::replenishPositions($items, false);
static::assertEquals($items, $items); static::assertSame($items, $items);
} }
/** /**
@@ -101,7 +101,7 @@ class RepositoryTest extends BaseTestCase
public function testReplenishPositionsUsingArraysWithoutExtremePositionForce(array $items, $asLast, array $expected) public function testReplenishPositionsUsingArraysWithoutExtremePositionForce(array $items, $asLast, array $expected)
{ {
Repository::replenishPositions($items, $asLast, true); Repository::replenishPositions($items, $asLast, true);
static::assertEquals($expected, $items); static::assertSame($expected, $items);
} }
/** /**
@@ -114,7 +114,7 @@ class RepositoryTest extends BaseTestCase
public function testReplenishPositionsUsingArraysWithExtremePositionForce(array $items, $asLast, array $expected) public function testReplenishPositionsUsingArraysWithExtremePositionForce(array $items, $asLast, array $expected)
{ {
Repository::replenishPositions($items, $asLast, true); Repository::replenishPositions($items, $asLast, true);
static::assertEquals($expected, $items); static::assertSame($expected, $items);
} }
/** /**
@@ -124,10 +124,10 @@ class RepositoryTest extends BaseTestCase
public function testReplenishPositionsUsingObjectsWithoutExtremePosition(array $items) public function testReplenishPositionsUsingObjectsWithoutExtremePosition(array $items)
{ {
Repository::replenishPositions($items); Repository::replenishPositions($items);
static::assertEquals($items, $items); static::assertSame($items, $items);
Repository::replenishPositions($items, false); Repository::replenishPositions($items, false);
static::assertEquals($items, $items); static::assertSame($items, $items);
} }
/** /**
@@ -171,7 +171,7 @@ class RepositoryTest extends BaseTestCase
*/ */
public function testGetExtremePositionUsingArraysWithoutExtremePosition(array $items, $max, $expected) public function testGetExtremePositionUsingArraysWithoutExtremePosition(array $items, $max, $expected)
{ {
static::assertEquals($expected, Repository::getExtremePosition($items, $max)); static::assertSame($expected, Repository::getExtremePosition($items, $max));
} }
/** /**
@@ -183,7 +183,7 @@ class RepositoryTest extends BaseTestCase
*/ */
public function testGetExtremePositionUsingArraysWithExtremePosition(array $items, $max, $expected) public function testGetExtremePositionUsingArraysWithExtremePosition(array $items, $max, $expected)
{ {
static::assertEquals($expected, Repository::getExtremePosition($items, $max)); static::assertSame($expected, Repository::getExtremePosition($items, $max));
} }
/** /**
@@ -195,7 +195,7 @@ class RepositoryTest extends BaseTestCase
*/ */
public function testGetExtremePositionUsingObjectsWithoutExtremePosition(array $items, $max, $expected) public function testGetExtremePositionUsingObjectsWithoutExtremePosition(array $items, $max, $expected)
{ {
static::assertEquals($expected, Repository::getExtremePosition($items, $max)); static::assertSame($expected, Repository::getExtremePosition($items, $max));
} }
/** /**
@@ -207,7 +207,7 @@ class RepositoryTest extends BaseTestCase
*/ */
public function testGetExtremePositionUsingObjectsWithExtremePosition(array $items, $max, $expected) public function testGetExtremePositionUsingObjectsWithExtremePosition(array $items, $max, $expected)
{ {
static::assertEquals($expected, Repository::getExtremePosition($items, $max)); static::assertSame($expected, Repository::getExtremePosition($items, $max));
} }
public function testGetEntityOrderedQueryBuilderUsingDefaults() public function testGetEntityOrderedQueryBuilderUsingDefaults()