constructor = type.getConstructor();
    } catch (NoSuchMethodException e) {
      return arbitraryConstantInstanceOrNull(type);
    }
    constructor.setAccessible(true); // accessibility check is too slow
    try {
      return constructor.newInstance();
    } catch (InstantiationException | IllegalAccessException impossible) {
      throw new AssertionError(impossible);
    } catch (InvocationTargetException e) {

# of git and editors capable of LF line endings.
#
# Windows .bat files are known to have multiple bugs when run with LF
# endings, and so they are checked in with CRLF endings, with a test
# in test/winbatch.go to catch problems. (See golang.org/issue/37791.)
#
# We'll prevent accidental CRLF line endings from entering the repo
# via the git-codereview gofmt checks and tests.
#
# See golang.org/issue/9281.

            return execute(cliRequest);
        } catch (ExitException e) {
            return e.exitCode;
        } catch (UnrecognizedOptionException e) {
            // pure user error, suppress stack trace
            return 1;
        } catch (BuildAbort e) {
            CLIReportingUtils.showError(slf4jLogger, "ABORTED", e, cliRequest.showErrors);

            return 2;
        } catch (Exception e) {

                    ClassRealm classRealm = world.newRealm(realmId, null);

                    logger.debug("Created new class realm {}", realmId);

                    return classRealm;
                } catch (DuplicateRealmException e) {
                    realmId = id + '-' + random.nextInt();
                }
            }
        }
    }

    public ClassRealm getMavenApiRealm() {

            final ClassLoader orignal = currentThread.getContextClassLoader();
            currentThread.setContextClassLoader(CommonPoolUtil.class.getClassLoader());
            try {
                task.run();
            } catch (final Exception e) {
                logger.error("Uncaught exception from " + task, e);
            } finally {
                currentThread.setContextClassLoader(orignal);
            }
        });
    }

            Thread.sleep(500)
          } catch (e: InterruptedException) {
            throw AssertionError()
          }
          assertFailsWith<IOException> {
            response.body.source().readUtf8()
          }.also { expected ->
            exceptionRef.set(expected)
            latch.countDown()
          }
        }
      },
    )
    latch.await()
    assertThat(call.isCanceled()).isTrue()

          val exchange = response.exchange
          val streams: Streams
          try {
            checkUpgradeSuccess(response, exchange)
            streams = exchange!!.newWebSocketStreams()
          } catch (e: IOException) {
            failWebSocket(e, response)
            response.closeQuietly()
            exchange?.webSocketUpgradeFailed()
            return
          }

                        if (Files.isRegularFile(path)) {
                            return Files.getLastModifiedTime(path).toMillis();
                        }
                    } catch (final Exception e) {
                        logger.debug("Failed to access {}", key, e);
                    }
                    return 0L;
                }
            });

    protected FessFunctions() {

          state = STATE_READ_RESPONSE_HEADERS
          responseBuilder
        }
        else -> {
          state = STATE_OPEN_RESPONSE_BODY
          responseBuilder
        }
      }
    } catch (e: EOFException) {
      // Provide more context if the server ends the stream before sending a response.
      val address = carrier.route.address.url.redact()
      throw IOException("unexpected end of stream on $address", e)

		if (code === 0 && !go.exited) {
			// deadlock, make Go print error and stack traces
			go._pendingEvent = { id: 0 };
			go._resume();
		}
	});
	return go.run(result.instance);
}).catch((err) => {
	console.error(err);
	process.exit(1);