Ordering<Object> objects = Ordering.explicit((Object) 1);
    Ordering<Number> numbers = Ordering.explicit((Number) 1);
    Ordering<Integer> integers = Ordering.explicit(1);

    // Like by like equals like
    Ordering<Number> unusedA = numbers.compound(numbers);

    // The compound takes the more specific type of the two, regardless of order

    Ordering<Number> unusedB = numbers.compound(objects);

    Ordering<Object> objects = Ordering.explicit((Object) 1);
    Ordering<Number> numbers = Ordering.explicit((Number) 1);
    Ordering<Integer> integers = Ordering.explicit(1);

    // Like by like equals like
    Ordering<Number> unusedA = numbers.compound(numbers);

    // The compound takes the more specific type of the two, regardless of order

    Ordering<Number> unusedB = numbers.compound(objects);

            missing = fessConfig.getQueryFacetFieldsMissing();
        }
    }

    /**
     * Converts the sort string into a BucketOrder object for OpenSearch aggregations.
     * Parses sort configuration like "count.desc" or "term.asc" into appropriate bucket ordering.
     *
     * @return the BucketOrder instance representing the sort configuration
     */
    public BucketOrder getBucketOrder() {

import java.util.AbstractSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import org.jspecify.annotations.Nullable;

/**
 * A map-like data structure that wraps a backing map and caches values while iterating through
 * {@link #unmodifiableKeySet()}. By design, the cache is cleared when this structure is mutated. If

import junit.framework.TestCase;
import org.jspecify.annotations.NullUnmarked;
import org.jspecify.annotations.Nullable;

/**
 * Tests for {@link GcFinalization}.
 *
 * @author Martin Buchholz
 * @author mike nonemacher
 */
@AndroidIncompatible // depends on details of gc

@NullUnmarked
public class GcFinalizationTest extends TestCase {

  // ----------------------------------------------------------------

 * href="https://github.com/lukas-krecan/future-converter">Future Converter</a>.)
 *
 * <h3>Extension</h3>
 *
 * If you want a class like {@code FluentFuture} but with extra methods, we recommend declaring your
 * own subclass of {@link ListenableFuture}, complete with a method like {@link #from} to adapt an
 * existing {@code ListenableFuture}, implemented atop a {@link ForwardingListenableFuture} that

public class AbstractPackageSanityTestsTest extends TestCase {
  /*
   * This is a public type so that the Android test runner can create an instance directly as it
   * insists upon doing. It then runs the test, which behaves exactly like this package's existing
   * PackageSanityTests. (The test would run on the JVM, too, if not for the suppression below, and
   * that would be a problem because it violates small-test rules. Note that we strip the

    }

    // Happy path: handleDFSReferral returns a resolved path
    @Test
    @DisplayName("handleDFSReferral returns resolved UNC path as stubbed")
    void handleDfsReferralValidInputs() {
        // Edge-like Windows UNC-style: a single backslash in the path
        String reqPath = "\\";
        String resolved = "smb://server/share/path";
        when(locator.handleDFSReferral(referral, reqPath)).thenReturn(resolved);

    @ValueSource(strings = { "192.168.0", "abcd", "192.168" })
    void isDotQuadIPRejectsNonDotQuad(String value) {
        assertFalse(UniAddress.isDotQuadIP(value), "isDotQuadIP should return false for non IP-like values");
    }

    @Test
    void isDotQuadIPHandlesEmptyString() {
        // Empty string should return false, not throw exception

    expectUnchanged();
    assertTrue(collection.contains(e0()));
  }

  /*
   * AbstractCollection fails the removeAll(null) test when the subject
   * collection is empty, but we'd still like to test removeAll(null) when we
   * can. We split the test into empty and non-empty cases. This allows us to
   * suppress only the former.
   */

  @CollectionFeature.Require(SUPPORTS_REMOVE)