}
        """

        when:
        succeeds('foo')

        then:

        def configOp = operations.only(ConfigureProjectBuildOperationType, { it.details.projectPath == ':foo' })
        with(operations.only(NotifyProjectBeforeEvaluatedBuildOperationType, { it.details.projectPath == ':foo' })) {
            displayName == 'Notify beforeEvaluate listeners of :foo'

	i, found := slices.BinarySearch(v.keys, key)
	if found {
		v.keys = slices.Delete(v.keys, i, i+1)
		v.m.Delete(key)
	}
}

// Do calls f for each entry in the map.
// The map is locked during the iteration,
// but existing entries may be concurrently updated.
func (v *Map) Do(f func(KeyValue)) {
	v.keysMu.RLock()
	defer v.keysMu.RUnlock()
	for _, k := range v.keys {
		i, _ := v.m.Load(k)
		val, _ := i.(Var)

        }

        buildFile << """
            import org.gradle.internal.operations.BuildOperationExecutor
            import org.gradle.internal.operations.RunnableBuildOperation
            import org.gradle.internal.operations.BuildOperationContext
            import org.gradle.internal.operations.BuildOperationDescriptor
            import java.util.concurrent.CountDownLatch

// The iteration order is not specified and is not guaranteed
// to be the same from one call to the next.
func All[Map ~map[K]V, K comparable, V any](m Map) iter.Seq2[K, V] {
	return func(yield func(K, V) bool) {
		for k, v := range m {
			if !yield(k, v) {
				return
			}
		}
	}
}

// Keys returns an iterator over keys in m.
// The iteration order is not specified and is not guaranteed

            assert state.configuring
        }

        and:
        state.executed

        and:
        operations.size() == 3
        assertConfigureOp(operations[0])
        assertBeforeEvaluateOp(operations[1])
        assertAfterEvaluateOp(operations[2])
    }

    void "notifies listeners and updates state on evaluation failure"() {
        when:

import org.gradle.internal.operations.BuildOperationExecutor;
import org.gradle.internal.operations.BuildOperationListenerManager;
import org.gradle.internal.operations.BuildOperationProgressEventEmitter;
import org.gradle.internal.operations.BuildOperationRunner;
import org.gradle.internal.operations.CurrentBuildOperationRef;
import org.gradle.internal.operations.DefaultBuildOperationExecutor;

import org.gradle.internal.operations.BuildOperationCategory;
import org.gradle.internal.operations.BuildOperationDescriptor;
import org.gradle.internal.operations.BuildOperationIdFactory;
import org.gradle.internal.operations.BuildOperationListener;
import org.gradle.internal.operations.OperationFinishEvent;
import org.gradle.internal.operations.OperationIdentifier;

                operations << 'withPlugin'
            }

            operations << "applying"
            apply plugin: pluginClass
            apply type: ruleSourceClass
            operations << "applied"

            task verify { doLast { assert operations == ['applying', 'withType', 'withId', 'withPlugin', 'applied'] } }

            gradle.buildFinished { loader.close() }
        """

    /**
     * The constant for the test execution operations.
     */
    String TEST_EXECUTION = "TEST_EXECUTION";

    /**
     * The constant for the task execution operations.
     */
    String TASK_EXECUTION = "TASK_EXECUTION";

    /**
     * The constant for the build execution operations.
     */
    String BUILD_EXECUTION = "BUILD_EXECUTION";

    /**

        operations * operation.run(_)

        where:
        // Where operations < maxThreads
        // operations = maxThreads
        // operations >> maxThreads
        operations | maxThreads
        0          | 1
        1          | 1
        20         | 1
        1          | 4
        4          | 4
        20         | 4
    }