private long endOfFile;
    private int fileAttributes;

    /**
     * Constructs a close response
     *
     * @param config
     *            The configuration to use
     * @param fileId
     *            The file ID that was closed
     * @param fileName
     *            The name of the file that was closed
     */
    public Smb2CloseResponse(final Configuration config, final byte[] fileId, final String fileName) {

        // Close should have sent FindClose2 exactly once
        ArgumentCaptor<SmbComFindClose2> captor = ArgumentCaptor.forClass(SmbComFindClose2.class);
        verify(tree, times(1)).send(captor.capture(), any());
        assertNotNull(captor.getValue());

        // Tree handle is released after close
        verify(tree, atLeastOnce()).release();
    }

    @Test

      return multiset().subMultiset(fromElement, CLOSED, toElement, OPEN).elementSet();
    }

    @Override
    public SortedSet<E> headSet(@ParametricNullness E toElement) {
      return multiset().headMultiset(toElement, OPEN).elementSet();
    }

    @Override
    public SortedSet<E> tailSet(@ParametricNullness E fromElement) {
      return multiset().tailMultiset(fromElement, CLOSED).elementSet();
    }

    @Override

        }
    }

    /**
     * Check if this context is closed
     *
     * @return true if closed, false otherwise
     */
    public boolean isClosed() {
        return closed;
    }

        // Close and verify subsequent calls throw
        handle.close();
        CIFSException ex1 = assertThrows(CIFSException.class, handle::getInput, "getInput after close must throw");
        assertTrue(ex1.getMessage().contains("Already closed"));
        CIFSException ex2 = assertThrows(CIFSException.class, handle::getOutput, "getOutput after close must throw");

    }

    @Override
    BoundType typeAsLowerBound() {
      return BoundType.CLOSED;
    }

    @Override
    BoundType typeAsUpperBound() {
      return BoundType.OPEN;
    }

    @Override
    Cut<C> withLowerBoundType(BoundType boundType, DiscreteDomain<C> domain) {
      switch (boundType) {
        case CLOSED:
          return this;
        case OPEN:

    type: String?,
    data: String,
  ) {
  }

  /**
   * Invoked when the HTTP connection has been closed normally.
   *
   * No further calls to this listener will be made.
   */
  open fun onClosed(eventSource: EventSource) {
  }

  /**
   * Invoked when an event source has been closed due to an error reading from or writing to the

  }

  public void testCopyToAppendable_doesNotCloseIfWriter() throws IOException {
    TestWriter writer = new TestWriter();
    assertFalse(writer.closed());
    source.copyTo(writer);
    assertFalse(writer.closed());
  }

  public void testClosesOnErrors_copyingToCharSinkThatThrows() {
    for (TestOption option : EnumSet.of(OPEN_THROWS, WRITE_THROWS, CLOSE_THROWS)) {

          .build(),
      )

    val exception =
      assertFailsWith<IOException> {
        call2.execute()
      }
    assertThat(exception.message).isIn("Socket closed", "Socket is closed")
  }

  }

  public TestReader(TestInputStream in) {
    super(new InputStreamReader(checkNotNull(in), UTF_8));
    this.in = in;
  }

  public boolean closed() {
    return in.closed();
  }