import org.gradle.test.precondition.Requires
import org.gradle.test.preconditions.IntegTestPreconditions
import org.gradle.workers.fixtures.WorkerExecutorFixture
import org.junit.Rule

import java.time.Instant

@IntegrationTestTimeout(120)
@Requires(IntegTestPreconditions.NotParallelExecutor)
class WorkerExecutorParallelBuildOperationsIntegrationTest extends AbstractWorkerExecutorIntegrationTest {
    @Rule

 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.internal.impl;

import java.nio.file.Path;
import java.time.Instant;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

import org.apache.maven.RepositoryUtils;
import org.apache.maven.api.*;
import org.apache.maven.api.annotations.Nonnull;

        return injector.getInstance(Session.class);
    }

    static class DefaultSession extends AbstractSession {

        private final Map<String, String> systemProperties;
        private Instant startTime = Instant.now();

        DefaultSession(RepositorySystemSession session, RepositorySystem repositorySystem, Lookup lookup) {
            this(session, repositorySystem, Collections.emptyList(), null, lookup);
        }

          },
          "exemplar": true,
          "expr": "max(minio_node_drive_total{job=~\"$scrape_jobs\",server=\"$server\"})",
          "format": "table",
          "hide": false,
          "instant": true,
          "interval": "",
          "intervalFactor": 1,
          "legendFormat": "",
          "metric": "process_start_time_seconds",
          "refId": "A",
          "step": 60
        }

                                return RETRY
                            }
                        } finally {
                            count++
                            instant."executed${count}"
                        }
                    }
                })
                assert lock1.doIsLockedByCurrentThread()
                assert lock2.doIsLockedByCurrentThread()
            }

            valueSource.clearFeedback();
        }
    }

    static class BuildTimestampValueSource extends AbstractValueSource {
        private final Instant startTime;
        private final Map<String, String> properties;

        BuildTimestampValueSource(Instant startTime, Map<String, String> properties) {
            super(false);
            this.startTime = startTime;
            this.properties = properties;
        }

 *  // runs the given closure and defines operation 'doStuff'
 *  operation.doStuff {
 *      // do some test action
 *  }
 *
 *  then:
 *  // query
 *  operation.doStuff.end > operation.doStuff.start
 *  instant.doStuff == operation.doStuff.end
 * </pre>
 */
class Operations {
    private final InstantFactory instantFactory
    private final Object lock = new Object()
    private final Map<String, NamedOperation> operations = [:]

import org.gradle.internal.Describables;
import org.gradle.internal.DisplayName;

import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import javax.inject.Inject;
import java.io.File;
import java.time.Instant;
import java.util.function.Supplier;

import static org.gradle.internal.time.TimestampSuppliers.daysAgo;

abstract public class DefaultCacheConfigurations implements CacheConfigurationsInternal {

		return
	}

	// Construct the name to present.
	log := ev.Log()
	name := log.Message
	if log.Category != "" {
		name = "[" + log.Category + "] " + name
	}

	// Emit an instant event.
	ctx.Instant(traceviewer.InstantEvent{
		Name:     name,
		Ts:       ctx.elapsed(ev.Time()),
		Category: "user event",
		Resource: uint64(id),
		Stack:    ctx.Stack(viewerFrames(ev.Stack())),
	})

        // still be waiting. A short time later, the workers will wake up and start running the work.
        Instant expiry = Instant.now().plus(2, ChronoUnit.SECONDS);
        ExecutorState.HealthState healthState;
        do {
            healthState = coordinationService.withStateLock(() -> state.healthCheck(queue));