return delegate.dispatch(request.unwrap()).wrap()
    }

    override fun peek(): mockwebserver3.MockResponse {
      return delegate.peek().wrap()
    }

    override fun shutdown() {
      delegate.shutdown()
    }
  }
}

internal fun MockResponse.wrap(): mockwebserver3.MockResponse {
  val result = mockwebserver3.MockResponse.Builder()
  val copyFromWebSocketListener = webSocketListener

    fun shutdownAll() {
      try {
        val toClear = servers.values.toList()
        servers.clear()
        for (server in toClear) {
          server.shutdown()
        }
      } catch (e: IOException) {
        logger.log(Level.WARNING, "MockWebServer shutdown failed", e)
      }
    }
  }

  @Suppress("NewApi")
  @IgnoreJRERequirement
  override fun supportsParameter(
    parameterContext: ParameterContext,

			case svc.Interrogate:
				s <- c.CurrentStatus
			case svc.Stop, svc.Shutdown:
				klog.Infof("Service stopping")
				// We need to translate this request into a signal that can be handled by the signal handler
				// handling shutdowns normally (currently apiserver/pkg/server/signal.go).
				// If we do not do this, our main threads won't be notified of the upcoming shutdown.

  @Test
  fun shutdownWithoutStart() {
    val server = MockWebServer()
    server.shutdown()
  }

  @Test
  fun closeViaClosable() {
    val server: Closeable = MockWebServer()
    server.close()
  }

  @Test
  fun shutdownWithoutEnqueue() {
    val server = MockWebServer()
    server.start()
    server.shutdown()
  }

  @Test
  fun portImplicitlyStarts() {

	} else {
		logger.Error(nil, "kubeClient is nil", "controller", tc.name)
		klog.FlushAndExit(klog.ExitFlushTimeout, 1)
	}
	defer tc.broadcaster.Shutdown()
	defer tc.nodeUpdateQueue.ShutDown()
	defer tc.podUpdateQueue.ShutDown()

	// wait for the cache to be synced
	if !cache.WaitForNamedCacheSync(tc.name, ctx.Done(), tc.podListerSynced, tc.nodeListerSynced) {
		return
	}

        response = client.get("/items/")
        assert response.status_code == 200, response.text
        assert response.json() == [{"name": "Foo"}]
    with open("log.txt") as log:
        assert "Application shutdown" in log.read()


def test_openapi_schema(app: FastAPI):
    with TestClient(app) as client:
        response = client.get("/openapi.json")
        assert response.status_code == 200, response.text

	// which prevent unsafe Add.
	Add(delta int) error

	// Done decrements the WaitGroup counter.
	Done()
}

// WithWaitGroup adds all non long-running requests to wait group, which is used for graceful shutdown.
func WithWaitGroup(handler http.Handler, longRunning apirequest.LongRunningRequestCheck, wg RequestWaitGroup) http.Handler {

limitations under the License.
*/

package nodeshutdown

import (
	"k8s.io/kubernetes/pkg/kubelet/lifecycle"
)

// NewManager returns a fake node shutdown manager for non linux platforms.
func NewManager(conf *Config) (Manager, lifecycle.PodAdmitHandler) {
	m := managerStub{}
	return m, m

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.internal.http2

import java.io.IOException

/**
 * Thrown when an HTTP/2 connection is shutdown (either explicitly or if the peer has sent a GOAWAY
 * frame) and an attempt is made to use the connection.
 */

 */

package org.gradle.api.internal.classloading;

/**
 * Doesn't need to do anything.
 */
public class NoOpGroovySystemLoader implements GroovySystemLoader {
    @Override
    public void shutdown() {
    }

    @Override
    public void discardTypesFrom(ClassLoader classLoader) {
    }