adapter.completed('ok', new TestCompleteEvent(200L))
        adapter.completed('suite1', new TestCompleteEvent(200L))
        adapter.started(broken, new TestStartEvent(100L, 'suite2'))
        adapter.failure('broken', TestFailure.fromTestFrameworkFailure(new RuntimeException()))
        adapter.completed('broken', new TestCompleteEvent(200L))
        adapter.completed('suite2', new TestCompleteEvent(200L))

        processor.started(root, new TestStartEvent(100L))
        processor.completed('root', new TestCompleteEvent(200L))
        processor.started(other, new TestStartEvent(200L))

        when:
        processor.started(test, new TestStartEvent(200L))

        then:
        1 * target.started(test, { it.parentId == 'suite1' })
    }

    def doesNothingToTestWhichHasAParentId() {

class TestStartEventTest extends Specification {
    def canCreateCopyWithNonNullParentId() {
        TestStartEvent event = new TestStartEvent(200L)

        expect:
        def newEvent = event.withParentId('parent')
        newEvent != event
        newEvent.startTime == 200L
        newEvent.parentId == 'parent'
    }

        state.completed(new TestCompleteEvent(200L, ResultType.SKIPPED))

        when:
        def result = new DefaultTestResult(state)

        then:
        result.getStartTime() == 100L
        result.getEndTime() == 200L
        result.resultType == ResultType.SKIPPED
        result.exceptions == state.failures.collect { it.rawFailure }

        1 * workerLeaseService.blocking(_) >> { Runnable runnable -> runnable.run() }
        1 * processor.stop()
        then:
        1 * timeProvider.getCurrentTime() >> 200L
        1 * resultProcessor.completed({ it == "rootTestSuiteId456" }, { event ->
            event.endTime == 200L && event.resultType == null
        })
        0 * _._
    }

    def 'fires end events when detector fails'() {
        given:

      HeldCertificate.Builder()
        .serialNumber(100L)
        .build()
    val certA1Sha256Pin = pin(certA1.certificate)
    val certB1 =
      HeldCertificate.Builder()
        .serialNumber(200L)
        .build()
    val certB1Sha256Pin = pin(certB1.certificate)
    val certC1 =
      HeldCertificate.Builder()
        .serialNumber(300L)
        .build()

        .serialNumber(100L)
        .build()
    internal var certA1Sha256Pin = CertificatePinner.pin(certA1.certificate)

    private var certB1 =
      HeldCertificate.Builder()
        .serialNumber(200L)
        .build()
    internal var certB1Sha256Pin = CertificatePinner.pin(certB1.certificate)

    private var certC1 =
      HeldCertificate.Builder()
        .serialNumber(300L)
        .build()

                    startListener.daemonStarted(daemonConnection.getDaemon());
                    return daemonConnection;
                }
                try {
                    sleep(200L);
                } catch (InterruptedException e) {
                    throw UncheckedException.throwAsUncheckedException(e);
                }
            } while (!timer.hasExpired());
        } finally {

                if (System.currentTimeMillis() > expiry) {
                    throw new IllegalStateException("Timeout waiting for thread to block.");
                }
                try {
                    Thread.sleep(200L);
                } catch (InterruptedException e) {
                    throw UncheckedException.throwAsUncheckedException(e);
                }
            }
        }
    }

                    "cluster": {
                      "Kind": {
                        "StringValue": "outbound|2000||s1tcp.none"
                      }
                    },
                    "stat_prefix": {
                      "Kind": {
                        "StringValue": "outbound|2000||s1tcp.none"
                      }
                    }
                  }
                }
              }