assertEquals(alsoRead, hasReadData, "FILE_READ_DATA flag presence should match alsoRead");
    }

    @Test
    @DisplayName("openCopyTargetFile retries after removing READONLY and succeeds")
    void openCopyTargetFile_retryOnReadonly_thenSuccess() throws Exception {
        // Arrange
        SmbFile dest = mock(SmbFile.class);
        SmbFileHandleImpl handle = mock(SmbFileHandleImpl.class);

            // Verify that no renewal happened
            assertFalse(renewed, "renewCredentials should return false if no renewal mechanism succeeds");
            assertEquals(mockCredentials, wrapper.getCredentials(), "Credentials should remain unchanged if no renewal mechanism succeeds");
            // Note: Credentials interface does not have renew() method
        }
    }

                        throw new RuntimeException("Even call error");
                    }
                    // Odd calls succeed
                }
            }
        };
        ComponentUtil.register(mockSearchLogHelper, "searchLogHelper");

        // First call (odd) should succeed
        String result1 = aggregateLogJob.execute();
        assertEquals("", result1);

        // Second call (even) should fail

   */
  fun cancel()

  fun interface Factory {
    /**
     * Creates a new event source and immediately returns it. Creating an event source initiates an
     * asynchronous process to connect the socket. Once that succeeds or fails, `listener` will be
     * notified. The caller must cancel the returned event source when it is no longer in use.
     */
    fun newEventSource(
      request: Request,
      listener: EventSourceListener,

    }

    @Test
    public void testReconnectHandleSuccess() throws Exception {
        when(mockManager.getHandleForReconnect("/test/file.txt")).thenReturn(testHandle);

        // Create a test reconnector that succeeds
        TestHandleReconnector testReconnector = new TestHandleReconnector(mockManager, true);

        CompletableFuture<HandleInfo> future = testReconnector.reconnectHandle("/test/file.txt", new IOException("Network error"));

            TestCredentials creds = new TestCredentials("X", false, false, null, false);
            assertNull(creds.getSubject());
        }
    }

    @Test
    @DisplayName("refresh succeeds when not configured to fail")
    void refresh_success() throws Exception {
        TestCredentials creds = new TestCredentials("Z", false, false, new Subject(), false);
        // Should not throw

    }

    @Test
    @DisplayName("Iterator with filter throwing exception")
    void iteratorWithFilterException() throws Exception {
        // Setup: first attempt throws, second succeeds
        FileEntry entry1 = mock(FileEntry.class);
        FileEntry entry2 = mock(FileEntry.class);

        when(delegate.hasNext()).thenReturn(true, true, false);

        verify(handle, times(1)).release();
        verifyNoMoreInteractions(handle);
    }

    @Test
    @DisplayName("ensureDFSResolved(): no exception when underlying call succeeds")
    void ensureDFSResolved_success() throws Exception {
        // Arrange: default mock does nothing

        // Act: call method under test
        handle.ensureDFSResolved();

        // Mock transports
        SmbTransportImpl trans1 = mock(SmbTransportImpl.class);
        SmbTransportImpl trans2 = mock(SmbTransportImpl.class);

        // trans2 fails first (lower fail count, tried first), trans1 succeeds
        when(trans2.unwrap(SmbTransportImpl.class)).thenReturn(trans2);
        when(trans2.ensureConnected()).thenThrow(new IOException("Connection failed"));
        doNothing().when(trans2).close();

                            response.writeBytesWireFormat(buffer, 0);
                        }
                        success[index] = true;
                    } catch (Exception e) {
                        success[index] = false;
                    }
                });
            }

            // When
            for (Thread thread : threads) {