service.stopAsync();
    service.stopAsync();
    service.stopAsync().awaitTerminated();
    assertEquals(Service.State.TERMINATED, service.state());
    service.stopAsync().awaitTerminated();
    assertEquals(Service.State.TERMINATED, service.state());

    executionThread.join();
  }

  public void testServiceExitingOnItsOwn() throws Exception {

    assertThrows(RejectedExecutionException.class, () -> executor.submit(doNothingRunnable));
    assertTrue(executor.isTerminated());

    otherThread.join(1000);
    assertEquals(Thread.State.TERMINATED, otherThread.getState());
    Throwable throwable = throwableFromOtherThread.get();
    assertNull(
        "Throwable from other thread: "
            + (throwable == null ? null : Throwables.getStackTraceAsString(throwable)),

    assertLessThan(NEW, STARTING);
    assertLessThan(NEW, TERMINATED);

    assertLessThan(STARTING, RUNNING);
    assertLessThan(STARTING, STOPPING);
    assertLessThan(STARTING, FAILED);

    assertLessThan(RUNNING, STOPPING);
    assertLessThan(RUNNING, FAILED);

    assertLessThan(STOPPING, FAILED);
    assertLessThan(STOPPING, TERMINATED);
  }

    /**
     * 
     * @param zterm
     *            whether the string should be zero terminated
     */
    public UnicodeString ( boolean zterm ) {
        this.zterm = zterm;
    }


    /**
     * 
     * @param rus
     *            wrapped string
     * @param zterm
     *            whether the string should be zero terminated
     */
    public UnicodeString ( rpc.unicode_string rus, boolean zterm ) {

		// If it was a job pod that (a) we captured and (b) just terminated (successfully or otherwise)
		// remove it (the pod process is gone, but kube will keep the Pods around in
		// a terminated || failed state - we should still do cleanup)
		if isAnnotated && isTerminated {
			log.Debugf("deleting pod from mesh: pod was enabled but is now terminated")

    TestService service = new TestService();
    service.stopAsync().awaitTerminated();
    assertEquals(0, service.startUpCalled);
    assertEquals(0, service.shutDownCalled);
    assertEquals(Service.State.TERMINATED, service.state());
    assertThat(service.transitionStates).isEmpty();
  }

  public void testStop_afterStart() {
    TestService service = new TestService();
    service.startAsync().awaitRunning();

    checkNotNull(charSequence);

    try (Writer out = openStream()) {
      out.append(charSequence);
    }
  }

  /**
   * Writes the given lines of text to this sink with each line (including the last) terminated with
   * the operating system's default line separator. This method is equivalent to {@code
   * writeLines(lines, System.getProperty("line.separator"))}.
   *

                logger.error("IndexUpdater is terminated.", e);
            } else if (logger.isInfoEnabled()) {
                logger.info("IndexUpdater is terminated.");
            }
            forceStop();
        } catch (final Throwable t) {
            if (ComponentUtil.available()) {
                logger.error("IndexUpdater is terminated.", t);
            } else if (logger.isDebugEnabled()) {

    assertThrows(RejectedExecutionException.class, () -> executor.submit(doNothingRunnable));
    assertTrue(executor.isTerminated());

    otherThread.join(1000);
    assertEquals(Thread.State.TERMINATED, otherThread.getState());
    Throwable throwable = throwableFromOtherThread.get();
    assertNull(
        "Throwable from other thread: "
            + (throwable == null ? null : Throwables.getStackTraceAsString(throwable)),

			log.Errorf("Error running UDS log server: %v", err)
		}
	}()

	go func() {
		<-stop
		if err := l.loggingServer.Close(); err != nil {
			log.Errorf("CNI log server terminated with error: %v", err)
		} else {
			log.Debug("CNI log server terminated")
		}
	}()

	return nil
}

func (l *UDSLogger) handleLog(w http.ResponseWriter, req *http.Request) {
	if req.Body == nil {
		return
	}
	defer req.Body.Close()