mageekguy\atoum\test\adapter\calls: lines coverage

92% of 953

OPs

99% of 149

Lines

77% of 166

Branches

63% of 80

Paths

Method	OPs	OPs %	Lines	Line %	Branches	Branches %	Paths	Path %
mageekguy\atoum\test\adapter\calls::__construct()	8	100%	2	100%	1	0%	1	100%
mageekguy\atoum\test\adapter\calls::__invoke()	6	100%	1	100%	1	100%	1	100%
mageekguy\atoum\test\adapter\calls::__toString()	11	100%	1	100%	1	100%	1	100%
mageekguy\atoum\test\adapter\calls::count()	6	100%	2	100%	1	100%	1	100%
mageekguy\atoum\test\adapter\calls::offsetSet()	23	100%	6	100%	4	100%	2	100%
mageekguy\atoum\test\adapter\calls::offsetGet()	17	100%	1	100%	1	100%	1	100%
mageekguy\atoum\test\adapter\calls::offsetUnset()	40	100%	7	100%	4	100%	2	100%
mageekguy\atoum\test\adapter\calls::offsetExists()	22	100%	1	100%	1	100%	1	100%
mageekguy\atoum\test\adapter\calls::getIterator()	15	100%	1	100%	1	100%	1	100%
mageekguy\atoum\test\adapter\calls::reset()	12	100%	3	100%	1	100%	1	100%
mageekguy\atoum\test\adapter\calls::setDecorator()	16	100%	2	100%	1	100%	1	100%
mageekguy\atoum\test\adapter\calls::getDecorator()	6	100%	1	100%	1	100%	1	100%
mageekguy\atoum\test\adapter\calls::addCall()	11	100%	1	100%	1	100%	1	100%
mageekguy\atoum\test\adapter\calls::removeCall()	48	81%	11	91%	7	71%	3	67%
mageekguy\atoum\test\adapter\calls::toArray()	28	100%	6	100%	5	100%	2	100%
mageekguy\atoum\test\adapter\calls::getEqualTo()	38	100%	6	100%	4	100%	2	100%
mageekguy\atoum\test\adapter\calls::getIdenticalTo()	38	100%	6	100%	4	100%	2	100%
mageekguy\atoum\test\adapter\calls::getPreviousEqualTo()	43	86%	8	100%	9	67%	4	25%
mageekguy\atoum\test\adapter\calls::getPreviousIdenticalTo()	43	86%	8	100%	9	67%	4	25%
mageekguy\atoum\test\adapter\calls::getPrevious()	26	100%	1	100%	5	100%	2	100%
mageekguy\atoum\test\adapter\calls::hasPreviousEqualTo()	34	79%	6	100%	9	56%	4	25%
mageekguy\atoum\test\adapter\calls::hasPreviousIdenticalTo()	34	79%	6	100%	9	56%	4	25%
mageekguy\atoum\test\adapter\calls::hasPrevious()	26	100%	1	100%	5	100%	2	100%
mageekguy\atoum\test\adapter\calls::getAfterEqualTo()	43	86%	8	100%	9	67%	4	25%
mageekguy\atoum\test\adapter\calls::getAfterIdenticalTo()	43	86%	9	100%	9	67%	4	25%
mageekguy\atoum\test\adapter\calls::getAfter()	26	100%	2	100%	5	100%	2	100%
mageekguy\atoum\test\adapter\calls::hasAfterEqualTo()	34	79%	6	100%	9	56%	4	25%
mageekguy\atoum\test\adapter\calls::hasAfterIdenticalTo()	34	79%	6	100%	9	56%	4	25%
mageekguy\atoum\test\adapter\calls::hasAfter()	26	100%	1	100%	5	100%	2	100%
mageekguy\atoum\test\adapter\calls::get()	23	74%	1	100%	5	60%	2	50%
mageekguy\atoum\test\adapter\calls::getTimeline()	34	68%	8	100%	11	55%	5	20%
mageekguy\atoum\test\adapter\calls::setCall()	49	98%	11	100%	7	86%	3	100%
mageekguy\atoum\test\adapter\calls::getCalls()	25	100%	2	100%	5	100%	2	100%
mageekguy\atoum\test\adapter\calls::getKey()	15	100%	1	100%	1	100%	1	100%
mageekguy\atoum\test\adapter\calls::buildCallsForCall()	32	100%	5	100%	1	100%	1	100%
mageekguy\atoum\test\adapter\calls::buildCall()	18	100%	1	100%	5	100%	2	100%

#
1	<?php
2
3	namespace mageekguy\atoum\test\adapter;
4
5	use
6	mageekguy\atoum\exceptions,
7	mageekguy\atoum\test\adapter
8	;
9
10	class calls implements \countable, \arrayAccess, \iteratorAggregate
11	{
12	protected $calls = array();
13	protected $size = 0;
14	protected $decorator = null;
15
16	private static $callsNumber = 0;
17
18	public function __construct()100%
19	{
20	$this->setDecorator();
21	}
22
23	public function __invoke()100%
24	{
25	return $this->calls;
26	}
27
28	public function __toString()100%
29	{
30	return $this->decorator->decorate($this);
31	}
32
33	public function count()
34	{
35	return $this->size;
36	}
37
38	public function offsetSet($functionName = null, $call = null)100%
39	{
40	if ($functionName !== null)
41	{
42	$call->setFunction($functionName);
43	}
44
45	return $this->addCall($call);
46	}
47
48	public function offsetGet($mixed)100%
49	{
50	return $this->getEqualTo(self::buildCall($mixed));
51	}
52
53	public function offsetUnset($mixed)100%
54	{
55	$key = self::getKey(self::buildCall($mixed));
56
57	if (isset($this->calls[$key]) === true)
58	{
59	$this->size -= sizeof($this->calls[$key]);
60
61	unset($this->calls[$key]);
62	}
63
64	return $this;
65	}
66
67	public function offsetExists($mixed)100%
68	{
69	return (isset($this->calls[self::getKey(self::buildCall($mixed))]) === true);
70	}
71
72	public function getIterator()100%
73	{
74	return new \arrayIterator($this());
75	}
76
77	public function reset()100%
78	{
79	$this->calls = array();
80	$this->size = 0;
81
82	return $this;
83	}
84
85	public function setDecorator(adapter\calls\decorator $decorator = null)100%
86	{
87	$this->decorator = $decorator ?: new adapter\calls\decorator();
88
89	return $this;
90	}
91
92	public function getDecorator()100%
93	{
94	return $this->decorator;
95	}
96
97	public function addCall(adapter\call $call)100%
98	{
99	return $this->setCall($call);
100	}
101
102	public function removeCall(adapter\call $call, $position)91%
103	{
104	$function = $call->getFunction();
105
106	if ($function == '')
107	{
108	throw new exceptions\logic\invalidArgument('Function is undefined');
109	}
110
111	$key = self::getKey($call);
112
113	if (isset($this->calls[$key][$position]) === true)
114	{
115	unset($this->calls[$key][$position]);
116	$this->size--;
117	}
118
119	return $this;
120	}
121
122	public function toArray(adapter\call $call = null)100%
123	{
124	if ($call === null)
125	{
126	$calls = $this->getTimeline();
127	}
128	else
129	{
130	$calls = $this->getEqualTo($call)->toArray();
131	}
132
133	return $calls;
134	}
135
136	public function getEqualTo(adapter\call $call)100%
137	{
138	$innerCalls = $this->getCalls($call);
139
140	if ($call->getArguments() !== null)
141	{
142	$innerCalls = array_filter($innerCalls, function($innerCall) use ($call) { return $call->isEqualTo($innerCall); });
143	}
144
145	return self::buildCallsForCall($call, $innerCalls);
146	}
147
148	public function getIdenticalTo(adapter\call $call)100%
149	{
150	$innerCalls = $this->getCalls($call);
151
152	if ($call->getArguments() !== null)
153	{
154	$innerCalls = array_filter($innerCalls, function($innerCall) use ($call) { return $call->isIdenticalTo($innerCall); });
155	}
156
157	return self::buildCallsForCall($call, $innerCalls);
158	}
159
160	public function getPreviousEqualTo(adapter\call $call, $position)100%
161	{
162	$calls = new static();
163
164	foreach ($this->getEqualTo($call)->toArray() as $innerPosition => $innerCall)
165	{
166	if ($innerPosition < $position)
167	{
168	$calls->setCall($innerCall, $innerPosition);
169	}
170	}
171
172	return $calls;
173	}
174
175	public function getPreviousIdenticalTo(adapter\call $call, $position)100%
176	{
177	$calls = new static();
178
179	foreach ($this->getIdenticalTo($call)->toArray() as $innerPosition => $innerCall)
180	{
181	if ($innerPosition < $position)
182	{
183	$calls->setCall($innerCall, $innerPosition);
184	}
185	}
186
187	return $calls;
188	}
189
190	public function getPrevious(adapter\call $call, $position, $identical = false)100%
191	{
192	return ($identical === false ? $this->getPreviousEqualTo($call, $position) : $this->getPreviousIdenticalTo($call, $position));
193	}
194
195	public function hasPreviousEqualTo(adapter\call $call, $position)100%
196	{
197	foreach ($this->getEqualTo($call)->toArray() as $innerPosition => $innerCall)
198	{
199	if ($innerPosition < $position)
200	{
201	return true;
202	}
203	}
204
205	return false;
206	}
207
208	public function hasPreviousIdenticalTo(adapter\call $call, $position)100%
209	{
210	foreach ($this->getIdenticalTo($call)->toArray() as $innerPosition => $innerCall)
211	{
212	if ($innerPosition < $position)
213	{
214	return true;
215	}
216	}
217
218	return false;
219	}
220
221	public function hasPrevious(adapter\call $call, $position, $identical = false)100%
222	{
223	return ($identical === false ? $this->hasPreviousEqualTo($call, $position) : $this->hasPreviousIdenticalTo($call, $position));
224	}
225
226	public function getAfterEqualTo(adapter\call $call, $position)100%
227	{
228	$calls = new static();
229
230	foreach ($this->getEqualTo($call)->toArray() as $innerPosition => $innerCall)
231	{
232	if ($innerPosition > $position)
233	{
234	$calls->setCall($innerCall, $innerPosition);
235	}
236	}
237
238	return $calls;
239	}
240
241	public function getAfterIdenticalTo(adapter\call $call, $position)
242	{
243	$calls = new static();
244
245	foreach ($this->getIdenticalTo($call)->toArray() as $innerPosition => $innerCall)
246	{
247	if ($innerPosition > $position)
248	{
249	$calls->setCall($innerCall, $innerPosition);
250	}
251	}
252
253	return $calls;
254	}
255
256	public function getAfter(adapter\call $call, $position, $identical = false)
257	{
258	return ($identical === false ? $this->getAfterEqualTo($call, $position) : $this->getAfterIdenticalTo($call, $position));
259	}
260
261	public function hasAfterEqualTo(adapter\call $call, $position)100%
262	{
263	foreach ($this->getEqualTo($call)->toArray() as $innerPosition => $innerCall)
264	{
265	if ($innerPosition > $position)
266	{
267	return true;
268	}
269	}
270
271	return false;
272	}
273
274	public function hasAfterIdenticalTo(adapter\call $call, $position)100%
275	{
276	foreach ($this->getIdenticalTo($call)->toArray() as $innerPosition => $innerCall)
277	{
278	if ($innerPosition > $position)
279	{
280	return true;
281	}
282	}
283
284	return false;
285	}
286
287	public function hasAfter(adapter\call $call, $position, $identical = false)100%
288	{
289	return ($identical === false ? $this->hasAfterEqualTo($call, $position) : $this->hasAfterIdenticalTo($call, $position));
290	}
291
292	public function get(adapter\call $call, $identical = false)100%
293	{
294	return ($identical === false ? $this->getEqualTo($call) : $this->getIdenticalTo($call));
295	}
296
297	public function getTimeline()100%
298	{
299	$timeline = array();
300
301	foreach ($this as $innerCalls)
302	{
303	foreach ($innerCalls as $position => $call)
304	{
305	$timeline[$position] = $call;
306	}
307	}
308
309	ksort($timeline, SORT_NUMERIC);
310
311	return $timeline;
312	}
313
314	protected function setCall(adapter\call $call, $position = null)100%
315	{
316	$function = $call->getFunction();
317
318	if ($function == '')
319	{
320	throw new exceptions\logic\invalidArgument('Function is undefined');
321	}
322
323	if ($position === null)
324	{
325	$position = ++self::$callsNumber;
326	}
327
328	$this->calls[self::getKey($call)][$position] = $call;
329	$this->size++;
330
331	return $this;
332	}
333
334	protected function getCalls($mixed)100%
335	{
336	$key = self::getKey($mixed);
337
338	return (isset($this->calls[$key]) === false ? array() : $this->calls[$key]);
339	}
340
341	protected static function getKey(adapter\call $call)100%
342	{
343	return strtolower($call->getFunction());
344	}
345
346	private static function buildCallsForCall(adapter\call $call, array $array)
347	{
348	$calls = new static();
349
350	$calls->calls[self::getKey($call)] = $array;
351	$calls->size = sizeof($array);
352
353	return $calls;
354	}
355
356	private static function buildCall($mixed)100%
357	{
358	return ($mixed instanceof adapter\call ? $mixed : new adapter\call($mixed));
359	}
360	}