plugins {
    id("gradlebuild.distribution.api-java")
}

description = "Execution engine that takes a unit of work and makes it happen"

dependencies {
    api(libs.guava)
    api(libs.jsr305)
    api(libs.slf4jApi)

    api(projects.concurrent)
    api(projects.stdlibJavaExtensions)
    api(projects.serialization)
    compileOnly(libs.errorProneAnnotations)
    api(project(":base-services"))
    api(project(":build-cache"))

	assert.Equal(t, handles.Load(), 1)
	q.Add(types.NamespacedName{Name: "something else"})
	close(stop)
	assert.NoError(t, q.WaitForClose(time.Second))
	// event 2 is guaranteed to happen from WaitForClose
	assert.Equal(t, handles.Load(), 2)

        super(name, OutputType.FILE, task);
        // This is for backwards compatibility for plugins that attach a convention mapping to the replaced property
        // TODO - this wiring should happen automatically (and be deprecated too)
        getOutputLocation().convention(getProjectLayout().file(new DefaultProvider<>(() -> {

	for {
		i := bytes.Index(save, []byte("\n:"))
		if i == -1 {
			break
		}
		start := i + 2
		save = save[start:]
		end := bytes.Index(save, []byte(" "))
		if end == -1 {
			// shouldn't happen, but...
			break
		}
		chain := Chain(save[:end])
		chainsSet.Insert(chain)
		save = save[end:]
	}
	return chainsSet

		if err != nil {
			// This shouldn't happen: we should have already skipped count files that
			// don't contain valid start or end times.
			u.logger.Printf("BUG: failed to parse expiry for collected count file: %v", err)
			continue
		}

		if end.Before(thisInstant) {
			expiry := end.Format(dateFormat)
			countFiles[expiry] = append(countFiles[expiry], f)

    /**
     * Selects the artifacts for the matching variant of each node seen during traversal.
     * The implementation should attempt to select artifacts eagerly, but may be lazy where
     * the selection cannot happen until the results are queried.
     *
     * @param variantSelector Performs variant selection
     * @param spec Governs how artifacts are selected

// EmptyFields represents a set with no paths
// It looks like metav1.Fields{Raw: []byte("{}")}
var EmptyFields = func() metav1.FieldsV1 {
	f, err := SetToFields(*fieldpath.NewSet())
	if err != nil {
		panic("should never happen")
	}
	return f
}()

// FieldsToSet creates a set paths from an input trie of fields
func FieldsToSet(f metav1.FieldsV1) (s fieldpath.Set, err error) {
	err = s.FromJSON(bytes.NewReader(f.Raw))
	return s, err
}

		reactors []reaction
		// PV event to simulate. This PV will be automatically added to
		// initialObjects.
		updatedPV *v1.PersistentVolume
		// List of expected kubeclient actions that should happen during the
		// test.
		expectedActions []clienttesting.Action
	}{
		// PV events
		//
		{
			name:      "PV without finalizer -> finalizer is added",
			updatedPV: pv(),

        }

        ILoggerFactory loggerFactory = LoggerFactory.getILoggerFactory();
        if (!(loggerFactory instanceof OutputEventListenerBackedLoggerContext)) {
            // Cannot configure Slf4j logger. This will happen if:
            // - Tests are executed with a custom classloader (e.g using `java.system.class.loader`)
            // - Tests are run with `--module-path`, effectively hiding Gradle classes
            return;
        }

// output side to satisfy the constraint of the next operation.
struct RequantizeState {
  // Sometimes, we have to "requantize" the quantization result to satisfy all
  // the constraints. The "requantize" can happen either on the input or output
  // of the quantization result.
  enum RequantizePosition {
    NO_REQUANTIZE,
    ON_INPUT,
    ON_OUTPUT
  } pos = NO_REQUANTIZE;