These binaries were generated by:

$ cat empty.s
.global _start
_start:
$ as --32 -o empty.o empty.s && ld  --build-id -m elf_i386 -o test32 empty.o
$ as --64 -o empty.o empty.s && ld --build-id -o test64 empty.o
$ powerpc-linux-gnu-as -o empty.o empty.s && powerpc-linux-gnu-ld --build-id -o test32be empty.o

public class IncludedTest {
    @Test
    public void testOK() {
    }
}
"""
        sourcePath.file("com/example/ExcludedTest.java") << """
package com.example;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Tag;

@Tag("exclude")
public class ExcludedTest {
    @Test
    public void testOK() {
    }
}
"""
    }

        val resolver = tracingCodeResolver()

        val topLevelBlock = parseAsTopLevelBlock(
            """
            addAndConfigure("test") {
                number = 123
            }
            justAdd("test2")
            complexValueOne = one(two("three"))
            complexValueOneFromUtils = utils.oneUtil()
            complexValueTwo = two("three")
            nested {
                number = 456
                add()

    }

    @Test
    public void test1() {
        System.out.println("TestFactory[" + data + "].test1()");
    }

    @Test(dependsOnMethods = {"test1"})
    public void test2() {
        System.out.println("TestFactory[" + data + "].test2()");
    }

    @AfterClass
    public void afterClass() {
        System.out.println("TestFactory[" + data + "].afterClass()");
    }

	err = syscall.Mprotect(b[p:], syscall.PROT_NONE)
	if err != nil {
		panic(err)
	}
	// Get a slice pointing to the last byte of the good page.
	x := b[p-one : p]

	test16(x)
	test16i(x, 0)
	test32(x)
	test32i(x, 0)
	test64(x)
	test64i(x, 0)
}

func test16(x []byte) uint16 {
	defer func() {
		r := recover()
		if r == nil {
			panic("no fault or bounds check failure happened")
		}

        file("src/test/java/FooTest.java") << """
            import junit.framework.*;

            public class FooTest extends TestCase {
                public void testPass() {}
                public void testOk() {}
            }
        """.stripIndent()

        when:
        succeeds("test", "--tests", "FooTest.testPass")

        then:
        def result = new DefaultTestExecutionResult(testDirectory)

		defer mustRecover(2)
		panic(2)
	}()
	panic(1)
}

func test2() {
	// Sequential panic.
	defer mustNotRecover()
	defer func() {
		v := recover()
		if v == nil || v.(int) != 2 {
			println("wrong value", v, 2)
			die()
		}
		defer mustRecover(3)
		panic(3)
	}()
	panic(2)
}

func test3() {
	// Sequential panic - like test2 but less picky.
	defer mustNotRecover()
	defer func() {
		recover()

var splitTestsLines = []splitTestWithLine{
	{"-command TEST1 $GOLINE", []string{"-command", "TEST1", "22"}, 22},
	{"-command TEST2 ${DOLLAR}GOLINE", []string{"-command", "TEST2", "$GOLINE"}, 26},
	{"TEST1", []string{"22"}, 33},
	{"TEST2", []string{"66"}, 66},
	{"TEST1 ''", []string{"22", "''"}, 99},
	{"TEST2 ''", []string{"44", "''"}, 44},
}

// TestGenerateCommandShortHand - similar to TestGenerateCommandParse,
// except:

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package gover

import (
	"reflect"
	"testing"
)

func TestCompare(t *testing.T) { test2(t, compareTests, "Compare", Compare) }

var compareTests = []testCase2[string, string, int]{
	{"", "", 0},
	{"x", "x", 0},
	{"", "x", 0},
	{"1", "1.1", -1},
	{"1.5", "1.6", -1},
	{"1.5", "1.10", -1},

test2...