int result = request.encode(buffer, 100);

            assertTrue(result > 0);
            assertTrue(result <= buffer.length - 100);
        }

        @Test
        @DisplayName("Should handle empty data array")
        void testEmptyDataArray() {
            byte[] emptyData = new byte[0];
            byte[] name = "TEST_DATA".getBytes(StandardCharsets.UTF_8);

        // Remove second instance
        assertTrue(ruleManager.removeRule(rule));
        assertEquals(0, ruleManager.getRuleCount());
        assertFalse(ruleManager.hasRule(rule));
    }

    /**
     * Test empty RuleManager
     */
    public void test_emptyRuleManager() {
        assertEquals(0, ruleManager.getRuleCount());

        ResponseData responseData = new ResponseData();

    /**
     * Gets the current user bean from the session.
     * This method returns the concrete FessUserBean class instead of the generic type.
     *
     * @return an optional containing the current user bean, or empty if not logged in
     */
    @Override
    protected OptionalThing<FessUserBean> getUserBean() { // to return as concrete class
        return fessLoginAssist.getSavedUserBean();
    }

    /**

    }

    // Test reload with InputStream
    public void test_reload_withComments() {
        String content = "# This is a comment\n" + "word1\n" + "\n" + // empty line
                "word2\n" + "# Another comment\n" + "word3\n";

        InputStream is = new ByteArrayInputStream(content.getBytes(StandardCharsets.UTF_8));
        stopwordsFile.reload(null, is);

    return populate(new HashMap<String, String>(), entries);
  }

  // TODO: call conversion constructors or factory methods instead of using
  // populate() on an empty map
  @CanIgnoreReturnValue
  private static <T, M extends Map<T, String>> M populate(M map, Entry<T, String>[] entries) {
    for (Entry<T, String> entry : entries) {
      map.put(entry.getKey(), entry.getValue());

    SortedSet<E> set = newTreeSet();
    for (E element : elements) {
      // Explicit null check because TreeSet wrongly accepts add(null) when empty.
      set.add(checkNotNull(element));
    }
    return set;
  }

  public static class ContiguousSetGenerator extends AbstractContiguousSetGenerator {
    @Override

     */
    public void validatePath(String path) throws SmbException {
        totalValidations.incrementAndGet();

        if (path == null || path.isEmpty()) {
            return; // Empty paths allowed
        }

        // Check overall path length
        if (path.length() > MAX_PATH_SIZE) {
            failedValidations.incrementAndGet();

    assertNotWellFormed(0xF0, 0x8F, 0xAD, 0xA2);
    assertNotWellFormed(0xF4, 0x90, 0xAD, 0xA2);
  }

  /** Tests some hard-coded test cases. */
  public void testSomeSequences() {
    // Empty
    assertWellFormed();
    // One-byte characters, including control characters
    assertWellFormed(0x00, 0x61, 0x62, 0x63, 0x7F); // "\u0000abc\u007f"
    // Two-byte characters

    // evict 9, 1, 2, 10
    getAll(cache, asList(15));
    CacheTesting.drainRecencyQueues(cache);
    assertThat(keySet).containsExactly(0, 6, 7, 8, 15);

    // fill empty space
    getAll(cache, asList(9));
    CacheTesting.drainRecencyQueues(cache);
    assertThat(keySet).containsExactly(0, 6, 7, 8, 15, 9);

    // evict 6
    getAll(cache, asList(1));

  }

  // Casting to any type is safe because the list will never hold any elements.
  @SuppressWarnings("unchecked")
  public static <E> ImmutableList<E> of() {
    return (ImmutableList<E>) RegularImmutableList.EMPTY;
  }

  public static <E> ImmutableList<E> of(E e1) {
    return new SingletonImmutableList<E>(checkNotNull(e1));
  }

  public static <E> ImmutableList<E> of(E e1, E e2) {