the whole shebang

2014-11-25 16:42:40 +01:00
parent 7f74c0613e
commit ab1334c0cf
3686 changed files with 496409 additions and 1 deletions
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/AbstractReaderTest.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/AbstractReaderTest.php
@@ -0,0 +1,571 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations;
+
+use Doctrine\Common\Annotations\DoctrineReader;
+use Doctrine\Common\Annotations\Annotation\IgnoreAnnotation;
+use Doctrine\Common\Annotations\Annotation\IgnorePhpDoc;
+use ReflectionClass, Doctrine\Common\Annotations\AnnotationReader;
+
+use Doctrine\Tests\Common\Annotations\DummyAnnotation;
+use Doctrine\Tests\Common\Annotations\Name;
+use Doctrine\Tests\Common\Annotations\DummyId;
+use Doctrine\Tests\Common\Annotations\DummyJoinTable;
+use Doctrine\Tests\Common\Annotations\DummyJoinColumn;
+use Doctrine\Tests\Common\Annotations\DummyColumn;
+use Doctrine\Tests\Common\Annotations\DummyGeneratedValue;
+
+require_once __DIR__ . '/TopLevelAnnotation.php';
+
+abstract class AbstractReaderTest extends \PHPUnit_Framework_TestCase
+{
+    public function getReflectionClass()
+    {
+        $className = 'Doctrine\Tests\Common\Annotations\DummyClass';
+        return new ReflectionClass($className);
+    }
+
+    public function testAnnotations()
+    {
+        $class = $this->getReflectionClass();
+        $reader = $this->getReader();
+
+        $this->assertEquals(1, count($reader->getClassAnnotations($class)));
+        $this->assertInstanceOf($annotName = 'Doctrine\Tests\Common\Annotations\DummyAnnotation', $annot = $reader->getClassAnnotation($class, $annotName));
+        $this->assertEquals("hello", $annot->dummyValue);
+
+        $field1Prop = $class->getProperty('field1');
+        $propAnnots = $reader->getPropertyAnnotations($field1Prop);
+        $this->assertEquals(1, count($propAnnots));
+        $this->assertInstanceOf($annotName, $annot = $reader->getPropertyAnnotation($field1Prop, $annotName));
+        $this->assertEquals("fieldHello", $annot->dummyValue);
+
+        $getField1Method = $class->getMethod('getField1');
+        $methodAnnots = $reader->getMethodAnnotations($getField1Method);
+        $this->assertEquals(1, count($methodAnnots));
+        $this->assertInstanceOf($annotName, $annot = $reader->getMethodAnnotation($getField1Method, $annotName));
+        $this->assertEquals(array(1, 2, "three"), $annot->value);
+
+        $field2Prop = $class->getProperty('field2');
+        $propAnnots = $reader->getPropertyAnnotations($field2Prop);
+        $this->assertEquals(1, count($propAnnots));
+        $this->assertInstanceOf($annotName = 'Doctrine\Tests\Common\Annotations\DummyJoinTable', $joinTableAnnot = $reader->getPropertyAnnotation($field2Prop, $annotName));
+        $this->assertEquals(1, count($joinTableAnnot->joinColumns));
+        $this->assertEquals(1, count($joinTableAnnot->inverseJoinColumns));
+        $this->assertTrue($joinTableAnnot->joinColumns[0] instanceof DummyJoinColumn);
+        $this->assertTrue($joinTableAnnot->inverseJoinColumns[0] instanceof DummyJoinColumn);
+        $this->assertEquals('col1', $joinTableAnnot->joinColumns[0]->name);
+        $this->assertEquals('col2', $joinTableAnnot->joinColumns[0]->referencedColumnName);
+        $this->assertEquals('col3', $joinTableAnnot->inverseJoinColumns[0]->name);
+        $this->assertEquals('col4', $joinTableAnnot->inverseJoinColumns[0]->referencedColumnName);
+
+        $dummyAnnot = $reader->getMethodAnnotation($class->getMethod('getField1'), 'Doctrine\Tests\Common\Annotations\DummyAnnotation');
+        $this->assertEquals('', $dummyAnnot->dummyValue);
+        $this->assertEquals(array(1, 2, 'three'), $dummyAnnot->value);
+
+        $dummyAnnot = $reader->getPropertyAnnotation($class->getProperty('field1'), 'Doctrine\Tests\Common\Annotations\DummyAnnotation');
+        $this->assertEquals('fieldHello', $dummyAnnot->dummyValue);
+
+        $classAnnot = $reader->getClassAnnotation($class, 'Doctrine\Tests\Common\Annotations\DummyAnnotation');
+        $this->assertEquals('hello', $classAnnot->dummyValue);
+    }
+
+    public function testAnnotationsWithValidTargets()
+    {
+        $reader = $this->getReader();
+        $class  = new ReflectionClass('Doctrine\Tests\Common\Annotations\Fixtures\ClassWithValidAnnotationTarget');
+
+        $this->assertEquals(1,count($reader->getClassAnnotations($class)));
+        $this->assertEquals(1,count($reader->getPropertyAnnotations($class->getProperty('foo'))));
+        $this->assertEquals(1,count($reader->getMethodAnnotations($class->getMethod('someFunction'))));
+        $this->assertEquals(1,count($reader->getPropertyAnnotations($class->getProperty('nested'))));
+    }
+
+    public function testAnnotationsWithVarType()
+    {
+        $reader = $this->getReader();
+        $class  = new ReflectionClass('Doctrine\Tests\Common\Annotations\Fixtures\ClassWithAnnotationWithVarType');
+
+        $this->assertEquals(1,count($fooAnnot = $reader->getPropertyAnnotations($class->getProperty('foo'))));
+        $this->assertEquals(1,count($barAnnot = $reader->getMethodAnnotations($class->getMethod('bar'))));
+
+        $this->assertInternalType('string',  $fooAnnot[0]->string);
+        $this->assertInstanceOf('Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll', $barAnnot[0]->annotation);
+    }
+
+     /**
+     * @expectedException Doctrine\Common\Annotations\AnnotationException
+     * @expectedExceptionMessage [Semantical Error] Annotation @AnnotationTargetPropertyMethod is not allowed to be declared on class Doctrine\Tests\Common\Annotations\Fixtures\ClassWithInvalidAnnotationTargetAtClass. You may only use this annotation on these code elements: METHOD, PROPERTY
+     */
+    public function testClassWithInvalidAnnotationTargetAtClassDocBlock()
+    {
+        $reader  = $this->getReader();
+        $reader->getClassAnnotations(new \ReflectionClass('Doctrine\Tests\Common\Annotations\Fixtures\ClassWithInvalidAnnotationTargetAtClass'));
+    }
+
+    public function testClassWithWithInclude()
+    {
+        $reader = $this->getReader();
+        $annots = $reader->getClassAnnotations(new \ReflectionClass('Doctrine\Tests\Common\Annotations\Fixtures\ClassWithRequire'));
+        $this->assertCount(1, $annots);
+    }
+
+     /**
+     * @expectedException Doctrine\Common\Annotations\AnnotationException
+     * @expectedExceptionMessage [Semantical Error] Annotation @AnnotationTargetClass is not allowed to be declared on property Doctrine\Tests\Common\Annotations\Fixtures\ClassWithInvalidAnnotationTargetAtProperty::$foo. You may only use this annotation on these code elements: CLASS
+     */
+    public function testClassWithInvalidAnnotationTargetAtPropertyDocBlock()
+    {
+        $reader  = $this->getReader();
+        $reader->getPropertyAnnotations(new \ReflectionProperty('Doctrine\Tests\Common\Annotations\Fixtures\ClassWithInvalidAnnotationTargetAtProperty', 'foo'));
+    }
+
+     /**
+     * @expectedException Doctrine\Common\Annotations\AnnotationException
+     * @expectedExceptionMessage [Semantical Error] Annotation @AnnotationTargetAnnotation is not allowed to be declared on property Doctrine\Tests\Common\Annotations\Fixtures\ClassWithInvalidAnnotationTargetAtProperty::$bar. You may only use this annotation on these code elements: ANNOTATION
+     */
+    public function testClassWithInvalidNestedAnnotationTargetAtPropertyDocBlock()
+    {
+        $reader  = $this->getReader();
+        $reader->getPropertyAnnotations(new \ReflectionProperty('Doctrine\Tests\Common\Annotations\Fixtures\ClassWithInvalidAnnotationTargetAtProperty', 'bar'));
+    }
+
+     /**
+     * @expectedException Doctrine\Common\Annotations\AnnotationException
+     * @expectedExceptionMessage [Semantical Error] Annotation @AnnotationTargetClass is not allowed to be declared on method Doctrine\Tests\Common\Annotations\Fixtures\ClassWithInvalidAnnotationTargetAtMethod::functionName(). You may only use this annotation on these code elements: CLASS
+     */
+    public function testClassWithInvalidAnnotationTargetAtMethodDocBlock()
+    {
+        $reader  = $this->getReader();
+        $reader->getMethodAnnotations(new \ReflectionMethod('Doctrine\Tests\Common\Annotations\Fixtures\ClassWithInvalidAnnotationTargetAtMethod', 'functionName'));
+    }
+
+    /**
+     * @expectedException Doctrine\Common\Annotations\AnnotationException
+     * @expectedExceptionMessage Expected namespace separator or identifier, got ')' at position 24 in class @Doctrine\Tests\Common\Annotations\Fixtures\AnnotationWithTargetSyntaxError.
+     */
+    public function testClassWithAnnotationWithTargetSyntaxErrorAtClassDocBlock()
+    {
+        $reader  = $this->getReader();
+        $reader->getClassAnnotations(new \ReflectionClass('Doctrine\Tests\Common\Annotations\Fixtures\ClassWithAnnotationWithTargetSyntaxError'));
+    }
+
+    /**
+     * @expectedException Doctrine\Common\Annotations\AnnotationException
+     * @expectedExceptionMessage Expected namespace separator or identifier, got ')' at position 24 in class @Doctrine\Tests\Common\Annotations\Fixtures\AnnotationWithTargetSyntaxError.
+     */
+    public function testClassWithAnnotationWithTargetSyntaxErrorAtPropertyDocBlock()
+    {
+        $reader  = $this->getReader();
+        $reader->getPropertyAnnotations(new \ReflectionProperty('Doctrine\Tests\Common\Annotations\Fixtures\ClassWithAnnotationWithTargetSyntaxError','foo'));
+    }
+
+    /**
+     * @expectedException Doctrine\Common\Annotations\AnnotationException
+     * @expectedExceptionMessage Expected namespace separator or identifier, got ')' at position 24 in class @Doctrine\Tests\Common\Annotations\Fixtures\AnnotationWithTargetSyntaxError.
+     */
+    public function testClassWithAnnotationWithTargetSyntaxErrorAtMethodDocBlock()
+    {
+        $reader  = $this->getReader();
+        $reader->getMethodAnnotations(new \ReflectionMethod('Doctrine\Tests\Common\Annotations\Fixtures\ClassWithAnnotationWithTargetSyntaxError','bar'));
+    }
+
+    /**
+     * @expectedException Doctrine\Common\Annotations\AnnotationException
+     * @expectedExceptionMessage [Type Error] Attribute "string" of @AnnotationWithVarType declared on property Doctrine\Tests\Common\Annotations\Fixtures\ClassWithAnnotationWithVarType::$invalidProperty expects a(n) string, but got integer.
+     */
+    public function testClassWithPropertyInvalidVarTypeError()
+    {
+        $reader = $this->getReader();
+        $class  = new ReflectionClass('Doctrine\Tests\Common\Annotations\Fixtures\ClassWithAnnotationWithVarType');
+
+        $reader->getPropertyAnnotations($class->getProperty('invalidProperty'));
+    }
+
+    /**
+     * @expectedException Doctrine\Common\Annotations\AnnotationException
+     * @expectedExceptionMessage [Type Error] Attribute "annotation" of @AnnotationWithVarType declared on method Doctrine\Tests\Common\Annotations\Fixtures\ClassWithAnnotationWithVarType::invalidMethod() expects a(n) Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll, but got an instance of Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAnnotation.
+     */
+    public function testClassWithMethodInvalidVarTypeError()
+    {
+        $reader = $this->getReader();
+        $class  = new ReflectionClass('Doctrine\Tests\Common\Annotations\Fixtures\ClassWithAnnotationWithVarType');
+
+        $reader->getMethodAnnotations($class->getMethod('invalidMethod'));
+    }
+
+    /**
+     * @expectedException Doctrine\Common\Annotations\AnnotationException
+     * @expectedExceptionMessage Expected namespace separator or identifier, got ')' at position 18 in class Doctrine\Tests\Common\Annotations\DummyClassSyntaxError.
+     */
+    public function testClassSyntaxErrorContext()
+    {
+        $reader = $this->getReader();
+        $reader->getClassAnnotations(new \ReflectionClass('Doctrine\Tests\Common\Annotations\DummyClassSyntaxError'));
+    }
+
+    /**
+     * @expectedException Doctrine\Common\Annotations\AnnotationException
+     * @expectedExceptionMessage Expected namespace separator or identifier, got ')' at position 18 in method Doctrine\Tests\Common\Annotations\DummyClassMethodSyntaxError::foo().
+     */
+    public function testMethodSyntaxErrorContext()
+    {
+        $reader = $this->getReader();
+        $reader->getMethodAnnotations(new \ReflectionMethod('Doctrine\Tests\Common\Annotations\DummyClassMethodSyntaxError', 'foo'));
+    }
+
+    /**
+     * @expectedException Doctrine\Common\Annotations\AnnotationException
+     * @expectedExceptionMessage Expected namespace separator or identifier, got ')' at position 18 in property Doctrine\Tests\Common\Annotations\DummyClassPropertySyntaxError::$foo.
+     */
+    public function testPropertySyntaxErrorContext()
+    {
+        $reader = $this->getReader();
+        $reader->getPropertyAnnotations(new \ReflectionProperty('Doctrine\Tests\Common\Annotations\DummyClassPropertySyntaxError', 'foo'));
+    }
+
+    /**
+     * @group regression
+     */
+    public function testMultipleAnnotationsOnSameLine()
+    {
+        $reader = $this->getReader();
+        $annots = $reader->getPropertyAnnotations(new \ReflectionProperty('Doctrine\Tests\Common\Annotations\DummyClass2', 'id'));
+        $this->assertEquals(3, count($annots));
+    }
+
+    public function testNonAnnotationProblem()
+    {
+        $reader = $this->getReader();
+
+        $this->assertNotNull($annot = $reader->getPropertyAnnotation(new \ReflectionProperty('Doctrine\Tests\Common\Annotations\DummyClassNonAnnotationProblem', 'foo'), $name = 'Doctrine\Tests\Common\Annotations\DummyAnnotation'));
+        $this->assertInstanceOf($name, $annot);
+    }
+
+    public function testImportWithConcreteAnnotation()
+    {
+        $reader = $this->getReader();
+        $property = new \ReflectionProperty('Doctrine\Tests\Common\Annotations\TestImportWithConcreteAnnotation', 'field');
+        $annotations = $reader->getPropertyAnnotations($property);
+        $this->assertEquals(1, count($annotations));
+        $this->assertNotNull($reader->getPropertyAnnotation($property, 'Doctrine\Tests\Common\Annotations\DummyAnnotation'));
+    }
+
+    public function testImportWithInheritance()
+    {
+        $reader = $this->getReader();
+
+        $class = new TestParentClass();
+        $ref = new \ReflectionClass($class);
+
+        $childAnnotations = $reader->getPropertyAnnotations($ref->getProperty('child'));
+        $this->assertEquals(1, count($childAnnotations));
+        $this->assertInstanceOf('Doctrine\Tests\Common\Annotations\Foo\Name', reset($childAnnotations));
+
+        $parentAnnotations = $reader->getPropertyAnnotations($ref->getProperty('parent'));
+        $this->assertEquals(1, count($parentAnnotations));
+        $this->assertInstanceOf('Doctrine\Tests\Common\Annotations\Bar\Name', reset($parentAnnotations));
+    }
+
+    /**
+     * @expectedException Doctrine\Common\Annotations\AnnotationException
+     * @expectedExceptionMessage The annotation "@NameFoo" in property Doctrine\Tests\Common\Annotations\TestAnnotationNotImportedClass::$field was never imported.
+     */
+    public function testImportDetectsNotImportedAnnotation()
+    {
+        $reader = $this->getReader();
+        $reader->getPropertyAnnotations(new \ReflectionProperty('Doctrine\Tests\Common\Annotations\TestAnnotationNotImportedClass', 'field'));
+    }
+
+    /**
+     * @expectedException Doctrine\Common\Annotations\AnnotationException
+     * @expectedExceptionMessage The annotation "@Foo\Bar\Name" in property Doctrine\Tests\Common\Annotations\TestNonExistentAnnotationClass::$field was never imported.
+     */
+    public function testImportDetectsNonExistentAnnotation()
+    {
+        $reader = $this->getReader();
+        $reader->getPropertyAnnotations(new \ReflectionProperty('Doctrine\Tests\Common\Annotations\TestNonExistentAnnotationClass', 'field'));
+    }
+
+    public function testTopLevelAnnotation()
+    {
+        $reader = $this->getReader();
+        $annotations = $reader->getPropertyAnnotations(new \ReflectionProperty('Doctrine\Tests\Common\Annotations\TestTopLevelAnnotationClass', 'field'));
+
+        $this->assertEquals(1, count($annotations));
+        $this->assertInstanceOf('\TopLevelAnnotation', reset($annotations));
+    }
+
+    public function testIgnoresAnnotationsNotPrefixedWithWhitespace()
+    {
+        $reader = $this->getReader();
+
+        $annotation = $reader->getClassAnnotation(new \ReflectionClass(new TestIgnoresNonAnnotationsClass()), 'Doctrine\Tests\Common\Annotations\Name');
+        $this->assertInstanceOf('Doctrine\Tests\Common\Annotations\Name', $annotation);
+    }
+
+    /**
+     * @expectedException Doctrine\Common\Annotations\AnnotationException
+     * @expectedExceptionMessage The class "Doctrine\Tests\Common\Annotations\Fixtures\NoAnnotation" is not annotated with @Annotation. Are you sure this class can be used as annotation? If so, then you need to add @Annotation to the _class_ doc comment of "Doctrine\Tests\Common\Annotations\Fixtures\NoAnnotation". If it is indeed no annotation, then you need to add @IgnoreAnnotation("NoAnnotation") to the _class_ doc comment of class Doctrine\Tests\Common\Annotations\Fixtures\InvalidAnnotationUsageClass.
+     */
+    public function testErrorWhenInvalidAnnotationIsUsed()
+    {
+        $reader = $this->getReader();
+        $ref = new \ReflectionClass('Doctrine\Tests\Common\Annotations\Fixtures\InvalidAnnotationUsageClass');
+        $reader->getClassAnnotations($ref);
+    }
+
+    public function testInvalidAnnotationUsageButIgnoredClass()
+    {
+        $reader = $this->getReader();
+        $ref = new \ReflectionClass('Doctrine\Tests\Common\Annotations\Fixtures\InvalidAnnotationUsageButIgnoredClass');
+        $annots = $reader->getClassAnnotations($ref);
+
+        $this->assertEquals(2, count($annots));
+    }
+
+    /**
+     * @group DDC-1660
+     * @group regression
+     */
+    public function testInvalidAnnotationButIgnored()
+    {
+        $reader = $this->getReader();
+        $class  = new \ReflectionClass('Doctrine\Tests\Common\Annotations\Fixtures\ClassDDC1660');
+
+        $this->assertTrue(class_exists('Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Version'));
+        $this->assertCount(0, $reader->getClassAnnotations($class));
+        $this->assertCount(0, $reader->getMethodAnnotations($class->getMethod('bar')));
+        $this->assertCount(0, $reader->getPropertyAnnotations($class->getProperty('foo')));
+    }
+
+    public function testAnnotationEnumeratorException()
+    {
+        $reader     = $this->getReader();
+        $class      = new \ReflectionClass('Doctrine\Tests\Common\Annotations\Fixtures\ClassWithAnnotationEnum');
+
+        $this->assertCount(1, $bar = $reader->getMethodAnnotations($class->getMethod('bar')));
+        $this->assertCount(1, $foo = $reader->getPropertyAnnotations($class->getProperty('foo')));
+
+        $this->assertInstanceOf('Doctrine\Tests\Common\Annotations\Fixtures\AnnotationEnum', $bar[0]);
+        $this->assertInstanceOf('Doctrine\Tests\Common\Annotations\Fixtures\AnnotationEnum', $foo[0]);
+
+        try {
+            $reader->getPropertyAnnotations($class->getProperty('invalidProperty'));
+            $this->fail();
+        } catch (\Doctrine\Common\Annotations\AnnotationException $exc) {
+            $this->assertEquals('[Enum Error] Attribute "value" of @Doctrine\Tests\Common\Annotations\Fixtures\AnnotationEnum declared on property Doctrine\Tests\Common\Annotations\Fixtures\ClassWithAnnotationEnum::$invalidProperty accept only [ONE, TWO, THREE], but got FOUR.', $exc->getMessage());
+        }
+
+        try {
+            $reader->getMethodAnnotations($class->getMethod('invalidMethod'));
+            $this->fail();
+        } catch (\Doctrine\Common\Annotations\AnnotationException $exc) {
+            $this->assertEquals('[Enum Error] Attribute "value" of @Doctrine\Tests\Common\Annotations\Fixtures\AnnotationEnum declared on method Doctrine\Tests\Common\Annotations\Fixtures\ClassWithAnnotationEnum::invalidMethod() accept only [ONE, TWO, THREE], but got 5.', $exc->getMessage());
+        }
+    }
+
+    /**
+     * @group DCOM-106
+     */
+    public function testIgnoreFixMeAndUpperCaseToDo()
+    {
+        $reader = $this->getReader();
+        $ref = new \ReflectionClass('Doctrine\Tests\Common\Annotations\DCOM106');
+        $reader->getClassAnnotations($ref);
+    }
+    
+    /**
+     * @return AnnotationReader
+     */
+    abstract protected function getReader();
+}
+
+/**
+ * @parseAnnotation("var")
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ *
+ */
+class TestParseAnnotationClass
+{
+    /**
+     * @var
+     */
+    private $field;
+}
+
+/**
+ * @Name
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class TestIgnoresNonAnnotationsClass
+{
+}
+
+class TestTopLevelAnnotationClass
+{
+    /**
+     * @\TopLevelAnnotation
+     */
+    private $field;
+}
+
+class TestNonExistentAnnotationClass
+{
+    /**
+     * @Foo\Bar\Name
+     */
+    private $field;
+}
+
+class TestAnnotationNotImportedClass
+{
+    /**
+     * @NameFoo
+     */
+    private $field;
+}
+
+class TestChildClass
+{
+    /**
+     * @\Doctrine\Tests\Common\Annotations\Foo\Name(name = "foo")
+     */
+    protected $child;
+}
+
+class TestParentClass extends TestChildClass
+{
+    /**
+     * @\Doctrine\Tests\Common\Annotations\Bar\Name(name = "bar")
+     */
+    private $parent;
+}
+
+class TestImportWithConcreteAnnotation
+{
+    /**
+     * @DummyAnnotation(dummyValue = "bar")
+     */
+    private $field;
+}
+
+/**
+ * @ignoreAnnotation("var")
+ */
+class DummyClass2 {
+    /**
+     * @DummyId @DummyColumn(type="integer") @DummyGeneratedValue
+     * @var integer
+     */
+    private $id;
+}
+
+/** @Annotation */
+class DummyId extends \Doctrine\Common\Annotations\Annotation {}
+/** @Annotation */
+class DummyColumn extends \Doctrine\Common\Annotations\Annotation {
+    public $type;
+}
+/** @Annotation */
+class DummyGeneratedValue extends \Doctrine\Common\Annotations\Annotation {}
+/** @Annotation */
+class DummyAnnotation extends \Doctrine\Common\Annotations\Annotation {
+    public $dummyValue;
+}
+
+/**
+ * @api
+ * @Annotation
+ */
+class DummyAnnotationWithIgnoredAnnotation extends \Doctrine\Common\Annotations\Annotation {
+    public $dummyValue;
+}
+
+/** @Annotation */
+class DummyJoinColumn extends \Doctrine\Common\Annotations\Annotation {
+    public $name;
+    public $referencedColumnName;
+}
+/** @Annotation */
+class DummyJoinTable extends \Doctrine\Common\Annotations\Annotation {
+    public $name;
+    public $joinColumns;
+    public $inverseJoinColumns;
+}
+
+/**
+ * @DummyAnnotation(@)
+ */
+class DummyClassSyntaxError
+{
+
+}
+
+class DummyClassMethodSyntaxError
+{
+    /**
+     * @DummyAnnotation(@)
+     */
+    public function foo()
+    {
+
+    }
+}
+
+class DummyClassPropertySyntaxError
+{
+    /**
+     * @DummyAnnotation(@)
+     */
+    public $foo;
+}
+
+/**
+ * @ignoreAnnotation({"since", "var"})
+ */
+class DummyClassNonAnnotationProblem
+{
+    /**
+     * @DummyAnnotation
+     *
+     * @var \Test
+     * @since 0.1
+     */
+    public $foo;
+}
+
+
+/**
+* @DummyAnnotation Foo bar <foobar@1domain.com>
+*/
+class DummyClassWithEmail
+{
+
+}
+
+
+/**
+ * @fixme public
+ * @TODO
+ */
+class DCOM106
+{
+    
+}
+
+namespace Doctrine\Tests\Common\Annotations\Foo;
+
+/** @Annotation */
+class Name extends \Doctrine\Common\Annotations\Annotation
+{
+    public $name;
+}
+
+namespace Doctrine\Tests\Common\Annotations\Bar;
+
+/** @Annotation */
+class Name extends \Doctrine\Common\Annotations\Annotation
+{
+    public $name;
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/AnnotationReaderTest.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/AnnotationReaderTest.php
@@ -0,0 +1,13 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations;
+
+use Doctrine\Common\Annotations\AnnotationReader;
+
+class AnnotationReaderTest extends AbstractReaderTest
+{
+    protected function getReader()
+    {
+        return new AnnotationReader();
+    }
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/CachedReaderTest.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/CachedReaderTest.php
@@ -0,0 +1,56 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route;
+use Doctrine\Common\Annotations\AnnotationReader;
+use Doctrine\Common\Annotations\CachedReader;
+use Doctrine\Common\Cache\ArrayCache;
+
+class CachedReaderTest extends AbstractReaderTest
+{
+    private $cache;
+
+    public function testIgnoresStaleCache()
+    {
+        $file = __DIR__.'/Fixtures/Controller.php';
+        touch($file);
+        $name = 'Doctrine\Tests\Common\Annotations\Fixtures\Controller';
+        $cacheKey = $name.'@[Annot]';
+
+        $cache = $this->getMock('Doctrine\Common\Cache\Cache');
+        $cache
+            ->expects($this->at(0))
+            ->method('fetch')
+            ->with($this->equalTo($cacheKey))
+            ->will($this->returnValue(array()))
+        ;
+        $cache
+            ->expects($this->at(1))
+            ->method('fetch')
+            ->with($this->equalTo('[C]'.$cacheKey))
+            ->will($this->returnValue(time() - 10))
+        ;
+        $cache
+            ->expects($this->at(2))
+            ->method('save')
+            ->with($this->equalTo($cacheKey))
+        ;
+        $cache
+            ->expects($this->at(3))
+            ->method('save')
+            ->with($this->equalTo('[C]'.$cacheKey))
+        ;
+
+        $reader = new CachedReader(new AnnotationReader(), $cache, true);
+        $route = new Route();
+        $route->pattern = '/someprefix';
+        $this->assertEquals(array($route), $reader->getClassAnnotations(new \ReflectionClass($name)));
+    }
+
+    protected function getReader()
+    {
+        $this->cache = new ArrayCache();
+        return new CachedReader(new AnnotationReader(), $this->cache);
+    }
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/DocLexerTest.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/DocLexerTest.php
@@ -0,0 +1,137 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations;
+
+use Doctrine\Common\Annotations\DocLexer;
+
+class DocLexerTest extends \PHPUnit_Framework_TestCase
+{
+    public function testMarkerAnnotation()
+    {
+        $lexer = new DocLexer;
+
+        $lexer->setInput("@Name");
+        $this->assertNull($lexer->token);
+        $this->assertNull($lexer->lookahead);
+
+        $this->assertTrue($lexer->moveNext());
+        $this->assertNull($lexer->token);
+        $this->assertEquals('@', $lexer->lookahead['value']);
+
+        $this->assertTrue($lexer->moveNext());
+        $this->assertEquals('@', $lexer->token['value']);
+        $this->assertEquals('Name', $lexer->lookahead['value']);
+
+        $this->assertFalse($lexer->moveNext());
+    }
+
+    public function testScannerTokenizesDocBlockWhitConstants()
+    {
+        $lexer      = new DocLexer();
+        $docblock   = '@AnnotationWithConstants(PHP_EOL, ClassWithConstants::SOME_VALUE, \Doctrine\Tests\Common\Annotations\Fixtures\IntefaceWithConstants::SOME_VALUE)';
+
+        $tokens = array (
+            array(
+                'value'     => '@',
+                'position'  => 0,
+                'type'      => DocLexer::T_AT,
+            ),
+            array(
+                'value'     => 'AnnotationWithConstants',
+                'position'  => 1,
+                'type'      => DocLexer::T_IDENTIFIER,
+            ),
+            array(
+                'value'     => '(',
+                'position'  => 24,
+                'type'      => DocLexer::T_OPEN_PARENTHESIS,
+            ),
+            array(
+                'value'     => 'PHP_EOL',
+                'position'  => 25,
+                'type'      => DocLexer::T_IDENTIFIER,
+            ),
+            array(
+                'value'     => ',',
+                'position'  => 32,
+                'type'      => DocLexer::T_COMMA,
+            ),
+            array(
+                'value'     => 'ClassWithConstants::SOME_VALUE',
+                'position'  => 34,
+                'type'      => DocLexer::T_IDENTIFIER,
+            ),
+            array(
+                'value'     => ',',
+                'position'  => 64,
+                'type'      => DocLexer::T_COMMA,
+            ),
+            array(
+                'value'     => '\\Doctrine\\Tests\\Common\\Annotations\\Fixtures\\IntefaceWithConstants::SOME_VALUE',
+                'position'  => 66,
+                'type'      => DocLexer::T_IDENTIFIER,
+            ),
+            array(
+                'value'     => ')',
+                'position'  => 143,
+                'type'      => DocLexer::T_CLOSE_PARENTHESIS,
+            )
+
+        );
+
+        $lexer->setInput($docblock);
+
+        foreach ($tokens as $expected) {
+            $lexer->moveNext();
+            $lookahead = $lexer->lookahead;
+            $this->assertEquals($expected['value'],     $lookahead['value']);
+            $this->assertEquals($expected['type'],      $lookahead['type']);
+            $this->assertEquals($expected['position'],  $lookahead['position']);
+        }
+
+        $this->assertFalse($lexer->moveNext());
+    }
+
+
+    public function testScannerTokenizesDocBlockWhitInvalidIdentifier()
+    {
+        $lexer      = new DocLexer();
+        $docblock   = '@Foo\3.42';
+
+        $tokens = array (
+            array(
+                'value'     => '@',
+                'position'  => 0,
+                'type'      => DocLexer::T_AT,
+            ),
+            array(
+                'value'     => 'Foo',
+                'position'  => 1,
+                'type'      => DocLexer::T_IDENTIFIER,
+            ),
+            array(
+                'value'     => '\\',
+                'position'  => 4,
+                'type'      => DocLexer::T_NAMESPACE_SEPARATOR,
+            ),
+            array(
+                'value'     => 3.42,
+                'position'  => 5,
+                'type'      => DocLexer::T_FLOAT,
+            )
+        );
+
+        $lexer->setInput($docblock);
+
+        foreach ($tokens as $expected) {
+            $lexer->moveNext();
+            $lookahead = $lexer->lookahead;
+            $this->assertEquals($expected['value'],     $lookahead['value']);
+            $this->assertEquals($expected['type'],      $lookahead['type']);
+            $this->assertEquals($expected['position'],  $lookahead['position']);
+        }
+
+        $this->assertFalse($lexer->moveNext());
+    }
+
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/DocParserTest.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/DocParserTest.php
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/DummyClass.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/DummyClass.php
@@ -0,0 +1,48 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations;
+
+use Doctrine\Tests\Common\Annotations\DummyAnnotation;
+use Doctrine\Tests\Common\Annotations\Name;
+use Doctrine\Tests\Common\Annotations\DummyJoinTable;
+use Doctrine\Tests\Common\Annotations\DummyJoinColumn;
+
+/**
+ * A description of this class.
+ *
+ * Let's see if the parser recognizes that this @ is not really referring to an
+ * annotation. Also make sure that @var \ is not concated to "@var\is".
+ *
+ * @author robo
+ * @since 2.0
+ * @DummyAnnotation(dummyValue="hello")
+ */
+class DummyClass
+{
+    /**
+     * A nice property.
+     *
+     * @var mixed
+     * @DummyAnnotation(dummyValue="fieldHello")
+     */
+    private $field1;
+
+    /**
+     * @DummyJoinTable(name="join_table",
+     *      joinColumns={@DummyJoinColumn(name="col1", referencedColumnName="col2")},
+     *      inverseJoinColumns={
+     *          @DummyJoinColumn(name="col3", referencedColumnName="col4")
+     *      })
+     */
+    private $field2;
+
+    /**
+     * Gets the value of field1.
+     *
+     * @return mixed
+     * @DummyAnnotation({1,2,"three"})
+     */
+    public function getField1()
+    {
+    }
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/FileCacheReaderTest.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/FileCacheReaderTest.php
@@ -0,0 +1,40 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations;
+
+use Doctrine\Common\Annotations\AnnotationReader;
+use Doctrine\Common\Annotations\FileCacheReader;
+
+class FileCacheReaderTest extends AbstractReaderTest
+{
+    private $cacheDir;
+
+    protected function getReader()
+    {
+        $this->cacheDir = sys_get_temp_dir() . "/annotations_". uniqid();
+        @mkdir($this->cacheDir);
+        return new FileCacheReader(new AnnotationReader(), $this->cacheDir);
+    }
+
+    public function tearDown()
+    {
+        foreach (glob($this->cacheDir.'/*.php') AS $file) {
+            unlink($file);
+        }
+        rmdir($this->cacheDir);
+    }
+
+    /**
+     * @group DCOM-81
+     */
+    public function testAttemptToCreateAnnotationCacheDir()
+    {
+        $this->cacheDir = sys_get_temp_dir() . "/not_existed_dir_". uniqid();
+
+        $this->assertFalse(is_dir($this->cacheDir));
+
+        $cache = new FileCacheReader(new AnnotationReader(), $this->cacheDir);
+
+        $this->assertTrue(is_dir($this->cacheDir));
+    }
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/Annotation/AnnotWithDefaultValue.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/Annotation/AnnotWithDefaultValue.php
@@ -0,0 +1,10 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures\Annotation;
+
+/** @Annotation */
+class AnnotWithDefaultValue
+{
+    /** @var string */
+    public $foo = 'bar';
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/Annotation/Autoload.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/Annotation/Autoload.php
@@ -0,0 +1,10 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures\Annotation;
+
+/**
+ * @Annotation
+ */
+class Autoload
+{
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/Annotation/Route.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/Annotation/Route.php
@@ -0,0 +1,11 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures\Annotation;
+
+/** @Annotation */
+class Route
+{
+    /** @var string @Required */
+    public $pattern;
+    public $name;
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/Annotation/Secure.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/Annotation/Secure.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures\Annotation;
+
+/** @Annotation */
+class Secure
+{
+    private $roles;
+
+    public function __construct(array $values)
+    {
+        if (is_string($values['value'])) {
+            $values['value'] = array($values['value']);
+        }
+
+        $this->roles = $values['value'];
+    }
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/Annotation/Template.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/Annotation/Template.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures\Annotation;
+
+/** @Annotation */
+class Template
+{
+    private $name;
+
+    public function __construct(array $values)
+    {
+        $this->name = isset($values['value']) ? $values['value'] : null;
+    }
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/Annotation/Version.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/Annotation/Version.php
@@ -0,0 +1,11 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures\Annotation;
+
+/**
+ * @Annotation
+ * @Target("PROPERTY")
+ */
+final class Version
+{
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationEnum.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationEnum.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+/**
+ * @Annotation
+ * @Target("ALL")
+ */
+final class AnnotationEnum
+{
+    const ONE   = 'ONE';
+    const TWO   = 'TWO';
+    const THREE = 'THREE';
+
+    /**
+     * @var mixed
+     *
+     * @Enum({"ONE","TWO","THREE"})
+     */
+    public $value;
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationEnumInvalid.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationEnumInvalid.php
@@ -0,0 +1,17 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+/**
+ * @Annotation
+ * @Target("ALL")
+ */
+final class AnnotationEnumInvalid
+{
+    /**
+     * @var mixed
+     *
+     * @Enum({1, 2, "foo", "bar", {"foo":"bar"}})
+     */
+    public $value;
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationEnumLiteral.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationEnumLiteral.php
@@ -0,0 +1,34 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\AnnotationEnumLiteral as SelfEnum;
+
+/**
+ * @Annotation
+ * @Target("ALL")
+ */
+final class AnnotationEnumLiteral
+{
+    const ONE   = 1;
+    const TWO   = 2;
+    const THREE = 3;
+
+    /**
+     * @var mixed
+     *
+     * @Enum(
+     *      value = {
+     *          1,
+     *          2,
+     *          3,
+     *      },
+     *      literal = {
+     *          1 : "AnnotationEnumLiteral::ONE",
+     *          2 : "AnnotationEnumLiteral::TWO",
+     *          3 : "AnnotationEnumLiteral::THREE",
+     *      }
+     * )
+     */
+    public $value;
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationEnumLiteralInvalid.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationEnumLiteralInvalid.php
@@ -0,0 +1,31 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+/**
+ * @Annotation
+ * @Target("ALL")
+ */
+final class AnnotationEnumLiteralInvalid
+{
+    const ONE   = 1;
+    const TWO   = 2;
+    const THREE = 3;
+
+    /**
+     * @var mixed
+     *
+     * @Enum(
+     *      value = {
+     *          1,
+     *          2
+     *      },
+     *      literal = {
+     *          1 : "AnnotationEnumLiteral::ONE",
+     *          2 : "AnnotationEnumLiteral::TWO",
+     *          3 : "AnnotationEnumLiteral::THREE"
+     *      }
+     * )
+     */
+    public $value;
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationTargetAll.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationTargetAll.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+/**
+ * @Annotation
+ * @Target("ALL")
+ */
+class AnnotationTargetAll
+{
+    public $data;
+    public $name;
+    public $target;
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationTargetAnnotation.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationTargetAnnotation.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+/**
+ * @Annotation
+ * @Target({ "ANNOTATION" })
+ */
+final class AnnotationTargetAnnotation
+{
+    public $data;
+    public $name;
+    public $target;
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationTargetClass.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationTargetClass.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+
+/**
+ * @Annotation
+ * @Target("CLASS")
+ */
+final class AnnotationTargetClass
+{
+    public $data;
+    public $name;
+    public $target;
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationTargetMethod.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationTargetMethod.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+
+/**
+ * @Annotation
+ * @Target("METHOD")
+ */
+final class AnnotationTargetMethod
+{
+    public $data;
+    public $name;
+    public $target;
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationTargetPropertyMethod.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationTargetPropertyMethod.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+/**
+ * @Annotation
+ * @Target({ "METHOD", "PROPERTY" })
+ */
+final class AnnotationTargetPropertyMethod
+{
+    public $data;
+    public $name;
+    public $target;
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationWithAttributes.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationWithAttributes.php
@@ -0,0 +1,119 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+/**
+ * @Annotation
+ * @Target("ALL")
+ * @Attributes({
+      @Attribute("mixed",                type = "mixed"),
+      @Attribute("boolean",              type = "boolean"),
+      @Attribute("bool",                 type = "bool"),
+      @Attribute("float",                type = "float"),
+      @Attribute("string",               type = "string"),
+      @Attribute("integer",              type = "integer"),
+      @Attribute("array",                type = "array"),
+      @Attribute("arrayOfIntegers",      type = "array<integer>"),
+      @Attribute("annotation",           type = "Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll"),
+      @Attribute("arrayOfAnnotations",   type = "array<Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll>"),
+  })
+ */
+final class AnnotationWithAttributes
+{
+
+    public final function __construct(array $data)
+    {
+        foreach ($data as $key => $value) {
+            $this->$key = $value;
+        }
+    }
+
+    private $mixed;
+    private $boolean;
+    private $bool;
+    private $float;
+    private $string;
+    private $integer;
+    private $array;
+    private $annotation;
+    private $arrayOfIntegers;
+    private $arrayOfAnnotations;
+
+    /**
+     * @return mixed
+     */
+    public function getMixed()
+    {
+        return $this->mixed;
+    }
+
+    /**
+     * @return boolean
+     */
+    public function getBoolean()
+    {
+        return $this->boolean;
+    }
+
+    /**
+     * @return bool
+     */
+    public function getBool()
+    {
+        return $this->bool;
+    }
+
+    /**
+     * @return float
+     */
+    public function getFloat()
+    {
+        return $this->float;
+    }
+
+    /**
+     * @return string
+     */
+    public function getString()
+    {
+        return $this->string;
+    }
+
+    public function getInteger()
+    {
+        return $this->integer;
+    }
+
+    /**
+     * @return array
+     */
+    public function getArray()
+    {
+        return $this->array;
+    }
+
+    /**
+     * @return Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll
+     */
+    public function getAnnotation()
+    {
+        return $this->annotation;
+    }
+
+    /**
+     * @return array<integer>
+     */
+    public function getArrayOfIntegers()
+    {
+        return $this->arrayOfIntegers;
+    }
+
+    /**
+     * @return array<Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll>
+     */
+    public function getArrayOfAnnotations()
+    {
+        return $this->arrayOfAnnotations;
+    }
+
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationWithConstants.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationWithConstants.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+/**
+ * @Annotation
+ * @Target("ALL")
+ */
+final class AnnotationWithConstants
+{
+
+    const INTEGER = 1;
+    const FLOAT   = 1.2;
+    const STRING  = '1.2.3';
+
+    /**
+     * @var mixed
+     */
+    public $value;
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationWithRequiredAttributes.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationWithRequiredAttributes.php
@@ -0,0 +1,50 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+/**
+ * @Annotation
+ * @Target("ALL")
+ * @Attributes({
+      @Attribute("value",   required = true ,   type = "string"),
+      @Attribute("annot",   required = true ,   type = "Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAnnotation"),
+   })
+ */
+final class AnnotationWithRequiredAttributes
+{
+
+    public final function __construct(array $data)
+    {
+        foreach ($data as $key => $value) {
+            $this->$key = $value;
+        }
+    }
+
+    /**
+     * @var string
+     */
+    private $value;
+
+    /**
+     *
+     * @var Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAnnotation
+     */
+    private $annot;
+
+    /**
+     * @return string
+     */
+    public function getValue()
+    {
+        return $this->value;
+    }
+
+    /**
+     * @return Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAnnotation
+     */
+    public function getAnnot()
+    {
+        return $this->annot;
+    }
+
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationWithRequiredAttributesWithoutContructor.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationWithRequiredAttributesWithoutContructor.php
@@ -0,0 +1,24 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+/**
+ * @Annotation
+ * @Target("ALL")
+ */
+final class AnnotationWithRequiredAttributesWithoutContructor
+{
+
+    /**
+     * @Required
+     * @var string
+     */
+    public $value;
+
+    /**
+     * @Required
+     * @var Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAnnotation
+     */
+    public $annot;
+
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationWithTargetSyntaxError.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationWithTargetSyntaxError.php
@@ -0,0 +1,11 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+/**
+ * @Annotation
+ * @Target(@)
+ */
+final class AnnotationWithTargetSyntaxError
+{
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationWithVarType.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationWithVarType.php
@@ -0,0 +1,62 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+/**
+ * @Annotation
+ * @Target("ALL")
+ */
+final class AnnotationWithVarType
+{
+
+    /**
+     * @var mixed
+     */
+    public $mixed;
+
+    /**
+     * @var boolean
+     */
+    public $boolean;
+
+    /**
+     * @var bool
+     */
+    public $bool;
+
+    /**
+     * @var float
+     */
+    public $float;
+
+    /**
+     * @var string
+     */
+    public $string;
+
+    /**
+     * @var integer
+     */
+    public $integer;
+
+    /**
+     * @var array
+     */
+    public $array;
+
+    /**
+     * @var Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll
+     */
+    public $annotation;
+
+    /**
+     * @var array<integer>
+     */
+    public $arrayOfIntegers;
+
+    /**
+     * @var array<Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll>
+     */
+    public $arrayOfAnnotations;
+
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/Api.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/Api.php
@@ -0,0 +1,10 @@
+<?php
+
+/**
+ * This class is not an annotation
+ * It's a class build to test ClassWithInclude
+ */
+class Api
+{
+	
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassDDC1660.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassDDC1660.php
@@ -0,0 +1,30 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+/**
+ * @since 2.0
+ * @version $Id: SomeEntityClass.php 509 2012-02-03 09:38:48Z mf $
+ */
+class ClassDDC1660
+{
+
+    /**
+     * @var     string
+     * @since   2.0
+     * @version 1
+     */
+    public $foo;
+
+    /**
+     * @param   string
+     * @return  string
+     * @since   2.0
+     * @version 1
+     */
+    public function bar($param)
+    {
+        return null;
+    }
+
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithAnnotationEnum.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithAnnotationEnum.php
@@ -0,0 +1,29 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\AnnotationEnum;
+
+class ClassWithAnnotationEnum
+{
+    /**
+     * @AnnotationEnum(AnnotationEnum::ONE)
+     */
+    public $foo;
+
+    /**
+     * @AnnotationEnum("TWO")
+     */
+    public function bar(){}
+
+
+    /**
+     * @AnnotationEnum("FOUR")
+     */
+    public $invalidProperty;
+
+    /**
+     * @AnnotationEnum(5)
+     */
+    public function invalidMethod(){}
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithAnnotationWithTargetSyntaxError.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithAnnotationWithTargetSyntaxError.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\AnnotationWithTargetSyntaxError;
+
+/**
+ * @AnnotationWithTargetSyntaxError()
+ */
+class ClassWithAnnotationWithTargetSyntaxError
+{
+    /**
+     * @AnnotationWithTargetSyntaxError()
+     */
+    public $foo;
+
+    /**
+     * @AnnotationWithTargetSyntaxError()
+     */
+    public function bar(){}
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithAnnotationWithVarType.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithAnnotationWithVarType.php
@@ -0,0 +1,31 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\AnnotationWithVarType;
+use Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll;
+use Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAnnotation;
+
+class ClassWithAnnotationWithVarType
+{
+    /**
+     * @AnnotationWithVarType(string = "String Value")
+     */
+    public $foo;
+
+    /**
+     * @AnnotationWithVarType(annotation = @AnnotationTargetAll)
+     */
+    public function bar(){}
+
+
+    /**
+     * @AnnotationWithVarType(string = 123)
+     */
+    public $invalidProperty;
+
+    /**
+     * @AnnotationWithVarType(annotation = @AnnotationTargetAnnotation)
+     */
+    public function invalidMethod(){}
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithClosure.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithClosure.php
@@ -0,0 +1,52 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll;
+use Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAnnotation;
+
+/**
+ * @AnnotationTargetAll("Foo")
+ */
+final class ClassWithClosure
+{
+
+    /**
+     * @AnnotationTargetAll(@AnnotationTargetAnnotation)
+     * @var string
+     */
+    public $value;
+
+    /**
+     * @AnnotationTargetAll(@AnnotationTargetAnnotation)
+     *
+     * @param   \Closure $callback
+     * @return  \Closure
+     */
+    public function methodName(\Closure $callback)
+    {
+        $self = $this;
+        return function() use ($self, $callback) {
+            return $callback;
+        };
+    }
+
+    /**
+     * @param   integer $year
+     * @param   integer $month
+     * @param   integer $day
+     * @return  \Doctrine\Common\Collections\ArrayCollection
+     */
+    public function getEventsForDate($year, $month, $day){
+        $extractEvents  = null; // check if date of item is inside day given
+        $extractEvents  = $this->events->filter(function ($item) use ($year, $month, $day) {
+            $leftDate   = new \DateTime($year.'-'.$month.'-'.$day.' 00:00');
+            $rigthDate  = new \DateTime($year.'-'.$month.'-'.$day.' +1 day 00:00');
+            return ( ( $leftDate <= $item->getDateStart() ) && ( $item->getDateStart() < $rigthDate ) );
+
+            }
+        );
+        return $extractEvents;
+    }
+
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithConstants.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithConstants.php
@@ -0,0 +1,10 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+class ClassWithConstants
+{
+
+    const SOME_VALUE = 'ClassWithConstants.SOME_VALUE';
+    const SOME_KEY   = 'ClassWithConstants.SOME_KEY';
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithFullyQualifiedUseStatements.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithFullyQualifiedUseStatements.php
@@ -0,0 +1,11 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use
+    \Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Secure,
+    \Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route
+;
+use \Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Template;
+
+class ClassWithFullyQualifiedUseStatements {}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithInvalidAnnotationTargetAtClass.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithInvalidAnnotationTargetAtClass.php
@@ -0,0 +1,17 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetPropertyMethod;
+
+/**
+ * @AnnotationTargetPropertyMethod("Some data")
+ */
+class ClassWithInvalidAnnotationTargetAtClass
+{
+
+    /**
+     * @AnnotationTargetPropertyMethod("Bar")
+     */
+    public $foo;
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithInvalidAnnotationTargetAtMethod.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithInvalidAnnotationTargetAtMethod.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetClass;
+
+/**
+ * @AnnotationTargetClass("Some data")
+ */
+class ClassWithInvalidAnnotationTargetAtMethod
+{
+
+    /**
+     * @AnnotationTargetClass("functionName")
+     */
+    public function functionName($param)
+    {
+
+    }
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithInvalidAnnotationTargetAtProperty.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithInvalidAnnotationTargetAtProperty.php
@@ -0,0 +1,24 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetClass;
+use Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAnnotation;
+
+/**
+ * @AnnotationTargetClass("Some data")
+ */
+class ClassWithInvalidAnnotationTargetAtProperty
+{
+
+    /**
+     * @AnnotationTargetClass("Bar")
+     */
+    public $foo;
+
+
+    /**
+     * @AnnotationTargetAnnotation("Foo")
+     */
+    public $bar;
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithRequire.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithRequire.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+// Include a class named Api
+require_once(__DIR__ . '/Api.php');
+
+use Doctrine\Tests\Common\Annotations\DummyAnnotationWithIgnoredAnnotation;
+
+/**
+ * @DummyAnnotationWithIgnoredAnnotation(dummyValue="hello")
+ */
+class ClassWithRequire
+{
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithValidAnnotationTarget.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithValidAnnotationTarget.php
@@ -0,0 +1,41 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetClass;
+use Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll;
+use Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetPropertyMethod;
+use Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetNestedAnnotation;
+
+/**
+ * @AnnotationTargetClass("Some data")
+ */
+class ClassWithValidAnnotationTarget
+{
+
+    /**
+     * @AnnotationTargetPropertyMethod("Some data")
+     */
+    public $foo;
+
+
+    /**
+     * @AnnotationTargetAll("Some data",name="Some name")
+     */
+    public $name;
+
+    /**
+     * @AnnotationTargetPropertyMethod("Some data",name="Some name")
+     */
+    public function someFunction()
+    {
+
+    }
+
+
+    /**
+     * @AnnotationTargetAll(@AnnotationTargetAnnotation)
+     */
+    public $nested;
+
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/Controller.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/Controller.php
@@ -0,0 +1,300 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Template;
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route;
+
+/**
+ * @Route("/someprefix")
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class Controller
+{
+    /**
+     * @Route("/", name="_demo")
+     * @Template()
+     */
+    public function indexAction()
+    {
+        return array();
+    }
+
+    /**
+     * @Route("/hello/{name}", name="_demo_hello")
+     * @Template()
+     */
+    public function helloAction($name)
+    {
+        return array('name' => $name);
+    }
+
+    /**
+     * @Route("/contact", name="_demo_contact")
+     * @Template()
+     */
+    public function contactAction()
+    {
+        $form = ContactForm::create($this->get('form.context'), 'contact');
+
+        $form->bind($this->container->get('request'), $form);
+        if ($form->isValid()) {
+            $form->send($this->get('mailer'));
+
+            $this->get('session')->setFlash('notice', 'Message sent!');
+
+            return new RedirectResponse($this->generateUrl('_demo'));
+        }
+
+        return array('form' => $form);
+    }
+
+    /**
+     * Creates the ACL for the passed object identity
+     *
+     * @param ObjectIdentityInterface $oid
+     * @return void
+     */
+    private function createObjectIdentity(ObjectIdentityInterface $oid)
+    {
+        $classId = $this->createOrRetrieveClassId($oid->getType());
+
+        $this->connection->executeQuery($this->getInsertObjectIdentitySql($oid->getIdentifier(), $classId, true));
+    }
+
+    /**
+     * Returns the primary key for the passed class type.
+     *
+     * If the type does not yet exist in the database, it will be created.
+     *
+     * @param string $classType
+     * @return integer
+     */
+    private function createOrRetrieveClassId($classType)
+    {
+        if (false !== $id = $this->connection->executeQuery($this->getSelectClassIdSql($classType))->fetchColumn()) {
+            return $id;
+        }
+
+        $this->connection->executeQuery($this->getInsertClassSql($classType));
+
+        return $this->connection->executeQuery($this->getSelectClassIdSql($classType))->fetchColumn();
+    }
+
+    /**
+     * Returns the primary key for the passed security identity.
+     *
+     * If the security identity does not yet exist in the database, it will be
+     * created.
+     *
+     * @param SecurityIdentityInterface $sid
+     * @return integer
+     */
+    private function createOrRetrieveSecurityIdentityId(SecurityIdentityInterface $sid)
+    {
+        if (false !== $id = $this->connection->executeQuery($this->getSelectSecurityIdentityIdSql($sid))->fetchColumn()) {
+            return $id;
+        }
+
+        $this->connection->executeQuery($this->getInsertSecurityIdentitySql($sid));
+
+        return $this->connection->executeQuery($this->getSelectSecurityIdentityIdSql($sid))->fetchColumn();
+    }
+
+    /**
+     * Deletes all ACEs for the given object identity primary key.
+     *
+     * @param integer $oidPK
+     * @return void
+     */
+    private function deleteAccessControlEntries($oidPK)
+    {
+        $this->connection->executeQuery($this->getDeleteAccessControlEntriesSql($oidPK));
+    }
+
+    /**
+     * Deletes the object identity from the database.
+     *
+     * @param integer $pk
+     * @return void
+     */
+    private function deleteObjectIdentity($pk)
+    {
+        $this->connection->executeQuery($this->getDeleteObjectIdentitySql($pk));
+    }
+
+    /**
+     * Deletes all entries from the relations table from the database.
+     *
+     * @param integer $pk
+     * @return void
+     */
+    private function deleteObjectIdentityRelations($pk)
+    {
+        $this->connection->executeQuery($this->getDeleteObjectIdentityRelationsSql($pk));
+    }
+
+    /**
+     * This regenerates the ancestor table which is used for fast read access.
+     *
+     * @param AclInterface $acl
+     * @return void
+     */
+    private function regenerateAncestorRelations(AclInterface $acl)
+    {
+        $pk = $acl->getId();
+        $this->connection->executeQuery($this->getDeleteObjectIdentityRelationsSql($pk));
+        $this->connection->executeQuery($this->getInsertObjectIdentityRelationSql($pk, $pk));
+
+        $parentAcl = $acl->getParentAcl();
+        while (null !== $parentAcl) {
+            $this->connection->executeQuery($this->getInsertObjectIdentityRelationSql($pk, $parentAcl->getId()));
+
+            $parentAcl = $parentAcl->getParentAcl();
+        }
+    }
+
+    /**
+     * This processes changes on an ACE related property (classFieldAces, or objectFieldAces).
+     *
+     * @param string $name
+     * @param array $changes
+     * @return void
+     */
+    private function updateFieldAceProperty($name, array $changes)
+    {
+        $sids = new \SplObjectStorage();
+        $classIds = new \SplObjectStorage();
+        $currentIds = array();
+        foreach ($changes[1] as $field => $new) {
+            for ($i=0,$c=count($new); $i<$c; $i++) {
+                $ace = $new[$i];
+
+                if (null === $ace->getId()) {
+                    if ($sids->contains($ace->getSecurityIdentity())) {
+                        $sid = $sids->offsetGet($ace->getSecurityIdentity());
+                    } else {
+                        $sid = $this->createOrRetrieveSecurityIdentityId($ace->getSecurityIdentity());
+                    }
+
+                    $oid = $ace->getAcl()->getObjectIdentity();
+                    if ($classIds->contains($oid)) {
+                        $classId = $classIds->offsetGet($oid);
+                    } else {
+                        $classId = $this->createOrRetrieveClassId($oid->getType());
+                    }
+
+                    $objectIdentityId = $name === 'classFieldAces' ? null : $ace->getAcl()->getId();
+
+                    $this->connection->executeQuery($this->getInsertAccessControlEntrySql($classId, $objectIdentityId, $field, $i, $sid, $ace->getStrategy(), $ace->getMask(), $ace->isGranting(), $ace->isAuditSuccess(), $ace->isAuditFailure()));
+                    $aceId = $this->connection->executeQuery($this->getSelectAccessControlEntryIdSql($classId, $objectIdentityId, $field, $i))->fetchColumn();
+                    $this->loadedAces[$aceId] = $ace;
+
+                    $aceIdProperty = new \ReflectionProperty('Symfony\Component\Security\Acl\Domain\Entry', 'id');
+                    $aceIdProperty->setAccessible(true);
+                    $aceIdProperty->setValue($ace, intval($aceId));
+                } else {
+                    $currentIds[$ace->getId()] = true;
+                }
+            }
+        }
+
+        foreach ($changes[0] as $old) {
+            for ($i=0,$c=count($old); $i<$c; $i++) {
+                $ace = $old[$i];
+
+                if (!isset($currentIds[$ace->getId()])) {
+                    $this->connection->executeQuery($this->getDeleteAccessControlEntrySql($ace->getId()));
+                    unset($this->loadedAces[$ace->getId()]);
+                }
+            }
+        }
+    }
+
+    /**
+     * This processes changes on an ACE related property (classAces, or objectAces).
+     *
+     * @param string $name
+     * @param array $changes
+     * @return void
+     */
+    private function updateAceProperty($name, array $changes)
+    {
+        list($old, $new) = $changes;
+
+        $sids = new \SplObjectStorage();
+        $classIds = new \SplObjectStorage();
+        $currentIds = array();
+        for ($i=0,$c=count($new); $i<$c; $i++) {
+            $ace = $new[$i];
+
+            if (null === $ace->getId()) {
+                if ($sids->contains($ace->getSecurityIdentity())) {
+                    $sid = $sids->offsetGet($ace->getSecurityIdentity());
+                } else {
+                    $sid = $this->createOrRetrieveSecurityIdentityId($ace->getSecurityIdentity());
+                }
+
+                $oid = $ace->getAcl()->getObjectIdentity();
+                if ($classIds->contains($oid)) {
+                    $classId = $classIds->offsetGet($oid);
+                } else {
+                    $classId = $this->createOrRetrieveClassId($oid->getType());
+                }
+
+                $objectIdentityId = $name === 'classAces' ? null : $ace->getAcl()->getId();
+
+                $this->connection->executeQuery($this->getInsertAccessControlEntrySql($classId, $objectIdentityId, null, $i, $sid, $ace->getStrategy(), $ace->getMask(), $ace->isGranting(), $ace->isAuditSuccess(), $ace->isAuditFailure()));
+                $aceId = $this->connection->executeQuery($this->getSelectAccessControlEntryIdSql($classId, $objectIdentityId, null, $i))->fetchColumn();
+                $this->loadedAces[$aceId] = $ace;
+
+                $aceIdProperty = new \ReflectionProperty($ace, 'id');
+                $aceIdProperty->setAccessible(true);
+                $aceIdProperty->setValue($ace, intval($aceId));
+            } else {
+                $currentIds[$ace->getId()] = true;
+            }
+        }
+
+        for ($i=0,$c=count($old); $i<$c; $i++) {
+            $ace = $old[$i];
+
+            if (!isset($currentIds[$ace->getId()])) {
+                $this->connection->executeQuery($this->getDeleteAccessControlEntrySql($ace->getId()));
+                unset($this->loadedAces[$ace->getId()]);
+            }
+        }
+    }
+
+    /**
+     * Persists the changes which were made to ACEs to the database.
+     *
+     * @param \SplObjectStorage $aces
+     * @return void
+     */
+    private function updateAces(\SplObjectStorage $aces)
+    {
+        foreach ($aces as $ace) {
+            $propertyChanges = $aces->offsetGet($ace);
+            $sets = array();
+
+            if (isset($propertyChanges['mask'])) {
+                $sets[] = sprintf('mask = %d', $propertyChanges['mask'][1]);
+            }
+            if (isset($propertyChanges['strategy'])) {
+                $sets[] = sprintf('granting_strategy = %s', $this->connection->quote($propertyChanges['strategy']));
+            }
+            if (isset($propertyChanges['aceOrder'])) {
+                $sets[] = sprintf('ace_order = %d', $propertyChanges['aceOrder'][1]);
+            }
+            if (isset($propertyChanges['auditSuccess'])) {
+                $sets[] = sprintf('audit_success = %s', $this->connection->getDatabasePlatform()->convertBooleans($propertyChanges['auditSuccess'][1]));
+            }
+            if (isset($propertyChanges['auditFailure'])) {
+                $sets[] = sprintf('audit_failure = %s', $this->connection->getDatabasePlatform()->convertBooleans($propertyChanges['auditFailure'][1]));
+            }
+
+            $this->connection->executeQuery($this->getUpdateAccessControlEntrySql($ace->getId(), $sets));
+        }
+    }
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/DifferentNamespacesPerFileWithClassAsFirst.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/DifferentNamespacesPerFileWithClassAsFirst.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures {
+    use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Secure;
+
+    class DifferentNamespacesPerFileWithClassAsFirst {}
+}
+
+namespace {
+    use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route;
+}
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures\Foo {
+    use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Template;
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/DifferentNamespacesPerFileWithClassAsLast.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/DifferentNamespacesPerFileWithClassAsLast.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures\Foo {
+    use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Secure;
+}
+
+namespace {
+    use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route;
+}
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures {
+    use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Template;
+
+    class DifferentNamespacesPerFileWithClassAsLast {}
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/EqualNamespacesPerFileWithClassAsFirst.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/EqualNamespacesPerFileWithClassAsFirst.php
@@ -0,0 +1,13 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Secure;
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route;
+
+class EqualNamespacesPerFileWithClassAsFirst {}
+
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Template;
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/EqualNamespacesPerFileWithClassAsLast.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/EqualNamespacesPerFileWithClassAsLast.php
@@ -0,0 +1,12 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Secure;
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route;
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Template;
+
+class EqualNamespacesPerFileWithClassAsLast {}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/GlobalNamespacesPerFileWithClassAsFirst.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/GlobalNamespacesPerFileWithClassAsFirst.php
@@ -0,0 +1,12 @@
+<?php
+
+namespace {
+	use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Secure;
+	use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route;
+
+	class GlobalNamespacesPerFileWithClassAsFirst {}
+}
+
+namespace {
+	use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Template;
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/GlobalNamespacesPerFileWithClassAsLast.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/GlobalNamespacesPerFileWithClassAsLast.php
@@ -0,0 +1,12 @@
+<?php
+
+namespace {
+	use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Secure;
+}
+
+namespace {
+	use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route;
+	use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Template;
+
+	class GlobalNamespacesPerFileWithClassAsLast {}
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/IntefaceWithConstants.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/IntefaceWithConstants.php
@@ -0,0 +1,10 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+interface IntefaceWithConstants
+{
+
+    const SOME_VALUE = 'IntefaceWithConstants.SOME_VALUE';
+    const SOME_KEY   = 'IntefaceWithConstants.SOME_KEY';
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/InvalidAnnotationUsageButIgnoredClass.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/InvalidAnnotationUsageButIgnoredClass.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route;
+
+/**
+ * @NoAnnotation
+ * @IgnoreAnnotation("NoAnnotation")
+ * @Route("foo")
+ */
+class InvalidAnnotationUsageButIgnoredClass
+{
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/InvalidAnnotationUsageClass.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/InvalidAnnotationUsageClass.php
@@ -0,0 +1,10 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+/**
+ * @NoAnnotation
+ */
+class InvalidAnnotationUsageClass
+{
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/MultipleClassesInFile.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/MultipleClassesInFile.php
@@ -0,0 +1,9 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Secure;
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route;
+
+class AnotherClass { }
+class MultipleClassesInFile { }
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/MultipleImportsInUseStatement.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/MultipleImportsInUseStatement.php
@@ -0,0 +1,10 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use
+    Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route,
+    Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Secure
+;
+
+class MultipleImportsInUseStatement {}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/NamespaceAndClassCommentedOut.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/NamespaceAndClassCommentedOut.php
@@ -0,0 +1,20 @@
+<?php
+
+// namespace Doctrine\Tests\Common\Annotations\Fixtures;
+namespace Doctrine\Tests\Common\Annotations\Fixtures\Foo {
+
+    use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Secure;
+
+    // class NamespaceAndClassCommentedOut {}
+}
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures {
+
+    // class NamespaceAndClassCommentedOut {}
+    use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route;
+
+    // namespace Doctrine\Tests\Common\Annotations\Fixtures;
+    use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Template;
+
+    class NamespaceAndClassCommentedOut {}
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/NamespaceWithClosureDeclaration.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/NamespaceWithClosureDeclaration.php
@@ -0,0 +1,12 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Secure;
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route;
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Template;
+
+$var = 1;
+function () use ($var) {};
+
+class NamespaceWithClosureDeclaration {}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/NamespacedSingleClassLOC1000.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/NamespacedSingleClassLOC1000.php
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/NoAnnotation.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/NoAnnotation.php
@@ -0,0 +1,5 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+class NoAnnotation {}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/NonNamespacedClass.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/NonNamespacedClass.php
@@ -0,0 +1,10 @@
+<?php
+
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Template;
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route;
+
+/**
+ * @Route("foo")
+ * @Template
+ */
+class AnnotationsTestsFixturesNonNamespacedClass { }
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/SingleClassLOC1000.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/SingleClassLOC1000.php
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/TestInterface.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Fixtures/TestInterface.php
@@ -0,0 +1,13 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Secure;
+
+interface TestInterface
+{
+    /**
+     * @Secure
+     */
+    function foo();
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/PerformanceTest.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/PerformanceTest.php
@@ -0,0 +1,194 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations;
+
+use Doctrine\Common\Annotations\FileCacheReader;
+use Doctrine\Common\Cache\ArrayCache;
+use Doctrine\Common\Annotations\CachedReader;
+use Doctrine\Common\Annotations\DocLexer;
+use Doctrine\Common\Annotations\DocParser;
+use Doctrine\Common\Annotations\PhpParser;
+use Doctrine\Common\Annotations\AnnotationReader;
+
+require_once __DIR__ . '/Fixtures/Annotation/Route.php';
+require_once __DIR__ . '/Fixtures/Annotation/Template.php';
+require_once __DIR__ . '/Fixtures/Annotation/Secure.php';
+require_once __DIR__ . '/Fixtures/SingleClassLOC1000.php';
+
+class PerformanceTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @group performance
+     */
+    public function testCachedReadPerformanceWithInMemory()
+    {
+        $reader = new CachedReader(new AnnotationReader(), new ArrayCache());
+        $method = $this->getMethod();
+
+        $time = microtime(true);
+        for ($i=0,$c=500; $i<$c; $i++) {
+            $reader->getMethodAnnotations($method);
+        }
+        $time = microtime(true) - $time;
+
+        $this->printResults('cached reader (in-memory)', $time, $c);
+    }
+
+    /**
+     * @group performance
+     */
+    public function testCachedReadPerformanceWithFileCache()
+    {
+        $method = $this->getMethod();
+
+        // prime cache
+        $reader = new FileCacheReader(new AnnotationReader(), sys_get_temp_dir());
+        $reader->getMethodAnnotations($method);
+
+        $time = microtime(true);
+        for ($i=0,$c=500; $i<$c; $i++) {
+            $reader = new FileCacheReader(new AnnotationReader(), sys_get_temp_dir());
+            $reader->getMethodAnnotations($method);
+            clearstatcache();
+        }
+        $time = microtime(true) - $time;
+
+        $this->printResults('cached reader (file)', $time, $c);
+    }
+
+    /**
+     * @group performance
+     */
+    public function testReadPerformance()
+    {
+        $method = $this->getMethod();
+
+        $time = microtime(true);
+        for ($i=0,$c=150; $i<$c; $i++) {
+            $reader = new AnnotationReader();
+            $reader->getMethodAnnotations($method);
+        }
+        $time = microtime(true) - $time;
+
+        $this->printResults('reader', $time, $c);
+    }
+
+    /**
+     * @group performance
+     */
+    public function testDocParsePerformance()
+    {
+        $imports = array(
+            'ignorephpdoc'     => 'Annotations\Annotation\IgnorePhpDoc',
+            'ignoreannotation' => 'Annotations\Annotation\IgnoreAnnotation',
+            'route'            => 'Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route',
+            'template'         => 'Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Template',
+            '__NAMESPACE__'    => 'Doctrine\Tests\Common\Annotations\Fixtures',
+        );
+        $ignored = array(
+            'access', 'author', 'copyright', 'deprecated', 'example', 'ignore',
+            'internal', 'link', 'see', 'since', 'tutorial', 'version', 'package',
+            'subpackage', 'name', 'global', 'param', 'return', 'staticvar',
+            'static', 'var', 'throws', 'inheritdoc',
+        );
+
+        $method = $this->getMethod();
+        $methodComment = $method->getDocComment();
+        $classComment = $method->getDeclaringClass()->getDocComment();
+
+        $time = microtime(true);
+        for ($i=0,$c=200; $i<$c; $i++) {
+            $parser = new DocParser();
+            $parser->setImports($imports);
+            $parser->setIgnoredAnnotationNames($ignored);
+            $parser->setIgnoreNotImportedAnnotations(true);
+
+            $parser->parse($methodComment);
+            $parser->parse($classComment);
+        }
+        $time = microtime(true) - $time;
+
+        $this->printResults('doc-parser', $time, $c);
+    }
+
+    /**
+     * @group performance
+     */
+    public function testDocLexerPerformance()
+    {
+        $method = $this->getMethod();
+        $methodComment = $method->getDocComment();
+        $classComment = $method->getDeclaringClass()->getDocComment();
+
+        $time = microtime(true);
+        for ($i=0,$c=500; $i<$c; $i++) {
+            $lexer = new DocLexer();
+            $lexer->setInput($methodComment);
+            $lexer->setInput($classComment);
+        }
+        $time = microtime(true) - $time;
+
+        $this->printResults('doc-lexer', $time, $c);
+    }
+
+    /**
+     * @group performance
+     */
+    public function testPhpParserPerformanceWithShortCut()
+    {
+        $class = new \ReflectionClass('Doctrine\Tests\Common\Annotations\Fixtures\NamespacedSingleClassLOC1000');
+
+        $time = microtime(true);
+        for ($i=0,$c=500; $i<$c; $i++) {
+            $parser = new PhpParser();
+            $parser->parseClass($class);
+        }
+        $time = microtime(true) - $time;
+
+        $this->printResults('doc-parser-with-short-cut', $time, $c);
+    }
+
+    /**
+     * @group performance
+     */
+    public function testPhpParserPerformanceWithoutShortCut()
+    {
+        $class = new \ReflectionClass('SingleClassLOC1000');
+
+        $time = microtime(true);
+        for ($i=0,$c=500; $i<$c; $i++) {
+            $parser = new PhpParser();
+            $parser->parseClass($class);
+        }
+        $time = microtime(true) - $time;
+
+        $this->printResults('doc-parser-without-short-cut', $time, $c);
+    }
+
+    private function getMethod()
+    {
+        return new \ReflectionMethod('Doctrine\Tests\Common\Annotations\Fixtures\Controller', 'helloAction');
+    }
+
+    private function printResults($test, $time, $iterations)
+    {
+        if (0 == $iterations) {
+            throw new \InvalidArgumentException('$iterations cannot be zero.');
+        }
+
+        $title = $test." results:\n";
+        $iterationsText = sprintf("Iterations:         %d\n", $iterations);
+        $totalTime      = sprintf("Total Time:         %.3f s\n", $time);
+        $iterationTime  = sprintf("Time per iteration: %.3f ms\n", $time/$iterations * 1000);
+
+        $max = max(strlen($title), strlen($iterationTime)) - 1;
+
+        echo "\n".str_repeat('-', $max)."\n";
+        echo $title;
+        echo str_repeat('=', $max)."\n";
+        echo $iterationsText;
+        echo $totalTime;
+        echo $iterationTime;
+        echo str_repeat('-', $max)."\n";
+    }
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/PhpParserTest.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/PhpParserTest.php
@@ -0,0 +1,207 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations;
+
+use ReflectionClass;
+use Doctrine\Common\Annotations\PhpParser;
+
+require_once __DIR__.'/Fixtures/NonNamespacedClass.php';
+require_once __DIR__.'/Fixtures/GlobalNamespacesPerFileWithClassAsFirst.php';
+require_once __DIR__.'/Fixtures/GlobalNamespacesPerFileWithClassAsLast.php';
+
+class PhpParserTest extends \PHPUnit_Framework_TestCase
+{
+    public function testParseClassWithMultipleClassesInFile()
+    {
+        $class = new ReflectionClass(__NAMESPACE__ . '\Fixtures\MultipleClassesInFile');
+        $parser = new PhpParser();
+
+        $this->assertEquals(array(
+            'route'  => __NAMESPACE__ . '\Fixtures\Annotation\Route',
+            'secure' => __NAMESPACE__ . '\Fixtures\Annotation\Secure',
+        ), $parser->parseClass($class));
+    }
+
+    public function testParseClassWithMultipleImportsInUseStatement()
+    {
+        $class = new ReflectionClass(__NAMESPACE__ . '\Fixtures\MultipleImportsInUseStatement');
+        $parser = new PhpParser();
+
+        $this->assertEquals(array(
+            'route'  => __NAMESPACE__ . '\Fixtures\Annotation\Route',
+            'secure' => __NAMESPACE__ . '\Fixtures\Annotation\Secure',
+        ), $parser->parseClass($class));
+    }
+
+    public function testParseClassWhenNotUserDefined()
+    {
+        $parser = new PhpParser();
+        $this->assertEquals(array(), $parser->parseClass(new \ReflectionClass('\stdClass')));
+    }
+
+    public function testClassFileDoesNotExist()
+    {
+        $class = $this->getMockBuilder('\ReflectionClass')
+                ->disableOriginalConstructor()
+                          ->getMock();
+        $class->expects($this->once())
+             ->method('getFilename')
+             ->will($this->returnValue('/valid/class/Fake.php(35) : eval()d code'));
+
+        $parser = new PhpParser();
+        $this->assertEquals(array(), $parser->parseClass($class));
+    }
+
+    public function testParseClassWhenClassIsNotNamespaced()
+    {
+        $parser = new PhpParser();
+        $class = new ReflectionClass('\AnnotationsTestsFixturesNonNamespacedClass');
+
+        $this->assertEquals(array(
+            'route'    => __NAMESPACE__ . '\Fixtures\Annotation\Route',
+            'template' => __NAMESPACE__ . '\Fixtures\Annotation\Template',
+        ), $parser->parseClass($class));
+    }
+
+    public function testParseClassWhenClassIsInterface()
+    {
+        $parser = new PhpParser();
+        $class = new ReflectionClass(__NAMESPACE__ . '\Fixtures\TestInterface');
+
+        $this->assertEquals(array(
+            'secure' => __NAMESPACE__ . '\Fixtures\Annotation\Secure',
+        ), $parser->parseClass($class));
+    }
+
+    public function testClassWithFullyQualifiedUseStatements()
+    {
+        $parser = new PhpParser();
+        $class = new ReflectionClass(__NAMESPACE__ . '\Fixtures\ClassWithFullyQualifiedUseStatements');
+
+        $this->assertEquals(array(
+            'secure'   => '\\' . __NAMESPACE__ . '\Fixtures\Annotation\Secure',
+            'route'    => '\\' . __NAMESPACE__ . '\Fixtures\Annotation\Route',
+            'template' => '\\' . __NAMESPACE__ . '\Fixtures\Annotation\Template',
+        ), $parser->parseClass($class));
+    }
+
+    public function testNamespaceAndClassCommentedOut()
+    {
+        $parser = new PhpParser();
+        $class = new ReflectionClass(__NAMESPACE__ . '\Fixtures\NamespaceAndClassCommentedOut');
+
+        $this->assertEquals(array(
+            'route'    => __NAMESPACE__ . '\Fixtures\Annotation\Route',
+            'template' => __NAMESPACE__ . '\Fixtures\Annotation\Template',
+        ), $parser->parseClass($class));
+	}
+
+    public function testEqualNamespacesPerFileWithClassAsFirst()
+    {
+        $parser = new PhpParser();
+        $class = new ReflectionClass(__NAMESPACE__ . '\Fixtures\EqualNamespacesPerFileWithClassAsFirst');
+
+        $this->assertEquals(array(
+            'secure'   => __NAMESPACE__ . '\Fixtures\Annotation\Secure',
+            'route'    => __NAMESPACE__ . '\Fixtures\Annotation\Route',
+        ), $parser->parseClass($class));
+    }
+
+    public function testEqualNamespacesPerFileWithClassAsLast()
+    {
+        $parser = new PhpParser();
+        $class = new ReflectionClass(__NAMESPACE__ . '\Fixtures\EqualNamespacesPerFileWithClassAsLast');
+
+        $this->assertEquals(array(
+            'route'    => __NAMESPACE__ . '\Fixtures\Annotation\Route',
+            'template' => __NAMESPACE__ . '\Fixtures\Annotation\Template',
+        ), $parser->parseClass($class));
+    }
+
+    public function testDifferentNamespacesPerFileWithClassAsFirst()
+    {
+        $parser = new PhpParser();
+        $class = new ReflectionClass(__NAMESPACE__ . '\Fixtures\DifferentNamespacesPerFileWithClassAsFirst');
+
+        $this->assertEquals(array(
+            'secure'   => __NAMESPACE__ . '\Fixtures\Annotation\Secure',
+        ), $parser->parseClass($class));
+    }
+
+    public function testDifferentNamespacesPerFileWithClassAsLast()
+    {
+        $parser = new PhpParser();
+        $class = new ReflectionClass(__NAMESPACE__ . '\Fixtures\DifferentNamespacesPerFileWithClassAsLast');
+
+        $this->assertEquals(array(
+            'template' => __NAMESPACE__ . '\Fixtures\Annotation\Template',
+        ), $parser->parseClass($class));
+    }
+
+    public function testGlobalNamespacesPerFileWithClassAsFirst()
+    {
+        $parser = new PhpParser();
+        $class = new \ReflectionClass('\GlobalNamespacesPerFileWithClassAsFirst');
+
+        $this->assertEquals(array(
+            'secure'   => __NAMESPACE__ . '\Fixtures\Annotation\Secure',
+            'route'    => __NAMESPACE__ . '\Fixtures\Annotation\Route',
+        ), $parser->parseClass($class));
+    }
+
+    public function testGlobalNamespacesPerFileWithClassAsLast()
+    {
+        $parser = new PhpParser();
+        $class = new ReflectionClass('\GlobalNamespacesPerFileWithClassAsLast');
+
+        $this->assertEquals(array(
+            'route'    => __NAMESPACE__ . '\Fixtures\Annotation\Route',
+            'template' => __NAMESPACE__ . '\Fixtures\Annotation\Template',
+        ), $parser->parseClass($class));
+    }
+
+    public function testNamespaceWithClosureDeclaration()
+    {
+        $parser = new PhpParser();
+        $class = new ReflectionClass(__NAMESPACE__ . '\Fixtures\NamespaceWithClosureDeclaration');
+
+        $this->assertEquals(array(
+            'secure'   => __NAMESPACE__ . '\Fixtures\Annotation\Secure',
+            'route'    => __NAMESPACE__ . '\Fixtures\Annotation\Route',
+            'template' => __NAMESPACE__ . '\Fixtures\Annotation\Template',
+        ), $parser->parseClass($class));
+    }
+
+    public function testIfPointerResetsOnMultipleParsingTries()
+    {
+        $parser = new PhpParser();
+        $class = new ReflectionClass(__NAMESPACE__ . '\Fixtures\NamespaceWithClosureDeclaration');
+
+        $this->assertEquals(array(
+            'secure'   => __NAMESPACE__ . '\Fixtures\Annotation\Secure',
+            'route'    => __NAMESPACE__ . '\Fixtures\Annotation\Route',
+            'template' => __NAMESPACE__ . '\Fixtures\Annotation\Template',
+        ), $parser->parseClass($class));
+
+        $this->assertEquals(array(
+            'secure'   => __NAMESPACE__ . '\Fixtures\Annotation\Secure',
+            'route'    => __NAMESPACE__ . '\Fixtures\Annotation\Route',
+            'template' => __NAMESPACE__ . '\Fixtures\Annotation\Template',
+        ), $parser->parseClass($class));
+    }
+
+    /**
+     * @group DCOM-97
+     * @group regression
+     */
+    public function testClassWithClosure()
+    {
+        $parser = new PhpParser();
+        $class  = new ReflectionClass(__NAMESPACE__ . '\Fixtures\ClassWithClosure');
+
+        $this->assertEquals(array(
+          'annotationtargetall'         => __NAMESPACE__ . '\Fixtures\AnnotationTargetAll',
+          'annotationtargetannotation'  => __NAMESPACE__ . '\Fixtures\AnnotationTargetAnnotation',
+        ), $parser->parseClass($class));
+    }
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/SimpleAnnotationReaderTest.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/SimpleAnnotationReaderTest.php
@@ -0,0 +1,97 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations;
+
+use Doctrine\Common\Annotations\SimpleAnnotationReader;
+
+class SimpleAnnotationReaderTest extends AbstractReaderTest
+{
+    /**
+     * Contrary to the behavior of the default annotation reader, we do just ignore
+     * these in the simple annotation reader (so, no expected exception here).
+     */
+    public function testImportDetectsNotImportedAnnotation()
+    {
+        parent::testImportDetectsNotImportedAnnotation();
+    }
+
+    /**
+     * Contrary to the behavior of the default annotation reader, we do just ignore
+     * these in the simple annotation reader (so, no expected exception here).
+     */
+    public function testImportDetectsNonExistentAnnotation()
+    {
+        parent::testImportDetectsNonExistentAnnotation();
+    }
+
+    /**
+     * Contrary to the behavior of the default annotation reader, we do just ignore
+     * these in the simple annotation reader (so, no expected exception here).
+     */
+    public function testClassWithInvalidAnnotationTargetAtClassDocBlock()
+    {
+        parent::testClassWithInvalidAnnotationTargetAtClassDocBlock();
+    }
+
+    /**
+     * Contrary to the behavior of the default annotation reader, we do just ignore
+     * these in the simple annotation reader (so, no expected exception here).
+     */
+    public function testClassWithInvalidAnnotationTargetAtPropertyDocBlock()
+    {
+        parent::testClassWithInvalidAnnotationTargetAtPropertyDocBlock();
+    }
+
+    /**
+     * Contrary to the behavior of the default annotation reader, we do just ignore
+     * these in the simple annotation reader (so, no expected exception here).
+     */
+    public function testClassWithInvalidNestedAnnotationTargetAtPropertyDocBlock()
+    {
+        parent::testClassWithInvalidNestedAnnotationTargetAtPropertyDocBlock();
+    }
+
+    /**
+     * Contrary to the behavior of the default annotation reader, we do just ignore
+     * these in the simple annotation reader (so, no expected exception here).
+     */
+    public function testClassWithInvalidAnnotationTargetAtMethodDocBlock()
+    {
+        parent::testClassWithInvalidAnnotationTargetAtMethodDocBlock();
+    }
+
+    /**
+     * @expectedException Doctrine\Common\Annotations\AnnotationException
+     */
+    public function testInvalidAnnotationUsageButIgnoredClass()
+    {
+        parent::testInvalidAnnotationUsageButIgnoredClass();
+    }
+
+    /**
+     * @group DDC-1660
+     * @group regression
+     *
+     * Contrary to the behavior of the default annotation reader, @version is not ignored
+     */
+    public function testInvalidAnnotationButIgnored()
+    {
+        $reader = $this->getReader();
+        $class  = new \ReflectionClass('Doctrine\Tests\Common\Annotations\Fixtures\ClassDDC1660');
+
+        $this->assertTrue(class_exists('Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Version'));
+        $this->assertCount(1, $reader->getClassAnnotations($class));
+        $this->assertCount(1, $reader->getMethodAnnotations($class->getMethod('bar')));
+        $this->assertCount(1, $reader->getPropertyAnnotations($class->getProperty('foo')));
+    }
+    
+    protected function getReader()
+    {
+        $reader = new SimpleAnnotationReader();
+        $reader->addNamespace(__NAMESPACE__);
+        $reader->addNamespace(__NAMESPACE__ . '\Fixtures');
+        $reader->addNamespace(__NAMESPACE__ . '\Fixtures\Annotation');
+
+        return $reader;
+    }
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Ticket/DCOM55Test.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Ticket/DCOM55Test.php
@@ -0,0 +1,65 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Ticket;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\Controller;
+
+/**
+ * @group
+ */
+class DCOM55Test extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @expectedException Doctrine\Common\Annotations\AnnotationException
+     * @expectedExceptionMessage [Semantical Error] The class "Doctrine\Tests\Common\Annotations\Fixtures\Controller" is not annotated with @Annotation. Are you sure this class can be used as annotation? If so, then you need to add @Annotation to the _class_ doc comment of "Doctrine\Tests\Common\Annotations\Fixtures\Controller". If it is indeed no annotation, then you need to add @IgnoreAnnotation("Controller") to the _class_ doc comment of class Doctrine\Tests\Common\Annotations\Ticket\Dummy.
+     */
+    public function testIssue()
+    {
+        $class = new \ReflectionClass(__NAMESPACE__ . '\\Dummy');
+        $reader = new \Doctrine\Common\Annotations\AnnotationReader();
+        $reader->getClassAnnotations($class);
+    }
+
+    public function testAnnotation()
+    {
+        $class = new \ReflectionClass(__NAMESPACE__ . '\\DCOM55Consumer');
+        $reader = new \Doctrine\Common\Annotations\AnnotationReader();
+        $annots = $reader->getClassAnnotations($class);
+
+        $this->assertEquals(1, count($annots));
+        $this->assertInstanceOf(__NAMESPACE__.'\\DCOM55Annotation', $annots[0]);
+    }
+
+    public function testParseAnnotationDocblocks()
+    {
+        $class = new \ReflectionClass(__NAMESPACE__ . '\\DCOM55Annotation');
+        $reader = new \Doctrine\Common\Annotations\AnnotationReader();
+        $annots = $reader->getClassAnnotations($class);
+
+        $this->assertEquals(0, count($annots));
+    }
+}
+
+/**
+ * @Controller
+ */
+class Dummy
+{
+
+}
+
+/**
+ * @Annotation
+ */
+class DCOM55Annotation
+{
+
+}
+
+/**
+ * @DCOM55Annotation
+ */
+class DCOM55Consumer
+{
+
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Ticket/DCOM58Entity.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Ticket/DCOM58Entity.php
@@ -0,0 +1,8 @@
+<?php
+// Some class named Entity in the global namespace
+/**
+ * @Annotation
+ */
+class Entity
+{
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Ticket/DCOM58Test.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/Ticket/DCOM58Test.php
@@ -0,0 +1,112 @@
+<?php
+namespace Doctrine\Tests\Common\Annotations\Ticket;
+
+//Some class named Entity in the global namespace
+include __DIR__ .'/DCOM58Entity.php';
+
+/**
+ * @group DCOM58
+ */
+class DCOM58Test extends \PHPUnit_Framework_TestCase
+{
+    public function testIssue()
+    {
+        $reader     = new \Doctrine\Common\Annotations\AnnotationReader();
+        $result     = $reader->getClassAnnotations(new \ReflectionClass(__NAMESPACE__."\MappedClass"));
+
+        foreach ($result as $annot) {
+            $classAnnotations[get_class($annot)] = $annot;
+        }
+
+        $this->assertTrue(!isset($classAnnotations['']), 'Class "xxx" is not a valid entity or mapped super class.');
+    }
+
+    public function testIssueGlobalNamespace()
+    {
+        $docblock   = "@Entity";
+        $parser     = new \Doctrine\Common\Annotations\DocParser();
+        $parser->setImports(array(
+            "__NAMESPACE__" =>"Doctrine\Tests\Common\Annotations\Ticket\Doctrine\ORM\Mapping"
+        ));
+
+        $annots     = $parser->parse($docblock);
+
+        $this->assertEquals(1, count($annots));
+        $this->assertInstanceOf("Doctrine\Tests\Common\Annotations\Ticket\Doctrine\ORM\Mapping\Entity", $annots[0]);
+    }
+
+    public function testIssueNamespaces()
+    {
+        $docblock   = "@Entity";
+        $parser     = new \Doctrine\Common\Annotations\DocParser();
+        $parser->addNamespace("Doctrine\Tests\Common\Annotations\Ticket\Doctrine\ORM");
+
+        $annots     = $parser->parse($docblock);
+
+        $this->assertEquals(1, count($annots));
+        $this->assertInstanceOf("Doctrine\Tests\Common\Annotations\Ticket\Doctrine\ORM\Entity", $annots[0]);
+    }
+
+    public function testIssueMultipleNamespaces()
+    {
+        $docblock   = "@Entity";
+        $parser     = new \Doctrine\Common\Annotations\DocParser();
+        $parser->addNamespace("Doctrine\Tests\Common\Annotations\Ticket\Doctrine\ORM\Mapping");
+        $parser->addNamespace("Doctrine\Tests\Common\Annotations\Ticket\Doctrine\ORM");
+
+        $annots     = $parser->parse($docblock);
+
+        $this->assertEquals(1, count($annots));
+        $this->assertInstanceOf("Doctrine\Tests\Common\Annotations\Ticket\Doctrine\ORM\Mapping\Entity", $annots[0]);
+    }
+
+    public function testIssueWithNamespacesOrImports()
+    {
+        $docblock   = "@Entity";
+        $parser     = new \Doctrine\Common\Annotations\DocParser();
+        $annots     = $parser->parse($docblock);
+
+        $this->assertEquals(1, count($annots));
+        $this->assertInstanceOf("Entity", $annots[0]);
+        $this->assertEquals(1, count($annots));
+    }
+
+
+    public function testIssueSimpleAnnotationReader()
+    {
+        $reader     = new \Doctrine\Common\Annotations\SimpleAnnotationReader();
+        $reader->addNamespace('Doctrine\Tests\Common\Annotations\Ticket\Doctrine\ORM\Mapping');
+        $annots     = $reader->getClassAnnotations(new \ReflectionClass(__NAMESPACE__."\MappedClass"));
+
+        $this->assertEquals(1, count($annots));
+        $this->assertInstanceOf("Doctrine\Tests\Common\Annotations\Ticket\Doctrine\ORM\Mapping\Entity", $annots[0]);
+    }
+
+}
+
+/**
+ * @Entity
+ */
+class MappedClass
+{
+
+}
+
+
+namespace Doctrine\Tests\Common\Annotations\Ticket\Doctrine\ORM\Mapping;
+/**
+* @Annotation
+*/
+class Entity
+{
+
+}
+
+namespace Doctrine\Tests\Common\Annotations\Ticket\Doctrine\ORM;
+/**
+* @Annotation
+*/
+class Entity
+{
+
+}
--- a/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/TopLevelAnnotation.php
+++ b/vendor/doctrine/annotations/tests/Doctrine/Tests/Common/Annotations/TopLevelAnnotation.php
@@ -0,0 +1,8 @@
+<?php
+
+use Doctrine\Common\Annotations\Annotation;
+
+/** @Annotation */
+class TopLevelAnnotation extends Annotation
+{
+}