implementation(projects.io)
    implementation(project(":base-services-groovy"))

    implementation(libs.slf4jApi)
    implementation(libs.commonsIo)

    compileOnly(libs.jetbrainsAnnotations)

    testImplementation(project(":process-services"))
    testImplementation(project(":resources"))
    testImplementation(project(":snapshots"))
    testImplementation(testFixtures(project(":core")))

        because("Loaded by the AWS libraries with reflection when present: https://github.com/gradle/gradle/issues/15332")
    }
    api(libs.guava)

    implementation(projects.baseServices)
    implementation(project(":hashing"))

    implementation(libs.commonsLang)
    implementation(libs.slf4jApi)

    testImplementation(testFixtures(project(":core")))
    testImplementation(testFixtures(project(":dependency-management")))

 * override {@code putAll} as well, either providing your own implementation, or delegating to the
 * provided {@code standardPutAll} method.
 *
 * <p><b>{@code default} method warning:</b> This class does <i>not</i> forward calls to {@code
 * default} methods. Instead, it inherits their default implementations. When those implementations
 * invoke methods, they invoke methods on the {@code ForwardingSortedMap}.
 *

                trait ${project.toUpperCase()}
            """
        }
        file("a/build.gradle") << """
            dependencies {
              implementation(project(":b"))
              implementation(project(":c"))
              implementation(project(":d"))
            }
        """

        expect:
        executer.noDeprecationChecks()
        succeeds(":a:classes", "--parallel")
        true
    }

      testProguardFiles("test-proguard-rules.pro")
    }
  }
}

dependencies {
  implementation(libs.playservices.safetynet)
  implementation(projects.okhttp)
  implementation(projects.okhttpAndroid)
  implementation(libs.androidx.activity)

  androidTestImplementation(libs.androidx.junit)
  androidTestImplementation(libs.androidx.espresso.core)

        }
    }
// tag::android[]
}
// end::android[]

dependencies {
    implementation(fileTree(mapOf("dir" to "libs", "include" to listOf("*.jar"))))
    implementation(kotlin("stdlib-jdk7", KotlinCompilerVersion.VERSION))
    implementation("com.android.support:appcompat-v7:27.1.1")
    implementation("com.android.support.constraint:constraint-layout:1.1.0")
    testImplementation("junit:junit:4.13")

        }
    }
// tag::android[]
}
// end::android[]

dependencies {
    implementation(fileTree(mapOf("dir" to "libs", "include" to listOf("*.jar"))))
    implementation(kotlin("stdlib-jdk7"))
    implementation("com.android.support:appcompat-v7:27.1.1")
    implementation("com.android.support.constraint:constraint-layout:1.1.0")
    testImplementation("junit:junit:4.13")

    api(project(":logging"))
    api(project(":model-core"))
    api(project(":snapshots"))

    api(libs.kotlinStdlib)

    implementation(projects.configurationCacheBase)
    implementation(projects.serialization)
    implementation(projects.stdlibKotlinExtensions)

    implementation(libs.guava)

class ScriptSourceAwareImplementationResolverTest extends Specification {

    def "correct implementation for #type coerced to Action is tracked"() {
        expect:
        ScriptSourceAwareImplementationResolver.unwrapBean(implementation as Action) == implementation

        where:
        type      | implementation
        "Closure" | { it }
        "Action"  |  new Action<String>() { @Override void execute(String s) {} }

 with its <<<DefaultToolchainManagerPrivate>>> implementation ({{{./xref/org/apache/maven/toolchain/DefaultToolchainManagerPrivate.html}source}}),
 to manage toolchain selection,

 * internal JDK toolchain implementation: <<<JavaToolchain>>> interface ({{{./apidocs/org/apache/maven/toolchain/java/JavaToolchain.html}javadoc}}),
 with its <<<JavaToolchainImpl>>> implementation