assertEquals(0x56, buffer[2] & 0xFF);
        assertEquals(0x78, buffer[3] & 0xFF);
    }

    @ParameterizedTest
    @ValueSource(ints = { 0, 1, 255, 256, 65535, 65536, Integer.MAX_VALUE })
    @DisplayName("Should handle boundary values")
    void testBoundaryValues(int value) {
        // Given
        byte[] buffer = new byte[4];

        // When
        Encdec.enc_uint32le(value, buffer, 0);

       * header blocks, we need to keep track of the smallest value in that interval.
       */
      private var smallestHeaderTableSizeSetting = Integer.MAX_VALUE
      private var emitDynamicTableSizeUpdate: Boolean = false

      @JvmField var maxDynamicTableByteCount: Int = headerTableSizeSetting

      // Visible for testing.

    private static final char PAD = '=';

    private static final byte[] DECODE_TABLE = new byte[128];
    static {
        for (int i = 0; i < DECODE_TABLE.length; i++) {
            DECODE_TABLE[i] = Byte.MAX_VALUE;
        }
        for (int i = 0; i < ENCODE_TABLE.length; i++) {
            DECODE_TABLE[ENCODE_TABLE[i]] = (byte) i;
        }
    }

    /**
     * Encodes data in Base64.
     *
     * @param inData

  Closeable {
  val pool = factory.newConnectionPool(routePlanner = this)
  val events = LinkedBlockingDeque<String>()
  var canceled = false
  var autoGeneratePlans = false
  var defaultConnectionIdleAtNanos = Long.MAX_VALUE
  private var nextPlanId = 0
  private var nextPlanIndex = 0
  val plans = mutableListOf<FakePlan>()

  override val deferredPlans = ArrayDeque<RoutePlanner.Plan>()

      checkArgument(occurrences >= 0);
      Integer frequency = backingMap.getOrDefault(element, 0);
      if (occurrences == 0) {
        return frequency;
      }
      checkArgument(occurrences <= Integer.MAX_VALUE - frequency);
      backingMap.put(element, frequency + occurrences);
      return frequency;
    }

    @Override
    Iterator<E> elementIterator() {
      return Multisets.elementIterator(entryIterator());

 * not used in this API). Since the count of an element is represented as an {@code int}, a multiset
 * may never contain more than {@link Integer#MAX_VALUE} occurrences of any one element.
 *
 * <p>{@code Multiset} refines the specifications of several methods from {@code Collection}. It
 * also defines an additional query operation, {@link #count}, which returns the count of an

        assertNull(expire);
    }

    // Test with different expire values
    public void test_differentExpireValues() {
        int[] testExpires = { 0, 1, 60, 3600, 86400, Integer.MAX_VALUE };

        for (int expire : testExpires) {
            ComponentUtil.setFessConfig(new FessConfig.SimpleImpl() {
                private static final long serialVersionUID = 1L;

                @Override

      static <V> NeverScheduledFuture<V> create() {
        return new NeverScheduledFuture<>();
      }

      @Override
      public long getDelay(TimeUnit unit) {
        return Long.MAX_VALUE;
      }

      @Override
      public int compareTo(Delayed other) {
        return Long.compare(getDelay(NANOSECONDS), other.getDelay(NANOSECONDS));
      }
    }
  }

  private val taskRunner = taskFaker.taskRunner
  private lateinit var cache: DiskLruCache
  private val toClose = ArrayDeque<DiskLruCache>()

  private fun createNewCache() {
    createNewCacheWithSize(Int.MAX_VALUE)
  }

  private fun createNewCacheWithSize(maxSize: Int) {
    cache =
      DiskLruCache(filesystem, cacheDir, appVersion, 2, maxSize.toLong(), taskRunner).also {
        toClose.add(it)
      }

  public static final class ImmutableLongArrayHeadSubListAsListGenerator
      extends TestLongListGenerator {
    @Override
    protected List<Long> create(Long[] elements) {
      Long[] suffix = {Long.MIN_VALUE, Long.MAX_VALUE};
      Long[] all = concat(elements, suffix);
      return makeArray(all).subArray(0, elements.length).asList();
    }
  }

  @J2ktIncompatible
  @GwtIncompatible // used only from suite