assertEquals(2048, negotiationWithLargeBuffers.getResponseRaw().length);
    }

    @Test
    @DisplayName("Fields should be immutable after construction")
    void testImmutability() {
        // Get references to the objects
        SmbNegotiationRequest originalRequest = negotiation.getRequest();

     *
     * @return the actual port number
     */
    public int getPort() {
        return ((ServerConnector) server.getConnectors()[0]).getLocalPort();
    }

    /**
     * Update the port in sitemaps files after the server has started.
     * This is needed when using port 0 (random port) because the actual port
     * is not known until the server starts.
     */
    public void updateSitemapsPort() {

  }

  int getSuccessor(int entryIndex) {
    return (entryIndex + 1 < size) ? entryIndex + 1 : -1;
  }

  /**
   * Updates the index an iterator is pointing to after a call to remove: returns the index of the
   * entry that should be looked at after a removal on indexRemoved, with indexBeforeRemove as the
   * index that *was* the next entry that would be looked at.
   */

        newCapacity = Integer.MAX_VALUE; // guaranteed to be >= newCapacity
      }
      return newCapacity;
    }

    /**
     * Returns a new immutable array. The builder can continue to be used after this call, to append
     * more values and build again.
     *
     * <p><b>Performance note:</b> the returned array is backed by the same array as the builder, so

    <example>${fe:join(values)}</example>
  </function>

  <function>
    <description>
      Returns a string resulting from replacing in an input string all occurrences
      of a "before" string into an "after" substring.
    </description>
    <name>replace</name>
    <function-class>org.codelibs.fess.taglib.FessFunctions</function-class>

    }

    @Test
    public void test_destroy() {
        // Test destroy method - should not throw exception
        thumbnailGenerator.destroy();
        // After destroy, generator should not be available
        assertFalse(thumbnailGenerator.isAvailable());
    }

    @Test
    public void test_createTask_withValidParams() {

        .withPluginClasspath()
        .forwardOutput()
        /*
        This is a workaround to use `--no-daemon` with TestKit.
        Without this, daemon may keep writing to project dir after the test finishes, resulting in errors like:

        org.junit.platform.commons.JUnitException: Failed to close extension context
	        at java.base/java.util.ArrayList.forEach(ArrayList.java:1511)

    }
    if (restoreInterruptedBit) {
      currentThread.interrupt();
    }
    /*
     * TODO(cpovirk): Clear interrupted status here? We currently don't, which means that an
     * interrupt before, during, or after runInterruptibly() (unless it produced an
     * InterruptedException caught above) can linger and affect listeners.
     */
  }

  /**

    this.backingThreadFactory = checkNotNull(backingThreadFactory);
    return this;
  }

  /**
   * Returns a new thread factory using the options supplied during the building process. After
   * building, it is still possible to change the options used to build the ThreadFactory and/or
   * build again. State is not shared amongst built instances.
   *

   * the map directly affect the cache.
   *
   * <p>Iterators from the returned map are at least <i>weakly consistent</i>: they are safe for
   * concurrent use, but if the cache is modified (including by eviction) after the iterator is
   * created, it is undefined which of the changes (if any) will be reflected in that iterator.
   */
  @J2ktIncompatible // Thread safety complexity
  ConcurrentMap<K, V> asMap();

  /**