Yiisoft\Yii\Debug\Tests\Unit\DumperTest::jsonDataProvider()

Complexity

Conditions	1
Paths	1

Size

Total Lines	249
Code Lines	160

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

<?php
    public static function jsonDataProvider(): iterable
    {
        $emptyObject = new stdClass();
        $emptyObjectId = spl_object_id($emptyObject);

        yield 'empty object' => [
            $emptyObject,
            <<<S
                {"stdClass#{$emptyObjectId}":"{stateless object}"}
                S,
        ];

        // @formatter:off
        $shortFunctionObject = fn () => 1;
        // @formatter:on
        $shortFunctionObjectId = spl_object_id($shortFunctionObject);

$shortFunctionObject of type callable is incompatible with the type object expected by parameter $object of spl_object_id().

        yield 'short function' => [
            $shortFunctionObject,
            <<<S
                {"Closure#{$shortFunctionObjectId}":"fn () => 1"}
                S,
        ];

        // @formatter:off
        $staticShortFunctionObject = static fn () => 1;
        // @formatter:on
        $staticShortFunctionObjectId = spl_object_id($staticShortFunctionObject);

$staticShortFunctionObject of type callable is incompatible with the type object expected by parameter $object of spl_object_id().

        yield 'short static function' => [
            $staticShortFunctionObject,
            <<<S
                {"Closure#{$staticShortFunctionObjectId}":"static fn () => 1"}
                S,
        ];

        // @formatter:off
        $functionObject = function () {
            return 1;
        };
        // @formatter:on
        $functionObjectId = spl_object_id($functionObject);

$functionObject of type callable is incompatible with the type object expected by parameter $object of spl_object_id().

        yield 'function' => [
            $functionObject,
            <<<S
                {"Closure#{$functionObjectId}":"function () {\\n            return 1;\\n        }"}
                S,
        ];

        // @formatter:off
        $staticFunctionObject = static function () {
            return 1;
        };
        // @formatter:on
        $staticFunctionObjectId = spl_object_id($staticFunctionObject);

$staticFunctionObject of type callable is incompatible with the type object expected by parameter $object of spl_object_id().

        yield 'static function' => [
            $staticFunctionObject,
            <<<S
                {"Closure#{$staticFunctionObjectId}":"static function () {\\n            return 1;\\n        }"}
                S,
        ];
        yield 'string' => [
            'Hello, Yii!',
            '"Hello, Yii!"',
        ];
        yield 'empty string' => [
            '',
            '""',
        ];
        yield 'null' => [
            null,
            'null',
        ];
        yield 'integer' => [
            1,
            '1',
        ];
        yield 'integer with separator' => [
            1_23_456,

The constant Yiisoft\Yii\Debug\Tests\Unit\1_23_456 was not found. Maybe you did not declare it correctly or list all dependencies?

            '123456',
        ];
        yield 'boolean' => [
            true,
            'true',
        ];
        yield 'fileResource' => [
            fopen('php://input', 'rb'),
            '{"timed_out":false,"blocked":true,"eof":false,"wrapper_type":"PHP","stream_type":"Input","mode":"rb","unread_bytes":0,"seekable":true,"uri":"php:\/\/input"}',
        ];
        yield 'empty array' => [
            [],
            '[]',
        ];
        yield 'array of 3 elements, automatic keys' => [
            [
                'one',
                'two',
                'three',
            ],
            '["one","two","three"]',
        ];
        yield 'array of 3 elements, custom keys' => [
            [
                2 => 'one',
                'two' => 'two',
                0 => 'three',
            ],
            '{"2":"one","two":"two","0":"three"}',
        ];

        // @formatter:off
        $closureInArrayObject = fn () => new \DateTimeZone('');
        // @formatter:on
        $closureInArrayObjectId = spl_object_id($closureInArrayObject);

$closureInArrayObject of type callable is incompatible with the type object expected by parameter $object of spl_object_id().

        yield 'closure in array' => [
            // @formatter:off
            [$closureInArrayObject],
            // @formatter:on
            <<<S
                [{"Closure#{$closureInArrayObjectId}":"fn () => new \\\DateTimeZone('')"}]
                S,
        ];

        // @formatter:off
        $closureWithUsualClassNameObject = fn (Dumper $date) => new \DateTimeZone('');

The parameter $date is not used and could be removed.

        // @formatter:on
        $closureWithUsualClassNameObjectId = spl_object_id($closureWithUsualClassNameObject);

$closureWithUsualClassNameObject of type callable is incompatible with the type object expected by parameter $object of spl_object_id().

        yield 'original class name' => [
            $closureWithUsualClassNameObject,
            <<<S
                {"Closure#{$closureWithUsualClassNameObjectId}":"fn (\\\Yiisoft\\\Yii\\\Debug\\\Dumper \$date) => new \\\DateTimeZone('')"}
                S,
        ];

        // @formatter:off
        $closureWithAliasedClassNameObject = fn (Dumper $date) => new \DateTimeZone('');

The parameter $date is not used and could be removed.

        // @formatter:on
        $closureWithAliasedClassNameObjectId = spl_object_id($closureWithAliasedClassNameObject);

$closureWithAliasedClassNameObject of type callable is incompatible with the type object expected by parameter $object of spl_object_id().

        yield 'class alias' => [
            $closureWithAliasedClassNameObject,
            <<<S
                {"Closure#{$closureWithAliasedClassNameObjectId}":"fn (\\\Yiisoft\\\Yii\\\Debug\\\Dumper \$date) => new \\\DateTimeZone('')"}
                S,
        ];

        // @formatter:off
        $closureWithAliasedNamespaceObject = fn (D\Dumper $date) => new \DateTimeZone('');

The parameter $date is not used and could be removed.

        // @formatter:on
        $closureWithAliasedNamespaceObjectId = spl_object_id($closureWithAliasedNamespaceObject);

$closureWithAliasedNamespaceObject of type callable is incompatible with the type object expected by parameter $object of spl_object_id().

        yield 'namespace alias' => [
            $closureWithAliasedNamespaceObject,
            <<<S
                {"Closure#{$closureWithAliasedNamespaceObjectId}":"fn (\\\Yiisoft\\\Yii\\\Debug\\\Dumper \$date) => new \\\DateTimeZone('')"}
                S,
        ];
        // @formatter:off
        $closureWithNullCollisionOperatorObject = fn () => $_ENV['var'] ?? null;
        // @formatter:on
        $closureWithNullCollisionOperatorObjectId = spl_object_id($closureWithNullCollisionOperatorObject);

$closureWithNullCollisionOperatorObject of type callable is incompatible with the type object expected by parameter $object of spl_object_id().

        yield 'closure with null-collision operator' => [
            $closureWithNullCollisionOperatorObject,
            <<<S
                {"Closure#{$closureWithNullCollisionOperatorObjectId}":"fn () => \$_ENV['var'] ?? null"}
                S,
        ];
        yield 'utf8 supported' => [
            '🤣',
            '"🤣"',
        ];


        $objectWithClosureInProperty = new stdClass();
        // @formatter:off
        $objectWithClosureInProperty->a = fn () => 1;
        // @formatter:on
        $objectWithClosureInPropertyId = spl_object_id($objectWithClosureInProperty);
        $objectWithClosureInPropertyClosureId = spl_object_id($objectWithClosureInProperty->a);

$objectWithClosureInProperty->a of type callable is incompatible with the type object expected by parameter $object of spl_object_id().

        yield 'closure in property supported' => [
            $objectWithClosureInProperty,
            <<<S
                {"stdClass#{$objectWithClosureInPropertyId}":{"public \$a":{"Closure#{$objectWithClosureInPropertyClosureId}":"fn () => 1"}}}
                S,
        ];
        yield 'binary string' => [
            pack('H*', md5('binary string')),
            '"ɍ��^��\u00191\u0017�]�-f�"',
        ];


        $fileResource = tmpfile();
        $fileResourceUri = stream_get_meta_data($fileResource)['uri'];
        $fileResourceUri = addcslashes($fileResourceUri, '/\\');

        yield 'file resource' => [
            $fileResource,
            <<<S
                {"timed_out":false,"blocked":true,"eof":false,"wrapper_type":"plainfile","stream_type":"STDIO","mode":"r+b","unread_bytes":0,"seekable":true,"uri":"{$fileResourceUri}"}
                S,
        ];

        $closedFileResource = tmpfile();
        fclose($closedFileResource);

        yield 'closed file resource' => [
            $closedFileResource,
            '"{closed resource}"',
        ];

        $opendirResource = opendir(sys_get_temp_dir());

        yield 'opendir resource' => [
            $opendirResource,
            <<<S
                {"timed_out":false,"blocked":true,"eof":false,"wrapper_type":"plainfile","stream_type":"dir","mode":"r","unread_bytes":0,"seekable":true}
                S,
        ];

        $curlResource = curl_init('https://example.com');
        $curlResourceObjectId = spl_object_id($curlResource);

It seems like $curlResource can also be of type resource; however, parameter $object of spl_object_id() does only seem to accept object, maybe add an additional type check?

        yield 'curl resource' => [
            $curlResource,
            <<<S
                {"CurlHandle#{$curlResourceObjectId}":"{stateless object}"}
                S,
        ];
        yield 'stdout' => [
            STDOUT,
            <<<S
                {"timed_out":false,"blocked":true,"eof":false,"wrapper_type":"PHP","stream_type":"STDIO","mode":"wb","unread_bytes":0,"seekable":false,"uri":"php:\/\/stdout"}
                S,
        ];
        yield 'stderr' => [
            STDERR,
            <<<S
                {"timed_out":false,"blocked":true,"eof":false,"wrapper_type":"PHP","stream_type":"STDIO","mode":"wb","unread_bytes":0,"seekable":false,"uri":"php:\/\/stderr"}
                S,
        ];
        yield 'stdin' => [
            STDIN,
            <<<S
                {"timed_out":false,"blocked":true,"eof":false,"wrapper_type":"PHP","stream_type":"STDIO","mode":"rb","unread_bytes":0,"seekable":false,"uri":"php:\/\/stdin"}