Use attributes for test data providers

mvorisek · mvorisek · commit 48988b20acf7 · 2024-12-05T14:03:42.000+01:00
diff --git a/.github/workflows/test-unit.yml b/.github/workflows/test-unit.yml
@@ -42,7 +42,7 @@ jobs:
       - name: "Run tests (only for Phpunit)"
         if: startsWith(matrix.type, 'Phpunit')
         run: |
-          vendor/bin/phpunit --exclude-group none --no-coverage --fail-on-warning --fail-on-risky $(if vendor/bin/phpunit --version | grep -q '^PHPUnit 9\.'; then echo -v; else echo --fail-on-notice --fail-on-deprecation --display-notices --display-deprecations --display-warnings --display-errors --display-incomplete --display-skipped; fi)
+          vendor/bin/phpunit --exclude-group none --no-coverage --fail-on-warning --fail-on-risky $(if vendor/bin/phpunit --version | grep -q '^PHPUnit 9\.'; then echo -v; else echo --fail-on-notice --fail-on-deprecation --display-notices --display-deprecations --display-phpunit-deprecations --display-warnings --display-errors --display-incomplete --display-skipped; fi)
 
       - name: Check Coding Style (only for CodingStyle)
         if: matrix.type == 'CodingStyle'
@@ -133,7 +133,7 @@ jobs:
           REDIS_URIS: "redis://redis1,redis://redis2,redis://redis3"
           MEMCACHE_HOST: memcached
         run: |
-          php -d opcache.enable_cli=1 vendor/bin/phpunit --exclude-group none $(if [ -n "$LOG_COVERAGE" ]; then echo --coverage-text; else echo --no-coverage; fi) --fail-on-warning --fail-on-risky $(if vendor/bin/phpunit --version | grep -q '^PHPUnit 9\.'; then echo -v; else echo --fail-on-notice --fail-on-deprecation --display-notices --display-deprecations --display-warnings --display-errors --display-incomplete --display-skipped; fi)
+          php -d opcache.enable_cli=1 vendor/bin/phpunit --exclude-group none $(if [ -n "$LOG_COVERAGE" ]; then echo --coverage-text; else echo --no-coverage; fi) --fail-on-warning --fail-on-risky $(if vendor/bin/phpunit --version | grep -q '^PHPUnit 9\.'; then echo -v; else echo --fail-on-notice --fail-on-deprecation --display-notices --display-deprecations --display-phpunit-deprecations --display-warnings --display-errors --display-incomplete --display-skipped; fi)
 
       - name: "Run tests 2/2"
         env:
@@ -146,7 +146,7 @@ jobs:
           REDIS_URIS: "redis://valkey1,redis://valkey2,redis://valkey3"
           MEMCACHE_HOST: memcached
         run: |
-          php -d opcache.enable_cli=1 vendor/bin/phpunit --exclude-group none $(if [ -n "$LOG_COVERAGE" ]; then echo --coverage-text; else echo --no-coverage; fi) --fail-on-warning --fail-on-risky $(if vendor/bin/phpunit --version | grep -q '^PHPUnit 9\.'; then echo -v; else echo --fail-on-notice --fail-on-deprecation --display-notices --display-deprecations --display-warnings --display-errors --display-incomplete --display-skipped; fi)
+          php -d opcache.enable_cli=1 vendor/bin/phpunit --exclude-group none $(if [ -n "$LOG_COVERAGE" ]; then echo --coverage-text; else echo --no-coverage; fi) --fail-on-warning --fail-on-risky $(if vendor/bin/phpunit --version | grep -q '^PHPUnit 9\.'; then echo -v; else echo --fail-on-notice --fail-on-deprecation --display-notices --display-deprecations --display-phpunit-deprecations --display-warnings --display-errors --display-incomplete --display-skipped; fi)
 
       - name: Upload coverage (only for coverage)
         if: env.LOG_COVERAGE && false # TODO
diff --git a/tests/mutex/FlockMutexTest.php b/tests/mutex/FlockMutexTest.php
@@ -9,6 +9,7 @@
 use malkusch\lock\exception\TimeoutException;
 use malkusch\lock\mutex\FlockMutex;
 use malkusch\lock\util\PcntlTimeout;
+use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\TestCase;
 
 class FlockMutexTest extends TestCase
@@ -41,6 +42,7 @@ protected function tearDown(): void
      *
      * @dataProvider provideTimeoutableStrategiesCases
      */
+    #[DataProvider('provideTimeoutableStrategiesCases')]
     public function testCodeExecutedOutsideLockIsNotThrown(int $strategy): void
     {
         $this->mutex->strategy = $strategy; // @phpstan-ignore property.private
@@ -57,6 +59,7 @@ public function testCodeExecutedOutsideLockIsNotThrown(int $strategy): void
      *
      * @dataProvider provideTimeoutableStrategiesCases
      */
+    #[DataProvider('provideTimeoutableStrategiesCases')]
     public function testTimeoutOccurs(int $strategy): void
     {
         $this->expectException(TimeoutException::class);
diff --git a/tests/mutex/MemcachedMutexTest.php b/tests/mutex/MemcachedMutexTest.php
@@ -7,6 +7,7 @@
 use malkusch\lock\exception\LockReleaseException;
 use malkusch\lock\exception\TimeoutException;
 use malkusch\lock\mutex\MemcachedMutex;
+use PHPUnit\Framework\Attributes\RequiresPhpExtension;
 use PHPUnit\Framework\MockObject\MockObject;
 use PHPUnit\Framework\TestCase;
 
@@ -15,6 +16,7 @@
  *
  * @requires extension memcached
  */
+#[RequiresPhpExtension('memcached')]
 class MemcachedMutexTest extends TestCase
 {
     /** @var \Memcached|MockObject */
diff --git a/tests/mutex/MutexConcurrencyTest.php b/tests/mutex/MutexConcurrencyTest.php
@@ -14,6 +14,7 @@
 use malkusch\lock\mutex\PredisMutex;
 use malkusch\lock\mutex\SemaphoreMutex;
 use malkusch\lock\mutex\TransactionalMutex;
+use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\Constraint\IsType;
 use PHPUnit\Framework\TestCase;
 use Predis\Client;
@@ -84,6 +85,7 @@ private function fork(int $concurrency, \Closure $code): void
      *
      * @dataProvider provideHighContentionCases
      */
+    #[DataProvider('provideHighContentionCases')]
     public function testHighContention(\Closure $code, \Closure $mutexFactory): void
     {
         $concurrency = 10;
@@ -196,6 +198,7 @@ static function ($timeout = 3) use ($dsn, $user, $password) {
      *
      * @dataProvider provideExecutionIsSerializedWhenLockedCases
      */
+    #[DataProvider('provideExecutionIsSerializedWhenLockedCases')]
     public function testExecutionIsSerializedWhenLocked(\Closure $mutexFactory): void
     {
         $time = \microtime(true);
diff --git a/tests/mutex/MutexTest.php b/tests/mutex/MutexTest.php
@@ -18,6 +18,7 @@
 use malkusch\lock\mutex\SpinlockMutex;
 use malkusch\lock\mutex\TransactionalMutex;
 use org\bovigo\vfs\vfsStream;
+use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\TestCase;
 use Predis\Client;
 
@@ -192,6 +193,7 @@ static function ($uri) {
      *
      * @dataProvider provideMutexFactoriesCases
      */
+    #[DataProvider('provideMutexFactoriesCases')]
     public function testSynchronizedDelegates(\Closure $mutexFactory): void
     {
         /** @var Mutex $mutex */
@@ -209,6 +211,7 @@ public function testSynchronizedDelegates(\Closure $mutexFactory): void
      *
      * @dataProvider provideMutexFactoriesCases
      */
+    #[DataProvider('provideMutexFactoriesCases')]
     public function testRelease(\Closure $mutexFactory): void
     {
         $mutex = $mutexFactory();
@@ -225,6 +228,7 @@ public function testRelease(\Closure $mutexFactory): void
      *
      * @dataProvider provideMutexFactoriesCases
      */
+    #[DataProvider('provideMutexFactoriesCases')]
     public function testSynchronizedPassesExceptionThrough(\Closure $mutexFactory): void
     {
         $this->expectException(\DomainException::class);
diff --git a/tests/mutex/PHPRedisMutexTest.php b/tests/mutex/PHPRedisMutexTest.php
@@ -8,6 +8,9 @@
 use malkusch\lock\exception\LockReleaseException;
 use malkusch\lock\exception\MutexException;
 use malkusch\lock\mutex\PHPRedisMutex;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\Attributes\Group;
+use PHPUnit\Framework\Attributes\RequiresPhpExtension;
 use PHPUnit\Framework\TestCase;
 
 if (\PHP_MAJOR_VERSION >= 8) {
@@ -63,6 +66,8 @@ public function set($key, $value, $options = null)
  *
  * @group redis
  */
+#[RequiresPhpExtension('redis')]
+#[Group('redis')]
 class PHPRedisMutexTest extends TestCase
 {
     /** @var \Redis[] */
@@ -203,6 +208,7 @@ public function testEvalScriptFails(): void
      *
      * @dataProvider provideSerializersAndCompressorsCases
      */
+    #[DataProvider('provideSerializersAndCompressorsCases')]
     public function testSerializersAndCompressors($serializer, $compressor): void
     {
         foreach ($this->connections as $connection) {
diff --git a/tests/mutex/PredisMutexTest.php b/tests/mutex/PredisMutexTest.php
@@ -7,6 +7,7 @@
 use malkusch\lock\exception\LockAcquireException;
 use malkusch\lock\exception\LockReleaseException;
 use malkusch\lock\mutex\PredisMutex;
+use PHPUnit\Framework\Attributes\Group;
 use PHPUnit\Framework\MockObject\MockObject;
 use PHPUnit\Framework\TestCase;
 use Predis\ClientInterface;
@@ -16,6 +17,7 @@
 /**
  * @group redis
  */
+#[Group('redis')]
 class PredisMutexTest extends TestCase
 {
     /** @var ClientInterface|MockObject */
diff --git a/tests/mutex/RedisMutexTest.php b/tests/mutex/RedisMutexTest.php
@@ -11,12 +11,15 @@
 use malkusch\lock\mutex\RedisMutex;
 use phpmock\environment\SleepEnvironmentBuilder;
 use phpmock\phpunit\PHPMock;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\Attributes\Group;
 use PHPUnit\Framework\MockObject\MockObject;
 use PHPUnit\Framework\TestCase;
 
 /**
  * @group redis
  */
+#[Group('redis')]
 class RedisMutexTest extends TestCase
 {
     use PHPMock;
@@ -63,6 +66,7 @@ static function ($id): array {
      *
      * @dataProvider provideMinorityCases
      */
+    #[DataProvider('provideMinorityCases')]
     public function testTooFewServerToAcquire(int $count, int $available): void
     {
         $this->expectException(LockAcquireException::class);
@@ -98,6 +102,7 @@ static function () use (&$i, $available): bool {
      *
      * @dataProvider provideMajorityCases
      */
+    #[DataProvider('provideMajorityCases')]
     public function testFaultTolerance(int $count, int $available): void
     {
         $mutex = $this->buildRedisMutex($count);
@@ -131,6 +136,7 @@ static function () use (&$i, $available): bool {
      *
      * @dataProvider provideMinorityCases
      */
+    #[DataProvider('provideMinorityCases')]
     public function testAcquireTooFewKeys($count, $available): void
     {
         $this->expectException(TimeoutException::class);
@@ -163,6 +169,7 @@ static function () use (&$i, $available): bool {
      *
      * @dataProvider provideTimingOutCases
      */
+    #[DataProvider('provideTimingOutCases')]
     public function testTimingOut(int $count, float $timeout, float $delay): void
     {
         $timeoutStr = (string) round($timeout, 6);
@@ -210,6 +217,7 @@ public static function provideTimingOutCases(): iterable
      *
      * @dataProvider provideMajorityCases
      */
+    #[DataProvider('provideMajorityCases')]
     public function testAcquireWithMajority(int $count, int $available): void
     {
         $mutex = $this->buildRedisMutex($count);
@@ -239,6 +247,7 @@ static function () use (&$i, $available): bool {
      *
      * @dataProvider provideMinorityCases
      */
+    #[DataProvider('provideMinorityCases')]
     public function testTooFewServersToRelease(int $count, int $available): void
     {
         $mutex = $this->buildRedisMutex($count);
@@ -274,6 +283,7 @@ static function () use (&$i, $available): bool {
      *
      * @dataProvider provideMinorityCases
      */
+    #[DataProvider('provideMinorityCases')]
     public function testReleaseTooFewKeys(int $count, int $available): void
     {
         $mutex = $this->buildRedisMutex($count);
diff --git a/tests/mutex/TransactionalMutexTest.php b/tests/mutex/TransactionalMutexTest.php
@@ -6,6 +6,7 @@
 
 use malkusch\lock\exception\LockAcquireException;
 use malkusch\lock\mutex\TransactionalMutex;
+use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\TestCase;
 
 /**
@@ -18,6 +19,7 @@ class TransactionalMutexTest extends TestCase
      *
      * @dataProvider provideInvalidErrorModeCases
      */
+    #[DataProvider('provideInvalidErrorModeCases')]
     public function testInvalidErrorMode(int $mode): void
     {
         $this->expectException(\InvalidArgumentException::class);
@@ -109,6 +111,7 @@ public function testFailExceptionRollsback(): void
      *
      * @dataProvider provideReplayTransactionCases
      */
+    #[DataProvider('provideReplayTransactionCases')]
     public function testReplayTransaction(\Exception $exception): void
     {
         $pdo = $this->buildMySqlPdo();
diff --git a/tests/util/DoubleCheckedLockingTest.php b/tests/util/DoubleCheckedLockingTest.php
@@ -6,6 +6,7 @@
 
 use malkusch\lock\mutex\Mutex;
 use malkusch\lock\util\DoubleCheckedLocking;
+use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\MockObject\MockObject;
 use PHPUnit\Framework\TestCase;
 
@@ -87,6 +88,7 @@ public function testLockedCheckAndExecution(): void
      *
      * @dataProvider provideCodeNotExecutedCases
      */
+    #[DataProvider('provideCodeNotExecutedCases')]
     public function testCodeNotExecuted(\Closure $check): void
     {
         $this->mutex->expects(self::any())

Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,7 @@`
`9`	`9`	`use malkusch\lock\exception\TimeoutException;`
`10`	`10`	`use malkusch\lock\mutex\FlockMutex;`
`11`	`11`	`use malkusch\lock\util\PcntlTimeout;`
	`12`	`+use PHPUnit\Framework\Attributes\DataProvider;`
`12`	`13`	`use PHPUnit\Framework\TestCase;`
`13`	`14`
`14`	`15`	`class FlockMutexTest extends TestCase`
`@@ -41,6 +42,7 @@ protected function tearDown(): void`
`41`	`42`	`*`
`42`	`43`	`* @dataProvider provideTimeoutableStrategiesCases`
`43`	`44`	`*/`
	`45`	`+ #[DataProvider('provideTimeoutableStrategiesCases')]`
`44`	`46`	`public function testCodeExecutedOutsideLockIsNotThrown(int $strategy): void`
`45`	`47`	`{`
`46`	`48`	`$this->mutex->strategy = $strategy; // @phpstan-ignore property.private`
`@@ -57,6 +59,7 @@ public function testCodeExecutedOutsideLockIsNotThrown(int $strategy): void`
`57`	`59`	`*`
`58`	`60`	`* @dataProvider provideTimeoutableStrategiesCases`
`59`	`61`	`*/`
	`62`	`+ #[DataProvider('provideTimeoutableStrategiesCases')]`
`60`	`63`	`public function testTimeoutOccurs(int $strategy): void`
`61`	`64`	`{`
`62`	`65`	`$this->expectException(TimeoutException::class);`
Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,7 @@`
`7`	`7`	`use malkusch\lock\exception\LockReleaseException;`
`8`	`8`	`use malkusch\lock\exception\TimeoutException;`
`9`	`9`	`use malkusch\lock\mutex\MemcachedMutex;`
	`10`	`+use PHPUnit\Framework\Attributes\RequiresPhpExtension;`
`10`	`11`	`use PHPUnit\Framework\MockObject\MockObject;`
`11`	`12`	`use PHPUnit\Framework\TestCase;`
`12`	`13`
`@@ -15,6 +16,7 @@`
`15`	`16`	`*`
`16`	`17`	`* @requires extension memcached`
`17`	`18`	`*/`
	`19`	`+#[RequiresPhpExtension('memcached')]`
`18`	`20`	`class MemcachedMutexTest extends TestCase`
`19`	`21`	`{`
`20`	`22`	`/** @var \Memcached\|MockObject */`
Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,7 @@`
`14`	`14`	`use malkusch\lock\mutex\PredisMutex;`
`15`	`15`	`use malkusch\lock\mutex\SemaphoreMutex;`
`16`	`16`	`use malkusch\lock\mutex\TransactionalMutex;`
	`17`	`+use PHPUnit\Framework\Attributes\DataProvider;`
`17`	`18`	`use PHPUnit\Framework\Constraint\IsType;`
`18`	`19`	`use PHPUnit\Framework\TestCase;`
`19`	`20`	`use Predis\Client;`
`@@ -84,6 +85,7 @@ private function fork(int $concurrency, \Closure $code): void`
`84`	`85`	`*`
`85`	`86`	`* @dataProvider provideHighContentionCases`
`86`	`87`	`*/`
	`88`	`+ #[DataProvider('provideHighContentionCases')]`
`87`	`89`	`public function testHighContention(\Closure $code, \Closure $mutexFactory): void`
`88`	`90`	`{`
`89`	`91`	`$concurrency = 10;`
`@@ -196,6 +198,7 @@ static function ($timeout = 3) use ($dsn, $user, $password) {`
`196`	`198`	`*`
`197`	`199`	`* @dataProvider provideExecutionIsSerializedWhenLockedCases`
`198`	`200`	`*/`
	`201`	`+ #[DataProvider('provideExecutionIsSerializedWhenLockedCases')]`
`199`	`202`	`public function testExecutionIsSerializedWhenLocked(\Closure $mutexFactory): void`
`200`	`203`	`{`
`201`	`204`	`$time = \microtime(true);`
Original file line number	Diff line number	Diff line change
`@@ -18,6 +18,7 @@`
`18`	`18`	`use malkusch\lock\mutex\SpinlockMutex;`
`19`	`19`	`use malkusch\lock\mutex\TransactionalMutex;`
`20`	`20`	`use org\bovigo\vfs\vfsStream;`
	`21`	`+use PHPUnit\Framework\Attributes\DataProvider;`
`21`	`22`	`use PHPUnit\Framework\TestCase;`
`22`	`23`	`use Predis\Client;`
`23`	`24`
`@@ -192,6 +193,7 @@ static function ($uri) {`
`192`	`193`	`*`
`193`	`194`	`* @dataProvider provideMutexFactoriesCases`
`194`	`195`	`*/`
	`196`	`+ #[DataProvider('provideMutexFactoriesCases')]`
`195`	`197`	`public function testSynchronizedDelegates(\Closure $mutexFactory): void`
`196`	`198`	`{`
`197`	`199`	`/** @var Mutex $mutex */`
`@@ -209,6 +211,7 @@ public function testSynchronizedDelegates(\Closure $mutexFactory): void`
`209`	`211`	`*`
`210`	`212`	`* @dataProvider provideMutexFactoriesCases`
`211`	`213`	`*/`
	`214`	`+ #[DataProvider('provideMutexFactoriesCases')]`
`212`	`215`	`public function testRelease(\Closure $mutexFactory): void`
`213`	`216`	`{`
`214`	`217`	`$mutex = $mutexFactory();`
`@@ -225,6 +228,7 @@ public function testRelease(\Closure $mutexFactory): void`
`225`	`228`	`*`
`226`	`229`	`* @dataProvider provideMutexFactoriesCases`
`227`	`230`	`*/`
	`231`	`+ #[DataProvider('provideMutexFactoriesCases')]`
`228`	`232`	`public function testSynchronizedPassesExceptionThrough(\Closure $mutexFactory): void`
`229`	`233`	`{`
`230`	`234`	`$this->expectException(\DomainException::class);`
Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,9 @@`
`8`	`8`	`use malkusch\lock\exception\LockReleaseException;`
`9`	`9`	`use malkusch\lock\exception\MutexException;`
`10`	`10`	`use malkusch\lock\mutex\PHPRedisMutex;`
	`11`	`+use PHPUnit\Framework\Attributes\DataProvider;`
	`12`	`+use PHPUnit\Framework\Attributes\Group;`
	`13`	`+use PHPUnit\Framework\Attributes\RequiresPhpExtension;`
`11`	`14`	`use PHPUnit\Framework\TestCase;`
`12`	`15`
`13`	`16`	`if (\PHP_MAJOR_VERSION >= 8) {`
`@@ -63,6 +66,8 @@ public function set($key, $value, $options = null)`
`63`	`66`	`*`
`64`	`67`	`* @group redis`
`65`	`68`	`*/`
	`69`	`+#[RequiresPhpExtension('redis')]`
	`70`	`+#[Group('redis')]`
`66`	`71`	`class PHPRedisMutexTest extends TestCase`
`67`	`72`	`{`
`68`	`73`	`/** @var \Redis[] */`
`@@ -203,6 +208,7 @@ public function testEvalScriptFails(): void`
`203`	`208`	`*`
`204`	`209`	`* @dataProvider provideSerializersAndCompressorsCases`
`205`	`210`	`*/`
	`211`	`+ #[DataProvider('provideSerializersAndCompressorsCases')]`
`206`	`212`	`public function testSerializersAndCompressors($serializer, $compressor): void`
`207`	`213`	`{`
`208`	`214`	`foreach ($this->connections as $connection) {`
Original file line number	Diff line number	Diff line change
`@@ -11,12 +11,15 @@`
`11`	`11`	`use malkusch\lock\mutex\RedisMutex;`
`12`	`12`	`use phpmock\environment\SleepEnvironmentBuilder;`
`13`	`13`	`use phpmock\phpunit\PHPMock;`
	`14`	`+use PHPUnit\Framework\Attributes\DataProvider;`
	`15`	`+use PHPUnit\Framework\Attributes\Group;`
`14`	`16`	`use PHPUnit\Framework\MockObject\MockObject;`
`15`	`17`	`use PHPUnit\Framework\TestCase;`
`16`	`18`
`17`	`19`	`/**`
`18`	`20`	`* @group redis`
`19`	`21`	`*/`
	`22`	`+#[Group('redis')]`
`20`	`23`	`class RedisMutexTest extends TestCase`
`21`	`24`	`{`
`22`	`25`	`use PHPMock;`
`@@ -63,6 +66,7 @@ static function ($id): array {`
`63`	`66`	`*`
`64`	`67`	`* @dataProvider provideMinorityCases`
`65`	`68`	`*/`
	`69`	`+ #[DataProvider('provideMinorityCases')]`
`66`	`70`	`public function testTooFewServerToAcquire(int $count, int $available): void`
`67`	`71`	`{`
`68`	`72`	`$this->expectException(LockAcquireException::class);`
`@@ -98,6 +102,7 @@ static function () use (&$i, $available): bool {`
`98`	`102`	`*`
`99`	`103`	`* @dataProvider provideMajorityCases`
`100`	`104`	`*/`
	`105`	`+ #[DataProvider('provideMajorityCases')]`
`101`	`106`	`public function testFaultTolerance(int $count, int $available): void`
`102`	`107`	`{`
`103`	`108`	`$mutex = $this->buildRedisMutex($count);`
`@@ -131,6 +136,7 @@ static function () use (&$i, $available): bool {`
`131`	`136`	`*`
`132`	`137`	`* @dataProvider provideMinorityCases`
`133`	`138`	`*/`
	`139`	`+ #[DataProvider('provideMinorityCases')]`
`134`	`140`	`public function testAcquireTooFewKeys($count, $available): void`
`135`	`141`	`{`
`136`	`142`	`$this->expectException(TimeoutException::class);`
`@@ -163,6 +169,7 @@ static function () use (&$i, $available): bool {`
`163`	`169`	`*`
`164`	`170`	`* @dataProvider provideTimingOutCases`
`165`	`171`	`*/`
	`172`	`+ #[DataProvider('provideTimingOutCases')]`
`166`	`173`	`public function testTimingOut(int $count, float $timeout, float $delay): void`
`167`	`174`	`{`
`168`	`175`	`$timeoutStr = (string) round($timeout, 6);`
`@@ -210,6 +217,7 @@ public static function provideTimingOutCases(): iterable`
`210`	`217`	`*`
`211`	`218`	`* @dataProvider provideMajorityCases`
`212`	`219`	`*/`
	`220`	`+ #[DataProvider('provideMajorityCases')]`
`213`	`221`	`public function testAcquireWithMajority(int $count, int $available): void`
`214`	`222`	`{`
`215`	`223`	`$mutex = $this->buildRedisMutex($count);`
`@@ -239,6 +247,7 @@ static function () use (&$i, $available): bool {`
`239`	`247`	`*`
`240`	`248`	`* @dataProvider provideMinorityCases`
`241`	`249`	`*/`
	`250`	`+ #[DataProvider('provideMinorityCases')]`
`242`	`251`	`public function testTooFewServersToRelease(int $count, int $available): void`
`243`	`252`	`{`
`244`	`253`	`$mutex = $this->buildRedisMutex($count);`
`@@ -274,6 +283,7 @@ static function () use (&$i, $available): bool {`
`274`	`283`	`*`
`275`	`284`	`* @dataProvider provideMinorityCases`
`276`	`285`	`*/`
	`286`	`+ #[DataProvider('provideMinorityCases')]`
`277`	`287`	`public function testReleaseTooFewKeys(int $count, int $available): void`
`278`	`288`	`{`
`279`	`289`	`$mutex = $this->buildRedisMutex($count);`
Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,7 @@`
`6`	`6`
`7`	`7`	`use malkusch\lock\exception\LockAcquireException;`
`8`	`8`	`use malkusch\lock\mutex\TransactionalMutex;`
	`9`	`+use PHPUnit\Framework\Attributes\DataProvider;`
`9`	`10`	`use PHPUnit\Framework\TestCase;`
`10`	`11`
`11`	`12`	`/**`
`@@ -18,6 +19,7 @@ class TransactionalMutexTest extends TestCase`
`18`	`19`	`*`
`19`	`20`	`* @dataProvider provideInvalidErrorModeCases`
`20`	`21`	`*/`
	`22`	`+ #[DataProvider('provideInvalidErrorModeCases')]`
`21`	`23`	`public function testInvalidErrorMode(int $mode): void`
`22`	`24`	`{`
`23`	`25`	`$this->expectException(\InvalidArgumentException::class);`
`@@ -109,6 +111,7 @@ public function testFailExceptionRollsback(): void`
`109`	`111`	`*`
`110`	`112`	`* @dataProvider provideReplayTransactionCases`
`111`	`113`	`*/`
	`114`	`+ #[DataProvider('provideReplayTransactionCases')]`
`112`	`115`	`public function testReplayTransaction(\Exception $exception): void`
`113`	`116`	`{`
`114`	`117`	`$pdo = $this->buildMySqlPdo();`
Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,7 @@`
`6`	`6`
`7`	`7`	`use malkusch\lock\mutex\Mutex;`
`8`	`8`	`use malkusch\lock\util\DoubleCheckedLocking;`
	`9`	`+use PHPUnit\Framework\Attributes\DataProvider;`
`9`	`10`	`use PHPUnit\Framework\MockObject\MockObject;`
`10`	`11`	`use PHPUnit\Framework\TestCase;`
`11`	`12`
`@@ -87,6 +88,7 @@ public function testLockedCheckAndExecution(): void`
`87`	`88`	`*`
`88`	`89`	`* @dataProvider provideCodeNotExecutedCases`
`89`	`90`	`*/`
	`91`	`+ #[DataProvider('provideCodeNotExecutedCases')]`
`90`	`92`	`public function testCodeNotExecuted(\Closure $check): void`
`91`	`93`	`{`
`92`	`94`	`$this->mutex->expects(self::any())`