}

    @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

 */
package okhttp3.internal

import java.net.InetAddress
import okhttp3.Dns

/**
 * A network that always resolves two IP addresses per host. Use this when testing route selection
 * fallbacks to guarantee that a fallback address is available.
 */
class DoubleInetAddressDns : Dns {
  override fun lookup(hostname: String): List<InetAddress> {
    val addresses = Dns.SYSTEM.lookup(hostname)

 * 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

	ctx, cancel := context.WithCancel(ctx)
	defer cancel()

	// Keep track of fallback disks
	var fdMu sync.Mutex
	fds := opts.fallbackDisks
	fallback := func(err error) StorageAPI {
		if _, ok := err.(StorageErr); ok {
			// Attempt to grab a fallback disk
			fdMu.Lock()
			defer fdMu.Unlock()
			if len(fds) == 0 {
				return nil
			}
			fdsCopy := fds

 * selected in the static initializer of AbstractFuture. This is convenient and performant but
 * introduces some testing difficulties. This test exercises the fallback strategies.
 *
 * <p>To force selection of our fallback strategies, we load {@link AbstractFuture} (and all of
 * {@code com.google.common.util.concurrent}) in degenerate class loaders which make certain
 * platform classes unavailable. Then we construct a test suite so we can run the normal

        assertTrue(ex.getMessage().contains("Cannot use netbios/short names"));
    }

    @Test
    @DisplayName("createContext: no Kerberos in initial token and no fallback -> throws")
    void createContext_noKerberosNoFallback_throws() throws CIFSException {
        Kerb5Authenticator auth = new Kerb5Authenticator((Subject) null);

        private final String id;

        private final ArtifactRepositoryLayout fallback;

        UnknownRepositoryLayout(String id, ArtifactRepositoryLayout fallback) {
            this.id = id;
            this.fallback = fallback;
        }

        @Override
        public String getId() {
            return id;
        }

        @Override

   *     exception itself.
   * @param executor the executor that runs {@code fallback} if the input fails
   */
  public <X extends Throwable> ClosingFuture<V> catching(
      Class<X> exceptionType, ClosingFunction<? super X, ? extends V> fallback, Executor executor) {
    return catchingMoreGeneric(exceptionType, fallback, executor);
  }

## File Structure

Language resource files are located in:
```
src/main/resources/
├── fess_label.properties           # Base English labels (fallback)
├── fess_label_[locale].properties  # Language-specific labels (~1,056 lines)
├── fess_message.properties         # Base English messages (fallback)
└── fess_message_[locale].properties # Language-specific messages (~200 lines)
```

### Naming Convention

}
```

#### 4.5.2 Fallback TCP Provider
```java
package jcifs.internal.smb2.rdma.tcp;

public class TcpRdmaProvider implements RdmaProvider {
    @Override
    public boolean isAvailable() {
        return true;  // TCP is always available
    }
    
    @Override
    public Set<RdmaCapability> getSupportedCapabilities() {
        // TCP fallback only supports send/receive