@Test
    public void inMemory() throws IOException {
        ContentOutputStream cos = new ContentOutputStream(10, Curl.tmpDir);
        cos.write(new byte[] { 0, 1, 2, 3, 4 });
        assertFalse(cos.done);
        assertTrue(cos.isInMemory());
        cos.close();
        assertFalse(cos.done);
    }

    @Test
    public void inFile() throws IOException {

class NodeStatusResponseTest {

    @Mock
    private Configuration mockConfig;

    @Mock
    private NbtAddress mockQueryAddress;

    private NodeStatusResponse response;

    @BeforeEach
    void setUp() throws Exception {
        // Setup mock configuration with lenient stubbing
        lenient().when(mockConfig.getOemEncoding()).thenReturn("UTF-8");

        // Setup mock query address

   * avoids the need for expensive resizing operations later, but setting this value unnecessarily
   * high wastes memory.
   *
   * @throws IllegalArgumentException if {@code initialCapacity} is negative
   * @throws IllegalStateException if an initial capacity was already set
   */
  @CanIgnoreReturnValue
  public MapMaker initialCapacity(int initialCapacity) {
    checkState(

   * successful TLS handshake, but before the connection is used.
   *
   * @throws SSLPeerUnverifiedException if `peerCertificates` don't match the certificates pinned
   *     for `hostname`.
   */
  @Throws(SSLPeerUnverifiedException::class)
  fun check(
    hostname: String,
    peerCertificates: List<Certificate>,
  ) = check(hostname) {

internal class FileOperator(
  private val fileChannel: FileChannel,
) {
  /** Write [byteCount] bytes from [source] to the file at [pos]. */
  @Throws(IOException::class)
  fun write(
    pos: Long,
    source: Buffer,
    byteCount: Long,
  ) {
    if (byteCount < 0L || byteCount > source.size) {
      throw IndexOutOfBoundsException()
    }
    var mutablePos = pos
    var mutableByteCount = byteCount

    private SmbFile mockFile2;

    private LeaseManager baseLeaseManager;
    private DirectoryLeaseManager directoryLeaseManager;
    private AutoCloseable mocks;

    @BeforeEach
    public void setUp() throws Exception {
        mocks = MockitoAnnotations.openMocks(this);

        when(context.getConfig()).thenReturn(config);
        when(config.isDirectoryNotificationsEnabled()).thenReturn(false);

    // something else.
    TimeZone.setDefault(TimeZone.getTimeZone("America/Los_Angeles"))
  }

  @AfterEach
  @Throws(Exception::class)
  fun tearDown() {
    TimeZone.setDefault(originalDefault)
  }

  @Test
  @Throws(Exception::class)
  fun parseStandardFormats() {
    // RFC 822, updated by RFC 1123 with GMT.

        return 0;
    }

    /**
     * {@inheritDoc}
     *
     * @throws SMBProtocolDecodingException if the response structure is invalid
     *
     * @see jcifs.internal.smb2.ServerMessageBlock2#readBytesWireFormat(byte[], int)
     */
    @Override
    protected int readBytesWireFormat(final byte[] buffer, final int bufferIndex) throws SMBProtocolDecodingException {

     * @return the number of bytes read
     * @throws SMBProtocolDecodingException if decoding fails
     */
    protected int readErrorResponse(final byte[] buffer, int bufferIndex) throws SMBProtocolDecodingException {
        final int start = bufferIndex;
        final int structureSize = SMBUtil.readInt2(buffer, bufferIndex);
        if (structureSize != 9) {

     * @return The IndexResponse from OpenSearch.
     * @throws OpenSearchAccessException if the insertion fails.
     * @throws CrawlingAccessException if there's a conflict during insertion.
     */
    protected IndexResponse insert(final Object target, final OpType opType) {
        final String url = getUrl(target);
        if (url == null) {
            throw new OpenSearchAccessException("url is null.");
        }