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);

    /**

import java.util.Map;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Stream;

/**
 * Utility class for {@link Stream}.
 */
public abstract class StreamUtil {
    protected StreamUtil() {
        // nothing
    }

    /**
     * Creates a {@link StreamOf} instance from the provided values.

@Ignore("test runners must not instantiate and run this directly, only via suites we build")
// @Ignore affects the Android test runner, which respects JUnit 4 annotations on JUnit 3 tests.
@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class CollectionRemoveTester<E> extends AbstractCollectionTester<E> {
  @CollectionFeature.Require(SUPPORTS_REMOVE)
  @CollectionSize.Require(absent = ZERO)
  public void testRemove_present() {
    int initialSize = collection.size();

@Ignore("test runners must not instantiate and run this directly, only via suites we build")
// @Ignore affects the Android test runner, which respects JUnit 4 annotations on JUnit 3 tests.
@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class MapComputeIfAbsentTester<K, V> extends AbstractMapTester<K, V> {

  @MapFeature.Require(SUPPORTS_PUT)
  public void testComputeIfAbsent_supportedAbsent() {
    assertEquals(

        return expressionsBySyntax;
    }

    public void flushExpressionsBySyntax()
    {
        expressionsBySyntax = null;
    }
]]></code>
        </codeSegment>
      </codeSegments>
    </class>
    <class>
      <version>1.0.0</version>
      <name>Expression</name>
      <description>A plugin parameter expression supported by Maven</description>
      <fields>
        <field>
          <version>1.0.0</version>

import org.jspecify.annotations.Nullable;

/**
 * Tests for {@code ForwardingList}.
 *
 * @author Robert Konigsberg
 * @author Louis Wasserman
 */
@NullUnmarked
public class ForwardingListTest extends TestCase {
  static final class StandardImplForwardingList<T> extends ForwardingList<T> {
    private final List<T> backingList;

    StandardImplForwardingList(List<T> backingList) {
      this.backingList = backingList;

import org.jspecify.annotations.Nullable;

/**
 * Tests for {@link ForwardingSortedMultiset}.
 *
 * @author Louis Wasserman
 */
@NullUnmarked
public class ForwardingSortedMultisetTest extends TestCase {
  static class StandardImplForwardingSortedMultiset<E> extends ForwardingSortedMultiset<E> {
    private final SortedMultiset<E> backingMultiset;

 * continue to distinguish between exceptions and errors, even when they come from other threads.
 *
 * @author Chris Povirk
 * @since 10.0
 */
@GwtCompatible
public class ExecutionError extends Error {
  /*
   * Ideally, this class would have exposed only constructors that require a non-null cause. See

    assertCanIterateAgain(filtered);
    assertEquals("[foo]", filtered.toString());
  }

  private static class TypeA {}

  private interface TypeB {}

  private static class HasBoth extends TypeA implements TypeB {}

  @GwtIncompatible // Iterables.filter(Iterable, Class)
  public void testFilterByType() throws Exception {
    HasBoth hasBoth = new HasBoth();
    FluentIterable<TypeA> alist =

     *
     * @return an array of the method's parameter types
     */
    Class<?>[] getParameterTypes();

    /**
     * Returns the return type of the method.
     *
     * @param <T>
     *            the return type of the method
     * @return the return type of the method
     */
    <T> Class<T> getReturnType();

    /**
     * Returns {@literal true} if the method is {@literal public}.