Reflection.newProxy(Map.class, new CheckSetUpInvocationHandler(map, setUpRan));
      return proxy;
    }
  }

  /**
   * Intercepts calls to a {@code Map} to check that {@code setUpRan} is true when they happen. Then
   * forwards the calls to the underlying {@code Map}.
   */
  private static class CheckSetUpInvocationHandler implements InvocationHandler, Serializable {
    private final Map<String, String> map;

        }, "remove() should not throw any exception");
    }

    @Test
    @DisplayName("EmptyIterator should behave consistently across multiple calls")
    void testConsistentBehavior() {
        // When & Then - test multiple sequential calls
        for (int i = 0; i < 10; i++) {
            assertFalse(emptyIterator.hasNext(), "hasNext should consistently return false");

    }

    /**
     * Helper method to create a DcerpcPipeHandle with injected mocks
     * Uses mock to avoid constructor issues while allowing real method calls
     */
    private DcerpcPipeHandle createMockedDcerpcPipeHandle() throws Exception {
        // Create a mock without calling the constructor
        DcerpcPipeHandle handle = mock(DcerpcPipeHandle.class);

        assertTrue(result.contains("Illegal state in search log processing"));
        assertTrue(result.endsWith("\n"));
    }

    @Test
    public void test_execute_multipleErrors() {
        // Test with multiple calls to execute() with errors
        SearchLogHelper mockSearchLogHelper = new SearchLogHelper() {
            private int callCount = 0;

            @Override
            public void storeSearchLog() {

 * when responses are of an unexpected type or cannot be decoded.
 *
 * Other exception types cancel the current call:
 *
 *  * For synchronous calls made with [Call.execute], the exception is propagated to the caller.
 *
 *  * For asynchronous calls made with [Call.enqueue], an [IOException] is propagated to the caller
 *    indicating that the call was canceled. The interceptor's exception is delivered to the current

        // When
        mockRequest.setFileId(testFileId);

        // Then
        verify(mockRequest, times(1)).setFileId(testFileId);
    }

    @Test
    @DisplayName("Should handle multiple setFileId calls")
    void testMultipleSetFileIdCalls() {
        // Given
        RequestWithFileId request = new Smb2CloseRequest(mockConfig, emptyFileId);
        byte[] firstFileId = new byte[16];

        assertNull(session.transport, "transport not created yet");
        SmbTransport tr = session.transport();
        assertNotNull(tr, "transport should now exist");
        // subsequent calls return the same instance
        assertSame(tr, session.transport());
    }

    @Test
    void sendResetsResponseAndForwards() throws Exception {
        SmbSession session = new SmbSession(addr, 445, inet, 0, auth);

import java.util.NavigableSet;
import java.util.NoSuchElementException;
import java.util.SortedMap;
import org.jspecify.annotations.Nullable;

/**
 * A navigable map which forwards all its method calls to another navigable map. Subclasses should
 * override one or more methods to modify the behavior of the backing map as desired per the <a
 * href="http://en.wikipedia.org/wiki/Decorator_pattern">decorator pattern</a>.
 *

   *
   * <p>This method should be overridden when bulk retrieval is significantly more efficient than
   * many individual lookups. Note that {@link LoadingCache#getAll} will defer to individual calls
   * to {@link LoadingCache#get} if this method is not overridden.
   *
   * @param keys the unique, non-null keys whose values should be loaded

            doNothing().when(mockSession).close();

            assertDoesNotThrow(() -> {
                mockSession.close();
                mockSession.close();
            }, "Multiple close() calls should not throw exceptions");

            verify(mockSession, times(2)).close();
        }

        @Test
        @DisplayName("Should handle close with exception gracefully")