}

    /**
     * Simplifies the array.
     *
     * @param values The array.
     * @return The simplified array.
     */
    protected static String[] simplifyArray(final String[] values) {
        return stream(values).get(stream -> stream.filter(StringUtil::isNotBlank).distinct().toArray(n -> new String[n]));
    }

    /**
     * Returns the parameter value array.
     *
     * @param request The request.

  public void testCreateWithNull_supported() {
    E[] array = createArrayWithNullElement();
    collection = getSubjectGenerator().create(array);
    expectContents(array);
  }

  @CollectionFeature.Require(absent = ALLOWS_NULL_VALUES)
  @CollectionSize.Require(absent = ZERO)
  public void testCreateWithNull_unsupported() {
    E[] array = createArrayWithNullElement();

    assertThrows(

        AvPair avPair = new AvPair(type, raw);

        // Modify the original raw array
        raw[0] = 0x05;

        // Ensure the AvPair's internal raw array is not affected (defensive copy not made)
        // This test assumes that the AvPair constructor does NOT make a defensive copy of the raw array.
        // If a defensive copy were made, this test would fail, and the behavior would be more robust.

    return new Unhashables();
  }

  @Override
  public T create(Object... elements) {
    UnhashableObject[] array = createArray(elements.length);
    int i = 0;
    for (Object e : elements) {
      array[i++] = (UnhashableObject) e;
    }
    return create(array);
  }

  /**
   * Creates a new collection containing the given elements; implement this method instead of {@link
   * #create(Object...)}.

 *
 * @author mbechler
 */
public interface Encodable {

    /**
     * Encodes this object into the specified byte array.
     *
     * @param dst the destination byte array to encode into
     * @param dstIndex the starting index in the destination array
     * @return encoded length
     */
    int encode(byte[] dst, int dstIndex);

    /**

    }

    /**
     * Sets the array of web protocols to recognize for URL classification.
     *
     * @param webProtocols array of protocol prefixes (e.g., "http:", "https:")
     */
    public void setWebProtocols(final String[] webProtocols) {
        this.webProtocols = webProtocols;
    }

    /**
     * Sets the array of file protocols to recognize for URL classification.
     *

    }

    /**
     * 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
     */

      throws BucketOverflowException {
    /*
     * The cast is safe: n==entryArray.length means that we have filled the whole array with Entry
     * instances, in which case it is safe to cast it from an array of nullable entries to an array
     * of non-null entries.
     */
    @SuppressWarnings("nullness")
    Entry<K, V>[] entries =

        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() {

        }
    }

    /**
     * Array structure for DFS enumeration containing level 1 information
     */
    public static class DfsEnumArray1 extends NdrObject {

        /**
         * Default constructor for DfsEnumArray1
         */
        public DfsEnumArray1() {
            // Default constructor
        }

        /**
         * Number of DFS entries in the array
         */
        public int count;