val latch = CountDownLatch(1)

    override fun runOnce(): Long {
      latch.countDown()
      return -1L
    }
  }

  /** Adds [task] to run in [delayNanos]. Returns true if the coordinator is impacted. */
  internal fun scheduleAndDecide(
    task: Task,
    delayNanos: Long,
    recurrence: Boolean,
  ): Boolean {
    task.initQueue(this)

    val now = taskRunner.backend.nanoTime()

     * {@link InternalTransformer} should return a {@link org.gradle.internal.resources.ResourceLockState.Disposition}
     * that tells the resource coordinator how to proceed:
     *
     * FINISHED - All locks were acquired, release the state lock
     * FAILED - One or more locks were not acquired, roll back any locks that were acquired and release the state lock

          return readyTask
        }

        // Notify the coordinator of a task that's coming up soon.
        coordinatorWaiting -> {
          if (minDelayNanos < coordinatorWakeUpAt - now) {
            backend.coordinatorNotify(this@TaskRunner)
          }
          return null
        }

        // No other thread is coordinating. Become the coordinator!
        else -> {
          coordinatorWaiting = true

            server.insertHandler(context)
            server.start()
        } catch (IllegalArgumentException ignored) {
            server = null // repository not found, probably running on coordinator. If not, error will be caught later
        }
    }

    void stopServer() {
        server?.stop()
    }

        when:
        def failures = []
        coordinator.withStateLock {
            finalizedPlan.collectFailures(failures)
        }

        then:
        failures.size() == 1
        def e = failures.first()
        e.message.contains("Execution failed for task :finalizer")

        then:
        coordinator.withStateLock {

[!GOOS:darwin] [!GOOS:linux] [!GOOS:windows] skip

# Verify that the fuzzing engine records the actual crashing input, even when
# a worker process terminates without communicating the crashing input back
# to the coordinator.

[short] skip
env GOCACHE=$WORK/cache

# Start fuzzing. The worker crashes after 100 iterations.
# The fuzz function writes the crashing input to "want" before exiting.

 * limitations under the License.
 */

package org.gradle.api.internal.file.archive;

import java.io.Closeable;
import java.io.File;

/**
 * A coordinator that can be used to manage access to decompressed data extracted from archive files like zip and tars.
 *
 * <p>
 * For a given build tree, only a single process is allowed write access to extract archives at a time.
 *

    def listenerBuildOperationDecorator = new TestListenerBuildOperationDecorator()
    def workerLimits = new DefaultWorkerLimits(1)
    def workerLeases = new DefaultWorkerLeaseService(coordinator, workerLimits)
    def executorFactory = Mock(ExecutorFactory)
    def accessHierarchies = new ExecutionNodeAccessHierarchies(CASE_SENSITIVE, Stub(Stat))

    }

    @After
    fun cleanUp() {
        unmockkStatic("gradlebuild.basics.kotlindsl.Kotlin_dsl_upstream_candidatesKt")
    }

    @Test
    fun `keeps flakiness-detection-commit as it is in coordinator build`() {
        verifyBaselineDetermination("any", true, flakinessDetectionCommitBaseline, flakinessDetectionCommitBaseline)
    }

    @Test
    fun `resolves to current commit in worker build`() {
        // given

}

// SnapshotCoverage copies the current counter values into coverageSnapshot,
// preserving them for later inspection. SnapshotCoverage also rounds each
// counter down to the nearest power of two. This lets the coordinator store
// multiple values for each counter by OR'ing them together.
func SnapshotCoverage() {
	cov := coverage()
	for i, b := range cov {
		b |= b >> 1
		b |= b >> 2
		b |= b >> 4
		b -= b >> 1