throw new CrawlingAccessException(
                    "Storage endpoint is blank. Please set the STORAGE_ENDPOINT environment variable or endpoint parameter.");
        }
        builder.endpoint(endpoint);
        final String accessKey = getInitParameter("accessKey", null, String.class);
        if (StringUtil.isBlank(accessKey)) {
            throw new CrawlingAccessException(

            final boolean update) {
        throw new UnsupportedOperationException("not yet.");
    }

    @Override
    public SuggestWriterResult delete(final Client client, final SuggestSettings settings, final String index, final String id) {
        throw new UnsupportedOperationException("not yet.");
    }

    @Override

   *     write {@code throw sneakyThrow(t);} to convince the compiler that the statement will always
   *     throw.
   */
  @CanIgnoreReturnValue
  static Error sneakyThrow(Throwable t) {
    throw new SneakyThrows<Error>().throwIt(t);
  }

  @SuppressWarnings("unchecked") // not really safe, but that's the point
  private Error throwIt(Throwable t) throws T {
    throw (T) t;
  }

  private SneakyThrows() {}

        throw ProtocolException(
          "HTTP $code had non-zero Content-Length: ${response.body.contentLength()}",
        )
      }
      return response
    } catch (e: IOException) {
      if (sendRequestException != null) {
        sendRequestException.addSuppressed(e)
        throw sendRequestException
      }
      throw e
    }
  }

    public T next() {
      try {
        return iterator.next();
      } catch (NoSuchElementException e) {
        nextThrewException = true;
        throw e;
      }
    }

    @Override
    public void remove() {
      if (nextThrewException) {
        throw new IllegalStateException();
      }
      iterator.remove();
    }
  }

  public void testCanCatchJdkBug6529795InTargetIterator() {

            + " see the Javadoc for Files.createTempDir().";

    @Override
    File createTempDir() {
      throw new IllegalStateException(MESSAGE);
    }

    @Override
    File createTempFile(String prefix) throws IOException {
      throw new IOException(MESSAGE);
    }
  }

  private TempFileCreator() {}

                        log.debug("Invalid parameter error.", e);
                    }
                    return;
                }
                throw new CIFSException("Failed to resolve SIDs", e);
            } catch (final IOException e) {
                throw new CIFSException("Failed to resolve SIDs", e);
            }
        }
    }

    @Override

            if (data.length <= 8) {
                throw new PACDecodingException("Empty PAC");
            }

            int bufferCount = pacStream.readInt();
            int version = pacStream.readInt();

            if (version != PacConstants.PAC_VERSION) {
                throw new PACDecodingException("Unrecognized PAC version " + version);
            }

     * @return {@link ResultSet}
     * @throws SQLRuntimeException
     *             If a {@link SQLException} occurs.
     */
    public static ResultSet executeQuery(final PreparedStatement ps) throws SQLRuntimeException {
        assertArgumentNotNull("ps", ps);

        try {
            return ps.executeQuery();
        } catch (final SQLException ex) {
            throw new SQLRuntimeException(ex);
        }
    }

                // contract of ExitException is that nothing needed by us
                throw e;
            } catch (Exception e) {
                // other exceptions (including InvokerException but sans Exit, see above): we need to inform user
                throw handleException(context, e);
            }
        } finally {
            Thread.currentThread().setContextClassLoader(oldCL);