readingConverter = SuggestUtil.createDefaultReadingConverter(client, settings);
        }
        try {
            readingConverter.init();
        } catch (final IOException e) {
            throw new SuggesterException("Failed to initialize reading converter: " + readingConverter.getClass().getName(), e);
        }

        if (contentsReadingConverter == null) {

        throw new UnsupportedOperationException(msg);
    }

    @Override
    protected <RESULT extends Entity> ListResultBean<RESULT> createListResultBean(final ConditionBean cb, final List<RESULT> selectedList) {
        if (selectedList instanceof EsPagingResultBean) {
            return (ListResultBean<RESULT>) selectedList;
        }

    private Unordered(N nodeU, N nodeV) {
      super(nodeU, nodeV);
    }

    @Override
    public N source() {
      throw new UnsupportedOperationException(NOT_AVAILABLE_ON_UNDIRECTED);
    }

    @Override
    public N target() {
      throw new UnsupportedOperationException(NOT_AVAILABLE_ON_UNDIRECTED);
    }

    @Override
    public boolean isOrdered() {
      return false;
    }

    @Override
    public boolean hasNext() {
      return true; // pretend that you have more...
    }

    @Override
    public E next() {
      // ...but throw an unchecked exception when you ask for it.
      if (!iterator.hasNext()) {
        throw new ThrowsAtEndException();
      }
      return iterator.next();
    }

    @Override
    public void remove() {
      iterator.remove();
    }
  }

        // Test with len = 23 (one byte too short)
        SMBProtocolDecodingException exception = assertThrows(SMBProtocolDecodingException.class, () -> response.decode(buffer, 0, 23),
                "Should throw exception when length < 24");

        assertEquals("Invalid resume key", exception.getMessage(), "Exception message should match");
    }

    @Test
    @DisplayName("Test decode throws exception with zero length")

  @ParametricNullness
  public static <V extends @Nullable Object> V getDone(Future<V> future) throws ExecutionException {
    /*
     * We throw IllegalStateException, since the call could succeed later. Perhaps we "should" throw
     * IllegalArgumentException, since the call could succeed with a different argument. Those

    this.iterator = iterator;
  }

  @Override
  public Iterator<E> iterator() {
    if (iterator == null) {
      // TODO: throw something else? Do we worry that people's code and tests
      // might be relying on this particular type of exception?
      throw new IllegalStateException();
    }
    try {
      return iterator;
    } finally {
      iterator = null;
    }
  }

      "u" -> username = value
      "pass" -> password = value
      "h" -> host = value
      "port" -> port = value
      "p" -> path = value
      "q" -> query = value
      "f" -> fragment = value
      else -> throw IllegalArgumentException("unexpected attribute: $value")
    }
  }

  override fun toString(): String = format("Parsing: <%s> against <%s>", input!!, base!!)

  companion object {

    try {
      Mac mac = Mac.getInstance(algorithmName);
      mac.init(key);
      return mac;
    } catch (NoSuchAlgorithmException e) {
      throw new IllegalStateException(e);
    } catch (InvalidKeyException e) {
      throw new IllegalArgumentException(e);
    }
  }

  @Override
  public Hasher newHasher() {
    if (supportsClone) {
      try {

      // permitted not to throw because it would be a no-op
    }
    expectUnchanged();
  }

  @MapFeature.Require(value = SUPPORTS_PUT, absent = ALLOWS_NULL_KEY_QUERIES)
  public void testReplace_absentNullKeyUnsupported() {
    try {
      getMap().replace(null, v3());
    } catch (NullPointerException tolerated) {
      // permitted not to throw because it would be a no-op
    }
    expectUnchanged();