Test cases for next palindromic number I recently did a programming challenge: given a positive number find the next palindromic number. In PHP, I decided to do something like this:

&lt;?php

function palindromic($input) {
  while (1) {
    $number = (string) ++$input;

    if ($number == strrev($number)) {
      return $number;
    }
  }
}


I was then asked to provide test inputs for the function and to explain why, so I had (where x is a random number)


x &lt; 10: test single digits
10 &lt; x &lt; 100: tests numbers with even length
100 &lt; x &lt; 1000: tests numbers with odd lengths
1,000,000 &lt; x: tests a largish number


Note: we can always assume a positive number, so checking for non-positive numbers or inputs that are a different type, or asserting exceptions thrown back, etc aren't relevant to the challenge.

Apparently there were some other important numbers to test, can anyone explain what I've missed here?
I don't code in java or python so I don't fully follow the methods provided in the commented link under the question.

I've decided to write a method that avoids the incremental checking for palindromic integers.  Instead, it uses arithmetic based on a few preliminary string function results to discover the closest greater palindromic integer.  Note, there are limitations to my method because the input and output are integers rather than strings.  I can conclude after testing that my method will stay true into the 10's of trillions.

Code: (Demo)

function nextPalindromicInteger($integer) {
    if ($integer &lt; 9) {
        $next = $integer + 1;
        return "$integer =&gt; $next (+1) " . ($next != strrev($next) ? "FAIL" : "PASS") . "\n";
    }
    $size = strlen($integer);
    $psize = ceil($size / 2);  // find length of rhs &amp; lhs including pivot when length is odd
    $npsize = $size - $psize;  // find length of rhs &amp; lhs excluding pivot when length is odd
    $rnplhs = (int)strrev(substr($integer, 0, $npsize));  // reverse nplhs
    $nprhs = (int)substr($integer, -$npsize);  // store right hand side integer excluding pivot  //KEEP
    $trimmed=strlen(rtrim(substr($integer, 0, $psize), '9')); // store length of rtrim'd plhs
    if ($rnplhs &gt; $nprhs) {
        $bump = 0;
    } elseif (!strlen(trim($integer, '9'))) {
        $bump = 2;
        $nprhs = 0;
        $rnplhs = 0;
    } else {
        if ($psize != $npsize) {  // odd integer length
            if ($trimmed == 1) {
                $exponent = 1;  // dictates $bump=11
            } else {
                $exponent = $npsize;
            }
        } else {  // even integer length
            $exponent = $trimmed;
        }
        $bump = pow(10, $exponent);
        if ($psize == $npsize || $trimmed &lt; $psize) {
            $bump += pow(10, $exponent - 1);
        }
    }
    $next = $integer + $rnplhs - $nprhs + $bump;
    return "$integer =&gt; $next (+" . ($next - $integer) . ") " . ($next != strrev($next) ? "FAIL" : "PASS") . "\n";
}
for ($x = 0; $x &lt; 14; ++$x) {
    $integer = rand(pow(10, $x), pow(10, $x + 1) - 1);
    echo nextPalindromicInteger($integer);   
}


If I spent some more time refining, I could probably write my function more eloquently, but for the purposes of this question it is sufficient to reveal (to me at least) some of the fringe cases.

I found in my development and testing that it was important to test against:


a range of integers, some with even length and some with odd length.
integers with a pivot (shared middle digit) of nine.
integers with an odd length and a non-9 pivot.
integers consisting entirely of 9's.
integers where the reversed left-hand-side component minus the right-hand-side component is:  &gt;0, =0, and &lt;0


Once I isolated the patterns that exist with certain sequences, I could declare the correct "bump" or adjustment.  Some bumps are static, others depend on the length or value of the left-hand-side component.

As for your relevant numbers to check using your method, I can't think of any that would cause trouble because you are looping and checking each iteration.  Perhaps the challenge was assuming that you would try to write a method without loops as I did or run "inside out" string comparison checks on each side's digits.

As for checking "large-ish" numbers, I found that once I had perfected the bumps from 1 to 9999, all integers above that were accounted for.

Possible Output:

9 =&gt; 11 (+2) PASS
75 =&gt; 77 (+2) PASS
776 =&gt; 777 (+1) PASS
4891 =&gt; 4994 (+103) PASS
92764 =&gt; 92829 (+65) PASS
999539 =&gt; 999999 (+460) PASS
7059657 =&gt; 7060607 (+950) PASS
48756572 =&gt; 48766784 (+10212) PASS
633149324 =&gt; 633151336 (+2012) PASS
2096785014 =&gt; 2096886902 (+101888) PASS
80448359477 =&gt; 80448384408 (+24931) PASS
237762850363 =&gt; 237763367732 (+517369) PASS
7730351516591 =&gt; 7730351530377 (+13786) PASS
79541453924626 =&gt; 79541455414597 (+1489971) PASS