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

        expect:
        succeeds("build", "--parallel", "--max-workers", "4")
        true
    }

                }

                artifacts {
                    implementation p.flatMap { it.output }
                    broken b.flatMap { it.output }
                    broken b.flatMap { throw new RuntimeException("broken artifact") }
                }
            }

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

    private final String vendor;
    private final String implementation;

    public JavaToolchainInput(JavaToolchainSpec spec) {
        this.javaLanguageVersion = spec.getLanguageVersion().getOrNull();
        this.vendor = spec.getVendor().get().toString();
        this.implementation = spec.getImplementation().get().toString();
    }

    @Optional
    @Input

 * should override {@code equals} as well, either providing your own implementation, or delegating
 * to the provided {@code standardEquals} method.
 *
 * <p>Each of the {@code standard} methods, where appropriate, use {@link Objects#equal} to test
 * equality for both keys and values. This may not be the desired behavior for map implementations
 * that use non-standard notions of key equality, such as the entry of a {@code SortedMap} whose

final class Platform {

  /** Returns the platform preferred implementation of a map based on a hash table. */
  static <K extends @Nullable Object, V extends @Nullable Object>
      Map<K, V> newHashMapWithExpectedSize(int expectedSize) {
    return Maps.newHashMapWithExpectedSize(expectedSize);
  }

  /**
   * Returns the platform preferred implementation of an insertion ordered map based on a hash
   * table.
   */

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

description = "Services and types used to setup a build process from a Gradle distribution."

dependencies {
    api(project(":stdlib-java-extensions"))
    api(project(":base-services"))
    api(libs.jsr305)

    implementation(libs.guava)

    testImplementation(libs.asm)
    testImplementation(libs.asmTree)

    testRuntimeOnly(project(":resources"))

            // Add a dependency with explicit coordinate parameters
            implementation(module(group = "org", name = "foo", version = "1.0")) // is getImplementation().add(module("org", "foo", "1.0"))

            // Add dependencies on projects
            implementation(project(":path")) // is getImplementation().add(project(":path"))
            implementation(project()) // is getImplementation().add(project())

     * Returns the classpath for the module implementation. This is the classpath of the module itself. Does not include any dependencies.
     */
    ClassPath getImplementationClasspath();

    /**
     * Returns the classpath containing the runtime dependencies of the module. Does not include any other modules.
     */
    ClassPath getRuntimeClasspath();

    /**
     * Returns implementation + runtime.
     */

}

description = "Base tools to work with files"

gradlebuildJava.usedInWorkers()

dependencies {
    api(projects.stdlibJavaExtensions)

    api(libs.jsr305)

    implementation(libs.guava)
    implementation(libs.slf4jApi)

    testImplementation(project(":native"))
    testImplementation(project(":base-services")) {
        because("TextUtil is needed")
    }

    /**
     * Writes a signed 64 bit long value. The implementation may encode the value as a variable number of bytes, not necessarily as 8 bytes.
     */
    void writeLong(long value) throws IOException;

    /**
     * Writes a signed 64 bit long value whose value is likely to be small and positive but may not be. The implementation may encode the value in a way that is more efficient for small positive
     * values.