}

    @Test
    @DisplayName("Should handle empty byte array")
    void testToHexStringEmpty() {
        // Given
        byte[] data = {};

        // When
        String result = Hexdump.toHexString(data);

        // Then
        assertNotNull(result);
        assertEquals("", result);
    }

    @Test
    @DisplayName("Should handle null byte array")
    void testToHexStringNull() {
        // When/Then

        ingesters = newIngesters;
    }

    /**
     * Returns the array of registered ingesters sorted by priority.
     * The returned array contains all ingesters in priority order
     * (lower priority numbers first).
     *
     * @return the sorted array of ingesters
     */
    public Ingester[] getIngesters() {
        return ingesters;
    }

    }

    /**
     * Converts a byte array to a hexadecimal string representation.
     *
     * @param src the source byte array to convert
     * @param srcIndex the starting index in the source array
     * @param size the number of characters in the resulting hex string
     * @return a hexadecimal string representation of the byte array
     */

        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");
    }

    "fffe".decodeHex(),
    // UTF-32BE.
    "0000feff".decodeHex(),
  )

/**
 * Returns an array containing only elements found in this array and also in [other]. The returned
 * elements are in the same order as in this.
 */
internal fun Array<String>.intersect(
  other: Array<String>,
  comparator: Comparator<in String>,
): Array<String> {
  val result = mutableListOf<String>()
  for (a in this) {
    for (b in other) {

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

    /**
     * Sets the signing digest for this message.
     *
     * @param digest the signing digest to set

  @CollectionSize.Require(absent = {ZERO, ONE})
  public void testCreateWithDuplicates() {
    E[] array = createSamplesArray();
    array[1] = e0();
    collection = getSubjectGenerator().create(array);

    expectContents(array);
  }

        }
    }

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

  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(

  }

  // The underlying replacement array we can share between multiple escaper
  // instances.
  private final char[][] replacementArray;

  private ArrayBasedEscaperMap(char[][] replacementArray) {
    this.replacementArray = replacementArray;
  }

  // Returns the non-null array of replacements for fast lookup.
  char[][] getReplacementArray() {
    return replacementArray;