--- FAIL: TestPanicHelper/1 (N.NNs)
        panic_test.go:NNN: TestPanicHelper/1
`,
	}, {
		desc:  "subtest panics with inner cleanup panic",
		flags: []string{"-test_panic_test=TestPanicHelper/1", "-test_panic_cleanup", "-test_panic_cleanup_panic=inner"},
		want: `
ran inner cleanup 1
ran middle cleanup 1
ran outer cleanup
--- FAIL: TestPanicHelper (N.NNs)
    panic_test.go:NNN: TestPanicHelper

                println "inner 1: " + it
            }
            conf($('param')) {
                println "inner 2: " + it
            }
        }
    }
    tasks {
        show(Task) { doLast { println $.thing } }
    }
}
'''

        expect:
        succeeds "show"
        output.contains("outer 1: param")
        output.contains("inner 1: param")

type it struct {
	Floats bool
	inner  string
}

func main() {
	i1 := it{Floats: true}
	if i1.floats { // ERROR "(type it .* field or method floats, but does have field Floats)|undefined field or method"
	}
	i2 := &it{floats: false} // ERROR "cannot refer to unexported field floats in struct literal|unknown field|declared and not used"
	_ = &it{InneR: "foo"}    // ERROR "(but does have field inner)|unknown field"
	_ = i2

    public final inner class Operation$Subtract
}

public abstract class Operation {
    // source: 'classKinds.kt'
    private method <init>(): void
    public synthetic method <init>(p0: kotlin.jvm.internal.DefaultConstructorMarker): void
    public final inner class Operation$Add
    public final inner class Operation$Negate
    public final inner class Operation$Subtract
}

    }

    def "inner class name format"() {
        expect:
        MethodDescription.name('a').owner(Outer.Inner).toString() == 'org.gradle.internal.reflect.MethodDescriptionTest$Outer$Inner#a'
    }

    class Outer {
        static class Inner {

        }
    }

}

tasks.named('test', Test) {
    useJUnitPlatform()

    maxHeapSize = '1G'

    testLogging {
        events "passed"
    }
}
// end::java-basic-test-config[]

// tag::practical-integ-test-source-set[]
sourceSets {
    intTest {
        compileClasspath += sourceSets.main.output
        runtimeClasspath += sourceSets.main.output
    }
}

configurations {

                    "-x", ":docs:platformTest",
                    "-x", ":docs:configCacheTest",
                    "-x", ":distributions-integ-tests:quickTest",
                    "-x", ":distributions-integ-tests:platformTest",
                    "-x", ":distributions-integ-tests:configCacheTest"
                ) +
                listOf(extraParameters) +
                functionalTestParameters(os, arch) +

type RecomputeTrigger struct {
	inner StaticSingleton[int32]
	// krt will suppress events for unchanged resources. To workaround this, we constantly change and int each time TriggerRecomputation
	// is called to ensure our event is not suppressed.
	i *atomic.Int32
}

func NewRecomputeTrigger() *RecomputeTrigger {
	inner := NewStatic[int32](ptr.Of(int32(0)))
	return &RecomputeTrigger{inner: inner, i: atomic.NewInt32(0)}
}

    synthetic final field $title: java.lang.String
    inner (anonymous) class MainKt$ArticleScreenContent$2
    method <init>(p0: java.lang.String): void
    public synthetic bridge method invoke(): java.lang.Object
    public final method invoke(): void
}

public final class MainKt {
    // source: 'main.kt'
    inner (anonymous) class MainKt$ArticleScreenContent$1
    inner (anonymous) class MainKt$ArticleScreenContent$2

class StringInternerTest extends Specification {
    @Subject
    StringInterner stringInterner = new StringInterner()

    def "should return null when null is passed to intern method"() {
        expect:
        stringInterner.intern(null) == null
    }

    def "should return first instance when multiple strings with similar contents are interned"() {
        given: