suggester.createIndexIfNothing();
        Thread.sleep(100);

        // Verify initial state - should have one index
        GetAliasesResponse aliasResponse = client.admin().indices().prepareGetAliases(suggester.getIndex()).execute().actionGet();
        assertTrue("Should have at least one index initially", aliasResponse.getAliases().size() >= 1);

        // Create next index - this is the main method we're testing

    }

    @Test
    @DisplayName("Test multiple path operations")
    void testMultiplePathOperations() {
        request = new Smb2CreateRequest(mockConfig, "initial\\path.txt");
        assertEquals("\\initial\\path.txt", request.getPath());

        request.setPath("\\second\\path.txt");
        assertEquals("\\second\\path.txt", request.getPath());

        request.setPath("third\\path\\");

        char[] plaintext = "DestroyTest".toCharArray();
        byte[] encrypted = storage.encryptCredentials(plaintext);

        assertFalse(storage.isDestroyed(), "Storage should not be destroyed initially");

        // Destroy the storage - may throw DestroyFailedException if SecretKey doesn't support destroy
        try {
            storage.destroy();
        } catch (DestroyFailedException e) {

        negotiatedField.setAccessible(true);
        negotiatedField.set(initial, negotiationResponse);

        // When: Request connection with signing enforced
        SmbTransportImpl withSigning = pool.getSmbTransport(ctx, address, 445, false, true);

        // Then: Should create new connection
        assertNotSame(initial, withSigning, "Should create new connection with different signing");
    }

    @Test

    }

    @Test
    public void nextElement_firstCall_flipsIsPrimary() {
        DummyResponse d = new DummyResponse();
        // Initially isPrimary is true (inherited constructor)
        SmbComTransactionResponse r1 = (SmbComTransactionResponse) d.nextElement();
        assertSame(d, r1, "nextElement should return the same instance");

            assertNotNull(initialState, "Initial state should not be null");
            assertTrue(
                    initialState == RdmaConnection.RdmaConnectionState.DISCONNECTED
                            || initialState == RdmaConnection.RdmaConnectionState.CONNECTING,
                    "Initial state should be DISCONNECTED or CONNECTING");

            // Test connection properties

        assertFalse(cacheEntry.isComplete());

        // Step 3: Verify can cache directory listing
        assertTrue(directoryLeaseManager.canCacheDirectoryListing(directoryPath));

        // Step 4: Initially no cached listing
        assertNull(directoryLeaseManager.getCachedDirectoryListing(directoryPath));

        // Step 5: Simulate directory enumeration and update cache

        }
    }

    @Nested
    @DisplayName("Timeout Tests")
    class TimeoutTests {

        @Test
        @DisplayName("getOverrideTimeout should return null initially")
        void testGetOverrideTimeoutInitial() {
            assertNull(testRequest.getOverrideTimeout());
        }

        @Test
        @DisplayName("setOverrideTimeout should set timeout value")

    @DisplayName("Should verify response state methods from parent")
    void testResponseStateMethods() throws Exception {
        // Test that response inherits state tracking from ServerMessageBlock2Response

        // Initially not received
        Method isReceivedMethod = ServerMessageBlock2Response.class.getDeclaredMethod("isReceived");
        isReceivedMethod.setAccessible(true);
        assertFalse((boolean) isReceivedMethod.invoke(response));

  // Java 2nd Edition Item 76: Write readObject methods defensively.
  private transient AtomicLongArray longs;

  /**
   * Creates a new {@code AtomicDoubleArray} of the given length, with all elements initially zero.
   *
   * @param length the length of the array
   */
  public AtomicDoubleArray(int length) {
    this.longs = new AtomicLongArray(length);
  }

  /**