val trustManager =
      object : X509TrustManager {
        override fun checkClientTrusted(
          chain: Array<out X509Certificate>?,
          authType: String?,
        ) {}

        override fun checkServerTrusted(
          chain: Array<out X509Certificate>?,
          authType: String?,
        ) {}

        override fun getAcceptedIssuers(): Array<X509Certificate> = arrayOf()
      }

      new Callable<String>() {
        @Override
        public String call() throws InterruptedException {
          MILLISECONDS.sleep(DELAY_MS);
          return GOOD_CALLABLE_RESULT;
        }
      };
  private static final Callable<String> BAD_CALLABLE =
      new Callable<String>() {
        @Override
        public String call() throws InterruptedException, SampleException {

        path = pipe.unc;
    }

    @Override
    public void close() throws IOException {
        pipe.close();
    }

    @Override
    public void write(final int b) throws IOException {
        tmp[0] = (byte) b;
        write(tmp, 0, 1);
    }

    @Override
    public void write(final byte[] b) throws IOException {
        write(b, 0, b.length);
    }

     *
     * @see jcifs.internal.CommonServerMessageBlockRequest#size()
     */
    @Override
    public int size() {
        return size8(Smb2Constants.SMB2_HEADER_LENGTH + 4);
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb2.ServerMessageBlock2#writeBytesWireFormat(byte[], int)
     */
    @Override
    protected int writeBytesWireFormat(final byte[] dst, final int dstIndex) {

 */
@SuppressLint("NewApi")
@SuppressSignatureCheck
class Android10SocketAdapter : SocketAdapter {
  override fun matchesSocket(sslSocket: SSLSocket): Boolean = SSLSockets.isSupportedSocket(sslSocket)

  override fun isSupported(): Boolean = Companion.isSupported()

  @SuppressLint("NewApi")
  override fun getSelectedProtocol(sslSocket: SSLSocket): String? =
    try {

    }
  }

  @Override
  public int read(char[] cbuf, int off, int len) throws IOException {
    checkNotNull(cbuf);
    if (current == null) {
      return -1;
    }
    int result = current.read(cbuf, off, len);
    if (result == -1) {
      advance();
      return read(cbuf, off, len);
    }
    return result;
  }

  @Override
  public long skip(long n) throws IOException {

    super(false, false, true, true, true);
  }

  @Override
  protected SortedMap<String, String> makeEmptyMap() {
    TreeBasedTable<String, String, String> table = TreeBasedTable.create();
    table.put("a", "b", "c");
    table.put("c", "b", "a");
    table.put("a", "a", "d");
    return table.row("b");
  }

  @Override
  protected SortedMap<String, String> makePopulatedMap() {

            this.type = type;
            this.scope = scope;
        }

        @Override
        public String getName() {
            return name;
        }

        @Override
        public int getNameType() {
            return type;
        }

        @Override
        public String getScope() {
            return scope;
        }
    }

        URLStreamHandler httpHandler = new URLStreamHandler() {
            @Override
            protected URLConnection openConnection(URL u) throws IOException {
                return mock(HttpURLConnection.class);
            }
        };

        // Create mock HTTPS handler
        URLStreamHandler httpsHandler = new URLStreamHandler() {
            @Override
            protected URLConnection openConnection(URL u) throws IOException {

        this.flags = flags;
    }

    @Override
    protected Smb2LeaseBreakResponse createResponse(CIFSContext tc, ServerMessageBlock2Request<Smb2LeaseBreakResponse> req) {
        return new Smb2LeaseBreakResponse(tc.getConfig());
    }

    @Override
    public int size() {
        return size8(Smb2Constants.SMB2_HEADER_LENGTH + STRUCTURE_SIZE);
    }

    @Override