DoublyLinkedListTest - Code Metrics - Inspection of "removed from Scrutinizer the folder tests" - SiroDiaz/DataStructures - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 4b3449...8131a6 )

by Siro Díaz

created 2017-06-22 21:41 UTC

DoublyLinkedListTest A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	221
Duplicated Lines	71.49 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

Metric	Value
wmc	23
lcom	1
cbo	2
dl	158
loc	221
rs	10
c	0
b	0
f	0

How to fix Duplicated Code

<?php

namespace DataStructures\Tests\Lists;

use DataStructures\Lists\DoublyLinkedList;
use PHPUnit\Framework\TestCase;

class DoublyLinkedListTest extends TestCase {
    private $list;

    public function setUp() {
        $this->list = new DoublyLinkedList();
    }

    public function testSize() {
        $this->assertEquals($this->list->size(), 0);
        $this->list->push(true);
        $this->list->push(2);
        $this->assertEquals($this->list->size(), 2);
    }

    public function testEmpty() {
        $this->assertTrue($this->list->empty());
    }

    public function testPush() {
        $this->list->push(20);
        $this->assertEquals(1, $this->list->size());
        $this->assertEquals(20, $this->list->get(0));
        $this->list->push(true);
        
        $this->assertEquals(2, $this->list->size());
        
        $this->assertTrue($this->list->get(1));
        
        $this->list->push(30);
        $this->assertEquals(20, $this->list->get(0));
        $this->assertEquals(30, $this->list->get(1));
        $this->assertEquals(true, $this->list->get(2));
    }

    public function testGetLast() {
        $this->assertNull($this->list->getLast());
        $this->list->push(true);
        $this->list->push(50);
        $this->list->push("string");
        $this->assertEquals("string", $this->list->getLast());
    }

    public function testInsert() {
        $this->list->insert(0, 100);
        $this->assertEquals(100, $this->list->get(0));
        $this->assertEquals(1, $this->list->size());
        
        $this->list->insert(0, 200);
        $this->assertEquals(2, $this->list->size());
        $this->assertEquals(200, $this->list->get(0));
        $this->assertEquals(100, $this->list->get(1));
        $this->assertEquals(100, $this->list->getLast());
        
        $this->list->insert(1, 300);
        $this->assertEquals(3, $this->list->size());
        $this->assertEquals(200, $this->list->get(0));
        $this->assertEquals(300, $this->list->get(1));
        $this->assertEquals(100, $this->list->get(2));
        $this->list->insert(2, 1000);
        $this->assertEquals(1000, $this->list->get(2));
        $this->assertEquals(100, $this->list->get(3));
        $this->list->insert(6, true);
        $this->assertTrue($this->list->get(4));
        $this->assertEquals(5, $this->list->size());
    }
    
    public function testDeleteException() {
        $this->expectException(\OutOfBoundsException::class);
        $this->list->delete(10);
    }
    
    public function testDelete() {
        $this->list->push(20);
        $this->list->push(true);
        $this->list->push(15);
        $this->list->push(3.14);
        $this->list->push("string");
        
        $this->assertEquals($this->list->delete(4), "string");
        $this->assertEquals(3.14, $this->list->delete(3));
        
        $this->assertEquals(3, $this->list->size());
        $this->assertEquals(true, $this->list->delete(1));
        $this->assertEquals(false, $this->list->empty());
        $this->assertEquals(20, $this->list->delete(0));
    }
    
    public function testShift() {
        $this->assertNull($this->list->shift());
        $this->list->push(20);
        $this->list->push(true);
        $this->assertEquals(20, $this->list->shift());
        $this->assertEquals(1, $this->list->size());
        $this->assertEquals(true, $this->list->shift());
        $this->assertEquals(true, $this->list->empty());
        $this->assertNull($this->list->shift());
    }
    
    public function testPop() {
        $this->list->push(20);
        $this->list->push(true);
        $this->list->push(15);
        $this->list->push(3.14);
        $this->list->push("string");
        
        $this->assertEquals($this->list->pop(), "string");
        $this->assertEquals(3.14, $this->list->pop());
        $this->list->insert(1, ['hello']);
        $this->assertEquals(15, $this->list->pop());
        $this->assertTrue($this->list->pop());
        $this->assertSame($this->list->pop(), ['hello']);
        $this->assertSame($this->list->pop(), 20);
        $this->assertTrue($this->list->empty());
    }
    
    public function testPopException() {
        $this->expectException(\OutOfBoundsException::class);
        $this->list->pop();
    }
    
    public function testUnshift() {
        $this->list->unshift(999);
        $this->assertEquals(1, $this->list->size());
        $this->assertEquals(999, $this->list->get(0));
        $this->assertEquals($this->list->getLast(), 999);
        $this->list->unshift(888);
        $this->assertEquals(2, $this->list->size());
        $this->assertEquals(888, $this->list->get(0));
        $this->assertEquals(999, $this->list->get(1));
        $this->assertEquals($this->list->getLast(), 999);
        $this->list->unshift(777);
        $this->assertEquals(3, $this->list->size());
        $this->assertEquals(777, $this->list->get(0));
        $this->assertEquals(888, $this->list->get(1));
        $this->assertEquals(999, $this->list->get(2));
        $this->assertEquals($this->list->getLast(), 999);
    }
    
    public function testGet() {
        $this->list->push(20);
        $this->list->push(true);
        $this->list->push(15);
        $this->list->push(3.14);
        $this->list->push("string");
        $this->assertEquals($this->list->get(0), 20);
        $this->assertTrue($this->list->get(1));
        $this->assertEquals($this->list->get(2), 15);
        $this->assertEquals($this->list->get(3), 3.14);
        $this->assertEquals($this->list->get(4), "string");
    }
    
    public function testGetWithException() {
        $this->expectException(\OutOfBoundsException::class);
        $this->list->get(5);
    }

    public function testGetOutOfBound() {
        $this->expectException(\OutOfBoundsException::class);
        $this->list->get(-1);
    }
    
    public function testGetAll() {
        foreach($this->list->getAll() as $node) {
            $this->assertNull($node);
        }
        
        $this->list->push(20);
        $this->list->push(true);
        $this->list->push(15);
        $this->list->push(3.14);
        $this->list->push("string");
        $data = [];
        foreach($this->list->getAll() as $node) {
            $data[] = $node;
        }
        $this->assertCount(5, $data);
        $this->assertSame([20, true, 15, 3.14, "string"], $data);
    }
    
    public function testToArray() {
        $this->list->push(20);
        $this->list->push(true);
        $this->list->push(15);
        $this->list->push(3.14);
        $this->list->push("string");
        $this->list->pop();
        $nodes = $this->list->toArray();
        $this->assertSame([20, true, 15, 3.14], $nodes);
    }
    
    public function testClear() {
        $this->list->push(20);
        $this->list->push(true);
        $this->list->push(15);
        $this->list->push(3.14);
        $this->list->push("string");
        $this->list->clear();
        $this->assertEmpty($this->list->toArray());
        $this->assertEquals($this->list->size(), 0);
    }

    public function testIterator() {
        $this->list->push(20);
        $this->list->push(true);
        $this->list->push(15);
        $this->list->push(3.14);
        $this->list->push("string");

        $this->list->shift();
        $expectedResult = [];
        $result = [];
        foreach($this->list->getAll() as $node) {
            $expectedResult[] = $node;
        }
        foreach($this->list as $index => $val) {
            $result[] = $val;
        }

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

1			<?php
2
3			namespace DataStructures\Tests\Lists;
4
5			use DataStructures\Lists\DoublyLinkedList;
6			use PHPUnit\Framework\TestCase;
7
8			class DoublyLinkedListTest extends TestCase {
9			private $list;
10
11			public function setUp() {
12			$this->list = new DoublyLinkedList();
13			}
14
15			public function testSize() {
16			$this->assertEquals($this->list->size(), 0);
17			$this->list->push(true);
18			$this->list->push(2);
19			$this->assertEquals($this->list->size(), 2);
20			}
21
22			public function testEmpty() {
23			$this->assertTrue($this->list->empty());
24			}
25
26			public function testPush() {
27			$this->list->push(20);
28			$this->assertEquals(1, $this->list->size());
29			$this->assertEquals(20, $this->list->get(0));
30			$this->list->push(true);
31
32			$this->assertEquals(2, $this->list->size());
33
34			$this->assertTrue($this->list->get(1));
35
36			$this->list->push(30);
37			$this->assertEquals(20, $this->list->get(0));
38			$this->assertEquals(30, $this->list->get(1));
39			$this->assertEquals(true, $this->list->get(2));
40			}
41
42			public function testGetLast() {
43			$this->assertNull($this->list->getLast());
44			$this->list->push(true);
45			$this->list->push(50);
46			$this->list->push("string");
47			$this->assertEquals("string", $this->list->getLast());
48			}
49
50			public function testInsert() {
51			$this->list->insert(0, 100);
52			$this->assertEquals(100, $this->list->get(0));
53			$this->assertEquals(1, $this->list->size());
54
55			$this->list->insert(0, 200);
56			$this->assertEquals(2, $this->list->size());
57			$this->assertEquals(200, $this->list->get(0));
58			$this->assertEquals(100, $this->list->get(1));
59			$this->assertEquals(100, $this->list->getLast());
60
61			$this->list->insert(1, 300);
62			$this->assertEquals(3, $this->list->size());
63			$this->assertEquals(200, $this->list->get(0));
64			$this->assertEquals(300, $this->list->get(1));
65			$this->assertEquals(100, $this->list->get(2));
66			$this->list->insert(2, 1000);
67			$this->assertEquals(1000, $this->list->get(2));
68			$this->assertEquals(100, $this->list->get(3));
69			$this->list->insert(6, true);
70			$this->assertTrue($this->list->get(4));
71			$this->assertEquals(5, $this->list->size());
72			}
73
74			public function testDeleteException() {
75			$this->expectException(\OutOfBoundsException::class);
76			$this->list->delete(10);
77			}
78
79			public function testDelete() {
80			$this->list->push(20);
81			$this->list->push(true);
82			$this->list->push(15);
83			$this->list->push(3.14);
84			$this->list->push("string");
85
86			$this->assertEquals($this->list->delete(4), "string");
87			$this->assertEquals(3.14, $this->list->delete(3));
88
89			$this->assertEquals(3, $this->list->size());
90			$this->assertEquals(true, $this->list->delete(1));
91			$this->assertEquals(false, $this->list->empty());
92			$this->assertEquals(20, $this->list->delete(0));
93			}
94
95			public function testShift() {
96			$this->assertNull($this->list->shift());
97			$this->list->push(20);
98			$this->list->push(true);
99			$this->assertEquals(20, $this->list->shift());
100			$this->assertEquals(1, $this->list->size());
101			$this->assertEquals(true, $this->list->shift());
102			$this->assertEquals(true, $this->list->empty());
103			$this->assertNull($this->list->shift());
104			}
105
106			public function testPop() {
107			$this->list->push(20);
108			$this->list->push(true);
109			$this->list->push(15);
110			$this->list->push(3.14);
111			$this->list->push("string");
112
113			$this->assertEquals($this->list->pop(), "string");
114			$this->assertEquals(3.14, $this->list->pop());
115			$this->list->insert(1, ['hello']);
116			$this->assertEquals(15, $this->list->pop());
117			$this->assertTrue($this->list->pop());
118			$this->assertSame($this->list->pop(), ['hello']);
119			$this->assertSame($this->list->pop(), 20);
120			$this->assertTrue($this->list->empty());
121			}
122
123			public function testPopException() {
124			$this->expectException(\OutOfBoundsException::class);
125			$this->list->pop();
126			}
127
128			public function testUnshift() {
129			$this->list->unshift(999);
130			$this->assertEquals(1, $this->list->size());
131			$this->assertEquals(999, $this->list->get(0));
132			$this->assertEquals($this->list->getLast(), 999);
133			$this->list->unshift(888);
134			$this->assertEquals(2, $this->list->size());
135			$this->assertEquals(888, $this->list->get(0));
136			$this->assertEquals(999, $this->list->get(1));
137			$this->assertEquals($this->list->getLast(), 999);
138			$this->list->unshift(777);
139			$this->assertEquals(3, $this->list->size());
140			$this->assertEquals(777, $this->list->get(0));
141			$this->assertEquals(888, $this->list->get(1));
142			$this->assertEquals(999, $this->list->get(2));
143			$this->assertEquals($this->list->getLast(), 999);
144			}
145
146			public function testGet() {
147			$this->list->push(20);
148			$this->list->push(true);
149			$this->list->push(15);
150			$this->list->push(3.14);
151			$this->list->push("string");
152			$this->assertEquals($this->list->get(0), 20);
153			$this->assertTrue($this->list->get(1));
154			$this->assertEquals($this->list->get(2), 15);
155			$this->assertEquals($this->list->get(3), 3.14);
156			$this->assertEquals($this->list->get(4), "string");
157			}
158
159			public function testGetWithException() {
160			$this->expectException(\OutOfBoundsException::class);
161			$this->list->get(5);
162			}
163
164			public function testGetOutOfBound() {
165			$this->expectException(\OutOfBoundsException::class);
166			$this->list->get(-1);
167			}
168
169			public function testGetAll() {
170			foreach($this->list->getAll() as $node) {
171			$this->assertNull($node);
172			}
173
174			$this->list->push(20);
175			$this->list->push(true);
176			$this->list->push(15);
177			$this->list->push(3.14);
178			$this->list->push("string");
179			$data = [];
180			foreach($this->list->getAll() as $node) {
181			$data[] = $node;
182			}
183			$this->assertCount(5, $data);
184			$this->assertSame([20, true, 15, 3.14, "string"], $data);
185			}
186
187			public function testToArray() {
188			$this->list->push(20);
189			$this->list->push(true);
190			$this->list->push(15);
191			$this->list->push(3.14);
192			$this->list->push("string");
193			$this->list->pop();
194			$nodes = $this->list->toArray();
195			$this->assertSame([20, true, 15, 3.14], $nodes);
196			}
197
198			public function testClear() {
199			$this->list->push(20);
200			$this->list->push(true);
201			$this->list->push(15);
202			$this->list->push(3.14);
203			$this->list->push("string");
204			$this->list->clear();
205			$this->assertEmpty($this->list->toArray());
206			$this->assertEquals($this->list->size(), 0);
207			}
208
209			public function testIterator() {
210			$this->list->push(20);
211			$this->list->push(true);
212			$this->list->push(15);
213			$this->list->push(3.14);
214			$this->list->push("string");
215
216			$this->list->shift();
217			$expectedResult = [];
218			$result = [];
219			foreach($this->list->getAll() as $node) {
220			$expectedResult[] = $node;
221			}
222			foreach($this->list as $index => $val) {
223			$result[] = $val;
224			}
225
226			$this->assertSame($expectedResult, $result);
227			}
228			}

SiroDiaz / DataStructures

Push — master ( 4b3449...8131a6 )

DoublyLinkedListTest A

Complexity

Size/Duplication

Coupling/Cohesion

Importance

How to fix Duplicated Code

Duplicated Code

Duplication Side-by-Side

Filter issues like