}

  /**
   * Returns a stream over the values in this array, in order.
   *
   * @since 33.4.0 (but since 22.0 in the JRE flavor)
   */
  // If users use this when they shouldn't, we hope that NewApi will catch subsequent stream calls
  @IgnoreJRERequirement
  public IntStream stream() {
    return Arrays.stream(array, start, end);
  }

      for (String entry : entries) {
        jarOut.putNextEntry(new ZipEntry(entry));
        Resources.copy(ClassPathTest.class.getResource(entry), jarOut);
        jarOut.closeEntry();
      }
    } catch (Throwable e) {
      throw closer.rethrow(e);
    } finally {
      closer.close();
    }
  }

  private static Manifest manifest(String content) throws IOException {

   */
  static boolean safeContains(Collection<?> collection, @Nullable Object object) {
    checkNotNull(collection);
    try {
      return collection.contains(object);
    } catch (ClassCastException | NullPointerException e) {
      return false;
    }
  }

  /**
   * Delegates to {@link Collection#remove}. Returns {@code false} if the {@code remove} method

        ComponentUtil.setFessConfig(null);
        super.tearDown(testInfo);
    }

    private String encodeUrl(final String url) {
        try {
            return URLEncoder.encode(url, Constants.UTF_8);
        } catch (final UnsupportedEncodingException e) {
            throw new FessSystemException("Unsupported encoding.", e);
        }
    }

    @Test
    public void test_decodeUrl_ok() throws Exception {
        String url, exp;

      this.lock = lock;
    }

    @Override
    public void run() {
      lock.lock();
      try {
        locked.countDown();
        finishLatch.await(1, MINUTES);
      } catch (InterruptedException e) {
        fail(e.toString());
      } finally {
        lock.unlock();
      }
    }

    void waitUntilHoldingLock() throws InterruptedException {
      locked.await(1, MINUTES);

      this.lock = lock;
    }

    @Override
    public void run() {
      lock.lock();
      try {
        locked.countDown();
        finishLatch.await(1, MINUTES);
      } catch (InterruptedException e) {
        fail(e.toString());
      } finally {
        lock.unlock();
      }
    }

    void waitUntilHoldingLock() throws InterruptedException {
      locked.await(1, MINUTES);

class SIDCacheImplTest {

    // Helper to create a SID from text without throwing in the test body
    private static SID sid(String textual) {
        try {
            return new SID(textual);
        } catch (SmbException e) {
            throw new RuntimeException(e);
        }
    }

    @Test
    @DisplayName("resolveSids(DcerpcHandle,...) populates acct, domain and type for known types")

	if err != nil {
		return nil, err
	}

	_, err = obj.Stat()
	if err != nil {
		return nil, err
	}

	return obj, nil
}

// TransferError will catch network errors during transfer.
// When TransferError() is called Close() will also
// be called, so we do not need to Wait() here.
func (w *writerAt) TransferError(err error) {
	_ = w.w.CloseWithError(err)

      assertFailsWith<IOException> {
        source.readUtf8()
      }
      try {
        assertThat(response.peekTrailers()).isNull() // Okay. This is what HTTP/1 does.
      } catch (_: IOException) {
        // Also okay. This is what HTTP/2 does.
      }
      assertFailsWith<IOException> {
        response.trailers()
      }
    }
  }

  @Test

                     * have a real NetBIOS name
                     */
                    this.calledName = null;
                    return getHostName();
                }
            } catch (final UnknownHostException uhe) {
                this.calledName = null;
            }
        } else {
            this.calledName = null;
        }

        return this.calledName;
    }