Update to drupal 8.0.0-rc1. For more information, see https://www.drupal.org/node/2582663

vendor/doctrine/common/tests/Doctrine/Tests/Common/Reflection/DeeperNamespaceParent.php

@@ -0,0 +1,7 @@
+<?php
+
+namespace Doctrine\Tests\Common\Reflection;
+
+class DeeperNamespaceParent extends Dummies\NoParent
+{
+}

vendor/doctrine/common/tests/Doctrine/Tests/Common/Reflection/Dummies/NoParent.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace Doctrine\Tests\Common\Reflection\Dummies;
+
+class NoParent
+{
+    public $test;
+}

vendor/doctrine/common/tests/Doctrine/Tests/Common/Reflection/ExampleAnnotationClass.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace Doctrine\Tests\Common\Reflection;
+
+use Doctrine\Common\Annotations\Annotation;
+
+/**
+ * @Annotation(
+ *   key = "value"
+ * )
+ */
+class ExampleAnnotationClass {
+
+} 

vendor/doctrine/common/tests/Doctrine/Tests/Common/Reflection/FullyClassifiedParent.php

@@ -0,0 +1,7 @@
+<?php
+
+namespace Doctrine\Tests\Common\Reflection;
+
+class FullyClassifiedParent extends \Doctrine\Tests\Common\Reflection\NoParent
+{
+}

vendor/doctrine/common/tests/Doctrine/Tests/Common/Reflection/NoParent.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace Doctrine\Tests\Common\Reflection;
+
+class NoParent
+{
+    public $test;
+}

vendor/doctrine/common/tests/Doctrine/Tests/Common/Reflection/RuntimePublicReflectionPropertyTest.php

@@ -0,0 +1,192 @@
+<?php
+
+namespace Doctrine\Tests\Common\Reflection;
+
+use PHPUnit_Framework_TestCase;
+use Doctrine\Common\Reflection\RuntimePublicReflectionProperty;
+use Doctrine\Common\Proxy\Proxy;
+
+class RuntimePublicReflectionPropertyTest extends PHPUnit_Framework_TestCase
+{
+    public function testGetValueOnProxyPublicProperty()
+    {
+        $getCheckMock = $this->getMock('stdClass', array('callGet'));
+        $getCheckMock->expects($this->never())->method('callGet');
+        $initializer = function () use ($getCheckMock) {
+            call_user_func($getCheckMock);
+        };
+
+        $mockProxy = new RuntimePublicReflectionPropertyTestProxyMock();
+        $mockProxy->__setInitializer($initializer);
+
+        $reflProperty = new RuntimePublicReflectionProperty(
+            __NAMESPACE__ . '\RuntimePublicReflectionPropertyTestProxyMock',
+            'checkedProperty'
+        );
+
+        $this->assertSame('testValue', $reflProperty->getValue($mockProxy));
+        unset($mockProxy->checkedProperty);
+        $this->assertNull($reflProperty->getValue($mockProxy));
+    }
+
+    public function testSetValueOnProxyPublicProperty()
+    {
+        $setCheckMock = $this->getMock('stdClass', array('neverCallSet'));
+        $setCheckMock->expects($this->never())->method('neverCallSet');
+        $initializer = function () use ($setCheckMock) {
+            call_user_func(array($setCheckMock, 'neverCallSet'));
+        };
+
+        $mockProxy = new RuntimePublicReflectionPropertyTestProxyMock();
+        $mockProxy->__setInitializer($initializer);
+
+        $reflProperty = new RuntimePublicReflectionProperty(
+            __NAMESPACE__ . '\RuntimePublicReflectionPropertyTestProxyMock',
+            'checkedProperty'
+        );
+
+        $reflProperty->setValue($mockProxy, 'newValue');
+        $this->assertSame('newValue', $mockProxy->checkedProperty);
+
+        unset($mockProxy->checkedProperty);
+        $reflProperty->setValue($mockProxy, 'otherNewValue');
+        $this->assertSame('otherNewValue', $mockProxy->checkedProperty);
+
+        $setCheckMock = $this->getMock('stdClass', array('callSet'));
+        $setCheckMock->expects($this->once())->method('callSet');
+        $initializer = function () use ($setCheckMock) {
+            call_user_func(array($setCheckMock, 'callSet'));
+        };
+
+        $mockProxy->__setInitializer($initializer);
+        $mockProxy->__setInitialized(true);
+
+        unset($mockProxy->checkedProperty);
+        $reflProperty->setValue($mockProxy, 'againNewValue');
+        $this->assertSame('againNewValue', $mockProxy->checkedProperty);
+    }
+}
+
+/**
+ * Mock that simulates proxy public property lazy loading
+ */
+class RuntimePublicReflectionPropertyTestProxyMock implements Proxy
+{
+    /**
+     * @var \Closure|null
+     */
+    private $initializer     = null;
+
+    /**
+     * @var \Closure|null
+     */
+    private $initialized     = false;
+
+    /**
+     * @var string
+     */
+    public  $checkedProperty = 'testValue';
+
+    /**
+     * {@inheritDoc}
+     */
+    public function __getInitializer()
+    {
+        return $this->initializer;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function __setInitializer(\Closure $initializer = null)
+    {
+        $this->initializer = $initializer;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function __getLazyProperties()
+    {
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function __load()
+    {
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function __isInitialized()
+    {
+        return $this->initialized;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function __setInitialized($initialized)
+    {
+        $this->initialized = (bool) $initialized;
+    }
+
+    /**
+     * @param string $name
+     */
+    public function __get($name)
+    {
+        if ($this->initializer) {
+            $cb = $this->initializer;
+            $cb();
+        }
+
+        return $this->checkedProperty;
+    }
+
+    /**
+     * @param string $name
+     * @param mixed  $value
+     */
+    public function __set($name, $value)
+    {
+        if ($this->initializer) {
+            $cb = $this->initializer;
+            $cb();
+        }
+
+        // triggers notices if `$name` is used: see https://bugs.php.net/bug.php?id=63463
+        $this->checkedProperty = $value;
+    }
+
+    /**
+     * @param string $name
+     *
+     * @return integer
+     */
+    public function __isset($name)
+    {
+        if ($this->initializer) {
+            $cb = $this->initializer;
+            $cb();
+        }
+
+        return isset($this->checkedProperty);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function __setCloner(\Closure $cloner = null)
+    {
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function __getCloner()
+    {
+    }
+}

vendor/doctrine/common/tests/Doctrine/Tests/Common/Reflection/SameNamespaceParent.php

@@ -0,0 +1,7 @@
+<?php
+
+namespace Doctrine\Tests\Common\Reflection;
+
+class SameNamespaceParent extends NoParent
+{
+}

vendor/doctrine/common/tests/Doctrine/Tests/Common/Reflection/StaticReflectionParserTest.php

@@ -0,0 +1,93 @@
+<?php
+
+namespace Doctrine\Tests\Common\Reflection;
+
+use Doctrine\Tests\DoctrineTestCase;
+use Doctrine\Common\Reflection\StaticReflectionParser;
+use Doctrine\Common\Reflection\Psr0FindFile;
+
+class StaticReflectionParserTest extends DoctrineTestCase
+{
+    /**
+     * @dataProvider parentClassData
+     *
+     * @param bool $classAnnotationOptimize
+     * @param string $parsedClassName
+     * @param string $expectedClassName
+     *
+     * @return void
+     */
+    public function testParentClass($classAnnotationOptimize, $parsedClassName, $expectedClassName)
+    {
+        // If classed annotation optimization is enabled the properties tested
+        // below cannot be found.
+        if ($classAnnotationOptimize) {
+            $this->setExpectedException('ReflectionException');
+        }
+
+        $testsRoot = substr(__DIR__, 0, -strlen(__NAMESPACE__) - 1);
+        $paths = array(
+            'Doctrine\\Tests' => array($testsRoot),
+        );
+        $staticReflectionParser = new StaticReflectionParser($parsedClassName, new Psr0FindFile($paths), $classAnnotationOptimize);
+        $declaringClassName = $staticReflectionParser->getStaticReflectionParserForDeclaringClass('property', 'test')->getClassName();
+        $this->assertEquals($expectedClassName, $declaringClassName);
+
+    }
+
+    /**
+     * @return array
+     */
+    public function parentClassData()
+    {
+        $data = array();
+        $noParentClassName = 'Doctrine\\Tests\\Common\\Reflection\\NoParent';
+        $dummyParentClassName = 'Doctrine\\Tests\\Common\\Reflection\\Dummies\\NoParent';
+        foreach (array(false, true) as $classAnnotationOptimize) {
+            $data[] = array(
+              $classAnnotationOptimize, $noParentClassName, $noParentClassName,
+            );
+            $data[] = array(
+              $classAnnotationOptimize, 'Doctrine\\Tests\\Common\\Reflection\\FullyClassifiedParent', $noParentClassName,
+            );
+            $data[] = array(
+              $classAnnotationOptimize, 'Doctrine\\Tests\\Common\\Reflection\\SameNamespaceParent', $noParentClassName,
+            );
+            $data[] = array(
+              $classAnnotationOptimize, 'Doctrine\\Tests\\Common\\Reflection\\DeeperNamespaceParent', $dummyParentClassName,
+            );
+            $data[] = array(
+              $classAnnotationOptimize, 'Doctrine\\Tests\\Common\\Reflection\\UseParent', $dummyParentClassName,
+            );
+        }
+        return $data;
+    }
+
+    /**
+     * @dataProvider classAnnotationOptimize
+     */
+    public function testClassAnnotationOptimizedParsing($classAnnotationOptimize) {
+        $testsRoot = substr(__DIR__, 0, -strlen(__NAMESPACE__) - 1);
+        $paths = array(
+          'Doctrine\\Tests' => array($testsRoot),
+        );
+        $staticReflectionParser = new StaticReflectionParser('Doctrine\\Tests\\Common\\Reflection\\ExampleAnnotationClass', new Psr0FindFile($paths), $classAnnotationOptimize);
+        $expectedDocComment = '/**
+ * @Annotation(
+ *   key = "value"
+ * )
+ */';
+        $this->assertEquals($expectedDocComment, $staticReflectionParser->getDocComment('class'));
+    }
+
+    /**
+     * @return array
+     */
+    public function classAnnotationOptimize()
+    {
+        return array(
+            array(false),
+            array(true)
+        );
+    }
+}

vendor/doctrine/common/tests/Doctrine/Tests/Common/Reflection/UseParent.php

@@ -0,0 +1,9 @@
+<?php
+
+namespace Doctrine\Tests\Common\Reflection;
+
+use Doctrine\Tests\Common\Reflection\Dummies\NoParent as Test;
+
+class UseParent extends Test
+{
+}