child.started()
                instant.op1Running
                thread.blockUntil.op2Running
                child.completed()
                parent.completed()
            }
            start {
                def logger = factory.newOperation("category").setDescription("op-2")
                logger.started()
                instant.op2Running
                thread.blockUntil.op1Running

    long instant = 0L;
    final List<String> events = Lists.newArrayList();

    @Override
    public long readMicros() {
      return NANOSECONDS.toMicros(instant);
    }

    void sleepMillis(int millis) {
      sleepMicros("U", MILLISECONDS.toMicros(millis));
    }

    void sleepMicros(String caption, long micros) {
      instant += MICROSECONDS.toNanos(micros);

    long instant = 0L;
    final List<String> events = Lists.newArrayList();

    @Override
    public long readMicros() {
      return NANOSECONDS.toMicros(instant);
    }

    void sleepMillis(int millis) {
      sleepMicros("U", MILLISECONDS.toMicros(millis));
    }

    void sleepMicros(String caption, long micros) {
      instant += MICROSECONDS.toNanos(micros);

        server.stop()
        client.stop()

        then:
        1 * service.doStuff("1")
        1 * service.doStuff("2")
        1 * service.doStuff("3")
        1 * service.doStuff("4") >> { instant.received }

        cleanup:
        client?.stop()
        server?.stop()
    }

    def "client can send messages to server"() {
        RemoteService1 service = Mock()
        def server = new Server()

                        instant.first
                        thread.block()
                    }
                }
            }
            start {
                thread.blockUntil.first
                asWorker {
                    controller.transition(TestState.B, TestState.C) {
                        instant.second
                    }
                }
            }

        1 * serverHandler.dispatch("[message 1]")
        1 * serverHandler.dispatch("[message 2]")
        1 * serverHandler.dispatch("[message 3]") >> { instant.channel1Done }
        1 * serverHandler.dispatch("[message 4]") >> { instant.channel2Done }
        0 * _._
    }

    private class Participant {
        MessageHub hub = new MessageHub("participant", executorFactory, getErrorHandler())

import org.gradle.test.fixtures.file.TestFile
import org.gradle.util.GradleVersion
import org.gradle.util.JarUtils
import org.gradle.util.internal.DefaultGradleVersion

import java.text.SimpleDateFormat
import java.time.Instant
import java.util.concurrent.TimeUnit

import static org.gradle.cache.internal.WrapperDistributionCleanupAction.WRAPPER_DISTRIBUTION_FILE_PATH

trait GradleUserHomeCleanupFixture implements VersionSpecificCacheCleanupFixture {

                    instant.action1
                    thread.blockUntil.action2
                    ivy1 = param
                    ivySettings1 = param.settings
                    assert IvyContext.context.ivy.is(ivy1)
                } as Action)
            }
            start {
                manager.withIvy({ param ->
                    instant.action2

          "format": "table",
          "hide": false,
          "instant": true,
          "intervalFactor": 1,
          "legendFormat": "{{ destination_workload}}.{{ destination_workload_namespace }}",
          "refId": "A"
        },
        {
          "datasource": {

                thread.blockUntil.disabled
                DeprecationLogger.deprecate("nag").willBeRemovedInGradle9().undocumented().nagUser()
                instant.logged
            }
            start {
                DeprecationLogger.whileDisabled {
                    instant.disabled
                    DeprecationLogger.deprecate("ignored").willBeRemovedInGradle9().undocumented().nagUser()
                    thread.blockUntil.logged