*       (given by {@link #bits}). For example, {@link Hashing#sha1} produces a 160-bit number,
 *       while {@link Hashing#murmur3_32()} yields only 32 bits. Because a {@code long} value is
 *       clearly insufficient to hold all hash code values, this API represents a hash code as an
 *       instance of {@link HashCode}.
 *   <li><b>pure function:</b> the value produced must depend only on the input bytes, in the order

 *       (given by {@link #bits}). For example, {@link Hashing#sha1} produces a 160-bit number,
 *       while {@link Hashing#murmur3_32()} yields only 32 bits. Because a {@code long} value is
 *       clearly insufficient to hold all hash code values, this API represents a hash code as an
 *       instance of {@link HashCode}.
 *   <li><b>pure function:</b> the value produced must depend only on the input bytes, in the order

    }

    /**
     * Expect a deprecation warning to appear when {@link #build()} or {@link #buildAndFail()} is called if the given condition is true.
     *
     * @param condition only expect the warning to be produced when this condition is {@code true}.
     * @param warning the text of the warning to match.
     * @param followup how are we planning to resolve the deprecation before it turns into a breakage;

| Value is the name of the Suite.
| No default, no compatibility

| link:{javadocPath}/org/gradle/api/attributes/TestSuiteTargetName.html#TEST_SUITE_TARGET_NAME_ATTRIBUTE[`org.gradle.testsuite.target.name`]
| Indicates the name of the link:{javadocPath}/org/gradle/testing/base/TestSuiteTarget.html[TestSuiteTarget] that produced this output.
| Value is the name of the Target.

        final TaskContainer tasks = project.getTasks();
        tasks.register(PUBLISH_LOCAL_LIFECYCLE_TASK_NAME, publish -> {
            publish.setDescription("Publishes all Maven publications produced by this project to the local Maven cache.");
            publish.setGroup(PublishingPlugin.PUBLISH_TASK_GROUP);
        });

        project.getExtensions().configure(PublishingExtension.class, extension -> {

    @Nullable
    private volatile Try<T> result;

    /**
     * Creates a container for a value that is yet to be produced.
     *
     * Note: this is package protected. Use {@link CalculatedValueContainerFactory} instead.
     */

            return true;
        }
    }

    enum WorkResult {
        DID_WORK,
        DID_NO_WORK
    }

    /**
     * Loads output not produced during the current execution.
     * This can be output produced during a previous execution when the work is up-to-date,
     * or loaded from cache.
     */
    @Nullable
    Object loadAlreadyProducedOutput(File workspace);

     */
    void disableAutoTargetJvm();

    /**
     * Adds a task {@code javadocJar} that will package the output of the {@code javadoc} task in a JAR with classifier {@code javadoc}.
     * <P>
     * The produced artifact is registered as a documentation variant on the {@code java} component and added as a dependency on the {@code assemble} task.

                        + "This can lead to incorrect results being produced, depending on what order the tasks are executed",
                    consumer,
                    producer
                ))
                .solution("Declare task '" + producer + "' as an input of '" + consumer + "'")
                .solution("Declare an explicit dependency on '" + producer + "' from '" + consumer + "' using Task#dependsOn")

    by a `tf_executor.yield` operation. The operands of the terminator
    correspond to the result values of the `tf_executor.island` operation. An
    extra result of type `!tf_executor.control` is always produced by every
    `tf_executor.island`.
    Within an island, execution semantics follow standard sequential behavior as
    expected by TF2 and by compiler analyses and transformations, and values