{105, "ENOBUFS", "no buffer space available"},
	{106, "EISCONN", "transport endpoint is already connected"},
	{107, "ENOTCONN", "transport endpoint is not connected"},
	{108, "ESHUTDOWN", "cannot send after transport endpoint shutdown"},
	{109, "ETOOMANYREFS", "too many references: cannot splice"},
	{110, "ETIMEDOUT", "connection timed out"},
	{111, "ECONNREFUSED", "connection refused"},
	{112, "EHOSTDOWN", "host is down"},

   */
  @ForOverride
  protected abstract void doStart();

  /**
   * This method should be used to initiate service shutdown. The invocation of this method should
   * cause a call to {@link #notifyStopped()}, either during this method's run, or after it has
   * returned. If shutdown fails, the invocation should cause a call to {@link
   * #notifyFailed(Throwable)} instead.
   *

	{139, "EISNAM", "is a named type file"},
	{140, "EREMOTEIO", "remote I/O error"},
	{141, "EINIT", "unknown error 141"},
	{142, "EREMDEV", "unknown error 142"},
	{143, "ESHUTDOWN", "cannot send after transport endpoint shutdown"},
	{144, "ETOOMANYREFS", "too many references: cannot splice"},
	{145, "ETIMEDOUT", "connection timed out"},
	{146, "ECONNREFUSED", "connection refused"},
	{147, "EHOSTDOWN", "host is down"},

    assertTrue(future.isDone());

    assertTrue(successLatch.await(200, MILLISECONDS));
    assertTrue(listenerLatch.await(200, MILLISECONDS));

    latch.countDown();

    exec.shutdown();
    exec.awaitTermination(100, MILLISECONDS);
  }

  /**
   * Tests that all listeners complete, even if they were added before or after the future was

        this.leakingLoader = leakingLoader;
        prefListenerField = AbstractPreferences.class.getDeclaredField("prefListeners");
        prefListenerField.setAccessible(true);
    }

    @Override
    public void shutdown() {
        try {
            Preferences groovyNode = Preferences.userRoot().node("/org/codehaus/groovy/tools/shell");

            constructorAction = """
                Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
                    @Override
                    public void run() {
                        println "Shutdown working dir: " + System.getProperty("user.dir")
                    }
                }));
            """
            action += """
                println "Execution working dir: " + System.getProperty("user.dir")

	}
	q.cond.Signal()
}

func (q *queueImpl) Closed() <-chan struct{} {
	return q.closed
}

// get blocks until it can return a task to be processed. If shutdown = true,
// the processing go routine should stop.
func (q *queueImpl) get() (task *queueTask, shutdown bool) {
	q.cond.L.Lock()
	defer q.cond.L.Unlock()
	// wait for closing to be set, or a task to be pushed
	for !q.closing && len(q.tasks) == 0 {
		q.cond.Wait()

	var errCh chan error
	tearDown := func() {
		cancel()

		// If the kube-controller-manager was started, let's wait for
		// it to shutdown cleanly.
		if errCh != nil {
			err, ok := <-errCh
			if ok && err != nil {
				logger.Error(err, "Failed to shutdown test server cleanly")
			}
		}
		if len(result.TmpDir) != 0 {
			os.RemoveAll(result.TmpDir)
		}
	}
	defer func() {

}

// New creates a new CertificateSigningRequest object.
func (r *StatusREST) New() runtime.Object {
	return &certificates.CertificateSigningRequest{}
}

// Destroy cleans up resources on shutdown.
func (r *StatusREST) Destroy() {
	// Given that underlying store is shared with REST,
	// we don't destroy it here explicitly.
}

// Get retrieves the object from the storage. It is required to support Patch.

      Proxy.Type.SOCKS,
      InetSocketAddress.createUnresolved("localhost", serverSocket!!.localPort),
    )
  }

  fun connectionCount(): Int = connectionCount.get()

  fun shutdown() {
    serverSocket!!.close()
    executor.shutdown()
    if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
      throw IOException("Gave up waiting for executor to shut down")
    }
  }

  private fun service(from: Socket) {