given:
        def toolchains = mavenHome.createFile(new File("toolchains.xml"))
        toolchains.write(toolchain)
        def supplier = useProperty ? createSupplier(toolchains.getCanonicalPath(), null) : createSupplier(null, userHome)

        when:
        def directories = supplier.get()

        then:
        directoriesAsStablePaths(directories) == stablePaths([new File("/usr/lib/jvm/adoptopenjdk-16.jdk").absolutePath])

        socketReceiverThread = new Thread() {
            def terminate = false
            void run() {
                InetAddress selectedAddress = null
                while (!terminate) {
                    byte[] bytes = new byte[9]
                    DatagramPacket packet = new DatagramPacket(bytes, bytes.length)
                    receivingSocket.receive(packet)

    @Input
    Map<String, Object> templateArgs = [:]

    @Internal
    final SimpleTemplateEngine engine = new SimpleTemplateEngine()
    @Internal
    final gradlebuild.performance.generator.MavenJarCreator mavenJarCreator = new gradlebuild.performance.generator.MavenJarCreator()

    @Internal
    final List<TestProject> projects = []
    @Internal

            assert event.question == "enter value"
        }
        1 * userInputReader.readInput() >> new UserInputReader.TextResponse("thing")
        1 * outputEventBroadcaster.onOutput(_) >> { TextQuestionPromptEvent event ->
            assert event.question == "enter another value"
        }
        1 * userInputReader.readInput() >> new UserInputReader.TextResponse("")
        1 * outputEventBroadcaster.onOutput(_ as UserInputResumeEvent)

            public class IgnoredTest {
                @Test
                public void testIgnored1() {
                    throw new RuntimeException();
                }
            }
        '''

        when:
        run('check')

        then:
        new DefaultTestExecutionResult(testDirectory)
            .assertTestClassesExecuted('org.gradle.IgnoredTest')

class HtmlDependencyVerificationReportRendererTest extends Specification {
    static private File dummyFile = new File("dummy")
    static private File dummyFileSig = new File("dummy.asc")

    @Rule
    TestNameTestDirectoryProvider temporaryFolder = new TestNameTestDirectoryProvider(getClass())

    File verificationFile = temporaryFolder.createFile("verification-metadata.xml")

import spock.lang.Subject

class DefaultRepositoryContentDescriptorTest extends Specification {

    @Subject
    DefaultRepositoryContentDescriptor descriptor = new DefaultMavenRepositoryContentDescriptor({ throw new RuntimeException("only required in error cases") }, new VersionParser())

    def "reasonable error message when input is incorrect (include string)"() {
        when:
        descriptor.includeGroup(null)

        then:

    def delegate = Mock(BuildSessionActionExecutor)
    def cancellationToken = new DefaultBuildCancellationToken()
    def buildExecutionTimer = Mock(BuildStartedTime)
    def requestMetadata = Stub(BuildRequestMetaData)
    def requestContext = new DefaultBuildRequestContext(requestMetadata, cancellationToken, new NoOpBuildEventConsumer())
    def startParameter = new StartParameterInternal()
    def action = Stub(BuildAction) {

    def transform() {
        XIncludeAwareXmlProvider provider = new XIncludeAwareXmlProvider()
        provider.parse(sourceFile.get().asFile)
        transformDocument(provider.document)
        provider.write(destFile.get().asFile)
    }

    private def transformDocument(Document mainDocbookTemplate) {
        ClassMetaDataRepository<ClassMetaData> classRepository = new SimpleClassMetaDataRepository<ClassMetaData>()

class DependencyInsightReporterSpec extends Specification {
    def versionParser = new VersionParser()
    def versionComparator = new DefaultVersionComparator()
    def versionSelectorScheme = new DefaultVersionSelectorScheme(versionComparator, versionParser)

    @Subject
    def reporter = new DependencyInsightReporter(versionSelectorScheme, versionComparator, versionParser)

    def "sorts dependencies"() {