private final OkHttpClient client = new OkHttpClient();

      public void run() throws Exception {
        RequestBody requestBody = new RequestBody() {
          @Override public MediaType contentType() {
            return MEDIA_TYPE_MARKDOWN;
          }

          @Override public void writeTo(BufferedSink sink) throws IOException {
            sink.writeUtf8("Numbers\n");
            sink.writeUtf8("-------\n");

     * @throws NdrException if encoding fails
     */
    public abstract void encode_in(NdrBuffer buf) throws NdrException;

    /**
     * Decode the output parameters from this DCERPC message.
     * @param buf the buffer to decode from
     * @throws NdrException if decoding fails
     */
    public abstract void decode_out(NdrBuffer buf) throws NdrException;

     */
    private SmbCopyUtil() {
    }

    /**
     * @param dest
     * @return
     * @throws SmbException
     * @throws SmbAuthException
     */
    static SmbFileHandleImpl openCopyTargetFile(final SmbFile dest, final int attrs, final boolean alsoRead) throws CIFSException {
        try {
            return dest.openUnshared(SmbConstants.O_CREAT | SmbConstants.O_WRONLY | SmbConstants.O_TRUNC,

    @Test
    @DisplayName("refresh succeeds when not configured to fail")
    void refresh_success() throws Exception {
        TestCredentials creds = new TestCredentials("Z", false, false, new Subject(), false);
        // Should not throw
        assertDoesNotThrow(creds::refresh);
    }

    @Test
    @DisplayName("refresh throws CIFSException when configured to fail")
    void refresh_failure_throws_cifs() {

  public void testSuccessful() throws Exception {
    TrustedListenableFutureTask<Integer> task = TrustedListenableFutureTask.create(returning(2));
    assertFalse(task.isDone());
    task.run();
    assertTrue(task.isDone());
    assertFalse(task.isCancelled());
    assertEquals(2, getDone(task).intValue());
  }

  public void testCancelled() throws Exception {

                throw new TransferCancelledException();
            }

            @Override
            public void transferProgressed(TransferEvent event) throws TransferCancelledException {
                throw new TransferCancelledException();
            }

            @Override
            public void transferCorrupted(TransferEvent event) throws TransferCancelledException {

  /**
   * Guaranteed to throw an exception and leave the underlying data unmodified.
   *
   * @throws UnsupportedOperationException always
   * @deprecated Unsupported operation.
   */
  @Deprecated
  @Override
  @DoNotCall("Always throws UnsupportedOperationException")
  public final void add(@ParametricNullness E e) {
    throw new UnsupportedOperationException();
  }

  /**

    }

    @Test
    void testConstructor() throws SmbException {
        assertNotNull(smbRandomAccessFile);
        assertEquals(0, smbRandomAccessFile.getFilePointer());
    }

    @Test
    void testGetFilePointer() throws SmbException {
        assertEquals(0, smbRandomAccessFile.getFilePointer());
    }

    @Test
    void testSeek() throws SmbException {
        long newPosition = 100L;

  protected CharEscaper() {}

  /**
   * Returns the escaped form of a given literal string.
   *
   * @param string the literal string to be escaped
   * @return the escaped form of {@code string}
   * @throws NullPointerException if {@code string} is null
   */
  @Override
  public String escape(String string) {
    checkNotNull(string); // GWT specific check (do not optimize)

    handler.priority(streamId, streamDependency, weight, exclusive)
  }

  @Throws(IOException::class)
  private fun readRstStream(
    handler: Handler,
    length: Int,
    flags: Int,
    streamId: Int,
  ) {
    if (length != 4) throw IOException("TYPE_RST_STREAM length: $length != 4")
    if (streamId == 0) throw IOException("TYPE_RST_STREAM streamId == 0")
    val errorCodeInt = source.readInt()