EntityGeneratorTest::testEmbeddedEntityWithNamedColumnPrefix() - Code Metrics - Inspection of "ClassMetadataFactory changed to bring ClassMetadat..." - doctrine/orm - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions
Push — develop ( ba9041...24f682 )

by Guilherme
created 2017-08-09 21:35 UTC
testEmbeddedEntityWithNamedColumnPrefix() A

↳ Parent: EntityGeneratorTest
Complexity

Conditions	1
Paths	1
Size

Total Lines	13
Code Lines	10
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
dl	0
loc	13
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	10
nc	1
nop	0
<?php

declare(strict_types=1);

namespace Doctrine\Tests\ORM\Tools;

use Doctrine\Common\Annotations\AnnotationReader;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\DBAL\Types\Type;
use Doctrine\ORM\Mapping\ClassMetadataFactory;
use Doctrine\ORM\Mapping\ClassMetadata;
use Doctrine\ORM\Mapping\Driver\AnnotationDriver;
use Doctrine\ORM\Mapping;
use Doctrine\ORM\Reflection\RuntimeReflectionService;
use Doctrine\ORM\Reflection\StaticReflectionService;
use Doctrine\ORM\Tools\EntityGenerator;
use Doctrine\Tests\Models\DDC2372\DDC2372Admin;
use Doctrine\Tests\Models\DDC2372\DDC2372User;
use Doctrine\Tests\OrmTestCase;
use SebastianBergmann\Environment\Runtime;

class EntityGeneratorTest extends OrmTestCase
{
    /**
     * @var EntityGenerator
     */
    private $generator;
    private $tmpDir;
    private $namespace;

    /**
     * @var Mapping\ClassMetadataBuildingContext
     */
    private $staticMetadataBuildingContext;

    /**
     * @var Mapping\ClassMetadataBuildingContext
     */
    private $runtimeMetadataBuildingContext;

    public function setUp()
    {
        $this->staticMetadataBuildingContext = new Mapping\ClassMetadataBuildingContext(
            $this->createMock(ClassMetadataFactory::class),
            new StaticReflectionService()
        );

        $this->runtimeMetadataBuildingContext = new Mapping\ClassMetadataBuildingContext(
            $this->createMock(ClassMetadataFactory::class),
            new RuntimeReflectionService()
        );

        $this->namespace = uniqid("doctrine_", false);
        $this->tmpDir = sys_get_temp_dir();

        mkdir($this->tmpDir . \DIRECTORY_SEPARATOR . $this->namespace);

        $this->generator = new EntityGenerator();

        $this->generator->setGenerateAnnotations(true);
        $this->generator->setGenerateStubMethods(true);
        $this->generator->setRegenerateEntityIfExists(false);
        $this->generator->setUpdateEntityIfExists(true);
        $this->generator->setFieldVisibility(EntityGenerator::FIELD_VISIBLE_PROTECTED);
    }

    public function tearDown()
    {
        $ri = new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($this->tmpDir . '/' . $this->namespace));

        foreach ($ri AS $file) {
            /* @var $file \SplFileInfo */
            if ($file->isFile()) {
                unlink($file->getPathname());
            }
        }

        rmdir($this->tmpDir . '/' . $this->namespace);
    }

    /**
     * @param ClassMetadata[] $embeddedClasses
     *
     * @return ClassMetadata
     */
    public function generateBookEntityFixture(array $embeddedClasses = [])
    {
        $metadata = new ClassMetadata($this->namespace . '\EntityGeneratorBook', $this->staticMetadataBuildingContext);

        $metadata->setCustomRepositoryClassName($this->namespace . '\EntityGeneratorBookRepository');

        $tableMetadata = new Mapping\TableMetadata();

        $tableMetadata->setName('book');
        $tableMetadata->addUniqueConstraint(
            [
                'name'    => 'name_uniq',
                'columns' => ['name'],
                'options' => [],
                'flags'   => [],
            ]
        );

        $tableMetadata->addIndex(
            [
                'name'    => 'status_idx',
                'columns' => ['status'],
                'unique'  => false,
                'options' => [],
                'flags'   => [],
            ]
        );

        $metadata->setTable($tableMetadata);

        // Property: "name"
        $fieldMetadata = new Mapping\FieldMetadata('name');

        $fieldMetadata->setType(Type::getType('string'));
        $fieldMetadata->setNullable(false);
        $fieldMetadata->setUnique(false);

        $metadata->addProperty($fieldMetadata);

        // Property: "status"
        $fieldMetadata = new Mapping\FieldMetadata('status');

        $fieldMetadata->setType(Type::getType('string'));
        $fieldMetadata->setNullable(false);
        $fieldMetadata->setUnique(false);
        $fieldMetadata->setOptions([
            'default' => 'published',
        ]);

        $metadata->addProperty($fieldMetadata);

        // Property: "id"
        $fieldMetadata = new Mapping\FieldMetadata('id');

        $fieldMetadata->setType(Type::getType('integer'));
        $fieldMetadata->setPrimaryKey(true);
        $fieldMetadata->setNullable(false);
        $fieldMetadata->setUnique(false);
        $fieldMetadata->setValueGenerator(new Mapping\ValueGeneratorMetadata(Mapping\GeneratorType::AUTO));

        $metadata->addProperty($fieldMetadata);

        // Property: "author"
        $joinColumns = [];

        $joinColumn = new Mapping\JoinColumnMetadata();
        $joinColumn->setColumnName('author_id');
        $joinColumn->setReferencedColumnName('id');

        $joinColumns[] = $joinColumn;

        $association = new Mapping\OneToOneAssociationMetadata('author');

        $association->setJoinColumns($joinColumns);
        $association->setTargetEntity(EntityGeneratorAuthor::class);
        $association->setMappedBy('book');

        $metadata->addProperty($association);

        // Property: "comments"
        $joinTable = new Mapping\JoinTableMetadata();
        $joinTable->setName('book_comment');

        $joinColumn = new Mapping\JoinColumnMetadata();
        $joinColumn->setColumnName("book_id");
        $joinColumn->setReferencedColumnName("id");

        $joinTable->addJoinColumn($joinColumn);

        $joinColumn = new Mapping\JoinColumnMetadata();
        $joinColumn->setColumnName("comment_id");
        $joinColumn->setReferencedColumnName("id");

        $joinTable->addInverseJoinColumn($joinColumn);

        $association = new Mapping\ManyToManyAssociationMetadata('comments');

        $association->setJoinTable($joinTable);
        $association->setTargetEntity(EntityGeneratorComment::class);
        $association->setFetchMode(Mapping\FetchMode::EXTRA_LAZY);

        $metadata->addProperty($association);

        $metadata->addLifecycleCallback('loading', 'postLoad');
        $metadata->addLifecycleCallback('willBeRemoved', 'preRemove');

        foreach ($embeddedClasses as $fieldName => $embeddedClass) {

            $metadata->mapEmbedded(
                [
                    'fieldName'    => $fieldName,
                    'class'        => $embeddedClass->getClassName(),
                    'columnPrefix' => null,
                ]
            );
        }

        $this->generator->writeEntityClass($metadata, $this->tmpDir);

        return $metadata;
    }

    private function generateEntityTypeFixture(array $field)
    {
        $metadata = new ClassMetadata($this->namespace . '\EntityType', $this->staticMetadataBuildingContext);

        $tableMetadata = new Mapping\TableMetadata();
        $tableMetadata->setName('entity_type');

        $metadata->setTable($tableMetadata);

        $fieldMetadata = new Mapping\FieldMetadata('id');
        $fieldMetadata->setType(Type::getType('integer'));
        $fieldMetadata->setPrimaryKey(true);
        $fieldMetadata->setNullable(false);
        $fieldMetadata->setUnique(false);
        $fieldMetadata->setValueGenerator(new Mapping\ValueGeneratorMetadata(Mapping\GeneratorType::AUTO));

        $metadata->addProperty($fieldMetadata);

        $fieldMetadata = new Mapping\FieldMetadata($field['fieldName']);
        $fieldMetadata->setType(Type::getType($field['dbType']));
        $fieldMetadata->setNullable(false);
        $fieldMetadata->setUnique(false);

        $metadata->addProperty($fieldMetadata);

        $this->generator->writeEntityClass($metadata, $this->tmpDir);

        return $metadata;
    }

    /**
     * @return ClassMetadata
     */
    private function generateIsbnEmbeddableFixture(array $embeddedClasses = [], $columnPrefix = null)
    {
        $metadata = new ClassMetadata($this->namespace . '\EntityGeneratorIsbn', $this->staticMetadataBuildingContext);
        $metadata->isEmbeddedClass = true;

        $fieldMetadata = new Mapping\FieldMetadata('prefix');
        $fieldMetadata->setType(Type::getType('integer'));
        $fieldMetadata->setNullable(false);
        $fieldMetadata->setUnique(false);

        $metadata->addProperty($fieldMetadata);

        $fieldMetadata = new Mapping\FieldMetadata('groupNumber');
        $fieldMetadata->setType(Type::getType('integer'));
        $fieldMetadata->setNullable(false);
        $fieldMetadata->setUnique(false);

        $metadata->addProperty($fieldMetadata);

        $fieldMetadata = new Mapping\FieldMetadata('publisherNumber');
        $fieldMetadata->setType(Type::getType('integer'));
        $fieldMetadata->setNullable(false);
        $fieldMetadata->setUnique(false);

        $metadata->addProperty($fieldMetadata);

        $fieldMetadata = new Mapping\FieldMetadata('titleNumber');
        $fieldMetadata->setType(Type::getType('integer'));
        $fieldMetadata->setNullable(false);
        $fieldMetadata->setUnique(false);

        $metadata->addProperty($fieldMetadata);

        $fieldMetadata = new Mapping\FieldMetadata('checkDigit');
        $fieldMetadata->setType(Type::getType('integer'));
        $fieldMetadata->setNullable(false);
        $fieldMetadata->setUnique(false);

        $metadata->addProperty($fieldMetadata);

        foreach ($embeddedClasses as $fieldName => $embeddedClass) {

            $metadata->mapEmbedded(
                [
                    'fieldName'    => $fieldName,
                    'class'        => $embeddedClass->getClassName(),
                    'columnPrefix' => $columnPrefix,
                ]
            );
        }

        $this->generator->writeEntityClass($metadata, $this->tmpDir);

        return $metadata;
    }

    /**
     * @return ClassMetadata
     */
    private function generateTestEmbeddableFixture()
    {
        $metadata = new ClassMetadata($this->namespace . '\EntityGeneratorTestEmbeddable', $this->staticMetadataBuildingContext);

        $metadata->isEmbeddedClass = true;

        $fieldMetadata = new Mapping\FieldMetadata('field1');
        $fieldMetadata->setType(Type::getType('integer'));
        $fieldMetadata->setNullable(false);
        $fieldMetadata->setUnique(false);

        $metadata->addProperty($fieldMetadata);

        $fieldMetadata = new Mapping\FieldMetadata('field2');
        $fieldMetadata->setType(Type::getType('integer'));
        $fieldMetadata->setNullable(true);
        $fieldMetadata->setUnique(false);

        $metadata->addProperty($fieldMetadata);

        $fieldMetadata = new Mapping\FieldMetadata('field3');
        $fieldMetadata->setType(Type::getType('datetime'));
        $fieldMetadata->setNullable(false);
        $fieldMetadata->setUnique(false);

        $metadata->addProperty($fieldMetadata);

        $fieldMetadata = new Mapping\FieldMetadata('field4');
        $fieldMetadata->setType(Type::getType('datetime'));
        $fieldMetadata->setNullable(true);
        $fieldMetadata->setUnique(false);

        $metadata->addProperty($fieldMetadata);

        $this->generator->writeEntityClass($metadata, $this->tmpDir);

        return $metadata;
    }

    /**
     * @param ClassMetadata $metadata
     */
    private function loadEntityClass(ClassMetadata $metadata)
    {
        $className = basename(str_replace('\\', '/', $metadata->getClassName()));
        $path      = $this->tmpDir . '/' . $this->namespace . '/' . $className . '.php';

        self::assertFileExists($path);

        require_once $path;
    }

    /**
     * @param  ClassMetadata $metadata
     *
     * @return mixed An instance of the given metadata's class.
     */
    public function newInstance(ClassMetadata $metadata)
    {
        $this->loadEntityClass($metadata);

        $className = $metadata->getClassName();

        return new $className;
    }

    /**
     * @group embedded
     * @group GH-6314
     */
    public function testEmbeddedEntityWithNamedColumnPrefix()
    {
        $columnPrefix = 'GH6314Prefix_';
        $testMetadata = $this->generateTestEmbeddableFixture();
        $isbnMetadata = $this->generateIsbnEmbeddableFixture(['testEmbedded' => $testMetadata], $columnPrefix);
        $isbnEntity = $this->newInstance($isbnMetadata);
        $refClass = new \ReflectionClass($isbnEntity);
        self::assertTrue($refClass->hasProperty('testEmbedded'));

        $docComment = $refClass->getProperty('testEmbedded')->getDocComment();
        $needle = sprintf('@Embedded(class="%s", columnPrefix="%s")', $testMetadata->getClassName(), $columnPrefix);
        self::assertContains($needle, $docComment);
    }

    /**
     * @group embedded
     * @group GH-6314
     */
    public function testEmbeddedEntityWithoutColumnPrefix()
    {
        $testMetadata = $this->generateTestEmbeddableFixture();
        $isbnMetadata = $this->generateIsbnEmbeddableFixture(['testEmbedded' => $testMetadata], false);
        $isbnEntity = $this->newInstance($isbnMetadata);
        $refClass = new \ReflectionClass($isbnEntity);
        self::assertTrue($refClass->hasProperty('testEmbedded'));

        $docComment = $refClass->getProperty('testEmbedded')->getDocComment();
        $needle = sprintf('@Embedded(class="%s", columnPrefix=false)', $testMetadata->getClassName());
        self::assertContains($needle, $docComment);
    }

    /**
     * @group embedded
     */
    public function testGeneratedEntityClass()
    {
        $testMetadata = $this->generateTestEmbeddableFixture();
        $isbnMetadata = $this->generateIsbnEmbeddableFixture(['test' => $testMetadata]);
        $metadata     = $this->generateBookEntityFixture(['isbn' => $isbnMetadata]);
        $book         = $this->newInstance($metadata);

        $bookClassName = $metadata->getClassName();

        self::assertTrue(class_exists($bookClassName), "Class does not exist.");
        self::assertTrue(method_exists($bookClassName, '__construct'), "EntityGeneratorBook::__construct() missing.");
        self::assertTrue(method_exists($bookClassName, 'getId'), "EntityGeneratorBook::getId() missing.");
        self::assertTrue(method_exists($bookClassName, 'setName'), "EntityGeneratorBook::setName() missing.");
        self::assertTrue(method_exists($bookClassName, 'getName'), "EntityGeneratorBook::getName() missing.");
        self::assertTrue(method_exists($bookClassName, 'setStatus'), "EntityGeneratorBook::setStatus() missing.");
        self::assertTrue(method_exists($bookClassName, 'getStatus'), "EntityGeneratorBook::getStatus() missing.");
        self::assertTrue(method_exists($bookClassName, 'setAuthor'), "EntityGeneratorBook::setAuthor() missing.");
        self::assertTrue(method_exists($bookClassName, 'getAuthor'), "EntityGeneratorBook::getAuthor() missing.");
        self::assertTrue(method_exists($bookClassName, 'getComments'), "EntityGeneratorBook::getComments() missing.");
        self::assertTrue(method_exists($bookClassName, 'addComment'), "EntityGeneratorBook::addComment() missing.");
        self::assertTrue(method_exists($bookClassName, 'removeComment'), "EntityGeneratorBook::removeComment() missing.");
        self::assertTrue(method_exists($bookClassName, 'setIsbn'), "EntityGeneratorBook::setIsbn() missing.");
        self::assertTrue(method_exists($bookClassName, 'getIsbn'), "EntityGeneratorBook::getIsbn() missing.");

        $reflClass = new \ReflectionClass($metadata->getClassName());

        self::assertCount(6, $reflClass->getProperties());
        self::assertCount(15, $reflClass->getMethods());

        self::assertEquals('published', $book->getStatus());

        $book->setName('Jonathan H. Wage');
        self::assertEquals('Jonathan H. Wage', $book->getName());

        $reflMethod = new \ReflectionMethod($metadata->getClassName(), 'addComment');
        $addCommentParameters = $reflMethod->getParameters();
        self::assertEquals('comment', $addCommentParameters[0]->getName());


        $reflMethod = new \ReflectionMethod($metadata->getClassName(), 'removeComment');
        $removeCommentParameters = $reflMethod->getParameters();
        self::assertEquals('comment', $removeCommentParameters[0]->getName());


        $author = new EntityGeneratorAuthor();
        $book->setAuthor($author);
        self::assertEquals($author, $book->getAuthor());

        $comment = new EntityGeneratorComment();
        self::assertInstanceOf($metadata->getClassName(), $book->addComment($comment));
        self::assertInstanceOf(ArrayCollection::class, $book->getComments());
        self::assertEquals(new ArrayCollection([$comment]), $book->getComments());
        self::assertInternalType('boolean', $book->removeComment($comment));
        self::assertEquals(new ArrayCollection([]), $book->getComments());

        $this->newInstance($isbnMetadata);

        $isbnClassName = $isbnMetadata->getClassName();

        $isbn = new $isbnClassName();

        $book->setIsbn($isbn);
        self::assertSame($isbn, $book->getIsbn());

        $reflMethod = new \ReflectionMethod($metadata->getClassName(), 'setIsbn');
        $reflParameters = $reflMethod->getParameters();
        self::assertEquals($isbnMetadata->getClassName(), $reflParameters[0]->getClass()->name);
    }

    /**
     * @group embedded
     */
    public function testEntityUpdatingWorks()
    {
        $metadata = $this->generateBookEntityFixture(['isbn' => $this->generateIsbnEmbeddableFixture()]);

        $fieldMetadata = new Mapping\FieldMetadata('test');

        $fieldMetadata->setType(Type::getType('string'));

        $metadata->addProperty($fieldMetadata);

        $testEmbeddableMetadata = $this->generateTestEmbeddableFixture();

        $metadata->mapEmbedded(
            [
            'fieldName'    => 'testEmbedded',
            'class'        => $testEmbeddableMetadata->getClassName(),
            'columnPrefix' => null,
            ]
        );

        $this->generator->writeEntityClass($metadata, $this->tmpDir);

        self::assertFileExists($this->tmpDir . "/" . $this->namespace . "/EntityGeneratorBook.php~");

        $book = $this->newInstance($metadata);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $reflClass = new \ReflectionClass($metadata->getClassName());

        self::assertTrue($reflClass->hasProperty('name'), "Regenerating keeps property 'name'.");
        self::assertTrue($reflClass->hasProperty('status'), "Regenerating keeps property 'status'.");
        self::assertTrue($reflClass->hasProperty('id'), "Regenerating keeps property 'id'.");
        self::assertTrue($reflClass->hasProperty('isbn'), "Regenerating keeps property 'isbn'.");

        self::assertTrue($reflClass->hasProperty('test'), "Check for property test failed.");
        self::assertTrue($reflClass->getProperty('test')->isProtected(), "Check for protected property test failed.");
        self::assertTrue($reflClass->hasProperty('testEmbedded'), "Check for property testEmbedded failed.");
        self::assertTrue($reflClass->getProperty('testEmbedded')->isProtected(), "Check for protected property testEmbedded failed.");
        self::assertTrue($reflClass->hasMethod('getTest'), "Check for method 'getTest' failed.");
        self::assertTrue($reflClass->getMethod('getTest')->isPublic(), "Check for public visibility of method 'getTest' failed.");
        self::assertTrue($reflClass->hasMethod('setTest'), "Check for method 'setTest' failed.");
        self::assertTrue($reflClass->getMethod('setTest')->isPublic(), "Check for public visibility of method 'setTest' failed.");
        self::assertTrue($reflClass->hasMethod('getTestEmbedded'), "Check for method 'getTestEmbedded' failed.");
        self::assertTrue(
            $reflClass->getMethod('getTestEmbedded')->isPublic(),
            "Check for public visibility of method 'getTestEmbedded' failed."
        );
        self::assertTrue($reflClass->hasMethod('setTestEmbedded'), "Check for method 'setTestEmbedded' failed.");
        self::assertTrue(
            $reflClass->getMethod('setTestEmbedded')->isPublic(),
            "Check for public visibility of method 'setTestEmbedded' failed."
        );
    }

    /**
     * @group DDC-2121
     */
    public function testMethodDocBlockShouldStartWithBackSlash()
    {
        $embeddedMetadata = $this->generateIsbnEmbeddableFixture();
        $metadata = $this->generateBookEntityFixture(['isbn' => $embeddedMetadata]);
        $book     = $this->newInstance($metadata);

        self::assertPhpDocVarType('\Doctrine\Common\Collections\Collection', new \ReflectionProperty($book, 'comments'));
        self::assertPhpDocReturnType('\Doctrine\Common\Collections\Collection', new \ReflectionMethod($book, 'getComments'));
        self::assertPhpDocParamType('\Doctrine\Tests\ORM\Tools\EntityGeneratorComment', new \ReflectionMethod($book, 'addComment'));
        self::assertPhpDocReturnType('EntityGeneratorBook', new \ReflectionMethod($book, 'addComment'));
        self::assertPhpDocParamType('\Doctrine\Tests\ORM\Tools\EntityGeneratorComment', new \ReflectionMethod($book, 'removeComment'));
        self::assertPhpDocReturnType('boolean', new \ReflectionMethod($book, 'removeComment'));

        self::assertPhpDocVarType('\Doctrine\Tests\ORM\Tools\EntityGeneratorAuthor', new \ReflectionProperty($book, 'author'));
        self::assertPhpDocReturnType('\Doctrine\Tests\ORM\Tools\EntityGeneratorAuthor|null', new \ReflectionMethod($book, 'getAuthor'));
        self::assertPhpDocParamType('\Doctrine\Tests\ORM\Tools\EntityGeneratorAuthor|null', new \ReflectionMethod($book, 'setAuthor'));

//        $expectedClassName = '\\' . $embeddedMetadata->getClassName();

//        self::assertPhpDocVarType($expectedClassName, new \ReflectionProperty($book, 'isbn'));
//        self::assertPhpDocReturnType($expectedClassName, new \ReflectionMethod($book, 'getIsbn'));
//        self::assertPhpDocParamType($expectedClassName, new \ReflectionMethod($book, 'setIsbn'));
    }

    public function testEntityExtendsStdClass()
    {
        $this->generator->setClassToExtend('stdClass');
        $metadata = $this->generateBookEntityFixture();

        $book = $this->newInstance($metadata);
        self::assertInstanceOf('stdClass', $book);

        $metadata = $this->generateIsbnEmbeddableFixture();
        $isbn = $this->newInstance($metadata);
        self::assertInstanceOf('stdClass', $isbn);
    }

    public function testLifecycleCallbacks()
    {
        $metadata = $this->generateBookEntityFixture();

        $book = $this->newInstance($metadata);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $reflClass = new \ReflectionClass($metadata->getClassName());

        self::assertTrue($reflClass->hasMethod('loading'), "Check for postLoad lifecycle callback.");
        self::assertTrue($reflClass->hasMethod('willBeRemoved'), "Check for preRemove lifecycle callback.");
    }

    public function testLoadMetadata()
    {
        $embeddedMetadata = $this->generateIsbnEmbeddableFixture();
        $metadata         = $this->generateBookEntityFixture(['isbn' => $embeddedMetadata]);
        $book             = $this->newInstance($metadata);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}

        $cm = new ClassMetadata($metadata->getClassName(), $this->runtimeMetadataBuildingContext);

        $driver = $this->createAnnotationDriver();
        $driver->loadMetadataForClass($cm->getClassName(), $cm, $this->runtimeMetadataBuildingContext);

        self::assertEquals($cm->getTableName(), $metadata->getTableName());
        self::assertEquals($cm->lifecycleCallbacks, $metadata->lifecycleCallbacks);
        self::assertEquals($cm->identifier, $metadata->identifier);
        self::assertEquals($cm->getCustomRepositoryClassName(), $metadata->getCustomRepositoryClassName());
//        self::assertEquals($cm->embeddedClasses, $metadata->embeddedClasses);

//        self::assertEquals($cm->isEmbeddedClass, $metadata->isEmbeddedClass);

        self::assertEquals(Mapping\FetchMode::EXTRA_LAZY, $cm->getProperty('comments')->getFetchMode());
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}

//        $isbn = $this->newInstance($embeddedMetadata);

//
//        $cm = new ClassMetadata($embeddedMetadata->getClassName(), $this->runtimeMetadataBuildingContext);
//
//        $driver->loadMetadataForClass($cm->getClassName(), $cm);
//
//        self::assertEquals($cm->embeddedClasses, $embeddedMetadata->embeddedClasses);
//        self::assertEquals($cm->isEmbeddedClass, $embeddedMetadata->isEmbeddedClass);
    }

    public function testLoadPrefixedMetadata()
    {
        $embeddedMetadata = $this->generateIsbnEmbeddableFixture();
        $metadata = $this->generateBookEntityFixture(['isbn' => $embeddedMetadata]);

        $reader = new AnnotationReader();
        $driver = new AnnotationDriver($reader, []);

        $book = $this->newInstance($metadata);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}

        $cm = new ClassMetadata($metadata->getClassName(), $this->runtimeMetadataBuildingContext);

        $driver->loadMetadataForClass($cm->getClassName(), $cm, $this->runtimeMetadataBuildingContext);

        self::assertEquals($cm->getTableName(), $metadata->getTableName());
        self::assertEquals($cm->lifecycleCallbacks, $metadata->lifecycleCallbacks);
        self::assertEquals($cm->identifier, $metadata->identifier);
        self::assertEquals($cm->getCustomRepositoryClassName(), $metadata->getCustomRepositoryClassName());

//        $isbn = $this->newInstance($embeddedMetadata);

//
//        $cm = new ClassMetadata($embeddedMetadata->getClassName(), $this->runtimeMetadataBuildingContext);
//
//        $driver->loadMetadataForClass($cm->getClassName(), $cm);
//
//        self::assertEquals($cm->embeddedClasses, $embeddedMetadata->embeddedClasses);
//        self::assertEquals($cm->isEmbeddedClass, $embeddedMetadata->isEmbeddedClass);
    }

    /**
     * @group DDC-3272
     */
    public function testMappedSuperclassAnnotationGeneration()
    {
        $metadata = new ClassMetadata($this->namespace . '\EntityGeneratorBook', $this->staticMetadataBuildingContext);

        $metadata->isMappedSuperclass = true;

        $this->generator->writeEntityClass($metadata, $this->tmpDir);

        $this->newInstance($metadata); // force instantiation (causes autoloading to kick in)

        $driver = new AnnotationDriver(new AnnotationReader(), []);
        $cm     = new ClassMetadata($metadata->getClassName(), $this->runtimeMetadataBuildingContext);

        $driver->loadMetadataForClass($cm->getClassName(), $cm, $this->runtimeMetadataBuildingContext);

        self::assertTrue($cm->isMappedSuperclass);
    }

    /**
     * @dataProvider getParseTokensInEntityFileData
     */
    public function testParseTokensInEntityFile($php, $classes)
    {
        $r = new \ReflectionObject($this->generator);
        $m = $r->getMethod('parseTokensInEntityFile');
        $m->setAccessible(true);

        $p = $r->getProperty('staticReflection');
        $p->setAccessible(true);

        $ret = $m->invoke($this->generator, $php);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        self::assertEquals($classes, array_keys($p->getValue($this->generator)));
    }

    /**
     * @group DDC-1784
     */
    public function testGenerateEntityWithSequenceGenerator()
    {
        $metadata = new ClassMetadata($this->namespace . '\DDC1784Entity', $this->staticMetadataBuildingContext);

        $fieldMetadata = new Mapping\FieldMetadata('id');
        $fieldMetadata->setType(Type::getType('integer'));
        $fieldMetadata->setPrimaryKey(true);
        $fieldMetadata->setValueGenerator(new Mapping\ValueGeneratorMetadata(
            Mapping\GeneratorType::SEQUENCE,
            [
                'sequenceName'   => 'DDC1784_ID_SEQ',
                'allocationSize' => 1,
            ]
        ));

        $metadata->addProperty($fieldMetadata);

        $this->generator->writeEntityClass($metadata, $this->tmpDir);

        $filename = $this->tmpDir . DIRECTORY_SEPARATOR
                  . $this->namespace . DIRECTORY_SEPARATOR . 'DDC1784Entity.php';

        self::assertFileExists($filename);

        require_once $filename;

        $reflection = new \ReflectionProperty($metadata->getClassName(), 'id');
        $docComment = $reflection->getDocComment();

        self::assertContains('@ORM\Id', $docComment);
        self::assertContains('@ORM\Column(name="id", type="integer")', $docComment);
        self::assertContains('@ORM\GeneratedValue(strategy="SEQUENCE")', $docComment);
        self::assertContains('@ORM\SequenceGenerator(sequenceName="DDC1784_ID_SEQ", allocationSize=1)', $docComment);
    }

    /**
     * @group DDC-2079
     */
    public function testGenerateEntityWithMultipleInverseJoinColumns()
    {
        $metadata = new ClassMetadata($this->namespace . '\DDC2079Entity', $this->staticMetadataBuildingContext);

        $fieldMetadata = new Mapping\FieldMetadata('id');
        $fieldMetadata->setType(Type::getType('integer'));
        $fieldMetadata->setPrimaryKey(true);
        $fieldMetadata->setValueGenerator(new Mapping\ValueGeneratorMetadata(Mapping\GeneratorType::SEQUENCE));

        $metadata->addProperty($fieldMetadata);

        $joinTable = new Mapping\JoinTableMetadata();
        $joinTable->setName('unidade_centro_custo');

        $joinColumn = new Mapping\JoinColumnMetadata();
        $joinColumn->setColumnName("idorcamento");
        $joinColumn->setReferencedColumnName("idorcamento");

        $joinTable->addJoinColumn($joinColumn);

        $joinColumn = new Mapping\JoinColumnMetadata();
        $joinColumn->setColumnName("idunidade");
        $joinColumn->setReferencedColumnName("idunidade");

        $joinTable->addJoinColumn($joinColumn);

        $joinColumn = new Mapping\JoinColumnMetadata();
        $joinColumn->setColumnName("idcentrocusto");
        $joinColumn->setReferencedColumnName("idcentrocusto");

        $joinTable->addInverseJoinColumn($joinColumn);

        $joinColumn = new Mapping\JoinColumnMetadata();
        $joinColumn->setColumnName("idpais");
        $joinColumn->setReferencedColumnName("idpais");

        $joinTable->addInverseJoinColumn($joinColumn);

        $association = new Mapping\ManyToManyAssociationMetadata('centroCustos');

        $association->setJoinTable($joinTable);
        $association->setTargetEntity($this->namespace . '\\DDC2079CentroCusto');

        $metadata->addProperty($association);

        $this->generator->writeEntityClass($metadata, $this->tmpDir);

        $filename = $this->tmpDir . DIRECTORY_SEPARATOR
            . $this->namespace . DIRECTORY_SEPARATOR . 'DDC2079Entity.php';

        self::assertFileExists($filename);

        require_once $filename;

        $property   = new \ReflectionProperty($metadata->getClassName(), 'centroCustos');
        $docComment = $property->getDocComment();

        //joinColumns
        self::assertContains('@ORM\JoinColumn(name="idorcamento", referencedColumnName="idorcamento"),', $docComment);
        self::assertContains('@ORM\JoinColumn(name="idunidade", referencedColumnName="idunidade")', $docComment);
        //inverseJoinColumns
        self::assertContains('@ORM\JoinColumn(name="idcentrocusto", referencedColumnName="idcentrocusto"),', $docComment);
        self::assertContains('@ORM\JoinColumn(name="idpais", referencedColumnName="idpais")', $docComment);

    }

     /**
     * @group DDC-2172
     */
    public function testGetInheritanceTypeString()
    {
        $reflection = new \ReflectionClass('\Doctrine\ORM\Mapping\ClassMetadata');
        $method     = new \ReflectionMethod($this->generator, 'getInheritanceTypeString');
        $constants  = $reflection->getConstants();
        $pattern    = '/^InheritanceType::/';

        $method->setAccessible(true);

        foreach ($constants as $name => $value) {
            if( ! preg_match($pattern, $name)) {
                continue;
            }

            $expected = preg_replace($pattern, '', $name);
            $actual   = $method->invoke($this->generator, $value);

            self::assertEquals($expected, $actual);
        }

        $this->expectException(\InvalidArgumentException::class);
        $this->expectExceptionMessage('Invalid provided InheritanceType: INVALID');

        $method->invoke($this->generator, 'INVALID');
    }

    /**
    * @group DDC-2172
    */
    public function testGetChangeTrackingPolicyString()
    {
        $reflection = new \ReflectionClass('\Doctrine\ORM\Mapping\ClassMetadata');
        $method     = new \ReflectionMethod($this->generator, 'getChangeTrackingPolicyString');
        $constants  = $reflection->getConstants();
        $pattern    = '/^ChangeTrackingPolicy::/';

        $method->setAccessible(true);

        foreach ($constants as $name => $value) {
            if( ! preg_match($pattern, $name)) {
                continue;
            }

            $expected = preg_replace($pattern, '', $name);
            $actual   = $method->invoke($this->generator, $value);

            self::assertEquals($expected, $actual);
        }

        $this->expectException(\InvalidArgumentException::class);
        $this->expectExceptionMessage('Invalid provided ChangeTrackingPolicy: INVALID');

        $method->invoke($this->generator, 'INVALID');
    }

    /**
     * @group DDC-2172
     */
    public function testGetIdGeneratorTypeString()
    {
        $reflection = new \ReflectionClass('\Doctrine\ORM\Mapping\ClassMetadata');
        $method     = new \ReflectionMethod($this->generator, 'getIdGeneratorTypeString');
        $constants  = $reflection->getConstants();
        $pattern    = '/^GeneratorType::/';

        $method->setAccessible(true);

        foreach ($constants as $name => $value) {
            if( ! preg_match($pattern, $name)) {
                continue;
            }

            $expected = preg_replace($pattern, '', $name);
            $actual   = $method->invoke($this->generator, $value);

            self::assertEquals($expected, $actual);
        }

        $this->expectException(\InvalidArgumentException::class);
        $this->expectExceptionMessage('Invalid provided IdGeneratorType: INVALID');

        $method->invoke($this->generator, 'INVALID');
    }

    /**
     * @dataProvider getEntityTypeAliasDataProvider
     *
     * @group DDC-1694
     */
    public function testEntityTypeAlias(array $field)
    {
        $metadata   = $this->generateEntityTypeFixture($field);
        $path       = $this->tmpDir . '/'. $this->namespace . '/EntityType.php';

        self::assertFileExists($path);
        require_once $path;

        $entityClassName = $metadata->getClassName();

        $entity     = new $entityClassName;
        $reflClass  = new \ReflectionClass($entityClassName);

        $type   = $field['phpType'];
        $name   = $field['fieldName'];
        $value  = $field['value'];
        $getter = "get" . ucfirst($name);
        $setter = "set" . ucfirst($name);

        self::assertPhpDocVarType($type, $reflClass->getProperty($name));
        self::assertPhpDocParamType($type, $reflClass->getMethod($setter));
        self::assertPhpDocReturnType($type, $reflClass->getMethod($getter));

        self::assertSame($entity, $entity->{$setter}($value));
        self::assertEquals($value, $entity->{$getter}());
    }

    /**
     * @group DDC-2372
     */
    public function testTraitPropertiesAndMethodsAreNotDuplicated()
    {
        $cmf = new ClassMetadataFactory();
        $em = $this->getTestEntityManager();
        $cmf->setEntityManager($em);

        $user = new DDC2372User();
        $metadata = $cmf->getMetadataFor(get_class($user));

        // @todo guilhermeblanco Fix this test as changing Entity class should never be allowed.
        $metadata->setClassName($this->namespace . "\DDC2372User");

        $this->generator->writeEntityClass($metadata, $this->tmpDir);

        self::assertFileExists($this->tmpDir . "/" . $this->namespace . "/DDC2372User.php");

        require $this->tmpDir . "/" . $this->namespace . "/DDC2372User.php";

        $reflClass = new \ReflectionClass($metadata->getClassName());

        self::assertSame($reflClass->hasProperty('address'), false);
        self::assertSame($reflClass->hasMethod('setAddress'), false);
        self::assertSame($reflClass->hasMethod('getAddress'), false);
    }

    /**
     * @group DDC-2372
     */
    public function testTraitPropertiesAndMethodsAreNotDuplicatedInChildClasses()
    {
        $cmf = new ClassMetadataFactory();
        $em = $this->getTestEntityManager();
        $cmf->setEntityManager($em);

        $user = new DDC2372Admin();
        $metadata = $cmf->getMetadataFor(get_class($user));

        // @todo guilhermeblanco Fix this test as changing Entity class should never be allowed.
        $metadata->setClassName($this->namespace . "\DDC2372Admin");

        $this->generator->writeEntityClass($metadata, $this->tmpDir);

        self::assertFileExists($this->tmpDir . "/" . $this->namespace . "/DDC2372Admin.php");
        require $this->tmpDir . "/" . $this->namespace . "/DDC2372Admin.php";

        $reflClass = new \ReflectionClass($metadata->getClassName());

        self::assertSame($reflClass->hasProperty('address'), false);
        self::assertSame($reflClass->hasMethod('setAddress'), false);
        self::assertSame($reflClass->hasMethod('getAddress'), false);
    }

    /**
     * @group DDC-1590
     */
    public function testMethodsAndPropertiesAreNotDuplicatedInChildClasses()
    {
        $cmf    = new ClassMetadataFactory();
        $em     = $this->getTestEntityManager();

        $cmf->setEntityManager($em);

        $ns     = $this->namespace;
        $nsdir  = $this->tmpDir . '/' . $ns;

        // Dump DDC1590User into temp file
        $content = str_replace(
            'namespace Doctrine\Tests\Models\DDC1590',
            'namespace ' . $ns,
            file_get_contents(__DIR__ . '/../../Models/DDC1590/DDC1590User.php')
        );

        $fname = $nsdir . "/DDC1590User.php";
        file_put_contents($fname, $content);

        // Require DDC1590User
        require $fname;

        $metadata = $cmf->getMetadataFor($ns . '\DDC1590User');
        $this->generator->writeEntityClass($metadata, $this->tmpDir);

        // class DDC1590User extends DDC1590Entity { ... }

        $source = file_get_contents($fname);

        // class _DDC1590User extends DDC1590Entity { ... }

        $source2    = str_replace('class DDC1590User', 'class _DDC1590User', $source);
        $fname2     = $nsdir . "/_DDC1590User.php";
        file_put_contents($fname2, $source2);
        require $fname2;

        // class __DDC1590User { ... }

        $source3    = str_replace('class DDC1590User extends DDC1590Entity', 'class __DDC1590User', $source);
        $fname3     = $nsdir . "/__DDC1590User.php";
        file_put_contents($fname3, $source3);
        require $fname3;


        // class _DDC1590User extends DDC1590Entity { ... }

        $rc2 = new \ReflectionClass($ns.'\_DDC1590User');

        self::assertTrue($rc2->hasProperty('name'));
        self::assertTrue($rc2->hasProperty('id'));
        self::assertTrue($rc2->hasProperty('created_at'));

        self::assertTrue($rc2->hasMethod('getName'));
        self::assertTrue($rc2->hasMethod('setName'));
        self::assertTrue($rc2->hasMethod('getId'));
        self::assertFalse($rc2->hasMethod('setId'));
        self::assertTrue($rc2->hasMethod('getCreatedAt'));
        self::assertTrue($rc2->hasMethod('setCreatedAt'));

        // class __DDC1590User { ... }

        $rc3 = new \ReflectionClass($ns.'\__DDC1590User');

        self::assertTrue($rc3->hasProperty('name'));
        self::assertFalse($rc3->hasProperty('id'));
        self::assertFalse($rc3->hasProperty('created_at'));

        self::assertTrue($rc3->hasMethod('getName'));
        self::assertTrue($rc3->hasMethod('setName'));
        self::assertFalse($rc3->hasMethod('getId'));
        self::assertFalse($rc3->hasMethod('setId'));
        self::assertFalse($rc3->hasMethod('getCreatedAt'));
        self::assertFalse($rc3->hasMethod('setCreatedAt'));
    }

    /**
     * @group embedded
     * @group DDC-3304
     */
    public function testGeneratedMutableEmbeddablesClass()
    {
        $embeddedMetadata = $this->generateTestEmbeddableFixture();
        $metadata = $this->generateIsbnEmbeddableFixture(['test' => $embeddedMetadata]);

        $isbn = $this->newInstance($metadata);
        $isbnClassName = $metadata->getClassName();

        self::assertTrue(class_exists($isbnClassName), "Class does not exist.");
        self::assertFalse(method_exists($isbnClassName, '__construct'), "EntityGeneratorIsbn::__construct present.");
        self::assertTrue(method_exists($isbnClassName, 'getPrefix'), "EntityGeneratorIsbn::getPrefix() missing.");
        self::assertTrue(method_exists($isbnClassName, 'setPrefix'), "EntityGeneratorIsbn::setPrefix() missing.");
        self::assertTrue(method_exists($isbnClassName, 'getGroupNumber'), "EntityGeneratorIsbn::getGroupNumber() missing.");
        self::assertTrue(method_exists($isbnClassName, 'setGroupNumber'), "EntityGeneratorIsbn::setGroupNumber() missing.");
        self::assertTrue(method_exists($isbnClassName, 'getPublisherNumber'), "EntityGeneratorIsbn::getPublisherNumber() missing.");
        self::assertTrue(method_exists($isbnClassName, 'setPublisherNumber'), "EntityGeneratorIsbn::setPublisherNumber() missing.");
        self::assertTrue(method_exists($isbnClassName, 'getTitleNumber'), "EntityGeneratorIsbn::getTitleNumber() missing.");
        self::assertTrue(method_exists($isbnClassName, 'setTitleNumber'), "EntityGeneratorIsbn::setTitleNumber() missing.");
        self::assertTrue(method_exists($isbnClassName, 'getCheckDigit'), "EntityGeneratorIsbn::getCheckDigit() missing.");
        self::assertTrue(method_exists($isbnClassName, 'setCheckDigit'), "EntityGeneratorIsbn::setCheckDigit() missing.");
        self::assertTrue(method_exists($isbnClassName, 'getTest'), "EntityGeneratorIsbn::getTest() missing.");
        self::assertTrue(method_exists($isbnClassName, 'setTest'), "EntityGeneratorIsbn::setTest() missing.");

        $isbn->setPrefix(978);
        self::assertSame(978, $isbn->getPrefix());

        $this->newInstance($embeddedMetadata);

        $testEmbeddedCLassName = $embeddedMetadata->getClassName();

        $test = new $testEmbeddedCLassName();

        $isbn->setTest($test);
        self::assertSame($test, $isbn->getTest());

        $reflMethod = new \ReflectionMethod($isbnClassName, 'setTest');
        $reflParameters = $reflMethod->getParameters();
        self::assertEquals($embeddedMetadata->getClassName(), $reflParameters[0]->getClass()->name);
    }

    /**
     * @group embedded
     * @group DDC-3304
     */
    public function testGeneratedImmutableEmbeddablesClass()
    {
        $this->generator->setEmbeddablesImmutable(true);
        $embeddedMetadata = $this->generateTestEmbeddableFixture();
        $metadata = $this->generateIsbnEmbeddableFixture(['test' => $embeddedMetadata]);

        $this->loadEntityClass($embeddedMetadata);
        $this->loadEntityClass($metadata);

        $isbnClassName = $metadata->getClassName();

        self::assertTrue(class_exists($isbnClassName), "Class does not exist.");
        self::assertTrue(method_exists($isbnClassName, '__construct'), "EntityGeneratorIsbn::__construct missing.");
        self::assertTrue(method_exists($isbnClassName, 'getPrefix'), "EntityGeneratorIsbn::getPrefix() missing.");
        self::assertFalse(method_exists($isbnClassName, 'setPrefix'), "EntityGeneratorIsbn::setPrefix() present.");
        self::assertTrue(method_exists($isbnClassName, 'getGroupNumber'), "EntityGeneratorIsbn::getGroupNumber() missing.");
        self::assertFalse(method_exists($isbnClassName, 'setGroupNumber'), "EntityGeneratorIsbn::setGroupNumber() present.");
        self::assertTrue(method_exists($isbnClassName, 'getPublisherNumber'), "EntityGeneratorIsbn::getPublisherNumber() missing.");
        self::assertFalse(method_exists($isbnClassName, 'setPublisherNumber'), "EntityGeneratorIsbn::setPublisherNumber() present.");
        self::assertTrue(method_exists($isbnClassName, 'getTitleNumber'), "EntityGeneratorIsbn::getTitleNumber() missing.");
        self::assertFalse(method_exists($isbnClassName, 'setTitleNumber'), "EntityGeneratorIsbn::setTitleNumber() present.");
        self::assertTrue(method_exists($isbnClassName, 'getCheckDigit'), "EntityGeneratorIsbn::getCheckDigit() missing.");
        self::assertFalse(method_exists($isbnClassName, 'setCheckDigit'), "EntityGeneratorIsbn::setCheckDigit() present.");
        self::assertTrue(method_exists($isbnClassName, 'getTest'), "EntityGeneratorIsbn::getTest() missing.");
        self::assertFalse(method_exists($isbnClassName, 'setTest'), "EntityGeneratorIsbn::setTest() present.");

        $embeddedClassName = $embeddedMetadata->getClassName();

        $test = new $embeddedClassName(1, new \DateTime());
        $isbn = new $isbnClassName($test, 978, 3, 12, 732320, 83);

        $reflMethod = new \ReflectionMethod($isbn, '__construct');
        $reflParameters = $reflMethod->getParameters();

        self::assertCount(6, $reflParameters);

        self::assertSame($embeddedMetadata->getClassName(), $reflParameters[0]->getClass()->name);
        self::assertSame('test', $reflParameters[0]->getName());

        self::assertFalse($reflParameters[0]->isOptional());

        self::assertSame('prefix', $reflParameters[1]->getName());

        self::assertFalse($reflParameters[1]->isOptional());

        self::assertSame('groupNumber', $reflParameters[2]->getName());

        self::assertFalse($reflParameters[2]->isOptional());

        self::assertSame('publisherNumber', $reflParameters[3]->getName());

        self::assertFalse($reflParameters[3]->isOptional());

        self::assertSame('titleNumber', $reflParameters[4]->getName());

        self::assertFalse($reflParameters[4]->isOptional());

        self::assertSame('checkDigit', $reflParameters[5]->getName());

        self::assertFalse($reflParameters[5]->isOptional());

        $reflMethod = new \ReflectionMethod($test, '__construct');
        $reflParameters = $reflMethod->getParameters();

        self::assertCount(4, $reflParameters);

        self::assertSame('field1', $reflParameters[0]->getName());

        self::assertFalse($reflParameters[0]->isOptional());

        self::assertSame('DateTime', $reflParameters[1]->getClass()->name);
        self::assertSame('field3', $reflParameters[1]->getName());

        self::assertFalse($reflParameters[1]->isOptional());

        self::assertSame('field2', $reflParameters[2]->getName());

        self::assertTrue($reflParameters[2]->isOptional());

        self::assertSame('DateTime', $reflParameters[3]->getClass()->name);
        self::assertSame('field4', $reflParameters[3]->getName());

        self::assertTrue($reflParameters[3]->isOptional());
    }

    public function testRegenerateEntityClass()
    {
        $metadata = $this->generateBookEntityFixture();
        $this->loadEntityClass($metadata);

        $className = basename(str_replace('\\', '/', $metadata->getClassName()));
        $path = $this->tmpDir . '/' . $this->namespace . '/' . $className . '.php';
        $classTest = file_get_contents($path);

        $this->generator->setRegenerateEntityIfExists(true);
        $this->generator->setBackupExisting(false);

        $this->generator->writeEntityClass($metadata, $this->tmpDir);
        $classNew = file_get_contents($path);

        self::assertSame($classTest,$classNew);
    }

    /**
     * @return array
     */
    public function getEntityTypeAliasDataProvider()
    {
        return [
            [
                [
                'fieldName' => 'datetimetz',
                'phpType' => '\\DateTime',
                'dbType' => 'datetimetz',
                'value' => new \DateTime
                ]
            ],
            [
                [
                'fieldName' => 'datetime',
                'phpType' => '\\DateTime',
                'dbType' => 'datetime',
                'value' => new \DateTime
                ]
            ],
            [
                [
                'fieldName' => 'date',
                'phpType' => '\\DateTime',
                'dbType' => 'date',
                'value' => new \DateTime
                ]
            ],
            [
                [
                'fieldName' => 'time',
                'phpType' => '\DateTime',
                'dbType' => 'time',
                'value' => new \DateTime
                ]
            ],
            [
                [
                'fieldName' => 'object',
                'phpType' => '\stdClass',
                'dbType' => 'object',
                'value' => new \stdClass()
                ]
            ],
            [
                [
                'fieldName' => 'bigint',
                'phpType' => 'int',
                'dbType' => 'bigint',
                'value' => 11
                ]
            ],
            [
                [
                'fieldName' => 'smallint',
                'phpType' => 'int',
                'dbType' => 'smallint',
                'value' => 22
                ]
            ],
            [
                [
                'fieldName' => 'text',
                'phpType' => 'string',
                'dbType' => 'text',
                'value' => 'text'
                ]
            ],
            [
                [
                'fieldName' => 'blob',
                'phpType' => 'string',
                'dbType' => 'blob',
                'value' => 'blob'
                ]
            ],
            [
                [
                'fieldName' => 'decimal',
                'phpType' => 'string',
                'dbType' => 'decimal',
                'value' => '12.34'
                ],
            ]
        ];
    }

    public function getParseTokensInEntityFileData()
    {
        return [
            [
                '<?php namespace Foo\Bar; class Baz {}',
                ['Foo\Bar\Baz'],
            ],
            [
                '<?php namespace Foo\Bar; use Foo; class Baz {}',
                ['Foo\Bar\Baz'],
            ],
            [
                '<?php namespace /*Comment*/ Foo\Bar; /** Foo */class /* Comment */ Baz {}',
                ['Foo\Bar\Baz'],
            ],
            [
                '
<?php namespace
/*Comment*/
Foo\Bar
;

/** Foo */
class
/* Comment */
 Baz {}
     ',
                ['Foo\Bar\Baz'],
            ],
            [
                '
<?php namespace Foo\Bar; class Baz {
    public static function someMethod(){
        return self::class;
    }
}
',
                ['Foo\Bar\Baz'],
            ],
        ];
    }

    /**
     * @param string $type
     * @param \ReflectionProperty $property
     */
    private function assertPhpDocVarType($type, \ReflectionProperty $property)
    {
        $docComment = $property->getDocComment();
        $regex      = '/@var\s+([\S]+)$/m';

        self::assertRegExp($regex, $docComment);
        self::assertEquals(1, preg_match($regex, $docComment, $matches));
        self::assertEquals($type, $matches[1]);
    }

    /**
     * @param string $type
     * @param \ReflectionMethod $method
     */
    private function assertPhpDocReturnType($type, \ReflectionMethod $method)
    {
        $docComment = $method->getDocComment();
        $regex      = '/@return\s+([\S]+)(\s+.*)$/m';

        self::assertRegExp($regex, $docComment);
        self::assertEquals(1, preg_match($regex, $docComment, $matches));
        self::assertEquals($type, $matches[1]);
    }

    /**
     * @param string $type
     * @param \ReflectionProperty $method
     */
    private function assertPhpDocParamType($type, \ReflectionMethod $method)
    {
        self::assertEquals(1, preg_match('/@param\s+([^\s]+)/', $method->getDocComment(), $matches));
        self::assertEquals($type, $matches[1]);
    }
}

class EntityGeneratorAuthor {}
class EntityGeneratorComment {}

1			<?php
2
3			declare(strict_types=1);
4
5			namespace Doctrine\Tests\ORM\Tools;
6
7			use Doctrine\Common\Annotations\AnnotationReader;
8			use Doctrine\Common\Collections\ArrayCollection;
9			use Doctrine\DBAL\Types\Type;
10			use Doctrine\ORM\Mapping\ClassMetadataFactory;
11			use Doctrine\ORM\Mapping\ClassMetadata;
12			use Doctrine\ORM\Mapping\Driver\AnnotationDriver;
13			use Doctrine\ORM\Mapping;
14			use Doctrine\ORM\Reflection\RuntimeReflectionService;
15			use Doctrine\ORM\Reflection\StaticReflectionService;
16			use Doctrine\ORM\Tools\EntityGenerator;
17			use Doctrine\Tests\Models\DDC2372\DDC2372Admin;
18			use Doctrine\Tests\Models\DDC2372\DDC2372User;
19			use Doctrine\Tests\OrmTestCase;
20			use SebastianBergmann\Environment\Runtime;
21
22			class EntityGeneratorTest extends OrmTestCase
23			{
24			/**
25			* @var EntityGenerator
26			*/
27			private $generator;
28			private $tmpDir;
29			private $namespace;
30
31			/**
32			* @var Mapping\ClassMetadataBuildingContext
33			*/
34			private $staticMetadataBuildingContext;
35
36			/**
37			* @var Mapping\ClassMetadataBuildingContext
38			*/
39			private $runtimeMetadataBuildingContext;
40
doctrine / orm

Push — develop ( ba9041...24f682 )

testEmbeddedEntityWithNamedColumnPrefix() A

Complexity

Size

Duplication

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like
