CollectionResolverTest::testResolvingArrayCollectionWithKeyAndTooManyWhitespace() - Code Metrics - Inspection of "Remove unused variable" - phpDocumentor/TypeResolver - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 70fdb3...522edb )

by Jaap

created 2019-03-29 21:30 UTC

testResolvingArrayCollectionWithKeyAndTooManyWhitespace() A

↳ Parent: CollectionResolverTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php declare(strict_types=1);
/**
 * This file is part of phpDocumentor.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * @copyright 2010-2018 Mike van Riel<[email protected]>
 * @license   http://www.opensource.org/licenses/mit-license.php MIT
 * @link      http://phpdoc.org
 */

namespace phpDocumentor\Reflection;

use phpDocumentor\Reflection\Types\Array_;
use phpDocumentor\Reflection\Types\Collection;
use phpDocumentor\Reflection\Types\Compound;
use phpDocumentor\Reflection\Types\Context;
use phpDocumentor\Reflection\Types\Object_;
use PHPUnit\Framework\TestCase;

/**
 * @covers ::<private>
 * @coversDefaultClass phpDocumentor\Reflection\TypeResolver
 */
class CollectionResolverTest extends TestCase
{
    /**
     * @covers ::__construct
     * @covers ::resolve
     *
     * @uses \phpDocumentor\Reflection\Types\Context
     * @uses \phpDocumentor\Reflection\Types\Compound
     * @uses \phpDocumentor\Reflection\Types\Collection
     * @uses \phpDocumentor\Reflection\Types\String_
     */
    public function testResolvingCollection()
    {
        $fixture = new TypeResolver();

        /** @var Collection $resolvedType */
        $resolvedType = $fixture->resolve('ArrayObject<string>', new Context(''));

        $this->assertInstanceOf(Collection::class, $resolvedType);
        $this->assertSame('\\ArrayObject<string>', (string) $resolvedType);

        $this->assertEquals('\\ArrayObject', (string) $resolvedType->getFqsen());

        /** @var Array_ $valueType */
        $valueType = $resolvedType->getValueType();

        /** @var Compound $keyType */
        $keyType = $resolvedType->getKeyType();

        $this->assertInstanceOf(Types\String_::class, $valueType);
        $this->assertInstanceOf(Types\Compound::class, $keyType);
    }

    /**
     * @covers ::__construct
     * @covers ::resolve
     *
     * @uses \phpDocumentor\Reflection\Types\Context
     * @uses \phpDocumentor\Reflection\Types\Compound
     * @uses \phpDocumentor\Reflection\Types\Collection
     * @uses \phpDocumentor\Reflection\Types\String_
     */
    public function testResolvingCollectionWithKeyType()
    {
        $fixture = new TypeResolver();

        /** @var Collection $resolvedType */
        $resolvedType = $fixture->resolve('ArrayObject<string[],Iterator>', new Context(''));

        $this->assertInstanceOf(Collection::class, $resolvedType);
        $this->assertSame('\\ArrayObject<string[],\\Iterator>', (string) $resolvedType);

        $this->assertEquals('\\ArrayObject', (string) $resolvedType->getFqsen());

        /** @var Object_ $valueType */
        $valueType = $resolvedType->getValueType();

        /** @var Array_ $keyType */
        $keyType = $resolvedType->getKeyType();

        $this->assertInstanceOf(Types\Object_::class, $valueType);
        $this->assertEquals('\\Iterator', (string) $valueType->getFqsen());
        $this->assertInstanceOf(Types\Array_::class, $keyType);
        $this->assertInstanceOf(Types\String_::class, $keyType->getValueType());
    }

    /**
     * @covers ::__construct
     * @covers ::resolve
     *
     * @uses \phpDocumentor\Reflection\Types\Context
     * @uses \phpDocumentor\Reflection\Types\Compound
     * @uses \phpDocumentor\Reflection\Types\Collection
     * @uses \phpDocumentor\Reflection\Types\String_
     */
    public function testResolvingArrayCollection()
    {
        $fixture = new TypeResolver();

        /** @var Collection $resolvedType */
        $resolvedType = $fixture->resolve('array<string>', new Context(''));

        $this->assertInstanceOf(Array_::class, $resolvedType);
        $this->assertSame('string[]', (string) $resolvedType);

        /** @var Array_ $valueType */
        $valueType = $resolvedType->getValueType();

        /** @var Compound $keyType */
        $keyType = $resolvedType->getKeyType();

        $this->assertInstanceOf(Types\String_::class, $valueType);
        $this->assertInstanceOf(Types\Compound::class, $keyType);
    }

    /**
     * @covers ::__construct
     * @covers ::resolve
     *
     * @uses \phpDocumentor\Reflection\Types\Context
     * @uses \phpDocumentor\Reflection\Types\Compound
     * @uses \phpDocumentor\Reflection\Types\Collection
     * @uses \phpDocumentor\Reflection\Types\String_
     */
    public function testResolvingArrayCollectionWithKey()
    {
        $fixture = new TypeResolver();

        /** @var Collection $resolvedType */
        $resolvedType = $fixture->resolve('array<string,object|array>', new Context(''));

        $this->assertInstanceOf(Array_::class, $resolvedType);
        $this->assertSame('array<string,object|array>', (string) $resolvedType);

        /** @var Array_ $valueType */
        $valueType = $resolvedType->getValueType();

        /** @var Compound $keyType */
        $keyType = $resolvedType->getKeyType();

        $this->assertInstanceOf(Types\String_::class, $keyType);
        $this->assertInstanceOf(Types\Compound::class, $valueType);
    }

    /**
     * @covers ::__construct
     * @covers ::resolve
     *
     * @uses \phpDocumentor\Reflection\Types\Context
     * @uses \phpDocumentor\Reflection\Types\Compound
     * @uses \phpDocumentor\Reflection\Types\Collection
     * @uses \phpDocumentor\Reflection\Types\String_
     */
    public function testResolvingArrayCollectionWithKeyAndWhitespace()
    {
        $fixture = new TypeResolver();

        /** @var Collection $resolvedType */
        $resolvedType = $fixture->resolve('array<string, object|array>', new Context(''));

        $this->assertInstanceOf(Array_::class, $resolvedType);
        $this->assertSame('array<string,object|array>', (string) $resolvedType);

        /** @var Array_ $valueType */
        $valueType = $resolvedType->getValueType();

        /** @var Compound $keyType */
        $keyType = $resolvedType->getKeyType();

        $this->assertInstanceOf(Types\String_::class, $keyType);
        $this->assertInstanceOf(Types\Compound::class, $valueType);
    }

    /**
     * @covers ::__construct
     * @covers ::resolve
     * 
     * @expectedException \InvalidArgumentException
     *
     * @uses \phpDocumentor\Reflection\Types\Context
     * @uses \phpDocumentor\Reflection\Types\Compound
     * @uses \phpDocumentor\Reflection\Types\Collection
     * @uses \phpDocumentor\Reflection\Types\String_
     */
    public function testResolvingArrayCollectionWithKeyAndTooManyWhitespace()
    {
        $fixture = new TypeResolver();

        $fixture->resolve('array<string,  object|array>', new Context(''));
    }

    /**
     * @covers ::__construct
     * @covers ::resolve
     *
     * @uses \phpDocumentor\Reflection\Types\Context
     * @uses \phpDocumentor\Reflection\Types\Compound
     * @uses \phpDocumentor\Reflection\Types\Collection
     * @uses \phpDocumentor\Reflection\Types\String_
     */
    public function testResolvingCollectionOfCollection()
    {
        $fixture = new TypeResolver();

        /** @var Collection $resolvedType */
        $resolvedType = $fixture->resolve('ArrayObject<string|integer|double,ArrayObject<DateTime>>', new Context(''));

        $this->assertInstanceOf(Collection::class, $resolvedType);
        $this->assertSame('\\ArrayObject<string|int|float,\\ArrayObject<\\DateTime>>', (string) $resolvedType);

        $this->assertEquals('\\ArrayObject', (string) $resolvedType->getFqsen());

        /** @var Collection $valueType */
        $valueType = $resolvedType->getValueType();
        /** @var Object_ $collectionValueType */
        $collectionValueType = $valueType->getValueType();
        $this->assertInstanceOf(Types\Collection::class, $valueType);
        $this->assertInstanceOf(Types\Object_::class, $valueType->getValueType());
        $this->assertEquals('\\ArrayObject', (string) $valueType->getFqsen());
        $this->assertEquals('\\DateTime', (string) $collectionValueType->getFqsen());

        /** @var Compound $keyType */
        $keyType = $resolvedType->getKeyType();
        $this->assertInstanceOf(Types\Compound::class, $keyType);
        $this->assertInstanceOf(Types\String_::class, $keyType->get(0));
        $this->assertInstanceOf(Types\Integer::class, $keyType->get(1));
        $this->assertInstanceOf(Types\Float_::class, $keyType->get(2));
    }

    /**
     * @covers ::__construct
     * @covers ::resolve
     * @expectedException \RuntimeException
     * @expectedExceptionMessage An array can have only integers or strings as keys
     */
    public function testBadArrayCollectionKey()
    {
        $fixture = new TypeResolver();
        $fixture->resolve('array<object,string>', new Context(''));
    }

    /**
     * @covers ::__construct
     * @covers ::resolve
     * @expectedException \RuntimeException
     * @expectedExceptionMessage Unexpected collection operator "<", class name is missing
     */
    public function testMissingStartCollection()
    {
        $fixture = new TypeResolver();
        $fixture->resolve('<string>', new Context(''));
    }

    /**
     * @covers ::__construct
     * @covers ::resolve
     * @expectedException \RuntimeException
     * @expectedExceptionMessage Collection: ">" is missing
     */
    public function testMissingEndCollection()
    {
        $fixture = new TypeResolver();
        $fixture->resolve('ArrayObject<object|string', new Context(''));
    }

    /**
     * @covers ::__construct
     * @covers ::resolve
     * @expectedException \RuntimeException
     * @expectedExceptionMessage string is not a collection
     */
    public function testBadCollectionClass()
    {
        $fixture = new TypeResolver();
        $fixture->resolve('string<integer>', new Context(''));
    }

    /**
     * @covers ::__construct
     * @covers ::resolve
     *
     * @uses \phpDocumentor\Reflection\Types\Context
     * @uses \phpDocumentor\Reflection\Types\Compound
     * @uses \phpDocumentor\Reflection\Types\Collection
     * @uses \phpDocumentor\Reflection\Types\String_
     */
    public function testResolvingCollectionAsArray()
    {
        $fixture = new TypeResolver();

        /** @var Collection $resolvedType */
        $resolvedType = $fixture->resolve('array<string,float>', new Context(''));

        $this->assertInstanceOf(Array_::class, $resolvedType);
        $this->assertSame('array<string,float>', (string) $resolvedType);

        /** @var Array_ $valueType */
        $valueType = $resolvedType->getValueType();

        /** @var Compound $keyType */
        $keyType = $resolvedType->getKeyType();

        $this->assertInstanceOf(Types\Float_::class, $valueType);
        $this->assertInstanceOf(Types\String_::class, $keyType);
    }
}


1			<?php declare(strict_types=1);
2			/**
3			* This file is part of phpDocumentor.
4			*
5			* For the full copyright and license information, please view the LICENSE
6			* file that was distributed with this source code.
7			*
8			* @copyright 2010-2018 Mike van Riel<[email protected]>
9			* @license http://www.opensource.org/licenses/mit-license.php MIT
10			* @link http://phpdoc.org
11			*/
12
13			namespace phpDocumentor\Reflection;
14
15			use phpDocumentor\Reflection\Types\Array_;
16			use phpDocumentor\Reflection\Types\Collection;
17			use phpDocumentor\Reflection\Types\Compound;
18			use phpDocumentor\Reflection\Types\Context;
19			use phpDocumentor\Reflection\Types\Object_;
20			use PHPUnit\Framework\TestCase;
21
22			/**
23			* @covers ::<private>
24			* @coversDefaultClass phpDocumentor\Reflection\TypeResolver
25			*/
26			class CollectionResolverTest extends TestCase
27			{
28			/**
29			* @covers ::__construct
30			* @covers ::resolve
31			*
32			* @uses \phpDocumentor\Reflection\Types\Context
33			* @uses \phpDocumentor\Reflection\Types\Compound
34			* @uses \phpDocumentor\Reflection\Types\Collection
35			* @uses \phpDocumentor\Reflection\Types\String_
36			*/
37			public function testResolvingCollection()
38			{
39			$fixture = new TypeResolver();
40
41			/** @var Collection $resolvedType */
42			$resolvedType = $fixture->resolve('ArrayObject<string>', new Context(''));
43
44			$this->assertInstanceOf(Collection::class, $resolvedType);
45			$this->assertSame('\\ArrayObject<string>', (string) $resolvedType);
46
47			$this->assertEquals('\\ArrayObject', (string) $resolvedType->getFqsen());
48
49			/** @var Array_ $valueType */
50			$valueType = $resolvedType->getValueType();
51
52			/** @var Compound $keyType */
53			$keyType = $resolvedType->getKeyType();
54
55			$this->assertInstanceOf(Types\String_::class, $valueType);
56			$this->assertInstanceOf(Types\Compound::class, $keyType);
57			}
58
59			/**
60			* @covers ::__construct
61			* @covers ::resolve
62			*
63			* @uses \phpDocumentor\Reflection\Types\Context
64			* @uses \phpDocumentor\Reflection\Types\Compound
65			* @uses \phpDocumentor\Reflection\Types\Collection
66			* @uses \phpDocumentor\Reflection\Types\String_
67			*/
68			public function testResolvingCollectionWithKeyType()
69			{
70			$fixture = new TypeResolver();
71
72			/** @var Collection $resolvedType */
73			$resolvedType = $fixture->resolve('ArrayObject<string[],Iterator>', new Context(''));
74
75			$this->assertInstanceOf(Collection::class, $resolvedType);
76			$this->assertSame('\\ArrayObject<string[],\\Iterator>', (string) $resolvedType);
77
78			$this->assertEquals('\\ArrayObject', (string) $resolvedType->getFqsen());
79
80			/** @var Object_ $valueType */
81			$valueType = $resolvedType->getValueType();
82
83			/** @var Array_ $keyType */
84			$keyType = $resolvedType->getKeyType();
85
86			$this->assertInstanceOf(Types\Object_::class, $valueType);
87			$this->assertEquals('\\Iterator', (string) $valueType->getFqsen());
88			$this->assertInstanceOf(Types\Array_::class, $keyType);
89			$this->assertInstanceOf(Types\String_::class, $keyType->getValueType());
90			}
91
92			/**
93			* @covers ::__construct
94			* @covers ::resolve
95			*
96			* @uses \phpDocumentor\Reflection\Types\Context
97			* @uses \phpDocumentor\Reflection\Types\Compound
98			* @uses \phpDocumentor\Reflection\Types\Collection
99			* @uses \phpDocumentor\Reflection\Types\String_
100			*/
101			public function testResolvingArrayCollection()
102			{
103			$fixture = new TypeResolver();
104
105			/** @var Collection $resolvedType */
106			$resolvedType = $fixture->resolve('array<string>', new Context(''));
107
108			$this->assertInstanceOf(Array_::class, $resolvedType);
109			$this->assertSame('string[]', (string) $resolvedType);
110
111			/** @var Array_ $valueType */
112			$valueType = $resolvedType->getValueType();
113
114			/** @var Compound $keyType */
115			$keyType = $resolvedType->getKeyType();
116
117			$this->assertInstanceOf(Types\String_::class, $valueType);
118			$this->assertInstanceOf(Types\Compound::class, $keyType);
119			}
120
121			/**
122			* @covers ::__construct
123			* @covers ::resolve
124			*
125			* @uses \phpDocumentor\Reflection\Types\Context
126			* @uses \phpDocumentor\Reflection\Types\Compound
127			* @uses \phpDocumentor\Reflection\Types\Collection
128			* @uses \phpDocumentor\Reflection\Types\String_
129			*/
130			public function testResolvingArrayCollectionWithKey()
131			{
132			$fixture = new TypeResolver();
133
134			/** @var Collection $resolvedType */
135			$resolvedType = $fixture->resolve('array<string,object\|array>', new Context(''));
136
137			$this->assertInstanceOf(Array_::class, $resolvedType);
138			$this->assertSame('array<string,object\|array>', (string) $resolvedType);
139
140			/** @var Array_ $valueType */
141			$valueType = $resolvedType->getValueType();
142
143			/** @var Compound $keyType */
144			$keyType = $resolvedType->getKeyType();
145
146			$this->assertInstanceOf(Types\String_::class, $keyType);
147			$this->assertInstanceOf(Types\Compound::class, $valueType);
148			}
149
150			/**
151			* @covers ::__construct
152			* @covers ::resolve
153			*
154			* @uses \phpDocumentor\Reflection\Types\Context
155			* @uses \phpDocumentor\Reflection\Types\Compound
156			* @uses \phpDocumentor\Reflection\Types\Collection
157			* @uses \phpDocumentor\Reflection\Types\String_
158			*/
159			public function testResolvingArrayCollectionWithKeyAndWhitespace()
160			{
161			$fixture = new TypeResolver();
162
163			/** @var Collection $resolvedType */
164			$resolvedType = $fixture->resolve('array<string, object\|array>', new Context(''));
165
166			$this->assertInstanceOf(Array_::class, $resolvedType);
167			$this->assertSame('array<string,object\|array>', (string) $resolvedType);
168
169			/** @var Array_ $valueType */
170			$valueType = $resolvedType->getValueType();
171
172			/** @var Compound $keyType */
173			$keyType = $resolvedType->getKeyType();
174
175			$this->assertInstanceOf(Types\String_::class, $keyType);
176			$this->assertInstanceOf(Types\Compound::class, $valueType);
177			}
178
179			/**
180			* @covers ::__construct
181			* @covers ::resolve
182			*
183			* @expectedException \InvalidArgumentException
184			*
185			* @uses \phpDocumentor\Reflection\Types\Context
186			* @uses \phpDocumentor\Reflection\Types\Compound
187			* @uses \phpDocumentor\Reflection\Types\Collection
188			* @uses \phpDocumentor\Reflection\Types\String_
189			*/
190			public function testResolvingArrayCollectionWithKeyAndTooManyWhitespace()
191			{
192			$fixture = new TypeResolver();
193
194			$fixture->resolve('array<string, object\|array>', new Context(''));
195			}
196
197			/**
198			* @covers ::__construct
199			* @covers ::resolve
200			*
201			* @uses \phpDocumentor\Reflection\Types\Context
202			* @uses \phpDocumentor\Reflection\Types\Compound
203			* @uses \phpDocumentor\Reflection\Types\Collection
204			* @uses \phpDocumentor\Reflection\Types\String_
205			*/
206			public function testResolvingCollectionOfCollection()
207			{
208			$fixture = new TypeResolver();
209
210			/** @var Collection $resolvedType */
211			$resolvedType = $fixture->resolve('ArrayObject<string\|integer\|double,ArrayObject<DateTime>>', new Context(''));
212
213			$this->assertInstanceOf(Collection::class, $resolvedType);
214			$this->assertSame('\\ArrayObject<string\|int\|float,\\ArrayObject<\\DateTime>>', (string) $resolvedType);
215
216			$this->assertEquals('\\ArrayObject', (string) $resolvedType->getFqsen());
217
218			/** @var Collection $valueType */
219			$valueType = $resolvedType->getValueType();
220			/** @var Object_ $collectionValueType */
221			$collectionValueType = $valueType->getValueType();
222			$this->assertInstanceOf(Types\Collection::class, $valueType);
223			$this->assertInstanceOf(Types\Object_::class, $valueType->getValueType());
224			$this->assertEquals('\\ArrayObject', (string) $valueType->getFqsen());
225			$this->assertEquals('\\DateTime', (string) $collectionValueType->getFqsen());
226
227			/** @var Compound $keyType */
228			$keyType = $resolvedType->getKeyType();
229			$this->assertInstanceOf(Types\Compound::class, $keyType);
230			$this->assertInstanceOf(Types\String_::class, $keyType->get(0));
231			$this->assertInstanceOf(Types\Integer::class, $keyType->get(1));
232			$this->assertInstanceOf(Types\Float_::class, $keyType->get(2));
233			}
234
235			/**
236			* @covers ::__construct
237			* @covers ::resolve
238			* @expectedException \RuntimeException
239			* @expectedExceptionMessage An array can have only integers or strings as keys
240			*/
241			public function testBadArrayCollectionKey()
242			{
243			$fixture = new TypeResolver();
244			$fixture->resolve('array<object,string>', new Context(''));
245			}
246
247			/**
248			* @covers ::__construct
249			* @covers ::resolve
250			* @expectedException \RuntimeException
251			* @expectedExceptionMessage Unexpected collection operator "<", class name is missing
252			*/
253			public function testMissingStartCollection()
254			{
255			$fixture = new TypeResolver();
256			$fixture->resolve('<string>', new Context(''));
257			}
258
259			/**
260			* @covers ::__construct
261			* @covers ::resolve
262			* @expectedException \RuntimeException
263			* @expectedExceptionMessage Collection: ">" is missing
264			*/
265			public function testMissingEndCollection()
266			{
267			$fixture = new TypeResolver();
268			$fixture->resolve('ArrayObject<object\|string', new Context(''));
269			}
270
271			/**
272			* @covers ::__construct
273			* @covers ::resolve
274			* @expectedException \RuntimeException
275			* @expectedExceptionMessage string is not a collection
276			*/
277			public function testBadCollectionClass()
278			{
279			$fixture = new TypeResolver();
280			$fixture->resolve('string<integer>', new Context(''));
281			}
282
283			/**
284			* @covers ::__construct
285			* @covers ::resolve
286			*
287			* @uses \phpDocumentor\Reflection\Types\Context
288			* @uses \phpDocumentor\Reflection\Types\Compound
289			* @uses \phpDocumentor\Reflection\Types\Collection
290			* @uses \phpDocumentor\Reflection\Types\String_
291			*/
292			public function testResolvingCollectionAsArray()
293			{
294			$fixture = new TypeResolver();
295
296			/** @var Collection $resolvedType */
297			$resolvedType = $fixture->resolve('array<string,float>', new Context(''));
298
299			$this->assertInstanceOf(Array_::class, $resolvedType);
300			$this->assertSame('array<string,float>', (string) $resolvedType);
301
302			/** @var Array_ $valueType */
303			$valueType = $resolvedType->getValueType();
304
305			/** @var Compound $keyType */
306			$keyType = $resolvedType->getKeyType();
307
308			$this->assertInstanceOf(Types\Float_::class, $valueType);
309			$this->assertInstanceOf(Types\String_::class, $keyType);
310			}
311			}
312

phpDocumentor / TypeResolver

Push — master ( 70fdb3...522edb )

testResolvingArrayCollectionWithKeyAndTooManyWhitespace() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like