String current = getVersion();
        if (current.equals(version) || (version == null && current.isEmpty())) {
            return this;
        }
        return new RelocatedArtifact(artifact, groupId, artifactId, classifier, extension, version, message);
    }

    @Deprecated
    @Override
    public Artifact setFile(File file) {
        File current = getFile();

      double nextVal = currentVal + delta;
      long next = doubleToRawLongBits(nextVal);
      if (value.compareAndSet(current, next)) {
        return nextVal;
      }
    }
  }

  /**
   * Returns the String representation of the current value.
   *
   * @return the String representation of the current value
   */
  @Override
  public String toString() {

	out.Name = v1.ResourceName(in.Name)
	out.Container = in.Container
	out.CurrentAverageUtilization = in.Current.AverageUtilization
	if in.Current.AverageValue != nil {
		out.CurrentAverageValue = *in.Current.AverageValue
	}
	return nil
}

    /**
     * scope of the current dependency. Not-<code>null</code> all the time
     *
     * @return scope
     */
    IdeaDependencyScope getScope();

    /**
     * Allows to check if current dependency is transitive, i.e. is visible to the module which depends on module that has current dependency.
     *
     * @return <code>true</code> if current dependency is transitive; <code>false</code> otherwise
     */

var cwdOnce sync.Once

// UncachedCwd returns the current working directory.
// Most callers should use Cwd, which caches the result for future use.
// UncachedCwd is appropriate to call early in program startup before flag parsing,
// because the -C flag may change the current directory.
func UncachedCwd() string {
	wd, err := os.Getwd()
	if err != nil {
		Fatalf("cannot determine current directory: %v", err)
	}
	return wd
}

        options.forkOptions.executable = executable ? Jvm.current().javacExecutable.absolutePath : null

        def javaToolchain = null
        if (toolchain != null) {
            def isCurrent = toolchain == "current"
            javaToolchain = Mock(JavaToolchain)
            javaToolchain.installationPath >> TestFiles.fileFactory().dir(Jvm.current().javaHome)
            javaToolchain.isCurrentJvm() >> isCurrent

        Registries current = registries.get();
        Registries next = current.startProjectExecution(parallel);
        setProjectExecutionState(current, next);
    }

    @Override
    public void finishProjectExecution() {
        // TODO - check no locks are currently held
        Registries current = registries.get();
        Registries next = current.finishProjectExecution();

        String current = getVersion();
        if (current.equals(version) || (version == null && current.isEmpty())) {
            return this;
        }
        return new RelocatedArtifact(artifact, groupId, artifactId, classifier, extension, version, message);
    }

    @Deprecated
    @Override
    public Artifact setFile(File file) {
        File current = getFile();

    }

    static void assumeCurrentJavaVersionIsSupportedBy(VersionNumber kotlinVersionNumber) {
        JavaVersion current = JavaVersion.current()
        JavaVersion mini = getMinimumJavaVersionFor(kotlinVersionNumber)
        assumeTrue("KGP $kotlinVersionNumber minimum supported Java version is $mini, current is $current", current >= mini)
        JavaVersion maxi = getMaximumJavaVersionFor(kotlinVersionNumber)
        if (maxi != null) {

     * @throws IllegalStateException if the passed entry point token does not match the current innermost instrumented call tracked for the thread.
     */
    void leaveCall(EntryPointCallSite entryPoint);

    /**
     * Checks if the current thread's innermost instrumented call matches the name and call kind, and has not been marked as intercepted yet.
     *