client.close();
    }

    @Test
    void testGetWitnessServer() throws Exception {
        WitnessRpcClient mockRpc = mock(WitnessRpcClient.class);
        TestWitnessClient client = new TestWitnessClient(witnessServer, mockContext, mockRpc);

        assertEquals(witnessServer, client.getWitnessServer());

        client.close();
    }

    /**

                SmbConstants.O_CREAT | SmbConstants.O_WRONLY | SmbConstants.O_TRUNC, SmbConstants.FILE_WRITE_DATA,
                SmbConstants.DEFAULT_SHARING);

        // Close the stream
        outputStream.close();

        // When & Then - after close, tmp is null so write(int) will throw NullPointerException
        // This is the actual behavior of the implementation

        CloseableUtil.close(out);
    }

    private static class NotifyOutputStream extends OutputStream {
        private String notify_;

        @Override
        public void write(final int arg0) throws IOException {
        }

        @Override
        public void close() throws IOException {
            super.close();
            notify_ = "closed";
        }

    webSocket.close(1000, null);
    System.out.println("onClose (" + code + "): " + reason);
  }

  @Override public void onFailure(WebSocket webSocket, Throwable t, Response response) {
    // TODO(jwilson): can I read the response body? Do I have to?
    System.out.println("onFailure " + response);
  }

  @Override public void close() throws IOException {
    if (webSocket == null) return;

import jcifs.internal.Request;
import jcifs.internal.smb1.SMB1SigningDigest;
import jcifs.internal.smb1.ServerMessageBlock;
import jcifs.internal.util.SMBUtil;

/**
 * SMB1 Close file request message.
 *
 * This command is used to close a file that was previously opened
 * with an Open command.
 */
public class SmbComClose extends ServerMessageBlock implements Request<SmbComBlankResponse> {

        return false;
    }

    /**
     * {@inheritDoc}
     *
     *
     * @see jcifs.CIFSContext#close()
     */
    @Override
    public boolean close() throws CIFSException {
        if (!this.closed) {
            Runtime.getRuntime().removeShutdownHook(this);
        }
        return false;
    }

    /**

 * part is particularly large or if the underlying source is particularly slow, the [nextPart] call
 * may be slow!
 *
 * Closing a part **does not** close this multipart reader; callers must explicitly close this with
 * [close].
 *
 * [rfc_2046]: http://www.ietf.org/rfc/rfc2046.txt
 */
class MultipartReader
  @Throws(IOException::class)
  constructor(
    private val source: BufferedSource,

name: "Close invalid questions issues"
on:
  schedule:
  - cron: "*/10 * * * *"

permissions:
  contents: read

jobs:
  stale:
    permissions:
      issues: write  # for actions/stale to close stale issues
      pull-requests: write  # for actions/stale to close stale PRs
    runs-on: ubuntu-latest
    env:
      ACTIONS_STEP_DEBUG: true
    steps:
    - name: Close Stale Issues
      uses: actions/stale@v8
      with:

name: "Close Missing Playground issues"
on:
  schedule:
  - cron: "*/10 * * * *"

permissions:
  contents: read

jobs:
  stale:
    permissions:
      issues: write  # for actions/stale to close stale issues
      pull-requests: write  # for actions/stale to close stale PRs
    runs-on: ubuntu-latest
    env:
      ACTIONS_STEP_DEBUG: true
    steps:
    - name: Close Stale Issues
      uses: actions/stale@v8
      with:

        doThrow(new IOException("Close network error")).when(mockDcerpcHandle).sendrecv(any(MsrpcLsarClose.class));

        // Act & Assert
        IOException thrown = assertThrows(IOException.class, () -> {
            handle.close();
        });

        assertEquals("Close network error", thrown.getMessage());