// If this test becomes flaky it means we broke the code which prevents mutation of in-memory cached module metadata
    def "selected variants are consistent using concurrent resolution of graphs from cache having different derivation strategies"() {
        executer.requireOwnGradleUserHomeDir()
        settingsFile << """
            include 'app'
            include 'lib'
        """

        buildFile << """

func contains(tokset uint64, tok token) bool {
	return tokset&(1<<tok) != 0
}

type LitKind uint8

// TODO(gri) With the 'i' (imaginary) suffix now permitted on integer
// and floating-point numbers, having a single ImagLit does
// not represent the literal kind well anymore. Remove it?
const (
	IntLit LitKind = iota
	FloatLit
	ImagLit
	RuneLit
	StringLit
)

type Operator uint

    }

    @Override
    public final FileObject createResource(JavaFileManager.Location location, CharSequence pkg, CharSequence relativeName, Element... originatingElements) throws IOException {
        // Prefer having javac validate the location over us, by calling it first.
        FileObject resource = delegate.createResource(location, pkg, relativeName, originatingElements);

 * It only intercepts the calls where the receiver is the class of interest.
 * <p>
 * It is possible but not strictly necessary to use this interceptor to intercept constructors.
 * Due to the way constructor interception works, having an {@link InterceptScope#constructorsOf(Class)
 * as a scope already guarantees that the invocation would have the given class object as the receiver.
 */

    elements.add(null);
    collection = getSubjectGenerator().create(elements.toArray());
    assertEquals(
        "A Set's hashCode() should be the sum of those of its elements (with "
            + "a null element counting as having a hash of zero).",
        expectedHashCode,
        getSet().hashCode());
  }

  /**
   * Returns the {@link Method} instances for the test methods in this class which call {@code

                output = file("output")
            }

            task build(type: GradleBuild) {
              dependsOn upper
              tasks = ["upper"]
              outputs.file "build.gradle" // having an output (or input) triggers the bug
            }
        """

        when:
        succeeds "build"

        then:
        executed ":upper", ":build", ":${testDirectory.name}:upper"

  // entries (i, delta) to the i-th entry of the partial sum.
  //
  // This allows us to efficiently compute the change to the peak of a memory
  // profile due to cloning an operation range without having to actually clone
  // that range and without having to build a profile vector.
  //
  // The returned vector has at most 2 entries for each tensor referenced in
  // [remat.begin, remat.end). There may be multiple entries for a single

		return nil, err
	}

	return &security.Caller{
		AuthSource: security.AuthSourceClientCertificate,
		Identities: ids,
	}, nil
}

// authenticateHTTP performs mTLS authentication for http requests. Requires having the endpoints on a listener
// with proper TLS configuration.
func (cca *ClientCertAuthenticator) authenticateHTTP(req *http.Request) (*security.Caller, error) {
	if req.TLS == nil || req.TLS.VerifiedChains == nil {

    {
      echo "It looks as if you don't have a compiled kubectl binary"
      echo
      echo "If you are running from a clone of the git repo, please run"
      echo "'./build/run.sh make cross'. Note that this requires having"
      echo "Docker installed."
      echo
      echo "If you are running from a binary release tarball, something is wrong. "
      echo "Look at http://kubernetes.io/ for information on how to contact the "

The script can be executed without Gradle - it will mimic a tool that requires an interactive login.

Gradle build file registers two tasks - one performs a login and the other one depends on the login having succeeded:
====
include::sample[dir="kotlin",files="build.gradle.kts[]"]
include::sample[dir="groovy",files="build.gradle[]"]
====

The `login` task declares an input property and connects it with a credentials provider.