"int_value": 0
                },
                "grpc.keepalive_time_ms": {
                  "int_value": 10000
                },
                "grpc.keepalive_timeout_ms": {
                  "int_value": 20000
                }
              }
            }
          },
          "initial_metadata": [
          {{ if .sts }}
          {{ if .gcp_project_id }}

// errorcheck -0 -m -l

// Copyright 2020 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

type t [20000]*int

func (t) f() {
}

func x() {
	x := t{}.f // ERROR "t{}.f escapes to heap"
	x()
}

func y() {
	var i int       // ERROR "moved to heap: i"

    val a = Settings()
    a[Settings.HEADER_TABLE_SIZE] = 10000
    a[Settings.MAX_HEADER_LIST_SIZE] = 20000
    a[Settings.INITIAL_WINDOW_SIZE] = 30000
    val b = Settings()
    b[Settings.MAX_HEADER_LIST_SIZE] = 40000
    b[Settings.INITIAL_WINDOW_SIZE] = 50000
    b[Settings.MAX_CONCURRENT_STREAMS] = 60000
    a.merge(b)
    assertThat(a.headerTableSize).isEqualTo(10000)
    assertThat(a.getMaxHeaderListSize(-1)).isEqualTo(40000)

            "jarAnalysis",
            new HashCodeSerializer(),
            new ClassSetAnalysisData.Serializer(() -> new HierarchicalNameSerializer(interner))
        ).withCacheDecorator(inMemoryCacheDecoratorFactory.decorator(20000, true));
        this.classpathEntrySnapshotCache = new MinimalPersistentCache<>(cache.createIndexedCache(jarCacheParameters));

        IndexedCacheParameters<HashCode, ClassAnalysis> classCacheParameters = IndexedCacheParameters.of(

import static org.gradle.launcher.daemon.server.api.DaemonStateControl.State.Stopped

abstract class AbstractDaemonFixture implements DaemonFixture {
    public static final int STATE_CHANGE_TIMEOUT = 20000
    protected final DaemonLogFile daemonLog
    final DaemonContext context

    AbstractDaemonFixture(DaemonLogFile daemonLog, GradleVersion version) {
        this.daemonLog = daemonLog

  LOG_FIRST_N(INFO, 1)
      << "Finish Node Expansion Passes. Rewrite the op to call function: "
      << fname;

  return absl::OkStatus();
}

REGISTER_REWRITE(EagerOpRewriteRegistry::POST_PLACEMENT, 20000,
                 CompositeOpExpansion);

}  // namespace tfr

cmp go.mod go.mod.orig

! go mod tidy -go=0.9
stderr '^invalid value "0.9" for flag -go: expecting a Go version like "'$goversion'"$'

! go mod tidy -go=2000.0
stderr '^invalid value "2000.0" for flag -go: maximum supported Go version is '$goversion'$'


# Supported versions should change the go.mod file to be tidy according to the
# indicated version.

go mod tidy -go=1.15

    public JavaModuleDetector(FileContentCacheFactory cacheFactory, FileCollectionFactory fileCollectionFactory) {
        this.cache = cacheFactory.newCache("java-modules", 20000, new ModuleInfoLocator(), new BaseSerializerFactory().getSerializerFor(Boolean.class));
        this.fileCollectionFactory = fileCollectionFactory;
    }

	)
	supportedPortProtocols = sets.NewString(
		string(api.ProtocolTCP),
		string(api.ProtocolUDP),
		string(api.ProtocolSCTP),
	)
	maxTopologyLabels = 16
	maxAddresses      = 100
	maxPorts          = 20000
	maxEndpoints      = 1000
	maxZoneHints      = 8
)

// ValidateEndpointSliceName can be used to check whether the given endpoint
// slice name is valid. Prefix indicates this name will be used as part of

     * 8. We expect the test thread's interrupt state to be false.
     */
    InterruptionUtil.requestInterruptIn(200, TimeUnit.MILLISECONDS);

    assertFalse(Thread.interrupted());
    try {
      delayedFuture.get(20000, TimeUnit.MILLISECONDS);
      fail("expected to be interrupted");
    } catch (InterruptedException expected) {
    } catch (TimeoutException e) {
      throw new RuntimeException(e);
    }