// The carry input must be 0 or 1; otherwise the behavior is undefined.
// The carryOut output is guaranteed to be 0 or 1.
//
// This function's execution time does not depend on the inputs.
// On supported platforms this is an intrinsic lowered by the compiler.
func Add64(x, y, carry uint64) (sum, carryOut uint64) {
	sum = x + y + carry

        succeeds 'help'

        then: 'shared bean should have been isolated'
        output.count('Bean.value = 42') == 2
        outputDoesNotContain 'Bean.value = 43'
    }

    def 'flow actions cannot depend on tasks'() {
        given:
        buildFile '''
            import org.gradle.api.flow.*
            import org.gradle.api.services.*
            import org.gradle.api.tasks.*

        """

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

    @Issue("https://github.com/gradle/gradle/issues/6735")
    def "can depend on the source set of another Java project"() {
        createDirs("java", "scala")
        settingsFile << """
            include 'java', 'scala'
        """
        buildFile << """
            allprojects {

// limitations under the License.

package krt

import (
	"go.uber.org/atomic"

	"istio.io/istio/pkg/ptr"
)

// RecomputeTrigger trigger provides an escape hatch to allow krt transformations to depend on external state and recompute
// correctly when those change.
// Typically, all state is registered and fetched through krt.Fetch. Through this mechanism, any changes are automatically

# The only intended use case of this library is by `pywrap_tensorflow_to_stablehlo`. Not letting
# `pywrap_tensorflow_to_stablehlo` directly depend on sub-libraries like `static_range_srq` and instead haiving
# a consolidated impl library `pywrap_tensorflow_to_stablehlo_lib_impl` allows the maintainers to avoid

  LazyLogger(Class<?> ownerOfLogger) {
    this.loggerName = ownerOfLogger.getName();
  }

  Logger get() {
    /*
     * We use double-checked locking. We could the try racy single-check idiom, but that would
     * depend on Logger not contain mutable state.
     *
     * We could use Suppliers.memoizingSupplier here, but I micro-optimized to this implementation

        // Technically, the relative order or entries is visible to the caller, so it might be considered when computing the hash.
        // However, the File.list spec leaves the order undefined, so no reasonable implementation should depend on it.
        // Making the hash order-independent by sorting the entries maximizes CC hits, even if the OS-returned order changes.
        Arrays.sort(entries)
        entries.forEach(hasher::putString)
        hasher.hash()

env GO111MODULE=on

# TODO(golang.org/issue/41297): we shouldn't need go.sum. None of the commands
# below depend on the build list.

go list -m -versions rsc.io/quote
stdout '^rsc.io/quote v1.0.0 v1.1.0 v1.2.0 v1.2.1 v1.3.0 v1.4.0 v1.5.0 v1.5.1 v1.5.2 v1.5.3-pre1$'

# Latest rsc.io/quote should be v1.5.2, not v1.5.3-pre1.
go list -m rsc.io/quote@latest
stdout 'rsc.io/quote v1.5.2$'

====

This will create a `Sign` task for each publication you specify and wire all `publish__PubName__PublicationTo__RepoName__Repository` tasks to depend on it. Thus, publishing any publication will automatically create and publish the signatures for its artifacts and metadata, as you can see from this output:

== Example: Sign and publish a project

.Output of `gradle publish`

            }
        """
        file("src/testFixtures/java/Example.java") << """
            class Example {}
        """

        expect:
        succeeds("verify")
    }

    def "can depend on test fixtures from another project"() {
        buildFile << """
            plugins {
                id 'java-test-fixtures'
            }
        """
        file("src/testFixtures/java/Example.java") << """