Merge branch '7.0' into 7.1

nicolas-grekas · nicolas-grekas · commit ba711a6cfc00 · 2024-07-26T14:41:01.000+02:00
* 7.0:
  [Console][PhpUnitBridge][VarDumper] Fix `NO_COLOR` empty value handling
  [Translation] Fix CSV escape char in `CsvFileLoader` on PHP &gt;= 7.4
  [DoctrineBridge] fix messenger bus dispatch inside an active transaction
  [HttpFoundation] Add tests for uncovered sections
  treat uninitialized properties referenced by property paths as null
  properly set up constraint options
  [ErrorHandler][VarDumper] Remove PHP 8.4 deprecations
  move adding detailed JSON error messages to the validate phase
  [Profiler] Add word wrap in tables in dialog to see all the text
  [Core] Fix &amp; Enhance security arabic translation.
  [HttpFoundation] Add tests for `MethodRequestMatcher` and `SchemeRequestMatcher`
diff --git a/Constraints/AbstractComparisonValidator.php b/Constraints/AbstractComparisonValidator.php
@@ -12,6 +12,7 @@
 namespace Symfony\Component\Validator\Constraints;
 
 use Symfony\Component\PropertyAccess\Exception\NoSuchPropertyException;
+use Symfony\Component\PropertyAccess\Exception\UninitializedPropertyException;
 use Symfony\Component\PropertyAccess\PropertyAccess;
 use Symfony\Component\PropertyAccess\PropertyAccessorInterface;
 use Symfony\Component\Validator\Constraint;
@@ -53,6 +54,8 @@ public function validate(mixed $value, Constraint $constraint): void
                 $comparedValue = $this->getPropertyAccessor()->getValue($object, $path);
             } catch (NoSuchPropertyException $e) {
                 throw new ConstraintDefinitionException(sprintf('Invalid property path "%s" provided to "%s" constraint: ', $path, get_debug_type($constraint)).$e->getMessage(), 0, $e);
+            } catch (UninitializedPropertyException) {
+                $comparedValue = null;
             }
         } else {
             $comparedValue = $constraint->value;
diff --git a/Constraints/BicValidator.php b/Constraints/BicValidator.php
@@ -13,6 +13,7 @@
 
 use Symfony\Component\Intl\Countries;
 use Symfony\Component\PropertyAccess\Exception\NoSuchPropertyException;
+use Symfony\Component\PropertyAccess\Exception\UninitializedPropertyException;
 use Symfony\Component\PropertyAccess\PropertyAccess;
 use Symfony\Component\PropertyAccess\PropertyAccessor;
 use Symfony\Component\Validator\Constraint;
@@ -127,6 +128,8 @@ public function validate(mixed $value, Constraint $constraint): void
                 $iban = $this->getPropertyAccessor()->getValue($object, $path);
             } catch (NoSuchPropertyException $e) {
                 throw new ConstraintDefinitionException(sprintf('Invalid property path "%s" provided to "%s" constraint: ', $path, get_debug_type($constraint)).$e->getMessage(), 0, $e);
+            } catch (UninitializedPropertyException) {
+                $iban = null;
             }
         }
         if (!$iban) {
diff --git a/Constraints/RangeValidator.php b/Constraints/RangeValidator.php
@@ -12,6 +12,7 @@
 namespace Symfony\Component\Validator\Constraints;
 
 use Symfony\Component\PropertyAccess\Exception\NoSuchPropertyException;
+use Symfony\Component\PropertyAccess\Exception\UninitializedPropertyException;
 use Symfony\Component\PropertyAccess\PropertyAccess;
 use Symfony\Component\PropertyAccess\PropertyAccessorInterface;
 use Symfony\Component\Validator\Constraint;
@@ -159,6 +160,8 @@ private function getLimit(?string $propertyPath, mixed $default, Constraint $con
             return $this->getPropertyAccessor()->getValue($object, $propertyPath);
         } catch (NoSuchPropertyException $e) {
             throw new ConstraintDefinitionException(sprintf('Invalid property path "%s" provided to "%s" constraint: ', $propertyPath, get_debug_type($constraint)).$e->getMessage(), 0, $e);
+        } catch (UninitializedPropertyException) {
+            return null;
         }
     }
 
diff --git a/Tests/Constraints/AbstractComparisonValidatorTestCase.php b/Tests/Constraints/AbstractComparisonValidatorTestCase.php
@@ -16,6 +16,7 @@
 use Symfony\Component\Validator\Constraints\AbstractComparison;
 use Symfony\Component\Validator\Exception\ConstraintDefinitionException;
 use Symfony\Component\Validator\Test\ConstraintValidatorTestCase;
+use Symfony\Component\Validator\Tests\Constraints\Fixtures\TypedDummy;
 
 class ComparisonTest_Class
 {
@@ -263,6 +264,31 @@ public function testCompareWithNullValueAtPropertyAt($dirtyValue, $dirtyValueAsS
         }
     }
 
+    /**
+     * @dataProvider provideComparisonsToNullValueAtPropertyPath
+     */
+    public function testCompareWithUninitializedPropertyAtPropertyPath($dirtyValue, $dirtyValueAsString, $isValid)
+    {
+        $this->setObject(new TypedDummy());
+
+        $this->validator->validate($dirtyValue, $this->createConstraint([
+            'message' => 'Constraint Message',
+            'propertyPath' => 'value',
+        ]));
+
+        if ($isValid) {
+            $this->assertNoViolation();
+        } else {
+            $this->buildViolation('Constraint Message')
+                ->setParameter('{{ value }}', $dirtyValueAsString)
+                ->setParameter('{{ compared_value }}', 'null')
+                ->setParameter('{{ compared_value_type }}', 'null')
+                ->setParameter('{{ compared_value_path }}', 'value')
+                ->setCode($this->getErrorCode())
+                ->assertRaised();
+        }
+    }
+
     public static function provideAllInvalidComparisons(): array
     {
         // The provider runs before setUp(), so we need to manually fix
diff --git a/Tests/Constraints/BicValidatorTest.php b/Tests/Constraints/BicValidatorTest.php
@@ -18,6 +18,7 @@
 use Symfony\Component\Validator\Mapping\ClassMetadata;
 use Symfony\Component\Validator\Mapping\Loader\AttributeLoader;
 use Symfony\Component\Validator\Test\ConstraintValidatorTestCase;
+use Symfony\Component\Validator\Tests\Constraints\Fixtures\BicTypedDummy;
 
 class BicValidatorTest extends ConstraintValidatorTestCase
 {
@@ -89,6 +90,15 @@ public function testInvalidComparisonToPropertyPathFromAttribute()
             ->assertRaised();
     }
 
+    public function testPropertyPathReferencingUninitializedProperty()
+    {
+        $this->setObject(new BicTypedDummy());
+
+        $this->validator->validate('UNCRIT2B912', new Bic(['ibanPropertyPath' => 'iban']));
+
+        $this->assertNoViolation();
+    }
+
     public function testValidComparisonToValue()
     {
         $constraint = new Bic(['iban' => 'FR14 2004 1010 0505 0001 3M02 606']);
diff --git a/Tests/Constraints/Fixtures/BicTypedDummy.php b/Tests/Constraints/Fixtures/BicTypedDummy.php
@@ -0,0 +1,17 @@
+<?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\Component\Validator\Tests\Constraints\Fixtures;
+
+class BicTypedDummy
+{
+    public string $iban;
+}
diff --git a/Tests/Constraints/Fixtures/MinMaxTyped.php b/Tests/Constraints/Fixtures/MinMaxTyped.php
@@ -0,0 +1,18 @@
+<?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\Component\Validator\Tests\Constraints\Fixtures;
+
+class MinMaxTyped
+{
+    public int $min;
+    public int $max;
+}
diff --git a/Tests/Constraints/Fixtures/TypedDummy.php b/Tests/Constraints/Fixtures/TypedDummy.php
@@ -0,0 +1,17 @@
+<?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\Component\Validator\Tests\Constraints\Fixtures;
+
+class TypedDummy
+{
+    public mixed $value;
+}
diff --git a/Tests/Constraints/GreaterThanOrEqualValidatorWithPositiveOrZeroConstraintTest.php b/Tests/Constraints/GreaterThanOrEqualValidatorWithPositiveOrZeroConstraintTest.php
@@ -23,7 +23,7 @@ class GreaterThanOrEqualValidatorWithPositiveOrZeroConstraintTest extends Greate
 {
     protected static function createConstraint(?array $options = null): Constraint
     {
-        return new PositiveOrZero();
+        return new PositiveOrZero($options);
     }
 
     public static function provideValidComparisons(): array
@@ -82,6 +82,11 @@ public function testInvalidValuePath()
         $this->markTestSkipped('PropertyPath option is not used in PositiveOrZero constraint');
     }
 
+    public static function provideAllValidComparisons(): array
+    {
+        self::markTestSkipped('The "value" option cannot be used in the PositiveOrZero constraint');
+    }
+
     /**
      * @dataProvider provideValidComparisonsToPropertyPath
      */
@@ -90,6 +95,11 @@ public function testValidComparisonToPropertyPath($comparedValue)
         $this->markTestSkipped('PropertyPath option is not used in PositiveOrZero constraint');
     }
 
+    public function testNoViolationOnNullObjectWithPropertyPath()
+    {
+        $this->markTestSkipped('PropertyPath option is not used in PositiveOrZero constraint');
+    }
+
     /**
      * @dataProvider throwsOnInvalidStringDatesProvider
      */
@@ -102,4 +112,19 @@ public function testInvalidComparisonToPropertyPathAddsPathAsParameter()
     {
         $this->markTestSkipped('PropertyPath option is not used in PositiveOrZero constraint');
     }
+
+    public static function throwsOnInvalidStringDatesProvider(): array
+    {
+        self::markTestSkipped('The "value" option cannot be used in the PositiveOrZero constraint');
+    }
+
+    public static function provideAllInvalidComparisons(): array
+    {
+        self::markTestSkipped('The "value" option cannot be used in the Negative constraint');
+    }
+
+    public static function provideComparisonsToNullValueAtPropertyPath(): array
+    {
+        self::markTestSkipped('PropertyPath option is not used in PositiveOrZero constraint');
+    }
 }
diff --git a/Tests/Constraints/GreaterThanValidatorWithPositiveConstraintTest.php b/Tests/Constraints/GreaterThanValidatorWithPositiveConstraintTest.php
@@ -23,7 +23,7 @@ class GreaterThanValidatorWithPositiveConstraintTest extends GreaterThanValidato
 {
     protected static function createConstraint(?array $options = null): Constraint
     {
-        return new Positive();
+        return new Positive($options);
     }
 
     public static function provideValidComparisons(): array
@@ -85,6 +85,11 @@ public function testInvalidValuePath()
         $this->markTestSkipped('PropertyPath option is not used in Positive constraint');
     }
 
+    public static function provideAllValidComparisons(): array
+    {
+        self::markTestSkipped('The "value" option cannot be used in the Positive constraint');
+    }
+
     /**
      * @dataProvider provideValidComparisonsToPropertyPath
      */
@@ -105,4 +110,19 @@ public function testInvalidComparisonToPropertyPathAddsPathAsParameter()
     {
         $this->markTestSkipped('PropertyPath option is not used in Positive constraint');
     }
+
+    public static function throwsOnInvalidStringDatesProvider(): array
+    {
+        self::markTestSkipped('The "value" option cannot be used in the Positive constraint');
+    }
+
+    public static function provideAllInvalidComparisons(): array
+    {
+        self::markTestSkipped('The "value" option cannot be used in the Positive constraint');
+    }
+
+    public static function provideComparisonsToNullValueAtPropertyPath(): array
+    {
+        self::markTestSkipped('PropertyPath option is not used in PositiveOrZero constraint');
+    }
 }
diff --git a/Tests/Constraints/LessThanOrEqualValidatorWithNegativeOrZeroConstraintTest.php b/Tests/Constraints/LessThanOrEqualValidatorWithNegativeOrZeroConstraintTest.php
@@ -23,7 +23,7 @@ class LessThanOrEqualValidatorWithNegativeOrZeroConstraintTest extends LessThanO
 {
     protected static function createConstraint(?array $options = null): Constraint
     {
-        return new NegativeOrZero();
+        return new NegativeOrZero($options);
     }
 
     public static function provideValidComparisons(): array
@@ -85,6 +85,11 @@ public function testInvalidValuePath()
         $this->markTestSkipped('PropertyPath option is not used in NegativeOrZero constraint');
     }
 
+    public static function provideAllValidComparisons(): array
+    {
+        self::markTestSkipped('The "value" option cannot be used in the NegativeOrZero constraint');
+    }
+
     /**
      * @dataProvider provideValidComparisonsToPropertyPath
      */
@@ -93,12 +98,9 @@ public function testValidComparisonToPropertyPath($comparedValue)
         $this->markTestSkipped('PropertyPath option is not used in NegativeOrZero constraint');
     }
 
-    /**
-     * @dataProvider throwsOnInvalidStringDatesProvider
-     */
-    public function testThrowsOnInvalidStringDates(AbstractComparison $constraint, $expectedMessage, $value)
+    public function testInvalidComparisonToPropertyPathAddsPathAsParameter()
     {
-        $this->markTestSkipped('The compared value cannot be an invalid string date because it is hardcoded to 0.');
+        $this->markTestSkipped('PropertyPath option is not used in NegativeOrZero constraint');
     }
 
     /**
@@ -109,8 +111,21 @@ public function testCompareWithNullValueAtPropertyAt($dirtyValue, $dirtyValueAsS
         $this->markTestSkipped('PropertyPath option is not used in NegativeOrZero constraint');
     }
 
-    public function testInvalidComparisonToPropertyPathAddsPathAsParameter()
+    /**
+     * @dataProvider provideComparisonsToNullValueAtPropertyPath
+     */
+    public function testCompareWithUninitializedPropertyAtPropertyPath($dirtyValue, $dirtyValueAsString, $isValid)
     {
         $this->markTestSkipped('PropertyPath option is not used in NegativeOrZero constraint');
     }
+
+    public static function throwsOnInvalidStringDatesProvider(): array
+    {
+        self::markTestSkipped('The "value" option cannot be used in the NegativeOrZero constraint');
+    }
+
+    public static function provideAllInvalidComparisons(): array
+    {
+        self::markTestSkipped('The "value" option cannot be used in the NegativeOrZero constraint');
+    }
 }
diff --git a/Tests/Constraints/LessThanValidatorWithNegativeConstraintTest.php b/Tests/Constraints/LessThanValidatorWithNegativeConstraintTest.php
@@ -23,7 +23,7 @@ class LessThanValidatorWithNegativeConstraintTest extends LessThanValidatorTest
 {
     protected static function createConstraint(?array $options = null): Constraint
     {
-        return new Negative();
+        return new Negative($options);
     }
 
     public static function provideValidComparisons(): array
@@ -85,6 +85,11 @@ public function testInvalidValuePath()
         $this->markTestSkipped('PropertyPath option is not used in Negative constraint');
     }
 
+    public static function provideAllValidComparisons(): array
+    {
+        self::markTestSkipped('The "value" option cannot be used in the Negative constraint');
+    }
+
     /**
      * @dataProvider provideValidComparisonsToPropertyPath
      */
@@ -93,18 +98,23 @@ public function testValidComparisonToPropertyPath($comparedValue)
         $this->markTestSkipped('PropertyPath option is not used in Negative constraint');
     }
 
+    public static function throwsOnInvalidStringDatesProvider(): array
+    {
+        self::markTestSkipped('The "value" option cannot be used in the Negative constraint');
+    }
+
     /**
-     * @dataProvider throwsOnInvalidStringDatesProvider
+     * @dataProvider provideComparisonsToNullValueAtPropertyPath
      */
-    public function testThrowsOnInvalidStringDates(AbstractComparison $constraint, $expectedMessage, $value)
+    public function testCompareWithNullValueAtPropertyAt($dirtyValue, $dirtyValueAsString, $isValid)
     {
-        $this->markTestSkipped('The compared value cannot be an invalid string date because it is hardcoded to 0.');
+        $this->markTestSkipped('PropertyPath option is not used in Negative constraint');
     }
 
     /**
      * @dataProvider provideComparisonsToNullValueAtPropertyPath
      */
-    public function testCompareWithNullValueAtPropertyAt($dirtyValue, $dirtyValueAsString, $isValid)
+    public function testCompareWithUninitializedPropertyAtPropertyPath($dirtyValue, $dirtyValueAsString, $isValid)
     {
         $this->markTestSkipped('PropertyPath option is not used in Negative constraint');
     }
@@ -113,4 +123,9 @@ public function testInvalidComparisonToPropertyPathAddsPathAsParameter()
     {
         $this->markTestSkipped('PropertyPath option is not used in Negative constraint');
     }
+
+    public static function provideAllInvalidComparisons(): array
+    {
+        self::markTestSkipped('The "value" option cannot be used in the Negative constraint');
+    }
 }
diff --git a/Tests/Constraints/RangeValidatorTest.php b/Tests/Constraints/RangeValidatorTest.php

Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,7 @@`
`12`	`12`	`namespace Symfony\Component\Validator\Constraints;`
`13`	`13`
`14`	`14`	`use Symfony\Component\PropertyAccess\Exception\NoSuchPropertyException;`
	`15`	`+use Symfony\Component\PropertyAccess\Exception\UninitializedPropertyException;`
`15`	`16`	`use Symfony\Component\PropertyAccess\PropertyAccess;`
`16`	`17`	`use Symfony\Component\PropertyAccess\PropertyAccessorInterface;`
`17`	`18`	`use Symfony\Component\Validator\Constraint;`
`@@ -159,6 +160,8 @@ private function getLimit(?string $propertyPath, mixed $default, Constraint $con`
`159`	`160`	`return $this->getPropertyAccessor()->getValue($object, $propertyPath);`
`160`	`161`	`} catch (NoSuchPropertyException $e) {`
`161`	`162`	`throw new ConstraintDefinitionException(sprintf('Invalid property path "%s" provided to "%s" constraint: ', $propertyPath, get_debug_type($constraint)).$e->getMessage(), 0, $e);`
	`163`	`+ } catch (UninitializedPropertyException) {`
	`164`	`+ return null;`
`162`	`165`	`}`
`163`	`166`	`}`
`164`	`167`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ class GreaterThanValidatorWithPositiveConstraintTest extends GreaterThanValidato`
`23`	`23`	`{`
`24`	`24`	`protected static function createConstraint(?array $options = null): Constraint`
`25`	`25`	`{`
`26`		`- return new Positive();`
	`26`	`+ return new Positive($options);`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`public static function provideValidComparisons(): array`
`@@ -85,6 +85,11 @@ public function testInvalidValuePath()`
`85`	`85`	`$this->markTestSkipped('PropertyPath option is not used in Positive constraint');`
`86`	`86`	`}`
`87`	`87`
	`88`	`+ public static function provideAllValidComparisons(): array`
	`89`	`+ {`
	`90`	`+ self::markTestSkipped('The "value" option cannot be used in the Positive constraint');`
	`91`	`+ }`
	`92`	`+`
`88`	`93`	`/**`
`89`	`94`	`* @dataProvider provideValidComparisonsToPropertyPath`
`90`	`95`	`*/`
`@@ -105,4 +110,19 @@ public function testInvalidComparisonToPropertyPathAddsPathAsParameter()`
`105`	`110`	`{`
`106`	`111`	`$this->markTestSkipped('PropertyPath option is not used in Positive constraint');`
`107`	`112`	`}`
	`113`	`+`
	`114`	`+ public static function throwsOnInvalidStringDatesProvider(): array`
	`115`	`+ {`
	`116`	`+ self::markTestSkipped('The "value" option cannot be used in the Positive constraint');`
	`117`	`+ }`
	`118`	`+`
	`119`	`+ public static function provideAllInvalidComparisons(): array`
	`120`	`+ {`
	`121`	`+ self::markTestSkipped('The "value" option cannot be used in the Positive constraint');`
	`122`	`+ }`
	`123`	`+`
	`124`	`+ public static function provideComparisonsToNullValueAtPropertyPath(): array`
	`125`	`+ {`
	`126`	`+ self::markTestSkipped('PropertyPath option is not used in PositiveOrZero constraint');`
	`127`	`+ }`
`108`	`128`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ class LessThanOrEqualValidatorWithNegativeOrZeroConstraintTest extends LessThanO`
`23`	`23`	`{`
`24`	`24`	`protected static function createConstraint(?array $options = null): Constraint`
`25`	`25`	`{`
`26`		`- return new NegativeOrZero();`
	`26`	`+ return new NegativeOrZero($options);`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`public static function provideValidComparisons(): array`
`@@ -85,6 +85,11 @@ public function testInvalidValuePath()`
`85`	`85`	`$this->markTestSkipped('PropertyPath option is not used in NegativeOrZero constraint');`
`86`	`86`	`}`
`87`	`87`
	`88`	`+ public static function provideAllValidComparisons(): array`
	`89`	`+ {`
	`90`	`+ self::markTestSkipped('The "value" option cannot be used in the NegativeOrZero constraint');`
	`91`	`+ }`
	`92`	`+`
`88`	`93`	`/**`
`89`	`94`	`* @dataProvider provideValidComparisonsToPropertyPath`
`90`	`95`	`*/`
`@@ -93,12 +98,9 @@ public function testValidComparisonToPropertyPath($comparedValue)`
`93`	`98`	`$this->markTestSkipped('PropertyPath option is not used in NegativeOrZero constraint');`
`94`	`99`	`}`
`95`	`100`
`96`		`- /**`
`97`		`- * @dataProvider throwsOnInvalidStringDatesProvider`
`98`		`- */`
`99`		`- public function testThrowsOnInvalidStringDates(AbstractComparison $constraint, $expectedMessage, $value)`
	`101`	`+ public function testInvalidComparisonToPropertyPathAddsPathAsParameter()`
`100`	`102`	`{`
`101`		`- $this->markTestSkipped('The compared value cannot be an invalid string date because it is hardcoded to 0.');`
	`103`	`+ $this->markTestSkipped('PropertyPath option is not used in NegativeOrZero constraint');`
`102`	`104`	`}`
`103`	`105`
`104`	`106`	`/**`
`@@ -109,8 +111,21 @@ public function testCompareWithNullValueAtPropertyAt($dirtyValue, $dirtyValueAsS`
`109`	`111`	`$this->markTestSkipped('PropertyPath option is not used in NegativeOrZero constraint');`
`110`	`112`	`}`
`111`	`113`
`112`		`- public function testInvalidComparisonToPropertyPathAddsPathAsParameter()`
	`114`	`+ /**`
	`115`	`+ * @dataProvider provideComparisonsToNullValueAtPropertyPath`
	`116`	`+ */`
	`117`	`+ public function testCompareWithUninitializedPropertyAtPropertyPath($dirtyValue, $dirtyValueAsString, $isValid)`
`113`	`118`	`{`
`114`	`119`	`$this->markTestSkipped('PropertyPath option is not used in NegativeOrZero constraint');`
`115`	`120`	`}`
	`121`	`+`
	`122`	`+ public static function throwsOnInvalidStringDatesProvider(): array`
	`123`	`+ {`
	`124`	`+ self::markTestSkipped('The "value" option cannot be used in the NegativeOrZero constraint');`
	`125`	`+ }`
	`126`	`+`
	`127`	`+ public static function provideAllInvalidComparisons(): array`
	`128`	`+ {`
	`129`	`+ self::markTestSkipped('The "value" option cannot be used in the NegativeOrZero constraint');`
	`130`	`+ }`
`116`	`131`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ class LessThanValidatorWithNegativeConstraintTest extends LessThanValidatorTest`
`23`	`23`	`{`
`24`	`24`	`protected static function createConstraint(?array $options = null): Constraint`
`25`	`25`	`{`
`26`		`- return new Negative();`
	`26`	`+ return new Negative($options);`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`public static function provideValidComparisons(): array`
`@@ -85,6 +85,11 @@ public function testInvalidValuePath()`
`85`	`85`	`$this->markTestSkipped('PropertyPath option is not used in Negative constraint');`
`86`	`86`	`}`
`87`	`87`
	`88`	`+ public static function provideAllValidComparisons(): array`
	`89`	`+ {`
	`90`	`+ self::markTestSkipped('The "value" option cannot be used in the Negative constraint');`
	`91`	`+ }`
	`92`	`+`
`88`	`93`	`/**`
`89`	`94`	`* @dataProvider provideValidComparisonsToPropertyPath`
`90`	`95`	`*/`
`@@ -93,18 +98,23 @@ public function testValidComparisonToPropertyPath($comparedValue)`
`93`	`98`	`$this->markTestSkipped('PropertyPath option is not used in Negative constraint');`
`94`	`99`	`}`
`95`	`100`
	`101`	`+ public static function throwsOnInvalidStringDatesProvider(): array`
	`102`	`+ {`
	`103`	`+ self::markTestSkipped('The "value" option cannot be used in the Negative constraint');`
	`104`	`+ }`
	`105`	`+`
`96`	`106`	`/**`
`97`		`- * @dataProvider throwsOnInvalidStringDatesProvider`
	`107`	`+ * @dataProvider provideComparisonsToNullValueAtPropertyPath`
`98`	`108`	`*/`
`99`		`- public function testThrowsOnInvalidStringDates(AbstractComparison $constraint, $expectedMessage, $value)`
	`109`	`+ public function testCompareWithNullValueAtPropertyAt($dirtyValue, $dirtyValueAsString, $isValid)`
`100`	`110`	`{`
`101`		`- $this->markTestSkipped('The compared value cannot be an invalid string date because it is hardcoded to 0.');`
	`111`	`+ $this->markTestSkipped('PropertyPath option is not used in Negative constraint');`
`102`	`112`	`}`
`103`	`113`
`104`	`114`	`/**`
`105`	`115`	`* @dataProvider provideComparisonsToNullValueAtPropertyPath`
`106`	`116`	`*/`
`107`		`- public function testCompareWithNullValueAtPropertyAt($dirtyValue, $dirtyValueAsString, $isValid)`
	`117`	`+ public function testCompareWithUninitializedPropertyAtPropertyPath($dirtyValue, $dirtyValueAsString, $isValid)`
`108`	`118`	`{`
`109`	`119`	`$this->markTestSkipped('PropertyPath option is not used in Negative constraint');`
`110`	`120`	`}`
`@@ -113,4 +123,9 @@ public function testInvalidComparisonToPropertyPathAddsPathAsParameter()`
`113`	`123`	`{`
`114`	`124`	`$this->markTestSkipped('PropertyPath option is not used in Negative constraint');`
`115`	`125`	`}`
	`126`	`+`
	`127`	`+ public static function provideAllInvalidComparisons(): array`
	`128`	`+ {`
	`129`	`+ self::markTestSkipped('The "value" option cannot be used in the Negative constraint');`
	`130`	`+ }`
`116`	`131`	`}`