}

    /**
     * Finds the null termination in a UTF-16LE encoded string buffer.
     *
     * @param buffer the byte buffer to search
     * @param bufferIndex the starting position in the buffer
     * @param maxLen the maximum length to search
     * @return position of terminating null bytes
     */

     * configuration and discovery in protocols like SAML.
     */
    METADATA,

    /**
     * Indicates a request to perform a logout operation, terminating the
     * user's SSO session.
     */
    LOGOUT;

        # After the requests is done, the items are still there
        assert items == {"foo": {"name": "Fighters"}, "bar": {"name": "Tenders"}}

    # The end of the "with TestClient" block simulates terminating the app, so
    # the lifespan ends and items are cleaned up

	// Avoid bugs in long file names
	// https://github.com/golang/tools/commit/5f9a5413737ba4b4f692214aebee582b47c8be74
	nameLen := bytes.IndexByte(nameBuf[:limit], 0)
	if nameLen < 0 {
		return 0, fmt.Errorf("failed to find terminating 0 byte in dirent")
	}
	return uint64(nameLen), nil

   *   <li>awaits executor service termination for half of the specified timeout.
   *   <li>if the timeout expires, it calls {@link ExecutorService#shutdownNow()}, cancelling
   *       pending tasks and interrupting running tasks.
   *   <li>awaits executor service termination for the other half of the specified timeout.
   * </ol>
   *

        smbComOpenAndX.useUnicode = true;
        // For Unicode: 1 byte (initial null in writeBytesWireFormat)
        // + potential 1 byte alignment (in writeString) + fileName.length() * 2 + 2 bytes (terminating nulls)
        // Since headerStart is 0 and dstIndex starts at 1 (after initial null), (1-0)%2=1, so alignment byte added
        // Total: 1 + 1 + 12*2 + 2 = 28 bytes

                });

                if (logger.isDebugEnabled()) {
                    logger.debug("Terminating process {}.", p);
                }
                try {
                    if (!p.destroyForcibly().waitFor(timeout, TimeUnit.MILLISECONDS)) {
                        logger.warn("Terminating process {} is timed out.", p);
                    } else if (logger.isDebugEnabled()) {

package bytes

import (
	"iter"
	"unicode"
	"unicode/utf8"
)

// Lines returns an iterator over the newline-terminated lines in the byte slice s.
// The lines yielded by the iterator include their terminating newlines.
// If s is empty, the iterator yields no lines at all.
// If s does not end in a newline, the final yielded line will not end in a newline.
// It returns a single-use iterator.
func Lines(s []byte) iter.Seq[[]byte] {

    inflater.inflate(buffer)
    assertThat(buffer.readUtf8()).isEqualTo("Hello inflation!")
  }

  /**
   * It's possible a self-terminating deflated message will contain trailing data that won't be
   * processed during inflation. If this happens, we need to either reject the message or discard
   * the unreachable data. We choose to discard it!
   *

    result.write(this, i)
    // Consume '\'.
    readByte()
    result.write(this, 1L) // The escaped character.
  }
}

/**
 * Consumes and returns a non-empty token, terminating at special characters in
 * [TOKEN_DELIMITERS]. Returns null if the buffer is empty or prefixed with a delimiter.
 */
private fun Buffer.readToken(): String? {
  var tokenSize = indexOfElement(TOKEN_DELIMITERS)