* (inclusive) to {@code upper} (inclusive). (These are the same values contained in {@code
   * Range.closed(lower, upper)}.)
   *
   * @throws IllegalArgumentException if {@code lower} is greater than {@code upper}
   * @since 23.0
   */
  public static ContiguousSet<Integer> closed(int lower, int upper) {
    return create(Range.closed(lower, upper), DiscreteDomain.integers());
  }

    int lower = 0;
    int upper = list.size() - 1;

    while (lower <= upper) {
      int middle = (lower + upper) >>> 1;
      int c = comparator.compare(key, list.get(middle));
      if (c < 0) {
        upper = middle - 1;
      } else if (c > 0) {
        lower = middle + 1;
      } else {
        return lower
            + presentBehavior.resultIndex(

   * than {@code upper}.
   *
   * @throws IllegalArgumentException if {@code lower} is greater than <i>or equal to</i> {@code
   *     upper}
   * @throws ClassCastException if {@code lower} and {@code upper} are not mutually comparable
   * @since 14.0
   */
  public static <C extends Comparable<?>> Range<C> open(C lower, C upper) {

        // Encode "TEST" (0x54 0x45 0x53 0x54)
        // T=0x54: upper nibble 0x5->F(0x46), lower nibble 0x4->E(0x45)
        src[1] = 'F';
        src[2] = 'E'; // T
        // E=0x45: upper nibble 0x4->E(0x45), lower nibble 0x5->F(0x46)
        src[3] = 'E';
        src[4] = 'F'; // E
        // S=0x53: upper nibble 0x5->F(0x46), lower nibble 0x3->D(0x44)
        src[5] = 'F';
        src[6] = 'D'; // S

    }

    @Test
    void testCompareLowerCaseToUpperCaseASCII() {
        ComparableVersion lower = new ComparableVersion("1.a");
        ComparableVersion upper = new ComparableVersion("1.A");
        // Lower case is equal to upper case
        assertTrue(upper.compareTo(lower) == 0, "expected 1.A == 1.a");
        assertTrue(lower.compareTo(upper) == 0, "expected 1.a == 1.A");
    }

    @Test

 * extract additional metadata, or perform other transformations during the
 * indexing process.
 *
 * Ingesters are processed in priority order, with lower numbers having higher priority.
 */
public abstract class Ingester {

    /** Priority of this ingester (lower numbers = higher priority) */
    protected int priority = 99;

    /**
     * Default constructor.
     */
    public Ingester() {

                    if (lower == null || upper == null || lower.compareTo(upper) != 0) {
                        restrictions.add(new Restriction(lower, lowerInclusive, upper, upperInclusive));
                    } else if (lowerInclusive && upperInclusive) {
                        restrictions.add(new Restriction(lower, lowerInclusive, upper, upperInclusive));
                    }

       * firstComplementRangeLowerBound is the first complement range lower bound inside
       * complementLowerBoundWindow. Complement range lower bounds are either positive range upper
       * bounds, or Cut.belowAll().
       *
       * positiveItr starts at the first positive range with lower bound greater than
       * firstComplementRangeLowerBound. (Positive range lower bounds correspond to complement range
       * upper bounds.)

 * The factory maintains a sorted collection of ingesters based on their priority
 * and provides methods to add new ingesters and retrieve the current collection.
 *
 * Ingesters are automatically sorted by priority, with lower numbers having higher priority.
 */
public class IngestFactory {
    /** Logger instance for this class */
    private static final Logger logger = LogManager.getLogger(IngestFactory.class);

    }

    @Override
    public BaseEncoding lowerCase() {
      BaseEncoding result = lowerCase;
      if (result == null) {
        Alphabet lower = alphabet.lowerCase();
        result = lowerCase = (lower == alphabet) ? this : newInstance(lower, paddingChar);
      }
      return result;
    }

    @Override
    public BaseEncoding ignoreCase() {
      BaseEncoding result = ignoreCase;