*
     * @param src the source data array
     * @param soff the offset in the source array
     * @param slen the length of data to process
     * @param dst the destination array for the result
     * @param doff the offset in the destination array
     */
    public void update(final byte[] src, int soff, final int slen, final byte[] dst, int doff) {

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

    /**
     * Constructs a ByteEncodable object wrapping a byte array segment.
     *
     * @param b the byte array to wrap
     * @param off the offset in the byte array
     * @param len the length of the segment to use
     */
    public ByteEncodable(final byte[] b, final int off, final int len) {
        this.bytes = b;

        assertArrayEquals(emptyHash, avChannelBindings.getRaw(), "Value should be an empty array when empty hash is provided");
    }

    /**
     * Test that the constructor stores the reference to the input byte array.
     * Note: The implementation does not create a defensive copy.
     */
    @Test
    void testConstructorStoresReference() {

    return new Ints();
  }

  @Override
  public Set<Integer> create(Object... elements) {
    Integer[] array = new Integer[elements.length];
    int i = 0;
    for (Object e : elements) {
      array[i++] = (Integer) e;
    }
    return create(array);
  }

  protected abstract Set<Integer> create(Integer[] elements);

  @Override
  public Integer[] createArray(int length) {

            yield Array.newInstance(rawClass, 0).getClass();
        }
        case null, default -> null;
        };
    }

    /**
     * Returns the array of type arguments for the specified type.
     * <p>
     * If <code>type</code> is an array type, the element type(s) of the array are analyzed recursively.
     * </p>
     * <p>

    }

    /**
     * Validates array is not null and has expected length
     *
     * @param array the array to validate
     * @param expectedLength the expected length
     * @param fieldName the field name for error reporting
     * @throws IllegalArgumentException if array is invalid
     */
    public static void validateArrayLength(byte[] array, int expectedLength, String fieldName) {

    resetContainer();
  }

  /**
   * @return an array of the proper size with {@code null} inserted into the middle element.
   */
  protected E[] createArrayWithNullElement() {
    E[] array = createSamplesArray();
    array[getNullLocation()] = null;
    return array;
  }

  protected void initCollectionWithNullElement() {
    E[] array = createArrayWithNullElement();

    resetContainer();
  }

  /**
   * @return an array of the proper size with {@code null} inserted into the middle element.
   */
  protected E[] createArrayWithNullElement() {
    E[] array = createSamplesArray();
    array[getNullLocation()] = null;
    return array;
  }

  protected void initCollectionWithNullElement() {
    E[] array = createArrayWithNullElement();

        assertEquals(0, blob.get().length, "Internal array should be empty");
        assertEquals(0, blob.length(), "length() should be 0 for empty");
        assertEquals("", blob.toString(), "toString() of empty should be empty string");
        assertTrue(blob.equals(blob), "Object should be equal to itself");
        assertEquals(blob.get().hashCode(), blob.hashCode(), "hashCode should delegate to internal array");
    }

     *
     * @param <T>
     *            The type of the Bean
     * @return The constructor
     */
    <T> Constructor<T> getConstructor();

    /**
     * Returns an array of the parameter types of the constructor.
     *
     * @return An array of the parameter types of the constructor
     */
    Class<?>[] getParameterTypes();

    /**
     * Returns {@literal true} if the constructor is {@literal public}.
     *