MabeEnumBench\EnumBench

Complexity

Total Complexity

32

Size/Duplication

Total Lines	157
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	initClass()	0	10	1
A	benchGetName()	0	6	2
A	benchGetValue()	0	6	2
A	benchGetOrdinal()	0	6	2
A	benchIsByEnumerator()	0	6	2
A	benchIsByValue()	0	6	2
A	benchGetConstants()	0	4	1
A	benchGetValues()	0	4	1
A	benchGetNames()	0	4	1
A	benchGetOrdinals()	0	4	1
A	benchGetEnumerators()	0	4	1
A	benchByValue()	0	6	2
A	benchByName()	0	6	2
A	benchByOrdinal()	0	6	2
A	benchGetByValues()	0	6	2
A	benchGetByEnumerator()	0	6	2
A	benchGetByCallStatic()	0	6	2
A	benchHasByEnumerator()	0	6	2
A	benchHasByValue()	0	6	2

<?php

namespace MabeEnumBench;

use MabeEnumTest\TestAsset\Enum66;

/**
 * Benchmark of abstract class Enum tested with enumeration of 66 enumerators.
 *
 * @BeforeClassMethods({"initClass"})
 * @Revs(2500)
 * @Iterations(25)
 */
class EnumBench
{
    /**
     * @var array
     */
    private static $constants;

    /**
     * @var string[]
     */
    private static $names;

    /**
     * @var mixed[]
     */
    private static $values;

    /**
     * @var int[]
     */
    private static $ordinals;

    /**
     * @var Enum66[]
     */
    private static $enumerators;

    /**
     * Initialize class
     */
    public static function initClass()
    {
        // initialize the enum to make sure the initialization process
        // will not effect the benchmark
        self::$constants   = Enum66::getConstants();
        self::$names       = Enum66::getNames();

It seems like \MabeEnumTest\TestAsset\Enum66::getNames() of type array<integer,integer|string> is incompatible with the declared type array<integer,string> of property $names.

        self::$values      = Enum66::getValues();
        self::$ordinals    = Enum66::getOrdinals();
        self::$enumerators = Enum66::getEnumerators();

It seems like \MabeEnumTest\TestAsset\Enum66::getEnumerators() of type array<integer,object<MabeEnum\Enum>> is incompatible with the declared type array<integer,object<MabeEnumTest\TestAsset\Enum66>> of property $enumerators.

    }

    public function benchGetName()
    {
        foreach (self::$enumerators as $enumerator) {
            $enumerator->getName();
        }
    }

    public function benchGetValue()
    {
        foreach (self::$enumerators as $enumerator) {
            $enumerator->getValue();

The call to the method MabeEnumTest\TestAsset\Enum66::getValue() seems un-needed as the method has no side-effects.

        }
    }

    public function benchGetOrdinal()
    {
        foreach (self::$enumerators as $enumerator) {
            $enumerator->getOrdinal();
        }
    }

    public function benchIsByEnumerator()
    {
        foreach (self::$enumerators as $enumerator) {
            $enumerator->is($enumerator);
        }
    }

    public function benchIsByValue()
    {
        foreach (self::$enumerators as $enumerator) {
            $enumerator->is($enumerator->getValue());
        }
    }

    public function benchGetConstants()
    {
        Enum66::getConstants();
    }

    public function benchGetValues()
    {
        Enum66::getValues();
    }

    public function benchGetNames()
    {
        Enum66::getNames();
    }

    public function benchGetOrdinals()
    {
        Enum66::getOrdinals();
    }

    public function benchGetEnumerators()
    {
        Enum66::getEnumerators();
    }

    public function benchByValue()
    {
        foreach (self::$values as $value) {
            Enum66::byValue($value);
        }
    }

    public function benchByName()
    {
        foreach (self::$names as $name) {
            Enum66::byName($name);
        }
    }

    public function benchByOrdinal()
    {
        foreach (self::$ordinals as $ord) {
            Enum66::byOrdinal($ord);
        }
    }

    public function benchGetByValues()
    {
        foreach (self::$values as $value) {
            Enum66::get($value);
        }
    }

    public function benchGetByEnumerator()
    {
        foreach (self::$enumerators as $enumerator) {
            Enum66::get($enumerator);
        }
    }

    public function benchGetByCallStatic()
    {
        foreach (self::$names as $name) {
            Enum66::$name();
        }
    }

    public function benchHasByEnumerator()
    {
        foreach (self::$enumerators as $enumerator) {
            Enum66::has($enumerator);
        }
    }

    public function benchHasByValue()
    {
        foreach (self::$values as $value) {
            Enum66::has($value);
        }
    }
}