}

    /**
     * Shuts down the Fess application.
     *
     * @param args command line arguments (not used)
     */
    public static void shutdown(final String[] args) {
        System.exit(0);
    }

    /**
     * Checks if the lasta.env system property is not set.
     *
     * @return true if lasta.env is not set, false otherwise
     */

      barrier.await(1, SECONDS);
      executor.execute(barrierTask);
      // timeout means the second task wasn't even tried
      barrier.await(1, SECONDS);
    } finally {
      service.shutdown();
    }
  }

  public void testRejectedExecutionThrownWithMultipleCalls() throws Exception {
    CountDownLatch latch = new CountDownLatch(1);
    SettableFuture<?> future = SettableFuture.create();

      }
    } catch (ae: AssertionError) {
      result += ae
    }

    if (result != null) throw result
  }

  private fun releaseClient() {
    testClient?.dispatcher?.executorService?.shutdown()
  }

  @SuppressLint("NewApi")
  private fun ExtensionContext.isFlaky(): Boolean =
    (testMethod.orElseGet { null }?.isAnnotationPresent(Flaky::class.java) == true) ||

    `LoggingEventListener.androidLogging()` write HTTP calls or events to Logcat.

 *  New: `OkHttpClient.webSocketCloseTimeout` configures how long a web socket connection will wait
    for a graceful shutdown before it performs an abrupt shutdown.

 *  Fix: Honor `RequestBody.isOneShot()` in `MultipartBody`

 *  Fix in `okhttp-coroutines`: Don't leak response bodies in `executeAsync()`. We had a bug where

	}

	return storageInfo
}

// Shutdown shutsdown all erasure coded sets in parallel
// returns error upon first error.
func (s *erasureSets) Shutdown(ctx context.Context) error {
	g := errgroup.WithNErrs(len(s.sets))

	for index := range s.sets {
		g.Go(func() error {
			return s.sets[index].Shutdown(ctx)
		}, index)
	}

	for _, err := range g.Wait() {
		if err != nil {

  /** Returns the lifecycle state of the service. */
  State state();

  /**
   * If the service is {@linkplain State#STARTING starting} or {@linkplain State#RUNNING running},
   * this initiates service shutdown and returns immediately. If the service is {@linkplain
   * State#NEW new}, it is {@linkplain State#TERMINATED terminated} without having been started nor

 *       MoreExecutors.directExecutor());
 *
 *     Runtime.getRuntime().addShutdownHook(new Thread() {
 *       public void run() {
 *         // Give the services 5 seconds to stop to ensure that we are responsive to shutdown
 *         // requests.
 *         try {
 *           manager.stopAsync().awaitStopped(5, TimeUnit.SECONDS);
 *         } catch (TimeoutException timeout) {
 *           // stopping timed out
 *         }

                  integer.getAndIncrement();
                }
              });
    }
  }

  @AfterExperiment
  void tearDown() throws Exception {
    executorService.shutdown();
  }

  @Footprint(exclude = {Runnable.class, Executor.class})
  public Object measureSize() {
    list = impl.newExecutionList();
    for (int i = 0; i < numListeners; i++) {

                    latch.countDown();
                }
            });
        }

        assertTrue(latch.await(10, TimeUnit.SECONDS), "Concurrent ops should complete");
        executor.shutdown();

        assertEquals(threadCount * operationsPerThread, successCount.get(), "All operations should succeed");
    }

    @Test

        } else if (currentChannels > targetChannels) {
            // Remove excess channels
            removeExcessChannels(currentChannels - targetChannels);
        }
    }
    
    public void shutdown() {
        scheduler.shutdown();
        
        for (ChannelInfo channel : channels.values()) {
            try {
                channel.getTransport().disconnect();
            } catch (Exception e) {