refactor: Improve thread stack depth testing in ThreadDumpUtilsSuite

- Updated the deepStack function to prevent tail-call optimization, ensuring a deep stack trace for testing.
- Enhanced assertions to verify the total stack depth and the correctness of the truncation message in thread dumps.
- Streamlined the test logic for better clarity and accuracy in validating stack depth limitations.

Author: wangzhigang1999

kyuubi-common/src/test/scala/org/apache/kyuubi/util/ThreadDumpUtilsSuite.scala

@@ -70,14 +70,19 @@ class ThreadDumpUtilsSuite extends KyuubiFunSuite {
     val stackDepth = 100
     val limit = 10
 
-    // Recursive function to create a deep stack
-    def deepStack(n: Int): Unit = {
+    // This function is INTENTIONALLY NOT tail-recursive.
+    // By performing an operation after the recursive call, we prevent the compiler
+    // from optimizing it into a loop, thus forcing a deep stack trace.
+    def deepStack(n: Int): Int = {
       if (n > 0) {
-        deepStack(n - 1)
+        val res = deepStack(n - 1)
+        res + 1 // This operation breaks tail-call optimization
       } else {
-        readyLatch.countDown() // Signal that the thread is ready
-        try Thread.sleep(5000) // Keep thread alive for dumping
-        catch { case _: InterruptedException => Thread.currentThread().interrupt() }
+        readyLatch.countDown() // Signal that the thread has reached the bottom of the stack
+        try {
+          Thread.sleep(5000) // Keep thread alive so we can dump it
+        } catch { case _: InterruptedException => Thread.currentThread().interrupt() }
+        0 // Base case return
       }
     }
 
@@ -86,25 +91,35 @@ class ThreadDumpUtilsSuite extends KyuubiFunSuite {
       deepStackThread.setDaemon(true)
       deepStackThread.start()
 
-      // Wait for the thread to reach its deepest point
       assert(readyLatch.await(5, TimeUnit.SECONDS), "Test thread did not initialize in time")
 
-      val config = ThreadDumpUtils.DumpConfig(stackDepth = limit)
-      val dump = ThreadDumpUtils.dumpToString(config)
-      val section = findThreadSection(dump, "deep-stack-test-thread")
-
-      assert(section.isDefined, "Thread 'deep-stack-test-thread' not found in dump")
-
-      // Verify that the stack trace is truncated and the message is correct
-      // Total frames = stackDepth + 1 (for the call to deepStack(0)),
-      // so we expect (101 - 10) more frames
-      val expectedMoreFrames = stackDepth + 1 - limit
-      assert(section.get.contains(s"... (${expectedMoreFrames} more stack frames)"))
-
-      // Verify the number of 'at' lines matches the limit
-      val stackTraceLines = section.get.linesIterator.count(_.trim.startsWith("at "))
+      // 1. Get the full, unlimited dump to determine the actual total stack depth.
+      val unlimitedConfig = ThreadDumpUtils.DumpConfig(stackDepth = 0)
+      val unlimitedDump = ThreadDumpUtils.dumpToString(unlimitedConfig)
+      val unlimitedSection = findThreadSection(unlimitedDump, "deep-stack-test-thread")
+      assert(
+        unlimitedSection.isDefined,
+        "Thread 'deep-stack-test-thread' not found in unlimited dump")
+      val totalFrames = unlimitedSection.get.linesIterator.count(_.trim.startsWith("at "))
+      assert(totalFrames > stackDepth, "Full stack depth is not as deep as expected.")
+
+      // 2. Get the limited dump and verify its contents against the full one.
+      val limitedConfig = ThreadDumpUtils.DumpConfig(stackDepth = limit)
+      val limitedDump = ThreadDumpUtils.dumpToString(limitedConfig)
+      val limitedSection = findThreadSection(limitedDump, "deep-stack-test-thread")
+      assert(limitedSection.isDefined, "Thread 'deep-stack-test-thread' not found in limited dump")
+
+      // Verify the number of "at" lines matches the configured limit.
+      val stackTraceLines = limitedSection.get.linesIterator.count(_.trim.startsWith("at "))
       assert(stackTraceLines == limit)
 
+      // Verify the truncation message is present and mathematically correct.
+      val expectedMoreFrames = totalFrames - limit
+      assert(
+        limitedSection.get.contains(s"... (${expectedMoreFrames} more stack frames)"),
+        s"Dump did not contain the expected truncation message. " +
+        s"Expected '... ($expectedMoreFrames more stack frames)'.")
+
     } finally {
       if (deepStackThread != null) deepStackThread.interrupt()
     }