api(project(":process-services"))

    api(libs.inject)
    api(libs.jsr305)
    api(libs.nativePlatform)

    implementation(project(":functional"))
    implementation(project(":native"))

    implementation(libs.guava)
    implementation(libs.asm)
    implementation(libs.xmlApis)
    implementation(libs.slf4jApi)

    testImplementation(project(":native"))
    testImplementation(project(":file-collections"))

                        }
                    }
                }
            }

            project(':a') {
                dependencies {
                    implementation project(':b')
                    implementation project(':c')
                }
            }

            abstract class MakeGreen implements TransformAction<Parameters> {
                interface Parameters extends TransformParameters {

            dependencies {
                implementation(kotlin("test-common"))
                implementation(kotlin("test-annotations-common"))
            }
        }

        named("jsTest") {
            dependencies {
                implementation(kotlin("test-js"))
            }
        }

        named("jvmTest") {
            dependencies {
                implementation(kotlin("test-junit5"))

    api(project(":problems-api"))
    api(project(":snapshots"))

    implementation(projects.time)
    implementation(project(":logging"))
    implementation(projects.enterpriseOperations) {
        because("Adds generic build operations for the execution engine")
    }

    implementation(libs.commonsLang)
    implementation(libs.commonsIo)

    testImplementation(project(":native"))

    api(project(":declarative-dsl-tooling-models"))
    api(libs.kotlinStdlib)


    implementation(libs.inject)
    testImplementation(libs.mockitoKotlin2)

    implementation(project(":base-services"))
    implementation(project(":resources"))
    implementation(project(":model-core"))

    implementation(libs.guava)
    implementation(libs.kotlinReflect)

    integTestImplementation(project(":internal-testing"))

 * a number of capabilities. Some examples:
 *
 * <ul>
 * <li>An implementation may decorate the instances in some fashion, for example to mix in the Groovy DSL, and so may return a subclass of the requested type.
 *

        name.getCompileTaskName("cpp") == "compileCpp"
        name.getTaskName("link") == "link"
        name.dirName == "main/"
        name.withPrefix("compile") == "compile"
        name.withSuffix("implementation") == "implementation"

        name.append("debug").dirName == "main/debug/"
    }

    def "names for single dimension variant of main"() {
        expect:
        def name = Names.of("mainDebug")

    <component>
      <role>org.apache.maven.lifecycle.LifeCyclePluginAnalyzer</role>
      <implementation>org.apache.maven.lifecycle.EmptyLifecyclePluginAnalyzer</implementation>
    </component>
    <component>
      <role>org.apache.maven.project.ProjectBuildingHelper</role>
      <implementation>org.apache.maven.project.EmptyProjectBuildingHelper</implementation>
    </component>
  </components>

 */

plugins {
    id("gradlebuild.distribution.implementation-java")
}

description = "Controls for the instrumentation agent potentially applied to the process"

dependencies {
    api(projects.stdlibJavaExtensions)

    implementation(projects.baseServices)
    implementation(projects.functional)

    implementation(libs.jsr305)
    implementation(libs.slf4jApi)

                val ${suiteName}Implementation = configurations.getByName("${suiteName}Implementation")
                // We might get junit included too, dependending on the test suite, so filter it
                val deps = ${suiteName}Implementation.dependencies
                            .filter { it.name != "junit-jupiter" }