else -> when (ctMember) {
                is CtField -> ktFile.getSince(ctDeclaringClass, ctMember, fallback = declaringClassSince)
                is CtConstructor -> ktFile.getSince(ctDeclaringClass, ctMember, fallback = declaringClassSince)
                is CtMethod -> ktFile.getSince(ctDeclaringClass, ctMember, fallback = declaringClassSince)
                else -> error("Unsupported japicmp member type '${member::class}'")
            }

  @LazyInit @Nullable Class<X> exceptionType;
  @LazyInit @Nullable F fallback;

  AbstractCatchingFuture(
      ListenableFuture<? extends V> inputFuture, Class<X> exceptionType, F fallback) {
    this.inputFuture = checkNotNull(inputFuture);
    this.exceptionType = checkNotNull(exceptionType);
    this.fallback = checkNotNull(fallback);
  }

  @Override

        } else {
            boolean fallback = false;

            String[] tok = part1.split("\\.");
            int idx = 0;
            if (idx < tok.length) {
                majorVersion = getNextIntegerToken(tok[idx++]);
                if (majorVersion == null) {
                    fallback = true;
                }
            } else {
                fallback = true;
            }

    /**
     * Query string parameter for error page fallback.
     * Contains the original search query if redirection fails.
     */
    public String q;

    /**
     * Number of results parameter for error page fallback.
     * Specifies how many results to display if redirection fails.
     */
    public String num;

    /**
     * Sort parameter for error page fallback.
     * Defines the sorting order if redirection fails.

            // Result should be either Unicode or ASCII fallback depending on default charset
            String expectedUnicode = String.valueOf(icon.getUnicodeChar());
            String expectedAscii = icon.getAsciiFallback();
            assertTrue(
                    result.equals(expectedUnicode) || result.equals(expectedAscii),
                    "Result should be either Unicode or ASCII fallback for " + icon + ", got: " + result);
        }
    }

     *
     * @return the Unicode character
     */
    public char getUnicodeChar() {
        return unicodeChar;
    }

    /**
     * Returns the ASCII fallback text for this icon.
     *
     * @return the ASCII fallback text
     */
    public String getAsciiFallback() {
        return asciiFallback;
    }

        output.cancel(false);
        throw new SomeUncheckedException();
      }
    }
    Fallback fallback = new Fallback();
    SettableFuture<Object> input = SettableFuture.create();

    ListenableFuture<Object> output = catching(input, Throwable.class, fallback, directExecutor());
    fallback.output = output;

    input.setException(new MyException());
    assertTrue(output.isCancelled());
  }

        output.cancel(false);
        throw new SomeUncheckedException();
      }
    }
    Fallback fallback = new Fallback();
    SettableFuture<Object> input = SettableFuture.create();

    ListenableFuture<Object> output = catching(input, Throwable.class, fallback, directExecutor());
    fallback.output = output;

    input.setException(new MyException());
    assertTrue(output.isCancelled());
  }

        assertFalse(providers.isEmpty(), "Should have at least one available provider");
        assertTrue(providers.contains("TCP Fallback"), "Should include TCP fallback");
    }

        }

        // Runtime exceptions and other errors are likely not recoverable
        return false;
    }

    /**
     * Check if error suggests fallback to TCP is needed
     *
     * @param error the error to check
     * @return true if TCP fallback is recommended
     */
    public boolean shouldFallbackToTcp(Exception error) {
        // Hardware errors suggest RDMA is not working