super.setUp();

        originalFessConfig = ComponentUtil.getFessConfig();

        // Set up test FessConfig
        ComponentUtil.setFessConfig(new FessConfig.SimpleImpl() {
            private static final long serialVersionUID = 1L;

            @Override
            public String getCookieDefaultPath() {
                return "/test/path";
            }

            @Override

internal class FileOperator(
  private val fileChannel: FileChannel,
) {
  /** Write [byteCount] bytes from [source] to the file at [pos]. */
  @Throws(IOException::class)
  fun write(
    pos: Long,
    source: Buffer,
    byteCount: Long,
  ) {
    if (byteCount < 0L || byteCount > source.size) {
      throw IndexOutOfBoundsException()
    }
    var mutablePos = pos
    var mutableByteCount = byteCount

    private static final long serialVersionUID = 1L;

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

    private FileConfig fileConfig;

    public String getId() {
        return asDocMeta().id();
    }

    public void setId(final String id) {
        asDocMeta().id(id);
    }

    public Long getVersionNo() {
        return asDocMeta().version();

    /**
     * Gets the sequence number.
     *
     * @return the sequence number
     */
    public long getSequenceNumber() {
        return sequenceNumber;
    }

    /**
     * Sets the sequence number.
     *
     * @param sequenceNumber the sequence number
     */
    public void setSequenceNumber(long sequenceNumber) {
        this.sequenceNumber = sequenceNumber;
    }

    /**

        assertTrue(file.canRead(), "Should be readable");
        assertTrue(file.canWrite(), "Should be writable");

        // Test timestamps
        long createTime = file.createTime();
        long lastModified = file.lastModified();
        long lastAccess = file.lastAccess();

        assertTrue(createTime > 0, "Create time should be set");
        assertTrue(lastModified > 0, "Last modified time should be set");

   * value.
   */
  private static void assertApproximateElementCountGuess(BloomFilter<?> bf, int sizeGuess) {
    assertThat(bf.approximateElementCount()).isAtLeast((long) (sizeGuess * 0.99));
    assertThat(bf.approximateElementCount()).isAtMost((long) (sizeGuess * 1.01));
  }

  public void testCreateAndCheckMitz32BloomFilterWithKnownFalsePositives() {
    int numInsertions = 1000000;
    BloomFilter<String> bf =

    /** True if the caller has closed this stream. */
    internal var closed: Boolean = false

    @Throws(IOException::class)
    override fun read(
      sink: Buffer,
      byteCount: Long,
    ): Long {
      require(byteCount >= 0L) { "byteCount < 0: $byteCount" }

      while (true) {
        var tryAgain = false
        var readBytesDelivered = -1L

   *
   * {@snippet :
   * List<Class<?>> classes = Arrays.asList(
   *     Object.class, String.class, Number.class, Long.class);
   * return Iterables.filter(classes, subtypeOf(Number.class));
   * }
   *
   * The code above returns an iterable containing {@code Number.class} and {@code Long.class}.
   *
   * <p><b>Discouraged:</b> Prefer using {@code clazz::isAssignableFrom} or {@code x ->

   * @see FileChannel#map(MapMode, long, long)
   * @since 2.0
   */
  public static MappedByteBuffer map(File file) throws IOException {
    checkNotNull(file);
    return map(file, MapMode.READ_ONLY);
  }

  /**
   * Fully maps a file in to memory as per {@link
   * FileChannel#map(java.nio.channels.FileChannel.MapMode, long, long)} using the requested {@link
   * MapMode}.
   *

    // Polling and backoff constants (in ms)
    private static final long MAX_POLL_INTERVAL = 5000; // Normal polling: max 5 seconds
    private static final long MAX_ERROR_BACKOFF = 30000; // Error polling: max 30 seconds
    private static final long BASE_POLL_INTERVAL = 1000;
    private static final long BASE_ERROR_DELAY = 1000;
    private static final int MAX_FAILURE_LIMIT = 5; // Limit failures for backoff calculation