* Execute a callable through the circuit breaker with fallback
     *
     * @param <T> return type
     * @param callable the callable to execute
     * @param fallback fallback supplier if circuit is open
     * @return the result or fallback value
     * @throws Exception if execution fails and no fallback provided
     */
    public <T> T call(Callable<T> callable, Callable<T> fallback) throws Exception {

import jcifs.internal.smb2.rdma.RdmaCapability;
import jcifs.internal.smb2.rdma.RdmaConnection;
import jcifs.internal.smb2.rdma.RdmaMemoryRegion;
import jcifs.internal.smb2.rdma.RdmaProvider;

/**
 * TCP fallback RDMA provider.
 *
 * This provider uses regular TCP connections but maintains the RDMA
 * interface for compatibility. It only supports send/receive operations
 * and does not provide true RDMA read/write capabilities.
 */

                    current_dependencies.extend(route.dependencies)
                current_callbacks = []
                if callbacks:
                    current_callbacks.extend(callbacks)
                if route.callbacks:
                    current_callbacks.extend(route.callbacks)
                current_generate_unique_id = get_value_or_default(
                    route.generate_unique_id_function,

- Added `kubectl node drain` helper callbacks `OnPodDeletionOrEvictionStarted`
  and `OnPodDeletionOrEvictionFailed`; people extending `kubectl` can use these
  new callbacks for more granularity. Deprecated the `OnPodDeletedOrEvicted`
  node drain helper callback. ([#117502](https://github.com/kubernetes/kubernetes/pull/117502), [@adilGhaffarDev](https://github.com/adilGhaffarDev))

  public void testOr_supplier_present() {
    assertEquals("a", Optional.of("a").or(Suppliers.ofInstance("fallback")));
  }

  public void testOr_supplier_absent() {
    assertEquals("fallback", Optional.absent().or(Suppliers.ofInstance("fallback")));
  }

  public void testOr_nullSupplier_absent() {

     * potential NTLM fallback (if the server does not support kerberos).
     *
     * @param subject
     *            represents the user who perform Kerberos authentication. Should at least contain a TGT for the user.
     * @param domain
     *            domain for NTLM fallback
     * @param username
     *            user for NTLM fallback
     * @param password

### [Fast Fallback](https://square.github.io/okhttp/4.x/okhttp/okhttp3/-ok-http-client/-builder/fast-fallback/)

Since version 5.0, `OkHttpClient` supports fast fallback, which is our implementation of Happy Eyeballs [RFC 6555](https://datatracker.ietf.org/doc/html/rfc6555).

    }

    @Test
    @DisplayName("Test fallback used when circuit is open")
    void testFallbackWhenOpen() throws Exception {
        // Open the circuit
        circuitBreaker.tripBreaker();

        String result = circuitBreaker.call(() -> "primary", () -> "fallback");

        assertEquals("fallback", result);
    }

    @Test

import java.util.EnumSet;
import java.util.Set;

/**
 * Interface for RDMA provider implementations.
 *
 * This interface abstracts different RDMA implementations such as
 * InfiniBand, iWARP, RoCE, or TCP fallback providers.
 */
public interface RdmaProvider {

    /**
     * Check if RDMA is available on this system
     *
     * @return true if RDMA can be used, false otherwise
     */
    boolean isAvailable();

 * and performant but introduces some testing difficulties. This test exercises the two fallback
 * strategies.
 *
 * <ul>
 *   <li>SafeAtomicHelper: uses Atomic FieldsUpdaters to implement synchronization
 *   <li>SynchronizedHelper: uses {@code synchronized} blocks for synchronization
 * </ul>
 *
 * To force selection of our fallback strategies we load {@link AggregateFutureState} (and all of