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

//go:build !unix

package script

func isETXTBSY(err error) bool {
	// syscall.ETXTBSY is only meaningful on Unix platforms.
	return false

        assertTestExecuted(className: "example.MyTest", methodName: "foo2", task: ":test")
        events.tests.size() == (supportsEfficientClassFiltering() ? 10 : 14)
    }

    def "fails with meaningful error when requested tests not found"() {
        given:
        collectDescriptorsFromBuild()
        and:
        testClassRemoved()
        when:
        launchTests { TestLauncher launcher ->

package abi

type RF_State int

// These constants are shared between the compiler, which uses them for state functions
// and panic indicators, and the runtime, which turns them into more meaningful strings
// For best code generation, RF_DONE and RF_READY should be 0 and 1.
const (
	RF_DONE          = RF_State(iota) // body of loop has exited in a non-panic way

     * A worker lease is also granted to the thread. The thread can release this if it needs to, but should reacquire
     * the lease prior to doing any meaningful work.
     *
     * This method is reentrant so that a thread can call this method from the given action.
     *
     * This method blocks until a worker lease is available.
     */

import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * Simple {@link ThreadFactory} implementation that ensures the corresponding threads have a meaningful name.
 */
public class BuildThreadFactory implements ThreadFactory {
    private final AtomicInteger id = new AtomicInteger();

    private static final String PREFIX = "BuilderThread";

    @Override

 */

package org.gradle.internal.concurrent;

import javax.annotation.Nullable;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicLong;

/**
 * Provides meaningful names to threads created in a thread pool.
 */
public class ThreadFactoryImpl implements ThreadFactory {
    private final AtomicLong counter = new AtomicLong();
    private final String displayName;
    @Nullable

        then:
        isReported * mockLogger.warn(_ as String, location.displayName)

        where:
        isValid << [false, true]
        isReported << [1, 0]
    }

    def 'reporter logs meaningful message'() {
        given:
        def reporter = new InvalidInstallationWarningReporter(mockLogger)
        def location = InstallationLocation.userDefined(new File("testHome"), "test")

            id("java")
        }
        ${mavenCentralRepository()}
        dependencies {
            testImplementation("junit:junit:4.13.1")
        }
        """
    }

    def "fails with meaningful error when no tests declared from included build"() {
        when:
        launchTests { TestLauncher launcher ->
            launcher.withTaskAndTestClasses(':included-build:test', [])
        }

        then:

     */
    @Nullable
    Throwable getException();

    /**
     * Returns the stack trace that can be reported to the user about where the problem occurred.
     *
     * <p>Not every problem has a meaningful stack, even when the problem has an associated exception. Returns an empty list in this case.</p>
     */
    List<StackTraceElement> getStack();

    /**
     * Returns the location of the problem, if known.
     */

                @org.junit.Test public void bar() throws Exception {
                     org.junit.Assert.assertEquals(1, 1);
                }
            }
        """
    }

    def "fails with meaningful error when no tests declared"() {
        when:
        launchTests { TestLauncher launcher ->
            launcher.withTaskAndTestClasses(':test',[])
        }

        then: