// Do not use directly with Compare.
const Future = ""

// AtLeast reports whether the file version v comes after a Go release.
//
// Use this predicate to enable a behavior once a certain Go release
// has happened (and stays enabled in the future).
func AtLeast(v, release string) bool {
	if v == Future {
		return true // an unknown future version is always after y.
	}

import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * A queueing mechanism that only executes items once certain conditions are reached.
 */
// TODO This class, DefaultBuildOperationQueue and ExecutionPlan have many of the same
// behavior and concerns - we should look for a way to generalize this pattern.

@LocalOnly
class FileSystemWatchingSettingsFinalizedBuildOperationIntegrationTest extends AbstractFileSystemWatchingIntegrationTest {

    def operations = new BuildOperationsFixture(executer, temporaryFolder)

    def "emits once when not used"() {
        given:
        settingsFile << "includeBuild 'plugin'"
        file("buildSrc/src/main/java/Thing.java") << "class Thing {}"
        createDir("plugin") {
            file("settings.gradle") << ""

	"log"
	"net/http"
	"net/http/httputil"
	"net/url"
	"os"
	"os/exec"
	"slices"
	"strings"
	"sync"
	"time"
)

type hgHandler struct {
	once      sync.Once
	hgPath    string
	hgPathErr error
}

func (h *hgHandler) Available() bool {
	h.once.Do(func() {
		h.hgPath, h.hgPathErr = exec.LookPath("hg")
	})
	return h.hgPathErr == nil
}

//
// Certificates are returned wrapped in an activeCert struct that should be held by
// the caller. When references to the activeCert are freed, the number of references
// to the certificate in the cache is decremented. Once the number of references
// reaches zero, the entry is evicted from the cache.
//
// The main difference between this implementation and CRYPTO_BUFFER_POOL is that

import org.apache.maven.project.ProjectBuilder;

/**
 * This realizes the metadata source via the default hint to provide backward-compat with Maven 2.x whose Plexus version
 * registered component descriptors twice: once keyed by role+roleHint and once keyed by role only. This effectively
 * made the metadata source available with its original role hint ("maven") as well as the default hint.
 *
 */
@Named
@Singleton
@Deprecated

@Requires(IntegTestPreconditions.NotConfigCached)
class ConfigurationCacheSettingsFinalizedBuildOperationIntegTest extends AbstractIntegrationSpec {

    def operations = new BuildOperationsFixture(executer, temporaryFolder)

    def "emits once when not used"() {
        given:
        settingsFile << "includeBuild 'plugin'"
        file("buildSrc/src/main/java/Thing.java") << "class Thing {}"
        createDir("plugin") {
            file("settings.gradle") << ""

     * the build process and provide it to the worker.
     */
    FilteringClassLoader.Spec getGradleApiFilterSpec();

    /**
     * Returns the extension classloader spec for use in worker processes.  This is expensive to calculate, so we create it once in
     * the build process and provide it to the worker.
     */

import java.io.File;

/**
 * Controls the state (not loaded / loaded) of the attached {@link GradleProperties} instance
 * so that the set of Gradle properties is deterministically loaded only once per build.
 */
@ServiceScope(Scope.Build.class)
public interface GradlePropertiesController {

    /**
     * The {@link GradleProperties} instance attached to this service.
     */

     * queried via {@link #getSoftwareTypeImplementations()}.
     */
    void register(Class<? extends Plugin<Project>> pluginClass, Class<? extends Plugin<Settings>> registeringPluginClass);

    /**
     * Returns a set of the software types available along with their model types and associated plugins.  Note that once