}

    @Test
    @DisplayName("Test handling of maximum values")
    void testMaximumValues() throws Exception {
        byte[] buffer = new byte[100];
        int bufferIndex = 0;

        // Reserved bytes
        buffer[bufferIndex] = 0x00;
        buffer[bufferIndex + 1] = 0x00;
        buffer[bufferIndex + 2] = 0x00;

        // Set all fields to maximum 32-bit values

    public void setCommandOutputEncoding(final String commandOutputEncoding) {
        this.commandOutputEncoding = commandOutputEncoding;
    }

    /**
     * Sets the maximum number of output lines to process.
     * @param maxOutputLine The maximum output lines to set.
     */
    public void setMaxOutputLine(final int maxOutputLine) {
        this.maxOutputLine = maxOutputLine;
    }

    /**

     *
     * @return minimum size in bytes for compression to be beneficial
     */
    int getMinCompressionSize();

    /**
     * Gets the maximum data size that can be compressed in a single operation.
     *
     * @return maximum size in bytes that can be compressed
     */
    int getMaxCompressionSize();

    /**
     * Gets a human-readable name for the compression algorithm.
     *

        } catch (final SQLException ex) {
            throw new SQLRuntimeException(ex);
        }
    }

    /**
     * Sets the maximum number of rows.
     *
     * @param statement
     *            {@link Statement}. Must not be {@literal null}.
     * @param maxRows
     *            Maximum number of rows.
     * @see Statement#setMaxRows(int)
     */

// and the maximum size of buffer that may be allocated during scanning.
// The contents of the buffer are ignored.
//
// The maximum token size must be less than the larger of max and cap(buf).
// If max <= cap(buf), [Scanner.Scan] will use this buffer only and do no allocation.
//
// By default, [Scanner.Scan] uses an internal buffer and sets the
// maximum token size to [MaxScanTokenSize].
//

     * This is a required field that identifies the specific crawling session.
     * Maximum length is 20 characters.
     */
    @Required
    @Size(max = 20)
    public String sessionId;

    /**
     * The name or description of the crawling session.
     * This is an optional descriptive field with a maximum length of 20 characters.
     */
    @Size(max = 20)
    public String name;

    /**

        // Utility class - not instantiable
    }

    private static final int MAX_BUFFERS = Config.getInt("jcifs.smb1.smb.maxBuffers", 16);
    private static final int MAX_BUFFER_SIZE = 0x100000; // 1MB maximum

    // Use concurrent queue for lock-free operations
    private static final java.util.concurrent.ConcurrentLinkedQueue<byte[]> bufferQueue =
            new java.util.concurrent.ConcurrentLinkedQueue<>();

    @CustomSize(maxKey = "form.admin.max.input.size")
    public String configParameter;

    /**
     * The maximum crawling depth from the starting URLs.
     */
    @Min(value = 0)
    @Max(value = 2147483647)
    @ValidateTypeFailure
    public Integer depth;

    /**
     * The maximum number of URLs to access during crawling.
     */
    @Min(value = 0)
    @Max(value = 9223372036854775807L)

   */
  void awaitRunning();

  /**
   * Waits for the {@link Service} to reach the {@linkplain State#RUNNING running state} for no more
   * than the given time.
   *
   * @param timeout the maximum time to wait
   * @throws TimeoutException if the service has not reached the given state within the deadline
   * @throws IllegalStateException if the service reaches a state from which it is not possible to

    /**
     * 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
     */
    public static int findUNITermination(final byte[] buffer, final int bufferIndex, final int maxLen) {
        int len = 0;