@Tag("Slowish")
class EventSourcesHttpTest {
  @RegisterExtension
  val platform = PlatformRule()

  @StartStop
  private val server = MockWebServer()

  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()

  private val listener = EventSourceRecorder()
  private val client = clientTestRule.newClient()

  @AfterEach
  fun after() {
    listener.assertExhausted()
  }

  @Test

 * to become available when attempting to connect to a busy pipe.
 *
 * @author mbechler
 */
public class FsctlPipeWaitRequest implements Encodable {

    private final byte[] nameBytes;
    private final long timeout;
    private final boolean timeoutSpecified;

    /**
     * Constructs a pipe wait request without timeout.
     *
     * @param name the pipe name to wait for
     */

 *
 * As per MS-SMB2 2.2.13.1.1 and 2.2.21.1.1
 */
public class Smb2RdmaTransform {

    // SMB_DIRECT_BUFFER_DESCRIPTOR_V1 structure
    private long offset; // 8 bytes: Offset within registered buffer
    private int token; // 4 bytes: RDMA provider token
    private int length; // 4 bytes: Length of buffer

    /**
     * Create SMB2 RDMA Transform
     *
     * @param offset offset within registered buffer

      return description;
    }
  }

  private Target empty;
  private Target disjoint;
  private Target superset;
  private Target nonEmptyProperSubset;
  private Target sameElements;
  private Target partialOverlap;
  private Target containsDuplicates;
  private Target nullSingleton;

  @Override
  public void setUp() throws Exception {
    super.setUp();

    private static final String RELOCATING_SHARDS = "relocating_shards";
    private static final String INITIALIZING_SHARDS = "initializing_shards";
    private static final String UNASSIGNED_SHARDS = "unassigned_shards";

    private final int status;

    private final String clusterName;

    private final String clusterStatus;

    private String message = StringUtil.EMPTY;

    /**

        private Session session;
        private RequestTrace trace;
        private String groupId;
        private String artifactId;
        private String version;
        private String classifier;
        private String extension;
        private String type;
        private String coordinateString;
        private String scope;
        private boolean optional;

          }
        } finally {
          dispatching.remove();
          queue.remove();
        }
      }
    }

    private static final class Event {
      private final Object event;
      private final Iterator<Subscriber> subscribers;

      private Event(Object event, Iterator<Subscriber> subscribers) {
        this.event = event;
        this.subscribers = subscribers;
      }
    }
  }

    // Command code for lease break
    public static final int SMB2_OPLOCK_BREAK = 0x0012;
    
    private int structureSize;
    private int flags;
    private Smb2LeaseKey leaseKey;
    private int currentLeaseState;
    private int newLeaseState;
    private int breakReason;
    private int accessMaskHint;
    private int shareAccessHint;
    
    @Override
    protected int writePayload(byte[] dst, int dstIndex) {

    }
    assertFalse(errorNotThrown);
  }

  private static class ClassWhichDoesNotImplementEquals implements Serializable {
    private static final long serialVersionUID = 1L;
  }

  private static class ClassWhichIsAlwaysEqualButHasDifferentHashcodes implements Serializable {
    private static final long serialVersionUID = 2L;

    @SuppressWarnings("EqualsHashCode")
    @Override

        public void clearCache() {
            // Mock implementation
        }
    }

    private static class MockSuggester {
        private MockSuggestIndexer indexer = new MockSuggestIndexer();
        private MockSuggestSettings settings = new MockSuggestSettings();

        public MockSuggestIndexer indexer() {
            return indexer;
        }

        public MockSuggestSettings settings() {