*
   * <p>The value returned by this method is non-null except in rare circumstances:
   *
   * <ul>
   *   <li>{@link #JAVA_EXT_DIRS} was deprecated in Java 8 and removed in Java 9. We have not
   *       confirmed whether it is available under older versions.
   *   <li>{@link #JAVA_COMPILER}, while still listed as required as of Java 15, is typically not
   *       available even under older version.

      // multiple times
      return target == that.target && method.equals(that.method);
    }
    return false;
  }

  /**
   * Checks whether {@code method} is thread-safe, as indicated by the presence of the {@link
   * AllowConcurrentEvents} annotation.
   */
  private static boolean isDeclaredThreadSafe(Method method) {

CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION
LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS

   * array or else you will break the immutability contract of {@code HashCode}.
   */
  byte[] getBytesInternal() {
    return asBytes();
  }

  /**
   * Returns whether this {@code HashCode} and that {@code HashCode} have the same value, given that
   * they have the same number of bits.
   */
  abstract boolean equalsSameBits(HashCode that);

  /**

     */
    @Override
    public Query toQuery(final QueryShardContext context) throws IOException {
        return queryBuilder.toQuery(context);
    }

    /**
     * Returns whether this query builder is a fragment.
     *
     * @return true if this is a fragment, false otherwise
     */
    @Override
    public boolean isFragment() {
        return queryBuilder.isFragment();
    }

    public OptionalEntity<JobLog> getJobLog(final String id) {
        return jobLogBhv.selectByPK(id);
    }

    /**
     * Stores a job log entry in the database.
     * Performs an insert or update operation based on whether the job log already exists.
     *
     * @param jobLog the job log to store
     */
    public void store(final JobLog jobLog) {

        jobLogBhv.insertOrUpdate(jobLog, op -> {

   * removeFrom.removeIf(predicate)} instead.
   *
   * @param removeFrom the iterable to (potentially) remove elements from
   * @param predicate a predicate that determines whether an element should be removed
   * @return {@code true} if any elements were removed from the iterable
   * @throws UnsupportedOperationException if the iterable does not support {@code remove()}.
   * @since 2.0
   */

        int hash2 = function.hashInt(key2).asInt();
        // test whether the hash values have same output bits
        same |= ~(hash1 ^ hash2);
        // test whether the hash values have different output bits
        diff |= hash1 ^ hash2;

        count++;
        // check whether we've exceeded the probabilistically
        // likely number of trials to have proven no funneling

         * Therefore, we can always create our own TypeVariable.
         *
         * 2. Under the JDK, the built-in TypeVariable implementation does not interoperate with
         * ours. Therefore, we have to be careful about whether we create our own TypeVariable:
         *
         * 2a. If the resolved types are identical to the original types, then we can return the

    assertEquals(distinct, getMultiset().elementSet().size());
  }

  @CollectionFeature.Require(absent = SUPPORTS_REMOVE)
  public void testRemove_occurrences_unsupported_absent() {
    // notice: we don't care whether it succeeds, or fails with UOE
    try {
      assertEquals(
          "multiset.remove(absent, 2) didn't return 0 or throw an exception",
          0,
          getMultiset().remove(e3(), 2));