package main

import "C"

import (
	"os"
	"runtime"
	"sync/atomic"
)

var started int32

// Start a goroutine that loops forever.
func init() {
	runtime.GOMAXPROCS(1)
	go func() {
		for {
			atomic.StoreInt32(&started, 1)
		}
	}()
}

//export GoFunction8
func GoFunction8() {
	for atomic.LoadInt32(&started) == 0 {
		runtime.Gosched()
	}
	os.Exit(0)
}

func main() {

	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

    }

    @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
            void run() {

  }

  private fun logWithTime(message: String) {
    val startNs = startNs
    val timeMs =
      if (startNs == null) {
        // Event occurred before start, for an example an early cancel.
        0L
      } else {
        TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startNs)
      }

    logger.invoke("[$timeMs ms] $message")
  }

  ) {
    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
    }

plugins {
    id("com.example.commons")
    id("org.springframework.boot")
}

dependencies {
    implementation("org.springframework.boot:spring-boot-starter-web")
    implementation("org.springframework.boot:spring-boot-starter-thymeleaf")

	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.
[19514] [INFO] Application startup complete.