// tag::use-tooling-api[]
repositories {
    maven { url 'https://repo.gradle.org/gradle/libs-releases' }
}

dependencies {
    implementation "org.gradle:gradle-tooling-api:$toolingApiVersion"
    // The tooling API need an SLF4J implementation available at runtime, replace this with any other implementation
    runtimeOnly 'org.slf4j:slf4j-simple:1.7.10'
}
// end::use-tooling-api[]

application {
    mainClass = 'org.gradle.sample.Main'

    licenses = ["notice"],
)

# Filesystem implementation for POSIX environments: Linux, MacOS, Android, etc.
tf_cc_shared_object(
    name = "libposix_filesystem.so",
    framework_so = [],
    linkstatic = False,
    visibility = ["//visibility:public"],
    deps = [":posix_filesystem_impl"],
)

# The real implementation of the filesystem.
cc_library(
    name = "posix_filesystem_impl",

}

// new224 returns an assembly implementation of SHA3-224 if available,
// otherwise it returns a generic implementation.
func new224() hash.Hash {
	if cpu.S390X.HasSHA3 {
		return newAsmState(sha3_224)
	}
	return new224Generic()
}

// new256 returns an assembly implementation of SHA3-256 if available,
// otherwise it returns a generic implementation.
func new256() hash.Hash {
	if cpu.S390X.HasSHA3 {

        """)
        customType(file("a"))
        customType(file("b")) << """
            dependencies {
                implementation project(':a')
            }
        """
        customType(file("c")) << """
            dependencies {
                implementation project(':b')
            }
        """

        when:
        isolatedProjectsRun(":b:producer")

        then:

// calls that would have gone to updateGeneric to updateVX if the vector
// facility is installed.
//
// A larger buffer is required for good performance because the vector
// implementation has a higher fixed cost per call than the generic
// implementation.
type mac struct {
	macState

	buffer [16 * TagSize]byte // size must be a multiple of block size (16)
	offset int
}

func (h *mac) Write(p []byte) (int, error) {

    // The client should not depend on core, but core still contains some types that are shared between the client and daemon
    api(project(":core"))

    implementation(libs.jsr305)
    implementation(libs.guava)
    implementation(libs.asm)
    implementation(libs.slf4jApi)
    implementation(project(":stdlib-java-extensions"))

    testImplementation(testFixtures(project(":core"))) {
        because("ConcurrentSpecification")
    }

        0 * opened._

        when:
        cache1.close()

        then:
        0 * _

        when:
        cache2.close()

        then:
        1 * closed.accept(implementation)
        0 * _
    }

    void "can close cache multiple times"() {
        def implementation

        when:

     * @param serviceInstance The service implementation.
     */
    <T> void add(Class<T> serviceType, T serviceInstance);

    /**
     * Adds a service to this registry. The implementation class should have a single public constructor, and this constructor can take services to be injected as parameters.
     *
     * @param serviceType The service implementation to make visible.
     */
    void add(Class<?> serviceType);

    options.javaModuleVersion = provider { version }
}
// end::declareVersion[]

// tag::dependencies[]
dependencies {
    implementation 'com.google.code.gson:gson:2.8.9'       // real module
    implementation 'org.apache.commons:commons-lang3:3.10' // automatic module
    implementation 'commons-cli:commons-cli:1.4'           // plain library
}
// end::dependencies[]

// tag::automaticModuleName[]
tasks.named('jar') {

    options.javaModuleVersion = provider { version as String }
}
// end::declareVersion[]

// tag::dependencies[]
dependencies {
    implementation("com.google.code.gson:gson:2.8.9")       // real module
    implementation("org.apache.commons:commons-lang3:3.10") // automatic module
    implementation("commons-cli:commons-cli:1.4")           // plain library
}
// end::dependencies[]

// tag::automaticModuleName[]
tasks.jar {