EnumSet32Bench::benchCountFull() - Code Metrics - Inspection of "added php-benchmark suite" - marc-mabe/php-enum - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — feature/bench ( a60088 )

by Marc

created 2017-07-14 22:59 UTC

EnumSet32Bench::benchCountFull() A

↳ Parent: EnumSet32Bench

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	4
Ratio	100 %

Importance

Changes

Metric	Value
dl	4
loc	4
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	0

<?php

namespace MabeEnumBench;

use MabeEnum\EnumSet;
use MabeEnumTest\TestAsset\Enum32;

/**
 * @BeforeClassMethods({"initClass"})
 * @BeforeMethods({"init"})
 * @Revs(1000)
 * @Iterations(20)
 */
class EnumSet32Bench

{
    private static $constants;
    private static $names;
    private static $values;
    private static $ordinals;
    private static $enumerators;

    private $emptySet;
    private $fullSet;

    public static function initClass()
    {
        // initialize the enum to make sure the initialization process
        // will not effect the benchmark
        self::$constants   = Enum32::getConstants();
        self::$names       = Enum32::getNames();
        self::$values      = Enum32::getValues();
        self::$ordinals    = Enum32::getOrdinals();
        self::$enumerators = Enum32::getEnumerators();
    }

    public function init()
    {
        $this->emptySet = new EnumSet(Enum32::class);
        $this->fullSet = new EnumSet(Enum32::class);
        foreach (self::$enumerators as $enumerator) {
            $this->fullSet->attach($enumerator);
        }
    }

    public function benchAttachEnumeratorOnEmpty()
    {
        foreach (self::$enumerators as $enumerator) {
            $this->emptySet->attach($enumerator);
        }
    }

    public function benchAttachValueOnEmpty()
    {
        foreach (self::$values as $value) {
            $this->emptySet->attach($value);
        }
    }

    public function benchAttachEnumeratorOnFull()
    {
        foreach (self::$enumerators as $enumerator) {
            $this->fullSet->attach($enumerator);
        }
    }

    public function benchAttachValueOnFull()
    {
        foreach (self::$values as $value) {
            $this->fullSet->attach($value);
        }
    }

    public function benchDetachEnumeratorOnEmpty()
    {
        foreach (self::$enumerators as $enumerator) {
            $this->emptySet->detach($enumerator);
        }
    }

    public function benchDetachValueOnEmpty()
    {
        foreach (self::$values as $value) {
            $this->emptySet->detach($value);
        }
    }

    public function benchDetachEnumeratorOnFull()
    {
        foreach (self::$enumerators as $enumerator) {
            $this->fullSet->detach($enumerator);
        }
    }

    public function benchDetachValueOnFull()
    {
        foreach (self::$values as $value) {
            $this->fullSet->detach($value);
        }
    }

    public function benchContainsEnumeratorTrue()
    {
        foreach (self::$enumerators as $enumerator) {
            $this->fullSet->contains($enumerator);
        }
    }

    public function benchContainsValueTrue()
    {
        foreach (self::$values as $value) {
            $this->fullSet->contains($value);
        }
    }

    public function benchContainsEnumeratorFalse()
    {
        foreach (self::$enumerators as $enumerator) {
            $this->fullSet->contains($enumerator);
        }
    }

    public function benchContainsValueFalse()
    {
        foreach (self::$values as $value) {
            $this->fullSet->contains($value);
        }
    }

    public function benchIterateFull()
    {
        foreach ($this->fullSet as $enumerator) {
            $enumerator->key();
        }
    }

    public function benchIterateEmpty()
    {
        foreach ($this->emptySet as $enumerator) {
            $enumerator->key();
        }
    }

    public function benchCountFull()
    {
        $this->fullSet->count();
    }

    public function benchCountEmpty()
    {
        $this->emptySet->count();
    }

    public function benchIsEqual()
    {
        $this->fullSet->isEqual($this->fullSet);
class User
{
    private $email;

    public function getEmail()
    {
        return $this->email;
    }

    public function setEmail($email)
    {
        $this->email = $email;
    }
}
    }

    public function benchIsSubset()
    {
        $this->fullSet->isEqual($this->fullSet);
class User
{
    private $email;

    public function getEmail()
    {
        return $this->email;
    }

    public function setEmail($email)
    {
        $this->email = $email;
    }
}
    }

    public function benchIsSuperset()
    {
        $this->fullSet->isSuperset($this->fullSet);
class User
{
    private $email;

    public function getEmail()
    {
        return $this->email;
    }

    public function setEmail($email)
    {
        $this->email = $email;
    }
}
    }

    public function benchUnion()
    {
        $this->fullSet->union($this->emptySet);
    }

    public function benchIntersect()
    {
        $this->fullSet->intersect($this->emptySet);
    }

    public function benchDiff()
    {
        $this->fullSet->diff($this->emptySet);
    }

    public function benchSymDiff()
    {
        $this->fullSet->symDiff($this->emptySet);
    }

    public function benchGetOrdinals()
    {
        $this->fullSet->getOrdinals();
    }

    public function benchGetValues()
    {
        $this->fullSet->getValues();
    }

    public function benchGetNames()
    {
        $this->fullSet->getNames();
    }

    public function benchGetEnumerators()
    {
        $this->fullSet->getEnumerators();
    }

    public function benchGetBit()
    {
        foreach (self::$ordinals as $ordinal) {
            $this->fullSet->getBit($ordinal);
        }
    }

    public function benchSetBit()
    {
        foreach (self::$ordinals as $ordinal) {
            $this->emptySet->setBit($ordinal, true);
        }
    }

    public function benchUnsetBit()
    {
        foreach (self::$ordinals as $ordinal) {
            $this->fullSet->setBit($ordinal, false);
        }
    }
}


1		<?php
2
3		namespace MabeEnumBench;
4
5		use MabeEnum\EnumSet;
6		use MabeEnumTest\TestAsset\Enum32;
7
8		/**
9		* @BeforeClassMethods({"initClass"})
10		* @BeforeMethods({"init"})
11		* @Revs(1000)
12		* @Iterations(20)
13		*/
14	View Code Duplication	class EnumSet32Bench
		0 ignored issues – show Duplication introduced 2017-07-14 23:05 UTC by Report Bug Copy Issue Report This class seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
15		{
16		private static $constants;
17		private static $names;
18		private static $values;
19		private static $ordinals;
20		private static $enumerators;
21
22		private $emptySet;
23		private $fullSet;
24
25		public static function initClass()
26		{
27		// initialize the enum to make sure the initialization process
28		// will not effect the benchmark
29		self::$constants = Enum32::getConstants();
30		self::$names = Enum32::getNames();
31		self::$values = Enum32::getValues();
32		self::$ordinals = Enum32::getOrdinals();
33		self::$enumerators = Enum32::getEnumerators();
34		}
35
36		public function init()
37		{
38		$this->emptySet = new EnumSet(Enum32::class);
39		$this->fullSet = new EnumSet(Enum32::class);
40		foreach (self::$enumerators as $enumerator) {
41		$this->fullSet->attach($enumerator);
42		}
43		}
44
45		public function benchAttachEnumeratorOnEmpty()
46		{
47		foreach (self::$enumerators as $enumerator) {
48		$this->emptySet->attach($enumerator);
49		}
50		}
51
52		public function benchAttachValueOnEmpty()
53		{
54		foreach (self::$values as $value) {
55		$this->emptySet->attach($value);
56		}
57		}
58
59		public function benchAttachEnumeratorOnFull()
60		{
61		foreach (self::$enumerators as $enumerator) {
62		$this->fullSet->attach($enumerator);
63		}
64		}
65
66		public function benchAttachValueOnFull()
67		{
68		foreach (self::$values as $value) {
69		$this->fullSet->attach($value);
70		}
71		}
72
73		public function benchDetachEnumeratorOnEmpty()
74		{
75		foreach (self::$enumerators as $enumerator) {
76		$this->emptySet->detach($enumerator);
77		}
78		}
79
80		public function benchDetachValueOnEmpty()
81		{
82		foreach (self::$values as $value) {
83		$this->emptySet->detach($value);
84		}
85		}
86
87		public function benchDetachEnumeratorOnFull()
88		{
89		foreach (self::$enumerators as $enumerator) {
90		$this->fullSet->detach($enumerator);
91		}
92		}
93
94		public function benchDetachValueOnFull()
95		{
96		foreach (self::$values as $value) {
97		$this->fullSet->detach($value);
98		}
99		}
100
101		public function benchContainsEnumeratorTrue()
102		{
103		foreach (self::$enumerators as $enumerator) {
104		$this->fullSet->contains($enumerator);
105		}
106		}
107
108		public function benchContainsValueTrue()
109		{
110		foreach (self::$values as $value) {
111		$this->fullSet->contains($value);
112		}
113		}
114
115		public function benchContainsEnumeratorFalse()
116		{
117		foreach (self::$enumerators as $enumerator) {
118		$this->fullSet->contains($enumerator);
119		}
120		}
121
122		public function benchContainsValueFalse()
123		{
124		foreach (self::$values as $value) {
125		$this->fullSet->contains($value);
126		}
127		}
128
129		public function benchIterateFull()
130		{
131		foreach ($this->fullSet as $enumerator) {
132		$enumerator->key();
133		}
134		}
135
136		public function benchIterateEmpty()
137		{
138		foreach ($this->emptySet as $enumerator) {
139		$enumerator->key();
140		}
141		}
142
143		public function benchCountFull()
144		{
145		$this->fullSet->count();
146		}
147
148		public function benchCountEmpty()
149		{
150		$this->emptySet->count();
151		}
152
153		public function benchIsEqual()
154		{
155		$this->fullSet->isEqual($this->fullSet);
		0 ignored issues – show Unused Code introduced 2017-07-14 23:05 UTC by Report Bug Copy Issue Report The call to the method `MabeEnum\EnumSet::isEqual()` seems un-needed as the method has no side-effects. PHP Analyzer performs a side-effects analysis of your code. A side-effect is basically anything that might be visible after the scope of the method is left. Let’s take a look at an example: class User { private $email; public function getEmail() { return $this->email; } public function setEmail($email) { $this->email = $email; } } If we look at the `getEmail()` method, we can see that it has no side-effect. Whether you call this method or not, no future calls to other methods are affected by this. As such code as the following is useless: $user = new User(); $user->getEmail(); // This line could safely be removed as it has no effect. On the hand, if we look at the `setEmail()`, this method _has_ side-effects. In the following case, we could not remove the method call: $user = new User(); $user->setEmail('email@domain'); // This line has a side-effect (it changes an // instance variable). Loading history...
156		}
157
158		public function benchIsSubset()
159		{
160		$this->fullSet->isEqual($this->fullSet);
		0 ignored issues – show Unused Code introduced 2017-07-14 23:05 UTC by Report Bug Copy Issue Report The call to the method `MabeEnum\EnumSet::isEqual()` seems un-needed as the method has no side-effects. PHP Analyzer performs a side-effects analysis of your code. A side-effect is basically anything that might be visible after the scope of the method is left. Let’s take a look at an example: class User { private $email; public function getEmail() { return $this->email; } public function setEmail($email) { $this->email = $email; } } If we look at the `getEmail()` method, we can see that it has no side-effect. Whether you call this method or not, no future calls to other methods are affected by this. As such code as the following is useless: $user = new User(); $user->getEmail(); // This line could safely be removed as it has no effect. On the hand, if we look at the `setEmail()`, this method _has_ side-effects. In the following case, we could not remove the method call: $user = new User(); $user->setEmail('email@domain'); // This line has a side-effect (it changes an // instance variable). Loading history...
161		}
162
163		public function benchIsSuperset()
164		{
165		$this->fullSet->isSuperset($this->fullSet);
		0 ignored issues – show Unused Code introduced 2017-07-14 23:05 UTC by Report Bug Copy Issue Report The call to the method `MabeEnum\EnumSet::isSuperset()` seems un-needed as the method has no side-effects. PHP Analyzer performs a side-effects analysis of your code. A side-effect is basically anything that might be visible after the scope of the method is left. Let’s take a look at an example: class User { private $email; public function getEmail() { return $this->email; } public function setEmail($email) { $this->email = $email; } } If we look at the `getEmail()` method, we can see that it has no side-effect. Whether you call this method or not, no future calls to other methods are affected by this. As such code as the following is useless: $user = new User(); $user->getEmail(); // This line could safely be removed as it has no effect. On the hand, if we look at the `setEmail()`, this method _has_ side-effects. In the following case, we could not remove the method call: $user = new User(); $user->setEmail('email@domain'); // This line has a side-effect (it changes an // instance variable). Loading history...
166		}
167
168		public function benchUnion()
169		{
170		$this->fullSet->union($this->emptySet);
171		}
172
173		public function benchIntersect()
174		{
175		$this->fullSet->intersect($this->emptySet);
176		}
177
178		public function benchDiff()
179		{
180		$this->fullSet->diff($this->emptySet);
181		}
182
183		public function benchSymDiff()
184		{
185		$this->fullSet->symDiff($this->emptySet);
186		}
187
188		public function benchGetOrdinals()
189		{
190		$this->fullSet->getOrdinals();
191		}
192
193		public function benchGetValues()
194		{
195		$this->fullSet->getValues();
196		}
197
198		public function benchGetNames()
199		{
200		$this->fullSet->getNames();
201		}
202
203		public function benchGetEnumerators()
204		{
205		$this->fullSet->getEnumerators();
206		}
207
208		public function benchGetBit()
209		{
210		foreach (self::$ordinals as $ordinal) {
211		$this->fullSet->getBit($ordinal);
212		}
213		}
214
215		public function benchSetBit()
216		{
217		foreach (self::$ordinals as $ordinal) {
218		$this->emptySet->setBit($ordinal, true);
219		}
220		}
221
222		public function benchUnsetBit()
223		{
224		foreach (self::$ordinals as $ordinal) {
225		$this->fullSet->setBit($ordinal, false);
226		}
227		}
228		}
229

marc-mabe / php-enum

Push — feature/bench ( a60088 )

EnumSet32Bench::benchCountFull() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like