}

var map_PodsMetricStatus = map[string]string{
	"":        "PodsMetricStatus indicates the current value of a metric describing each pod in the current scale target (for example, transactions-processed-per-second).",
	"metric":  "metric identifies the target metric by name and selector",
	"current": "current contains the current value for the given metric",
}

func (PodsMetricStatus) SwaggerDoc() map[string]string {

        "executable"     | "over java extension"                | null     | "other"        | "current"         | "other"
        "assigned tool"  | "over java extension"                | "other"  | null           | "current"         | "other"
    }

    def "uses #what toolchain #when (without java-base plugin)"() {
        Jvm currentJdk = Jvm.current()
        Jvm otherJdk = AvailableJavaHomes.differentVersion

    while (true) {
      long current = value;
      double currentVal = longBitsToDouble(current);
      double nextVal = updateFunction.applyAsDouble(currentVal);
      long next = doubleToRawLongBits(nextVal);
      if (updater.compareAndSet(this, current, next)) {
        return nextVal;
      }
    }
  }

  /**
   * Returns the String representation of the current value.
   *

        } finally {
            lock.unlock()
        }
    }

    private int getAvailablePort() {
        int first = current
        while (true) {
            current++
            if (current > endPort) {
                current = startPort
            }

            int candidate = current

            if (!(candidate in allocated) && portDetector.isAvailable(candidate)) {
                allocated.add(candidate)

        toolMethod = "${tool}For"
        current = (isCurrentJvm ? "current" : "non-current")
    }

    def "fails when trying to change java extension toolchain spec property after it has been used to resolve a toolchain"() {
        def jdkMetadata1 = AvailableJavaHomes.getJvmInstallationMetadata(Jvm.current())
        def jdkMetadata2 = AvailableJavaHomes.getJvmInstallationMetadata(AvailableJavaHomes.differentVersion)

        buildScript """

	}
}

func TestLookup(t *testing.T) {
	checkUser(t)

	want, err := Current()
	if err != nil {
		if hasCgo || (hasUSER && hasHOME) {
			t.Fatalf("Current: %v", err)
		} else {
			t.Skipf("skipping: %v", err)
		}
	}

	// TODO: Lookup() has a fast path that calls Current() and returns if the
	// usernames match, so this test does not exercise very much. It would be

    // This was added to keep KMP compatible with changes in Gradle 8.8
    def "can get current build operation via BuildOperationExecutor.getCurrentBuildOperation()" () {
        buildFile << """
            import org.gradle.internal.operations.*

            task currentBuildOperation {
                doLast {
                    println "Current build operation: " + services.get(BuildOperationExecutor).currentOperation
                }

	if (query == "upgrade" || query == "patch") && current != "" && current != "none" {
		// "upgrade" and "patch" may stay on the current version if allowed.
		if err := allowed(ctx, module.Version{Path: path, Version: current}); errors.Is(err, ErrDisallowed) {
			return revWithOrigin(nil), err
		}
		return lookup(current)
	}

	return revWithOrigin(nil), &NoMatchingVersionError{query: query, current: current}
}

      assert(!AtEnd());
      ++current$(i)_;

$for k [[
      if (current$(i+2-k)_ == end$(i+2-k)_) {
        current$(i+2-k)_ = begin$(i+2-k)_;
        ++current$(i+2-k-1)_;
      }

]]
      ComputeCurrentValue();
    }
    virtual ParamIteratorInterface<ParamType>* Clone() const {
      return new Iterator(*this);
    }
    virtual const ParamType* Current() const { return &current_value_; }

        DefaultProjectComponentSelector current = (DefaultProjectComponentSelector) selector;
        return new DefaultProjectComponentSelector(
            current.buildIdentifier,
            current.identityPath,
            current.projectPath,
            current.projectName,
            attributes,
            current.requestedCapabilities
        );
    }