import org.gradle.test.fixtures.file.TestFile

class IsolatedProjectsJavaPluginIntegrationTest extends AbstractIsolatedProjectsToolingApiIntegrationTest {

    def "java projects can be configured in a parallel"() {
        given:
        withSomeToolingModelBuilderPluginInBuildSrc()
        settingsFile << """
            include("a")
            include("b")
        """
        javaProject(file("a"))

                        output.text = String.valueOf(input.length())
                    }
                }
            """
        }
    }

    def "transformations are applied in parallel for each external dependency artifact"() {
        def m1 = mavenRepo.module("test", "test", "1.3").publish()
        m1.artifactFile.text = "1234"
        def m2 = mavenRepo.module("test", "test2", "2.3").publish()

/**
 * A class to represent the set of edges connecting an (implicit) origin node to a target node.
 *
 * <p>The {@link #nodeToOutEdge} map means this class only works on networks without parallel edges.
 * See {@link MultiEdgesConnecting} for a class that works with parallel edges.
 *
 * @author James Sexton
 * @param <E> Edge parameter type
 */
@ElementTypesAreNonnullByDefault
final class EdgesConnecting<E> extends AbstractSet<E> {

    @Rule
    BlockingHttpServer server = new BlockingHttpServer()

    def setup() {
        executer.withConsole(ConsoleOutput.Rich)
        executer.withArguments('--parallel', "--max-workers=$MAX_WORKERS")
        server.start()
    }

    def "omits parallel test execution if TestNG version does not emit class listener events"() {
        given:
        buildFile << """
            plugins {
                id 'java-library'

     */
    P getParameters();

    /**
     * Specifies the maximum number of tasks that can use this service in parallel. Setting this to 1 means that the service will be used by a single task at a time.
     * When this property has no value defined, then any number of tasks may use this service in parallel. This is the default.
     *
     * <p>

        [JAR_TASK_NAME]                                        | 'without additional argument'
        [JAR_TASK_NAME, '--parallel']                          | 'in parallel'
        [JAR_TASK_NAME, '--parallel', '--configure-on-demand'] | 'in parallel and configure on demand enabled'
    }

    @Issue("https://github.com/gradle/gradle/issues/821")

// A hard-to-spot variant of this form is common in parallel tests:
//
//	func Test(t *testing.T) {
//	    for _, test := range tests {
//	        t.Run(test.name, func(t *testing.T) {
//	            t.Parallel()
//	            use(test) // incorrect, and a data race
//	        })
//	    }
//	}
//
// The t.Parallel() call causes the rest of the function to execute
// concurrent with the loop [<go1.22].

	func (c *T) Log(args ...any)

	// Logf formats its arguments according to the format, analogous ...
	func (c *T) Logf(format string, args ...any)

	// Parallel signals that this test is to be run in parallel with ...

image::performance/parallel-task-slow.png[title="Bottleneck in parallel execution"]

Tweaking the build configuration to run the two slow tasks early on and in parallel
reduces the overall build time from 8 seconds to 5 seconds:

image::performance/parallel-task-fast.png[title="Optimized parallel execution"]

[[enable_daemon]]
== Re-enable the Gradle Daemon

         """
    }

    def "link task is executed in parallel"() {
        createTaskThatRunsInParallelUsingCustomToolchainWith("linkDebug")

        when:
        succeeds "assemble", "parallelTask"

        then:
        assertTaskIsParallel("linkDebug")
    }

    def "compile task is executed in parallel"() {
        createTaskThatRunsInParallelUsingCustomToolchainWith("compileDebugSwift")