FunctionsTest::testThrowWhenJoiningOnNonStringSet() - Code Metrics - Inspection of "update documentation" - Innmind/Immutable - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — develop ( 7af216...ebf010 )

by Baptiste

created 2019-12-08 17:13 UTC

testThrowWhenJoiningOnNonStringSet() A

↳ Parent: FunctionsTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	3
nc	1
nop	0
dl	0
loc	6
rs	10
c	0
b	0
f	0

<?php
declare(strict_types = 1);

namespace Tests\Innmind\Immutable;

use function Innmind\Immutable\{
    assertSet,
filter:
    dependency_paths: ["lib/*"]
    assertSequence,
filter:
    dependency_paths: ["lib/*"]
    assertMap,
filter:
    dependency_paths: ["lib/*"]
    unwrap,
filter:
    dependency_paths: ["lib/*"]
    join,
filter:
    dependency_paths: ["lib/*"]
    first,
filter:
    dependency_paths: ["lib/*"]
};
use Innmind\Immutable\{
    Set,
    Sequence,
    Map,
    Str,
    Exception\EmptySet,
};
use PHPUnit\Framework\TestCase;

class FunctionsTest extends TestCase
{
    public function testAssertSet()
    {
        $this->assertNull(assertSet('string', Set::of('string'), 42));
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {

        $this->expectException(\TypeError::class);
        $this->expectExceptionMessage('Argument 42 must be of type Set<string>, Set<int> given');

        assertSet('string', Set::of('int'), 42);
    }

    public function testAssertSequence()
    {
        $this->assertNull(assertSequence('string', Sequence::of('string'), 42));
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {

        $this->expectException(\TypeError::class);
        $this->expectExceptionMessage('Argument 42 must be of type Sequence<string>, Sequence<int> given');

        assertSequence('string', Sequence::of('int'), 42);
    }

    public function testAssertMap()
    {
        $this->assertNull(assertMap('string', 'int', Map::of('string', 'int'), 42));
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {

        $this->expectException(\TypeError::class);
        $this->expectExceptionMessage('Argument 42 must be of type Map<string, int>, Map<string, string> given');

        assertMap('string', 'int', Map::of('string', 'string'), 42);
    }

    public function testUnwrapSet()
    {
        $this->assertSame(
            [1, 2, 3],
            unwrap(Set::ints(1, 2, 3)),
        );
    }

    public function testUnwrapSequence()
    {
        $this->assertSame(
            [1, 2, 3],
            unwrap(Sequence::ints(1, 2, 3)),
            unwrap(/** @scrutinizer ignore-type */ Sequence::ints(1, 2, 3)),
        );
    }

    public function testThrowWhenUnwrappingNotOfExpectedType()
    {
        $this->expectException(\TypeError::class);
        $this->expectExceptionMessage('Argument 1 must be of type Set|Sequence, stdClass given');

        unwrap(new \stdClass);
        unwrap(/** @scrutinizer ignore-type */ new \stdClass);
    }

    public function testThrowWhenJoiningNotOfExpectedType()
    {
        $this->expectException(\TypeError::class);
        $this->expectExceptionMessage('Argument 2 must be of type Set|Sequence, stdClass given');

        join('|', new \stdClass);
        join('|', /** @scrutinizer ignore-type */ new \stdClass);
    }

    public function testThrowWhenJoiningOnNonStringSet()
    {
        $this->expectException(\TypeError::class);
        $this->expectExceptionMessage('Argument 2 must be of type Set<string>, Set<int> given');

        join('|', Set::of('int'));
    }

    public function testThrowWhenJoiningOnNonStringSequence()
    {
        $this->expectException(\TypeError::class);
        $this->expectExceptionMessage('Argument 2 must be of type Sequence<string>, Sequence<int> given');

        join('|', Sequence::of('int'));
        join('|', /** @scrutinizer ignore-type */ Sequence::of('int'));
    }

    public function testJoinSet()
    {
        $str = join('|', Set::of('string', '1', '2', '3'));

        $this->assertInstanceOf(Str::class, $str);
        $this->assertSame('1|2|3', $str->toString());
    }

    public function testJoinSequence()
    {
        $str = join('|', Sequence::of('string', '1', '2', '3'));
        $str = join('|', /** @scrutinizer ignore-type */ Sequence::of('string', '1', '2', '3'));

        $this->assertInstanceOf(Str::class, $str);
        $this->assertSame('1|2|3', $str->toString());
    }

    public function testThrowWhenTryingToAccessFirstValueOfAnEmptySet()
    {
        $this->expectException(EmptySet::class);

        first(Set::of('int'));
    }

    public function testAccessFirstValueOfASet()
    {
        $this->assertSame(null, first(Set::mixed(null, 1, '')));
        $this->assertSame('', first(Set::mixed('', 1, null)));
        $this->assertSame(false, first(Set::mixed(false, 1, null)));
        $this->assertSame(0, first(Set::mixed(0, 1, null)));
        $this->assertSame(42, first(Set::mixed(42, 1, null)));
    }
}


Innmind / Immutable

GitHub Access Token became invalid

Push — develop ( 7af216...ebf010 )

testThrowWhenJoiningOnNonStringSet() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like