Expose detection of closure comparisons

src/ClosureComparator.php

@@ -29,6 +29,8 @@ public function accepts(mixed $expected, mixed $actual): bool
 
     public function assertEquals(mixed $expected, mixed $actual, float $delta = 0.0, bool $canonicalize = false, bool $ignoreCase = false): void
     {
+        $this->factory()->recordClosureComparison();
+
         assert($expected instanceof Closure);
         assert($actual instanceof Closure);
 

src/Factory.php

@@ -32,7 +32,8 @@ final class Factory
     private array $defaultComparators = [];
 
     /** @var positive-int */
-    private int $contextLines = 3;
+    private int $contextLines               = 3;
+    private bool $closureComparisonOccurred = false;
 
     public static function getInstance(): self
     {
@@ -64,6 +65,24 @@ public function setContextLines(int $contextLines): void
         $this->contextLines = $contextLines;
     }
 
+    /**
+     * @internal this method is called by ClosureComparator and is not part of the consumer-facing API
+     */
+    public function recordClosureComparison(): void
+    {
+        $this->closureComparisonOccurred = true;
+    }
+
+    public function closureComparisonOccurred(): bool
+    {
+        return $this->closureComparisonOccurred;
+    }
+
+    public function resetClosureComparisonTracking(): void
+    {
+        $this->closureComparisonOccurred = false;
+    }
+
     public function getComparatorFor(mixed $expected, mixed $actual): Comparator
     {
         foreach ($this->customComparators as $comparator) {

tests/unit/ClosureComparatorTest.php

@@ -195,6 +195,21 @@ public function testAssertEqualsFails(Closure $expected, Closure $actual): void
         $this->fail('Expected ComparisonFailure to be thrown');
     }
 
+    public function testRecordsClosureComparisonInFactory(): void
+    {
+        $factory    = new Factory;
+        $comparator = new ClosureComparator;
+        $comparator->setFactory($factory);
+
+        $closure = static function (): void
+        {
+        };
+
+        $comparator->assertEquals($closure, $closure);
+
+        $this->assertTrue($factory->closureComparisonOccurred());
+    }
+
     public function testAsStringComparisonFormat(): void
     {
         $f = static function (): void

tests/unit/FactoryTest.php

@@ -180,4 +180,80 @@ public function testContextLinesCanBeConfigured(): void
 
         $this->assertSame(5, $factory->contextLines());
     }
+
+    public function testClosureComparisonTrackingIsDisabledByDefault(): void
+    {
+        $factory = new Factory;
+
+        $this->assertFalse($factory->closureComparisonOccurred());
+    }
+
+    public function testClosureComparisonIsRecordedWhenTwoClosuresAreCompared(): void
+    {
+        $closure = static function (): void
+        {
+        };
+
+        $factory = new Factory;
+        $factory->getComparatorFor($closure, $closure)->assertEquals($closure, $closure);
+
+        $this->assertTrue($factory->closureComparisonOccurred());
+    }
+
+    public function testClosureComparisonIsRecordedWhenClosuresAreNestedInArrays(): void
+    {
+        $closure = static function (): void
+        {
+        };
+
+        $expected = ['callback' => $closure];
+        $actual   = ['callback' => $closure];
+
+        $factory = new Factory;
+        $factory->getComparatorFor($expected, $actual)->assertEquals($expected, $actual);
+
+        $this->assertTrue($factory->closureComparisonOccurred());
+    }
+
+    public function testClosureComparisonIsRecordedWhenClosuresAreNestedInObjects(): void
+    {
+        $closure = static function (): void
+        {
+        };
+
+        $expected           = new stdClass;
+        $expected->callback = $closure;
+
+        $actual           = new stdClass;
+        $actual->callback = $closure;
+
+        $factory = new Factory;
+        $factory->getComparatorFor($expected, $actual)->assertEquals($expected, $actual);
+
+        $this->assertTrue($factory->closureComparisonOccurred());
+    }
+
+    public function testClosureComparisonIsNotRecordedWhenNoClosuresAreCompared(): void
+    {
+        $expected = [1];
+        $actual   = [1];
+
+        $factory = new Factory;
+        $factory->getComparatorFor($expected, $actual)->assertEquals($expected, $actual);
+
+        $this->assertFalse($factory->closureComparisonOccurred());
+    }
+
+    public function testClosureComparisonTrackingCanBeReset(): void
+    {
+        $closure = static function (): void
+        {
+        };
+
+        $factory = new Factory;
+        $factory->getComparatorFor($closure, $closure)->assertEquals($closure, $closure);
+        $factory->resetClosureComparisonTracking();
+
+        $this->assertFalse($factory->closureComparisonOccurred());
+    }
 }