// Try to infer the effective jvm options for the currently running process.
        // We only care about 'managed' jvm args, anything else is unimportant to the running build
        JvmOptions jvmOptions = new JvmOptions(fileCollectionFactory);
        // TODO(mlopatkin) figure out a nicer way of handling the presence of agent in the foreground daemon.

        if (consumerVersion == null) {
            return "";
        } else {
            // Consumer version is provided by client 1.2 and later
            return String.format("You are currently using tooling API version %s. ", consumerVersion.getVersion());
        }
    }

    private void checkUnsupportedTapiVersion() {

	parsedRV, _ := strconv.Atoi(outPod.ResourceVersion)
	currentRV := fmt.Sprintf("%d", parsedRV+1)

	firstNonConsistentReadRV := lastObjecRV
	if consistentReadsSupported && !cacheEnabled {
		firstNonConsistentReadRV = currentRV
	}

	secondNonConsistentReadRV := lastObjecRV
	if consistentReadsSupported {
		secondNonConsistentReadRV = currentRV
	}

	tcs := []struct {
		name             string

    private static final GradleVersionSpec GRADLE_VERSION_SPEC = new GradleVersionSpec()

    static {
        // If we are testing a non-current tooling API version, we will have loaded the class using its classloader and thus
        // GradleVersion.current() will report that version. In order to set up the testing infrastructure, we need to
        // know the version of Gradle being built

        expect:
        JavaVersion.current() == current
        JavaVersion.current().java6 == isJava6
        JavaVersion.current().java7 == isJava7
        JavaVersion.current().java8 == isJava8
        JavaVersion.current().java9 == isJava9
        JavaVersion.current().java10 == isJava10
        JavaVersion.current().java11 == isJava11
        JavaVersion.current().java12 == isJava12

        and:

		firstRequest.Store(false)
		return status.Error(codes.Unavailable, "server warmup not complete; try again")
	}
	// Check if server is ready to accept clients and process new requests.
	// Currently ready means caches have been synced and hence can build
	// clusters correctly. Without this check, InitContext() call below would
	// initialize with empty config, leading to reconnected Envoys loosing

   */
  public void threadAssertFalse(boolean b) {
    try {
      assertFalse(b);
    } catch (AssertionFailedError t) {
      threadRecordFailure(t);
      throw t;
    }
  }

  /**
   * Just like assertNull(x), but additionally recording (using threadRecordFailure) any
   * AssertionFailedError thrown, so that the current testcase will fail.
   */

        }
    }

    private
    var writingState: WritingState = Idle()

    // Start fingerprinting if not already started and not already committed
    // This should be strict but currently this method may be called multiple times when a
    // build invocation both runs tasks and queries models

        String trimmed = constraint.trim();
        if (trimmed.equals("current")) {
            return new Spec<GradleVersion>() {
                @Override
                public boolean isSatisfiedBy(GradleVersion element) {
                    return element.equals(GradleVersion.current());
                }
            };
        }
        if (trimmed.equals("!current")) {
            return new Spec<GradleVersion>() {

  if curr_version.startswith('bazel '):
    curr_version = curr_version.split('bazel ')[1]

  curr_version_int = convert_version_to_int(curr_version)

  # Check if current bazel version can be detected properly.
  if not curr_version_int:
    print('WARNING: current bazel installation is not a release version.')
    return curr_version

  print('You have bazel %s installed.' % curr_version)
  return curr_version