Rework CallbackIterator test to use data providers

tests/Model/CallbackIteratorTest.php

@@ -3,68 +3,86 @@
 namespace MongoDB\Tests\Model;
 
 use ArrayIterator;
+use Generator;
+use Iterator;
+use IteratorAggregate;
 use MongoDB\Model\CallbackIterator;
 use MongoDB\Tests\TestCase;
 
-use function array_keys;
 use function iterator_to_array;
-use function strrev;
 
 class CallbackIteratorTest extends TestCase
 {
-    public function testArrayIteration(): void
+    /** @dataProvider provideTests */
+    public function testIteration($expected, $source, $callback): void
     {
-        $expectedKey = 0;
-
-        $original = [1, 2, 3];
-
         $callbackIterator = new CallbackIterator(
-            new ArrayIterator($original),
-            function ($value, $key) use (&$expectedKey) {
-                $this->assertSame($expectedKey, $key);
-                $expectedKey++;
-
-                return $value * 2;
-            }
+            $source,
+            $callback
         );
 
-        $this->assertSame([2, 4, 6], iterator_to_array($callbackIterator));
+        $this->assertEquals($expected, iterator_to_array($callbackIterator));
     }
 
-    public function testHashIteration(): void
+    public static function provideTests(): Generator
     {
-        $expectedKey = 0;
+        $listIterator = new ArrayIterator([1, 2, 3]);
+        $hashIterator = new ArrayIterator(['a' => 1, 'b' => 2, 'c' => 3]);
 
-        $original = ['a' => 1, 'b' => 2, 'c' => 3];
-        $expectedKeys = array_keys($original);
+        $iteratorAggregate = new class ($listIterator) implements IteratorAggregate
+        {
+            private $iterator;
 
-        $callbackIterator = new CallbackIterator(
-            new ArrayIterator($original),
-            function ($value, $key) use (&$expectedKey, $expectedKeys) {
-                $this->assertSame($expectedKeys[$expectedKey], $key);
-                $expectedKey++;
+            public function __construct(Iterator $iterator)
+            {
+                $this->iterator = $iterator;
+            }
 
-                return $value * 2;
+            public function getIterator(): Iterator
+            {
+                return $this->iterator;
             }
-        );
+        };
 
-        $this->assertSame(['a' => 2, 'b' => 4, 'c' => 6], iterator_to_array($callbackIterator));
-    }
+        yield 'List with closure' => [
+            'expected' => [2, 4, 6],
+            'source' => $listIterator,
+            'callback' => function ($value, $key) use ($listIterator) {
+                self::assertSame($listIterator->key(), $key);
 
-    public function testWithCallable(): void
-    {
-        $original = ['foo', 'bar', 'baz'];
+                return $value * 2;
+            },
+        ];
 
-        $callbackIterator = new CallbackIterator(
-            new ArrayIterator($original),
-            [self::class, 'reverseValue']
-        );
+        yield 'List with callable' => [
+            'expected' => [2, 4, 6],
+            'source' => $listIterator,
+            'callback' => [self::class, 'doubleValue'],
+        ];
+
+        yield 'Hash with closure' => [
+            'expected' => ['a' => 2, 'b' => 4, 'c' => 6],
+            'source' => $hashIterator,
+            'callback' => function ($value, $key) use ($hashIterator) {
+                self::assertSame($hashIterator->key(), $key);
 
-        $this->assertSame(['oof', 'rab', 'zab'], iterator_to_array($callbackIterator));
+                return $value * 2;
+            },
+        ];
+
+        yield 'IteratorAggregate with closure' => [
+            'expected' => [2, 4, 6],
+            'source' => $iteratorAggregate,
+            'callback' => function ($value, $key) use ($listIterator) {
+                self::assertSame($listIterator->key(), $key);
+
+                return $value * 2;
+            },
+        ];
     }
 
-    public static function reverseValue($value, $key)
+    public static function doubleValue($value, $key)
     {
-        return strrev($value);
+        return $value * 2;
     }
 }