import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

/**
 * Base class for services that do not need a thread while "running" but may need one during startup
 * and shutdown. Subclasses can implement {@link #startUp} and {@link #shutDown} methods, each which
 * run in an executor which by default uses a separate thread for each method.
 *
 * @author Chris Nokleberg
 * @since 1.0
 */
@GwtIncompatible
@J2ktIncompatible

    public CompositeGroovySystemLoader(GroovySystemLoader... loaders) {
        this.loaders = CollectionUtils.toList(loaders);
    }

    @Override
    public void shutdown() {
        for (GroovySystemLoader loader : loaders) {
            loader.shutdown();
        }
    }

    @Override
    public void discardTypesFrom(ClassLoader classLoader) {
        for (GroovySystemLoader loader : loaders) {

    delegate.start(inetAddress, port)
  }

  @Synchronized
  @Throws(IOException::class)
  fun shutdown() {
    delegate.shutdown()
  }

  @Synchronized override fun after() {
    try {
      shutdown()
    } catch (e: IOException) {
      logger.log(Level.WARNING, "MockWebServer shutdown failed", e)
    }
  }

  override fun toString(): String = delegate.toString()

type Backend struct {
	OnRequest func(events []*auditinternal.Event)
}

// Run does nothing.
func (b *Backend) Run(stopCh <-chan struct{}) error {
	return nil
}

// Shutdown does nothing.
func (b *Backend) Shutdown() {
	return
}

// ProcessEvents calls a callback on a batch, if present.
func (b *Backend) ProcessEvents(ev ...*auditinternal.Event) bool {
	if b.OnRequest != nil {
		b.OnRequest(ev)
	}

  metadata+="cluster-location=${KUBE_TEMP}/cluster-location.txt,"
  metadata+="cluster-name=${KUBE_TEMP}/cluster-name.txt,"
  metadata+="gci-update-strategy=${KUBE_TEMP}/gci-update.txt,"
  metadata+="shutdown-script=${KUBE_ROOT}/cluster/gce/gci/shutdown.sh,"
  metadata+="${NODE_EXTRA_METADATA}"
  echo "${metadata}"
}

# Assumed vars:
#   scope_flags
# Parameters:
#   $1: template name (required).

    try {
      server.start()
    } catch (e: IOException) {
      throw RuntimeException(e)
    }
  }

  override fun after() {
    try {
      server.shutdown()
    } catch (e: IOException) {
      logger.log(Level.WARNING, "MockWebServer shutdown failed", e)
    }
  }

  @ExperimentalOkHttpApi
  companion object {
    private val logger = Logger.getLogger(MockWebServerRule::class.java.name)
  }

	natsserver "github.com/nats-io/nats-server/v2/test"
)

func TestNatsConnTLSCustomCA(t *testing.T) {
	s, opts := natsserver.RunServerWithConfig(filepath.Join("testdata", "contrib", "nats_tls.conf"))
	defer s.Shutdown()

	clientConfig := &NATSArgs{
		Enable: true,
		Address: xnet.Host{
			Name:      "localhost",
			Port:      (xnet.Port(opts.Port)),
			IsPortSet: true,
		},
		Subject:       "test",

		backend := backend
		funcs = append(funcs, func() error {
			return backend.Run(stopCh)
		})
	}
	return errors.AggregateGoroutines(funcs...)
}

func (u union) Shutdown() {
	for _, backend := range u.backends {
		backend.Shutdown()
	}
}

func (u union) String() string {
	var backendStrings []string
	for _, backend := range u.backends {
		backendStrings = append(backendStrings, fmt.Sprintf("%s", backend))

		return fd.fakeNetFD.Close()
	}
	runtime.SetFinalizer(fd, nil)
	return fd.pfd.Close()
}

func (fd *netFD) shutdown(how int) error {
	if fd.fakeNetFD != nil {
		return nil
	}
	err := fd.pfd.Shutdown(how)
	runtime.KeepAlive(fd)
	return wrapSyscallError("shutdown", err)
}

func (fd *netFD) Read(p []byte) (n int, err error) {
	if fd.fakeNetFD != nil {
		return fd.fakeNetFD.Read(p)
	}

	Run(stopCh <-chan struct{}) error

	// Shutdown will synchronously shut down the backend while making sure that all pending
	// events are delivered. It can be assumed that this method is called after
	// the stopCh channel passed to the Run method has been closed.
	Shutdown()

	// Returns the backend PluginName.
	String() string