diff --git a/CHANGELOG-2.1.md b/CHANGELOG-2.1.md
index 09d82ce62e1e..e29cd3a79a1a 100644
--- a/CHANGELOG-2.1.md
+++ b/CHANGELOG-2.1.md
@@ -300,6 +300,8 @@ To get the diff between two versions, go to https://github.com/symfony/symfony/c
  * changed default value for `extraFieldsMessage` and `missingFieldsMessage`
    in Collection constraint
  * made ExecutionContext immutable
+ * deprecated Constraint methods `setMessage`, `getMessageTemplate` and
+   `getMessageParameters`
 
 ### Yaml
 
diff --git a/UPGRADE-2.1.md b/UPGRADE-2.1.md
index 9b79eb32ae44..dfbfd2f85f3c 100644
--- a/UPGRADE-2.1.md
+++ b/UPGRADE-2.1.md
@@ -141,3 +141,37 @@ UPGRADE FROM 2.0 to 2.1
         $builder->add('tags', 'collection', array('prototype' => '__proto__'));
 
         // results in the name "__proto__" in the template
+
+* The methods `setMessage`, `getMessageTemplate` and `getMessageParameters`
+  in Constraint were deprecated
+
+    If you have implemented custom validators, you should use either of the
+    `addViolation*` methods of the context object instead.
+
+    Before:
+
+        public function isValid($value, Constraint $constraint)
+        {
+            // ...
+            if (!$valid) {
+                $this->setMessage($constraint->message, array(
+                    '{{ value }}' => $value,
+                ));
+
+                return false;
+            }
+        }
+
+    After:
+
+        public function isValid($value, Constraint $constraint)
+        {
+            // ...
+            if (!$valid) {
+                $this->context->addViolation($constraint->message, array(
+                    '{{ value }}' => $value,
+                ));
+
+                return false;
+            }
+        }
\ No newline at end of file
diff --git a/src/Symfony/Bridge/Doctrine/Validator/Constraints/UniqueEntityValidator.php b/src/Symfony/Bridge/Doctrine/Validator/Constraints/UniqueEntityValidator.php
index 2dd19894403c..8eedb4127cb9 100644
--- a/src/Symfony/Bridge/Doctrine/Validator/Constraints/UniqueEntityValidator.php
+++ b/src/Symfony/Bridge/Doctrine/Validator/Constraints/UniqueEntityValidator.php
@@ -102,7 +102,7 @@ public function isValid($entity, Constraint $constraint)
             return true;
         }
 
-        $this->context->addNestedViolationAt($fields[0], $constraint->message, array(), $criteria[$fields[0]]);
+        $this->context->addViolationAtRelativePath($fields[0], $constraint->message, array(), $criteria[$fields[0]]);
 
         return true; // all true, we added the violation already!
     }
diff --git a/src/Symfony/Bundle/SecurityBundle/Validator/Constraint/UserPasswordValidator.php b/src/Symfony/Bundle/SecurityBundle/Validator/Constraint/UserPasswordValidator.php
index 71208ac78976..e817886090e5 100644
--- a/src/Symfony/Bundle/SecurityBundle/Validator/Constraint/UserPasswordValidator.php
+++ b/src/Symfony/Bundle/SecurityBundle/Validator/Constraint/UserPasswordValidator.php
@@ -40,7 +40,7 @@ public function isValid($password, Constraint $constraint)
         $encoder = $this->encoderFactory->getEncoder($user);
 
         if (!$encoder->isPasswordValid($user->getPassword(), $password, $user->getSalt())) {
-            $this->setMessage($constraint->message);
+            $this->context->addViolation($constraint->message);
 
             return false;
         }
diff --git a/src/Symfony/Component/Validator/ConstraintValidator.php b/src/Symfony/Component/Validator/ConstraintValidator.php
index 2abf92f9c146..e7c045dfa85b 100644
--- a/src/Symfony/Component/Validator/ConstraintValidator.php
+++ b/src/Symfony/Component/Validator/ConstraintValidator.php
@@ -24,12 +24,18 @@ abstract class ConstraintValidator implements ConstraintValidatorInterface
      * @var ExecutionContext
      */
     protected $context;
+
     /**
      * @var string
+     *
+     * @deprecated
      */
     private $messageTemplate;
+
     /**
      * @var array
+     *
+     * @deprecated
      */
     private $messageParameters;
 
@@ -46,7 +52,7 @@ public function initialize(ExecutionContext $context)
     /**
      * {@inheritDoc}
      *
-     * @api
+     * @deprecated
      */
     public function getMessageTemplate()
     {
@@ -56,7 +62,7 @@ public function getMessageTemplate()
     /**
      * {@inheritDoc}
      *
-     * @api
+     * @deprecated
      */
     public function getMessageParameters()
     {
@@ -64,11 +70,15 @@ public function getMessageParameters()
     }
 
     /**
-     * @api
+     * Wrapper for $this->context->addViolation()
+     *
+     * @deprecated
      */
     protected function setMessage($template, array $parameters = array())
     {
         $this->messageTemplate = $template;
         $this->messageParameters = $parameters;
+
+        $this->context->addViolation($template, $parameters);
     }
 }
diff --git a/src/Symfony/Component/Validator/ConstraintValidatorInterface.php b/src/Symfony/Component/Validator/ConstraintValidatorInterface.php
index 8ef25ada648f..a813a671593a 100644
--- a/src/Symfony/Component/Validator/ConstraintValidatorInterface.php
+++ b/src/Symfony/Component/Validator/ConstraintValidatorInterface.php
@@ -12,6 +12,8 @@
 namespace Symfony\Component\Validator;
 
 /**
+ * @author Bernhard Schussek <bschussek@gmail.com>
+ *
  * @api
  */
 interface ConstraintValidatorInterface
@@ -34,18 +36,4 @@ function initialize(ExecutionContext $context);
      * @api
      */
     function isValid($value, Constraint $constraint);
-
-    /**
-     * @return string
-     *
-     * @api
-     */
-    function getMessageTemplate();
-
-    /**
-     * @return array
-     *
-     * @api
-     */
-    function getMessageParameters();
 }
diff --git a/src/Symfony/Component/Validator/ConstraintViolation.php b/src/Symfony/Component/Validator/ConstraintViolation.php
index e528b3acaba3..a069dabb1783 100644
--- a/src/Symfony/Component/Validator/ConstraintViolation.php
+++ b/src/Symfony/Component/Validator/ConstraintViolation.php
@@ -33,6 +33,21 @@ public function __construct($messageTemplate, array $messageParameters, $root, $
         $this->invalidValue = $invalidValue;
     }
 
+    /**
+     * @return string
+     */
+    public function __toString()
+    {
+        $class = (string) (is_object($this->root) ? get_class($this->root) : $this->root);
+        $propertyPath = (string) $this->propertyPath;
+
+        if ('' !== $propertyPath && '[' !== $propertyPath[0] && '' !== $class) {
+            $class .= '.';
+        }
+
+        return $class . $propertyPath . ":\n    " . $this->getMessage();
+    }
+
     /**
      * @return string
      *
@@ -62,7 +77,15 @@ public function getMessageParameters()
      */
     public function getMessage()
     {
-        return strtr($this->messageTemplate, $this->messageParameters);
+        $parameters = $this->messageParameters;
+
+        foreach ($parameters as $i => $parameter) {
+            if (is_array($parameter)) {
+                $parameters[$i] = 'Array';
+            }
+        }
+
+        return strtr($this->messageTemplate, $parameters);
     }
 
     public function getRoot()
diff --git a/src/Symfony/Component/Validator/ConstraintViolationList.php b/src/Symfony/Component/Validator/ConstraintViolationList.php
index 96efce4e814b..7bda2003e988 100644
--- a/src/Symfony/Component/Validator/ConstraintViolationList.php
+++ b/src/Symfony/Component/Validator/ConstraintViolationList.php
@@ -47,17 +47,7 @@ public function __toString()
         $string = '';
 
         foreach ($this->violations as $violation) {
-            $root = $violation->getRoot();
-            $class = (string) (is_object($root) ? get_class($root) : $root);
-            $propertyPath = (string) $violation->getPropertyPath();
-            if ('' !== $propertyPath && '[' !== $propertyPath[0] && '' !== $class) {
-                $class .= '.';
-            }
-            $string .= <<<EOF
-{$class}{$propertyPath}:
-    {$violation->getMessage()}
-
-EOF;
+            $string .= $violation . "\n";
         }
 
         return $string;
diff --git a/src/Symfony/Component/Validator/Constraints/BlankValidator.php b/src/Symfony/Component/Validator/Constraints/BlankValidator.php
index 7c08b15a351d..07212eaa65ca 100644
--- a/src/Symfony/Component/Validator/Constraints/BlankValidator.php
+++ b/src/Symfony/Component/Validator/Constraints/BlankValidator.php
@@ -32,7 +32,7 @@ class BlankValidator extends ConstraintValidator
     public function isValid($value, Constraint $constraint)
     {
         if ('' !== $value && null !== $value) {
-            $this->setMessage($constraint->message, array('{{ value }}' => $value));
+            $this->context->addViolation($constraint->message, array('{{ value }}' => $value));
 
             return false;
         }
diff --git a/src/Symfony/Component/Validator/Constraints/CallbackValidator.php b/src/Symfony/Component/Validator/Constraints/CallbackValidator.php
index 34104c0eac3d..c7a9fa286e3c 100644
--- a/src/Symfony/Component/Validator/Constraints/CallbackValidator.php
+++ b/src/Symfony/Component/Validator/Constraints/CallbackValidator.php
@@ -48,6 +48,7 @@ public function isValid($object, Constraint $constraint)
         }
 
         $methods = $constraint->methods;
+        $success = true;
 
         foreach ($methods as $method) {
             if (is_array($method) || $method instanceof \Closure) {
@@ -55,16 +56,16 @@ public function isValid($object, Constraint $constraint)
                     throw new ConstraintDefinitionException(sprintf('"%s::%s" targeted by Callback constraint is not a valid callable', $method[0], $method[1]));
                 }
 
-                call_user_func($method, $object, $this->context);
+                $success = call_user_func($method, $object, $this->context) && $success;
             } else {
                 if (!method_exists($object, $method)) {
                     throw new ConstraintDefinitionException(sprintf('Method "%s" targeted by Callback constraint does not exist', $method));
                 }
 
-                $object->$method($this->context);
+                $success = $object->$method($this->context) && $success;
             }
         }
 
-        return true;
+        return $success;
     }
 }
diff --git a/src/Symfony/Component/Validator/Constraints/ChoiceValidator.php b/src/Symfony/Component/Validator/Constraints/ChoiceValidator.php
index 250fa63ebc8b..c5401eb4fca3 100644
--- a/src/Symfony/Component/Validator/Constraints/ChoiceValidator.php
+++ b/src/Symfony/Component/Validator/Constraints/ChoiceValidator.php
@@ -66,7 +66,7 @@ public function isValid($value, Constraint $constraint)
         if ($constraint->multiple) {
             foreach ($value as $_value) {
                 if (!in_array($_value, $choices, $constraint->strict)) {
-                    $this->setMessage($constraint->multipleMessage, array('{{ value }}' => $_value));
+                    $this->context->addViolation($constraint->multipleMessage, array('{{ value }}' => $_value));
 
                     return false;
                 }
@@ -75,18 +75,18 @@ public function isValid($value, Constraint $constraint)
             $count = count($value);
 
             if ($constraint->min !== null && $count < $constraint->min) {
-                $this->setMessage($constraint->minMessage, array('{{ limit }}' => $constraint->min));
+                $this->context->addViolation($constraint->minMessage, array('{{ limit }}' => $constraint->min));
 
                 return false;
             }
 
             if ($constraint->max !== null && $count > $constraint->max) {
-                $this->setMessage($constraint->maxMessage, array('{{ limit }}' => $constraint->max));
+                $this->context->addViolation($constraint->maxMessage, array('{{ limit }}' => $constraint->max));
 
                 return false;
             }
         } elseif (!in_array($value, $choices, $constraint->strict)) {
-            $this->setMessage($constraint->message, array('{{ value }}' => $value));
+            $this->context->addViolation($constraint->message, array('{{ value }}' => $value));
 
             return false;
         }
diff --git a/src/Symfony/Component/Validator/Constraints/CollectionValidator.php b/src/Symfony/Component/Validator/Constraints/CollectionValidator.php
index c380041ee672..4697d8576158 100644
--- a/src/Symfony/Component/Validator/Constraints/CollectionValidator.php
+++ b/src/Symfony/Component/Validator/Constraints/CollectionValidator.php
@@ -68,8 +68,8 @@ public function isValid($value, Constraint $constraint)
                     $walker->walkConstraint($constr, $value[$field], $group, $propertyPath.'['.$field.']');
                 }
             } elseif (!$fieldConstraint instanceof Optional && !$constraint->allowMissingFields) {
-                $this->context->addNestedViolationAt('['.$field.']', $constraint->missingFieldsMessage, array(
-                    '{{ field }}' => '"'.$field.'"'
+                $this->context->addViolationAtRelativePath('['.$field.']', $constraint->missingFieldsMessage, array(
+                    '{{ field }}' => $field
                 ), null);
                 $valid = false;
             }
@@ -78,8 +78,8 @@ public function isValid($value, Constraint $constraint)
         if (!$constraint->allowExtraFields) {
             foreach ($value as $field => $fieldValue) {
                 if (!isset($constraint->fields[$field])) {
-                    $this->context->addNestedViolationAt('['.$field.']', $constraint->extraFieldsMessage, array(
-                        '{{ field }}' => '"'.$field.'"'
+                    $this->context->addViolationAtRelativePath('['.$field.']', $constraint->extraFieldsMessage, array(
+                        '{{ field }}' => $field
                     ), $fieldValue);
                     $valid = false;
                 }
diff --git a/src/Symfony/Component/Validator/Constraints/CountryValidator.php b/src/Symfony/Component/Validator/Constraints/CountryValidator.php
index ca681a32d440..c6de580500b3 100644
--- a/src/Symfony/Component/Validator/Constraints/CountryValidator.php
+++ b/src/Symfony/Component/Validator/Constraints/CountryValidator.php
@@ -47,7 +47,7 @@ public function isValid($value, Constraint $constraint)
         $value = (string) $value;
 
         if (!in_array($value, \Symfony\Component\Locale\Locale::getCountries())) {
-            $this->setMessage($constraint->message, array('{{ value }}' => $value));
+            $this->context->addViolation($constraint->message, array('{{ value }}' => $value));
 
             return false;
         }
diff --git a/src/Symfony/Component/Validator/Constraints/DateValidator.php b/src/Symfony/Component/Validator/Constraints/DateValidator.php
index 89893bbcda20..db4ef7c822ad 100644
--- a/src/Symfony/Component/Validator/Constraints/DateValidator.php
+++ b/src/Symfony/Component/Validator/Constraints/DateValidator.php
@@ -48,12 +48,12 @@ public function isValid($value, Constraint $constraint)
 
         $value = (string) $value;
 
-        if (!preg_match(static::PATTERN, $value, $matches)) {
-            $this->setMessage($constraint->message, array('{{ value }}' => $value));
+        if (!preg_match(static::PATTERN, $value, $matches) || !checkdate($matches[2], $matches[3], $matches[1])) {
+            $this->context->addViolation($constraint->message, array('{{ value }}' => $value));
 
             return false;
         }
 
-        return checkdate($matches[2], $matches[3], $matches[1]);
+        return true;
     }
 }
diff --git a/src/Symfony/Component/Validator/Constraints/EmailValidator.php b/src/Symfony/Component/Validator/Constraints/EmailValidator.php
index d4e2adcd4807..b26dd5544112 100644
--- a/src/Symfony/Component/Validator/Constraints/EmailValidator.php
+++ b/src/Symfony/Component/Validator/Constraints/EmailValidator.php
@@ -58,7 +58,7 @@ public function isValid($value, Constraint $constraint)
         }
 
         if (!$valid) {
-            $this->setMessage($constraint->message, array('{{ value }}' => $value));
+            $this->context->addViolation($constraint->message, array('{{ value }}' => $value));
 
             return false;
         }
diff --git a/src/Symfony/Component/Validator/Constraints/FalseValidator.php b/src/Symfony/Component/Validator/Constraints/FalseValidator.php
index bcdaf63db464..f473f7a19ad4 100644
--- a/src/Symfony/Component/Validator/Constraints/FalseValidator.php
+++ b/src/Symfony/Component/Validator/Constraints/FalseValidator.php
@@ -39,7 +39,7 @@ public function isValid($value, Constraint $constraint)
             return true;
         }
 
-        $this->setMessage($constraint->message);
+        $this->context->addViolation($constraint->message);
 
         return false;
     }
diff --git a/src/Symfony/Component/Validator/Constraints/FileValidator.php b/src/Symfony/Component/Validator/Constraints/FileValidator.php
index aeccf76837fd..39d93ed493f0 100644
--- a/src/Symfony/Component/Validator/Constraints/FileValidator.php
+++ b/src/Symfony/Component/Validator/Constraints/FileValidator.php
@@ -44,15 +44,15 @@ public function isValid($value, Constraint $constraint)
                 case UPLOAD_ERR_INI_SIZE:
                     $maxSize = UploadedFile::getMaxFilesize();
                     $maxSize = $constraint->maxSize ? min($maxSize, $constraint->maxSize) : $maxSize;
-                    $this->setMessage($constraint->uploadIniSizeErrorMessage, array('{{ limit }}' => $maxSize.' bytes'));
+                    $this->context->addViolation($constraint->uploadIniSizeErrorMessage, array('{{ limit }}' => $maxSize.' bytes'));
 
                     return false;
                 case UPLOAD_ERR_FORM_SIZE:
-                    $this->setMessage($constraint->uploadFormSizeErrorMessage);
+                    $this->context->addViolation($constraint->uploadFormSizeErrorMessage);
 
                     return false;
                 default:
-                    $this->setMessage($constraint->uploadErrorMessage);
+                    $this->context->addViolation($constraint->uploadErrorMessage);
 
                     return false;
             }
@@ -65,13 +65,13 @@ public function isValid($value, Constraint $constraint)
         $path = $value instanceof FileObject ? $value->getPathname() : (string) $value;
 
         if (!is_file($path)) {
-            $this->setMessage($constraint->notFoundMessage, array('{{ file }}' => $path));
+            $this->context->addViolation($constraint->notFoundMessage, array('{{ file }}' => $path));
 
             return false;
         }
 
         if (!is_readable($path)) {
-            $this->setMessage($constraint->notReadableMessage, array('{{ file }}' => $path));
+            $this->context->addViolation($constraint->notReadableMessage, array('{{ file }}' => $path));
 
             return false;
         }
@@ -94,7 +94,7 @@ public function isValid($value, Constraint $constraint)
             }
 
             if ($size > $limit) {
-                $this->setMessage($constraint->maxSizeMessage, array(
+                $this->context->addViolation($constraint->maxSizeMessage, array(
                     '{{ size }}'    => $size.$suffix,
                     '{{ limit }}'   => $limit.$suffix,
                     '{{ file }}'    => $path,
@@ -128,7 +128,7 @@ public function isValid($value, Constraint $constraint)
             }
 
             if (false === $valid) {
-                $this->setMessage($constraint->mimeTypesMessage, array(
+                $this->context->addViolation($constraint->mimeTypesMessage, array(
                     '{{ type }}'    => '"'.$mime.'"',
                     '{{ types }}'   => '"'.implode('", "', $mimeTypes) .'"',
                     '{{ file }}'    => $path,
diff --git a/src/Symfony/Component/Validator/Constraints/ImageValidator.php b/src/Symfony/Component/Validator/Constraints/ImageValidator.php
index d9cbc678a6fc..f91113c0fa31 100644
--- a/src/Symfony/Component/Validator/Constraints/ImageValidator.php
+++ b/src/Symfony/Component/Validator/Constraints/ImageValidator.php
@@ -40,7 +40,7 @@ public function isValid($value, Constraint $constraint)
 
         $size = @getimagesize($value);
         if (empty($size) || ($size[0] === 0) || ($size[1] === 0)) {
-            $this->setMessage($constraint->sizeNotDetectedMessage);
+            $this->context->addViolation($constraint->sizeNotDetectedMessage);
 
             return false;
         }
@@ -54,7 +54,7 @@ public function isValid($value, Constraint $constraint)
             }
 
             if ($width < $constraint->minWidth) {
-                $this->setMessage($constraint->minWidthMessage, array(
+                $this->context->addViolation($constraint->minWidthMessage, array(
                     '{{ width }}'    => $width,
                     '{{ min_width }}' => $constraint->minWidth
                 ));
@@ -69,7 +69,7 @@ public function isValid($value, Constraint $constraint)
             }
 
             if ($width > $constraint->maxWidth) {
-                $this->setMessage($constraint->maxWidthMessage, array(
+                $this->context->addViolation($constraint->maxWidthMessage, array(
                     '{{ width }}'    => $width,
                     '{{ max_width }}' => $constraint->maxWidth
                 ));
@@ -84,7 +84,7 @@ public function isValid($value, Constraint $constraint)
             }
 
             if ($height < $constraint->minHeight) {
-                $this->setMessage($constraint->minHeightMessage, array(
+                $this->context->addViolation($constraint->minHeightMessage, array(
                     '{{ height }}'    => $height,
                     '{{ min_height }}' => $constraint->minHeight
                 ));
@@ -99,7 +99,7 @@ public function isValid($value, Constraint $constraint)
             }
 
             if ($height > $constraint->maxHeight) {
-                $this->setMessage($constraint->maxHeightMessage, array(
+                $this->context->addViolation($constraint->maxHeightMessage, array(
                     '{{ height }}'    => $height,
                     '{{ max_height }}' => $constraint->maxHeight
                 ));
diff --git a/src/Symfony/Component/Validator/Constraints/IpValidator.php b/src/Symfony/Component/Validator/Constraints/IpValidator.php
index 724e5fe5cc99..4bb3fe547a9c 100644
--- a/src/Symfony/Component/Validator/Constraints/IpValidator.php
+++ b/src/Symfony/Component/Validator/Constraints/IpValidator.php
@@ -98,7 +98,7 @@ public function isValid($value, Constraint $constraint)
         }
 
         if (!filter_var($value, FILTER_VALIDATE_IP, $flag)) {
-            $this->setMessage($constraint->message, array('{{ value }}' => $value));
+            $this->context->addViolation($constraint->message, array('{{ value }}' => $value));
 
             return false;
         }
diff --git a/src/Symfony/Component/Validator/Constraints/LanguageValidator.php b/src/Symfony/Component/Validator/Constraints/LanguageValidator.php
index caa5953c89cc..e5ee7ff6c048 100644
--- a/src/Symfony/Component/Validator/Constraints/LanguageValidator.php
+++ b/src/Symfony/Component/Validator/Constraints/LanguageValidator.php
@@ -47,7 +47,7 @@ public function isValid($value, Constraint $constraint)
         $value = (string) $value;
 
         if (!in_array($value, \Symfony\Component\Locale\Locale::getLanguages())) {
-            $this->setMessage($constraint->message, array('{{ value }}' => $value));
+            $this->context->addViolation($constraint->message, array('{{ value }}' => $value));
 
             return false;
         }
diff --git a/src/Symfony/Component/Validator/Constraints/LocaleValidator.php b/src/Symfony/Component/Validator/Constraints/LocaleValidator.php
index c51b80806e78..4ad75447c0a4 100644
--- a/src/Symfony/Component/Validator/Constraints/LocaleValidator.php
+++ b/src/Symfony/Component/Validator/Constraints/LocaleValidator.php
@@ -47,7 +47,7 @@ public function isValid($value, Constraint $constraint)
         $value = (string) $value;
 
         if (!in_array($value, \Symfony\Component\Locale\Locale::getLocales())) {
-            $this->setMessage($constraint->message, array('{{ value }}' => $value));
+            $this->context->addViolation($constraint->message, array('{{ value }}' => $value));
 
             return false;
         }
diff --git a/src/Symfony/Component/Validator/Constraints/MaxLengthValidator.php b/src/Symfony/Component/Validator/Constraints/MaxLengthValidator.php
index c4485642e8eb..48bab5fde220 100644
--- a/src/Symfony/Component/Validator/Constraints/MaxLengthValidator.php
+++ b/src/Symfony/Component/Validator/Constraints/MaxLengthValidator.php
@@ -51,7 +51,7 @@ public function isValid($value, Constraint $constraint)
         }
 
         if ($length > $constraint->limit) {
-            $this->setMessage($constraint->message, array(
+            $this->context->addViolation($constraint->message, array(
                 '{{ value }}' => $value,
                 '{{ limit }}' => $constraint->limit,
             ));
diff --git a/src/Symfony/Component/Validator/Constraints/MaxValidator.php b/src/Symfony/Component/Validator/Constraints/MaxValidator.php
index 521f5dab9593..018f4d0c47d3 100644
--- a/src/Symfony/Component/Validator/Constraints/MaxValidator.php
+++ b/src/Symfony/Component/Validator/Constraints/MaxValidator.php
@@ -36,7 +36,7 @@ public function isValid($value, Constraint $constraint)
         }
 
         if (!is_numeric($value)) {
-            $this->setMessage($constraint->invalidMessage, array(
+            $this->context->addViolation($constraint->invalidMessage, array(
                 '{{ value }}' => $value,
                 '{{ limit }}' => $constraint->limit,
             ));
@@ -45,7 +45,7 @@ public function isValid($value, Constraint $constraint)
         }
 
         if ($value > $constraint->limit) {
-            $this->setMessage($constraint->message, array(
+            $this->context->addViolation($constraint->message, array(
                 '{{ value }}' => $value,
                 '{{ limit }}' => $constraint->limit,
             ));
diff --git a/src/Symfony/Component/Validator/Constraints/MinLengthValidator.php b/src/Symfony/Component/Validator/Constraints/MinLengthValidator.php
index 38bb8e8fbf5a..b148ec794ab3 100644
--- a/src/Symfony/Component/Validator/Constraints/MinLengthValidator.php
+++ b/src/Symfony/Component/Validator/Constraints/MinLengthValidator.php
@@ -51,7 +51,7 @@ public function isValid($value, Constraint $constraint)
         }
 
         if ($length < $constraint->limit) {
-            $this->setMessage($constraint->message, array(
+            $this->context->addViolation($constraint->message, array(
                 '{{ value }}' => $value,
                 '{{ limit }}' => $constraint->limit,
             ));
diff --git a/src/Symfony/Component/Validator/Constraints/MinValidator.php b/src/Symfony/Component/Validator/Constraints/MinValidator.php
index 1106258cf5b5..24e030edbff1 100644
--- a/src/Symfony/Component/Validator/Constraints/MinValidator.php
+++ b/src/Symfony/Component/Validator/Constraints/MinValidator.php
@@ -36,7 +36,7 @@ public function isValid($value, Constraint $constraint)
         }
 
         if (!is_numeric($value)) {
-            $this->setMessage($constraint->invalidMessage, array(
+            $this->context->addViolation($constraint->invalidMessage, array(
                 '{{ value }}' => $value,
                 '{{ limit }}' => $constraint->limit,
             ));
@@ -45,7 +45,7 @@ public function isValid($value, Constraint $constraint)
         }
 
         if ($value < $constraint->limit) {
-            $this->setMessage($constraint->message, array(
+            $this->context->addViolation($constraint->message, array(
                 '{{ value }}' => $value,
                 '{{ limit }}' => $constraint->limit,
             ));
diff --git a/src/Symfony/Component/Validator/Constraints/NotBlankValidator.php b/src/Symfony/Component/Validator/Constraints/NotBlankValidator.php
index d4706c231366..5fe90ce94db4 100644
--- a/src/Symfony/Component/Validator/Constraints/NotBlankValidator.php
+++ b/src/Symfony/Component/Validator/Constraints/NotBlankValidator.php
@@ -32,7 +32,7 @@ class NotBlankValidator extends ConstraintValidator
     public function isValid($value, Constraint $constraint)
     {
         if (false === $value || (empty($value) && '0' != $value)) {
-            $this->setMessage($constraint->message);
+            $this->context->addViolation($constraint->message);
 
             return false;
         }
diff --git a/src/Symfony/Component/Validator/Constraints/NotNullValidator.php b/src/Symfony/Component/Validator/Constraints/NotNullValidator.php
index d781698e7b60..0c8759cefcf6 100644
--- a/src/Symfony/Component/Validator/Constraints/NotNullValidator.php
+++ b/src/Symfony/Component/Validator/Constraints/NotNullValidator.php
@@ -32,7 +32,7 @@ class NotNullValidator extends ConstraintValidator
     public function isValid($value, Constraint $constraint)
     {
         if (null === $value) {
-            $this->setMessage($constraint->message);
+            $this->context->addViolation($constraint->message);
 
             return false;
         }
diff --git a/src/Symfony/Component/Validator/Constraints/NullValidator.php b/src/Symfony/Component/Validator/Constraints/NullValidator.php
index ecd87a8030d6..dc04f9cbabf6 100644
--- a/src/Symfony/Component/Validator/Constraints/NullValidator.php
+++ b/src/Symfony/Component/Validator/Constraints/NullValidator.php
@@ -32,7 +32,7 @@ class NullValidator extends ConstraintValidator
     public function isValid($value, Constraint $constraint)
     {
         if (null !== $value) {
-            $this->setMessage($constraint->message, array('{{ value }}' => $value));
+            $this->context->addViolation($constraint->message, array('{{ value }}' => $value));
 
             return false;
         }
diff --git a/src/Symfony/Component/Validator/Constraints/RegexValidator.php b/src/Symfony/Component/Validator/Constraints/RegexValidator.php
index 30cdbded2ad2..ebf517bf80cc 100644
--- a/src/Symfony/Component/Validator/Constraints/RegexValidator.php
+++ b/src/Symfony/Component/Validator/Constraints/RegexValidator.php
@@ -48,7 +48,7 @@ public function isValid($value, Constraint $constraint)
         $value = (string) $value;
 
         if ($constraint->match xor preg_match($constraint->pattern, $value)) {
-            $this->setMessage($constraint->message, array('{{ value }}' => $value));
+            $this->context->addViolation($constraint->message, array('{{ value }}' => $value));
 
             return false;
         }
diff --git a/src/Symfony/Component/Validator/Constraints/SizeLengthValidator.php b/src/Symfony/Component/Validator/Constraints/SizeLengthValidator.php
index 916914c039de..86de9b4d9e52 100644
--- a/src/Symfony/Component/Validator/Constraints/SizeLengthValidator.php
+++ b/src/Symfony/Component/Validator/Constraints/SizeLengthValidator.php
@@ -51,7 +51,7 @@ public function isValid($value, Constraint $constraint)
         }
 
         if ($constraint->min == $constraint->max && $length != $constraint->max) {
-            $this->setMessage($constraint->exactMessage, array(
+            $this->context->addViolation($constraint->exactMessage, array(
                 '{{ value }}' => $value,
                 '{{ limit }}' => $constraint->max,
             ));
@@ -60,7 +60,7 @@ public function isValid($value, Constraint $constraint)
         }
 
         if ($length > $constraint->max) {
-            $this->setMessage($constraint->maxMessage, array(
+            $this->context->addViolation($constraint->maxMessage, array(
                 '{{ value }}' => $value,
                 '{{ limit }}' => $constraint->max,
             ));
@@ -69,7 +69,7 @@ public function isValid($value, Constraint $constraint)
         }
 
         if ($length < $constraint->min) {
-            $this->setMessage($constraint->minMessage, array(
+            $this->context->addViolation($constraint->minMessage, array(
                 '{{ value }}' => $value,
                 '{{ limit }}' => $constraint->min,
             ));
diff --git a/src/Symfony/Component/Validator/Constraints/SizeValidator.php b/src/Symfony/Component/Validator/Constraints/SizeValidator.php
index 51fa5fb96205..db8bc65c6827 100644
--- a/src/Symfony/Component/Validator/Constraints/SizeValidator.php
+++ b/src/Symfony/Component/Validator/Constraints/SizeValidator.php
@@ -36,7 +36,7 @@ public function isValid($value, Constraint $constraint)
         }
 
         if (!is_numeric($value)) {
-            $this->setMessage($constraint->invalidMessage, array(
+            $this->context->addViolation($constraint->invalidMessage, array(
                 '{{ value }}' => $value,
             ));
 
@@ -44,7 +44,7 @@ public function isValid($value, Constraint $constraint)
         }
 
         if ($value > $constraint->max) {
-            $this->setMessage($constraint->maxMessage, array(
+            $this->context->addViolation($constraint->maxMessage, array(
                 '{{ value }}' => $value,
                 '{{ limit }}' => $constraint->max,
             ));
@@ -53,7 +53,7 @@ public function isValid($value, Constraint $constraint)
         }
 
         if ($value < $constraint->min) {
-            $this->setMessage($constraint->minMessage, array(
+            $this->context->addViolation($constraint->minMessage, array(
                 '{{ value }}' => $value,
                 '{{ limit }}' => $constraint->min,
             ));
diff --git a/src/Symfony/Component/Validator/Constraints/TimeValidator.php b/src/Symfony/Component/Validator/Constraints/TimeValidator.php
index 4b117b5bd3d7..6c4b8d538c87 100644
--- a/src/Symfony/Component/Validator/Constraints/TimeValidator.php
+++ b/src/Symfony/Component/Validator/Constraints/TimeValidator.php
@@ -49,7 +49,7 @@ public function isValid($value, Constraint $constraint)
         $value = (string) $value;
 
         if (!preg_match(static::PATTERN, $value)) {
-            $this->setMessage($constraint->message, array('{{ value }}' => $value));
+            $this->context->addViolation($constraint->message, array('{{ value }}' => $value));
 
             return false;
         }
diff --git a/src/Symfony/Component/Validator/Constraints/TrueValidator.php b/src/Symfony/Component/Validator/Constraints/TrueValidator.php
index 04dcbef8f23d..fe58c72eb571 100644
--- a/src/Symfony/Component/Validator/Constraints/TrueValidator.php
+++ b/src/Symfony/Component/Validator/Constraints/TrueValidator.php
@@ -39,7 +39,7 @@ public function isValid($value, Constraint $constraint)
             return true;
         }
 
-        $this->setMessage($constraint->message);
+        $this->context->addViolation($constraint->message);
 
         return false;
     }
diff --git a/src/Symfony/Component/Validator/Constraints/TypeValidator.php b/src/Symfony/Component/Validator/Constraints/TypeValidator.php
index 84382dd4677b..71bbed80bd67 100644
--- a/src/Symfony/Component/Validator/Constraints/TypeValidator.php
+++ b/src/Symfony/Component/Validator/Constraints/TypeValidator.php
@@ -48,8 +48,8 @@ public function isValid($value, Constraint $constraint)
             return true;
         }
 
-        $this->setMessage($constraint->message, array(
-            '{{ value }}' => is_object($value) ? get_class($value) : is_array($value) ? 'Array' : (string) $value,
+        $this->context->addViolation($constraint->message, array(
+            '{{ value }}' => is_object($value) ? get_class($value) : (is_array($value) ? 'Array' : (string) $value),
             '{{ type }}'  => $constraint->type,
         ));
 
diff --git a/src/Symfony/Component/Validator/Constraints/UrlValidator.php b/src/Symfony/Component/Validator/Constraints/UrlValidator.php
index 30021f945af1..0514ce661db1 100644
--- a/src/Symfony/Component/Validator/Constraints/UrlValidator.php
+++ b/src/Symfony/Component/Validator/Constraints/UrlValidator.php
@@ -60,7 +60,7 @@ public function isValid($value, Constraint $constraint)
         $pattern = sprintf(static::PATTERN, implode('|', $constraint->protocols));
 
         if (!preg_match($pattern, $value)) {
-            $this->setMessage($constraint->message, array('{{ value }}' => $value));
+            $this->context->addViolation($constraint->message, array('{{ value }}' => $value));
 
             return false;
         }
diff --git a/src/Symfony/Component/Validator/ExecutionContext.php b/src/Symfony/Component/Validator/ExecutionContext.php
index 1118d9d90a6b..300f3b1c6f8b 100644
--- a/src/Symfony/Component/Validator/ExecutionContext.php
+++ b/src/Symfony/Component/Validator/ExecutionContext.php
@@ -80,7 +80,7 @@ public function addViolation($message, array $params = array(), $invalidValue =
      * @param array $params The parameters parsed into the error message.
      * @param mixed $invalidValue The invalid, validated value.
      */
-    public function addViolationAt($propertyPath, $message, array $params = array(), $invalidValue = null)
+    public function addViolationAtPath($propertyPath, $message, array $params = array(), $invalidValue = null)
     {
         $this->globalContext->addViolation(new ConstraintViolation(
             $message,
@@ -93,27 +93,21 @@ public function addViolationAt($propertyPath, $message, array $params = array(),
     }
 
     /**
-     * Adds a violation at the child of the current validation graph node with
-     * the given property path.
+     * Adds a violation at the validation graph node with the given property
+     * path relative to the current property path.
      *
-     * @param string $childPropertyPath The property path of the child node.
+     * @param string $relativePath The relative property path for the violation.
      * @param string $message The error message.
      * @param array $params The parameters parsed into the error message.
      * @param mixed $invalidValue The invalid, validated value.
      */
-    public function addNestedViolationAt($childPropertyPath, $message, array $params = array(), $invalidValue = null)
+    public function addViolationAtRelativePath($relativePath, $message, array $params = array(), $invalidValue = null)
     {
-        $propertyPath = $this->propertyPath;
-
-        if ('' !== $propertyPath && '' !== $childPropertyPath && '[' !== $childPropertyPath[0]) {
-            $propertyPath .= '.';
-        }
-
         $this->globalContext->addViolation(new ConstraintViolation(
             $message,
             $params,
             $this->globalContext->getRoot(),
-            $propertyPath . $childPropertyPath,
+            $this->getAbsolutePropertyPath($relativePath),
             // check using func_num_args() to allow passing null values
             func_num_args() === 4 ? $invalidValue : $this->value
         ));
@@ -139,6 +133,15 @@ public function getPropertyPath()
         return $this->propertyPath;
     }
 
+    public function getAbsolutePropertyPath($relativePath)
+    {
+        if ('' !== $this->propertyPath && '' !== $relativePath && '[' !== $relativePath[0]) {
+            return $this->propertyPath . '.' . $relativePath;
+        }
+
+        return $this->propertyPath . $relativePath;
+    }
+
     public function getCurrentClass()
     {
         return $this->class;
diff --git a/src/Symfony/Component/Validator/GraphWalker.php b/src/Symfony/Component/Validator/GraphWalker.php
index da6e5a0aea7a..dbdcfdb70e91 100644
--- a/src/Symfony/Component/Validator/GraphWalker.php
+++ b/src/Symfony/Component/Validator/GraphWalker.php
@@ -178,17 +178,6 @@ public function walkConstraint(Constraint $constraint, $value, $group, $property
         );
 
         $validator->initialize($localContext);
-
-        if (!$validator->isValid($value, $constraint)) {
-            $messageTemplate = $validator->getMessageTemplate();
-            $messageParams = $validator->getMessageParameters();
-
-            // Somewhat ugly hack: Don't add a violation if no message is set.
-            // This is required if the validator added its violations directly
-            // to the globalContext already
-            if (!empty($messageTemplate)) {
-                $localContext->addViolation($messageTemplate, $messageParams);
-            }
-        }
+        $validator->isValid($value, $constraint);
     }
 }
diff --git a/tests/Symfony/Tests/Component/Validator/ConstraintViolationTest.php b/tests/Symfony/Tests/Component/Validator/ConstraintViolationTest.php
new file mode 100644
index 000000000000..39843f18cd87
--- /dev/null
+++ b/tests/Symfony/Tests/Component/Validator/ConstraintViolationTest.php
@@ -0,0 +1,35 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Tests\Component\Validator;
+
+use Symfony\Component\Validator\ConstraintViolation;
+
+class ConstraintViolationTest extends \PHPUnit_Framework_TestCase
+{
+    public function testToStringHandlesArrays()
+    {
+        $violation = new ConstraintViolation(
+            '{{ value }}',
+            array('{{ value }}' => array(1, 2, 3)),
+            'Root',
+            'property.path',
+            null
+        );
+
+        $expected = <<<EOF
+Root.property.path:
+    Array
+EOF;
+
+        $this->assertSame($expected, (string) $violation);
+    }
+}
diff --git a/tests/Symfony/Tests/Component/Validator/Constraints/AllValidatorTest.php b/tests/Symfony/Tests/Component/Validator/Constraints/AllValidatorTest.php
index 0649833574c1..60f3d3cecb4e 100644
--- a/tests/Symfony/Tests/Component/Validator/Constraints/AllValidatorTest.php
+++ b/tests/Symfony/Tests/Component/Validator/Constraints/AllValidatorTest.php
@@ -15,25 +15,32 @@
 
 use Symfony\Component\Validator\ExecutionContext;
 use Symfony\Component\Validator\Constraints\Min;
+use Symfony\Component\Validator\Constraints\Max;
 use Symfony\Component\Validator\Constraints\All;
 use Symfony\Component\Validator\Constraints\AllValidator;
 
 class AllValidatorTest extends \PHPUnit_Framework_TestCase
 {
-    protected $validator;
     protected $walker;
     protected $context;
+    protected $validator;
 
     protected function setUp()
     {
         $this->walker = $this->getMock('Symfony\Component\Validator\GraphWalker', array(), array(), '', false);
-        $metadataFactory = $this->getMock('Symfony\Component\Validator\Mapping\ClassMetadataFactoryInterface');
-        $globalContext = new GlobalExecutionContext('Root', $this->walker, $metadataFactory);
-
-        $this->context = new ExecutionContext($globalContext, null, 'foo', 'MyGroup', null, null);
-
+        $this->context = $this->getMock('Symfony\Component\Validator\ExecutionContext', array(), array(), '', false);
         $this->validator = new AllValidator();
         $this->validator->initialize($this->context);
+
+        $this->context->expects($this->any())
+            ->method('getGraphWalker')
+            ->will($this->returnValue($this->walker));
+        $this->context->expects($this->any())
+            ->method('getGroup')
+            ->will($this->returnValue('MyGroup'));
+        $this->context->expects($this->any())
+            ->method('getPropertyPath')
+            ->will($this->returnValue('foo.bar'));
     }
 
     protected function tearDown()
@@ -48,11 +55,13 @@ public function testNullIsValid()
         $this->assertTrue($this->validator->isValid(null, new All(new Min(4))));
     }
 
+
+    /**
+     * @expectedException Symfony\Component\Validator\Exception\UnexpectedTypeException
+     */
     public function testThrowsExceptionIfNotTraversable()
     {
-        $this->setExpectedException('Symfony\Component\Validator\Exception\UnexpectedTypeException');
-
-        $this->validator->isValid('foobar', new All(new Min(4)));
+        $this->validator->isValid('foo.barbar', new All(new Min(4)));
     }
 
     /**
@@ -62,12 +71,17 @@ public function testWalkSingleConstraint($array)
     {
         $constraint = new Min(4);
 
+        $i = 0;
+
         foreach ($array as $key => $value) {
-            $this->walker->expects($this->once())
-                                     ->method('walkConstraint')
-                                     ->with($this->equalTo($constraint), $this->equalTo($value), $this->equalTo('MyGroup'), $this->equalTo('foo['.$key.']'));
+            $this->walker->expects($this->at($i++))
+                ->method('walkConstraint')
+                ->with($constraint, $value, 'MyGroup', 'foo.bar['.$key.']');
         }
 
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid($array, new All($constraint)));
     }
 
@@ -76,27 +90,32 @@ public function testWalkSingleConstraint($array)
      */
     public function testWalkMultipleConstraints($array)
     {
-        $constraint = new Min(4);
-        // can only test for twice the same constraint because PHPUnits mocking
-        // can't test method calls with different arguments
-        $constraints = array($constraint, $constraint);
+        $constraint1 = new Min(4);
+        $constraint2 = new Max(6);
+
+        $constraints = array($constraint1, $constraint2);
+        $i = 0;
 
         foreach ($array as $key => $value) {
-            $this->walker->expects($this->exactly(2))
-                                     ->method('walkConstraint')
-                                     ->with($this->equalTo($constraint), $this->equalTo($value), $this->equalTo('MyGroup'), $this->equalTo('foo['.$key.']'));
+            $this->walker->expects($this->at($i++))
+                ->method('walkConstraint')
+                ->with($constraint1, $value, 'MyGroup', 'foo.bar['.$key.']');
+            $this->walker->expects($this->at($i++))
+                ->method('walkConstraint')
+                ->with($constraint2, $value, 'MyGroup', 'foo.bar['.$key.']');
         }
 
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid($array, new All($constraints)));
     }
 
     public function getValidArguments()
     {
         return array(
-            // can only test for one entry, because PHPUnits mocking does not allow
-            // to expect multiple method calls with different arguments
-            array(array(1)),
-            array(new \ArrayObject(array(1))),
+            array(array(5, 6, 7)),
+            array(new \ArrayObject(array(5, 6, 7))),
         );
     }
 }
diff --git a/tests/Symfony/Tests/Component/Validator/Constraints/BlankValidatorTest.php b/tests/Symfony/Tests/Component/Validator/Constraints/BlankValidatorTest.php
index b026a71d6144..bca2cad69c1c 100644
--- a/tests/Symfony/Tests/Component/Validator/Constraints/BlankValidatorTest.php
+++ b/tests/Symfony/Tests/Component/Validator/Constraints/BlankValidatorTest.php
@@ -16,34 +16,54 @@
 
 class BlankValidatorTest extends \PHPUnit_Framework_TestCase
 {
+    protected $context;
     protected $validator;
 
     protected function setUp()
     {
+        $this->context = $this->getMock('Symfony\Component\Validator\ExecutionContext', array(), array(), '', false);
         $this->validator = new BlankValidator();
+        $this->validator->initialize($this->context);
     }
 
     protected function tearDown()
     {
+        $this->context = null;
         $this->validator = null;
     }
 
     public function testNullIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid(null, new Blank()));
     }
 
     public function testBlankIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid('', new Blank()));
     }
 
     /**
      * @dataProvider getInvalidValues
      */
-    public function testInvalidValues($date)
+    public function testInvalidValues($value)
     {
-        $this->assertFalse($this->validator->isValid($date, new Blank()));
+        $constraint = new Blank(array(
+            'message' => 'myMessage'
+        ));
+
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ value }}' => $value,
+            ));
+
+        $this->assertFalse($this->validator->isValid($value, $constraint));
     }
 
     public function getInvalidValues()
@@ -55,17 +75,4 @@ public function getInvalidValues()
             array(1234),
         );
     }
-
-    public function testMessageIsSet()
-    {
-        $constraint = new Blank(array(
-            'message' => 'myMessage'
-        ));
-
-        $this->assertFalse($this->validator->isValid('foobar', $constraint));
-        $this->assertEquals($this->validator->getMessageTemplate(), 'myMessage');
-        $this->assertEquals($this->validator->getMessageParameters(), array(
-            '{{ value }}' => 'foobar',
-        ));
-    }
 }
diff --git a/tests/Symfony/Tests/Component/Validator/Constraints/CallbackValidatorTest.php b/tests/Symfony/Tests/Component/Validator/Constraints/CallbackValidatorTest.php
index d8822e5dc57e..a250325b9370 100644
--- a/tests/Symfony/Tests/Component/Validator/Constraints/CallbackValidatorTest.php
+++ b/tests/Symfony/Tests/Component/Validator/Constraints/CallbackValidatorTest.php
@@ -22,7 +22,9 @@ class CallbackValidatorTest_Class
 {
     public static function validateStatic($object, ExecutionContext $context)
     {
-        $context->addViolation('Static message', array('parameter'), 'invalidValue');
+        $context->addViolation('Static message', array('{{ value }}' => 'foobar'), 'invalidValue');
+
+        return false;
     }
 }
 
@@ -30,107 +32,93 @@ class CallbackValidatorTest_Object
 {
     public function validateOne(ExecutionContext $context)
     {
-        $context->addViolation('My message', array('parameter'), 'invalidValue');
+        $context->addViolation('My message', array('{{ value }}' => 'foobar'), 'invalidValue');
+
+        return false;
     }
 
     public function validateTwo(ExecutionContext $context)
     {
-        $context->addViolation('Other message', array('other parameter'), 'otherInvalidValue');
+        $context->addViolation('Other message', array('{{ value }}' => 'baz'), 'otherInvalidValue');
+
+        return false;
     }
 }
 
 class CallbackValidatorTest extends \PHPUnit_Framework_TestCase
 {
-    protected $validator;
-    protected $walker;
     protected $context;
+    protected $validator;
 
     protected function setUp()
     {
-        $this->walker = $this->getMock('Symfony\Component\Validator\GraphWalker', array(), array(), '', false);
-        $metadataFactory = $this->getMock('Symfony\Component\Validator\Mapping\ClassMetadataFactoryInterface');
-        $globalContext = new GlobalExecutionContext('Root', $this->walker, $metadataFactory);
-
-        $this->context = new ExecutionContext($globalContext, 'value', 'foo.bar', 'Group', 'ClassName', 'propertyName');
+        $this->context = $this->getMock('Symfony\Component\Validator\ExecutionContext', array(), array(), '', false);
         $this->validator = new CallbackValidator();
         $this->validator->initialize($this->context);
     }
 
     protected function tearDown()
     {
-        $this->validator = null;
-        $this->walker = null;
         $this->context = null;
+        $this->validator = null;
     }
 
     public function testNullIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid(null, new Callback(array('foo'))));
     }
 
     public function testCallbackSingleMethod()
     {
         $object = new CallbackValidatorTest_Object();
+        $constraint = new Callback(array('validateOne'));
 
-        $this->assertTrue($this->validator->isValid($object, new Callback(array('validateOne'))));
-
-        $violations = new ConstraintViolationList();
-        $violations->add(new ConstraintViolation(
-            'My message',
-            array('parameter'),
-            'Root',
-            'foo.bar',
-            'invalidValue'
-        ));
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('My message', array(
+                '{{ value }}' => 'foobar',
+            ));
 
-        $this->assertEquals($violations, $this->context->getViolations());
+        $this->assertFalse($this->validator->isValid($object, $constraint));
     }
 
     public function testCallbackSingleStaticMethod()
     {
         $object = new CallbackValidatorTest_Object();
 
-        $this->assertTrue($this->validator->isValid($object, new Callback(array(
-            array(__NAMESPACE__.'\CallbackValidatorTest_Class', 'validateStatic')
-        ))));
-
-        $violations = new ConstraintViolationList();
-        $violations->add(new ConstraintViolation(
-            'Static message',
-            array('parameter'),
-            'Root',
-            'foo.bar',
-            'invalidValue'
-        ));
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('Static message', array(
+                '{{ value }}' => 'foobar',
+            ));
 
-        $this->assertEquals($violations, $this->context->getViolations());
+        $this->assertFalse($this->validator->isValid($object, new Callback(array(
+            array(__CLASS__.'_Class', 'validateStatic')
+        ))));
     }
 
     public function testCallbackMultipleMethods()
     {
         $object = new CallbackValidatorTest_Object();
 
-        $this->assertTrue($this->validator->isValid($object, new Callback(array(
+        $this->context->expects($this->at(0))
+            ->method('addViolation')
+            ->with('My message', array(
+                '{{ value }}' => 'foobar',
+            ));
+        $this->context->expects($this->at(1))
+            ->method('addViolation')
+            ->with('Other message', array(
+                '{{ value }}' => 'baz',
+            ));
+
+
+        $this->assertFalse($this->validator->isValid($object, new Callback(array(
             'validateOne', 'validateTwo'
         ))));
-
-        $violations = new ConstraintViolationList();
-        $violations->add(new ConstraintViolation(
-            'My message',
-            array('parameter'),
-            'Root',
-            'foo.bar',
-            'invalidValue'
-        ));
-        $violations->add(new ConstraintViolation(
-            'Other message',
-            array('other parameter'),
-            'Root',
-            'foo.bar',
-            'otherInvalidValue'
-        ));
-
-        $this->assertEquals($violations, $this->context->getViolations());
     }
 
     /**
diff --git a/tests/Symfony/Tests/Component/Validator/Constraints/ChoiceValidatorTest.php b/tests/Symfony/Tests/Component/Validator/Constraints/ChoiceValidatorTest.php
index 54fc6305ef25..9f4bb3e636fa 100644
--- a/tests/Symfony/Tests/Component/Validator/Constraints/ChoiceValidatorTest.php
+++ b/tests/Symfony/Tests/Component/Validator/Constraints/ChoiceValidatorTest.php
@@ -24,6 +24,7 @@ function choice_callback()
 
 class ChoiceValidatorTest extends \PHPUnit_Framework_TestCase
 {
+    protected $context;
     protected $validator;
 
     public static function staticCallback()
@@ -33,19 +34,24 @@ public static function staticCallback()
 
     protected function setUp()
     {
-        $walker = $this->getMock('Symfony\Component\Validator\GraphWalker', array(), array(), '', false);
-        $factory = $this->getMock('Symfony\Component\Validator\Mapping\ClassMetadataFactoryInterface');
-        $globalContext = new GlobalExecutionContext('root', $walker, $factory);
-        $context = new ExecutionContext($globalContext, null, null, null, __CLASS__, null);
+        $this->context = $this->getMock('Symfony\Component\Validator\ExecutionContext', array(), array(), '', false);
         $this->validator = new ChoiceValidator();
-        $this->validator->initialize($context);
+        $this->validator->initialize($this->context);
+
+        $this->context->expects($this->any())
+            ->method('getCurrentClass')
+            ->will($this->returnValue(__CLASS__));
     }
 
     protected function tearDown()
     {
+        $this->context = null;
         $this->validator = null;
     }
 
+    /**
+     * @expectedException Symfony\Component\Validator\Exception\UnexpectedTypeException
+     */
     public function testExpectArrayIfMultipleIsTrue()
     {
         $constraint = new Choice(array(
@@ -53,27 +59,30 @@ public function testExpectArrayIfMultipleIsTrue()
             'multiple' => true,
         ));
 
-        $this->setExpectedException('Symfony\Component\Validator\Exception\UnexpectedTypeException');
-
         $this->validator->isValid('asdf', $constraint);
     }
 
     public function testNullIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid(null, new Choice(array('choices' => array('foo', 'bar')))));
     }
 
+    /**
+     * @expectedException Symfony\Component\Validator\Exception\ConstraintDefinitionException
+     */
     public function testChoicesOrCallbackExpected()
     {
-        $this->setExpectedException('Symfony\Component\Validator\Exception\ConstraintDefinitionException');
-
         $this->validator->isValid('foobar', new Choice());
     }
 
+    /**
+     * @expectedException Symfony\Component\Validator\Exception\ConstraintDefinitionException
+     */
     public function testValidCallbackExpected()
     {
-        $this->setExpectedException('Symfony\Component\Validator\Exception\ConstraintDefinitionException');
-
         $this->validator->isValid('foobar', new Choice(array('callback' => 'abcd')));
     }
 
@@ -81,6 +90,9 @@ public function testValidChoiceArray()
     {
         $constraint = new Choice(array('choices' => array('foo', 'bar')));
 
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid('bar', $constraint));
     }
 
@@ -88,6 +100,9 @@ public function testValidChoiceCallbackFunction()
     {
         $constraint = new Choice(array('callback' => __NAMESPACE__.'\choice_callback'));
 
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid('bar', $constraint));
     }
 
@@ -97,6 +112,9 @@ public function testValidChoiceCallbackClosure()
             return array('foo', 'bar');
         }));
 
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid('bar', $constraint));
     }
 
@@ -104,6 +122,9 @@ public function testValidChoiceCallbackStaticMethod()
     {
         $constraint = new Choice(array('callback' => array(__CLASS__, 'staticCallback')));
 
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid('bar', $constraint));
     }
 
@@ -111,6 +132,9 @@ public function testValidChoiceCallbackContextMethod()
     {
         $constraint = new Choice(array('callback' => 'staticCallback'));
 
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid('bar', $constraint));
     }
 
@@ -121,6 +145,9 @@ public function testMultipleChoices()
             'multiple' => true,
         ));
 
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid(array('baz', 'bar'), $constraint));
     }
 
@@ -131,11 +158,13 @@ public function testInvalidChoice()
             'message' => 'myMessage',
         ));
 
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ value }}' => 'baz',
+            ));
+
         $this->assertFalse($this->validator->isValid('baz', $constraint));
-        $this->assertEquals($this->validator->getMessageTemplate(), 'myMessage');
-        $this->assertEquals($this->validator->getMessageParameters(), array(
-            '{{ value }}' => 'baz',
-        ));
     }
 
     public function testInvalidChoiceMultiple()
@@ -146,11 +175,13 @@ public function testInvalidChoiceMultiple()
             'multiple' => true,
         ));
 
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ value }}' => 'baz',
+            ));
+
         $this->assertFalse($this->validator->isValid(array('foo', 'baz'), $constraint));
-        $this->assertEquals($this->validator->getMessageTemplate(), 'myMessage');
-        $this->assertEquals($this->validator->getMessageParameters(), array(
-            '{{ value }}' => 'baz',
-        ));
     }
 
     public function testTooFewChoices()
@@ -162,11 +193,13 @@ public function testTooFewChoices()
             'minMessage' => 'myMessage',
         ));
 
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ limit }}' => 2,
+            ));
+
         $this->assertFalse($this->validator->isValid(array('foo'), $constraint));
-        $this->assertEquals($this->validator->getMessageTemplate(), 'myMessage');
-        $this->assertEquals($this->validator->getMessageParameters(), array(
-            '{{ limit }}' => 2,
-        ));
     }
 
     public function testTooManyChoices()
@@ -178,36 +211,60 @@ public function testTooManyChoices()
             'maxMessage' => 'myMessage',
         ));
 
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ limit }}' => 2,
+            ));
+
         $this->assertFalse($this->validator->isValid(array('foo', 'bar', 'moo'), $constraint));
-        $this->assertEquals($this->validator->getMessageTemplate(), 'myMessage');
-        $this->assertEquals($this->validator->getMessageParameters(), array(
-            '{{ limit }}' => 2,
-        ));
     }
 
-    public function testStrictIsFalse()
+    public function testNonStrict()
     {
         $constraint = new Choice(array(
             'choices' => array(1, 2),
             'strict' => false,
         ));
 
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid('2', $constraint));
         $this->assertTrue($this->validator->isValid(2, $constraint));
     }
 
-    public function testStrictIsTrue()
+    public function testStrictAllowsExactValue()
     {
         $constraint = new Choice(array(
             'choices' => array(1, 2),
             'strict' => true,
         ));
 
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid(2, $constraint));
+    }
+
+    public function testStrictDisallowsDifferentType()
+    {
+        $constraint = new Choice(array(
+            'choices' => array(1, 2),
+            'strict' => true,
+            'message' => 'myMessage'
+        ));
+
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ value }}' => '2',
+            ));
+
         $this->assertFalse($this->validator->isValid('2', $constraint));
     }
 
-    public function testStrictIsFalseWhenMultipleChoices()
+    public function testNonStrictWithMultipleChoices()
     {
         $constraint = new Choice(array(
             'choices' => array(1, 2, 3),
@@ -215,17 +272,27 @@ public function testStrictIsFalseWhenMultipleChoices()
             'strict' => false
         ));
 
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid(array('2', 3), $constraint));
     }
 
-    public function testStrictIsTrueWhenMultipleChoices()
+    public function testStrictWithMultipleChoices()
     {
         $constraint = new Choice(array(
             'choices' => array(1, 2, 3),
             'multiple' => true,
-            'strict' => true
+            'strict' => true,
+            'multipleMessage' => 'myMessage',
         ));
 
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ value }}' => '3',
+            ));
+
         $this->assertFalse($this->validator->isValid(array(2, '3'), $constraint));
     }
 }
diff --git a/tests/Symfony/Tests/Component/Validator/Constraints/CollectionValidatorTest.php b/tests/Symfony/Tests/Component/Validator/Constraints/CollectionValidatorTest.php
index d52b0242a24f..b86ee08e41db 100644
--- a/tests/Symfony/Tests/Component/Validator/Constraints/CollectionValidatorTest.php
+++ b/tests/Symfony/Tests/Component/Validator/Constraints/CollectionValidatorTest.php
@@ -25,35 +25,42 @@
 
 abstract class CollectionValidatorTest extends \PHPUnit_Framework_TestCase
 {
-    protected $validator;
     protected $walker;
-    protected $globalContext;
     protected $context;
+    protected $validator;
 
     protected function setUp()
     {
         $this->walker = $this->getMock('Symfony\Component\Validator\GraphWalker', array(), array(), '', false);
-        $metadataFactory = $this->getMock('Symfony\Component\Validator\Mapping\ClassMetadataFactoryInterface');
-
-        $this->globalContext = new GlobalExecutionContext('Root', $this->walker, $metadataFactory);
-        $this->context = new ExecutionContext($this->globalContext, 'value', 'bar', 'MyGroup', 'ClassName', 'propertyName');
-
+        $this->context = $this->getMock('Symfony\Component\Validator\ExecutionContext', array(), array(), '', false);
         $this->validator = new CollectionValidator();
         $this->validator->initialize($this->context);
+
+        $this->context->expects($this->any())
+            ->method('getGraphWalker')
+            ->will($this->returnValue($this->walker));
+        $this->context->expects($this->any())
+            ->method('getGroup')
+            ->will($this->returnValue('MyGroup'));
+        $this->context->expects($this->any())
+            ->method('getPropertyPath')
+            ->will($this->returnValue('foo.bar'));
     }
 
     protected function tearDown()
     {
-        $this->validator = null;
         $this->walker = null;
-        $this->globalContext = null;
         $this->context = null;
+        $this->validator = null;
     }
 
     abstract protected function prepareTestData(array $contents);
 
     public function testNullIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolationAtRelativePath');
+
         $this->assertTrue($this->validator->isValid(null, new Collection(array('fields' => array(
             'foo' => new Min(4),
         )))));
@@ -63,6 +70,9 @@ public function testFieldsAsDefaultOption()
     {
         $data = $this->prepareTestData(array('foo' => 'foobar'));
 
+        $this->context->expects($this->never())
+            ->method('addViolationAtRelativePath');
+
         $this->assertTrue($this->validator->isValid($data, new Collection(array(
             'foo' => new Min(4),
         ))));
@@ -82,19 +92,27 @@ public function testWalkSingleConstraint()
     {
         $constraint = new Min(4);
 
-        $array = array('foo' => 3);
+        $array = array(
+            'foo' => 3,
+            'bar' => 5,
+        );
+        $i = 0;
 
         foreach ($array as $key => $value) {
-            $this->walker->expects($this->once())
+            $this->walker->expects($this->at($i++))
                 ->method('walkConstraint')
-                ->with($this->equalTo($constraint), $this->equalTo($value), $this->equalTo('MyGroup'), $this->equalTo('bar['.$key.']'));
+                ->with($constraint, $value, 'MyGroup', 'foo.bar['.$key.']');
         }
 
         $data = $this->prepareTestData($array);
 
+        $this->context->expects($this->never())
+            ->method('addViolationAtRelativePath');
+
         $this->assertTrue($this->validator->isValid($data, new Collection(array(
             'fields' => array(
                 'foo' => $constraint,
+                'bar' => $constraint,
             ),
         ))));
     }
@@ -105,21 +123,30 @@ public function testWalkMultipleConstraints()
             new Min(4),
             new NotNull(),
         );
-        $array = array('foo' => 3);
+
+        $array = array(
+            'foo' => 3,
+            'bar' => 5,
+        );
+        $i = 0;
 
         foreach ($array as $key => $value) {
-            foreach ($constraints as $i => $constraint) {
-                $this->walker->expects($this->at($i))
+            foreach ($constraints as $constraint) {
+                $this->walker->expects($this->at($i++))
                     ->method('walkConstraint')
-                    ->with($this->equalTo($constraint), $this->equalTo($value), $this->equalTo('MyGroup'), $this->equalTo('bar['.$key.']'));
+                    ->with($constraint, $value, 'MyGroup', 'foo.bar['.$key.']');
             }
         }
 
         $data = $this->prepareTestData($array);
 
+        $this->context->expects($this->never())
+            ->method('addViolationAtRelativePath');
+
         $this->assertTrue($this->validator->isValid($data, new Collection(array(
             'fields' => array(
                 'foo' => $constraints,
+                'bar' => $constraints,
             )
         ))));
     }
@@ -131,21 +158,18 @@ public function testExtraFieldsDisallowed()
             'baz' => 6,
         ));
 
+        $this->context->expects($this->once())
+            ->method('addViolationAtRelativePath')
+            ->with('[baz]', 'myMessage', array(
+                '{{ field }}' => 'baz'
+            ));
+
         $this->assertFalse($this->validator->isValid($data, new Collection(array(
             'fields' => array(
                 'foo' => new Min(4),
             ),
+            'extraFieldsMessage' => 'myMessage',
         ))));
-
-        $this->assertEquals(new ConstraintViolationList(array(
-            new ConstraintViolation(
-                'This field was not expected',
-                array('{{ field }}' => '"baz"'),
-                'Root',
-                'bar[baz]',
-                6
-            ),
-        )), $this->context->getViolations());
     }
 
     // bug fix
@@ -154,13 +178,17 @@ public function testNullNotConsideredExtraField()
         $data = $this->prepareTestData(array(
             'foo' => null,
         ));
-        $collection = new Collection(array(
+
+        $constraint = new Collection(array(
             'fields' => array(
                 'foo' => new Min(4),
             ),
         ));
 
-        $this->assertTrue($this->validator->isValid($data, $collection));
+        $this->context->expects($this->never())
+            ->method('addViolationAtRelativePath');
+
+        $this->assertTrue($this->validator->isValid($data, $constraint));
     }
 
     public function testExtraFieldsAllowed()
@@ -169,47 +197,55 @@ public function testExtraFieldsAllowed()
             'foo' => 5,
             'bar' => 6,
         ));
-        $collection = new Collection(array(
+
+        $constraint = new Collection(array(
             'fields' => array(
                 'foo' => new Min(4),
             ),
             'allowExtraFields' => true,
         ));
 
-        $this->assertTrue($this->validator->isValid($data, $collection));
+        $this->context->expects($this->never())
+            ->method('addViolationAtRelativePath');
+
+        $this->assertTrue($this->validator->isValid($data, $constraint));
     }
 
     public function testMissingFieldsDisallowed()
     {
         $data = $this->prepareTestData(array());
 
-        $this->assertFalse($this->validator->isValid($data, new Collection(array(
+        $constraint = new Collection(array(
             'fields' => array(
                 'foo' => new Min(4),
             ),
-        ))));
+            'missingFieldsMessage' => 'myMessage',
+        ));
 
-        $this->assertEquals(new ConstraintViolationList(array(
-            new ConstraintViolation(
-                'This field is missing',
-                array('{{ field }}' => '"foo"'),
-                'Root',
-                'bar[foo]',
-                null
-            ),
-        )), $this->context->getViolations());
+        $this->context->expects($this->once())
+            ->method('addViolationAtRelativePath')
+            ->with('[foo]', 'myMessage', array(
+                '{{ field }}' => 'foo',
+            ));
+
+        $this->assertFalse($this->validator->isValid($data, $constraint));
     }
 
     public function testMissingFieldsAllowed()
     {
         $data = $this->prepareTestData(array());
 
-        $this->assertTrue($this->validator->isValid($data, new Collection(array(
+        $constraint = new Collection(array(
             'fields' => array(
                 'foo' => new Min(4),
             ),
             'allowMissingFields' => true,
-        ))));
+        ));
+
+        $this->context->expects($this->never())
+            ->method('addViolationAtRelativePath');
+
+        $this->assertTrue($this->validator->isValid($data, $constraint));
     }
 
     public function testOptionalFieldPresent()
@@ -218,6 +254,9 @@ public function testOptionalFieldPresent()
             'foo' => null,
         ));
 
+        $this->context->expects($this->never())
+            ->method('addViolationAtRelativePath');
+
         $this->assertTrue($this->validator->isValid($data, new Collection(array(
             'foo' => new Optional(),
         ))));
@@ -227,6 +266,9 @@ public function testOptionalFieldNotPresent()
     {
         $data = $this->prepareTestData(array());
 
+        $this->context->expects($this->never())
+            ->method('addViolationAtRelativePath');
+
         $this->assertTrue($this->validator->isValid($data, new Collection(array(
             'foo' => new Optional(),
         ))));
@@ -242,7 +284,10 @@ public function testOptionalFieldSingleConstraint()
 
         $this->walker->expects($this->once())
             ->method('walkConstraint')
-            ->with($this->equalTo($constraint), $this->equalTo($array['foo']), $this->equalTo('MyGroup'), $this->equalTo('bar[foo]'));
+            ->with($constraint, $array['foo'], 'MyGroup', 'foo.bar[foo]');
+
+        $this->context->expects($this->never())
+            ->method('addViolationAtRelativePath');
 
         $data = $this->prepareTestData($array);
 
@@ -265,9 +310,12 @@ public function testOptionalFieldMultipleConstraints()
         foreach ($constraints as $i => $constraint) {
             $this->walker->expects($this->at($i))
                 ->method('walkConstraint')
-                ->with($this->equalTo($constraint), $this->equalTo($array['foo']), $this->equalTo('MyGroup'), $this->equalTo('bar[foo]'));
+                ->with($constraint, $array['foo'], 'MyGroup', 'foo.bar[foo]');
         }
 
+        $this->context->expects($this->never())
+            ->method('addViolationAtRelativePath');
+
         $data = $this->prepareTestData($array);
 
         $this->assertTrue($this->validator->isValid($data, new Collection(array(
@@ -281,6 +329,9 @@ public function testRequiredFieldPresent()
             'foo' => null,
         ));
 
+        $this->context->expects($this->never())
+            ->method('addViolationAtRelativePath');
+
         $this->assertTrue($this->validator->isValid($data, new Collection(array(
             'foo' => new Required(),
         ))));
@@ -290,8 +341,17 @@ public function testRequiredFieldNotPresent()
     {
         $data = $this->prepareTestData(array());
 
+        $this->context->expects($this->once())
+            ->method('addViolationAtRelativePath')
+            ->with('[foo]', 'myMessage', array(
+                '{{ field }}' => 'foo',
+            ));
+
         $this->assertFalse($this->validator->isValid($data, new Collection(array(
-            'foo' => new Required(),
+            'fields' => array(
+                 'foo' => new Required(),
+             ),
+            'missingFieldsMessage' => 'myMessage',
         ))));
     }
 
@@ -305,7 +365,10 @@ public function testRequiredFieldSingleConstraint()
 
         $this->walker->expects($this->once())
             ->method('walkConstraint')
-            ->with($this->equalTo($constraint), $this->equalTo($array['foo']), $this->equalTo('MyGroup'), $this->equalTo('bar[foo]'));
+            ->with($constraint, $array['foo'], 'MyGroup', 'foo.bar[foo]');
+
+        $this->context->expects($this->never())
+            ->method('addViolationAtRelativePath');
 
         $data = $this->prepareTestData($array);
 
@@ -328,9 +391,12 @@ public function testRequiredFieldMultipleConstraints()
         foreach ($constraints as $i => $constraint) {
             $this->walker->expects($this->at($i))
                 ->method('walkConstraint')
-                ->with($this->equalTo($constraint), $this->equalTo($array['foo']), $this->equalTo('MyGroup'), $this->equalTo('bar[foo]'));
+                ->with($constraint, $array['foo'], 'MyGroup', 'foo.bar[foo]');
         }
 
+        $this->context->expects($this->never())
+            ->method('addViolationAtRelativePath');
+
         $data = $this->prepareTestData($array);
 
         $this->assertTrue($this->validator->isValid($array, new Collection(array(
@@ -343,6 +409,7 @@ public function testObjectShouldBeLeftUnchanged()
         $value = new \ArrayObject(array(
             'foo' => 3
         ));
+
         $this->validator->isValid($value, new Collection(array(
             'fields' => array(
                 'foo' => new Min(2),
diff --git a/tests/Symfony/Tests/Component/Validator/Constraints/CountryValidatorTest.php b/tests/Symfony/Tests/Component/Validator/Constraints/CountryValidatorTest.php
index 64564e371663..8c6a37a5ad49 100644
--- a/tests/Symfony/Tests/Component/Validator/Constraints/CountryValidatorTest.php
+++ b/tests/Symfony/Tests/Component/Validator/Constraints/CountryValidatorTest.php
@@ -16,43 +16,57 @@
 
 class CountryValidatorTest extends LocalizedTestCase
 {
+    protected $context;
     protected $validator;
 
     protected function setUp()
     {
         parent::setUp();
 
+        $this->context = $this->getMock('Symfony\Component\Validator\ExecutionContext', array(), array(), '', false);
         $this->validator = new CountryValidator();
+        $this->validator->initialize($this->context);
     }
 
     protected function tearDown()
     {
+        $this->context = null;
         $this->validator = null;
     }
 
     public function testNullIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid(null, new Country()));
     }
 
     public function testEmptyStringIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid('', new Country()));
     }
 
+    /**
+     * @expectedException Symfony\Component\Validator\Exception\UnexpectedTypeException
+     */
     public function testExpectsStringCompatibleType()
     {
-        $this->setExpectedException('Symfony\Component\Validator\Exception\UnexpectedTypeException');
-
         $this->validator->isValid(new \stdClass(), new Country());
     }
 
     /**
      * @dataProvider getValidCountries
      */
-    public function testValidCountries($date)
+    public function testValidCountries($country)
     {
-        $this->assertTrue($this->validator->isValid($date, new Country()));
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
+        $this->assertTrue($this->validator->isValid($country, new Country()));
     }
 
     public function getValidCountries()
@@ -67,9 +81,19 @@ public function getValidCountries()
     /**
      * @dataProvider getInvalidCountries
      */
-    public function testInvalidCountries($date)
+    public function testInvalidCountries($country)
     {
-        $this->assertFalse($this->validator->isValid($date, new Country()));
+        $constraint = new Country(array(
+            'message' => 'myMessage'
+        ));
+
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ value }}' => $country,
+            ));
+
+        $this->assertFalse($this->validator->isValid($country, $constraint));
     }
 
     public function getInvalidCountries()
@@ -79,17 +103,4 @@ public function getInvalidCountries()
             array('EN'),
         );
     }
-
-    public function testMessageIsSet()
-    {
-        $constraint = new Country(array(
-            'message' => 'myMessage'
-        ));
-
-        $this->assertFalse($this->validator->isValid('foobar', $constraint));
-        $this->assertEquals($this->validator->getMessageTemplate(), 'myMessage');
-        $this->assertEquals($this->validator->getMessageParameters(), array(
-            '{{ value }}' => 'foobar',
-        ));
-    }
 }
diff --git a/tests/Symfony/Tests/Component/Validator/Constraints/DateTimeValidatorTest.php b/tests/Symfony/Tests/Component/Validator/Constraints/DateTimeValidatorTest.php
index 03bc68ab075d..777edcb13990 100644
--- a/tests/Symfony/Tests/Component/Validator/Constraints/DateTimeValidatorTest.php
+++ b/tests/Symfony/Tests/Component/Validator/Constraints/DateTimeValidatorTest.php
@@ -16,46 +16,63 @@
 
 class DateTimeValidatorTest extends \PHPUnit_Framework_TestCase
 {
+    protected $context;
     protected $validator;
 
     protected function setUp()
     {
+        $this->context = $this->getMock('Symfony\Component\Validator\ExecutionContext', array(), array(), '', false);
         $this->validator = new DateTimeValidator();
+        $this->validator->initialize($this->context);
     }
 
     protected function tearDown()
     {
+        $this->context = null;
         $this->validator = null;
     }
 
     public function testNullIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid(null, new DateTime()));
     }
 
     public function testEmptyStringIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid('', new DateTime()));
     }
 
     public function testDateTimeClassIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid(new \DateTime(), new DateTime()));
     }
 
+    /**
+     * @expectedException Symfony\Component\Validator\Exception\UnexpectedTypeException
+     */
     public function testExpectsStringCompatibleType()
     {
-        $this->setExpectedException('Symfony\Component\Validator\Exception\UnexpectedTypeException');
-
         $this->validator->isValid(new \stdClass(), new DateTime());
     }
 
     /**
      * @dataProvider getValidDateTimes
      */
-    public function testValidDateTimes($date)
+    public function testValidDateTimes($dateTime)
     {
-        $this->assertTrue($this->validator->isValid($date, new DateTime()));
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
+        $this->assertTrue($this->validator->isValid($dateTime, new DateTime()));
     }
 
     public function getValidDateTimes()
@@ -70,9 +87,19 @@ public function getValidDateTimes()
     /**
      * @dataProvider getInvalidDateTimes
      */
-    public function testInvalidDateTimes($date)
+    public function testInvalidDateTimes($dateTime)
     {
-        $this->assertFalse($this->validator->isValid($date, new DateTime()));
+        $constraint = new DateTime(array(
+            'message' => 'myMessage'
+        ));
+
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ value }}' => $dateTime,
+            ));
+
+        $this->assertFalse($this->validator->isValid($dateTime, $constraint));
     }
 
     public function getInvalidDateTimes()
@@ -90,17 +117,4 @@ public function getInvalidDateTimes()
             array('2010-01-01 00:00:60'),
         );
     }
-
-    public function testMessageIsSet()
-    {
-        $constraint = new DateTime(array(
-            'message' => 'myMessage'
-        ));
-
-        $this->assertFalse($this->validator->isValid('foobar', $constraint));
-        $this->assertEquals($this->validator->getMessageTemplate(), 'myMessage');
-        $this->assertEquals($this->validator->getMessageParameters(), array(
-            '{{ value }}' => 'foobar',
-        ));
-    }
 }
diff --git a/tests/Symfony/Tests/Component/Validator/Constraints/DateValidatorTest.php b/tests/Symfony/Tests/Component/Validator/Constraints/DateValidatorTest.php
index 0e64a6f459c1..16af8bdccb1c 100644
--- a/tests/Symfony/Tests/Component/Validator/Constraints/DateValidatorTest.php
+++ b/tests/Symfony/Tests/Component/Validator/Constraints/DateValidatorTest.php
@@ -16,37 +16,51 @@
 
 class DateValidatorTest extends \PHPUnit_Framework_TestCase
 {
+    protected $context;
     protected $validator;
 
     protected function setUp()
     {
+        $this->context = $this->getMock('Symfony\Component\Validator\ExecutionContext', array(), array(), '', false);
         $this->validator = new DateValidator();
+        $this->validator->initialize($this->context);
     }
 
     protected function tearDown()
     {
+        $this->context = null;
         $this->validator = null;
     }
 
     public function testNullIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid(null, new Date()));
     }
 
     public function testEmptyStringIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid('', new Date()));
     }
 
     public function testDateTimeClassIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid(new \DateTime(), new Date()));
     }
 
+    /**
+     * @expectedException Symfony\Component\Validator\Exception\UnexpectedTypeException
+     */
     public function testExpectsStringCompatibleType()
     {
-        $this->setExpectedException('Symfony\Component\Validator\Exception\UnexpectedTypeException');
-
         $this->validator->isValid(new \stdClass(), new Date());
     }
 
@@ -55,6 +69,9 @@ public function testExpectsStringCompatibleType()
      */
     public function testValidDates($date)
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid($date, new Date()));
     }
 
@@ -72,7 +89,17 @@ public function getValidDates()
      */
     public function testInvalidDates($date)
     {
-        $this->assertFalse($this->validator->isValid($date, new Date()));
+        $constraint = new Date(array(
+            'message' => 'myMessage'
+        ));
+
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ value }}' => $date,
+            ));
+
+        $this->assertFalse($this->validator->isValid($date, $constraint));
     }
 
     public function getInvalidDates()
@@ -86,17 +113,4 @@ public function getInvalidDates()
             array('2010-02-29'),
         );
     }
-
-    public function testMessageIsSet()
-    {
-        $constraint = new Date(array(
-            'message' => 'myMessage'
-        ));
-
-        $this->assertFalse($this->validator->isValid('foobar', $constraint));
-        $this->assertEquals($this->validator->getMessageTemplate(), 'myMessage');
-        $this->assertEquals($this->validator->getMessageParameters(), array(
-            '{{ value }}' => 'foobar',
-        ));
-    }
 }
diff --git a/tests/Symfony/Tests/Component/Validator/Constraints/EmailValidatorTest.php b/tests/Symfony/Tests/Component/Validator/Constraints/EmailValidatorTest.php
index 32fbd2c34eb8..70aefb2fa911 100644
--- a/tests/Symfony/Tests/Component/Validator/Constraints/EmailValidatorTest.php
+++ b/tests/Symfony/Tests/Component/Validator/Constraints/EmailValidatorTest.php
@@ -16,32 +16,43 @@
 
 class EmailValidatorTest extends \PHPUnit_Framework_TestCase
 {
+    protected $context;
     protected $validator;
 
     protected function setUp()
     {
+        $this->context = $this->getMock('Symfony\Component\Validator\ExecutionContext', array(), array(), '', false);
         $this->validator = new EmailValidator();
+        $this->validator->initialize($this->context);
     }
 
     protected function tearDown()
     {
+        $this->context = null;
         $this->validator = null;
     }
 
     public function testNullIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid(null, new Email()));
     }
 
     public function testEmptyStringIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid('', new Email()));
     }
 
+    /**
+     * @expectedException Symfony\Component\Validator\Exception\UnexpectedTypeException
+     */
     public function testExpectsStringCompatibleType()
     {
-        $this->setExpectedException('Symfony\Component\Validator\Exception\UnexpectedTypeException');
-
         $this->validator->isValid(new \stdClass(), new Email());
     }
 
@@ -50,6 +61,9 @@ public function testExpectsStringCompatibleType()
      */
     public function testValidEmails($email)
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid($email, new Email()));
     }
 
@@ -67,7 +81,17 @@ public function getValidEmails()
      */
     public function testInvalidEmails($email)
     {
-        $this->assertFalse($this->validator->isValid($email, new Email()));
+        $constraint = new Email(array(
+            'message' => 'myMessage'
+        ));
+
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ value }}' => $email,
+            ));
+
+        $this->assertFalse($this->validator->isValid($email, $constraint));
     }
 
     public function getInvalidEmails()
@@ -79,17 +103,4 @@ public function getInvalidEmails()
             array('example@example.com@example.com'),
         );
     }
-
-    public function testMessageIsSet()
-    {
-        $constraint = new Email(array(
-            'message' => 'myMessage'
-        ));
-
-        $this->assertFalse($this->validator->isValid('foobar', $constraint));
-        $this->assertEquals($this->validator->getMessageTemplate(), 'myMessage');
-        $this->assertEquals($this->validator->getMessageParameters(), array(
-            '{{ value }}' => 'foobar',
-        ));
-    }
 }
diff --git a/tests/Symfony/Tests/Component/Validator/Constraints/AssertFalseValidatorTest.php b/tests/Symfony/Tests/Component/Validator/Constraints/FalseValidatorTest.php
similarity index 68%
rename from tests/Symfony/Tests/Component/Validator/Constraints/AssertFalseValidatorTest.php
rename to tests/Symfony/Tests/Component/Validator/Constraints/FalseValidatorTest.php
index df95c7c78127..7b41e4899051 100644
--- a/tests/Symfony/Tests/Component/Validator/Constraints/AssertFalseValidatorTest.php
+++ b/tests/Symfony/Tests/Component/Validator/Constraints/FalseValidatorTest.php
@@ -16,25 +16,35 @@
 
 class FalseValidatorTest extends \PHPUnit_Framework_TestCase
 {
+    protected $context;
     protected $validator;
 
     protected function setUp()
     {
+        $this->context = $this->getMock('Symfony\Component\Validator\ExecutionContext', array(), array(), '', false);
         $this->validator = new FalseValidator();
+        $this->validator->initialize($this->context);
     }
 
     protected function tearDown()
     {
+        $this->context = null;
         $this->validator = null;
     }
 
     public function testNullIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid(null, new False()));
     }
 
     public function testFalseIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid(false, new False()));
     }
 
@@ -44,8 +54,10 @@ public function testTrueIsInvalid()
             'message' => 'myMessage'
         ));
 
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array());
+
         $this->assertFalse($this->validator->isValid(true, $constraint));
-        $this->assertEquals($this->validator->getMessageTemplate(), 'myMessage');
-        $this->assertEquals($this->validator->getMessageParameters(), array());
     }
 }
diff --git a/tests/Symfony/Tests/Component/Validator/Constraints/FileValidatorObjectTest.php b/tests/Symfony/Tests/Component/Validator/Constraints/FileValidatorObjectTest.php
new file mode 100644
index 000000000000..a331c9149773
--- /dev/null
+++ b/tests/Symfony/Tests/Component/Validator/Constraints/FileValidatorObjectTest.php
@@ -0,0 +1,22 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Tests\Component\Validator\Constraints;
+
+use Symfony\Component\HttpFoundation\File\File;
+
+class FileValidatorObjectTest extends FileValidatorTest
+{
+    protected function getFile($filename)
+    {
+        return new File($filename);
+    }
+}
diff --git a/tests/Symfony/Tests/Component/Validator/Constraints/FileValidatorPathTest.php b/tests/Symfony/Tests/Component/Validator/Constraints/FileValidatorPathTest.php
new file mode 100644
index 000000000000..b0ac0c667271
--- /dev/null
+++ b/tests/Symfony/Tests/Component/Validator/Constraints/FileValidatorPathTest.php
@@ -0,0 +1,37 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Tests\Component\Validator\Constraints;
+
+use Symfony\Component\Validator\Constraints\File;
+
+class FileValidatorPathTest extends FileValidatorTest
+{
+    protected function getFile($filename)
+    {
+        return $filename;
+    }
+
+    public function testFileNotFound()
+    {
+        $constraint = new File(array(
+            'notFoundMessage' => 'myMessage',
+        ));
+
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ file }}' => 'foobar',
+            ));
+
+        $this->assertFalse($this->validator->isValid('foobar', $constraint));
+    }
+}
diff --git a/tests/Symfony/Tests/Component/Validator/Constraints/FileValidatorTest.php b/tests/Symfony/Tests/Component/Validator/Constraints/FileValidatorTest.php
index 9b07c2e9e89e..fb09e23cfa86 100644
--- a/tests/Symfony/Tests/Component/Validator/Constraints/FileValidatorTest.php
+++ b/tests/Symfony/Tests/Component/Validator/Constraints/FileValidatorTest.php
@@ -16,15 +16,18 @@
 use Symfony\Component\HttpFoundation\File\File as FileObject;
 use Symfony\Component\HttpFoundation\File\UploadedFile;
 
-class FileValidatorTest extends \PHPUnit_Framework_TestCase
+abstract class FileValidatorTest extends \PHPUnit_Framework_TestCase
 {
+    protected $context;
     protected $validator;
     protected $path;
     protected $file;
 
     protected function setUp()
     {
+        $this->context = $this->getMock('Symfony\Component\Validator\ExecutionContext', array(), array(), '', false);
         $this->validator = new FileValidator();
+        $this->validator->initialize($this->context);
         $this->path = sys_get_temp_dir() . DIRECTORY_SEPARATOR . 'FileValidatorTest';
         $this->file = fopen($this->path, 'w');
     }
@@ -33,6 +36,7 @@ protected function tearDown()
     {
         fclose($this->file);
 
+        $this->context = null;
         $this->validator = null;
         $this->path = null;
         $this->file = null;
@@ -40,11 +44,17 @@ protected function tearDown()
 
     public function testNullIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid(null, new File()));
     }
 
     public function testEmptyStringIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid('', new File()));
     }
 
@@ -58,11 +68,17 @@ public function testExpectsStringCompatibleTypeOrFile()
 
     public function testValidFile()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid($this->path, new File()));
     }
 
     public function testValidUploadedfile()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $file = new UploadedFile($this->path, 'originalName');
         $this->assertTrue($this->validator->isValid($file, new File()));
     }
@@ -76,13 +92,15 @@ public function testTooLargeBytes()
             'maxSizeMessage'    => 'myMessage',
         ));
 
-        $this->assertFileValid($this->path, $constraint, false);
-        $this->assertEquals($this->validator->getMessageTemplate(), 'myMessage');
-        $this->assertEquals($this->validator->getMessageParameters(), array(
-            '{{ limit }}'   => '10 bytes',
-            '{{ size }}'    => '11 bytes',
-            '{{ file }}'    => $this->path,
-        ));
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ limit }}'   => '10 bytes',
+                '{{ size }}'    => '11 bytes',
+                '{{ file }}'    => $this->path,
+            ));
+
+        $this->assertFalse($this->validator->isValid($this->getFile($this->path), $constraint));
     }
 
     public function testTooLargeKiloBytes()
@@ -94,13 +112,15 @@ public function testTooLargeKiloBytes()
             'maxSizeMessage'    => 'myMessage',
         ));
 
-        $this->assertFileValid($this->path, $constraint, false);
-        $this->assertEquals($this->validator->getMessageTemplate(), 'myMessage');
-        $this->assertEquals($this->validator->getMessageParameters(), array(
-            '{{ limit }}'   => '1 kB',
-            '{{ size }}'    => '1.4 kB',
-            '{{ file }}'    => $this->path,
-        ));
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ limit }}'   => '1 kB',
+                '{{ size }}'    => '1.4 kB',
+                '{{ file }}'    => $this->path,
+            ));
+
+        $this->assertFalse($this->validator->isValid($this->getFile($this->path), $constraint));
     }
 
     public function testTooLargeMegaBytes()
@@ -112,13 +132,15 @@ public function testTooLargeMegaBytes()
             'maxSizeMessage'    => 'myMessage',
         ));
 
-        $this->assertFileValid($this->path, $constraint, false);
-        $this->assertEquals($this->validator->getMessageTemplate(), 'myMessage');
-        $this->assertEquals($this->validator->getMessageParameters(), array(
-            '{{ limit }}'   => '1 MB',
-            '{{ size }}'    => '1.4 MB',
-            '{{ file }}'    => $this->path,
-        ));
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ limit }}'   => '1 MB',
+                '{{ size }}'    => '1.4 MB',
+                '{{ file }}'    => $this->path,
+            ));
+
+        $this->assertFalse($this->validator->isValid($this->getFile($this->path), $constraint));
     }
 
     /**
@@ -133,19 +155,6 @@ public function testInvalidMaxSize()
         $this->validator->isValid($this->path, $constraint);
     }
 
-    public function testFileNotFound()
-    {
-        $constraint = new File(array(
-            'notFoundMessage' => 'myMessage',
-        ));
-
-        $this->assertFileValid('foobar', $constraint, false);
-        $this->assertEquals($this->validator->getMessageTemplate(), 'myMessage');
-        $this->assertEquals($this->validator->getMessageParameters(), array(
-            '{{ file }}' => 'foobar',
-        ));
-    }
-
     public function testValidMimeType()
     {
         $file = $this
@@ -164,6 +173,9 @@ public function testValidMimeType()
             ->will($this->returnValue('image/jpg'))
         ;
 
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $constraint = new File(array(
             'mimeTypes' => array('image/png', 'image/jpg'),
         ));
@@ -189,6 +201,9 @@ public function testValidWildcardMimeType()
             ->will($this->returnValue('image/jpg'))
         ;
 
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $constraint = new File(array(
             'mimeTypes' => array('image/*'),
         ));
@@ -219,13 +234,15 @@ public function testInvalidMimeType()
             'mimeTypesMessage' => 'myMessage',
         ));
 
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ type }}'    => '"application/pdf"',
+                '{{ types }}'   => '"image/png", "image/jpg"',
+                '{{ file }}'    => $this->path,
+            ));
+
         $this->assertFalse($this->validator->isValid($file, $constraint));
-        $this->assertEquals($this->validator->getMessageTemplate(), 'myMessage');
-        $this->assertEquals($this->validator->getMessageParameters(), array(
-            '{{ type }}'    => '"application/pdf"',
-            '{{ types }}'   => '"image/png", "image/jpg"',
-            '{{ file }}'    => $this->path,
-        ));
     }
 
     public function testInvalidWildcardMimeType()
@@ -251,35 +268,40 @@ public function testInvalidWildcardMimeType()
             'mimeTypesMessage' => 'myMessage',
         ));
 
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ type }}'    => '"application/pdf"',
+                '{{ types }}'   => '"image/*", "image/jpg"',
+                '{{ file }}'    => $this->path,
+            ));
+
         $this->assertFalse($this->validator->isValid($file, $constraint));
-        $this->assertEquals($this->validator->getMessageTemplate(), 'myMessage');
-        $this->assertEquals($this->validator->getMessageParameters(), array(
-            '{{ type }}'    => '"application/pdf"',
-            '{{ types }}'   => '"image/*", "image/jpg"',
-            '{{ file }}'    => $this->path,
-        ));
     }
 
     /**
      * @dataProvider uploadedFileErrorProvider
      */
-    public function testUploadedFileError($error, $message)
+    public function testUploadedFileError($error, $message, array $params = array())
     {
         $file = new UploadedFile('/path/to/file', 'originalName', 'mime', 0, $error);
 
-        $options[$message] = 'myMessage';
+        $constraint = new File(array(
+            $message => 'myMessage',
+        ));
 
-        $constraint = new File($options);
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', $params);
 
         $this->assertFalse($this->validator->isValid($file, $constraint));
-        $this->assertEquals($this->validator->getMessageTemplate(), 'myMessage');
 
     }
 
     public function uploadedFileErrorProvider()
     {
         return array(
-            array(UPLOAD_ERR_INI_SIZE, 'uploadIniSizeErrorMessage'),
+            array(UPLOAD_ERR_INI_SIZE, 'uploadIniSizeErrorMessage', array('{{ limit }}' => UploadedFile::getMaxFilesize() . ' bytes')),
             array(UPLOAD_ERR_FORM_SIZE, 'uploadFormSizeErrorMessage'),
             array(UPLOAD_ERR_PARTIAL, 'uploadErrorMessage'),
             array(UPLOAD_ERR_NO_TMP_DIR, 'uploadErrorMessage'),
@@ -287,11 +309,5 @@ public function uploadedFileErrorProvider()
         );
     }
 
-    protected function assertFileValid($filename, File $constraint, $valid = true)
-    {
-        $this->assertEquals($this->validator->isValid($filename, $constraint), $valid);
-        if (file_exists($filename)) {
-            $this->assertEquals($this->validator->isValid(new FileObject($filename), $constraint), $valid);
-        }
-    }
+    abstract protected function getFile($filename);
 }
diff --git a/tests/Symfony/Tests/Component/Validator/Constraints/ImageValidatorTest.php b/tests/Symfony/Tests/Component/Validator/Constraints/ImageValidatorTest.php
index 77b465265d2c..73e5da24e43c 100644
--- a/tests/Symfony/Tests/Component/Validator/Constraints/ImageValidatorTest.php
+++ b/tests/Symfony/Tests/Component/Validator/Constraints/ImageValidatorTest.php
@@ -16,33 +16,48 @@
 
 class ImageValidatorTest extends \PHPUnit_Framework_TestCase
 {
+    protected $context;
     protected $validator;
     protected $path;
     protected $image;
 
     protected function setUp()
     {
+        $this->context = $this->getMock('Symfony\Component\Validator\ExecutionContext', array(), array(), '', false);
         $this->validator = new ImageValidator();
+        $this->validator->initialize($this->context);
         $this->image = __DIR__.'/Fixtures/test.gif';
     }
 
     public function testNullIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid(null, new Image()));
     }
 
     public function testEmptyStringIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid('', new Image()));
     }
 
     public function testValidImage()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid($this->image, new Image()));
     }
 
     public function testValidSize()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $constraint = new Image(array(
             'minWidth' => 1,
             'maxWidth' => 2,
@@ -60,12 +75,14 @@ public function testWidthTooSmall()
             'minWidthMessage' => 'myMessage',
         ));
 
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ width }}' => '2',
+                '{{ min_width }}' => '3',
+            ));
+
         $this->assertFalse($this->validator->isValid($this->image, $constraint));
-        $this->assertEquals('myMessage', $this->validator->getMessageTemplate());
-        $this->assertEquals(array(
-            '{{ width }}' => '2',
-            '{{ min_width }}' => '3',
-        ), $this->validator->getMessageParameters());
     }
 
     public function testWidthTooBig()
@@ -75,12 +92,14 @@ public function testWidthTooBig()
             'maxWidthMessage' => 'myMessage',
         ));
 
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ width }}' => '2',
+                '{{ max_width }}' => '1',
+            ));
+
         $this->assertFalse($this->validator->isValid($this->image, $constraint));
-        $this->assertEquals('myMessage', $this->validator->getMessageTemplate());
-        $this->assertEquals(array(
-            '{{ width }}' => '2',
-            '{{ max_width }}' => '1',
-        ), $this->validator->getMessageParameters());
     }
 
     public function testHeightTooSmall()
@@ -90,12 +109,14 @@ public function testHeightTooSmall()
             'minHeightMessage' => 'myMessage',
         ));
 
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ height }}' => '2',
+                '{{ min_height }}' => '3',
+            ));
+
         $this->assertFalse($this->validator->isValid($this->image, $constraint));
-        $this->assertEquals('myMessage', $this->validator->getMessageTemplate());
-        $this->assertEquals(array(
-            '{{ height }}' => '2',
-            '{{ min_height }}' => '3',
-        ), $this->validator->getMessageParameters());
     }
 
     public function testHeightTooBig()
@@ -105,12 +126,14 @@ public function testHeightTooBig()
             'maxHeightMessage' => 'myMessage',
         ));
 
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ height }}' => '2',
+                '{{ max_height }}' => '1',
+            ));
+
         $this->assertFalse($this->validator->isValid($this->image, $constraint));
-        $this->assertEquals('myMessage', $this->validator->getMessageTemplate());
-        $this->assertEquals(array(
-            '{{ height }}' => '2',
-            '{{ max_height }}' => '1',
-        ), $this->validator->getMessageParameters());
     }
 
     /**
diff --git a/tests/Symfony/Tests/Component/Validator/Constraints/IpValidatorTest.php b/tests/Symfony/Tests/Component/Validator/Constraints/IpValidatorTest.php
index 9199a48d0113..ee24a4f4e4e2 100644
--- a/tests/Symfony/Tests/Component/Validator/Constraints/IpValidatorTest.php
+++ b/tests/Symfony/Tests/Component/Validator/Constraints/IpValidatorTest.php
@@ -16,39 +16,51 @@
 
 class IpValidatorTest extends \PHPUnit_Framework_TestCase
 {
+    protected $context;
     protected $validator;
 
     protected function setUp()
     {
+        $this->context = $this->getMock('Symfony\Component\Validator\ExecutionContext', array(), array(), '', false);
         $this->validator = new IpValidator();
+        $this->validator->initialize($this->context);
     }
 
     protected function tearDown()
     {
+        $this->context = null;
         $this->validator = null;
     }
 
     public function testNullIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid(null, new Ip()));
     }
 
     public function testEmptyStringIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid('', new Ip()));
     }
 
+    /**
+     * @expectedException Symfony\Component\Validator\Exception\UnexpectedTypeException
+     */
     public function testExpectsStringCompatibleType()
     {
-        $this->setExpectedException('Symfony\Component\Validator\Exception\UnexpectedTypeException');
-
         $this->validator->isValid(new \stdClass(), new Ip());
     }
 
+    /**
+     * @expectedException Symfony\Component\Validator\Exception\ConstraintDefinitionException
+     */
     public function testInvalidValidatorVersion()
     {
-        $this->setExpectedException('Symfony\Component\Validator\Exception\ConstraintDefinitionException');
-
         $ip = new Ip(array(
             'version' => 666,
         ));
@@ -59,6 +71,9 @@ public function testInvalidValidatorVersion()
      */
     public function testValidIpsV4($ip)
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid($ip, new Ip(array(
             'version' => Ip::V4,
         ))));
@@ -83,6 +98,9 @@ public function getValidIpsV4()
      */
     public function testValidIpsV6($ip)
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid($ip, new Ip(array(
             'version' => Ip::V6,
         ))));
@@ -118,6 +136,9 @@ public function getValidIpsV6()
      */
     public function testValidIpsAll($ip)
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid($ip, new Ip(array(
             'version' => Ip::ALL,
         ))));
@@ -133,9 +154,18 @@ public function getValidIpsAll()
      */
     public function testInvalidIpsV4($ip)
     {
-        $this->assertFalse($this->validator->isValid($ip, new Ip(array(
+        $constraint = new Ip(array(
             'version' => Ip::V4,
-        ))));
+            'message' => 'myMessage',
+        ));
+
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ value }}' => $ip,
+            ));
+
+        $this->assertFalse($this->validator->isValid($ip, $constraint));
     }
 
     public function getInvalidIpsV4()
@@ -158,9 +188,18 @@ public function getInvalidIpsV4()
      */
     public function testInvalidPrivateIpsV4($ip)
     {
-        $this->assertFalse($this->validator->isValid($ip, new Ip(array(
+        $constraint = new Ip(array(
             'version' => Ip::V4_NO_PRIV,
-        ))));
+            'message' => 'myMessage',
+        ));
+
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ value }}' => $ip,
+            ));
+
+        $this->assertFalse($this->validator->isValid($ip, $constraint));
     }
 
     public function getInvalidPrivateIpsV4()
@@ -177,9 +216,18 @@ public function getInvalidPrivateIpsV4()
      */
     public function testInvalidReservedIpsV4($ip)
     {
-        $this->assertFalse($this->validator->isValid($ip, new Ip(array(
+        $constraint = new Ip(array(
             'version' => Ip::V4_NO_RES,
-        ))));
+            'message' => 'myMessage',
+        ));
+
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ value }}' => $ip,
+            ));
+
+        $this->assertFalse($this->validator->isValid($ip, $constraint));
     }
 
     public function getInvalidReservedIpsV4()
@@ -196,9 +244,18 @@ public function getInvalidReservedIpsV4()
      */
     public function testInvalidPublicIpsV4($ip)
     {
-        $this->assertFalse($this->validator->isValid($ip, new Ip(array(
+        $constraint = new Ip(array(
             'version' => Ip::V4_ONLY_PUBLIC,
-        ))));
+            'message' => 'myMessage',
+        ));
+
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ value }}' => $ip,
+            ));
+
+        $this->assertFalse($this->validator->isValid($ip, $constraint));
     }
 
     public function getInvalidPublicIpsV4()
@@ -211,9 +268,18 @@ public function getInvalidPublicIpsV4()
      */
     public function testInvalidIpsV6($ip)
     {
-        $this->assertFalse($this->validator->isValid($ip, new Ip(array(
+        $constraint = new Ip(array(
             'version' => Ip::V6,
-        ))));
+            'message' => 'myMessage',
+        ));
+
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ value }}' => $ip,
+            ));
+
+        $this->assertFalse($this->validator->isValid($ip, $constraint));
     }
 
     public function getInvalidIpsV6()
@@ -240,9 +306,18 @@ public function getInvalidIpsV6()
      */
     public function testInvalidPrivateIpsV6($ip)
     {
-        $this->assertFalse($this->validator->isValid($ip, new Ip(array(
+        $constraint = new Ip(array(
             'version' => Ip::V6_NO_PRIV,
-        ))));
+            'message' => 'myMessage',
+        ));
+
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ value }}' => $ip,
+            ));
+
+        $this->assertFalse($this->validator->isValid($ip, $constraint));
     }
 
     public function getInvalidPrivateIpsV6()
@@ -259,9 +334,18 @@ public function getInvalidPrivateIpsV6()
      */
     public function testInvalidReservedIpsV6($ip)
     {
-        $this->assertFalse($this->validator->isValid($ip, new Ip(array(
+        $constraint = new Ip(array(
             'version' => Ip::V6_NO_RES,
-        ))));
+            'message' => 'myMessage',
+        ));
+
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ value }}' => $ip,
+            ));
+
+        $this->assertFalse($this->validator->isValid($ip, $constraint));
     }
 
     public function getInvalidReservedIpsV6()
@@ -277,9 +361,18 @@ public function getInvalidReservedIpsV6()
      */
     public function testInvalidPublicIpsV6($ip)
     {
-        $this->assertFalse($this->validator->isValid($ip, new Ip(array(
+        $constraint = new Ip(array(
             'version' => Ip::V6_ONLY_PUBLIC,
-        ))));
+            'message' => 'myMessage',
+        ));
+
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ value }}' => $ip,
+            ));
+
+        $this->assertFalse($this->validator->isValid($ip, $constraint));
     }
 
     public function getInvalidPublicIpsV6()
@@ -292,9 +385,18 @@ public function getInvalidPublicIpsV6()
      */
     public function testInvalidIpsAll($ip)
     {
-        $this->assertFalse($this->validator->isValid($ip, new Ip(array(
+        $constraint = new Ip(array(
             'version' => Ip::ALL,
-        ))));
+            'message' => 'myMessage',
+        ));
+
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ value }}' => $ip,
+            ));
+
+        $this->assertFalse($this->validator->isValid($ip, $constraint));
     }
 
     public function getInvalidIpsAll()
@@ -307,9 +409,18 @@ public function getInvalidIpsAll()
      */
     public function testInvalidPrivateIpsAll($ip)
     {
-        $this->assertFalse($this->validator->isValid($ip, new Ip(array(
+        $constraint = new Ip(array(
             'version' => Ip::ALL_NO_PRIV,
-        ))));
+            'message' => 'myMessage',
+        ));
+
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ value }}' => $ip,
+            ));
+
+        $this->assertFalse($this->validator->isValid($ip, $constraint));
     }
 
     public function getInvalidPrivateIpsAll()
@@ -322,9 +433,18 @@ public function getInvalidPrivateIpsAll()
      */
     public function testInvalidReservedIpsAll($ip)
     {
-        $this->assertFalse($this->validator->isValid($ip, new Ip(array(
+        $constraint = new Ip(array(
             'version' => Ip::ALL_NO_RES,
-        ))));
+            'message' => 'myMessage',
+        ));
+
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ value }}' => $ip,
+            ));
+
+        $this->assertFalse($this->validator->isValid($ip, $constraint));
     }
 
     public function getInvalidReservedIpsAll()
@@ -337,26 +457,22 @@ public function getInvalidReservedIpsAll()
      */
     public function testInvalidPublicIpsAll($ip)
     {
-        $this->assertFalse($this->validator->isValid($ip, new Ip(array(
+        $constraint = new Ip(array(
             'version' => Ip::ALL_ONLY_PUBLIC,
-        ))));
+            'message' => 'myMessage',
+        ));
+
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ value }}' => $ip,
+            ));
+
+        $this->assertFalse($this->validator->isValid($ip, $constraint));
     }
 
     public function getInvalidPublicIpsAll()
     {
         return array_merge($this->getInvalidPublicIpsV4(), $this->getInvalidPublicIpsV6());
     }
-
-    public function testMessageIsSet()
-    {
-        $constraint = new Ip(array(
-            'message' => 'myMessage'
-        ));
-
-        $this->assertFalse($this->validator->isValid('foobar', $constraint));
-        $this->assertEquals($this->validator->getMessageTemplate(), 'myMessage');
-        $this->assertEquals($this->validator->getMessageParameters(), array(
-            '{{ value }}' => 'foobar',
-        ));
-    }
 }
diff --git a/tests/Symfony/Tests/Component/Validator/Constraints/LanguageValidatorTest.php b/tests/Symfony/Tests/Component/Validator/Constraints/LanguageValidatorTest.php
index 3c68dfc98994..0f0064df1ea8 100644
--- a/tests/Symfony/Tests/Component/Validator/Constraints/LanguageValidatorTest.php
+++ b/tests/Symfony/Tests/Component/Validator/Constraints/LanguageValidatorTest.php
@@ -16,43 +16,57 @@
 
 class LanguageValidatorTest extends LocalizedTestCase
 {
+    protected $context;
     protected $validator;
 
     protected function setUp()
     {
         parent::setUp();
 
+        $this->context = $this->getMock('Symfony\Component\Validator\ExecutionContext', array(), array(), '', false);
         $this->validator = new LanguageValidator();
+        $this->validator->initialize($this->context);
     }
 
     protected function tearDown()
     {
+        $this->context = null;
         $this->validator = null;
     }
 
     public function testNullIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid(null, new Language()));
     }
 
     public function testEmptyStringIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid('', new Language()));
     }
 
+    /**
+     * @expectedException Symfony\Component\Validator\Exception\UnexpectedTypeException
+     */
     public function testExpectsStringCompatibleType()
     {
-        $this->setExpectedException('Symfony\Component\Validator\Exception\UnexpectedTypeException');
-
         $this->validator->isValid(new \stdClass(), new Language());
     }
 
     /**
      * @dataProvider getValidLanguages
      */
-    public function testValidLanguages($date)
+    public function testValidLanguages($language)
     {
-        $this->assertTrue($this->validator->isValid($date, new Language()));
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
+        $this->assertTrue($this->validator->isValid($language, new Language()));
     }
 
     public function getValidLanguages()
@@ -67,9 +81,19 @@ public function getValidLanguages()
     /**
      * @dataProvider getInvalidLanguages
      */
-    public function testInvalidLanguages($date)
+    public function testInvalidLanguages($language)
     {
-        $this->assertFalse($this->validator->isValid($date, new Language()));
+        $constraint = new Language(array(
+            'message' => 'myMessage'
+        ));
+
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ value }}' => $language,
+            ));
+
+        $this->assertFalse($this->validator->isValid($language, $constraint));
     }
 
     public function getInvalidLanguages()
@@ -79,17 +103,4 @@ public function getInvalidLanguages()
             array('foobar'),
         );
     }
-
-    public function testMessageIsSet()
-    {
-        $constraint = new Language(array(
-            'message' => 'myMessage'
-        ));
-
-        $this->assertFalse($this->validator->isValid('foobar', $constraint));
-        $this->assertEquals($this->validator->getMessageTemplate(), 'myMessage');
-        $this->assertEquals($this->validator->getMessageParameters(), array(
-            '{{ value }}' => 'foobar',
-        ));
-    }
 }
diff --git a/tests/Symfony/Tests/Component/Validator/Constraints/LocaleValidatorTest.php b/tests/Symfony/Tests/Component/Validator/Constraints/LocaleValidatorTest.php
index 1e6de9e94910..ad05aaf6a71c 100644
--- a/tests/Symfony/Tests/Component/Validator/Constraints/LocaleValidatorTest.php
+++ b/tests/Symfony/Tests/Component/Validator/Constraints/LocaleValidatorTest.php
@@ -16,43 +16,57 @@
 
 class LocaleValidatorTest extends LocalizedTestCase
 {
+    protected $context;
     protected $validator;
 
     protected function setUp()
     {
         parent::setUp();
 
+        $this->context = $this->getMock('Symfony\Component\Validator\ExecutionContext', array(), array(), '', false);
         $this->validator = new LocaleValidator();
+        $this->validator->initialize($this->context);
     }
 
     protected function tearDown()
     {
+        $this->context = null;
         $this->validator = null;
     }
 
     public function testNullIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid(null, new Locale()));
     }
 
     public function testEmptyStringIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid('', new Locale()));
     }
 
+    /**
+     * @expectedException Symfony\Component\Validator\Exception\UnexpectedTypeException
+     */
     public function testExpectsStringCompatibleType()
     {
-        $this->setExpectedException('Symfony\Component\Validator\Exception\UnexpectedTypeException');
-
         $this->validator->isValid(new \stdClass(), new Locale());
     }
 
     /**
      * @dataProvider getValidLocales
      */
-    public function testValidLocales($date)
+    public function testValidLocales($locale)
     {
-        $this->assertTrue($this->validator->isValid($date, new Locale()));
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
+        $this->assertTrue($this->validator->isValid($locale, new Locale()));
     }
 
     public function getValidLocales()
@@ -68,9 +82,19 @@ public function getValidLocales()
     /**
      * @dataProvider getInvalidLocales
      */
-    public function testInvalidLocales($date)
+    public function testInvalidLocales($locale)
     {
-        $this->assertFalse($this->validator->isValid($date, new Locale()));
+        $constraint = new Locale(array(
+            'message' => 'myMessage'
+        ));
+
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ value }}' => $locale,
+            ));
+
+        $this->assertFalse($this->validator->isValid($locale, $constraint));
     }
 
     public function getInvalidLocales()
@@ -80,17 +104,4 @@ public function getInvalidLocales()
             array('foobar'),
         );
     }
-
-    public function testMessageIsSet()
-    {
-        $constraint = new Locale(array(
-            'message' => 'myMessage'
-        ));
-
-        $this->assertFalse($this->validator->isValid('foobar', $constraint));
-        $this->assertEquals($this->validator->getMessageTemplate(), 'myMessage');
-        $this->assertEquals($this->validator->getMessageParameters(), array(
-            '{{ value }}' => 'foobar',
-        ));
-    }
 }
diff --git a/tests/Symfony/Tests/Component/Validator/Constraints/MaxLengthValidatorTest.php b/tests/Symfony/Tests/Component/Validator/Constraints/MaxLengthValidatorTest.php
index 57fcf758887f..2be5b4fb6a14 100644
--- a/tests/Symfony/Tests/Component/Validator/Constraints/MaxLengthValidatorTest.php
+++ b/tests/Symfony/Tests/Component/Validator/Constraints/MaxLengthValidatorTest.php
@@ -16,44 +16,60 @@
 
 class MaxLengthValidatorTest extends \PHPUnit_Framework_TestCase
 {
+    protected $context;
     protected $validator;
 
     protected function setUp()
     {
+        $this->context = $this->getMock('Symfony\Component\Validator\ExecutionContext', array(), array(), '', false);
         $this->validator = new MaxLengthValidator();
+        $this->validator->initialize($this->context);
     }
 
     protected function tearDown()
     {
+        $this->context = null;
         $this->validator = null;
     }
 
     public function testNullIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid(null, new MaxLength(array('limit' => 5))));
     }
 
     public function testEmptyStringIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid('', new MaxLength(array('limit' => 5))));
     }
 
+    /**
+     * @expectedException Symfony\Component\Validator\Exception\UnexpectedTypeException
+     */
     public function testExpectsStringCompatibleType()
     {
-        $this->setExpectedException('Symfony\Component\Validator\Exception\UnexpectedTypeException');
-
         $this->validator->isValid(new \stdClass(), new MaxLength(array('limit' => 5)));
     }
 
     /**
      * @dataProvider getValidValues
      */
-    public function testValidValues($value, $skip = false)
+    public function testValidValues($value, $mbOnly = false)
     {
-        if (!$skip) {
-            $constraint = new MaxLength(array('limit' => 5));
-            $this->assertTrue($this->validator->isValid($value, $constraint));
+        if ($mbOnly && !function_exists('mb_strlen')) {
+            return $this->markTestSkipped('mb_strlen does not exist');
         }
+
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
+        $constraint = new MaxLength(array('limit' => 5));
+        $this->assertTrue($this->validator->isValid($value, $constraint));
     }
 
     public function getValidValues()
@@ -61,20 +77,33 @@ public function getValidValues()
         return array(
             array(12345),
             array('12345'),
-            array('üüüüü', !function_exists('mb_strlen')),
-            array('ééééé', !function_exists('mb_strlen')),
+            array('üüüüü', true),
+            array('ééééé', true),
         );
     }
 
     /**
      * @dataProvider getInvalidValues
      */
-    public function testInvalidValues($value, $skip = false)
+    public function testInvalidValues($value, $mbOnly = false)
     {
-        if (!$skip) {
-            $constraint = new MaxLength(array('limit' => 5));
-            $this->assertFalse($this->validator->isValid($value, $constraint));
+        if ($mbOnly && !function_exists('mb_strlen')) {
+            return $this->markTestSkipped('mb_strlen does not exist');
         }
+
+        $constraint = new MaxLength(array(
+            'limit' => 5,
+            'message' => 'myMessage'
+        ));
+
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ value }}' => $value,
+                '{{ limit }}' => 5,
+            ));
+
+        $this->assertFalse($this->validator->isValid($value, $constraint));
     }
 
     public function getInvalidValues()
@@ -82,26 +111,11 @@ public function getInvalidValues()
         return array(
             array(123456),
             array('123456'),
-            array('üüüüüü', !function_exists('mb_strlen')),
-            array('éééééé', !function_exists('mb_strlen')),
+            array('üüüüüü', true),
+            array('éééééé', true),
         );
     }
 
-    public function testMessageIsSet()
-    {
-        $constraint = new MaxLength(array(
-            'limit' => 5,
-            'message' => 'myMessage'
-        ));
-
-        $this->assertFalse($this->validator->isValid('123456', $constraint));
-        $this->assertEquals($this->validator->getMessageTemplate(), 'myMessage');
-        $this->assertEquals($this->validator->getMessageParameters(), array(
-            '{{ value }}' => '123456',
-            '{{ limit }}' => 5,
-        ));
-    }
-
     public function testConstraintGetDefaultOption()
     {
         $constraint = new MaxLength(array(
diff --git a/tests/Symfony/Tests/Component/Validator/Constraints/MaxValidatorTest.php b/tests/Symfony/Tests/Component/Validator/Constraints/MaxValidatorTest.php
index 4d05ee79b02e..04304cb65bf5 100644
--- a/tests/Symfony/Tests/Component/Validator/Constraints/MaxValidatorTest.php
+++ b/tests/Symfony/Tests/Component/Validator/Constraints/MaxValidatorTest.php
@@ -16,20 +16,27 @@
 
 class MaxValidatorTest extends \PHPUnit_Framework_TestCase
 {
+    protected $context;
     protected $validator;
 
     protected function setUp()
     {
+        $this->context = $this->getMock('Symfony\Component\Validator\ExecutionContext', array(), array(), '', false);
         $this->validator = new MaxValidator();
+        $this->validator->initialize($this->context);
     }
 
     protected function tearDown()
     {
+        $this->context = null;
         $this->validator = null;
     }
 
     public function testNullIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid(null, new Max(array('limit' => 10))));
     }
 
@@ -38,6 +45,9 @@ public function testNullIsValid()
      */
     public function testValidValues($value)
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $constraint = new Max(array('limit' => 10));
         $this->assertTrue($this->validator->isValid($value, $constraint));
     }
@@ -57,7 +67,19 @@ public function getValidValues()
      */
     public function testInvalidValues($value)
     {
-        $constraint = new Max(array('limit' => 10));
+        $constraint = new Max(array(
+            'limit' => 10,
+            'message' => 'myMessage',
+            'invalidMessage' => 'myMessage'
+        ));
+
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ value }}' => $value,
+                '{{ limit }}' => 10,
+            ));
+
         $this->assertFalse($this->validator->isValid($value, $constraint));
     }
 
@@ -70,21 +92,6 @@ public function getInvalidValues()
         );
     }
 
-    public function testMessageIsSet()
-    {
-        $constraint = new Max(array(
-            'limit' => 10,
-            'message' => 'myMessage'
-        ));
-
-        $this->assertFalse($this->validator->isValid(11, $constraint));
-        $this->assertEquals($this->validator->getMessageTemplate(), 'myMessage');
-        $this->assertEquals($this->validator->getMessageParameters(), array(
-            '{{ value }}' => 11,
-            '{{ limit }}' => 10,
-        ));
-    }
-
     public function testConstraintGetDefaultOption()
     {
         $constraint = new Max(array(
diff --git a/tests/Symfony/Tests/Component/Validator/Constraints/MinLengthValidatorTest.php b/tests/Symfony/Tests/Component/Validator/Constraints/MinLengthValidatorTest.php
index 6cfa963dc28d..43066704d886 100644
--- a/tests/Symfony/Tests/Component/Validator/Constraints/MinLengthValidatorTest.php
+++ b/tests/Symfony/Tests/Component/Validator/Constraints/MinLengthValidatorTest.php
@@ -16,44 +16,60 @@
 
 class MinLengthValidatorTest extends \PHPUnit_Framework_TestCase
 {
+    protected $context;
     protected $validator;
 
     protected function setUp()
     {
+        $this->context = $this->getMock('Symfony\Component\Validator\ExecutionContext', array(), array(), '', false);
         $this->validator = new MinLengthValidator();
+        $this->validator->initialize($this->context);
     }
 
     protected function tearDown()
     {
+        $this->context = null;
         $this->validator = null;
     }
 
     public function testNullIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid(null, new MinLength(array('limit' => 6))));
     }
 
     public function testEmptyStringIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid('', new MinLength(array('limit' => 6))));
     }
 
+    /**
+     * @expectedException Symfony\Component\Validator\Exception\UnexpectedTypeException
+     */
     public function testExpectsStringCompatibleType()
     {
-        $this->setExpectedException('Symfony\Component\Validator\Exception\UnexpectedTypeException');
-
         $this->validator->isValid(new \stdClass(), new MinLength(array('limit' => 5)));
     }
 
     /**
      * @dataProvider getValidValues
      */
-    public function testValidValues($value, $skip = false)
+    public function testValidValues($value, $mbOnly = false)
     {
-        if (!$skip) {
-            $constraint = new MinLength(array('limit' => 6));
-            $this->assertTrue($this->validator->isValid($value, $constraint));
+        if ($mbOnly && !function_exists('mb_strlen')) {
+            return $this->markTestSkipped('mb_strlen does not exist');
         }
+
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
+        $constraint = new MinLength(array('limit' => 6));
+        $this->assertTrue($this->validator->isValid($value, $constraint));
     }
 
     public function getValidValues()
@@ -61,45 +77,43 @@ public function getValidValues()
         return array(
             array(123456),
             array('123456'),
-            array('üüüüüü', !function_exists('mb_strlen')),
-            array('éééééé', !function_exists('mb_strlen')),
+            array('üüüüüü', true),
+            array('éééééé', true),
         );
     }
 
     /**
      * @dataProvider getInvalidValues
      */
-    public function testInvalidValues($value, $skip = false)
+    public function testInvalidValues($value, $mbOnly = false)
     {
-        if (!$skip) {
-            $constraint = new MinLength(array('limit' => 6));
-            $this->assertFalse($this->validator->isValid($value, $constraint));
+        if ($mbOnly && !function_exists('mb_strlen')) {
+            return $this->markTestSkipped('mb_strlen does not exist');
         }
-    }
-
-    public function getInvalidValues()
-    {
-        return array(
-            array(12345),
-            array('12345'),
-            array('üüüüü', !function_exists('mb_strlen')),
-            array('ééééé', !function_exists('mb_strlen')),
-        );
-    }
 
-    public function testMessageIsSet()
-    {
         $constraint = new MinLength(array(
             'limit' => 5,
             'message' => 'myMessage'
+        ));
+
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ value }}' => $value,
+                '{{ limit }}' => 5,
             ));
 
-        $this->assertFalse($this->validator->isValid('1234', $constraint));
-        $this->assertEquals($this->validator->getMessageTemplate(), 'myMessage');
-        $this->assertEquals($this->validator->getMessageParameters(), array(
-            '{{ value }}' => '1234',
-            '{{ limit }}' => 5,
-        ));
+        $this->assertFalse($this->validator->isValid($value, $constraint));
+    }
+
+    public function getInvalidValues()
+    {
+        return array(
+            array(1234),
+            array('1234'),
+            array('üüüü', true),
+            array('éééé', true),
+        );
     }
 
     public function testConstraintGetDefaultOption()
diff --git a/tests/Symfony/Tests/Component/Validator/Constraints/MinValidatorTest.php b/tests/Symfony/Tests/Component/Validator/Constraints/MinValidatorTest.php
index 8306ce43ca59..2e93627fbd5c 100644
--- a/tests/Symfony/Tests/Component/Validator/Constraints/MinValidatorTest.php
+++ b/tests/Symfony/Tests/Component/Validator/Constraints/MinValidatorTest.php
@@ -16,15 +16,21 @@
 
 class MinValidatorTest extends \PHPUnit_Framework_TestCase
 {
+    protected $context;
     protected $validator;
 
     protected function setUp()
     {
+        $this->context = $this->getMock('Symfony\Component\Validator\ExecutionContext', array(), array(), '', false);
         $this->validator = new MinValidator();
+        $this->validator->initialize($this->context);
     }
 
     public function testNullIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid(null, new Min(array('limit' => 10))));
     }
 
@@ -33,6 +39,9 @@ public function testNullIsValid()
      */
     public function testValidValues($value)
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $constraint = new Min(array('limit' => 10));
         $this->assertTrue($this->validator->isValid($value, $constraint));
     }
@@ -52,7 +61,19 @@ public function getValidValues()
      */
     public function testInvalidValues($value)
     {
-        $constraint = new Min(array('limit' => 10));
+        $constraint = new Min(array(
+            'limit' => 10,
+            'message' => 'myMessage',
+            'invalidMessage' => 'myMessage'
+        ));
+
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ value }}' => $value,
+                '{{ limit }}' => 10,
+            ));
+
         $this->assertFalse($this->validator->isValid($value, $constraint));
     }
 
@@ -65,21 +86,6 @@ public function getInvalidValues()
         );
     }
 
-    public function testMessageIsSet()
-    {
-        $constraint = new Min(array(
-            'limit' => 10,
-            'message' => 'myMessage'
-        ));
-
-        $this->assertFalse($this->validator->isValid(9, $constraint));
-        $this->assertEquals($this->validator->getMessageTemplate(), 'myMessage');
-        $this->assertEquals($this->validator->getMessageParameters(), array(
-            '{{ value }}' => 9,
-            '{{ limit }}' => 10,
-        ));
-    }
-
     public function testConstraintGetDefaultOption()
     {
         $constraint = new Min(array(
diff --git a/tests/Symfony/Tests/Component/Validator/Constraints/NotBlankValidatorTest.php b/tests/Symfony/Tests/Component/Validator/Constraints/NotBlankValidatorTest.php
index 27dbc43a13d2..e9c46758dd91 100644
--- a/tests/Symfony/Tests/Component/Validator/Constraints/NotBlankValidatorTest.php
+++ b/tests/Symfony/Tests/Component/Validator/Constraints/NotBlankValidatorTest.php
@@ -16,15 +16,19 @@
 
 class NotBlankValidatorTest extends \PHPUnit_Framework_TestCase
 {
+    protected $context;
     protected $validator;
 
     protected function setUp()
     {
+        $this->context = $this->getMock('Symfony\Component\Validator\ExecutionContext', array(), array(), '', false);
         $this->validator = new NotBlankValidator();
+        $this->validator->initialize($this->context);
     }
 
     protected function tearDown()
     {
+        $this->context = null;
         $this->validator = null;
     }
 
@@ -33,6 +37,9 @@ protected function tearDown()
      */
     public function testValidValues($date)
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid($date, new NotBlank()));
     }
 
@@ -49,33 +56,54 @@ public function getValidValues()
 
     public function testNullIsInvalid()
     {
-        $this->assertFalse($this->validator->isValid(null, new NotBlank()));
+        $constraint = new NotBlank(array(
+            'message' => 'myMessage'
+        ));
+
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage');
+
+        $this->assertFalse($this->validator->isValid(null, $constraint));
     }
 
     public function testBlankIsInvalid()
     {
-        $this->assertFalse($this->validator->isValid('', new NotBlank()));
+        $constraint = new NotBlank(array(
+            'message' => 'myMessage'
+        ));
+
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage');
+
+        $this->assertFalse($this->validator->isValid('', $constraint));
     }
 
     public function testFalseIsInvalid()
     {
-        $this->assertFalse($this->validator->isValid(false, new NotBlank()));
-    }
+        $constraint = new NotBlank(array(
+            'message' => 'myMessage'
+        ));
 
-    public function testEmptyArrayIsInvalid()
-    {
-        $this->assertFalse($this->validator->isValid(array(), new NotBlank()));
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage');
+
+        $this->assertFalse($this->validator->isValid(false, $constraint));
     }
 
-    public function testSetMessage()
+    public function testEmptyArrayIsInvalid()
     {
         $constraint = new NotBlank(array(
             'message' => 'myMessage'
         ));
 
-        $this->assertFalse($this->validator->isValid('', $constraint));
-        $this->assertEquals($this->validator->getMessageTemplate(), 'myMessage');
-        $this->assertEquals($this->validator->getMessageParameters(), array());
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage');
+
+        $this->assertFalse($this->validator->isValid(array(), $constraint));
     }
 }
 
diff --git a/tests/Symfony/Tests/Component/Validator/Constraints/NotNullValidatorTest.php b/tests/Symfony/Tests/Component/Validator/Constraints/NotNullValidatorTest.php
index 0f46e1110962..6643ce50655f 100644
--- a/tests/Symfony/Tests/Component/Validator/Constraints/NotNullValidatorTest.php
+++ b/tests/Symfony/Tests/Component/Validator/Constraints/NotNullValidatorTest.php
@@ -16,15 +16,19 @@
 
 class NotNullValidatorTest extends \PHPUnit_Framework_TestCase
 {
+    protected $context;
     protected $validator;
 
     protected function setUp()
     {
+        $this->context = $this->getMock('Symfony\Component\Validator\ExecutionContext', array(), array(), '', false);
         $this->validator = new NotNullValidator();
+        $this->validator->initialize($this->context);
     }
 
     protected function tearDown()
     {
+        $this->context = null;
         $this->validator = null;
     }
 
@@ -33,6 +37,9 @@ protected function tearDown()
      */
     public function testValidValues($value)
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid($value, new NotNull()));
     }
 
@@ -52,8 +59,11 @@ public function testNullIsInvalid()
             'message' => 'myMessage'
         ));
 
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+            ));
+
         $this->assertFalse($this->validator->isValid(null, $constraint));
-        $this->assertEquals($this->validator->getMessageTemplate(), 'myMessage');
-        $this->assertEquals($this->validator->getMessageParameters(), array());
     }
 }
diff --git a/tests/Symfony/Tests/Component/Validator/Constraints/NullValidatorTest.php b/tests/Symfony/Tests/Component/Validator/Constraints/NullValidatorTest.php
index ebb3a61e9e26..4fd5d7038805 100644
--- a/tests/Symfony/Tests/Component/Validator/Constraints/NullValidatorTest.php
+++ b/tests/Symfony/Tests/Component/Validator/Constraints/NullValidatorTest.php
@@ -16,20 +16,27 @@
 
 class NullValidatorTest extends \PHPUnit_Framework_TestCase
 {
+    protected $context;
     protected $validator;
 
     protected function setUp()
     {
+        $this->context = $this->getMock('Symfony\Component\Validator\ExecutionContext', array(), array(), '', false);
         $this->validator = new NullValidator();
+        $this->validator->initialize($this->context);
     }
 
     protected function tearDown()
     {
+        $this->context = null;
         $this->validator = null;
     }
 
     public function testNullIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid(null, new Null()));
     }
 
@@ -38,7 +45,17 @@ public function testNullIsValid()
      */
     public function testInvalidValues($value)
     {
-        $this->assertFalse($this->validator->isValid($value, new Null()));
+        $constraint = new Null(array(
+            'message' => 'myMessage'
+        ));
+
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ value }}' => $value,
+            ));
+
+        $this->assertFalse($this->validator->isValid($value, $constraint));
     }
 
     public function getInvalidValues()
@@ -50,17 +67,4 @@ public function getInvalidValues()
             array(''),
         );
     }
-
-    public function testSetMessage()
-    {
-        $constraint = new Null(array(
-            'message' => 'myMessage'
-        ));
-
-        $this->assertFalse($this->validator->isValid(1, $constraint));
-        $this->assertEquals($this->validator->getMessageTemplate(), 'myMessage');
-        $this->assertEquals($this->validator->getMessageParameters(), array(
-            '{{ value }}' => 1,
-        ));
-    }
 }
diff --git a/tests/Symfony/Tests/Component/Validator/Constraints/RegexValidatorTest.php b/tests/Symfony/Tests/Component/Validator/Constraints/RegexValidatorTest.php
index d87e793167d7..e157ad3e676e 100644
--- a/tests/Symfony/Tests/Component/Validator/Constraints/RegexValidatorTest.php
+++ b/tests/Symfony/Tests/Component/Validator/Constraints/RegexValidatorTest.php
@@ -16,32 +16,43 @@
 
 class RegexValidatorTest extends \PHPUnit_Framework_TestCase
 {
+    protected $context;
     protected $validator;
 
     protected function setUp()
     {
+        $this->context = $this->getMock('Symfony\Component\Validator\ExecutionContext', array(), array(), '', false);
         $this->validator = new RegexValidator();
+        $this->validator->initialize($this->context);
     }
 
     protected function tearDown()
     {
+        $this->context = null;
         $this->validator = null;
     }
 
     public function testNullIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid(null, new Regex(array('pattern' => '/^[0-9]+$/'))));
     }
 
     public function testEmptyStringIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid('', new Regex(array('pattern' => '/^[0-9]+$/'))));
     }
 
+    /**
+     * @expectedException Symfony\Component\Validator\Exception\UnexpectedTypeException
+     */
     public function testExpectsStringCompatibleType()
     {
-        $this->setExpectedException('Symfony\Component\Validator\Exception\UnexpectedTypeException');
-
         $this->validator->isValid(new \stdClass(), new Regex(array('pattern' => '/^[0-9]+$/')));
     }
 
@@ -50,6 +61,9 @@ public function testExpectsStringCompatibleType()
      */
     public function testValidValues($value)
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $constraint = new Regex(array('pattern' => '/^[0-9]+$/'));
         $this->assertTrue($this->validator->isValid($value, $constraint));
     }
@@ -69,7 +83,17 @@ public function getValidValues()
      */
     public function testInvalidValues($value)
     {
-        $constraint = new Regex(array('pattern' => '/^[0-9]+$/'));
+        $constraint = new Regex(array(
+            'pattern' => '/^[0-9]+$/',
+            'message' => 'myMessage'
+        ));
+
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ value }}' => $value,
+            ));
+
         $this->assertFalse($this->validator->isValid($value, $constraint));
     }
 
@@ -81,20 +105,6 @@ public function getInvalidValues()
         );
     }
 
-    public function testMessageIsSet()
-    {
-        $constraint = new Regex(array(
-            'pattern' => '/^[0-9]+$/',
-            'message' => 'myMessage'
-        ));
-
-        $this->assertFalse($this->validator->isValid('foobar', $constraint));
-        $this->assertEquals($this->validator->getMessageTemplate(), 'myMessage');
-        $this->assertEquals($this->validator->getMessageParameters(), array(
-            '{{ value }}' => 'foobar',
-        ));
-    }
-
     public function testConstraintGetDefaultOption()
     {
         $constraint = new Regex(array(
diff --git a/tests/Symfony/Tests/Component/Validator/Constraints/SizeLengthValidatorTest.php b/tests/Symfony/Tests/Component/Validator/Constraints/SizeLengthValidatorTest.php
index e2a1ee2cabee..610bf917665a 100644
--- a/tests/Symfony/Tests/Component/Validator/Constraints/SizeLengthValidatorTest.php
+++ b/tests/Symfony/Tests/Component/Validator/Constraints/SizeLengthValidatorTest.php
@@ -2,12 +2,12 @@
 
 /*
  * This file is part of the Symfony package.
- *
- * (c) Fabien Potencier <fabien@symfony.com>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
+*
+* (c) Fabien Potencier <fabien@symfony.com>
+*
+* For the full copyright and license information, please view the LICENSE
+* file that was distributed with this source code.
+*/
 
 namespace Symfony\Tests\Component\Validator\Constraints;
 
@@ -16,44 +16,60 @@
 
 class SizeLengthValidatorTest extends \PHPUnit_Framework_TestCase
 {
+    protected $context;
     protected $validator;
 
     protected function setUp()
     {
+        $this->context = $this->getMock('Symfony\Component\Validator\ExecutionContext', array(), array(), '', false);
         $this->validator = new SizeLengthValidator();
+        $this->validator->initialize($this->context);
     }
 
     protected function tearDown()
     {
+        $this->context = null;
         $this->validator = null;
     }
 
     public function testNullIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid(null, new SizeLength(array('min' => 6, 'max' => 10))));
     }
 
     public function testEmptyStringIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid('', new SizeLength(array('min' => 6, 'max' => 10))));
     }
 
+    /**
+     * @expectedException Symfony\Component\Validator\Exception\UnexpectedTypeException
+     */
     public function testExpectsStringCompatibleType()
     {
-        $this->setExpectedException('Symfony\Component\Validator\Exception\UnexpectedTypeException');
-
         $this->validator->isValid(new \stdClass(), new SizeLength(array('min' => 6, 'max' => 10)));
     }
 
     /**
      * @dataProvider getValidValues
      */
-    public function testValidValues($value, $skip = false)
+    public function testValidValues($value, $mbOnly = false)
     {
-        if (!$skip) {
-            $constraint = new SizeLength(array('min' => 6, 'max' => 10));
-            $this->assertTrue($this->validator->isValid($value, $constraint));
+        if ($mbOnly && !function_exists('mb_strlen')) {
+            return $this->markTestSkipped('mb_strlen does not exist');
         }
+
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
+        $constraint = new SizeLength(array('min' => 6, 'max' => 10));
+        $this->assertTrue($this->validator->isValid($value, $constraint));
     }
 
     public function getValidValues()
@@ -63,22 +79,27 @@ public function getValidValues()
             array(1234567890),
             array('123456'),
             array('1234567890'),
-            array('üüüüüü', !function_exists('mb_strlen')),
-            array('üüüüüüüüüü', !function_exists('mb_strlen')),
-            array('éééééé', !function_exists('mb_strlen')),
-            array('éééééééééé', !function_exists('mb_strlen')),
+            array('üüüüüü', true),
+            array('üüüüüüüüüü', true),
+            array('éééééé', true),
+            array('éééééééééé', true),
         );
     }
 
     /**
      * @dataProvider getInvalidValues
      */
-    public function testInvalidValues($value, $skip = false)
+    public function testInvalidValues($value, $mbOnly = false)
     {
-        if (!$skip) {
-            $constraint = new SizeLength(array('min' => 6, 'max' => 10));
-            $this->assertFalse($this->validator->isValid($value, $constraint));
+        if ($mbOnly && !function_exists('mb_strlen')) {
+            return $this->markTestSkipped('mb_strlen does not exist');
         }
+
+        $this->context->expects($this->once())
+            ->method('addViolation');
+
+        $constraint = new SizeLength(array('min' => 6, 'max' => 10));
+        $this->assertFalse($this->validator->isValid($value, $constraint));
     }
 
     public function getInvalidValues()
@@ -88,49 +109,64 @@ public function getInvalidValues()
             array(12345678901),
             array('12345'),
             array('12345678901'),
-            array('üüüüü', !function_exists('mb_strlen')),
-            array('üüüüüüüüüüü', !function_exists('mb_strlen')),
-            array('ééééé', !function_exists('mb_strlen')),
-            array('ééééééééééé', !function_exists('mb_strlen')),
+            array('üüüüü', true),
+            array('üüüüüüüüüüü', true),
+            array('ééééé', true),
+            array('ééééééééééé', true),
         );
     }
 
-    public function testMessageIsSet()
+    public function testMinMessageIsSet()
     {
         $constraint = new SizeLength(array(
             'min' => 5,
             'max' => 10,
-            'minMessage' => 'myMinMessage',
-            'maxMessage' => 'myMaxMessage',
+            'minMessage' => 'myMessage',
         ));
 
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ value }}' => '1234',
+                '{{ limit }}' => 5,
+            ));
+
         $this->assertFalse($this->validator->isValid('1234', $constraint));
-        $this->assertEquals('myMinMessage', $this->validator->getMessageTemplate());
-        $this->assertEquals(array(
-            '{{ value }}' => '1234',
-            '{{ limit }}' => 5,
-        ), $this->validator->getMessageParameters());
+    }
+
+    public function testMaxMessageIsSet()
+    {
+        $constraint = new SizeLength(array(
+            'min' => 5,
+            'max' => 10,
+            'maxMessage' => 'myMessage',
+        ));
+
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ value }}' => '12345678901',
+                '{{ limit }}' => 10,
+            ));
 
         $this->assertFalse($this->validator->isValid('12345678901', $constraint));
-        $this->assertEquals('myMaxMessage', $this->validator->getMessageTemplate());
-        $this->assertEquals(array(
-            '{{ value }}' => '12345678901',
-            '{{ limit }}' => 10,
-        ), $this->validator->getMessageParameters());
     }
 
-    public function testExactErrorMessage()
+    public function testExactMessageIsSet()
     {
         $constraint = new SizeLength(array(
             'min' => 5,
             'max' => 5,
+            'exactMessage' => 'myMessage',
         ));
 
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ value }}' => '1234',
+                '{{ limit }}' => 5,
+            ));
+
         $this->assertFalse($this->validator->isValid('1234', $constraint));
-        $this->assertEquals('This value should have exactly {{ limit }} characters', $this->validator->getMessageTemplate());
-        $this->assertEquals(array(
-            '{{ value }}' => '1234',
-            '{{ limit }}' => 5,
-        ), $this->validator->getMessageParameters());
     }
 }
diff --git a/tests/Symfony/Tests/Component/Validator/Constraints/SizeValidatorTest.php b/tests/Symfony/Tests/Component/Validator/Constraints/SizeValidatorTest.php
index 49c39f37f4cf..48a448f17fbe 100644
--- a/tests/Symfony/Tests/Component/Validator/Constraints/SizeValidatorTest.php
+++ b/tests/Symfony/Tests/Component/Validator/Constraints/SizeValidatorTest.php
@@ -16,15 +16,21 @@
 
 class SizeValidatorTest extends \PHPUnit_Framework_TestCase
 {
+    protected $context;
     protected $validator;
 
     protected function setUp()
     {
+        $this->context = $this->getMock('Symfony\Component\Validator\ExecutionContext', array(), array(), '', false);
         $this->validator = new SizeValidator();
+        $this->validator->initialize($this->context);
     }
 
     public function testNullIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid(null, new Size(array('min' => 10, 'max' => 20))));
     }
 
@@ -33,6 +39,9 @@ public function testNullIsValid()
      */
     public function testValidValues($value)
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $constraint = new Size(array('min' => 10, 'max' => 20));
         $this->assertTrue($this->validator->isValid($value, $constraint));
     }
@@ -56,6 +65,9 @@ public function getValidValues()
      */
     public function testInvalidValues($value)
     {
+        $this->context->expects($this->once())
+            ->method('addViolation');
+
         $constraint = new Size(array('min' => 10, 'max' => 20));
         $this->assertFalse($this->validator->isValid($value, $constraint));
     }
@@ -71,27 +83,39 @@ public function getInvalidValues()
         );
     }
 
-    public function testMessageIsSet()
+    public function testMinMessageIsSet()
     {
         $constraint = new Size(array(
             'min' => 10,
             'max' => 20,
-            'minMessage' => 'myMinMessage',
-            'maxMessage' => 'myMaxMessage',
+            'minMessage' => 'myMessage',
         ));
 
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ value }}' => 9,
+                '{{ limit }}' => 10,
+            ));
+
         $this->assertFalse($this->validator->isValid(9, $constraint));
-        $this->assertEquals('myMinMessage', $this->validator->getMessageTemplate());
-        $this->assertEquals(array(
-            '{{ value }}' => 9,
-            '{{ limit }}' => 10,
-        ), $this->validator->getMessageParameters());
+    }
+
+    public function testMaxMessageIsSet()
+    {
+        $constraint = new Size(array(
+            'min' => 10,
+            'max' => 20,
+            'maxMessage' => 'myMessage',
+        ));
+
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ value }}' => 21,
+                '{{ limit }}' => 20,
+            ));
 
         $this->assertFalse($this->validator->isValid(21, $constraint));
-        $this->assertEquals('myMaxMessage', $this->validator->getMessageTemplate());
-        $this->assertEquals(array(
-            '{{ value }}' => 21,
-            '{{ limit }}' => 20,
-        ), $this->validator->getMessageParameters());
     }
 }
diff --git a/tests/Symfony/Tests/Component/Validator/Constraints/TimeValidatorTest.php b/tests/Symfony/Tests/Component/Validator/Constraints/TimeValidatorTest.php
index 77089419c801..a97ec0f5d694 100644
--- a/tests/Symfony/Tests/Component/Validator/Constraints/TimeValidatorTest.php
+++ b/tests/Symfony/Tests/Component/Validator/Constraints/TimeValidatorTest.php
@@ -16,37 +16,51 @@
 
 class TimeValidatorTest extends \PHPUnit_Framework_TestCase
 {
+    protected $context;
     protected $validator;
 
     protected function setUp()
     {
+        $this->context = $this->getMock('Symfony\Component\Validator\ExecutionContext', array(), array(), '', false);
         $this->validator = new TimeValidator();
+        $this->validator->initialize($this->context);
     }
 
     protected function tearDown()
     {
+        $this->context = null;
         $this->validator = null;
     }
 
     public function testNullIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid(null, new Time()));
     }
 
     public function testEmptyStringIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid('', new Time()));
     }
 
     public function testDateTimeClassIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid(new \DateTime(), new Time()));
     }
 
+    /**
+     * @expectedException Symfony\Component\Validator\Exception\UnexpectedTypeException
+     */
     public function testExpectsStringCompatibleType()
     {
-        $this->setExpectedException('Symfony\Component\Validator\Exception\UnexpectedTypeException');
-
         $this->validator->isValid(new \stdClass(), new Time());
     }
 
@@ -55,6 +69,9 @@ public function testExpectsStringCompatibleType()
      */
     public function testValidTimes($time)
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid($time, new Time()));
     }
 
@@ -72,7 +89,17 @@ public function getValidTimes()
      */
     public function testInvalidTimes($time)
     {
-        $this->assertFalse($this->validator->isValid($time, new Time()));
+        $constraint = new Time(array(
+            'message' => 'myMessage'
+        ));
+
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ value }}' => $time,
+            ));
+
+        $this->assertFalse($this->validator->isValid($time, $constraint));
     }
 
     public function getInvalidTimes()
@@ -87,17 +114,4 @@ public function getInvalidTimes()
             array('00:00:60'),
         );
     }
-
-    public function testMessageIsSet()
-    {
-        $constraint = new Time(array(
-            'message' => 'myMessage'
-        ));
-
-        $this->assertFalse($this->validator->isValid('foobar', $constraint));
-        $this->assertEquals($this->validator->getMessageTemplate(), 'myMessage');
-        $this->assertEquals($this->validator->getMessageParameters(), array(
-            '{{ value }}' => 'foobar',
-        ));
-    }
 }
diff --git a/tests/Symfony/Tests/Component/Validator/Constraints/AssertTrueValidatorTest.php b/tests/Symfony/Tests/Component/Validator/Constraints/TrueValidatorTest.php
similarity index 67%
rename from tests/Symfony/Tests/Component/Validator/Constraints/AssertTrueValidatorTest.php
rename to tests/Symfony/Tests/Component/Validator/Constraints/TrueValidatorTest.php
index 504566744913..d512aea88fce 100644
--- a/tests/Symfony/Tests/Component/Validator/Constraints/AssertTrueValidatorTest.php
+++ b/tests/Symfony/Tests/Component/Validator/Constraints/TrueValidatorTest.php
@@ -16,25 +16,35 @@
 
 class TrueValidatorTest extends \PHPUnit_Framework_TestCase
 {
+    protected $context;
     protected $validator;
 
     protected function setUp()
     {
+        $this->context = $this->getMock('Symfony\Component\Validator\ExecutionContext', array(), array(), '', false);
         $this->validator = new TrueValidator();
+        $this->validator->initialize($this->context);
     }
 
     protected function tearDown()
     {
+        $this->context = null;
         $this->validator = null;
     }
 
     public function testNullIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid(null, new True()));
     }
 
     public function testTrueIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid(true, new True()));
     }
 
@@ -44,8 +54,11 @@ public function testFalseIsInvalid()
             'message' => 'myMessage'
         ));
 
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+            ));
+
         $this->assertFalse($this->validator->isValid(false, $constraint));
-        $this->assertEquals($this->validator->getMessageTemplate(), 'myMessage');
-        $this->assertEquals($this->validator->getMessageParameters(), array());
     }
 }
diff --git a/tests/Symfony/Tests/Component/Validator/Constraints/AssertTypeValidatorTest.php b/tests/Symfony/Tests/Component/Validator/Constraints/TypeValidatorTest.php
similarity index 60%
rename from tests/Symfony/Tests/Component/Validator/Constraints/AssertTypeValidatorTest.php
rename to tests/Symfony/Tests/Component/Validator/Constraints/TypeValidatorTest.php
index 193a327c980a..9e4d9641950c 100644
--- a/tests/Symfony/Tests/Component/Validator/Constraints/AssertTypeValidatorTest.php
+++ b/tests/Symfony/Tests/Component/Validator/Constraints/TypeValidatorTest.php
@@ -19,25 +19,35 @@ class TypeValidatorTest extends \PHPUnit_Framework_TestCase
 {
     protected static $file;
 
+    protected $context;
     protected $validator;
 
     protected function setUp()
     {
+        $this->context = $this->getMock('Symfony\Component\Validator\ExecutionContext', array(), array(), '', false);
         $this->validator = new TypeValidator();
+        $this->validator->initialize($this->context);
     }
 
     protected function tearDown()
     {
+        $this->context = null;
         $this->validator = null;
     }
 
     public function testNullIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid(null, new Type(array('type' => 'integer'))));
     }
 
     public function testEmptyIsValidIfString()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid('', new Type(array('type' => 'string'))));
     }
 
@@ -51,6 +61,9 @@ public function testEmptyIsInvalidIfNoString()
      */
     public function testValidValues($value, $type)
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $constraint = new Type(array('type' => $type));
 
         $this->assertTrue($this->validator->isValid($value, $constraint));
@@ -96,27 +109,21 @@ public function getValidValues()
     /**
      * @dataProvider getInvalidValues
      */
-    public function testInvalidValues($value, $type)
+    public function testInvalidValues($value, $type, $valueAsString)
     {
-        $constraint = new Type(array('type' => $type));
+        $constraint = new Type(array(
+            'type' => $type,
+            'message' => 'myMessage'
+        ));
 
-        $this->assertFalse($this->validator->isValid($value, $constraint));
-    }
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ value }}' => $valueAsString,
+                '{{ type }}' => $type,
+            ));
 
-    public function testConstraintViolationCanHandleArrayValue()
-    {
-        $constraint = new Type(array('type' => 'string'));
-        $this->validator->isValid(array(0 => "Test"), $constraint);
-
-        $violation = new ConstraintViolation(
-            '{{ value }}',
-            $this->validator->getMessageParameters(),
-            '',
-            '',
-            ''
-        );
-
-        $this->assertEquals('Array', $violation->getMessage());
+        $this->assertFalse($this->validator->isValid($value, $constraint));
     }
 
     public function getInvalidValues()
@@ -125,52 +132,37 @@ public function getInvalidValues()
         $file = $this->createFile();
 
         return array(
-            array('foobar', 'numeric'),
-            array('foobar', 'boolean'),
-            array('0', 'integer'),
-            array('1.5', 'float'),
-            array(12345, 'string'),
-            array($object, 'boolean'),
-            array($object, 'numeric'),
-            array($object, 'integer'),
-            array($object, 'float'),
-            array($object, 'string'),
-            array($object, 'resource'),
-            array($file, 'boolean'),
-            array($file, 'numeric'),
-            array($file, 'integer'),
-            array($file, 'float'),
-            array($file, 'string'),
-            array($file, 'object'),
-            array('12a34', 'digit'),
-            array('1a#23', 'alnum'),
-            array('abcd1', 'alpha'),
-            array("\nabc", 'cntrl'),
-            array("abc\n", 'graph'),
-            array('abCDE', 'lower'),
-            array('ABcde', 'upper'),
-            array("\nabc", 'print'),
-            array('abc&$!', 'punct'),
-            array("\nabc", 'space'),
-            array('AR1012', 'xdigit'),
+            array('foobar', 'numeric', 'foobar'),
+            array('foobar', 'boolean', 'foobar'),
+            array('0', 'integer', '0'),
+            array('1.5', 'float', '1.5'),
+            array(12345, 'string', '12345'),
+            array($object, 'boolean', 'stdClass'),
+            array($object, 'numeric', 'stdClass'),
+            array($object, 'integer', 'stdClass'),
+            array($object, 'float', 'stdClass'),
+            array($object, 'string', 'stdClass'),
+            array($object, 'resource', 'stdClass'),
+            array($file, 'boolean', (string) $file),
+            array($file, 'numeric', (string) $file),
+            array($file, 'integer', (string) $file),
+            array($file, 'float', (string) $file),
+            array($file, 'string', (string) $file),
+            array($file, 'object', (string) $file),
+            array('12a34', 'digit', '12a34'),
+            array('1a#23', 'alnum', '1a#23'),
+            array('abcd1', 'alpha', 'abcd1'),
+            array("\nabc", 'cntrl', "\nabc"),
+            array("abc\n", 'graph', "abc\n"),
+            array('abCDE', 'lower', 'abCDE'),
+            array('ABcde', 'upper', 'ABcde'),
+            array("\nabc", 'print', "\nabc"),
+            array('abc&$!', 'punct', 'abc&$!'),
+            array("\nabc", 'space', "\nabc"),
+            array('AR1012', 'xdigit', 'AR1012'),
         );
     }
 
-    public function testMessageIsSet()
-    {
-        $constraint = new Type(array(
-            'type' => 'numeric',
-            'message' => 'myMessage'
-        ));
-
-        $this->assertFalse($this->validator->isValid('foobar', $constraint));
-        $this->assertEquals($this->validator->getMessageTemplate(), 'myMessage');
-        $this->assertEquals($this->validator->getMessageParameters(), array(
-            '{{ value }}' => 'foobar',
-            '{{ type }}' => 'numeric',
-        ));
-    }
-
     protected function createFile()
     {
         if (!self::$file) {
diff --git a/tests/Symfony/Tests/Component/Validator/Constraints/UrlValidatorTest.php b/tests/Symfony/Tests/Component/Validator/Constraints/UrlValidatorTest.php
index f0c809fb2c78..af44621baff5 100644
--- a/tests/Symfony/Tests/Component/Validator/Constraints/UrlValidatorTest.php
+++ b/tests/Symfony/Tests/Component/Validator/Constraints/UrlValidatorTest.php
@@ -16,32 +16,43 @@
 
 class UrlValidatorTest extends \PHPUnit_Framework_TestCase
 {
+    protected $context;
     protected $validator;
 
     protected function setUp()
     {
+        $this->context = $this->getMock('Symfony\Component\Validator\ExecutionContext', array(), array(), '', false);
         $this->validator = new UrlValidator();
+        $this->validator->initialize($this->context);
     }
 
     protected function tearDown()
     {
+        $this->context = null;
         $this->validator = null;
     }
 
     public function testNullIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid(null, new Url()));
     }
 
     public function testEmptyStringIsValid()
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid('', new Url()));
     }
 
+    /**
+     * @expectedException Symfony\Component\Validator\Exception\UnexpectedTypeException
+     */
     public function testExpectsStringCompatibleType()
     {
-        $this->setExpectedException('Symfony\Component\Validator\Exception\UnexpectedTypeException');
-
         $this->validator->isValid(new \stdClass(), new Url());
     }
 
@@ -50,6 +61,9 @@ public function testExpectsStringCompatibleType()
      */
     public function testValidUrls($url)
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $this->assertTrue($this->validator->isValid($url, new Url()));
     }
 
@@ -92,7 +106,17 @@ public function getValidUrls()
      */
     public function testInvalidUrls($url)
     {
-        $this->assertFalse($this->validator->isValid($url, new Url()));
+        $constraint = new Url(array(
+            'message' => 'myMessage'
+        ));
+
+        $this->context->expects($this->once())
+            ->method('addViolation')
+            ->with('myMessage', array(
+                '{{ value }}' => $url,
+            ));
+
+        $this->assertFalse($this->validator->isValid($url, $constraint));
     }
 
     public function getInvalidUrls()
@@ -118,6 +142,9 @@ public function getInvalidUrls()
      */
     public function testCustomProtocolIsValid($url)
     {
+        $this->context->expects($this->never())
+            ->method('addViolation');
+
         $constraint = new Url(array(
             'protocols' => array('ftp', 'file', 'git')
         ));
@@ -133,17 +160,4 @@ public function getValidCustomUrls()
             array('git://[::1]/'),
         );
     }
-
-    public function testMessageIsSet()
-    {
-        $constraint = new Url(array(
-            'message' => 'myMessage'
-        ));
-
-        $this->assertFalse($this->validator->isValid('foobar', $constraint));
-        $this->assertEquals($this->validator->getMessageTemplate(), 'myMessage');
-        $this->assertEquals($this->validator->getMessageParameters(), array(
-            '{{ value }}' => 'foobar',
-        ));
-    }
 }
diff --git a/tests/Symfony/Tests/Component/Validator/ExecutionContextTest.php b/tests/Symfony/Tests/Component/Validator/ExecutionContextTest.php
index 5b15a4d4c98e..266a7aa7599d 100644
--- a/tests/Symfony/Tests/Component/Validator/ExecutionContextTest.php
+++ b/tests/Symfony/Tests/Component/Validator/ExecutionContextTest.php
@@ -105,10 +105,10 @@ public function testAddViolationUsesPassedNullValue()
         )), $this->context->getViolations());
     }
 
-    public function testAddViolationAt()
+    public function testAddViolationAtPath()
     {
         // override preconfigured property path
-        $this->context->addViolationAt('bar.baz', 'Error', array('foo' => 'bar'), 'invalid');
+        $this->context->addViolationAtPath('bar.baz', 'Error', array('foo' => 'bar'), 'invalid');
 
         $this->assertEquals(new ConstraintViolationList(array(
             new ConstraintViolation(
@@ -121,9 +121,9 @@ public function testAddViolationAt()
         )), $this->context->getViolations());
     }
 
-    public function testAddViolationAtUsesPreconfiguredValueIfNotPassed()
+    public function testAddViolationAtPathUsesPreconfiguredValueIfNotPassed()
     {
-        $this->context->addViolationAt('bar.baz', 'Error');
+        $this->context->addViolationAtPath('bar.baz', 'Error');
 
         $this->assertEquals(new ConstraintViolationList(array(
             new ConstraintViolation(
@@ -136,10 +136,10 @@ public function testAddViolationAtUsesPreconfiguredValueIfNotPassed()
         )), $this->context->getViolations());
     }
 
-    public function testAddViolationAtUsesPassedNullValue()
+    public function testAddViolationAtPathUsesPassedNullValue()
     {
         // passed null value should override preconfigured value "invalid"
-        $this->context->addViolationAt('bar.baz', 'Error', array('foo' => 'bar'), null);
+        $this->context->addViolationAtPath('bar.baz', 'Error', array('foo' => 'bar'), null);
 
         $this->assertEquals(new ConstraintViolationList(array(
             new ConstraintViolation(
@@ -152,10 +152,10 @@ public function testAddViolationAtUsesPassedNullValue()
         )), $this->context->getViolations());
     }
 
-    public function testAddNestedViolationAt()
+    public function testAddViolationAtRelativePath()
     {
         // override preconfigured property path
-        $this->context->addNestedViolationAt('bam.baz', 'Error', array('foo' => 'bar'), 'invalid');
+        $this->context->addViolationAtRelativePath('bam.baz', 'Error', array('foo' => 'bar'), 'invalid');
 
         $this->assertEquals(new ConstraintViolationList(array(
             new ConstraintViolation(
@@ -168,84 +168,51 @@ public function testAddNestedViolationAt()
         )), $this->context->getViolations());
     }
 
-    public function testAddNestedViolationAtWithIndexPath()
+    public function testAddViolationAtRelativePathUsesPreconfiguredValueIfNotPassed()
     {
-        // override preconfigured property path
-        $this->context->addNestedViolationAt('[bam]', 'Error', array('foo' => 'bar'), 'invalid');
+        $this->context->addViolationAtRelativePath('bam.baz', 'Error');
 
         $this->assertEquals(new ConstraintViolationList(array(
             new ConstraintViolation(
                 'Error',
-                array('foo' => 'bar'),
+                array(),
                 'Root',
-                'foo.bar[bam]',
-                'invalid'
+                'foo.bar.bam.baz',
+                'currentValue'
             ),
         )), $this->context->getViolations());
     }
 
-    public function testAddNestedViolationAtWithEmptyPath()
+    public function testAddViolationAtRelativePathUsesPassedNullValue()
     {
-        // override preconfigured property path
-        $this->context->addNestedViolationAt('', 'Error', array('foo' => 'bar'), 'invalid');
+        // passed null value should override preconfigured value "invalid"
+        $this->context->addViolationAtRelativePath('bam.baz', 'Error', array('foo' => 'bar'), null);
 
         $this->assertEquals(new ConstraintViolationList(array(
             new ConstraintViolation(
                 'Error',
                 array('foo' => 'bar'),
                 'Root',
-                'foo.bar',
-                'invalid'
+                'foo.bar.bam.baz',
+                null
             ),
         )), $this->context->getViolations());
     }
 
-    public function testAddNestedViolationAtWithEmptyCurrentPropertyPath()
+    public function testGetAbsolutePropertyPathWithIndexPath()
     {
-        $this->context = new ExecutionContext($this->globalContext, 'currentValue', '', 'Group', 'ClassName', 'propertyName');
-
-        // override preconfigured property path
-        $this->context->addNestedViolationAt('bam.baz', 'Error', array('foo' => 'bar'), 'invalid');
-
-        $this->assertEquals(new ConstraintViolationList(array(
-            new ConstraintViolation(
-                'Error',
-                array('foo' => 'bar'),
-                'Root',
-                'bam.baz',
-                'invalid'
-            ),
-        )), $this->context->getViolations());
+        $this->assertEquals('foo.bar[bam]', $this->context->getAbsolutePropertyPath('[bam]'));
     }
 
-    public function testAddNestedViolationAtUsesPreconfiguredValueIfNotPassed()
+    public function testGetAbsolutePropertyPathWithEmptyPath()
     {
-        $this->context->addNestedViolationAt('bam.baz', 'Error');
-
-        $this->assertEquals(new ConstraintViolationList(array(
-            new ConstraintViolation(
-                'Error',
-                array(),
-                'Root',
-                'foo.bar.bam.baz',
-                'currentValue'
-            ),
-        )), $this->context->getViolations());
+        $this->assertEquals('foo.bar', $this->context->getAbsolutePropertyPath(''));
     }
 
-    public function testAddNestedViolationAtUsesPassedNullValue()
+    public function testGetAbsolutePropertyPathWithEmptyCurrentPropertyPath()
     {
-        // passed null value should override preconfigured value "invalid"
-        $this->context->addNestedViolationAt('bam.baz', 'Error', array('foo' => 'bar'), null);
+        $this->context = new ExecutionContext($this->globalContext, 'currentValue', '', 'Group', 'ClassName', 'propertyName');
 
-        $this->assertEquals(new ConstraintViolationList(array(
-            new ConstraintViolation(
-                'Error',
-                array('foo' => 'bar'),
-                'Root',
-                'foo.bar.bam.baz',
-                null
-            ),
-        )), $this->context->getViolations());
+        $this->assertEquals('bam.baz', $this->context->getAbsolutePropertyPath('bam.baz'));
     }
 }
diff --git a/tests/Symfony/Tests/Component/Validator/Fixtures/ConstraintAValidator.php b/tests/Symfony/Tests/Component/Validator/Fixtures/ConstraintAValidator.php
index b05208170048..148d3df6d43f 100644
--- a/tests/Symfony/Tests/Component/Validator/Fixtures/ConstraintAValidator.php
+++ b/tests/Symfony/Tests/Component/Validator/Fixtures/ConstraintAValidator.php
@@ -20,7 +20,7 @@ public function initialize(ExecutionContext $context)
     public function isValid($value, Constraint $constraint)
     {
         if ('VALID' != $value) {
-            $this->setMessage('message', array('param' => 'value'));
+            $this->context->addViolation('message', array('param' => 'value'));
 
             return false;
         }
diff --git a/tests/Symfony/Tests/Component/Validator/Fixtures/FailingConstraintValidator.php b/tests/Symfony/Tests/Component/Validator/Fixtures/FailingConstraintValidator.php
index 920ffe177efc..444c1b095b30 100644
--- a/tests/Symfony/Tests/Component/Validator/Fixtures/FailingConstraintValidator.php
+++ b/tests/Symfony/Tests/Component/Validator/Fixtures/FailingConstraintValidator.php
@@ -9,7 +9,7 @@ class FailingConstraintValidator extends ConstraintValidator
 {
     public function isValid($value, Constraint $constraint)
     {
-        $this->setMessage($constraint->message, array());
+        $this->context->addViolation($constraint->message, array());
 
         return false;
     }