# To verify the change, run the build with:
# @bot-gradle test ReadyForNightly
# ```
# stopGradleDaemons=true
# ```
version: "v1"
jdks:
  - params:
      - "linux.java8.openjdk.64bit"
      - "linux.java8.oracle.64bit"
    os: "linux"
    arch: "amd64"
    vendor: "oracle"
    version: "8u401"
    sha256: "19684fccd7ff32a8400e952a643f0049449a772ef63b8037d5b917cbd137d173"
  - params:
      - "linux.java11.openjdk.64bit"

    MapMaker maker = new MapMaker();
    assertThrows(IllegalArgumentException.class, () -> maker.initialCapacity(-1));
  }

  // TODO(cpovirk): enable when ready (apparently after a change to our GWT emulation)
  public void xtestInitialCapacity_setTwice() {
    MapMaker maker = new MapMaker().initialCapacity(16);
    try {
      // even to the same value is not allowed
      maker.initialCapacity(16);

//
// You can use returned dial function for `http.Transport.DialContext`.
//
// In this function, it uses functions from `rand` package. To make it really random,
// you MUST call `rand.Seed` and change the value from the default in your application
func DialContextWithLookupHost(lookupHost LookupHost, baseDialCtx DialContext) DialContext {
	if lookupHost == nil {
		lookupHost = net.DefaultResolver.LookupHost
	}

# the hashes of all the branch heads, so we can use a hash of
# all those branch names and heads as a conservative snapshot
# of the entire remote repo state, and use that as the tag sum.
# Any change on the server then invalidates the tag sum,
# even if it didn't have anything to do with tags, but at least
# we will avoid re-cloning a server when there have been no
# changes at all.
#

        internalInterface.name = replaceAsInternal(internalInterface.name)

        interfaces = ['internal': internalInterface,
                      'incubating': incubatingInterface]
    }

    def "#member change should not be reported"() {
        expect:
        noViolation(rule)

        where:
        member << [Mock(JApiMethod), Mock(JApiField), Mock(JApiImplementedInterface), Mock(JApiConstructor)]
    }

2. Running the CI scripts locally, as explained below
3. **Google employees only**: Google employees can use an internal-only tool
called "MLCI" that makes testing more convenient: it can execute any full CI job
against a pending change. Search for "MLCI" internally to find it.

You may invoke a CI script of your choice by following these instructions:

```bash
cd tensorflow-git-dir

    - [Node Binaries](#node-binaries-1)
    - [Container Images](#container-images-1)
  - [Changelog since v1.27.14](#changelog-since-v12714)
  - [Changes by Kind](#changes-by-kind-1)
    - [API Change](#api-change)
    - [Feature](#feature-1)
    - [Bug or Regression](#bug-or-regression-1)
  - [Dependencies](#dependencies-1)
    - [Added](#added-1)
    - [Changed](#changed-1)
    - [Removed](#removed-1)

 * things like environment, system properties, extensions etc. are loaded only once. It is caller duty to ensure
 * that subsequent call is right for the resident instance (ie no env change or different extension needed).
 * This implementation "pre-populates" MavenContext with pre-existing stuff (except for very first call)
 * and does not let DI container to be closed.
 */

import org.eclipse.aether.repository.RemoteRepository;
import org.eclipse.aether.repository.WorkspaceRepository;

/**
 * Default PluginCache implementation. Assumes cached data does not change.
 */
@Named
@Singleton
public class DefaultPluginRealmCache implements PluginRealmCache, Disposable {
    /**
     * CacheKey
     */
    protected static class CacheKey implements Key {

 */
public interface PluginValidationManager {
    enum IssueLocality {
        /**
         * Issue is "user actionable", is internal to the currently built project and is reparable from scope of it
         * by doing some change (for example by changing POM and fixing the problematic plugin configuration).
         */
        INTERNAL,

        /**