return h;
    }

    /**
     * Concatenates multiple byte arrays into a single array.
     */
    private static byte[] concat(byte[]... arrays) {
        int total = 0;
        for (byte[] a : arrays) {
            total += a.length;
        }
        byte[] res = new byte[total];
        int off = 0;
        for (byte[] a : arrays) {
            System.arraycopy(a, 0, res, off, a.length);

/**
 * Interface for objects that can be encoded to byte arrays.
 * Provides standardized method for converting objects to their binary representation.
 *
 * @author mbechler
 */
public class ByteEncodable implements Encodable {

    private final byte[] bytes;
    private final int off;
    private final int len;

    /**
     * Constructs a ByteEncodable object wrapping a byte array segment.
     *

            final String msg = "Failed to index from document: searchWord=" + searchWord//
                    + ", fields=" + Arrays.toString(fields)//
                    + ", tags=" + Arrays.toString(tags)//
                    + ", roles=" + Arrays.toString(roles)//
                    + ", langs=" + Arrays.toString(langs)//
                    + ", num=" + num;
            if (logger.isDebugEnabled()) {

    }

    /**
     * Gets the array of supported authentication mechanisms
     * @return the mechanisms array
     */
    public ASN1ObjectIdentifier[] getMechanisms() {
        return this.mechanisms;
    }

    /**
     * Sets the array of supported authentication mechanisms
     * @param mechanisms the mechanisms to set
     */

        @Test
        @DisplayName("Should handle maximum size arrays")
        void testMaximumSizeArrays() throws SMBProtocolDecodingException {
            // Arrange
            int[] largeHashAlgos = new int[100];
            Arrays.fill(largeHashAlgos, PreauthIntegrityNegotiateContext.HASH_ALGO_SHA512);
            byte[] largeSalt = new byte[1024];
            Arrays.fill(largeSalt, (byte) 0xAB);

     */
    @SafeVarargs
    public static <T> StreamOf<T> stream(final T... values) {
        return new StreamOf<>(() -> values != null ? Arrays.stream(values) : Collections.<T> emptyList().stream());
    }

    /**
     * Splits the given string into an array of substrings based on the specified regular expression
     * and returns a stream of those substrings.
     *

            byte[] buffer1 = new byte[100];
            byte[] buffer2 = new byte[200];

            Arrays.fill(buffer1, (byte) 0x11);
            Arrays.fill(buffer2, (byte) 0x22);

            // First decode
            response.decode(buffer1, 0, 50);
            byte[] data1 = response.getData();

  }

  /**
   * @return an array of the proper size with {@code null} as the key of the middle element.
   */
  protected Entry<K, V>[] createArrayWithNullKey() {
    Entry<K, V>[] array = createSamplesArray();
    int nullKeyLocation = getNullLocation();
    Entry<K, V> oldEntry = array[nullKeyLocation];
    array[nullKeyLocation] = mapEntry(null, oldEntry.getValue());
    return array;
  }

  /**

  private InetAddresses() {}

  /**
   * Returns an {@link Inet4Address}, given a byte array representation of the IPv4 address.
   *
   * @param bytes byte array representing an IPv4 address (should be of length 4)
   * @return {@link Inet4Address} corresponding to the supplied byte array
   * @throws IllegalArgumentException if a valid {@link Inet4Address} can not be created
   */

        // Initially not deleted
        assertFalse(item.isDeleted());

        // Set newInputs to empty array and newOutput
        item.setNewInputs(new String[] {});
        item.setNewOutput("output");
        assertTrue(item.isDeleted());

        // Set newInputs to non-empty array - not deleted
        item.setNewInputs(new String[] { "something" });
        assertFalse(item.isDeleted());
    }