assertEquals(0, cmd.readDataWireFormat(buf, 0, buf.length));
    }

    @ParameterizedTest
    @CsvSource({ "0, 0", // all zeros
            "-1, 2147483647", // negative fid, max positive security
            "12345, 999" // arbitrary numbers
    })
    void toString_includesCorrectHexValues(int fid, int securityInformation) {

import java.math.BigInteger;
import java.util.Arrays;
import java.util.Comparator;

/**
 * Static utility methods pertaining to {@code long} primitives that interpret values as
 * <i>unsigned</i> (that is, any negative value {@code x} is treated as the positive value {@code
 * 2^64 + x}). The methods for which signedness is not an issue are in {@link Longs}, as well as
 * signed versions of methods for which signedness is an issue.
 *

Commercial Contributor in connection with its distribution of the Program
in a commercial product offering. The obligations in this section do not
apply to any claims or Losses relating to any actual or alleged
intellectual property infringement. In order to qualify, an Indemnified
Contributor must: a) promptly notify the Commercial Contributor in

import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.lucene.search.TotalHits.Relation;
import org.codelibs.core.collection.ArrayUtil;
import org.codelibs.core.concurrent.CommonPoolUtil;
import org.codelibs.core.lang.StringUtil;
import org.codelibs.core.stream.StreamUtil;
import org.codelibs.fess.Constants;

        assertThrows(NullPointerException.class, () -> sis.read((byte[]) null));
    }

    @ParameterizedTest
    @ValueSource(longs = { 0L, -1L, -10L })
    @DisplayName("Skip returns 0 for zero or negative values")
    void skipReturnsZeroForNegativeOrZero(long skipBytes) throws IOException {
        // Create message with 5 bytes of data
        byte[] data = new byte[] { 10, 20, 30, 40, 50 };

Pull requests
-------------

Unless the change is a trivial fix such as for a typo, it's generally best to
start by opening a new issue describing the bug or feature you're intending to
fix. Even if you think it's relatively minor, it's helpful to know what people
are working on. And as mentioned above, API changes should be discussed
thoroughly before moving to code.

Some examples of types of pull requests that are immediately helpful:

   * @param expectedValuesPerKey the expected average number of values per key
   * @throws IllegalArgumentException if {@code expectedKeys} or {@code expectedValuesPerKey} is
   *     negative
   */
  public static <K extends @Nullable Object, V extends @Nullable Object>
      ArrayListMultimap<K, V> create(int expectedKeys, int expectedValuesPerKey) {

    /**
     * Identifier used to encode this strategy, when marshalled as part of a BloomFilter. Only
     * values in the [-128, 127] range are valid for the compact serial form. Non-negative values
     * are reserved for enums defined in BloomFilterStrategies; negative values are reserved for any
     * custom, stateful strategy we may define (e.g. any kind of strategy that would depend on user
     * input).
     */
    int ordinal();
  }

   * The index in the {@link #parts()} list at which the public suffix begins. For example, for the
   * domain name {@code myblog.blogspot.co.uk}, the value would be 1 (the index of the {@code
   * blogspot} part). The value is negative (specifically, {@link #NO_SUFFIX_FOUND}) if no public
   * suffix was found.
   */
  private int publicSuffixIndex() {
    int publicSuffixIndexLocal = publicSuffixIndexCache;

        // Test boundary values
        byte[] data = { (byte) 0x00, // min value
                (byte) 0xFF, // max value (-1 as signed byte)
                (byte) 0x7F, // max positive
                (byte) 0x80 // min negative
        };

        String result = Hexdump.toHexString(data);
        assertEquals("00FF7F80", result);
    }

    @Test
    @DisplayName("Should handle large byte arrays efficiently")