From 8df8eb251331965c83170af6681f4a904606a594 Mon Sep 17 00:00:00 2001
From: alexmart <alex@alex-mb.local>
Date: Sat, 21 May 2016 16:46:04 +0200
Subject: [PATCH 1/2] Short version example for Type constraint.

---
 reference/constraints/Type.rst | 61 ++++++++++++++++++++++++++++++++++
 1 file changed, 61 insertions(+)

diff --git a/reference/constraints/Type.rst b/reference/constraints/Type.rst
index abf93fe5b75..fe0fa7b54b9 100644
--- a/reference/constraints/Type.rst
+++ b/reference/constraints/Type.rst
@@ -19,6 +19,67 @@ option to validate this.
 Basic Usage
 -----------
 
+.. configuration-block::
+
+    .. code-block:: php-annotations
+
+        // src/AppBundle/Entity/Author.php
+        namespace AppBundle\Entity;
+
+        use Symfony\Component\Validator\Constraints as Assert;
+
+        class Author
+        {
+            /**
+             * @Assert\Type("integer")
+             */
+            protected $age;
+        }
+
+    .. code-block:: yaml
+
+        # src/AppBundle/Resources/config/validation.yml
+        AppBundle\Entity\Author:
+            properties:
+                age:
+                    - Type: integer
+
+    .. code-block:: xml
+
+        <!-- src/AppBundle/Resources/config/validation.xml -->
+        <?xml version="1.0" encoding="UTF-8" ?>
+        <constraint-mapping xmlns="http://symfony.com/schema/dic/constraint-mapping"
+            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+            xsi:schemaLocation="http://symfony.com/schema/dic/constraint-mapping http://symfony.com/schema/dic/constraint-mapping/constraint-mapping-1.0.xsd">
+
+            <class name="AppBundle\Entity\Author">
+                <property name="age">
+                    <constraint name="Type">
+                        <type>integer</type>
+                    </constraint>
+                </property>
+            </class>
+        </constraint-mapping>
+
+    .. code-block:: php
+
+        // src/AppBundle/Entity/Author.php
+        namespace AppBundle\Entity;
+
+        use Symfony\Component\Validator\Mapping\ClassMetadata;
+        use Symfony\Component\Validator\Constraints as Assert;
+
+        class Author
+        {
+            public static function loadValidatorMetadata(ClassMetadata $metadata)
+            {
+                $metadata->addPropertyConstraint('age', new Assert\Type('integer');
+            }
+        }
+
+Configure more options
+~~~~~~~~~~~~~~~~~~~~~~
+
 .. configuration-block::
 
     .. code-block:: php-annotations

From 101a129af460398784a145e4086c48fa2b2f49bc Mon Sep 17 00:00:00 2001
From: alexmart <alex@alex-mb.local>
Date: Tue, 24 May 2016 12:12:16 +0200
Subject: [PATCH 2/2] Constraint examples using the default option.

---
 reference/constraints/Choice.rst             | 18 +++++
 reference/constraints/EqualTo.rst            | 18 ++++-
 reference/constraints/GreaterThan.rst        | 21 +++++-
 reference/constraints/GreaterThanOrEqual.rst | 19 ++++-
 reference/constraints/IdenticalTo.rst        | 10 ++-
 reference/constraints/LessThan.rst           | 20 +++++-
 reference/constraints/LessThanOrEqual.rst    | 19 ++++-
 reference/constraints/NotEqualTo.rst         | 19 ++++-
 reference/constraints/NotIdenticalTo.rst     | 19 ++++-
 reference/constraints/Type.rst               | 73 ++++----------------
 10 files changed, 162 insertions(+), 74 deletions(-)

diff --git a/reference/constraints/Choice.rst b/reference/constraints/Choice.rst
index aeeadee7a64..b4d5a9a2f40 100644
--- a/reference/constraints/Choice.rst
+++ b/reference/constraints/Choice.rst
@@ -45,6 +45,11 @@ If your valid choice list is simple, you can pass them in directly via the
 
         class Author
         {
+            /**
+             * @Assert\Choice({"New York", "Berlin", "Tokyo"})
+             */
+            protected $city;
+
             /**
              * @Assert\Choice(choices = {"male", "female"}, message = "Choose a valid gender.")
              */
@@ -56,6 +61,7 @@ If your valid choice list is simple, you can pass them in directly via the
         # src/AppBundle/Resources/config/validation.yml
         AppBundle\Entity\Author:
             properties:
+                city: [New York, Berlin, Tokyo]
                 gender:
                     - Choice:
                         choices:  [male, female]
@@ -70,6 +76,13 @@ If your valid choice list is simple, you can pass them in directly via the
             xsi:schemaLocation="http://symfony.com/schema/dic/constraint-mapping http://symfony.com/schema/dic/constraint-mapping/constraint-mapping-1.0.xsd">
 
             <class name="AppBundle\Entity\Author">
+                <property name="city">
+                    <constraint name="Choice">
+                        <value>New York</value>
+                        <value>Berlin</value>
+                        <value>Tokyo</value>
+                    </constraint>
+                </property>
                 <property name="gender">
                     <constraint name="Choice">
                         <option name="choices">
@@ -96,6 +109,11 @@ If your valid choice list is simple, you can pass them in directly via the
 
             public static function loadValidatorMetadata(ClassMetadata $metadata)
             {
+                $metadata->addPropertyConstraint(
+                    'gender',
+                     new Assert\Choice(array('New York', 'Berlin', 'Tokyo'))
+                 );
+
                 $metadata->addPropertyConstraint('gender', new Assert\Choice(array(
                     'choices' => array('male', 'female'),
                     'message' => 'Choose a valid gender.',
diff --git a/reference/constraints/EqualTo.rst b/reference/constraints/EqualTo.rst
index 1603d938757..acfdf47d9e2 100644
--- a/reference/constraints/EqualTo.rst
+++ b/reference/constraints/EqualTo.rst
@@ -27,8 +27,8 @@ To force that a value is *not* equal, see :doc:`/reference/constraints/NotEqualT
 Basic Usage
 -----------
 
-If you want to ensure that the ``age`` of a ``Person`` class is equal to
-``20``, you could do the following:
+If you want to ensure that the ``firstName`` of a ``Person`` class is equal to ``Mary``
+and that the ``age`` is ``20``, you could do the following:
 
 .. configuration-block::
 
@@ -41,6 +41,11 @@ If you want to ensure that the ``age`` of a ``Person`` class is equal to
 
         class Person
         {
+            /**
+             * @Assert\EqualTo("Mary")
+             */
+            protected $firstName;
+
             /**
              * @Assert\EqualTo(
              *     value = 20
@@ -54,6 +59,8 @@ If you want to ensure that the ``age`` of a ``Person`` class is equal to
         # src/AppBundle/Resources/config/validation.yml
         AppBundle\Entity\Person:
             properties:
+                firstName:
+                    - EqualTo: Mary
                 age:
                     - EqualTo:
                         value: 20
@@ -67,6 +74,11 @@ If you want to ensure that the ``age`` of a ``Person`` class is equal to
             xsi:schemaLocation="http://symfony.com/schema/dic/constraint-mapping http://symfony.com/schema/dic/constraint-mapping/constraint-mapping-1.0.xsd">
 
             <class name="AppBundle\Entity\Person">
+                <property name="firstName">
+                    <constraint name="EqualTo">
+                        <value>Mary</value>
+                    </constraint>
+                </property>
                 <property name="age">
                     <constraint name="EqualTo">
                         <option name="value">20</option>
@@ -87,6 +99,8 @@ If you want to ensure that the ``age`` of a ``Person`` class is equal to
         {
             public static function loadValidatorMetadata(ClassMetadata $metadata)
             {
+                $metadata->addPropertyConstraint('firstName', new Assert\EqualTo('Mary'));
+
                 $metadata->addPropertyConstraint('age', new Assert\EqualTo(array(
                     'value' => 20,
                 )));
diff --git a/reference/constraints/GreaterThan.rst b/reference/constraints/GreaterThan.rst
index a7a167e39af..e4d1b7b163a 100644
--- a/reference/constraints/GreaterThan.rst
+++ b/reference/constraints/GreaterThan.rst
@@ -23,8 +23,10 @@ than another value, see :doc:`/reference/constraints/LessThan`.
 Basic Usage
 -----------
 
-If you want to ensure that the ``age`` of a ``Person`` class is greater
-than ``18``, you could do the following:
+The following constraints ensure that:
+- the number of ``siblings`` of a ``Person`` is greater than ``5``
+- the ``age`` of a ``Person`` class is greater than ``18``
+
 
 .. configuration-block::
 
@@ -37,6 +39,12 @@ than ``18``, you could do the following:
 
         class Person
         {
+
+            /**
+             * @Assert\GreaterThan(5)
+             */
+            protected $siblings;
+
             /**
              * @Assert\GreaterThan(
              *     value = 18
@@ -50,6 +58,8 @@ than ``18``, you could do the following:
         # src/AppBundle/Resources/config/validation.yml
         AppBundle\Entity\Person:
             properties:
+                siblings:
+                    - GreaterThan: 5
                 age:
                     - GreaterThan:
                         value: 18
@@ -63,6 +73,11 @@ than ``18``, you could do the following:
             xsi:schemaLocation="http://symfony.com/schema/dic/constraint-mapping http://symfony.com/schema/dic/constraint-mapping/constraint-mapping-1.0.xsd">
 
             <class name="AppBundle\Entity\Person">
+                <property name="siblings">
+                    <constraint name="GreaterThan">
+                        <value>5</value>
+                    </constraint>
+                </property>
                 <property name="age">
                     <constraint name="GreaterThan">
                         <option name="value">18</option>
@@ -83,6 +98,8 @@ than ``18``, you could do the following:
         {
             public static function loadValidatorMetadata(ClassMetadata $metadata)
             {
+                $metadata->addPropertyConstraint('siblings', new Assert\GreaterThan(5));
+
                 $metadata->addPropertyConstraint('age', new Assert\GreaterThan(array(
                     'value' => 18,
                 )));
diff --git a/reference/constraints/GreaterThanOrEqual.rst b/reference/constraints/GreaterThanOrEqual.rst
index dc6af7535d8..8e3e92afa47 100644
--- a/reference/constraints/GreaterThanOrEqual.rst
+++ b/reference/constraints/GreaterThanOrEqual.rst
@@ -22,8 +22,9 @@ in the options. To force that a value is greater than another value, see
 Basic Usage
 -----------
 
-If you want to ensure that the ``age`` of a ``Person`` class is greater
-than or equal to ``18``, you could do the following:
+The following constraints ensure that:
+- the number of ``siblings`` of a ``Person`` is greater than or equal to ``5``
+- the ``age`` of a ``Person`` class is greater than or equal to ``18``
 
 .. configuration-block::
 
@@ -36,6 +37,11 @@ than or equal to ``18``, you could do the following:
 
         class Person
         {
+            /**
+             * @Assert\GreaterThanOrEqual(5)
+             */
+            protected $siblings;
+
             /**
              * @Assert\GreaterThanOrEqual(
              *     value = 18
@@ -49,6 +55,8 @@ than or equal to ``18``, you could do the following:
         # src/AppBundle/Resources/config/validation.yml
         AppBundle\Entity\Person:
             properties:
+                siblings:
+                    - GreaterThanOrEqual: 5
                 age:
                     - GreaterThanOrEqual:
                         value: 18
@@ -62,6 +70,11 @@ than or equal to ``18``, you could do the following:
             xsi:schemaLocation="http://symfony.com/schema/dic/constraint-mapping http://symfony.com/schema/dic/constraint-mapping/constraint-mapping-1.0.xsd">
 
             <class name="AppBundle\Entity\Person">
+                <property name="siblings">
+                    <constraint name="GreaterThanOrEqual">
+                        <value>5</value>
+                    </constraint>
+                </property>
                 <property name="age">
                     <constraint name="GreaterThanOrEqual">
                         <option name="value">18</option>
@@ -82,6 +95,8 @@ than or equal to ``18``, you could do the following:
         {
             public static function loadValidatorMetadata(ClassMetadata $metadata)
             {
+                $metadata->addPropertyConstraint('siblings', new Assert\GreaterThanOrEqual(5));
+
                 $metadata->addPropertyConstraint('age', new Assert\GreaterThanOrEqual(array(
                     'value' => 18,
                 )));
diff --git a/reference/constraints/IdenticalTo.rst b/reference/constraints/IdenticalTo.rst
index aead27a3fb3..c2effefb99d 100644
--- a/reference/constraints/IdenticalTo.rst
+++ b/reference/constraints/IdenticalTo.rst
@@ -28,8 +28,9 @@ To force that a value is *not* identical, see
 Basic Usage
 -----------
 
-If you want to ensure that the ``age`` of a ``Person`` class is equal to
-``20`` and an integer, you could do the following:
+The following constraints ensure that:
+- ``firstName`` of ``Person` class is equal to ``Mary`` *and* is a string
+- ``age`` is equal to``20`` *and* is of type integer
 
 .. configuration-block::
 
@@ -42,6 +43,11 @@ If you want to ensure that the ``age`` of a ``Person`` class is equal to
 
         class Person
         {
+            /**
+             * @Assert\IdenticalTo("Mary")
+             */
+            protected $firstName;
+
             /**
              * @Assert\IdenticalTo(
              *     value = 20
diff --git a/reference/constraints/LessThan.rst b/reference/constraints/LessThan.rst
index 2feaa389780..33d4400a6af 100644
--- a/reference/constraints/LessThan.rst
+++ b/reference/constraints/LessThan.rst
@@ -23,8 +23,9 @@ than another value, see :doc:`/reference/constraints/GreaterThan`.
 Basic Usage
 -----------
 
-If you want to ensure that the ``age`` of a ``Person`` class is less than
-``80``, you could do the following:
+The following constraints ensure that:
+- the number of ``siblings`` of a ``Person`` is less than or equal to ``5``
+- ``age`` is less than``80``
 
 .. configuration-block::
 
@@ -37,6 +38,12 @@ If you want to ensure that the ``age`` of a ``Person`` class is less than
 
         class Person
         {
+
+            /**
+             * @Assert\LessThan(5)
+             */
+            protected $siblings;
+
             /**
              * @Assert\LessThan(
              *     value = 80
@@ -50,6 +57,8 @@ If you want to ensure that the ``age`` of a ``Person`` class is less than
         # src/AppBundle/Resources/config/validation.yml
         AppBundle\Entity\Person:
             properties:
+                siblings:
+                    - LessThan: 5
                 age:
                     - LessThan:
                         value: 80
@@ -63,6 +72,11 @@ If you want to ensure that the ``age`` of a ``Person`` class is less than
             xsi:schemaLocation="http://symfony.com/schema/dic/constraint-mapping http://symfony.com/schema/dic/constraint-mapping/constraint-mapping-1.0.xsd">
 
             <class name="AppBundle\Entity\Person">
+                <property name="siblings">
+                    <constraint name="LessThan">
+                        <value>5</value>
+                    </constraint>
+                </property>
                 <property name="age">
                     <constraint name="LessThan">
                         <option name="value">80</option>
@@ -83,6 +97,8 @@ If you want to ensure that the ``age`` of a ``Person`` class is less than
         {
             public static function loadValidatorMetadata(ClassMetadata $metadata)
             {
+                $metadata->addPropertyConstraint('siblings', new Assert\LessThan(5));
+
                 $metadata->addPropertyConstraint('age', new Assert\LessThan(array(
                     'value' => 80,
                 )));
diff --git a/reference/constraints/LessThanOrEqual.rst b/reference/constraints/LessThanOrEqual.rst
index e72686f1d19..8da19ae6f12 100644
--- a/reference/constraints/LessThanOrEqual.rst
+++ b/reference/constraints/LessThanOrEqual.rst
@@ -22,8 +22,9 @@ the options. To force that a value is less than another value, see
 Basic Usage
 -----------
 
-If you want to ensure that the ``age`` of a ``Person`` class is less than
-or equal to ``80``, you could do the following:
+The following constraints ensure that:
+- the number of ``siblings`` of a ``Person`` is less than or equal to ``5``
+- the ``age`` is less than or equal to ``80``
 
 .. configuration-block::
 
@@ -36,6 +37,11 @@ or equal to ``80``, you could do the following:
 
         class Person
         {
+            /**
+             * @Assert\LessThanOrEqual(5)
+             */
+            protected $siblings;
+
             /**
              * @Assert\LessThanOrEqual(
              *     value = 80
@@ -49,6 +55,8 @@ or equal to ``80``, you could do the following:
         # src/AppBundle/Resources/config/validation.yml
         AppBundle\Entity\Person:
             properties:
+                siblings:
+                    - LessThanOrEqual: 5
                 age:
                     - LessThanOrEqual:
                         value: 80
@@ -62,6 +70,11 @@ or equal to ``80``, you could do the following:
             xsi:schemaLocation="http://symfony.com/schema/dic/constraint-mapping http://symfony.com/schema/dic/constraint-mapping/constraint-mapping-1.0.xsd">
 
             <class name="AppBundle\Entity\Person">
+                <property name="siblings">
+                    <constraint name="LessThanOrEqual">
+                        <value>5</value>
+                    </constraint>
+                </property>
                 <property name="age">
                     <constraint name="LessThanOrEqual">
                         <option name="value">80</option>
@@ -82,6 +95,8 @@ or equal to ``80``, you could do the following:
         {
             public static function loadValidatorMetadata(ClassMetadata $metadata)
             {
+                $metadata->addPropertyConstraint('siblings', new Assert\LessThanOrEqual(5));
+
                 $metadata->addPropertyConstraint('age', new Assert\LessThanOrEqual(array(
                     'value' => 80,
                 )));
diff --git a/reference/constraints/NotEqualTo.rst b/reference/constraints/NotEqualTo.rst
index 1902da92512..4f9ca2a227c 100644
--- a/reference/constraints/NotEqualTo.rst
+++ b/reference/constraints/NotEqualTo.rst
@@ -27,9 +27,10 @@ options. To force that a value is equal, see
 
 Basic Usage
 -----------
+If you want to ensure that the ``firstName`` of a ``Person`` is not equal to
+``Mary`` and that the ``age`` of a ``Person`` class is not ``15``, you could do
+the following:
 
-If you want to ensure that the ``age`` of a ``Person`` class is not equal
-to ``15``, you could do the following:
 
 .. configuration-block::
 
@@ -42,6 +43,11 @@ to ``15``, you could do the following:
 
         class Person
         {
+            /**
+             * @Assert\NotEqualTo("Mary")
+             */
+            protected $firstName;
+
             /**
              * @Assert\NotEqualTo(
              *     value = 15
@@ -55,6 +61,8 @@ to ``15``, you could do the following:
         # src/AppBundle/Resources/config/validation.yml
         AppBundle\Entity\Person:
             properties:
+                firstName:
+                    - NotEqualTo: Mary
                 age:
                     - NotEqualTo:
                         value: 15
@@ -68,6 +76,11 @@ to ``15``, you could do the following:
             xsi:schemaLocation="http://symfony.com/schema/dic/constraint-mapping http://symfony.com/schema/dic/constraint-mapping/constraint-mapping-1.0.xsd">
 
             <class name="AppBundle\Entity\Person">
+                <property name="firstName">
+                    <constraint name="NotEqualTo">
+                        <value>Mary</value>
+                    </constraint>
+                </property>
                 <property name="age">
                     <constraint name="NotEqualTo">
                         <option name="value">15</option>
@@ -88,6 +101,8 @@ to ``15``, you could do the following:
         {
             public static function loadValidatorMetadata(ClassMetadata $metadata)
             {
+                $metadata->addPropertyConstraint('age', new Assert\NotEqualTo('Mary'));
+
                 $metadata->addPropertyConstraint('age', new Assert\NotEqualTo(array(
                     'value' => 15,
                 )));
diff --git a/reference/constraints/NotIdenticalTo.rst b/reference/constraints/NotIdenticalTo.rst
index 018b86dbf6e..5ca16e805fc 100644
--- a/reference/constraints/NotIdenticalTo.rst
+++ b/reference/constraints/NotIdenticalTo.rst
@@ -28,8 +28,9 @@ the options. To force that a value is identical, see
 Basic Usage
 -----------
 
-If you want to ensure that the ``age`` of a ``Person`` class is *not* equal
-to ``15`` and *not* an integer, you could do the following:
+The following constraints ensure that:
+- ``firstName`` of ``Person`` is not equal to ``Mary`` *or* not of the same type
+- ``age`` of ``Person`` class is not equal to ``15`` *or* not of the same type
 
 .. configuration-block::
 
@@ -42,6 +43,11 @@ to ``15`` and *not* an integer, you could do the following:
 
         class Person
         {
+            /**
+             * @Assert\NotIdenticalTo("Mary")
+             */
+            protected $firstName;
+
             /**
              * @Assert\NotIdenticalTo(
              *     value = 15
@@ -55,6 +61,8 @@ to ``15`` and *not* an integer, you could do the following:
         # src/AppBundle/Resources/config/validation.yml
         AppBundle\Entity\Person:
             properties:
+                firstName:
+                    - NotIdenticalTo: Mary
                 age:
                     - NotIdenticalTo:
                         value: 15
@@ -68,6 +76,11 @@ to ``15`` and *not* an integer, you could do the following:
             xsi:schemaLocation="http://symfony.com/schema/dic/constraint-mapping http://symfony.com/schema/dic/constraint-mapping/constraint-mapping-1.0.xsd">
 
             <class name="AppBundle\Entity\Person">
+            <property name="firstName">
+                    <constraint name="NotIdenticalTo">
+                        <value>Mary</value>
+                    </constraint>
+                </property>
                 <property name="age">
                     <constraint name="NotIdenticalTo">
                         <option name="value">15</option>
@@ -88,6 +101,8 @@ to ``15`` and *not* an integer, you could do the following:
         {
             public static function loadValidatorMetadata(ClassMetadata $metadata)
             {
+                $metadata->addPropertyConstraint('age', new Assert\NotIdenticalTo('Mary'));
+
                 $metadata->addPropertyConstraint('age', new Assert\NotIdenticalTo(array(
                     'value' => 15,
                 )));
diff --git a/reference/constraints/Type.rst b/reference/constraints/Type.rst
index fe0fa7b54b9..586fd849c6b 100644
--- a/reference/constraints/Type.rst
+++ b/reference/constraints/Type.rst
@@ -19,6 +19,9 @@ option to validate this.
 Basic Usage
 -----------
 
+This will check if ``firstName`` is of type ``string`` and that ``age`` is an
+``integer``.
+
 .. configuration-block::
 
     .. code-block:: php-annotations
@@ -31,66 +34,10 @@ Basic Usage
         class Author
         {
             /**
-             * @Assert\Type("integer")
+             * @Assert\Type("string")
              */
-            protected $age;
-        }
-
-    .. code-block:: yaml
-
-        # src/AppBundle/Resources/config/validation.yml
-        AppBundle\Entity\Author:
-            properties:
-                age:
-                    - Type: integer
-
-    .. code-block:: xml
-
-        <!-- src/AppBundle/Resources/config/validation.xml -->
-        <?xml version="1.0" encoding="UTF-8" ?>
-        <constraint-mapping xmlns="http://symfony.com/schema/dic/constraint-mapping"
-            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-            xsi:schemaLocation="http://symfony.com/schema/dic/constraint-mapping http://symfony.com/schema/dic/constraint-mapping/constraint-mapping-1.0.xsd">
-
-            <class name="AppBundle\Entity\Author">
-                <property name="age">
-                    <constraint name="Type">
-                        <type>integer</type>
-                    </constraint>
-                </property>
-            </class>
-        </constraint-mapping>
-
-    .. code-block:: php
-
-        // src/AppBundle/Entity/Author.php
-        namespace AppBundle\Entity;
-
-        use Symfony\Component\Validator\Mapping\ClassMetadata;
-        use Symfony\Component\Validator\Constraints as Assert;
-
-        class Author
-        {
-            public static function loadValidatorMetadata(ClassMetadata $metadata)
-            {
-                $metadata->addPropertyConstraint('age', new Assert\Type('integer');
-            }
-        }
-
-Configure more options
-~~~~~~~~~~~~~~~~~~~~~~
-
-.. configuration-block::
+            protected $firstName;
 
-    .. code-block:: php-annotations
-
-        // src/AppBundle/Entity/Author.php
-        namespace AppBundle\Entity;
-
-        use Symfony\Component\Validator\Constraints as Assert;
-
-        class Author
-        {
             /**
              * @Assert\Type(
              *     type="integer",
@@ -105,6 +52,9 @@ Configure more options
         # src/AppBundle/Resources/config/validation.yml
         AppBundle\Entity\Author:
             properties:
+                firstName:
+                    - Type: string
+
                 age:
                     - Type:
                         type: integer
@@ -119,6 +69,11 @@ Configure more options
             xsi:schemaLocation="http://symfony.com/schema/dic/constraint-mapping http://symfony.com/schema/dic/constraint-mapping/constraint-mapping-1.0.xsd">
 
             <class name="AppBundle\Entity\Author">
+                <property name="firstName">
+                    <constraint name="Type">
+                        <type>string</type>
+                    </constraint>
+                </property>
                 <property name="age">
                     <constraint name="Type">
                         <option name="type">integer</option>
@@ -140,6 +95,8 @@ Configure more options
         {
             public static function loadValidatorMetadata(ClassMetadata $metadata)
             {
+                $metadata->addPropertyConstraint('firstName', new Assert\Type('string'));
+
                 $metadata->addPropertyConstraint('age', new Assert\Type(array(
                     'type'    => 'integer',
                     'message' => 'The value {{ value }} is not a valid {{ type }}.',