fail<Any>()
    } catch (ioe: IOException) {
      assertThat(ioe).hasMessage("google.com")
      assertThat(ioe.cause!!).isInstanceOf<EOFException>()
    }
  }

  // TODO GET preferred order - with tests to confirm this
  // 1. successful fresh cached GET response
  // 2. unsuccessful (404, 500) fresh cached GET response
  // 3. successful network response
  // 4. successful stale cached GET response

import jcifs.internal.smb2.rdma.RdmaNegotiateResponse;

/**
 * DiSNI RDMA connection implementation.
 *
 * This class would integrate with the DiSNI library to provide
 * high-performance RDMA operations over InfiniBand/RoCE networks.
 *
 * Note: This is a skeleton implementation. A real implementation would
 * require proper DiSNI integration with actual RDMA hardware.
 */
public class DisniRdmaConnection extends RdmaConnection {

 *
 * <p>These options represent the various flags and settings available through the Maven CLI,
 * as well as those that can be specified in the {@code maven.config} file. They provide fine-grained
 * control over Maven's behavior during the build process.</p>
 *
 * @since 4.0.0
 */
@Experimental
public interface MavenOptions extends Options {

    /**
     * Returns the path to an alternate POM file.
     *

    suite.addTestSuite(HashMultimapTest.class);
    return suite;
  }

  /*
   * The behavior of toString() is tested by TreeMultimap, which shares a
   * lot of code with HashMultimap and has deterministic iteration order.
   */
  public void testCreate() {
    HashMultimap<String, Integer> multimap = HashMultimap.create();
    multimap.put("foo", 1);
    multimap.put("bar", 2);
    multimap.put("foo", 3);

 * Tests for AbstractByteHasher.
 *
 * @author Colin Decker
 */
@NullUnmarked
public class AbstractByteHasherTest extends TestCase {

  public void testBytes() {
    TestHasher hasher = new TestHasher(); // byte order insignificant here
    byte[] expected = {1, 2, 3, 4, 5, 6, 7, 8};
    hasher.putByte((byte) 1);
    hasher.putBytes(new byte[] {2, 3, 4, 5, 6});
    hasher.putByte((byte) 7);
    hasher.putBytes(new byte[] {});

    return (NavigableSet<E>) super.elementSet();
  }

  @LazyInit private transient @Nullable UnmodifiableSortedMultiset<E> descendingMultiset;

  // TODO(b/418181860): This method creates retain cycles in J2ObjC. In order to break the cycle,
  // there needs to be separate classes for primary and descending multiset, where the primary one
  // would hold {@code @LazyInit @RetainedWith @Nullable} reference to its descending multiset, and

    suite.addTestSuite(HashMultimapTest.class);
    return suite;
  }

  /*
   * The behavior of toString() is tested by TreeMultimap, which shares a
   * lot of code with HashMultimap and has deterministic iteration order.
   */
  public void testCreate() {
    HashMultimap<String, Integer> multimap = HashMultimap.create();
    multimap.put("foo", 1);
    multimap.put("bar", 2);
    multimap.put("foo", 3);

 * Implementations must quickly dispatch callbacks to avoid creating a bottleneck.
 *
 * While [onReset] may occur at any time, the following callbacks are expected in order,
 * correlated by stream ID.
 *
 *  * [onRequest]
 *  * [onHeaders] (unless canceled)
 *  * [onData] (optional sequence of data frames)
 *

    public String permissions;

    /** Virtual hosts where this configuration applies */
    @CustomSize(maxKey = "form.admin.max.input.size")
    public String virtualHosts;

    /** Sort order for displaying configurations */
    @Required
    @Min(value = 0)
    @Max(value = 2147483647)
    @ValidateTypeFailure
    public Integer sortOrder;

    /** User who created this configuration */

import com.google.common.annotations.J2ktIncompatible;
import java.io.Serializable;
import java.util.Iterator;
import org.jspecify.annotations.Nullable;

/** An ordering that uses the reverse of a given order. */
@GwtCompatible
final class ReverseOrdering<T extends @Nullable Object> extends Ordering<T>
    implements Serializable {
  final Ordering<? super T> forwardOrder;

  ReverseOrdering(Ordering<? super T> forwardOrder) {