attribute(DocsType.DOCS_TYPE_ATTRIBUTE, objects.named(DocsType, 'jacoco-coverage-data'))
    }
    outgoing.artifact(tasks.named('test').map { task ->
        task.extensions.getByType(JacocoTaskExtension).destinationFile
    })

    public void apply(Project project) {
        project.getPlugins().withType(JavaPlugin.class, javaPlugin -> {
            SourceSetContainer sourceSets = project.getExtensions().getByType(SourceSetContainer.class);
            SourceSet main = sourceSets.getByName(SourceSet.MAIN_SOURCE_SET_NAME);
            main.getJava().setSrcDirs(Arrays.asList("src"));
        });
    }
}

        task.destinationDir == new File(project.docsDir, 'groovydoc')
        task.source.files == project.sourceSets.main.groovy.files
        task.docTitle == project.extensions.getByType(ReportingExtension).apiDocTitle
        task.windowTitle == project.extensions.getByType(ReportingExtension).apiDocTitle
    }

        project.getTasks().named(cleanName(EclipsePlugin.ECLIPSE_TASK_NAME), dependsOn(getCleanTask()));

        EclipseModel model = project.getExtensions().getByType(EclipseModel.class);

        configureEclipseProject(project, model);
        configureEclipseWtpComponent(project, model);
        configureEclipseWtpFacet(project, model);

tasks.register<GreetingTask>("hello") {
    message.convention(extension.message)
}
// end::task[]

// tag::update[]
// Where the<GreetingPluginExtension>() is equivalent to project.extensions.getByType(GreetingPluginExtension::class.java)
the<GreetingPluginExtension>().message.set("Hi from Gradle")
// end::update[]

  }

  jvmArgs(
    "-Dokhttp.platform=$platform",
  )

  if (platform == "loom") {
    jvmArgs(
      "-Djdk.tracePinnedThreads=short",
    )
  }

  val javaToolchains = project.extensions.getByType<JavaToolchainService>()
  javaLauncher.set(javaToolchains.launcherFor {
    languageVersion.set(JavaLanguageVersion.of(testJavaVersion))
  })
}

dependencies {
  api(projects.okhttp)

    public void apply(Project project) {
        ProjectLayout layout = project.getLayout();
        TaskContainer tasks = project.getTasks();

        GradleDocumentationExtension extension = project.getExtensions().getByType(GradleDocumentationExtension.class);

        generateReleaseNotes(project, layout, tasks, extension);
    }

    private final List<RequestExtra> extras = new ArrayList<>();

    public List<RequestExtra> getAll() {
        return Collections.unmodifiableList(extras);
    }

    public <T> Optional<T> getByType(Class<T> type) {
        return Cast.uncheckedCast(extras.stream().filter(type::isInstance).findFirst());
    }

    public void add(RequestExtra extra) {
        extras.add(extra);
    }

abstract class CustomTaskUsingToolchains : DefaultTask() {

    @get:Nested
    abstract val launcher: Property<JavaLauncher> // <1>

    init {
        val toolchain = project.extensions.getByType<JavaPluginExtension>().toolchain // <2>
        val defaultLauncher = javaToolchainService.launcherFor(toolchain) // <3>
        launcher.convention(defaultLauncher) // <4>
    }

    @TaskAction

    protected abstract TextFileResourceLoader getTextFileResourceLoader();

    private void exposeScriptsAsPlugins(Project project) {
        GradlePluginDevelopmentExtension pluginExtension = project.getExtensions().getByType(GradlePluginDevelopmentExtension.class);

        SourceSet pluginSourceSet = pluginExtension.getPluginSourceSet();