public void reset() throws IOException {
        // In real implementation, this would reset the DiSNI connection
        connect();
    }

    @Override
    public int read(ByteBuffer buffer, long remoteAddress, int remoteKey, int length) throws IOException {
        if (state != RdmaConnectionState.ESTABLISHED) {
            throw new IOException("Connection not established");
        }

        try {

    private final Semaphore credits = new Semaphore(1, true);

    private final int desiredCredits = 512;

    private byte[] preauthIntegrityHash = new byte[64];
    private final Object preauthHashLock = new Object();

    SmbTransportImpl(final CIFSContext tc, final Address address, final int port, final InetAddress localAddr, final int localPort,
            final boolean forceSigning) {
        this.transportContext = tc;

        assertEquals(response.getTreeId(), response.getTid());
    }

    /**
     * Helper method to create a valid response buffer
     */
    private byte[] createValidResponseBuffer(int shareType, int shareFlags, int capabilities, int maxAccess) {
        byte[] buffer = new byte[256];
        SMBUtil.writeInt2(16, buffer, 0);
        buffer[2] = (byte) shareType;
        buffer[3] = 0;

        default:
            throw new CIFSException("Unknown compression algorithm: " + algorithm);
        }
    }

    @Override
    public int decompress(byte[] compressedData, int offset, int length, byte[] outputBuffer, int outputOffset, int algorithm)
            throws CIFSException {
        byte[] decompressed = decompress(compressedData, offset, length, algorithm);

                    void visitAnnotableParameterCount(int parameterCount, boolean visible) {
                        parametersOffset = argumentTypes.length - parameterCount
                    }

                    @Override
                    AnnotationVisitor visitParameterAnnotation(int parameter, String descriptor, boolean visible) {
                        int parameterIndex = parameter + parametersOffset

  override fun createSocket(
    host: String,
    port: Int,
  ): SSLSocket {
    val sslSocket = delegate.createSocket(host, port) as SSLSocket
    return configureSocket(sslSocket)
  }

  @Throws(IOException::class)
  override fun createSocket(
    host: String,
    port: Int,
    localAddress: InetAddress,
    localPort: Int,
  ): SSLSocket {

                                                  int num_dims);

// Get a Matrix TensorHandle with given float values and dimensions
TFE_TensorHandle* TestTensorHandleWithDimsFloat(TFE_Context* ctx, float data[],
                                                int64_t dims[], int num_dims);

// Get a Matrix TensorHandle with given int values and dimensions

    List<Element> queryList = Lists.newArrayListWithCapacity(numQueries);

    int numGoodQueries = (int) (numQueries * hitRate + 0.5);

    // add good queries
    int size = elementsInSet.size();
    if (size > 0) {
      int minCopiesOfEachGoodQuery = numGoodQueries / size;
      int extras = numGoodQueries % size;

      for (int i = 0; i < minCopiesOfEachGoodQuery; i++) {

        protected int writeDataWireFormat(byte[] dst, int dstIndex) {
            return dataWireFormatReturn;
        }

        @Override
        protected int readSetupWireFormat(byte[] buffer, int bufferIndex, int len) {
            return 0;
        }

        @Override
        protected int readParametersWireFormat(byte[] buffer, int bufferIndex, int len) throws SMBProtocolDecodingException {

   * @throws IllegalStateException if no port is defined. You can use {@link #withDefaultPort(int)}
   *     to prevent this from occurring.
   */
  public int getPort() {
    checkState(hasPort());
    return port;
  }

  /** Returns the current port number, with a default if no port is defined. */
  public int getPortOrDefault(int defaultPort) {
    return hasPort() ? port : defaultPort;
  }

  /**