* Writes a stopword item to the temporary file.
         * If the item is being updated, it writes the new version.
         *
         * @param oldItem The original item from the dictionary.
         * @return The written item, or null if the item was deleted.
         * @throws DictionaryException if the file was updated concurrently.
         */
        public StopwordsItem write(final StopwordsItem oldItem) {
            try {

   * fact the static type of {@link Throwable} is occasionally justified even for a method with no
   * {@code throws} clause: Some such methods can in fact throw a checked exception (e.g., by
   * calling code written in Kotlin).) Typically, we want to let a {@link Throwable} from such a
   * method propagate untouched, just as we'd typically let it do for a non-reflective call.

    /**
     * Reads up to len bytes of data from the input stream into an array of bytes.
     *
     * @param b the buffer into which the data is read
     * @param off the start offset in array b at which the data is written
     * @param len the maximum number of bytes to read
     * @return the total number of bytes read into the buffer, or -1 if there is no more data
     * @throws IOException if an I/O error occurs
     */
    @Override

        // Act
        transPeekNamedPipe = new TransPeekNamedPipe(mockConfig, TEST_PIPE_NAME, fid);

        // Assert
        assertNotNull(transPeekNamedPipe);
        // FID is written in writeSetupWireFormat, verify it there
    }

    @Test
    @DisplayName("writeSetupWireFormat should write correct bytes")
    void testWriteSetupWireFormat() {
        // Arrange

    tagClass: Int,
    tag: Long,
    block: (BufferedSink) -> Unit,
  ) {
    val constructedBit: Int
    val content = Buffer()

    stack.add(content)
    constructed = false // The enclosed object written in block() is not constructed.
    path += name
    try {
      block(content)
      constructedBit = if (constructed) 0b0010_0000 else 0
      constructed = true // The enclosing object is constructed.
    } finally {

            byte[] actualFileId = new byte[16];
            System.arraycopy(buffer, 88, actualFileId, 0, 16);
            assertArrayEquals(testFileId, actualFileId);

            // Verify total bytes written
            assertEquals(40, bytesWritten);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Test

entire whole, and thus to each and every part regardless of who wrote
it.

Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Library.

In addition, mere aggregation of another work not based on the Library

     * SMB server addressed by the URL parameter. See {@link jcifs.smb1.smb1.SmbFile}
     * for a detailed description and examples of the smb URL syntax. If the
     * second argument is <code>true</code>, then bytes will be written to the
     * end of the file rather than the beginning.
     *
     * @param url An smb URL string representing the file to write to
     * @param append Append to the end of file

            SMBUtil.writeInt2(0, readBuffer, 12); // Reserved bytes

            // When
            int written = response.writeBytesWireFormat(writeBuffer, 5);
            int read = response.readBytesWireFormat(readBuffer, 10);

            // Then
            assertEquals(0, written);
            assertEquals(4, read);
        }

        @Test

         * If the item is being updated, it writes the new version.
         *
         * @param oldItem The original item from the dictionary.
         * @return The written item, or null if the item was deleted.
         * @throws DictionaryException if the file was updated concurrently.
         */
        public StemmerOverrideItem write(final StemmerOverrideItem oldItem) {
            try {