throw new RuntimeException(e);
            }
        }, "close() should not throw any exception");
    }

    @Test
    @DisplayName("remove should not throw any exception")
    void testRemoveDoesNotThrowException() {
        // When & Then
        assertDoesNotThrow(() -> {
            emptyIterator.remove();
        }, "remove() should not throw any exception");
    }

    @Test

    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() {

            return parseArgs("atFile", args);
        } catch (ParseException e) {
            throw new IllegalArgumentException(
                    "Failed to parse arguments from file (" + atFile + "): " + e.getMessage(), e.getCause());
        } catch (IOException e) {
            throw new IllegalStateException("Error reading config file: " + atFile, e);
        }
    }

     * @param keys array of Kerberos keys for decryption
     * @throws PACDecodingException if token decoding fails
     */
    public KerberosToken(byte[] token, KerberosKey[] keys) throws PACDecodingException {

        if (token.length <= 0) {
            throw new PACDecodingException("Empty kerberos token");
        }

        byte[] content;
        try (ASN1InputStream stream = new ASN1InputStream(token)) {

        return caught;
      }
      throw new AssertionError(
          "expected to throw " + expectedThrowable.getSimpleName() + " but threw " + t, t);
    }
    if (userPassedSupplier) {
      throw new AssertionError(
          "expected to throw "
              + expectedThrowable.getSimpleName()
              + " but returned result: "
              + result);
    } else {

  public boolean addAll(Collection<? extends E> elementsToAdd) {
    throw up();
  }

  @Override
  public boolean removeAll(Collection<?> elementsToRemove) {
    throw up();
  }

  @Override
  public boolean retainAll(Collection<?> elementsToRetain) {
    throw up();
  }

  @Override
  public void clear() {
    throw up();
  }

  private static UnsupportedOperationException up() {

          throw exceptionSupplier.get();
        } else {
          throw new NoSuchElementException();
        }
      } else if (extras.isEmpty()) {
        return uncheckedCastNullableTToT(element);
      } else {
        throw multiples(false);
      }
    }
  }

  private MoreCollectors() {}

   *   throwIfUnchecked(failure);
   *   throw new AssertionError(failure);
   * }
   * </pre>
   *
   * @since 20.0
   */
  public static void throwIfUnchecked(Throwable throwable) {
    checkNotNull(throwable);
    if (throwable instanceof RuntimeException) {
      throw (RuntimeException) throwable;
    }
    if (throwable instanceof Error) {
      throw (Error) throwable;
    }
  }

  /**

     * @throws SmbException if an I/O error occurs
     */
    public void close() throws SmbException {
        file.close();
    }

    @Override
    public final boolean readBoolean() throws SmbException {
        if (read(tmp, 0, 1) < 0) {
            throw new SmbException("EOF");
        }
        return tmp[0] != (byte) 0x00;
    }

    @Override
    public final byte readByte() throws SmbException {

) : SSLSession {
  override fun getApplicationBufferSize(): Int = throw UnsupportedOperationException()

  override fun getCipherSuite(): String = throw UnsupportedOperationException()

  override fun getCreationTime(): Long = throw UnsupportedOperationException()

  override fun getId(): ByteArray = throw UnsupportedOperationException()

  override fun getLastAccessedTime(): Long = throw UnsupportedOperationException()