Merge branch '1.x' into task/1914-html-entry

norberttech · web-flow · commit 8764b22b7c83 · 2025-10-31T20:14:24.000+01:00
diff --git a/infection.json b/infection.json
@@ -74,10 +74,10 @@
   },
   "bootstrap": "vendor/autoload.php",
   "phpUnit": {
-    "customPath": "tools/phpunit/vendor/bin/phpunit"
+    "customPath": "tools/phpunit/vendor/bin/phpunit",
+    "configDir": "tools/infection"
   },
   "tmpDir": "var/infection/cache",
-  "testFrameworkOptions": "--testsuite=infection",
   "minMsi": 30,
   "minCoveredMsi": 75
 }
diff --git a/phpunit.xml.dist b/phpunit.xml.dist
@@ -168,13 +168,6 @@
     <testsuite name="adapter-xml-integration">
       <directory>src/adapter/etl-adapter-xml/tests/Flow/ETL/Adapter/XML/Tests/Integration</directory>
     </testsuite>
-    <testsuite name="infection">
-      <directory>src/core/etl/tests/Flow/ETL/Tests/Unit</directory>
-      <directory>src/lib/array-dot/tests/Flow/ArrayDot/Tests/Unit</directory>
-      <directory>src/lib/doctrine-dbal-bulk/tests/Flow/Doctrine/Bulk/Tests/Unit</directory>
-      <directory>src/lib/filesystem/tests/Flow/Filesystem/Tests/Unit</directory>
-      <directory>src/lib/parquet/tests/Flow/Parquet/Tests/Unit</directory>
-    </testsuite>
   </testsuites>
   <source>
     <include>
diff --git a/shell.nix b/shell.nix
@@ -1,7 +1,7 @@
 let
     nixpkgs = fetchTarball {
-        url = "https://github.com/NixOS/nixpkgs/archive/41239f03433fe534c51a1526bed9214ab2a3582f.tar.gz";
-
+        # Oct 31, 2025
+        url = "https://github.com/NixOS/nixpkgs/archive/66a437ebcf6160152336e801a7ec289ba2aba3c5.tar.gz";
     };
 
     lockedPkgs = import nixpkgs {
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/NativePHPRandomValueGeneratorTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/NativePHPRandomValueGeneratorTest.php
@@ -6,6 +6,7 @@
 
 use Flow\ETL\NativePHPRandomValueGenerator;
 use Flow\ETL\Tests\FlowTestCase;
+use PHPUnit\Framework\Attributes\DataProvider;
 
 final class NativePHPRandomValueGeneratorTest extends FlowTestCase
 {
@@ -51,7 +52,7 @@ public function test_can_create_random_int_from_given_range() : void
         );
     }
 
-    /** @dataProvider integers_provider */
+    #[DataProvider('integers_provider')]
     public function test_can_create_random_string_with_given_length(int $expectedLength) : void
     {
         self::assertSame($expectedLength, mb_strlen((new NativePHPRandomValueGenerator())->string($expectedLength)));
@@ -69,14 +70,14 @@ public function test_empty_string_on_length_below_1() : void
         );
     }
 
-    /** @dataProvider invalid_range_provider */
+    #[DataProvider('invalid_range_provider')]
     public function test_fail_on_invalid_range(int $min, int $max) : void
     {
         self::expectException(\ValueError::class);
         (new NativePHPRandomValueGenerator())->int($min, $max);
     }
 
-    /** @dataProvider valid_range_provider */
+    #[DataProvider('valid_range_provider')]
     public function test_return_random_int_on_valid_range(int $min, int $max) : void
     {
         self::assertThat(
diff --git a/src/lib/filesystem/tests/Flow/Filesystem/Tests/Unit/Path/UnixPathTest.php b/src/lib/filesystem/tests/Flow/Filesystem/Tests/Unit/Path/UnixPathTest.php
@@ -8,6 +8,7 @@
 use Flow\Filesystem\Exception\InvalidArgumentException;
 use Flow\Filesystem\Path\{Options, UnixPath};
 use Flow\Filesystem\Tests\Unit\PathTestCase;
+use PHPUnit\Framework\Attributes\DataProvider;
 
 final class UnixPathTest extends PathTestCase
 {
@@ -221,9 +222,7 @@ public function test_options_handling() : void
         self::assertEquals(['key' => 'value'], $path->options()->toArray());
     }
 
-    /**
-     * @dataProvider pathProvider
-     */
+    #[DataProvider('pathProvider')]
     public function test_os_agnostic_logic(string $input, string $expectedPath, string $expectedScheme) : void
     {
         $path = new UnixPath($input);
@@ -311,9 +310,7 @@ public function test_path_method() : void
         self::assertEquals('/path/file.txt', $path->path());
     }
 
-    /**
-     * @dataProvider patternProvider
-     */
+    #[DataProvider('patternProvider')]
     public function test_pattern_logic(string $pattern, string $filename, bool $expected) : void
     {
         $patternPath = new UnixPath($pattern);
@@ -468,9 +465,7 @@ public function test_set_extension_without_existing_extension() : void
         self::assertEquals('/path/to/file.txt', $newPath->path());
     }
 
-    /**
-     * @dataProvider partitionProvider
-     */
+    #[DataProvider('partitionProvider')]
     public function test_shared_partition_logic(string $input, array $partitionData, string $expected) : void
     {
         $path = new UnixPath($input);
diff --git a/src/lib/filesystem/tests/Flow/Filesystem/Tests/Unit/Path/WindowsPathTest.php b/src/lib/filesystem/tests/Flow/Filesystem/Tests/Unit/Path/WindowsPathTest.php
@@ -8,6 +8,7 @@
 use Flow\Filesystem\Exception\InvalidArgumentException;
 use Flow\Filesystem\Path\{Options, WindowsPath};
 use Flow\Filesystem\Tests\Unit\PathTestCase;
+use PHPUnit\Framework\Attributes\DataProvider;
 
 final class WindowsPathTest extends PathTestCase
 {
@@ -253,9 +254,7 @@ public function test_options_handling() : void
         self::assertEquals(['key' => 'value'], $path->options()->toArray());
     }
 
-    /**
-     * @dataProvider pathProvider
-     */
+    #[DataProvider('pathProvider')]
     public function test_os_agnostic_logic(string $input, string $expectedPath, string $expectedScheme) : void
     {
         $path = new WindowsPath($input);
@@ -264,9 +263,7 @@ public function test_os_agnostic_logic(string $input, string $expectedPath, stri
         self::assertEquals($expectedScheme, $path->protocol()->name);
     }
 
-    /**
-     * @dataProvider partitionProvider
-     */
+    #[DataProvider('partitionProvider')]
     public function test_partition_logic(string $input, array $partitionData, string $expected) : void
     {
         $path = new WindowsPath($input);
@@ -364,9 +361,7 @@ public function test_pathinfo_backslash_edge_case() : void
         self::assertEquals('file://', $parent->uri());
     }
 
-    /**
-     * @dataProvider patternProvider
-     */
+    #[DataProvider('patternProvider')]
     public function test_pattern_logic(string $pattern, string $filename, bool $expected) : void
     {
         $patternPath = new WindowsPath($pattern);
diff --git a/src/lib/parquet/src/Flow/Parquet/Writer/PageBuilder/DictionaryBuilder/ScalarDictionaryBuilder.php b/src/lib/parquet/src/Flow/Parquet/Writer/PageBuilder/DictionaryBuilder/ScalarDictionaryBuilder.php
@@ -21,16 +21,15 @@ public function build(WriteFlatColumnValues $data) : Dictionary
                 continue;
             }
 
-            /** @phpstan-ignore-next-line */
-            if (!isset($valueToIndex[$value])) {
+            $key = \is_float($value) ? \serialize($value) : $value;
+
+            if (!isset($valueToIndex[$key])) {
                 $dictionary[] = $value;
-                /** @phpstan-ignore-next-line */
-                $valueToIndex[$value] = $dictionarySize;
+                $valueToIndex[$key] = $dictionarySize;
                 $dictionarySize++;
             }
 
-            /** @phpstan-ignore-next-line */
-            $indices[] = $valueToIndex[$value];
+            $indices[] = $valueToIndex[$key];
         }
 
         foreach ($dictionary as $index => $value) {
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Dremel/WriteColumnDataTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Dremel/WriteColumnDataTest.php
@@ -9,6 +9,7 @@
 use Flow\Parquet\Exception\RuntimeException;
 use Flow\Parquet\ParquetFile\Schema;
 use Flow\Parquet\ParquetFile\Schema\{FlatColumn, ListElement, MapKey, MapValue, NestedColumn};
+use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\TestCase;
 
 final class WriteColumnDataTest extends TestCase
@@ -102,9 +103,7 @@ public function test_add_value_multiple_values() : void
         );
     }
 
-    /**
-     * @dataProvider valueTypesDataProvider
-     */
+    #[DataProvider('valueTypesDataProvider')]
     public function test_add_value_with_different_value_types(int|float|string|bool|null $value, string $expectedType) : void
     {
         /** @var FlatColumn $column */
@@ -222,10 +221,9 @@ public function test_flat_values_returns_all_flat_values() : void
     }
 
     /**
-     * @dataProvider initializeDataProvider
-     *
      * @param array<string> $expectedFlatPaths
      */
+    #[DataProvider('initializeDataProvider')]
     public function test_initialize_with_different_column_types(Schema $schema, string $columnPath, array $expectedFlatPaths) : void
     {
         $column = $schema->get($columnPath);
@@ -240,9 +238,7 @@ public function test_initialize_with_different_column_types(Schema $schema, stri
         }
     }
 
-    /**
-     * @dataProvider isEmptyDataProvider
-     */
+    #[DataProvider('isEmptyDataProvider')]
     public function test_is_empty(bool $isEmpty, \Closure $setupCallback) : void
     {
         /** @var FlatColumn $column */
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Thrift/MemoryBufferTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Thrift/MemoryBufferTest.php
@@ -5,6 +5,7 @@
 namespace Flow\Parquet\Tests\Unit\Thrift;
 
 use Flow\Parquet\Thrift\MemoryBuffer;
+use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\TestCase;
 use Thrift\Exception\TTransportException;
 
@@ -258,9 +259,7 @@ public function test_read_sequential_operations() : void
         self::assertSame(0, $buffer->available());
     }
 
-    /**
-     * @dataProvider read_length_provider
-     */
+    #[DataProvider('read_length_provider')]
     public function test_read_various_lengths(int $dataLength, int $readLength, int $expectedReadLength) : void
     {
         $data = \str_repeat('A', $dataLength);
@@ -351,9 +350,7 @@ public function test_write_multiple_times() : void
         self::assertSame(11, $buffer->available());
     }
 
-    /**
-     * @dataProvider write_data_provider
-     */
+    #[DataProvider('write_data_provider')]
     public function test_write_various_data_types(string $data) : void
     {
         $buffer = new MemoryBuffer();
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/ColumnChunkBuilder/NestedColumnChunkBuilderTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/ColumnChunkBuilder/NestedColumnChunkBuilderTest.php
@@ -11,6 +11,7 @@
 use Flow\Parquet\ParquetFile\Schema\{FlatColumn, LogicalType, NestedColumn, PhysicalType};
 use Flow\Parquet\Writer\ColumnChunkBuilder\{NestedColumnChunkBuilder, PlainFlatColumnChunkBuilder};
 use Flow\Parquet\Writer\{ColumnChunkBuilder, ColumnChunkContainer};
+use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\TestCase;
 
 final class NestedColumnChunkBuilderTest extends TestCase
@@ -286,10 +287,9 @@ public function test_constructor_initializes_correctly() : void
     }
 
     /**
-     * @dataProvider nested_column_structures_provider
-     *
      * @param array<FlatColumn> $children
      */
+    #[DataProvider('nested_column_structures_provider')]
     public function test_constructor_with_different_nested_structures(array $children, string $description) : void
     {
         $nestedColumn = NestedColumn::create('nested', $children);
@@ -759,9 +759,7 @@ public function test_workflow_multiple_cycles() : void
         self::assertSame(3, $containers[0]->columnChunk->valuesCount());
     }
 
-    /**
-     * @dataProvider compression_types_provider
-     */
+    #[DataProvider('compression_types_provider')]
     public function test_workflow_with_different_compressions(Compressions $compression) : void
     {
         $childColumn = new FlatColumn('child', PhysicalType::INT32);
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/ColumnChunkBuilder/PlainFlatColumnChunkBuilderTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/ColumnChunkBuilder/PlainFlatColumnChunkBuilderTest.php
@@ -11,6 +11,7 @@
 use Flow\Parquet\ParquetFile\Schema\{FlatColumn, LogicalType, PhysicalType};
 use Flow\Parquet\Writer\ColumnChunkBuilder\PlainFlatColumnChunkBuilder;
 use Flow\Parquet\Writer\ColumnChunkContainer;
+use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\TestCase;
 
 final class PlainFlatColumnChunkBuilderTest extends TestCase
@@ -266,9 +267,7 @@ public function test_close_page_with_data() : void
         self::assertGreaterThan(0, $builder->uncompressedSize());
     }
 
-    /**
-     * @dataProvider writer_version_provider
-     */
+    #[DataProvider('writer_version_provider')]
     public function test_close_page_with_different_writer_versions(int $writerVersion) : void
     {
         $column = new FlatColumn('test_col', PhysicalType::INT32);
@@ -369,9 +368,7 @@ public function test_constructor_with_byte_array_logical_type() : void
         self::assertSame($column, $builder->column());
     }
 
-    /**
-     * @dataProvider compression_types_provider
-     */
+    #[DataProvider('compression_types_provider')]
     public function test_constructor_with_different_compressions(Compressions $compression) : void
     {
         $column = new FlatColumn('test_col', PhysicalType::INT32);
@@ -382,9 +379,7 @@ public function test_constructor_with_different_compressions(Compressions $compr
         self::assertInstanceOf(PlainFlatColumnChunkBuilder::class, $builder);
     }
 
-    /**
-     * @dataProvider physical_types_provider
-     */
+    #[DataProvider('physical_types_provider')]
     public function test_constructor_with_different_physical_types(PhysicalType $physicalType, mixed $sampleValue) : void
     {
         $column = new FlatColumn('test_col', $physicalType);
@@ -624,9 +619,7 @@ public function test_is_full_initially_false() : void
         self::assertFalse($builder->isFull());
     }
 
-    /**
-     * @dataProvider page_size_provider
-     */
+    #[DataProvider('page_size_provider')]
     public function test_is_full_respects_page_size_option(int $pageSize) : void
     {
         $column = new FlatColumn('test_col', PhysicalType::INT32);
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/ColumnChunkBuilder/RLEDictionaryChunkBuilderTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/ColumnChunkBuilder/RLEDictionaryChunkBuilderTest.php
@@ -94,10 +94,9 @@ public function test_add_multiple_rows() : void
     }
 
     /**
-     * @dataProvider dictionary_data_provider
-     *
      * @param array<mixed> $values
      */
+    #[DataProvider('dictionary_data_provider')]
     public function test_add_row_with_dictionary_data(array $values, string $description) : void
     {
         $column = new FlatColumn('test_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
@@ -250,9 +249,7 @@ public function test_close_page_with_data_builds_dictionary() : void
         self::assertGreaterThan(0, $builder->uncompressedSize());
     }
 
-    /**
-     * @dataProvider writer_version_provider
-     */
+    #[DataProvider('writer_version_provider')]
     public function test_close_page_with_different_writer_versions(int $writerVersion) : void
     {
         $column = new FlatColumn('test_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
@@ -329,9 +326,7 @@ public function test_constructor_initializes_correctly() : void
         self::assertSame(0, $builder->uncompressedSize());
     }
 
-    /**
-     * @dataProvider compression_types_provider
-     */
+    #[DataProvider('compression_types_provider')]
     public function test_constructor_with_different_compressions(Compressions $compression) : void
     {
         $column = new FlatColumn('test_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
@@ -343,10 +338,9 @@ public function test_constructor_with_different_compressions(Compressions $compr
     }
 
     /**
-     * @dataProvider physical_types_provider
-     *
      * @param array<mixed> $sampleValues
      */
+    #[DataProvider('physical_types_provider')]
     public function test_constructor_with_different_physical_types(PhysicalType $physicalType, array $sampleValues) : void
     {
         $column = new FlatColumn('test_col', $physicalType);
@@ -645,9 +639,7 @@ public function test_is_full_initially_false() : void
         self::assertFalse($builder->isFull());
     }
 
-    /**
-     * @dataProvider page_size_provider
-     */
+    #[DataProvider('page_size_provider')]
     public function test_is_full_respects_page_size_option(int $pageSize) : void
     {
         $column = new FlatColumn('test_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/StatisticsCounterTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/StatisticsCounterTest.php
diff --git a/tools/infection/.gitignore b/tools/infection/.gitignore
diff --git a/tools/infection/phpunit.xml b/tools/infection/phpunit.xml

Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,7 @@`
`6`	`6`
`7`	`7`	`use Flow\ETL\NativePHPRandomValueGenerator;`
`8`	`8`	`use Flow\ETL\Tests\FlowTestCase;`
	`9`	`+use PHPUnit\Framework\Attributes\DataProvider;`
`9`	`10`
`10`	`11`	`final class NativePHPRandomValueGeneratorTest extends FlowTestCase`
`11`	`12`	`{`
`@@ -51,7 +52,7 @@ public function test_can_create_random_int_from_given_range() : void`
`51`	`52`	`);`
`52`	`53`	`}`
`53`	`54`
`54`		`- /** @dataProvider integers_provider */`
	`55`	`+ #[DataProvider('integers_provider')]`
`55`	`56`	`public function test_can_create_random_string_with_given_length(int $expectedLength) : void`
`56`	`57`	`{`
`57`	`58`	`self::assertSame($expectedLength, mb_strlen((new NativePHPRandomValueGenerator())->string($expectedLength)));`
`@@ -69,14 +70,14 @@ public function test_empty_string_on_length_below_1() : void`
`69`	`70`	`);`
`70`	`71`	`}`
`71`	`72`
`72`		`- /** @dataProvider invalid_range_provider */`
	`73`	`+ #[DataProvider('invalid_range_provider')]`
`73`	`74`	`public function test_fail_on_invalid_range(int $min, int $max) : void`
`74`	`75`	`{`
`75`	`76`	`self::expectException(\ValueError::class);`
`76`	`77`	`(new NativePHPRandomValueGenerator())->int($min, $max);`
`77`	`78`	`}`
`78`	`79`
`79`		`- /** @dataProvider valid_range_provider */`
	`80`	`+ #[DataProvider('valid_range_provider')]`
`80`	`81`	`public function test_return_random_int_on_valid_range(int $min, int $max) : void`
`81`	`82`	`{`
`82`	`83`	`self::assertThat(`
Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,7 @@`
`8`	`8`	`use Flow\Filesystem\Exception\InvalidArgumentException;`
`9`	`9`	`use Flow\Filesystem\Path\{Options, UnixPath};`
`10`	`10`	`use Flow\Filesystem\Tests\Unit\PathTestCase;`
	`11`	`+use PHPUnit\Framework\Attributes\DataProvider;`
`11`	`12`
`12`	`13`	`final class UnixPathTest extends PathTestCase`
`13`	`14`	`{`
`@@ -221,9 +222,7 @@ public function test_options_handling() : void`
`221`	`222`	`self::assertEquals(['key' => 'value'], $path->options()->toArray());`
`222`	`223`	`}`
`223`	`224`
`224`		`- /**`
`225`		`- * @dataProvider pathProvider`
`226`		`- */`
	`225`	`+ #[DataProvider('pathProvider')]`
`227`	`226`	`public function test_os_agnostic_logic(string $input, string $expectedPath, string $expectedScheme) : void`
`228`	`227`	`{`
`229`	`228`	`$path = new UnixPath($input);`
`@@ -311,9 +310,7 @@ public function test_path_method() : void`
`311`	`310`	`self::assertEquals('/path/file.txt', $path->path());`
`312`	`311`	`}`
`313`	`312`
`314`		`- /**`
`315`		`- * @dataProvider patternProvider`
`316`		`- */`
	`313`	`+ #[DataProvider('patternProvider')]`
`317`	`314`	`public function test_pattern_logic(string $pattern, string $filename, bool $expected) : void`
`318`	`315`	`{`
`319`	`316`	`$patternPath = new UnixPath($pattern);`
`@@ -468,9 +465,7 @@ public function test_set_extension_without_existing_extension() : void`
`468`	`465`	`self::assertEquals('/path/to/file.txt', $newPath->path());`
`469`	`466`	`}`
`470`	`467`
`471`		`- /**`
`472`		`- * @dataProvider partitionProvider`
`473`		`- */`
	`468`	`+ #[DataProvider('partitionProvider')]`
`474`	`469`	`public function test_shared_partition_logic(string $input, array $partitionData, string $expected) : void`
`475`	`470`	`{`
`476`	`471`	`$path = new UnixPath($input);`
Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,7 @@`
`8`	`8`	`use Flow\Filesystem\Exception\InvalidArgumentException;`
`9`	`9`	`use Flow\Filesystem\Path\{Options, WindowsPath};`
`10`	`10`	`use Flow\Filesystem\Tests\Unit\PathTestCase;`
	`11`	`+use PHPUnit\Framework\Attributes\DataProvider;`
`11`	`12`
`12`	`13`	`final class WindowsPathTest extends PathTestCase`
`13`	`14`	`{`
`@@ -253,9 +254,7 @@ public function test_options_handling() : void`
`253`	`254`	`self::assertEquals(['key' => 'value'], $path->options()->toArray());`
`254`	`255`	`}`
`255`	`256`
`256`		`- /**`
`257`		`- * @dataProvider pathProvider`
`258`		`- */`
	`257`	`+ #[DataProvider('pathProvider')]`
`259`	`258`	`public function test_os_agnostic_logic(string $input, string $expectedPath, string $expectedScheme) : void`
`260`	`259`	`{`
`261`	`260`	`$path = new WindowsPath($input);`
`@@ -264,9 +263,7 @@ public function test_os_agnostic_logic(string $input, string $expectedPath, stri`
`264`	`263`	`self::assertEquals($expectedScheme, $path->protocol()->name);`
`265`	`264`	`}`
`266`	`265`
`267`		`- /**`
`268`		`- * @dataProvider partitionProvider`
`269`		`- */`
	`266`	`+ #[DataProvider('partitionProvider')]`
`270`	`267`	`public function test_partition_logic(string $input, array $partitionData, string $expected) : void`
`271`	`268`	`{`
`272`	`269`	`$path = new WindowsPath($input);`
`@@ -364,9 +361,7 @@ public function test_pathinfo_backslash_edge_case() : void`
`364`	`361`	`self::assertEquals('file://', $parent->uri());`
`365`	`362`	`}`
`366`	`363`
`367`		`- /**`
`368`		`- * @dataProvider patternProvider`
`369`		`- */`
	`364`	`+ #[DataProvider('patternProvider')]`
`370`	`365`	`public function test_pattern_logic(string $pattern, string $filename, bool $expected) : void`
`371`	`366`	`{`
`372`	`367`	`$patternPath = new WindowsPath($pattern);`
Original file line number	Diff line number	Diff line change
`@@ -21,16 +21,15 @@ public function build(WriteFlatColumnValues $data) : Dictionary`
`21`	`21`	`continue;`
`22`	`22`	`}`
`23`	`23`
`24`		`- /** @phpstan-ignore-next-line */`
`25`		`- if (!isset($valueToIndex[$value])) {`
	`24`	`+ $key = \is_float($value) ? \serialize($value) : $value;`
	`25`	`+`
	`26`	`+ if (!isset($valueToIndex[$key])) {`
`26`	`27`	`$dictionary[] = $value;`
`27`		`- /** @phpstan-ignore-next-line */`
`28`		`- $valueToIndex[$value] = $dictionarySize;`
	`28`	`+ $valueToIndex[$key] = $dictionarySize;`
`29`	`29`	`$dictionarySize++;`
`30`	`30`	`}`
`31`	`31`
`32`		`- /** @phpstan-ignore-next-line */`
`33`		`- $indices[] = $valueToIndex[$value];`
	`32`	`+ $indices[] = $valueToIndex[$key];`
`34`	`33`	`}`
`35`	`34`
`36`	`35`	`foreach ($dictionary as $index => $value) {`
Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,7 @@`
`9`	`9`	`use Flow\Parquet\Exception\RuntimeException;`
`10`	`10`	`use Flow\Parquet\ParquetFile\Schema;`
`11`	`11`	`use Flow\Parquet\ParquetFile\Schema\{FlatColumn, ListElement, MapKey, MapValue, NestedColumn};`
	`12`	`+use PHPUnit\Framework\Attributes\DataProvider;`
`12`	`13`	`use PHPUnit\Framework\TestCase;`
`13`	`14`
`14`	`15`	`final class WriteColumnDataTest extends TestCase`
`@@ -102,9 +103,7 @@ public function test_add_value_multiple_values() : void`
`102`	`103`	`);`
`103`	`104`	`}`
`104`	`105`
`105`		`- /**`
`106`		`- * @dataProvider valueTypesDataProvider`
`107`		`- */`
	`106`	`+ #[DataProvider('valueTypesDataProvider')]`
`108`	`107`	`public function test_add_value_with_different_value_types(int\|float\|string\|bool\|null $value, string $expectedType) : void`
`109`	`108`	`{`
`110`	`109`	`/** @var FlatColumn $column */`
`@@ -222,10 +221,9 @@ public function test_flat_values_returns_all_flat_values() : void`
`222`	`221`	`}`
`223`	`222`
`224`	`223`	`/**`
`225`		`- * @dataProvider initializeDataProvider`
`226`		`- *`
`227`	`224`	`* @param array<string> $expectedFlatPaths`
`228`	`225`	`*/`
	`226`	`+ #[DataProvider('initializeDataProvider')]`
`229`	`227`	`public function test_initialize_with_different_column_types(Schema $schema, string $columnPath, array $expectedFlatPaths) : void`
`230`	`228`	`{`
`231`	`229`	`$column = $schema->get($columnPath);`
`@@ -240,9 +238,7 @@ public function test_initialize_with_different_column_types(Schema $schema, stri`
`240`	`238`	`}`
`241`	`239`	`}`
`242`	`240`
`243`		`- /**`
`244`		`- * @dataProvider isEmptyDataProvider`
`245`		`- */`
	`241`	`+ #[DataProvider('isEmptyDataProvider')]`
`246`	`242`	`public function test_is_empty(bool $isEmpty, \Closure $setupCallback) : void`
`247`	`243`	`{`
`248`	`244`	`/** @var FlatColumn $column */`
Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,7 @@`
`5`	`5`	`namespace Flow\Parquet\Tests\Unit\Thrift;`
`6`	`6`
`7`	`7`	`use Flow\Parquet\Thrift\MemoryBuffer;`
	`8`	`+use PHPUnit\Framework\Attributes\DataProvider;`
`8`	`9`	`use PHPUnit\Framework\TestCase;`
`9`	`10`	`use Thrift\Exception\TTransportException;`
`10`	`11`
`@@ -258,9 +259,7 @@ public function test_read_sequential_operations() : void`
`258`	`259`	`self::assertSame(0, $buffer->available());`
`259`	`260`	`}`
`260`	`261`
`261`		`- /**`
`262`		`- * @dataProvider read_length_provider`
`263`		`- */`
	`262`	`+ #[DataProvider('read_length_provider')]`
`264`	`263`	`public function test_read_various_lengths(int $dataLength, int $readLength, int $expectedReadLength) : void`
`265`	`264`	`{`
`266`	`265`	`$data = \str_repeat('A', $dataLength);`
`@@ -351,9 +350,7 @@ public function test_write_multiple_times() : void`
`351`	`350`	`self::assertSame(11, $buffer->available());`
`352`	`351`	`}`
`353`	`352`
`354`		`- /**`
`355`		`- * @dataProvider write_data_provider`
`356`		`- */`
	`353`	`+ #[DataProvider('write_data_provider')]`
`357`	`354`	`public function test_write_various_data_types(string $data) : void`
`358`	`355`	`{`
`359`	`356`	`$buffer = new MemoryBuffer();`