return DoubleMath.roundToBigInteger(d, mode);
    }

    @Override
    BigInteger minus(BigInteger a, BigInteger b) {
      return a.subtract(b);
    }
  }

  /**
   * Returns the result of dividing {@code p} by {@code q}, rounding using the specified {@code
   * RoundingMode}.
   *
   * @throws ArithmeticException if {@code q == 0}, or if {@code mode == UNNECESSARY} and {@code a}

 *   <li>Building the query and filter query for the suggestion request.</li>
 *   <li>Processing the request and handling the response or failure.</li>
 *   <li>Creating the response from the search results.</li>
 * </ul>
 *
 * <p>Example usage:</p>
 * <pre>
 * SuggestRequest suggestRequest = new SuggestRequest();
 * suggestRequest.setIndex("my_index");
 * suggestRequest.setQuery("example query");

        SecureRandom expectedRandom = new SecureRandom();
        when(mockDelegate.getRandom()).thenReturn(expectedRandom);

        // When
        SecureRandom result = delegatingConfig.getRandom();

        // Then
        assertSame(expectedRandom, result, "Should return delegated random");
        verify(mockDelegate).getRandom();
    }

    @Test
    @DisplayName("Protocol version methods should delegate correctly")

                upperVersion = new DefaultArtifactVersion(upperBound);
            }

            if (upperVersion != null && lowerVersion != null) {
                int result = upperVersion.compareTo(lowerVersion);
                if (result < 0 || (result == 0 && (!lowerBoundInclusive || !upperBoundInclusive))) {
                    throw new InvalidVersionSpecificationException("Range defies version ordering: " + spec);
                }

      types[i] = resolveType(types[i]);
    }
    return types;
  }

  private Type[] resolveTypes(Type[] types) {
    Type[] result = new Type[types.length];
    for (int i = 0; i < types.length; i++) {
      result[i] = resolveType(types[i]);
    }
    return result;
  }

  private WildcardType resolveWildcardType(WildcardType type) {
    Type[] lowerBounds = type.getLowerBounds();

   * one or more such elements. Returns {@code true} if this queue contained the specified element
   * (or equivalently, if this queue changed as a result of the call).
   *
   * @param o element to be removed from this queue, if present
   * @return {@code true} if this queue changed as a result of the call
   */
  @CanIgnoreReturnValue
  @Override
  public boolean remove(@Nullable Object o) {
    if (o == null) return false;

 *
 * @author Kevin Bourrillion
 * @since 2.0
 */
@FunctionalInterface
@GwtCompatible
public interface Predicate<T extends @Nullable Object> extends java.util.function.Predicate<T> {
  /**
   * Returns the result of applying this predicate to {@code input} (Java 8+ users, see notes in the
   * class documentation above). This method is <i>generally expected</i>, but not absolutely
   * required, to have the following properties:
   *

    testGraphMutation(GraphBuilder.undirected());
  }

  private static void testGraphMutation(GraphBuilder<? super Integer> graphBuilder) {
    Random gen = new Random(42); // Fixed seed so test results are deterministic.

    for (int trial = 0; trial < NUM_TRIALS; ++trial) {
      MutableGraph<Integer> graph = graphBuilder.allowsSelfLoops(true).build();

      assertThat(graph.nodes()).isEmpty();

import org.opensearch.search.SearchHit;

/**
 * Utility class for search engine operations and content formatting.
 * Provides helper methods for working with XContent builders, scrolling through search results,
 * and converting XContent objects to different output formats.
 */
public final class SearchEngineUtil {

    private static final Logger logger = LogManager.getLogger(SearchEngineUtil.class);

    /**

   * edges". For that functionality, see {@link Graphs#reachableNodes(Graph, Object)}.
   *
   * <p>Some algorithms that operate on a {@code SuccessorsFunction} may produce undesired results
   * if the returned {@link Iterable} contains duplicate elements. Implementations of such
   * algorithms should document their behavior in the presence of duplicates.
   *