ProxyFactoryTest::testFailedProxyCloningDoesNotMarkTheProxyAsInitialized() - Code Metrics - Inspection of "#6722 initialize proxies with their to-many fields..." - doctrine/orm - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Pull Request — develop (#6724)

by Marco

created 2017-12-18 17:13 UTC

testFailedProxyCloningDoesNotMarkTheProxyAsInitialized() B

↳ Parent: ProxyFactoryTest

Complexity

Conditions	2
Paths	3

Size

Total Lines	28
Code Lines	18

Duplication

Lines	28
Ratio	100 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
dl	28
loc	28
rs	8.8571
c	1
b	0
f	0
cc	2
eloc	18
nc	3
nop	0

<?php

declare(strict_types=1);

namespace Doctrine\Tests\ORM\Proxy;

use Doctrine\ORM\EntityNotFoundException;
use Doctrine\ORM\Mapping\ClassMetadata;
use Doctrine\ORM\Mapping\ClassMetadataBuildingContext;
use Doctrine\ORM\Mapping\ClassMetadataFactory;
use Doctrine\ORM\PersistentCollection;
use Doctrine\ORM\Persisters\Entity\BasicEntityPersister;
use Doctrine\ORM\Proxy\Factory\StaticProxyFactory;
use Doctrine\ORM\Reflection\RuntimeReflectionService;
use Doctrine\Tests\Mocks\ConnectionMock;
use Doctrine\Tests\Mocks\DriverMock;
use Doctrine\Tests\Mocks\EntityManagerMock;
use Doctrine\Tests\Mocks\UnitOfWorkMock;
use Doctrine\Tests\Models\CMS\CmsUser;
use Doctrine\Tests\Models\Company\CompanyEmployee;
use Doctrine\Tests\Models\ECommerce\ECommerceFeature;
use Doctrine\Tests\Models\FriendObject\ComparableObject;
use Doctrine\Tests\Models\ProxySpecifics\FuncGetArgs;
use Doctrine\Tests\OrmTestCase;
use ProxyManager\Proxy\GhostObjectInterface;

/**
 * Test the proxy generator. Its work is generating on-the-fly subclasses of a given model, which implement the Proxy pattern.
 * @author Giorgio Sironi <[email protected]>
 */
class ProxyFactoryTest extends OrmTestCase
{
    /**
     * @var ConnectionMock
     */
    private $connectionMock;

    /**
     * @var UnitOfWorkMock
     */
    private $uowMock;

    /**
     * @var EntityManagerMock
     */
    private $emMock;

    /**
     * @var StaticProxyFactory
     */
    private $proxyFactory;

    /**
     * @var ClassMetadataBuildingContext
     */
    private $metadataBuildingContext;

    /**
     * {@inheritDoc}
     */
    protected function setUp()
    {
        parent::setUp();

        $this->metadataBuildingContext = new ClassMetadataBuildingContext(
            $this->createMock(ClassMetadataFactory::class),
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            new RuntimeReflectionService()
        );
        $this->connectionMock          = new ConnectionMock([], new DriverMock());
        $this->emMock                  = EntityManagerMock::create($this->connectionMock);
        $this->uowMock                 = new UnitOfWorkMock($this->emMock);

        $this->emMock->setUnitOfWork($this->uowMock);

        $this->proxyFactory = new StaticProxyFactory(
            $this->emMock,
            $this->emMock->getConfiguration()->buildGhostObjectFactory()
        );
    }

    public function testReferenceProxyDelegatesLoadingToThePersister()
    {
        $identifier    = ['id' => 42];
        $classMetaData = $this->emMock->getClassMetadata(ECommerceFeature::class);

        $persister = $this
            ->getMockBuilder(BasicEntityPersister::class)
            ->setConstructorArgs([$this->emMock, $classMetaData])
            ->setMethods(['loadById'])
            ->getMock();

        $persister
            ->expects($this->atLeastOnce())
            ->method('loadById')
            ->with(
                $identifier,
                self::logicalAnd(
                    self::isInstanceOf(GhostObjectInterface::class),
                    self::isInstanceOf(ECommerceFeature::class)
                )
            )
            ->will($this->returnValue(new \stdClass()));

        $this->uowMock->setEntityPersister(ECommerceFeature::class, $persister);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        /* @var $proxy GhostObjectInterface|ECommerceFeature */
        $proxy = $this->proxyFactory->getProxy($classMetaData, $identifier);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        $proxy->getDescription();
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
    }

    public function testSkipMappedSuperClassesOnGeneration(): void
    {
        $cm = new ClassMetadata(\stdClass::class, $this->metadataBuildingContext);
        $cm->isMappedSuperclass = true;

        self::assertSame(
            0,
            $this->proxyFactory->generateProxyClasses([$cm]),
            'No proxies generated.'
        );
    }

    /**
     * @group 6625
     * @group embedded
     */
    public function testSkipEmbeddableClassesOnGeneration(): void
    {
        $cm = new ClassMetadata(\stdClass::class, $this->metadataBuildingContext);
        $cm->isEmbeddedClass = true;

        self::assertSame(
            0,
            $this->proxyFactory->generateProxyClasses([$cm]),
            'No proxies generated.'
        );
    }

    /**
     * @group DDC-1771
     */
    public function testSkipAbstractClassesOnGeneration()
    {
        $cm = new ClassMetadata(AbstractClass::class, $this->metadataBuildingContext);

        self::assertNotNull($cm->getReflectionClass());

        $num = $this->proxyFactory->generateProxyClasses([$cm]);

        self::assertEquals(0, $num, "No proxies generated.");
    }

    /**
     * @group DDC-2432
     */
    public function testFailedProxyLoadingDoesNotMarkTheProxyAsInitialized()
    {
        $classMetaData = $this->emMock->getClassMetadata(ECommerceFeature::class);

        $persister = $this
            ->getMockBuilder(BasicEntityPersister::class)
            ->setConstructorArgs([$this->emMock, $classMetaData])
            ->setMethods(['load'])
            ->getMock();

        $persister
            ->expects($this->atLeastOnce())
            ->method('load')
            ->will($this->returnValue(null));

        $this->uowMock->setEntityPersister(ECommerceFeature::class, $persister);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        /* @var $proxy GhostObjectInterface|ECommerceFeature */
        $proxy = $this->proxyFactory->getProxy($classMetaData, ['id' => 42]);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        try {
            $proxy->getDescription();
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            $this->fail('An exception was expected to be raised');
        } catch (EntityNotFoundException $exception) {

        }

        self::assertFalse($proxy->isProxyInitialized());
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
    }

    /**
     * @group DDC-2432
     */
    public function testFailedProxyCloningDoesNotMarkTheProxyAsInitialized()
    {
        $classMetaData = $this->emMock->getClassMetadata(ECommerceFeature::class);

        $persister = $this
            ->getMockBuilder(BasicEntityPersister::class)
            ->setConstructorArgs([$this->emMock, $classMetaData])
            ->setMethods(['load'])
            ->getMock();

        $persister
            ->expects($this->atLeastOnce())
            ->method('load')
            ->will($this->returnValue(null));

        $this->uowMock->setEntityPersister(ECommerceFeature::class, $persister);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        /* @var $proxy GhostObjectInterface|ECommerceFeature */
        $proxy = $this->proxyFactory->getProxy($classMetaData, ['id' => 42]);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        try {
            $cloned = clone $proxy;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
            $this->fail('An exception was expected to be raised');
        } catch (EntityNotFoundException $exception) {

        }

        self::assertFalse($proxy->isProxyInitialized());
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
    }

    public function testProxyClonesParentFields()
    {
        $identifier    = ['id' => 42];
        $classMetaData = $this->emMock->getClassMetadata(CompanyEmployee::class);

        $persister = $this
            ->getMockBuilder(BasicEntityPersister::class)
            ->setConstructorArgs([$this->emMock, $classMetaData])
            ->setMethods(['loadById'])
            ->getMock();

        $persister
            ->expects(self::atLeastOnce())
            ->method('loadById')
            ->with(
                $identifier,
                self::logicalAnd(
                    self::isInstanceOf(GhostObjectInterface::class),
                    self::isInstanceOf(CompanyEmployee::class)
                )
            )
            ->willReturnCallback(function (array $id, CompanyEmployee $companyEmployee) {
                $companyEmployee->setSalary(1000); // A property on the CompanyEmployee
                $companyEmployee->setName('Bob'); // A property on the parent class, CompanyPerson

                return $companyEmployee;
            });

        $this->uowMock->setEntityPersister(CompanyEmployee::class, $persister);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        /* @var $proxy GhostObjectInterface|CompanyEmployee */
        $proxy = $this->proxyFactory->getProxy($classMetaData, $identifier);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        $cloned = clone $proxy;

        self::assertSame(42, $cloned->getId(), 'Expected the Id to be cloned');
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        self::assertSame(1000, $cloned->getSalary(), 'Expect properties on the CompanyEmployee class to be cloned');
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        self::assertSame('Bob', $cloned->getName(), 'Expect properties on the CompanyPerson class to be cloned');
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
    }

    public function testFriendObjectsDoNotLazyLoadIfNotAccessingLazyState()
    {
        /* @var $persister BasicEntityPersister|\PHPUnit_Framework_MockObject_MockObject */
        $persister = $this->createMock(BasicEntityPersister::class);
        $persister->expects(self::never())->method('loadById');
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $this->uowMock->setEntityPersister(ComparableObject::class, $persister);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        /* @var $comparable ComparableObject|GhostObjectInterface */
        $comparable = $this->proxyFactory->getProxy(
            $this->emMock->getClassMetadata(ComparableObject::class),
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            ['id' => 123]
        );

        self::assertInstanceOf(ComparableObject::class, $comparable);
        self::assertInstanceOf(GhostObjectInterface::class, $comparable);
        self::assertFalse($comparable->isProxyInitialized());
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        // due to implementation details, identity check is not reading lazy state:
        self::assertTrue($comparable->equalTo($comparable));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        self::assertFalse($comparable->isProxyInitialized());
    }

    public function testFriendObjectsLazyLoadWhenAccessingLazyState()
    {
        /* @var $persister BasicEntityPersister|\PHPUnit_Framework_MockObject_MockObject */
        $persister = $this
            ->getMockBuilder(BasicEntityPersister::class)
            ->setConstructorArgs([$this->emMock, $this->emMock->getClassMetadata(ComparableObject::class)])
            ->setMethods(['loadById'])
            ->getMock();

        $persister
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects(self::exactly(2))
            ->method('loadById')
            ->with(
                self::logicalOr(['id' => 123], ['id' => 456]),
                self::logicalAnd(
                    self::isInstanceOf(GhostObjectInterface::class),
                    self::isInstanceOf(ComparableObject::class)
                )
            )
            ->willReturnCallback(function (array $id, ComparableObject $comparableObject) {
                $comparableObject->setComparedFieldValue(\json_encode($id));

                return $comparableObject;
            });

        $this->uowMock->setEntityPersister(ComparableObject::class, $persister);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        $metadata = $this->emMock->getClassMetadata(ComparableObject::class);

        /* @var $comparable1 ComparableObject|GhostObjectInterface */
        $comparable1 = $this->proxyFactory->getProxy($metadata, ['id' => 123]);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        /* @var $comparable2 ComparableObject|GhostObjectInterface */
        $comparable2 = $this->proxyFactory->getProxy($metadata, ['id' => 456]);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        self::assertInstanceOf(ComparableObject::class, $comparable1);
        self::assertInstanceOf(ComparableObject::class, $comparable2);
        self::assertInstanceOf(GhostObjectInterface::class, $comparable1);
        self::assertInstanceOf(GhostObjectInterface::class, $comparable2);
        self::assertNotSame($comparable1, $comparable2);
        self::assertFalse($comparable1->isProxyInitialized());
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        self::assertFalse($comparable2->isProxyInitialized());

        self::assertFalse(
            $comparable1->equalTo($comparable2),
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            'Due to implementation details, identity check is not reading lazy state'
        );

        self::assertTrue($comparable1->isProxyInitialized());
        self::assertTrue($comparable2->isProxyInitialized());
    }

    public function testProxyMethodsSupportFuncGetArgsLogic()
    {
        /* @var $persister BasicEntityPersister|\PHPUnit_Framework_MockObject_MockObject */
        $persister = $this->createMock(BasicEntityPersister::class);
        $persister->expects(self::never())->method('loadById');
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $this->uowMock->setEntityPersister(FuncGetArgs::class, $persister);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        /* @var $funcGetArgs FuncGetArgs|GhostObjectInterface */
        $funcGetArgs = $this->proxyFactory->getProxy(
            $this->emMock->getClassMetadata(FuncGetArgs::class),
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            ['id' => 123]
        );

        self::assertInstanceOf(GhostObjectInterface::class, $funcGetArgs);
        self::assertFalse($funcGetArgs->isProxyInitialized());
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        self::assertSame(
            [1, 2, 3, 4],
            $funcGetArgs->funcGetArgsCallingMethod(1, 2, 3, 4),
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            '`func_get_args()` calls are now supported in proxy implementations'
        );

        self::assertFalse($funcGetArgs->isProxyInitialized(), 'No lazy state was accessed anyway');
    }

    /**
     * @group #6722
     */
    public function testAccessingProxyToManyFieldsCausesNoAdditionalQueries() : void
    {
        /* @var $persister BasicEntityPersister|\PHPUnit_Framework_MockObject_MockObject */
        $persister = $this->createMock(BasicEntityPersister::class);
        $persister->expects(self::never())->method('loadById');
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $this->uowMock->setEntityPersister(CmsUser::class, $persister);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        /* @var $user CmsUser|GhostObjectInterface */
        $user = $this->proxyFactory->getProxy(CmsUser::class, ['id' => 123]);

        self::assertInstanceOf(GhostObjectInterface::class, $user);
        self::assertFalse($user->isProxyInitialized());
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        /* @var $phoneNumbers PersistentCollection */
        $phoneNumbers = $user->phonenumbers;

        self::assertInstanceOf(PersistentCollection::class, $phoneNumbers);
        self::assertFalse($phoneNumbers->isDirty());
        self::assertFalse($phoneNumbers->isInitialized());
        self::assertSame($user, $phoneNumbers->getOwner());

        /* @var $groups PersistentCollection */
        $groups = $user->groups;

        self::assertInstanceOf(PersistentCollection::class, $groups);
        self::assertFalse($groups->isDirty());
        self::assertFalse($groups->isInitialized());
        self::assertSame($user, $groups->getOwner());

        self::assertFalse($user->isProxyInitialized(), 'No lazy state was accessed anyway');
    }
}

abstract class AbstractClass
{

}


Pull Request — develop (#6724)

testFailedProxyCloningDoesNotMarkTheProxyAsInitialized() B

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

1			<?php
2
3			declare(strict_types=1);
4
5			namespace Doctrine\Tests\ORM\Proxy;
6
7			use Doctrine\ORM\EntityNotFoundException;
8			use Doctrine\ORM\Mapping\ClassMetadata;
9			use Doctrine\ORM\Mapping\ClassMetadataBuildingContext;
10			use Doctrine\ORM\Mapping\ClassMetadataFactory;
11			use Doctrine\ORM\PersistentCollection;
12			use Doctrine\ORM\Persisters\Entity\BasicEntityPersister;
13			use Doctrine\ORM\Proxy\Factory\StaticProxyFactory;
14			use Doctrine\ORM\Reflection\RuntimeReflectionService;
15			use Doctrine\Tests\Mocks\ConnectionMock;
16			use Doctrine\Tests\Mocks\DriverMock;
17			use Doctrine\Tests\Mocks\EntityManagerMock;
18			use Doctrine\Tests\Mocks\UnitOfWorkMock;
19			use Doctrine\Tests\Models\CMS\CmsUser;
20			use Doctrine\Tests\Models\Company\CompanyEmployee;
21			use Doctrine\Tests\Models\ECommerce\ECommerceFeature;
22			use Doctrine\Tests\Models\FriendObject\ComparableObject;
23			use Doctrine\Tests\Models\ProxySpecifics\FuncGetArgs;
24			use Doctrine\Tests\OrmTestCase;
25			use ProxyManager\Proxy\GhostObjectInterface;
26
27			/**
28			* Test the proxy generator. Its work is generating on-the-fly subclasses of a given model, which implement the Proxy pattern.
29			* @author Giorgio Sironi <[email protected]>
30			*/
31			class ProxyFactoryTest extends OrmTestCase
32			{
33			/**
34			* @var ConnectionMock
35			*/
36			private $connectionMock;
37
38			/**
39			* @var UnitOfWorkMock
40			*/

doctrine / orm

Pull Request — develop (#6724)

testFailedProxyCloningDoesNotMarkTheProxyAsInitialized() B

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like