return "cannotMultipleRunBackend"
}

func TestUnionRun(t *testing.T) {
	backends := []Backend{
		&cannotMultipleRunBackend{started: make(chan struct{})},
		&cannotMultipleRunBackend{started: make(chan struct{})},
		&cannotMultipleRunBackend{started: make(chan struct{})},
	}

	b := Union(backends...)

	if err := b.Run(make(chan struct{})); err != nil {
		t.Errorf("union backend run: %v", err)
	}

        BuildOperationDescriptor generatedDescriptor;

        when:
        adapter.started(testDescriptorInternal, testStartEvent)

        then:
        1 * buildOperationIdFactory.nextId() >> 1
        1 * clock.currentTime >> 0
        1 * listener.started(_, _) >> {
            generatedDescriptor = it[0]
            assert generatedDescriptor.details.testDescriptor == testDescriptorInternal

        this
    }

    @PackageScope
    GradleExecResult execute(String... command) {
        if (!started) {
            container.withCommand("tail", "-f", "/dev/null")
            startContainer()
        }
        return container.execute(command)
    }

    void startContainer() {
        started = true
        container.start()
        monitor = new Thread(new Runnable() {
            @Override

  ) {
    defaultInstancePort = defaultInstance.port
    instanceAPort = instanceA.port
    instanceBPort = instanceB.port
    assertThat(defaultInstance.started).isTrue()
    assertThat(instanceA.started).isTrue()
    assertThat(instanceB.started).isTrue()
    assertThat(defaultInstancePort).isNotEqualTo(instanceAPort)
    assertThat(defaultInstancePort).isNotEqualTo(instanceBPort)
  }

  @AfterEach
  fun tearDown(

    def "allows events to be added as enum values"() {
        when:
        logging.events STARTED, SKIPPED

        then:
        logging.events == [STARTED, SKIPPED] as Set
    }

    def "allows events to be added as string values"() {
        when:
        logging.events "started", "skipped"

        then:
        logging.events == [STARTED, SKIPPED] as Set
    }

	if err := h.loadChart(); err != nil {
		return err
	}

	h.started = true
	return nil
}

// RenderManifest renders the current helm templates with the current values and returns the resulting YAML manifest string.
func (h *Renderer) RenderManifest(values string) (string, error) {
	if !h.started {
		return "", fmt.Errorf("fileTemplateRenderer for %s not started in renderChart", h.componentName)
	}

[19515] [INFO] Booting worker with pid: 19515
[19511] [INFO] Started server process [19511]
[19511] [INFO] Waiting for application startup.
[19511] [INFO] Application startup complete.
[19513] [INFO] Started server process [19513]
[19513] [INFO] Waiting for application startup.
[19513] [INFO] Application startup complete.
[19514] [INFO] Started server process [19514]
[19514] [INFO] Waiting for application startup.

        def taskOutput = getTaskOutput(result)
        matchesTaskOutput(taskOutput, testLogEventRegex(TestLogEvent.SKIPPED.consoleMarker))
    }

    def "can group started test log event with task if configured"() {
        given:
        buildFile << testLoggingEvents(TestLogEvent.STARTED.testLoggingIdentifier)
        file(JAVA_TEST_FILE_PATH) << javaTestClass { '' }

        when:
        executer.withConsole(consoleType)

2019-11-12 22:14:43.820  INFO 1389 --- [           main] o.g.samples.SpringBootDemoApplication    : No active profile set, falling back to default profiles: default
2019-11-12 22:14:44.108  INFO 1389 --- [           main] o.g.samples.SpringBootDemoApplication    : Started SpringBootDemoApplication in 5.537 seconds (JVM running for 5.8)

BUILD SUCCESSFUL

 *
 * Implementations are thread safe and can be signalled concurrently.
 * However, a finished signal must not be emitted before the signal of the
 * corresponding started event has returned.
 *
 * Implementations may retain the notification values beyond the method that passed them.
 * Started notifications maybe held until a corresponding finished notification, and slightly after.