import org.gradle.api.internal.tasks.TaskDependencyUsageTracker
import org.gradle.internal.configuration.problems.ProblemFactory
import org.gradle.internal.configuration.problems.ProblemsListener


/** Reports all usages of the tracked TaskDependency APIs as problems using the [problems] listener.
 * Also checks which tasks in the API return value come from the other projects and tracks the projects coupling using the [coupledProjectsListener]. */

        mavenRepo.module("org.example", "example-lib", "1.0").publish()
        localMaven = "maven { url '${mavenRepo.uri}' }"
    }

    // TODO (donat) add more coverage after all classpath entry types are exposed via the TAPI

    def "respects manipulation done in the eclipse.classpath.whenMerged closure"() {
        setup:
        settingsFile << 'rootProject.name = "root"'
        buildFile <<

The Dataflow Actions API provides a way to schedule this type of work.
A dataflow action is a parameterized isolated piece of work that becomes eligible for execution as soon as all input parameters become available.

== Implementing a dataflow action

The first step is to implement the action itself.

import java.io.UncheckedIOException;
import java.io.Writer;
import java.nio.charset.StandardCharsets;
import java.util.Collection;
import java.util.stream.Collectors;

/**
 * Generates META-INF/services resource with all factory classes for generated JvmBytecodeCallInterceptors so we can load them at runtime
 */
public class InterceptJvmCallsResourceGenerator implements InstrumentationResourceGenerator {
    @Override

    @Override
    protected Class<?> lookupClass(String type) throws ClassNotFoundException {
        try {
            return super.lookupClass(type);
        } catch (ClassNotFoundException e) {
            // lookup class in all classloaders
            for (ClassLoaderDetails details : classLoaderDetails.values()) {
                try {
                    return map.resolveClass(details, type);
                } catch (ClassNotFoundException ignored) {

import org.gradle.test.preconditions.IntegTestPreconditions

class DevelocityBuildLifecycleServiceIntegrationTest extends AbstractIntegrationSpec {

    def "can use lifecycle service to apply logic to all projects"() {
        settingsFile << """
            include 'foo', 'bar'
            includeBuild 'included'

            $beforeProject {
                def projectPath = it.buildTreePath

            Class<?> returnType = softwareType.modelPublicType();
            extensions.add(returnType, softwareType.name(), Cast.uncheckedNonnullCast(value.call()));
        }
    }

        } catch (RuntimeException ex) {
            throw problemsService.getInternalReporter().rethrowing(ex, builder -> buildProblemFrom(ex, builder));
        }
        boolean success = task.call();
        diagnosticToProblemListener.printDiagnosticCounts();
        if (!success) {
            throw new CompilationFailedException(result);
        }
        return result;
    }

<<build_scans.adoc#build_scans,Part 9.>> Build Scans +
<<gradle_optimizations.adoc#gradle_optimizations,Part 10.>> Gradle Optimizations +

[[getting_started]]
== 2. Gradle Tutorial

The tutorial will take you from Gradle initialization all the way through to utilizing Gradle's task caching for your basic Java App.
No previous experience is necessary but a basic knowledge of Java and Kotlin is nice to have.

        feature is InterpretationStepFeature.ResolutionResultPostprocessing.ConventionApplication

    override fun processResolutionResult(resolutionResult: ResolutionResult): ResolutionResult {
        // Find all the software types that are referenced in the build file
        val referencedSoftwareTypes = findUsedSoftwareTypeNames(resolutionResult)
            .mapNotNull(softwareTypeConventionRepository::findConventions)