anonymous//tests/Iterator/CombineIteratorTest.php$0 - Code Metrics - Inspection of "Fixed project name iterable-functions" - jasny/improved-php-iterable - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Branch — master (01ba0d)

by Arnold

created 2018-09-25 02:02 UTC

anonymous//tests/Iterator/CombineIteratorTest.php$0 A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	4
Duplicated Lines	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
wmc	1

<?php

namespace Jasny\Tests\Iterator;

use Jasny\Iterator\CombineIterator;
use Jasny\Tests\LazyExecutionIteratorTrait;
use PHPUnit\Framework\TestCase;

/**
 * @covers \Jasny\Iterator\CombineIterator
 */
class CombineIteratorTest extends TestCase
{
    use LazyExecutionIteratorTrait;

    public function testIterate()
    {
        $assoc = ['one' => 'uno', 'two' => 'dos', 'three' => 'tres', 'four' => 'cuatro', 'five' => 'cinco'];

        $keys = array_keys($assoc);
        $values = array_values($assoc);

        $iterator = new CombineIterator($keys, $values);

        $result = iterator_to_array($iterator);

        $this->assertSame($assoc, $result);
    }

    public function testIterateIgnoreKeys()
    {
        $keys = ['I', 'II', 'III', 'IV', 'V'];
        $values = ['one' => 'uno', 'two' => 'dos', 'three' => 'tres', 'four' => 'cuatro', 'five' => 'cinco'];

        $iterator = new CombineIterator($keys, $values);

        $result = iterator_to_array($iterator);

        $expected = ['I' => 'uno', 'II' => 'dos', 'III' => 'tres', 'IV' => 'cuatro', 'V' => 'cinco'];
        $this->assertSame($expected, $result);
    }

    public function testIterateNotUnique()
    {
        $keys = ['foo', 'bar', 'qux', 'foo'];
        $values = ['one', 'two', 'three', 'four'];

        $iterator = new CombineIterator($keys, $values);

        $resultKeys = [];
        $resultValues = [];

        foreach ($iterator as $key => $value) {
            $resultKeys[] = $key;
            $resultValues[] = $value;
        }

        $this->assertSame($keys, $resultKeys);
        $this->assertSame($values, $resultValues);
    }

    public function testIterateMixedKeys()
    {
        $keys = [null, new \stdClass(), ['hello', 'world'], 5.2];
        $values = ['one', 'two', 'three', 'four'];

        $iterator = new CombineIterator($keys, $values);

        $resultKeys = [];
        $resultValues = [];

        foreach ($iterator as $key => $value) {
            $resultKeys[] = $key;
            $resultValues[] = $value;
        }

        $this->assertSame($keys, $resultKeys);
        $this->assertSame($values, $resultValues);
    }

    public function testIterateLesKeys()
    {
        $keys = ['foo', 'bar', 'qux'];
        $values = ['one', 'two', 'three', 'four', 'five'];

        $iterator = new CombineIterator($keys, $values);

        $result = iterator_to_array($iterator);

        $expected = ['foo' => 'one', 'bar' => 'two', 'qux' => 'three'];
        $this->assertSame($expected, $result);
    }

    public function testIterateLessValues()
    {
        $keys = ['foo', 'bar', 'qux', 'zoo', 'wut'];
        $values = ['one', 'two', 'three'];

        $iterator = new CombineIterator($keys, $values);

        $result = iterator_to_array($iterator);

        $expected = ['foo' => 'one', 'bar' => 'two', 'qux' => 'three', 'zoo' => null, 'wut' => null];
        $this->assertSame($expected, $result);
    }

    public function testIterateIterator()
    {
        $assoc = ['one' => 'uno', 'two' => 'dos', 'three' => 'tres', 'four' => 'cuatro', 'five' => 'cinco'];

        $keysInner = new \ArrayIterator(array_keys($assoc));
        $valuesInner = new \ArrayIterator(array_values($assoc));

        $iterator = new CombineIterator($keysInner, $valuesInner);

        $result = iterator_to_array($iterator);

        $this->assertSame($assoc, $result);
    }

    public function testIterateArrayObject()
    {
        $values = ['one' => 'uno', 'two' => 'dos', 'three' => 'tres', 'four' => 'cuatro', 'five' => 'cinco'];

        $keysInner = new \ArrayObject(array_keys($values));
        $valuesInner = new \ArrayObject(array_values($values));

        $iterator = new CombineIterator($keysInner, $valuesInner);

        $result = iterator_to_array($iterator);

        $this->assertSame($values, $result);
    }

    public function testNestedIteratorAggregate()
    {
        $keys = new class() implements \IteratorAggregate {
            public function getIterator()
            {
                return new \ArrayObject(['I', 'II', 'III']);
            }
        };

        $values = new class() implements \IteratorAggregate {
            public function getIterator()
            {
                return new \ArrayObject(['uno', 'dos', 'tres']);
            }
        };

        $iterator = new CombineIterator($keys, $values);

        $result = iterator_to_array($iterator);

        $expected = ['I' => 'uno', 'II' => 'dos', 'III' => 'tres'];
        $this->assertSame($expected, $result);
    }

    public function testIterateEmpty()
    {
        $iterator = new CombineIterator(new \EmptyIterator(), new \EmptyIterator());

        $result = iterator_to_array($iterator);

        $this->assertEquals([], $result);
    }

    /**
     * Test that nothing happens when not iterating
     */
    public function testLazyExecution()
    {
        $keys = $this->createLazyExecutionIterator();
        $values = new \ArrayIterator(range(0, 10));

        new CombineIterator($keys, $values);

        $this->assertTrue(true, "No warning");
    }
}


1			<?php
2
3			namespace Jasny\Tests\Iterator;
4
5			use Jasny\Iterator\CombineIterator;
6			use Jasny\Tests\LazyExecutionIteratorTrait;
7			use PHPUnit\Framework\TestCase;
8
9			/**
10			* @covers \Jasny\Iterator\CombineIterator
11			*/
12			class CombineIteratorTest extends TestCase
13			{
14			use LazyExecutionIteratorTrait;
15
16			public function testIterate()
17			{
18			$assoc = ['one' => 'uno', 'two' => 'dos', 'three' => 'tres', 'four' => 'cuatro', 'five' => 'cinco'];
19
20			$keys = array_keys($assoc);
21			$values = array_values($assoc);
22
23			$iterator = new CombineIterator($keys, $values);
24
25			$result = iterator_to_array($iterator);
26
27			$this->assertSame($assoc, $result);
28			}
29
30			public function testIterateIgnoreKeys()
31			{
32			$keys = ['I', 'II', 'III', 'IV', 'V'];
33			$values = ['one' => 'uno', 'two' => 'dos', 'three' => 'tres', 'four' => 'cuatro', 'five' => 'cinco'];
34
35			$iterator = new CombineIterator($keys, $values);
36
37			$result = iterator_to_array($iterator);
38
39			$expected = ['I' => 'uno', 'II' => 'dos', 'III' => 'tres', 'IV' => 'cuatro', 'V' => 'cinco'];
40			$this->assertSame($expected, $result);
41			}
42
43			public function testIterateNotUnique()
44			{
45			$keys = ['foo', 'bar', 'qux', 'foo'];
46			$values = ['one', 'two', 'three', 'four'];
47
48			$iterator = new CombineIterator($keys, $values);
49
50			$resultKeys = [];
51			$resultValues = [];
52
53			foreach ($iterator as $key => $value) {
54			$resultKeys[] = $key;
55			$resultValues[] = $value;
56			}
57
58			$this->assertSame($keys, $resultKeys);
59			$this->assertSame($values, $resultValues);
60			}
61
62			public function testIterateMixedKeys()
63			{
64			$keys = [null, new \stdClass(), ['hello', 'world'], 5.2];
65			$values = ['one', 'two', 'three', 'four'];
66
67			$iterator = new CombineIterator($keys, $values);
68
69			$resultKeys = [];
70			$resultValues = [];
71
72			foreach ($iterator as $key => $value) {
73			$resultKeys[] = $key;
74			$resultValues[] = $value;
75			}
76
77			$this->assertSame($keys, $resultKeys);
78			$this->assertSame($values, $resultValues);
79			}
80
81			public function testIterateLesKeys()
82			{
83			$keys = ['foo', 'bar', 'qux'];
84			$values = ['one', 'two', 'three', 'four', 'five'];
85
86			$iterator = new CombineIterator($keys, $values);
87
88			$result = iterator_to_array($iterator);
89
90			$expected = ['foo' => 'one', 'bar' => 'two', 'qux' => 'three'];
91			$this->assertSame($expected, $result);
92			}
93
94			public function testIterateLessValues()
95			{
96			$keys = ['foo', 'bar', 'qux', 'zoo', 'wut'];
97			$values = ['one', 'two', 'three'];
98
99			$iterator = new CombineIterator($keys, $values);
100
101			$result = iterator_to_array($iterator);
102
103			$expected = ['foo' => 'one', 'bar' => 'two', 'qux' => 'three', 'zoo' => null, 'wut' => null];
104			$this->assertSame($expected, $result);
105			}
106
107			public function testIterateIterator()
108			{
109			$assoc = ['one' => 'uno', 'two' => 'dos', 'three' => 'tres', 'four' => 'cuatro', 'five' => 'cinco'];
110
111			$keysInner = new \ArrayIterator(array_keys($assoc));
112			$valuesInner = new \ArrayIterator(array_values($assoc));
113
114			$iterator = new CombineIterator($keysInner, $valuesInner);
115
116			$result = iterator_to_array($iterator);
117
118			$this->assertSame($assoc, $result);
119			}
120
121			public function testIterateArrayObject()
122			{
123			$values = ['one' => 'uno', 'two' => 'dos', 'three' => 'tres', 'four' => 'cuatro', 'five' => 'cinco'];
124
125			$keysInner = new \ArrayObject(array_keys($values));
126			$valuesInner = new \ArrayObject(array_values($values));
127
128			$iterator = new CombineIterator($keysInner, $valuesInner);
129
130			$result = iterator_to_array($iterator);
131
132			$this->assertSame($values, $result);
133			}
134
135			public function testNestedIteratorAggregate()
136			{
137			$keys = new class() implements \IteratorAggregate {
138			public function getIterator()
139			{
140			return new \ArrayObject(['I', 'II', 'III']);
141			}
142			};
143
144			$values = new class() implements \IteratorAggregate {
145			public function getIterator()
146			{
147			return new \ArrayObject(['uno', 'dos', 'tres']);
148			}
149			};
150
151			$iterator = new CombineIterator($keys, $values);
152
153			$result = iterator_to_array($iterator);
154
155			$expected = ['I' => 'uno', 'II' => 'dos', 'III' => 'tres'];
156			$this->assertSame($expected, $result);
157			}
158
159			public function testIterateEmpty()
160			{
161			$iterator = new CombineIterator(new \EmptyIterator(), new \EmptyIterator());
162
163			$result = iterator_to_array($iterator);
164
165			$this->assertEquals([], $result);
166			}
167
168			/**
169			* Test that nothing happens when not iterating
170			*/
171			public function testLazyExecution()
172			{
173			$keys = $this->createLazyExecutionIterator();
174			$values = new \ArrayIterator(range(0, 10));
175
176			new CombineIterator($keys, $values);
177
178			$this->assertTrue(true, "No warning");
179			}
180			}
181

jasny / improved-php-iterable

Branch — master (01ba0d)

anonymous//tests/Iterator/CombineIteratorTest.php$0 A

Complexity

Size/Duplication

Importance

Duplication Side-by-Side

Filter issues like