class DocParserTest

class DocParserTest extends \PHPUnit_Framework_TestCase {
  public function testNestedArraysWithNestedAnnotation() {
    $parser = $this
      ->createTestParser();

    // Nested arrays with nested annotations
    $result = $parser
      ->parse('@Name(foo={1,2, {"key"=@Name}})');
    $annot = $result[0];
    $this
      ->assertTrue($annot instanceof Name);
    $this
      ->assertNull($annot->value);
    $this
      ->assertEquals(3, count($annot->foo));
    $this
      ->assertEquals(1, $annot->foo[0]);
    $this
      ->assertEquals(2, $annot->foo[1]);
    $this
      ->assertTrue(is_array($annot->foo[2]));
    $nestedArray = $annot->foo[2];
    $this
      ->assertTrue(isset($nestedArray['key']));
    $this
      ->assertTrue($nestedArray['key'] instanceof Name);
  }
  public function testBasicAnnotations() {
    $parser = $this
      ->createTestParser();

    // Marker annotation
    $result = $parser
      ->parse("@Name");
    $annot = $result[0];
    $this
      ->assertTrue($annot instanceof Name);
    $this
      ->assertNull($annot->value);
    $this
      ->assertNull($annot->foo);

    // Associative arrays
    $result = $parser
      ->parse('@Name(foo={"key1" = "value1"})');
    $annot = $result[0];
    $this
      ->assertNull($annot->value);
    $this
      ->assertTrue(is_array($annot->foo));
    $this
      ->assertTrue(isset($annot->foo['key1']));

    // Numerical arrays
    $result = $parser
      ->parse('@Name({2="foo", 4="bar"})');
    $annot = $result[0];
    $this
      ->assertTrue(is_array($annot->value));
    $this
      ->assertEquals('foo', $annot->value[2]);
    $this
      ->assertEquals('bar', $annot->value[4]);
    $this
      ->assertFalse(isset($annot->value[0]));
    $this
      ->assertFalse(isset($annot->value[1]));
    $this
      ->assertFalse(isset($annot->value[3]));

    // Multiple values
    $result = $parser
      ->parse('@Name(@Name, @Name)');
    $annot = $result[0];
    $this
      ->assertTrue($annot instanceof Name);
    $this
      ->assertTrue(is_array($annot->value));
    $this
      ->assertTrue($annot->value[0] instanceof Name);
    $this
      ->assertTrue($annot->value[1] instanceof Name);

    // Multiple types as values
    $result = $parser
      ->parse('@Name(foo="Bar", @Name, {"key1"="value1", "key2"="value2"})');
    $annot = $result[0];
    $this
      ->assertTrue($annot instanceof Name);
    $this
      ->assertTrue(is_array($annot->value));
    $this
      ->assertTrue($annot->value[0] instanceof Name);
    $this
      ->assertTrue(is_array($annot->value[1]));
    $this
      ->assertEquals('value1', $annot->value[1]['key1']);
    $this
      ->assertEquals('value2', $annot->value[1]['key2']);

    // Complete docblock
    $docblock = <<<DOCBLOCK
/**
 * Some nifty class.
 *
 * @author Mr.X
 * @Name(foo="bar")
 */
DOCBLOCK;
    $result = $parser
      ->parse($docblock);
    $this
      ->assertEquals(1, count($result));
    $annot = $result[0];
    $this
      ->assertTrue($annot instanceof Name);
    $this
      ->assertEquals("bar", $annot->foo);
    $this
      ->assertNull($annot->value);
  }
  public function testNamespacedAnnotations() {
    $parser = new DocParser();
    $parser
      ->setIgnoreNotImportedAnnotations(true);
    $docblock = <<<DOCBLOCK
/**
 * Some nifty class.
 *
 * @package foo
 * @subpackage bar
 * @author Mr.X <mr@x.com>
 * @Doctrine\\Tests\\Common\\Annotations\\Name(foo="bar")
 * @ignore
 */
DOCBLOCK;
    $result = $parser
      ->parse($docblock);
    $this
      ->assertEquals(1, count($result));
    $annot = $result[0];
    $this
      ->assertTrue($annot instanceof Name);
    $this
      ->assertEquals("bar", $annot->foo);
  }

  /**
   * @group debug
   */
  public function testTypicalMethodDocBlock() {
    $parser = $this
      ->createTestParser();
    $docblock = <<<DOCBLOCK
/**
 * Some nifty method.
 *
 * @since 2.0
 * @Doctrine\\Tests\\Common\\Annotations\\Name(foo="bar")
 * @param string \$foo This is foo.
 * @param mixed \$bar This is bar.
 * @return string Foo and bar.
 * @This is irrelevant
 * @Marker
 */
DOCBLOCK;
    $result = $parser
      ->parse($docblock);
    $this
      ->assertEquals(2, count($result));
    $this
      ->assertTrue(isset($result[0]));
    $this
      ->assertTrue(isset($result[1]));
    $annot = $result[0];
    $this
      ->assertTrue($annot instanceof Name);
    $this
      ->assertEquals("bar", $annot->foo);
    $marker = $result[1];
    $this
      ->assertTrue($marker instanceof Marker);
  }
  public function testAnnotationWithoutConstructor() {
    $parser = $this
      ->createTestParser();
    $docblock = <<<DOCBLOCK
/**
 * @SomeAnnotationClassNameWithoutConstructor("Some data")
 */
DOCBLOCK;
    $result = $parser
      ->parse($docblock);
    $this
      ->assertEquals(count($result), 1);
    $annot = $result[0];
    $this
      ->assertNotNull($annot);
    $this
      ->assertTrue($annot instanceof SomeAnnotationClassNameWithoutConstructor);
    $this
      ->assertNull($annot->name);
    $this
      ->assertNotNull($annot->data);
    $this
      ->assertEquals($annot->data, "Some data");
    $docblock = <<<DOCBLOCK
/**
 * @SomeAnnotationClassNameWithoutConstructor(name="Some Name", data = "Some data")
 */
DOCBLOCK;
    $result = $parser
      ->parse($docblock);
    $this
      ->assertEquals(count($result), 1);
    $annot = $result[0];
    $this
      ->assertNotNull($annot);
    $this
      ->assertTrue($annot instanceof SomeAnnotationClassNameWithoutConstructor);
    $this
      ->assertEquals($annot->name, "Some Name");
    $this
      ->assertEquals($annot->data, "Some data");
    $docblock = <<<DOCBLOCK
/**
 * @SomeAnnotationClassNameWithoutConstructor(data = "Some data")
 */
DOCBLOCK;
    $result = $parser
      ->parse($docblock);
    $this
      ->assertEquals(count($result), 1);
    $annot = $result[0];
    $this
      ->assertEquals($annot->data, "Some data");
    $this
      ->assertNull($annot->name);
    $docblock = <<<DOCBLOCK
/**
 * @SomeAnnotationClassNameWithoutConstructor(name = "Some name")
 */
DOCBLOCK;
    $result = $parser
      ->parse($docblock);
    $this
      ->assertEquals(count($result), 1);
    $annot = $result[0];
    $this
      ->assertEquals($annot->name, "Some name");
    $this
      ->assertNull($annot->data);
    $docblock = <<<DOCBLOCK
/**
 * @SomeAnnotationClassNameWithoutConstructor("Some data")
 */
DOCBLOCK;
    $result = $parser
      ->parse($docblock);
    $this
      ->assertEquals(count($result), 1);
    $annot = $result[0];
    $this
      ->assertEquals($annot->data, "Some data");
    $this
      ->assertNull($annot->name);
    $docblock = <<<DOCBLOCK
/**
 * @SomeAnnotationClassNameWithoutConstructor("Some data",name = "Some name")
 */
DOCBLOCK;
    $result = $parser
      ->parse($docblock);
    $this
      ->assertEquals(count($result), 1);
    $annot = $result[0];
    $this
      ->assertEquals($annot->name, "Some name");
    $this
      ->assertEquals($annot->data, "Some data");
    $docblock = <<<DOCBLOCK
/**
 * @SomeAnnotationWithConstructorWithoutParams(name = "Some name")
 */
DOCBLOCK;
    $result = $parser
      ->parse($docblock);
    $this
      ->assertEquals(count($result), 1);
    $annot = $result[0];
    $this
      ->assertEquals($annot->name, "Some name");
    $this
      ->assertEquals($annot->data, "Some data");
    $docblock = <<<DOCBLOCK
/**
 * @SomeAnnotationClassNameWithoutConstructorAndProperties()
 */
DOCBLOCK;
    $result = $parser
      ->parse($docblock);
    $this
      ->assertEquals(count($result), 1);
    $this
      ->assertTrue($result[0] instanceof SomeAnnotationClassNameWithoutConstructorAndProperties);
  }
  public function testAnnotationTarget() {
    $parser = new DocParser();
    $parser
      ->setImports(array(
      '__NAMESPACE__' => 'Doctrine\\Tests\\Common\\Annotations\\Fixtures',
    ));
    $class = new \ReflectionClass('Doctrine\\Tests\\Common\\Annotations\\Fixtures\\ClassWithValidAnnotationTarget');
    $context = 'class ' . $class
      ->getName();
    $docComment = $class
      ->getDocComment();
    $parser
      ->setTarget(Target::TARGET_CLASS);
    $this
      ->assertNotNull($parser
      ->parse($docComment, $context));
    $property = $class
      ->getProperty('foo');
    $docComment = $property
      ->getDocComment();
    $context = 'property ' . $class
      ->getName() . "::\$" . $property
      ->getName();
    $parser
      ->setTarget(Target::TARGET_PROPERTY);
    $this
      ->assertNotNull($parser
      ->parse($docComment, $context));
    $method = $class
      ->getMethod('someFunction');
    $docComment = $property
      ->getDocComment();
    $context = 'method ' . $class
      ->getName() . '::' . $method
      ->getName() . '()';
    $parser
      ->setTarget(Target::TARGET_METHOD);
    $this
      ->assertNotNull($parser
      ->parse($docComment, $context));
    try {
      $class = new \ReflectionClass('Doctrine\\Tests\\Common\\Annotations\\Fixtures\\ClassWithInvalidAnnotationTargetAtClass');
      $context = 'class ' . $class
        ->getName();
      $docComment = $class
        ->getDocComment();
      $parser
        ->setTarget(Target::TARGET_CLASS);
      $parser
        ->parse($class
        ->getDocComment(), $context);
      $this
        ->fail();
    } catch (\Doctrine\Common\Annotations\AnnotationException $exc) {
      $this
        ->assertNotNull($exc
        ->getMessage());
    }
    try {
      $class = new \ReflectionClass('Doctrine\\Tests\\Common\\Annotations\\Fixtures\\ClassWithInvalidAnnotationTargetAtMethod');
      $method = $class
        ->getMethod('functionName');
      $docComment = $method
        ->getDocComment();
      $context = 'method ' . $class
        ->getName() . '::' . $method
        ->getName() . '()';
      $parser
        ->setTarget(Target::TARGET_METHOD);
      $parser
        ->parse($docComment, $context);
      $this
        ->fail();
    } catch (\Doctrine\Common\Annotations\AnnotationException $exc) {
      $this
        ->assertNotNull($exc
        ->getMessage());
    }
    try {
      $class = new \ReflectionClass('Doctrine\\Tests\\Common\\Annotations\\Fixtures\\ClassWithInvalidAnnotationTargetAtProperty');
      $property = $class
        ->getProperty('foo');
      $docComment = $property
        ->getDocComment();
      $context = 'property ' . $class
        ->getName() . "::\$" . $property
        ->getName();
      $parser
        ->setTarget(Target::TARGET_PROPERTY);
      $parser
        ->parse($docComment, $context);
      $this
        ->fail();
    } catch (\Doctrine\Common\Annotations\AnnotationException $exc) {
      $this
        ->assertNotNull($exc
        ->getMessage());
    }
  }
  public function getAnnotationVarTypeProviderValid() {

    //({attribute name}, {attribute value})
    return array(
      // mixed type
      array(
        'mixed',
        '"String Value"',
      ),
      array(
        'mixed',
        'true',
      ),
      array(
        'mixed',
        'false',
      ),
      array(
        'mixed',
        '1',
      ),
      array(
        'mixed',
        '1.2',
      ),
      array(
        'mixed',
        '@Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationTargetAll',
      ),
      // boolean type
      array(
        'boolean',
        'true',
      ),
      array(
        'boolean',
        'false',
      ),
      // alias for internal type boolean
      array(
        'bool',
        'true',
      ),
      array(
        'bool',
        'false',
      ),
      // integer type
      array(
        'integer',
        '0',
      ),
      array(
        'integer',
        '1',
      ),
      array(
        'integer',
        '123456789',
      ),
      array(
        'integer',
        '9223372036854775807',
      ),
      // alias for internal type double
      array(
        'float',
        '0.1',
      ),
      array(
        'float',
        '1.2',
      ),
      array(
        'float',
        '123.456',
      ),
      // string type
      array(
        'string',
        '"String Value"',
      ),
      array(
        'string',
        '"true"',
      ),
      array(
        'string',
        '"123"',
      ),
      // array type
      array(
        'array',
        '{@AnnotationExtendsAnnotationTargetAll}',
      ),
      array(
        'array',
        '{@AnnotationExtendsAnnotationTargetAll,@AnnotationExtendsAnnotationTargetAll}',
      ),
      array(
        'arrayOfIntegers',
        '1',
      ),
      array(
        'arrayOfIntegers',
        '{1}',
      ),
      array(
        'arrayOfIntegers',
        '{1,2,3,4}',
      ),
      array(
        'arrayOfAnnotations',
        '@AnnotationExtendsAnnotationTargetAll',
      ),
      array(
        'arrayOfAnnotations',
        '{@Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationTargetAll}',
      ),
      array(
        'arrayOfAnnotations',
        '{@AnnotationExtendsAnnotationTargetAll, @Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationTargetAll}',
      ),
      // annotation instance
      array(
        'annotation',
        '@Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationTargetAll',
      ),
      array(
        'annotation',
        '@AnnotationExtendsAnnotationTargetAll',
      ),
    );
  }
  public function getAnnotationVarTypeProviderInvalid() {

    //({attribute name}, {type declared type}, {attribute value} , {given type or class})
    return array(
      // boolean type
      array(
        'boolean',
        'boolean',
        '1',
        'integer',
      ),
      array(
        'boolean',
        'boolean',
        '1.2',
        'double',
      ),
      array(
        'boolean',
        'boolean',
        '"str"',
        'string',
      ),
      array(
        'boolean',
        'boolean',
        '{1,2,3}',
        'array',
      ),
      array(
        'boolean',
        'boolean',
        '@Name',
        'an instance of Doctrine\\Tests\\Common\\Annotations\\Name',
      ),
      // alias for internal type boolean
      array(
        'bool',
        'bool',
        '1',
        'integer',
      ),
      array(
        'bool',
        'bool',
        '1.2',
        'double',
      ),
      array(
        'bool',
        'bool',
        '"str"',
        'string',
      ),
      array(
        'bool',
        'bool',
        '{"str"}',
        'array',
      ),
      // integer type
      array(
        'integer',
        'integer',
        'true',
        'boolean',
      ),
      array(
        'integer',
        'integer',
        'false',
        'boolean',
      ),
      array(
        'integer',
        'integer',
        '1.2',
        'double',
      ),
      array(
        'integer',
        'integer',
        '"str"',
        'string',
      ),
      array(
        'integer',
        'integer',
        '{"str"}',
        'array',
      ),
      array(
        'integer',
        'integer',
        '{1,2,3,4}',
        'array',
      ),
      // alias for internal type double
      array(
        'float',
        'float',
        'true',
        'boolean',
      ),
      array(
        'float',
        'float',
        'false',
        'boolean',
      ),
      array(
        'float',
        'float',
        '123',
        'integer',
      ),
      array(
        'float',
        'float',
        '"str"',
        'string',
      ),
      array(
        'float',
        'float',
        '{"str"}',
        'array',
      ),
      array(
        'float',
        'float',
        '{12.34}',
        'array',
      ),
      array(
        'float',
        'float',
        '{1,2,3}',
        'array',
      ),
      // string type
      array(
        'string',
        'string',
        'true',
        'boolean',
      ),
      array(
        'string',
        'string',
        'false',
        'boolean',
      ),
      array(
        'string',
        'string',
        '12',
        'integer',
      ),
      array(
        'string',
        'string',
        '1.2',
        'double',
      ),
      array(
        'string',
        'string',
        '{"str"}',
        'array',
      ),
      array(
        'string',
        'string',
        '{1,2,3,4}',
        'array',
      ),
      // annotation instance
      array(
        'annotation',
        'Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationTargetAll',
        'true',
        'boolean',
      ),
      array(
        'annotation',
        'Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationTargetAll',
        'false',
        'boolean',
      ),
      array(
        'annotation',
        'Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationTargetAll',
        '12',
        'integer',
      ),
      array(
        'annotation',
        'Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationTargetAll',
        '1.2',
        'double',
      ),
      array(
        'annotation',
        'Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationTargetAll',
        '{"str"}',
        'array',
      ),
      array(
        'annotation',
        'Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationTargetAll',
        '{1,2,3,4}',
        'array',
      ),
      array(
        'annotation',
        'Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationTargetAll',
        '@Name',
        'an instance of Doctrine\\Tests\\Common\\Annotations\\Name',
      ),
    );
  }
  public function getAnnotationVarTypeArrayProviderInvalid() {

    //({attribute name}, {type declared type}, {attribute value} , {given type or class})
    return array(
      array(
        'arrayOfIntegers',
        'integer',
        'true',
        'boolean',
      ),
      array(
        'arrayOfIntegers',
        'integer',
        'false',
        'boolean',
      ),
      array(
        'arrayOfIntegers',
        'integer',
        '{true,true}',
        'boolean',
      ),
      array(
        'arrayOfIntegers',
        'integer',
        '{1,true}',
        'boolean',
      ),
      array(
        'arrayOfIntegers',
        'integer',
        '{1,2,1.2}',
        'double',
      ),
      array(
        'arrayOfIntegers',
        'integer',
        '{1,2,"str"}',
        'string',
      ),
      array(
        'arrayOfAnnotations',
        'Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationTargetAll',
        'true',
        'boolean',
      ),
      array(
        'arrayOfAnnotations',
        'Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationTargetAll',
        'false',
        'boolean',
      ),
      array(
        'arrayOfAnnotations',
        'Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationTargetAll',
        '{@Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationTargetAll,true}',
        'boolean',
      ),
      array(
        'arrayOfAnnotations',
        'Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationTargetAll',
        '{@Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationTargetAll,true}',
        'boolean',
      ),
      array(
        'arrayOfAnnotations',
        'Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationTargetAll',
        '{@Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationTargetAll,1.2}',
        'double',
      ),
      array(
        'arrayOfAnnotations',
        'Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationTargetAll',
        '{@Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationTargetAll,@AnnotationExtendsAnnotationTargetAll,"str"}',
        'string',
      ),
    );
  }

  /**
   * @dataProvider getAnnotationVarTypeProviderValid
   */
  public function testAnnotationWithVarType($attribute, $value) {
    $parser = $this
      ->createTestParser();
    $context = 'property SomeClassName::$invalidProperty.';
    $docblock = sprintf('@Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationWithVarType(%s = %s)', $attribute, $value);
    $parser
      ->setTarget(Target::TARGET_PROPERTY);
    $result = $parser
      ->parse($docblock, $context);
    $this
      ->assertTrue(sizeof($result) === 1);
    $this
      ->assertInstanceOf('Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationWithVarType', $result[0]);
    $this
      ->assertNotNull($result[0]->{$attribute});
  }

  /**
   * @dataProvider getAnnotationVarTypeProviderInvalid
   */
  public function testAnnotationWithVarTypeError($attribute, $type, $value, $given) {
    $parser = $this
      ->createTestParser();
    $context = 'property SomeClassName::invalidProperty.';
    $docblock = sprintf('@Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationWithVarType(%s = %s)', $attribute, $value);
    $parser
      ->setTarget(Target::TARGET_PROPERTY);
    try {
      $parser
        ->parse($docblock, $context);
      $this
        ->fail();
    } catch (\Doctrine\Common\Annotations\AnnotationException $exc) {
      $this
        ->assertContains("[Type Error] Attribute \"{$attribute}\" of @Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationWithVarType declared on property SomeClassName::invalidProperty. expects a(n) {$type}, but got {$given}.", $exc
        ->getMessage());
    }
  }

  /**
   * @dataProvider getAnnotationVarTypeArrayProviderInvalid
   */
  public function testAnnotationWithVarTypeArrayError($attribute, $type, $value, $given) {
    $parser = $this
      ->createTestParser();
    $context = 'property SomeClassName::invalidProperty.';
    $docblock = sprintf('@Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationWithVarType(%s = %s)', $attribute, $value);
    $parser
      ->setTarget(Target::TARGET_PROPERTY);
    try {
      $parser
        ->parse($docblock, $context);
      $this
        ->fail();
    } catch (\Doctrine\Common\Annotations\AnnotationException $exc) {
      $this
        ->assertContains("[Type Error] Attribute \"{$attribute}\" of @Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationWithVarType declared on property SomeClassName::invalidProperty. expects either a(n) {$type}, or an array of {$type}s, but got {$given}.", $exc
        ->getMessage());
    }
  }

  /**
   * @dataProvider getAnnotationVarTypeProviderValid
   */
  public function testAnnotationWithAttributes($attribute, $value) {
    $parser = $this
      ->createTestParser();
    $context = 'property SomeClassName::$invalidProperty.';
    $docblock = sprintf('@Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationWithAttributes(%s = %s)', $attribute, $value);
    $parser
      ->setTarget(Target::TARGET_PROPERTY);
    $result = $parser
      ->parse($docblock, $context);
    $this
      ->assertTrue(sizeof($result) === 1);
    $this
      ->assertInstanceOf('Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationWithAttributes', $result[0]);
    $getter = "get" . ucfirst($attribute);
    $this
      ->assertNotNull($result[0]
      ->{$getter}());
  }

  /**
   * @dataProvider getAnnotationVarTypeProviderInvalid
   */
  public function testAnnotationWithAttributesError($attribute, $type, $value, $given) {
    $parser = $this
      ->createTestParser();
    $context = 'property SomeClassName::invalidProperty.';
    $docblock = sprintf('@Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationWithAttributes(%s = %s)', $attribute, $value);
    $parser
      ->setTarget(Target::TARGET_PROPERTY);
    try {
      $parser
        ->parse($docblock, $context);
      $this
        ->fail();
    } catch (\Doctrine\Common\Annotations\AnnotationException $exc) {
      $this
        ->assertContains("[Type Error] Attribute \"{$attribute}\" of @Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationWithAttributes declared on property SomeClassName::invalidProperty. expects a(n) {$type}, but got {$given}.", $exc
        ->getMessage());
    }
  }

  /**
   * @dataProvider getAnnotationVarTypeArrayProviderInvalid
   */
  public function testAnnotationWithAttributesWithVarTypeArrayError($attribute, $type, $value, $given) {
    $parser = $this
      ->createTestParser();
    $context = 'property SomeClassName::invalidProperty.';
    $docblock = sprintf('@Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationWithAttributes(%s = %s)', $attribute, $value);
    $parser
      ->setTarget(Target::TARGET_PROPERTY);
    try {
      $parser
        ->parse($docblock, $context);
      $this
        ->fail();
    } catch (\Doctrine\Common\Annotations\AnnotationException $exc) {
      $this
        ->assertContains("[Type Error] Attribute \"{$attribute}\" of @Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationWithAttributes declared on property SomeClassName::invalidProperty. expects either a(n) {$type}, or an array of {$type}s, but got {$given}.", $exc
        ->getMessage());
    }
  }
  public function testAnnotationWithRequiredAttributes() {
    $parser = $this
      ->createTestParser();
    $context = 'property SomeClassName::invalidProperty.';
    $parser
      ->setTarget(Target::TARGET_PROPERTY);
    $docblock = '@Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationWithRequiredAttributes("Some Value", annot = @Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationTargetAnnotation)';
    $result = $parser
      ->parse($docblock);
    $this
      ->assertTrue(sizeof($result) === 1);
    $this
      ->assertInstanceOf('Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationWithRequiredAttributes', $result[0]);
    $this
      ->assertEquals("Some Value", $result[0]
      ->getValue());
    $this
      ->assertInstanceOf('Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationTargetAnnotation', $result[0]
      ->getAnnot());
    $docblock = '@Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationWithRequiredAttributes("Some Value")';
    try {
      $result = $parser
        ->parse($docblock, $context);
      $this
        ->fail();
    } catch (\Doctrine\Common\Annotations\AnnotationException $exc) {
      $this
        ->assertContains('Attribute "annot" of @Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationWithRequiredAttributes declared on property SomeClassName::invalidProperty. expects a(n) Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationTargetAnnotation. This value should not be null.', $exc
        ->getMessage());
    }
    $docblock = '@Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationWithRequiredAttributes(annot = @Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationTargetAnnotation)';
    try {
      $result = $parser
        ->parse($docblock, $context);
      $this
        ->fail();
    } catch (\Doctrine\Common\Annotations\AnnotationException $exc) {
      $this
        ->assertContains('Attribute "value" of @Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationWithRequiredAttributes declared on property SomeClassName::invalidProperty. expects a(n) string. This value should not be null.', $exc
        ->getMessage());
    }
  }
  public function testAnnotationWithRequiredAttributesWithoutContructor() {
    $parser = $this
      ->createTestParser();
    $context = 'property SomeClassName::invalidProperty.';
    $parser
      ->setTarget(Target::TARGET_PROPERTY);
    $docblock = '@Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationWithRequiredAttributesWithoutContructor("Some Value", annot = @Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationTargetAnnotation)';
    $result = $parser
      ->parse($docblock);
    $this
      ->assertTrue(sizeof($result) === 1);
    $this
      ->assertInstanceOf('Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationWithRequiredAttributesWithoutContructor', $result[0]);
    $this
      ->assertEquals("Some Value", $result[0]->value);
    $this
      ->assertInstanceOf('Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationTargetAnnotation', $result[0]->annot);
    $docblock = '@Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationWithRequiredAttributesWithoutContructor("Some Value")';
    try {
      $result = $parser
        ->parse($docblock, $context);
      $this
        ->fail();
    } catch (\Doctrine\Common\Annotations\AnnotationException $exc) {
      $this
        ->assertContains('Attribute "annot" of @Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationWithRequiredAttributesWithoutContructor declared on property SomeClassName::invalidProperty. expects a(n) Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationTargetAnnotation. This value should not be null.', $exc
        ->getMessage());
    }
    $docblock = '@Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationWithRequiredAttributesWithoutContructor(annot = @Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationTargetAnnotation)';
    try {
      $result = $parser
        ->parse($docblock, $context);
      $this
        ->fail();
    } catch (\Doctrine\Common\Annotations\AnnotationException $exc) {
      $this
        ->assertContains('Attribute "value" of @Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationWithRequiredAttributesWithoutContructor declared on property SomeClassName::invalidProperty. expects a(n) string. This value should not be null.', $exc
        ->getMessage());
    }
  }
  public function getConstantsProvider() {
    $provider[] = array(
      '@AnnotationWithConstants(PHP_EOL)',
      PHP_EOL,
    );
    $provider[] = array(
      '@AnnotationWithConstants(AnnotationWithConstants::INTEGER)',
      AnnotationWithConstants::INTEGER,
    );
    $provider[] = array(
      '@Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationWithConstants(AnnotationWithConstants::STRING)',
      AnnotationWithConstants::STRING,
    );
    $provider[] = array(
      '@AnnotationWithConstants(Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationWithConstants::FLOAT)',
      AnnotationWithConstants::FLOAT,
    );
    $provider[] = array(
      '@AnnotationWithConstants(ClassWithConstants::SOME_VALUE)',
      ClassWithConstants::SOME_VALUE,
    );
    $provider[] = array(
      '@AnnotationWithConstants(Doctrine\\Tests\\Common\\Annotations\\Fixtures\\ClassWithConstants::SOME_VALUE)',
      ClassWithConstants::SOME_VALUE,
    );
    $provider[] = array(
      '@AnnotationWithConstants(IntefaceWithConstants::SOME_VALUE)',
      IntefaceWithConstants::SOME_VALUE,
    );
    $provider[] = array(
      '@AnnotationWithConstants(\\Doctrine\\Tests\\Common\\Annotations\\Fixtures\\IntefaceWithConstants::SOME_VALUE)',
      IntefaceWithConstants::SOME_VALUE,
    );
    $provider[] = array(
      '@AnnotationWithConstants({AnnotationWithConstants::STRING, AnnotationWithConstants::INTEGER, AnnotationWithConstants::FLOAT})',
      array(
        AnnotationWithConstants::STRING,
        AnnotationWithConstants::INTEGER,
        AnnotationWithConstants::FLOAT,
      ),
    );
    $provider[] = array(
      '@AnnotationWithConstants({
                AnnotationWithConstants::STRING = AnnotationWithConstants::INTEGER
             })',
      array(
        AnnotationWithConstants::STRING => AnnotationWithConstants::INTEGER,
      ),
    );
    $provider[] = array(
      '@AnnotationWithConstants({
                Doctrine\\Tests\\Common\\Annotations\\Fixtures\\IntefaceWithConstants::SOME_KEY = AnnotationWithConstants::INTEGER
             })',
      array(
        IntefaceWithConstants::SOME_KEY => AnnotationWithConstants::INTEGER,
      ),
    );
    $provider[] = array(
      '@AnnotationWithConstants({
                \\Doctrine\\Tests\\Common\\Annotations\\Fixtures\\IntefaceWithConstants::SOME_KEY = AnnotationWithConstants::INTEGER
             })',
      array(
        IntefaceWithConstants::SOME_KEY => AnnotationWithConstants::INTEGER,
      ),
    );
    $provider[] = array(
      '@AnnotationWithConstants({
                AnnotationWithConstants::STRING = AnnotationWithConstants::INTEGER,
                ClassWithConstants::SOME_KEY = ClassWithConstants::SOME_VALUE,
                Doctrine\\Tests\\Common\\Annotations\\Fixtures\\ClassWithConstants::SOME_KEY = IntefaceWithConstants::SOME_VALUE
             })',
      array(
        AnnotationWithConstants::STRING => AnnotationWithConstants::INTEGER,
        ClassWithConstants::SOME_KEY => ClassWithConstants::SOME_VALUE,
        ClassWithConstants::SOME_KEY => IntefaceWithConstants::SOME_VALUE,
      ),
    );
    return $provider;
  }

  /**
   * @dataProvider getConstantsProvider
   */
  public function testSupportClassConstants($docblock, $expected) {
    $parser = $this
      ->createTestParser();
    $parser
      ->setImports(array(
      'classwithconstants' => 'Doctrine\\Tests\\Common\\Annotations\\Fixtures\\ClassWithConstants',
      'intefacewithconstants' => 'Doctrine\\Tests\\Common\\Annotations\\Fixtures\\IntefaceWithConstants',
      'annotationwithconstants' => 'Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationWithConstants',
    ));
    $result = $parser
      ->parse($docblock);
    $this
      ->assertInstanceOf('\\Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationWithConstants', $annotation = $result[0]);
    $this
      ->assertEquals($expected, $annotation->value);
  }

  /**
   * @expectedException Doctrine\Common\Annotations\AnnotationException
   * @expectedExceptionMessage The annotation @SomeAnnotationClassNameWithoutConstructorAndProperties declared on  does not accept any values, but got {"value":"Foo"}.
   */
  public function testWithoutConstructorWhenIsNotDefaultValue() {
    $parser = $this
      ->createTestParser();
    $docblock = <<<DOCBLOCK
/**
 * @SomeAnnotationClassNameWithoutConstructorAndProperties("Foo")
 */
DOCBLOCK;
    $parser
      ->setTarget(Target::TARGET_CLASS);
    $parser
      ->parse($docblock);
  }

  /**
   * @expectedException Doctrine\Common\Annotations\AnnotationException
   * @expectedExceptionMessage The annotation @SomeAnnotationClassNameWithoutConstructorAndProperties declared on  does not accept any values, but got {"value":"Foo"}.
   */
  public function testWithoutConstructorWhenHasNoProperties() {
    $parser = $this
      ->createTestParser();
    $docblock = <<<DOCBLOCK
/**
 * @SomeAnnotationClassNameWithoutConstructorAndProperties(value = "Foo")
 */
DOCBLOCK;
    $parser
      ->setTarget(Target::TARGET_CLASS);
    $parser
      ->parse($docblock);
  }

  /**
   * @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 testAnnotationTargetSyntaxError() {
    $parser = $this
      ->createTestParser();
    $context = 'class ' . 'SomeClassName';
    $docblock = <<<DOCBLOCK
/**
 * @Doctrine\\Tests\\Common\\Annotations\\Fixtures\\AnnotationWithTargetSyntaxError()
 */
DOCBLOCK;
    $parser
      ->setTarget(Target::TARGET_CLASS);
    $parser
      ->parse($docblock, $context);
  }

  /**
   * @expectedException \InvalidArgumentException
   * @expectedExceptionMessage Invalid Target "Foo". Available targets: [ALL, CLASS, METHOD, PROPERTY, ANNOTATION]
   */
  public function testAnnotationWithInvalidTargetDeclarationError() {
    $parser = $this
      ->createTestParser();
    $context = 'class ' . 'SomeClassName';
    $docblock = <<<DOCBLOCK
/**
 * @AnnotationWithInvalidTargetDeclaration()
 */
DOCBLOCK;
    $parser
      ->setTarget(Target::TARGET_CLASS);
    $parser
      ->parse($docblock, $context);
  }

  /**
   * @expectedException \InvalidArgumentException
   * @expectedExceptionMessage @Target expects either a string value, or an array of strings, "NULL" given.
   */
  public function testAnnotationWithTargetEmptyError() {
    $parser = $this
      ->createTestParser();
    $context = 'class ' . 'SomeClassName';
    $docblock = <<<DOCBLOCK
/**
 * @AnnotationWithTargetEmpty()
 */
DOCBLOCK;
    $parser
      ->setTarget(Target::TARGET_CLASS);
    $parser
      ->parse($docblock, $context);
  }

  /**
   * @group DDC-575
   */
  public function testRegressionDDC575() {
    $parser = $this
      ->createTestParser();
    $docblock = <<<DOCBLOCK
/**
 * @Name
 *
 * Will trigger error.
 */
DOCBLOCK;
    $result = $parser
      ->parse($docblock);
    $this
      ->assertInstanceOf("Doctrine\\Tests\\Common\\Annotations\\Name", $result[0]);
    $docblock = <<<DOCBLOCK
/**
 * @Name
 * @Marker
 *
 * Will trigger error.
 */
DOCBLOCK;
    $result = $parser
      ->parse($docblock);
    $this
      ->assertInstanceOf("Doctrine\\Tests\\Common\\Annotations\\Name", $result[0]);
  }

  /**
   * @group DDC-77
   */
  public function testAnnotationWithoutClassIsIgnoredWithoutWarning() {
    $parser = new DocParser();
    $parser
      ->setIgnoreNotImportedAnnotations(true);
    $result = $parser
      ->parse("@param");
    $this
      ->assertEquals(0, count($result));
  }

  /**
   * @expectedException Doctrine\Common\Annotations\AnnotationException
   * @expectedExceptionMessage Expected PlainValue, got ''' at position 10.
   */
  public function testAnnotationDontAcceptSingleQuotes() {
    $parser = $this
      ->createTestParser();
    $parser
      ->parse("@Name(foo='bar')");
  }

  /**
   * @group DCOM-41
   */
  public function testAnnotationDoesntThrowExceptionWhenAtSignIsNotFollowedByIdentifier() {
    $parser = new DocParser();
    $result = $parser
      ->parse("'@'");
    $this
      ->assertEquals(0, count($result));
  }

  /**
   * @group DCOM-41
   * @expectedException Doctrine\Common\Annotations\AnnotationException
   */
  public function testAnnotationThrowsExceptionWhenAtSignIsNotFollowedByIdentifierInNestedAnnotation() {
    $parser = new DocParser();
    $result = $parser
      ->parse("@Doctrine\\Tests\\Common\\Annotations\\Name(@')");
  }

  /**
   * @group DCOM-56
   */
  public function testAutoloadAnnotation() {
    $this
      ->assertFalse(class_exists('Doctrine\\Tests\\Common\\Annotations\\Fixture\\Annotation\\Autoload', false), 'Pre-condition: Doctrine\\Tests\\Common\\Annotations\\Fixture\\Annotation\\Autoload not allowed to be loaded.');
    $parser = new DocParser();
    AnnotationRegistry::registerAutoloadNamespace('Doctrine\\Tests\\Common\\Annotations\\Fixtures\\Annotation', __DIR__ . '/../../../../');
    $parser
      ->setImports(array(
      'autoload' => 'Doctrine\\Tests\\Common\\Annotations\\Fixtures\\Annotation\\Autoload',
    ));
    $annotations = $parser
      ->parse('@Autoload');
    $this
      ->assertEquals(1, count($annotations));
    $this
      ->assertInstanceOf('Doctrine\\Tests\\Common\\Annotations\\Fixtures\\Annotation\\Autoload', $annotations[0]);
  }
  public function createTestParser() {
    $parser = new DocParser();
    $parser
      ->setIgnoreNotImportedAnnotations(true);
    $parser
      ->setImports(array(
      'name' => 'Doctrine\\Tests\\Common\\Annotations\\Name',
      '__NAMESPACE__' => 'Doctrine\\Tests\\Common\\Annotations',
    ));
    return $parser;
  }

  /**
   * @group DDC-78
   * @expectedException Doctrine\Common\Annotations\AnnotationException
   * @expectedExceptionMessage Expected PlainValue, got ''' at position 10 in class \Doctrine\Tests\Common\Annotations\Name
   */
  public function testSyntaxErrorWithContextDescription() {
    $parser = $this
      ->createTestParser();
    $parser
      ->parse("@Name(foo='bar')", "class \\Doctrine\\Tests\\Common\\Annotations\\Name");
  }

  /**
   * @group DDC-183
   */
  public function testSyntaxErrorWithUnknownCharacters() {
    $docblock = <<<DOCBLOCK
/**
 * @test at.
 */
class A {
}
DOCBLOCK;

    //$lexer = new \Doctrine\Common\Annotations\Lexer();

    //$lexer->setInput(trim($docblock, '/ *'));

    //var_dump($lexer);
    try {
      $parser = $this
        ->createTestParser();
      $result = $parser
        ->parse($docblock);
    } catch (Exception $e) {
      $this
        ->fail($e
        ->getMessage());
    }
  }

  /**
   * @group DCOM-14
   */
  public function testIgnorePHPDocThrowTag() {
    $docblock = <<<DOCBLOCK
/**
 * @throws \\RuntimeException
 */
class A {
}
DOCBLOCK;
    try {
      $parser = $this
        ->createTestParser();
      $result = $parser
        ->parse($docblock);
    } catch (Exception $e) {
      $this
        ->fail($e
        ->getMessage());
    }
  }

  /**
   * @group DCOM-38
   */
  public function testCastInt() {
    $parser = $this
      ->createTestParser();
    $result = $parser
      ->parse("@Name(foo=1234)");
    $annot = $result[0];
    $this
      ->assertInternalType('int', $annot->foo);
  }

  /**
   * @group DCOM-38
   */
  public function testCastNegativeInt() {
    $parser = $this
      ->createTestParser();
    $result = $parser
      ->parse("@Name(foo=-1234)");
    $annot = $result[0];
    $this
      ->assertInternalType('int', $annot->foo);
  }

  /**
   * @group DCOM-38
   */
  public function testCastFloat() {
    $parser = $this
      ->createTestParser();
    $result = $parser
      ->parse("@Name(foo=1234.345)");
    $annot = $result[0];
    $this
      ->assertInternalType('float', $annot->foo);
  }

  /**
   * @group DCOM-38
   */
  public function testCastNegativeFloat() {
    $parser = $this
      ->createTestParser();
    $result = $parser
      ->parse("@Name(foo=-1234.345)");
    $annot = $result[0];
    $this
      ->assertInternalType('float', $annot->foo);
    $result = $parser
      ->parse("@Marker(-1234.345)");
    $annot = $result[0];
    $this
      ->assertInternalType('float', $annot->value);
  }
  public function testReservedKeywordsInAnnotations() {
    $parser = $this
      ->createTestParser();
    $result = $parser
      ->parse('@Doctrine\\Tests\\Common\\Annotations\\True');
    $this
      ->assertTrue($result[0] instanceof True);
    $result = $parser
      ->parse('@Doctrine\\Tests\\Common\\Annotations\\False');
    $this
      ->assertTrue($result[0] instanceof False);
    $result = $parser
      ->parse('@Doctrine\\Tests\\Common\\Annotations\\Null');
    $this
      ->assertTrue($result[0] instanceof Null);
    $result = $parser
      ->parse('@True');
    $this
      ->assertTrue($result[0] instanceof True);
    $result = $parser
      ->parse('@False');
    $this
      ->assertTrue($result[0] instanceof False);
    $result = $parser
      ->parse('@Null');
    $this
      ->assertTrue($result[0] instanceof Null);
  }

  /**
   * @expectedException Doctrine\Common\Annotations\AnnotationException
   * @expectedExceptionMessage [Creation Error] The annotation @SomeAnnotationClassNameWithoutConstructor declared on some class does not have a property named "invalidaProperty". Available properties: data, name
   */
  public function testSetValuesExeption() {
    $docblock = <<<DOCBLOCK
/**
 * @SomeAnnotationClassNameWithoutConstructor(invalidaProperty = "Some val")
 */
DOCBLOCK;
    $this
      ->createTestParser()
      ->parse($docblock, 'some class');
  }

  /**
   * @expectedException Doctrine\Common\Annotations\AnnotationException
   * @expectedExceptionMessage [Syntax Error] Expected Doctrine\Common\Annotations\DocLexer::T_IDENTIFIER or Doctrine\Common\Annotations\DocLexer::T_TRUE or Doctrine\Common\Annotations\DocLexer::T_FALSE or Doctrine\Common\Annotations\DocLexer::T_NULL, got '3.42' at position 5.
   */
  public function testInvalidIdentifierInAnnotation() {
    $parser = $this
      ->createTestParser();
    $parser
      ->parse('@Foo\\3.42');
  }
  public function testTrailingCommaIsAllowed() {
    $parser = $this
      ->createTestParser();
    $annots = $parser
      ->parse('@Name({
            "Foo",
            "Bar",
        })');
    $this
      ->assertEquals(1, count($annots));
    $this
      ->assertEquals(array(
      'Foo',
      'Bar',
    ), $annots[0]->value);
  }
  public function testDefaultAnnotationValueIsNotOverwritten() {
    $parser = $this
      ->createTestParser();
    $annots = $parser
      ->parse('@Doctrine\\Tests\\Common\\Annotations\\Fixtures\\Annotation\\AnnotWithDefaultValue');
    $this
      ->assertEquals(1, count($annots));
    $this
      ->assertEquals('bar', $annots[0]->foo);
  }
  public function testArrayWithColon() {
    $parser = $this
      ->createTestParser();
    $annots = $parser
      ->parse('@Name({"foo": "bar"})');
    $this
      ->assertEquals(1, count($annots));
    $this
      ->assertEquals(array(
      'foo' => 'bar',
    ), $annots[0]->value);
  }

  /**
   * @expectedException Doctrine\Common\Annotations\AnnotationException
   * @expectedExceptionMessage [Semantical Error] Couldn't find constant foo.
   */
  public function testInvalidContantName() {
    $parser = $this
      ->createTestParser();
    $parser
      ->parse('@Name(foo: "bar")');
  }

}