stack.push(list);
            }

            list.add(parseItem(isCombination, isDigit, version.substring(startIndex)));
        }

        while (!stack.isEmpty()) {
            list = (ListItem) stack.pop();
            list.normalize();
        }
    }

    private static Item parseItem(boolean isDigit, String buf) {

}


fun Test.includeSpockAnnotation(fqcn: String) {
    systemProperties.compute("include.spock.annotation") { _, oldValue ->
        if (oldValue == null) fqcn else "$oldValue,$fqcn"
    }
}


fun Test.excludeSpockAnnotation(fqcn: String) {
    systemProperties.compute("exclude.spock.annotation") { _, oldValue ->
        if (oldValue == null) fqcn else "$oldValue,$fqcn"
    }

        assertTrue(exception instanceof java.io.Serializable);
    }

    @Test
    public void test_stackTrace() {
        // Test that stack trace is properly preserved
        String message = "GSA error with stack trace";
        Throwable cause = new NullPointerException("NPE occurred");
        GsaConfigException exception = new GsaConfigException(message, cause);

    public void test_stackTrace() {
        // Test that stack trace is properly captured
        LdapOperationException exception = new LdapOperationException("Stack trace test");
        StackTraceElement[] stackTrace = exception.getStackTrace();

        assertNotNull(stackTrace);
        assertTrue(stackTrace.length > 0);
        // Verify that current test method appears in stack trace
        boolean foundTestMethod = false;

    }
  }

  /**
   * Returns a string containing the result of {@link Throwable#toString() toString()}, followed by
   * the full, recursive stack trace of {@code throwable}. Note that you probably should not be
   * parsing the resulting string; if you need programmatic access to the stack frames, you can call
   * {@link Throwable#getStackTrace()}.
   */
  @GwtIncompatible // java.io.PrintWriter, java.io.StringWriter

 */

package gradlebuild.binarycompatibility.rules

import japicmp.model.JApiClass
import javassist.ClassPool
import me.champeau.gradle.japicmp.report.ViolationCheckContext
import spock.lang.Specification
import spock.lang.TempDir

abstract class AbstractContextAwareRuleSpecification extends Specification {
    @TempDir
    File testDir

    ViolationCheckContext context = new ViolationCheckContext() {

 * limitations under the License.
 */

package gradlebuild.buildutils.tasks

import gradlebuild.buildutils.model.ReleasedVersion
import spock.lang.Specification
import spock.lang.TempDir

class PreparePatchReleaseIntegrationTest extends Specification {

    @TempDir
    File tmpDir

    def "version file is bumped and previous version is added to released versions"() {

import org.jspecify.annotations.Nullable;

@NullUnmarked
@GwtIncompatible
@J2ktIncompatible
public final class InterruptibleTaskTest extends TestCase {

  // Regression test for a deadlock where a task could be stuck busy waiting for the task to
  // transition to DONE
  public void testInterruptThrows() throws Exception {
    CountDownLatch isInterruptibleRegistered = new CountDownLatch(1);

import org.jspecify.annotations.Nullable;

@NullUnmarked
@GwtIncompatible
@J2ktIncompatible
public final class InterruptibleTaskTest extends TestCase {

  // Regression test for a deadlock where a task could be stuck busy waiting for the task to
  // transition to DONE
  public void testInterruptThrows() throws Exception {
    CountDownLatch isInterruptibleRegistered = new CountDownLatch(1);

    }

    @Test
    public void test_stackTrace() {
        // Test that stack trace is properly captured
        ThemeException exception = new ThemeException("Stack trace test");

        assertNotNull(exception.getStackTrace());
        assertTrue(exception.getStackTrace().length > 0);

        // Verify that this test method appears in the stack trace
        boolean foundTestMethod = false;