import org.gradle.api.internal.StartParameterInternal;
import org.gradle.api.internal.initialization.ClassLoaderScope;
import org.gradle.configuration.project.BuiltInCommand;
import org.gradle.initialization.buildsrc.BuildSrcDetector;
import org.gradle.initialization.layout.BuildLayout;
import org.gradle.initialization.layout.BuildLayoutConfiguration;
import org.gradle.initialization.layout.BuildLayoutFactory;

    @Rule
    BlockingHttpServer server = new BlockingHttpServer()

    @Issue("https://issues.gradle.org/browse/GRADLE-2032")
    def "can simultaneously run gradle on projects with buildSrc"() {
        initScript """
            import ${BuildOperationListenerManager.name}
            import ${BuildOperationListener.name}
            import ${BuildOperationDescriptor.name}

        result.tasks.collect { it.path } == [':empty']
        result.taskPaths(SUCCESS) == []
        result.taskPaths(NO_SOURCE) == [':empty']
    }


    def "executed buildSrc tasks are not part of tasks in result object"() {
        given:
        file('buildSrc/src/main/groovy/pkg/Message.groovy') << """
            package pkg
            class Message { public static final String MSG = "::msg::" }
        """
        buildScript """

    }

    @Test
    @LeaksFileHandles("Kotlin Compiler Daemon working directory")
    fun `can use Gradle API generated extensions in buildSrc`() {

        withKotlinBuildSrc()

        withFile(
            "buildSrc/src/main/kotlin/foo/FooTask.kt",
            """
            package foo

            import org.gradle.api.*
            import org.gradle.api.model.*

    @Test
    fun `accessors are available after script body change`() {

        withKotlinBuildSrc()
        val myPluginScript = withFile(
            "buildSrc/src/main/kotlin/my-plugin.gradle.kts",
            """
            plugins { base }

            base {
                archivesName.set("my")
            }

            println("base")
            """

* Create a modular software project by combining multiple subprojects
* Share build configuration logic between subprojects using convention plugins in `buildSrc`
* Run similar named tasks in all subprojects
* Run a task in a specific subproject
* Build, bundle and run the application

== Next steps

When your project grows, you might be interested in more details how to configure JVM projects, structuring multi-project builds and dependency management:

        } else {
            assert configurationCacheReusedIn(output2)
        }

        where:
        api << LauncherApi.values()
    }

    def "Can run tasks from nested included build buildSrc"() {
        given:
        def runTestClass = withIncludedBuildBuildSrcTest(api)

        when:
        def output1 = runTestClass.apply('TestClass1')

        then:
        notThrown(Exception)

        given:
        requireOwnGradleUserHomeDir()

        file('buildSrc/src/main/java/Param.java') << """
import java.io.*;
public class Param implements Serializable {
    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        throw new IllegalStateException("$MESSAGE");
    }
}
"""

        file('buildSrc/src/main/java/TestWorkerProcessImpl.java') << '''

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
@NonNullApi
package org.gradle.initialization.buildsrc;

        output.contains "profile=myvalue"
        output.contains "See the profiling report at"
    }

    def "passes task options associated with a task originating from buildSrc"() {
        when:
        file('buildSrc/src/main/java/MyTask.java') << """
            import org.gradle.api.DefaultTask;
            import org.gradle.api.tasks.TaskAction;
            import org.gradle.api.provider.Property;