}

  public void testUncaughtExceptionHandler_custom() {
    assertEquals(
        UNCAUGHT_EXCEPTION_HANDLER,
        builder
            .setUncaughtExceptionHandler(UNCAUGHT_EXCEPTION_HANDLER)
            .build()
            .newThread(monitoredRunnable)
            .getUncaughtExceptionHandler());
  }

  public void testBuildMutateBuild() {

     * </p>
     *
     * @param handler
     *            クラスを処理するハンドラ
     */
    void forEach(ClassHandler handler);

    /**
     * このインスタンスが扱うリソースを探して
     * {@link ResourceHandler#processResource(String, java.io.InputStream) ハンドラ}
     * をコールバックします。
     * <p>
     * インスタンス構築時にルートディレクトリが指定されている場合は、 ルートディレクトリ以下のリソースのみが対象となります。
     * </p>
     *
     * @param handler
     *            リソースを処理するハンドラ
     */

        SingletonContext.getInstance();
        String pkgs = System.getProperty("java.protocol.handler.pkgs");
        if ( pkgs == null ) {
            System.setProperty("java.protocol.handler.pkgs", "jcifs");
        }
        else if ( pkgs.indexOf("jcifs") == -1 ) {
            pkgs += "|jcifs";
            System.setProperty("java.protocol.handler.pkgs", pkgs);
        }
    }


    /**
     * 
     */

app = FastAPI()


@app.exception_handler(StarletteHTTPException)
async def http_exception_handler(request, exc):
    return PlainTextResponse(str(exc.detail), status_code=exc.status_code)


@app.exception_handler(RequestValidationError)
async def validation_exception_handler(request, exc):
    return PlainTextResponse(str(exc), status_code=400)

	}
	errFatal := func(err error) {
		t.Helper()
		if err != nil {
			t.Fatal(err)
		}
	}
	wrapServer := func(handler http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			t.Logf("Got a %s request for: %v", r.Method, r.URL)
			handler.ServeHTTP(w, r)
		})
	}
	connReady := make(chan struct{})
	// We fake a local and remote server.
	localHost := hosts[0]

            activeLogger.level = Level.FINE
            handler.level = Level.FINE
            handler.formatter = MessageFormatter
            activeLogger.addHandler(handler)
          }

          if (sslDebug) {
            val activeLogger = getLogger("javax.net.ssl")

            activeLogger.level = Level.FINEST
            handler.level = Level.FINEST
            handler.formatter = MessageFormatter

from fastapi.exception_handlers import (
    http_exception_handler,
    request_validation_exception_handler,
)
from fastapi.exceptions import RequestValidationError
from starlette.exceptions import HTTPException as StarletteHTTPException

app = FastAPI()


@app.exception_handler(StarletteHTTPException)
async def custom_http_exception_handler(request, exc):
    print(f"OMG! An HTTP error!: {repr(exc)}")

	// If none of the routes match add default error handler routes
	apiRouter.NotFoundHandler = collectAPIStats("notfound", httpTraceAll(errorResponseHandler))
	apiRouter.MethodNotAllowedHandler = collectAPIStats("methodnotallowed", httpTraceAll(methodNotAllowedHandler("S3")))
}

// corsHandler handler for CORS (Cross Origin Resource Sharing)
func corsHandler(handler http.Handler) http.Handler {
	commonS3Headers := []string{
		xhttp.Date,

            MavenProject project, String artifactType, String artifactClassifier, File artifactFile) {
        ArtifactHandler handler = null;

        if (artifactType != null) {
            handler = artifactHandlerManager.getArtifactHandler(artifactType);
        }

        if (handler == null) {
            handler = artifactHandlerManager.getArtifactHandler("jar");
        }

        }
    }

  fun enable(
    loggerClass: String,
    handler: Handler = logHandler(),
  ): Closeable {
    val logger = Logger.getLogger(loggerClass)
    if (configuredLoggers.add(logger)) {
      logger.addHandler(handler)
      logger.level = Level.FINEST
    }
    return Closeable {
      logger.removeHandler(handler)
    }
  }

  fun enable(loggerClass: KClass<*>) = enable(loggerClass.java.name)