MultisetTestSuiteBuilder.NoRecurse.NO_ENTRY_SET, // Cannot create entries with count > 1
  };

  static final Supplier<TreeSet<String>> STRING_TREESET_FACTORY =
      new Supplier<TreeSet<String>>() {
        @Override
        public TreeSet<String> get() {
          return new TreeSet<>(Ordering.natural().nullsLast());
        }
      };

    }

    @Test
    void testResetAndReuse() {
        // Test that HMACT64 can be reset and reused
        HMACT64 hmac = new HMACT64(TEST_KEY);

        // First use
        hmac.engineUpdate(TEST_DATA, 0, TEST_DATA.length);
        byte[] result1 = hmac.engineDigest();

        // Reset and reuse with same data
        hmac.engineReset();
        hmac.engineUpdate(TEST_DATA, 0, TEST_DATA.length);

    }

    /**
     * Test that pre-auth hash is reset on error
     */
    @Test
    @DisplayName("Pre-auth integrity hash should reset on error")
    void testPreauthHashResetOnError() throws Exception {
        // Setup invalid SMB2 state to trigger error
        setPrivateField(transport, "smb2", false);

        // Try to update preauth hash - should fail and reset

    }

    fun redactHeader(name: String) {
      val newHeadersToRedact = TreeSet(String.CASE_INSENSITIVE_ORDER)
      newHeadersToRedact += headersToRedact
      newHeadersToRedact += name
      headersToRedact = newHeadersToRedact
    }

    fun redactQueryParams(vararg name: String) {
      val newQueryParamsNameToRedact = TreeSet(String.CASE_INSENSITIVE_ORDER)
      newQueryParamsNameToRedact += queryParamsNameToRedact

    @Mock
    private CommonServerMessageBlock disconnectRequest;

    @Mock
    private CommonServerMessageBlockRequest nextRequest;

    @BeforeEach
    void setUp() {
        // Reset mocks before each test
        reset(request, response, context, disconnectRequest, nextRequest);
    }

    @Test
    @DisplayName("Test initResponse returns initialized response")
    void testInitResponse() {
        // Given

    }

    @Test
    @DisplayName("Test reset functionality")
    void testReset() {
        // Reset should not throw exception
        assertDoesNotThrow(() -> transaction.reset());

        // Transaction should be ready for reuse
        assertTrue(transaction.hasMoreElements());
    }

    @Test
    @DisplayName("Test reset with key and lastName")
    void testResetWithKeyAndLastName() {

                    }
                }

                // Emergency cleanup of trees
                if (this.trees != null) {
                    try {
                        // Clear all tree references
                        for (SmbTreeImpl tree : this.trees) {
                            try {
                                // Force release trees during emergency cleanup
                                tree.release();

        primarySetupOffset = PRIMARY_SETUP_OFFSET;
        secondaryParameterOffset = SECONDARY_PARAMETER_OFFSET;
    }

    @Override
    void reset() {
        super.reset();
        isPrimary = hasMore = true;
    }

    void reset(final int key, final String lastName) {
        reset();
    }

    @Override
    public boolean hasMoreElements() {
        return hasMore;
    }

    @Override

      new RegularImmutableSortedSet<Object>(
          new TreeSet<Object>((Comparator<Object>) NATURAL_ORDER), false);

  static <E> ImmutableSortedSet<E> emptySet(Comparator<? super E> comparator) {
    checkNotNull(comparator);
    if (NATURAL_ORDER.equals(comparator)) {
      return of();
    } else {
      return new RegularImmutableSortedSet<E>(new TreeSet<E>(comparator), false);
    }
  }

    b.limit(limit);
  }

  static void mark(Buffer b) {
    b.mark();
  }

  static void position(Buffer b, int position) {
    b.position(position);
  }

  static void reset(Buffer b) {
    b.reset();
  }

  private Java8Compatibility() {}