checkNotNull(timeoutUnit);
    try {
      return callable.call();
    } catch (RuntimeException e) {
      throw new UncheckedExecutionException(e);
    } catch (Exception e) {
      restoreInterruptIfIsInterruptedException(e);
      throw new ExecutionException(e);
    } catch (Error e) {
      throw new ExecutionError(e);
    }
  }

  @CanIgnoreReturnValue // TODO(kak): consider removing this
  @Override

    MIEName(final byte[] buf) {
        int i;
        int len;
        if (buf.length < TOK_ID_SIZE + MECH_OID_LEN_SIZE) {
            throw new IllegalArgumentException();
        }
        // TOK_ID
        for (i = 0; i < TOK_ID.length; i++) {
            if (TOK_ID[i] != buf[i]) {
                throw new IllegalArgumentException();
            }
        }
        // MECH_OID_LEN
        len = 0xff00 & buf[i] << 8;
        i++;

   * Iterable)}, except that it does not throw {@link IOException}.
   *
   * @since 11.0
   */
  @CanIgnoreReturnValue
  public final StringBuilder appendTo(StringBuilder builder, Iterator<?> parts) {
    try {
      appendTo((Appendable) builder, parts);
    } catch (IOException impossible) {
      throw new AssertionError(impossible);
    }
    return builder;
  }

  /**

   * could throw during the invocation of that method. This is necessary because, e.g., a call to
   * {@code iterator().remove()} of an unmodifiable list could throw either {@link
   * IllegalStateException} or {@link UnsupportedOperationException}. Note that iterator
   * implementations should always throw one of the exceptions in a {@code PermittedExceptions}

                    throw new XmlPullParserException(
                            "Expected root element 'extensions' but found '" + parser.getName() + "'", parser, null);
                } else if (parsed) {
                    // fallback, already expected a XmlPullParserException due to invalid XML
                    throw new XmlPullParserException("Duplicated tag: 'extensions'", parser, null);

          boolean haveBeenCalled;

          @Override
          public Integer computeNext() {
            if (haveBeenCalled) {
              throw new AssertionError("Should not have been called again");
            } else {
              haveBeenCalled = true;
              throw sneakyThrow(new SomeCheckedException());
            }
          }
        };

    // The first time, the sneakily-thrown exception comes out

    @Test
    void testEncodeSourceOffsetBeyondLength() {
        // Test with source offset + length exceeding source array bounds
        byte[] data = { 0x01, 0x02 };
        // This constructor call itself should not throw an error, as it's just storing the values.
        // The error should occur when System.arraycopy is called.
        ByteEncodable encodable = new ByteEncodable(data, 1, 2); // off=1, len=2, data.length=2. 1+2 > 2

     * <code>getRequestingException</code> methods.
     * If this method returns <code>null</code> the <code>SmbAuthException</code> that triggered the authenticator check will
     * simply be rethrown. The default implementation returns <code>null</code>.
     * @return the authentication credentials or null if none available
     */
    protected NtlmPasswordAuthenticator getNtlmPasswordAuthentication() {

  private static final Callable<String> BAD_CALLABLE =
      () -> {
        MILLISECONDS.sleep(DELAY_MS);
        throw new SampleException();
      };
  private static final Runnable GOOD_RUNNABLE =
      () -> {
        try {
          MILLISECONDS.sleep(DELAY_MS);
        } catch (InterruptedException e) {
          throw new RuntimeException(e);
        }
      };
  private static final Runnable BAD_RUNNABLE =
      () -> {

  protected abstract E get(int index);

  /**
   * Constructs an iterator across a sequence of the given size whose initial position is 0. That
   * is, the first call to {@link #next()} will return the first element (or throw {@link
   * NoSuchElementException} if {@code size} is zero).
   *
   * @throws IllegalArgumentException if {@code size} is negative
   */
  protected AbstractIndexedListIterator(int size) {
    this(size, 0);
  }