diff --git a/exercises/concept/lucky-numbers/.meta/config.json b/exercises/concept/lucky-numbers/.meta/config.json
index 368f6ef08..9c0eda6e0 100644
--- a/exercises/concept/lucky-numbers/.meta/config.json
+++ b/exercises/concept/lucky-numbers/.meta/config.json
@@ -2,6 +2,9 @@
   "authors": [
     "mk-mxp"
   ],
+  "contributors": [
+    "resu-xuniL"
+  ],
   "files": {
     "solution": [
       "LuckyNumbers.php"
diff --git a/exercises/concept/lucky-numbers/LuckyNumbersTest.php b/exercises/concept/lucky-numbers/LuckyNumbersTest.php
index ad55249ec..d9bfe9648 100644
--- a/exercises/concept/lucky-numbers/LuckyNumbersTest.php
+++ b/exercises/concept/lucky-numbers/LuckyNumbersTest.php
@@ -1,7 +1,6 @@
 <?php
 
 use PHPUnit\Framework\TestCase;
-use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\Attributes\TestDox;
 
 class LuckyNumbersTest extends TestCase
@@ -14,143 +13,260 @@ public static function setUpBeforeClass(): void
     /**
      * @task_id 1
      */
-    #[DataProvider('sumUpTestCases')]
-    #[TestDox('Sums up $digitsOfNumber1 and $digitsOfNumber2 to $expected')]
-    public function testSumUp(
-        array $digitsOfNumber1,
-        array $digitsOfNumber2,
-        int $expected
-    ): void {
-        $class = new LuckyNumbers();
+    #[TestDox('Sums up two single digit numbers')]
+    public function testSumsUpTwoSingleDigitNumbers(): void
+    {
+        $luckynumber = new LuckyNumbers();
+        $this->assertEquals(9, $luckynumber->sumUp([2], [7]));
+    }
+
+    /**
+     * @task_id 1
+     */
+    #[TestDox('Sums up two numbers with two digits each')]
+    public function testSumsUpTwoNumbersWithTwoDigitsEach(): void
+    {
+        $luckynumber = new LuckyNumbers();
+        $this->assertEquals(81, $luckynumber->sumUp([2, 4], [5, 7]));
+    }
+
+    /**
+     * @task_id 1
+     */
+    #[TestDox('Sums up two numbers with three digits each')]
+    public function testSumsUpTwoNumbersWithThreeDigitsEach(): void
+    {
+        $luckynumber = new LuckyNumbers();
+        $this->assertEquals(896, $luckynumber->sumUp([5, 3, 4], [3, 6, 2]));
+    }
+
+    /**
+     * @task_id 1
+     */
+    #[TestDox('Sums up two numbers when the first contains fewer digits than the second')]
+    public function testSumsUpTwoNumbersWhenTheFirstContainsFewerDigitsThanTheSecond(): void
+    {
+        $luckynumber = new LuckyNumbers();
+        $this->assertEquals(181, $luckynumber->sumUp([2, 4], [1, 5, 7]));
+    }
 
-        $actual = $class->sumUp($digitsOfNumber1, $digitsOfNumber2);
+    /**
+     * @task_id 1
+     */
+    #[TestDox('Sums up two numbers when the first contains more digits than the second')]
+    public function testSumsUpTwoNumbersWhenTheFirstContainsMoreDigitsThanTheSecond(): void
+    {
+        $luckynumber = new LuckyNumbers();
+        $this->assertEquals(282, $luckynumber->sumUp([2, 2, 5], [5, 7]));
+    }
 
-        $this->assertSame($expected, $actual);
+    /**
+     * @task_id 1
+     */
+    #[TestDox('sumUp method handles overflow')]
+    public function testSumUpMethodHandlesOverflow(): void
+    {
+        $luckynumber = new LuckyNumbers();
+        $this->assertEquals(1100, $luckynumber->sumUp([9, 9, 9], [1, 0, 1]));
     }
 
-    public static function sumUpTestCases()
+    /**
+     * @task_id 1
+     */
+    #[TestDox('sumUp method handles large numbers')]
+    public function testSumUpMethodHandlesLargeNumbers(): void
     {
-        return [
-            'both numbers same length 1' => [ [2], [7], 9 ],
-            'both numbers same length 2' => [ [2, 4], [5, 7], 81 ],
-            'both numbers same length 3' => [ [5, 3, 4], [3, 6, 2], 896 ],
-            'first shorter than second number' => [ [2, 4], [1, 5, 7], 181 ],
-            'first longer than second number' => [ [2, 2, 5], [5, 7], 282 ],
-            'handles overflow' => [ [9, 9, 9], [1, 0, 1], 1100 ],
-            'handles large numbers' => [ [9, 9, 9, 9, 9, 9], [1], 1000000 ],
-        ];
+        $luckynumber = new LuckyNumbers();
+        $this->assertEquals(1000000, $luckynumber->sumUp([9, 9, 9, 9, 9, 9], [1]));
     }
 
     /**
      * @task_id 2
      */
-    #[DataProvider('isPalindromeTestCases')]
-    #[TestDox('Detects palindromic number $number')]
-    public function testIsPalindrome(int $number): void
+    #[TestDox('Detects a palindromic number consisting of a single zero')]
+    public function testDetectsAPalindromicNumberConsistingOfASingleZero(): void
     {
-        $class = new LuckyNumbers();
+        $luckynumber = new LuckyNumbers();
+        $this->assertTrue($luckynumber->isPalindrome(0));
+    }
 
-        $actual = $class->isPalindrome($number);
+    /**
+     * @task_id 2
+     */
+    #[TestDox('Detects a palindromic number consisting of a single digit')]
+    public function testDetectsAPalindromicNumberConsistingOfASingleDigit(): void
+    {
+        $luckynumber = new LuckyNumbers();
+        $this->assertTrue($luckynumber->isPalindrome(6));
+    }
 
-        $this->assertTrue($actual);
+    /**
+     * @task_id 2
+     */
+    #[TestDox('Detects a palindromic number with two identical digits')]
+    public function testDetectsAPalindromicNumberWithTwoIdenticalDigits(): void
+    {
+        $luckynumber = new LuckyNumbers();
+        $this->assertTrue($luckynumber->isPalindrome(33));
     }
 
-    public static function isPalindromeTestCases()
+    /**
+     * @task_id 2
+     */
+    #[TestDox('Detects a palindromic number with five symmetric digits')]
+    public function testDetectsAPalindromicNumberWithFiveSymmetricDigits(): void
     {
-        return [
-            [ 0 ],
-            [ 6 ],
-            [ 33 ],
-            [ 15651 ],
-            [ 48911984 ],
-        ];
+        $luckynumber = new LuckyNumbers();
+        $this->assertTrue($luckynumber->isPalindrome(15651));
     }
 
     /**
      * @task_id 2
      */
-    #[DataProvider('isNoPalindromeTestCases')]
-    #[TestDox('Detects non-palindromic number $number')]
-    public function testIsNoPalindrome(int $number): void
+    #[TestDox('Detects a palindromic number with eight symmetric digits')]
+    public function testDetectsAPalindromicNumberWithEightSymmetricDigits(): void
     {
-        $class = new LuckyNumbers();
+        $luckynumber = new LuckyNumbers();
+        $this->assertTrue($luckynumber->isPalindrome(48911984));
+    }
 
-        $actual = $class->isPalindrome($number);
+    /**
+     * @task_id 2
+     */
+    #[TestDox('Detects a non-palindromic number with two distinct digits')]
+    public function testDetectsANonPalindromicNumberWithTwoDistinctDigits(): void
+    {
+        $luckynumber = new LuckyNumbers();
+        $this->assertFalse($luckynumber->isPalindrome(12));
+    }
 
-        $this->assertFalse($actual);
+    /**
+     * @task_id 2
+     */
+    #[TestDox('Detects a non-palindromic number with six asymmetric digits')]
+    public function testDetectsANonPalindromicNumberWithSixAsymmetricDigits(): void
+    {
+        $luckynumber = new LuckyNumbers();
+        $this->assertFalse($luckynumber->isPalindrome(156512));
     }
 
-    public static function isNoPalindromeTestCases()
+    /**
+     * @task_id 2
+     */
+    #[TestDox('Detects a non-palindromic number with eight nearly symmetric digits')]
+    public function testDetectsANonPalindromicNumberWithEightNearlySymmetricDigits(): void
     {
-        return [
-            [ 12 ],
-            [ 156512 ],
-            [ 48921984 ],
-        ];
+        $luckynumber = new LuckyNumbers();
+        $this->assertFalse($luckynumber->isPalindrome(48921984));
     }
 
     /**
      * @task_id 3
      */
-    #[TestDox('Error message for empty input')]
-    public function testErrorMessageForEmptyInput(): void
+    #[TestDox('Error message for an empty input')]
+    public function testErrorMessageForAnEmptyInput(): void
     {
-        $class = new LuckyNumbers();
+        $luckynumber = new LuckyNumbers();
+        $this->assertSame('Required field', $luckynumber->validate(''));
+    }
 
-        $actual = $class->validate('');
+    /**
+     * @task_id 3
+     */
+    #[TestDox('Error message for a string input')]
+    public function testErrorMessageForAStringInput(): void
+    {
+        $luckynumber = new LuckyNumbers();
+        $this->assertSame('Must be a whole number larger than 0', $luckynumber->validate('some text'));
+    }
 
-        $this->assertSame('Required field', $actual);
+    /**
+     * @task_id 3
+     */
+    #[TestDox('Error message for an alphanumeric input')]
+    public function testErrorMessageForAnAlphanumericInput(): void
+    {
+        $luckynumber = new LuckyNumbers();
+        $this->assertSame('Must be a whole number larger than 0', $luckynumber->validate('f861'));
     }
 
     /**
      * @task_id 3
      */
-    #[DataProvider('invalidInputTestCases')]
-    #[TestDox('Error message for invalid input $input')]
-    public function testErrorMessageForInvalidInput(
-        string $input
-    ): void {
-        $class = new LuckyNumbers();
+    #[TestDox('Error message for a negative number input')]
+    public function testErrorMessageForANegativeNumberInput(): void
+    {
+        $luckynumber = new LuckyNumbers();
+        $this->assertSame('Must be a whole number larger than 0', $luckynumber->validate('-42'));
+    }
 
-        $actual = $class->validate($input);
+    /**
+     * @task_id 3
+     */
+    #[TestDox('Error message for zero as a digit input')]
+    public function testErrorMessageForZeroAsADigitInput(): void
+    {
+        $luckynumber = new LuckyNumbers();
+        $this->assertSame('Must be a whole number larger than 0', $luckynumber->validate('0'));
+    }
 
-        $this->assertSame('Must be a whole number larger than 0', $actual);
+    /**
+     * @task_id 3
+     */
+    #[TestDox('Returns an empty string for a valid digit input')]
+    public function testReturnsAnEmptyStringForAValidDigitInput(): void
+    {
+        $luckynumber = new LuckyNumbers();
+        $this->assertSame('', $luckynumber->validate('1'));
     }
 
-    public static function invalidInputTestCases()
+    /**
+     * @task_id 3
+     */
+    #[TestDox('Returns an empty string for a valid number input')]
+    public function testReturnsAnEmptyStringForAValidNumberInput(): void
     {
-        return [
-            [ 'some text' ],
-            [ 'f861' ],
-            [ '-42' ],
-            [ '0' ],
-        ];
+        $luckynumber = new LuckyNumbers();
+        $this->assertSame('', $luckynumber->validate('123456789'));
     }
 
     /**
      * @task_id 3
      */
-    #[DataProvider('validInputTestCases')]
-    #[TestDox('Error message for invalid input $input')]
-    public function testErrorMessageForValidInput(
-        string $input
-    ): void {
-        $class = new LuckyNumbers();
+    #[TestDox('Returns an empty string for a valid number input with leading and trailing whitespace')]
+    public function testReturnsAnEmptyStringForAValidNumberInputWithLeadingAndTrailingWhitespace(): void
+    {
+        $luckynumber = new LuckyNumbers();
+        $this->assertSame('', $luckynumber->validate('   123    '));
+    }
 
-        $actual = $class->validate($input);
+    /**
+     * @task_id 3
+     */
+    #[TestDox('Returns an empty string for a valid number input using lowercase exponent notation')]
+    public function testReturnsAnEmptyStringForAValidNumberInputUsingLowercaseExponentNotation(): void
+    {
+        $luckynumber = new LuckyNumbers();
+        $this->assertSame('', $luckynumber->validate('5e3'));
+    }
 
-        $this->assertSame('', $actual);
+    /**
+     * @task_id 3
+     */
+    #[TestDox('Returns an empty string for a valid number input using uppercase exponent notation')]
+    public function testReturnsAnEmptyStringForAValidNumberInputUsingUppercaseExponentNotation(): void
+    {
+        $luckynumber = new LuckyNumbers();
+        $this->assertSame('', $luckynumber->validate('4.2E1'));
     }
 
-    public static function validInputTestCases()
+    /**
+     * @task_id 3
+     */
+    #[TestDox('Returns an empty string for a valid number input using octal notation')]
+    public function testReturnsAnEmptyStringForAValidNumberInputUsingOcatlNotation(): void
     {
-        return [
-            [ '1' ],
-            [ '123456789' ],
-            [ '   123    ' ],
-            [ '5e3' ],
-            [ '4.2E1' ],
-            [ '00015-plus' ],
-        ];
+        $luckynumber = new LuckyNumbers();
+        $this->assertSame('', $luckynumber->validate('00015-plus'));
     }
 }