// 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
        }
    }

    AtomicDouble at = new AtomicDouble(1.0);
    assertBitEquals(1.0, at.get());
    for (double x : VALUES) {
      at.lazySet(x);
      assertBitEquals(x, at.get());
    }
  }

  /** compareAndSet succeeds in changing value if equal to expected else fails */
  public void testCompareAndSet() {
    double prev = Math.E;
    double unused = Math.E + Math.PI;
    AtomicDouble at = new AtomicDouble(prev);

        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);

   */
  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,

 * Don't start a new attempt until 250 ms after the most recent attempt was started.
 * Keep whichever TCP connection succeeds first and cancel all the others.
 * Race TCP only. Only attempt a TLS handshake on the winning TCP connection.

    AtomicDouble at = new AtomicDouble(1.0);
    assertBitEquals(1.0, at.get());
    for (double x : VALUES) {
      at.lazySet(x);
      assertBitEquals(x, at.get());
    }
  }

  /** compareAndSet succeeds in changing value if equal to expected else fails */
  public void testCompareAndSet() {
    double prev = Math.E;
    double unused = Math.E + Math.PI;
    AtomicDouble at = new AtomicDouble(prev);

        testClient.deleteIndexResult = true;
        testClient.documentCount = 10;
        testClient.aliasCount = 2;
        // First createIndex (backup) succeeds, second (new) fails
        testClient.createIndexFailOnNth = 2;

        final boolean result = testClient.reindexConfigIndices(false, allTargetPrefixes());

        assertFalse(result);
        // Backup should be cleaned up

      } else {
        succ.predecessorInMultimap = pred;
      }
    }

    void delete(ValueEntry<K, V> entry) {
      succeeds(entry.predecessorInMultimap, entry.successorInMultimap);
    }

    void append(ValueEntry<K, V> newEntry) {
      succeeds(lastEntry, newEntry);
      lastEntry = newEntry;
    }
  }

  @GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 1;

    }

    @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"));

      } else {
        succ.predecessorInMultimap = pred;
      }
    }

    void delete(ValueEntry<K, V> entry) {
      succeeds(entry.predecessorInMultimap, entry.successorInMultimap);
    }

    void append(ValueEntry<K, V> newEntry) {
      succeeds(lastEntry, newEntry);
      lastEntry = newEntry;
    }
  }

  @GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 1;