if (this.password != null) {
            // Multi-pass secure wipe of password char array
            Arrays.fill(this.password, '\0');
            Arrays.fill(this.password, '\uFFFF');
            Arrays.fill(this.password, '\uAAAA');
            Arrays.fill(this.password, '\u5555');
            Arrays.fill(this.password, '\0');
            this.password = null;
        }

      CompoundOrdering<?> that = (CompoundOrdering<?>) object;
      return Arrays.equals(this.comparators, that.comparators);
    }
    return false;
  }

  @Override
  public int hashCode() {
    return Arrays.hashCode(comparators);
  }

  @Override
  public String toString() {
    return "Ordering.compound(" + Arrays.toString(comparators) + ")";
  }

  void setUp() throws Exception {
    Random rng = new Random();
    for (int i = 0; i < 0x100; i++) {
      Integer[] array = new Integer[n];
      for (int j = 0; j < n; j++) {
        array[j] = rng.nextInt();
      }
      inputArrays[i] = array;
    }
  }

  @Benchmark
  int arraysSortNoComparator(int reps) {
    int tmp = 0;
    for (int i = 0; i < reps; i++) {
      Integer[] copy = inputArrays[i & 0xFF].clone();

    /**
     * Adds a query facet to the existing query array.
     * If no queries exist, creates a new array with the provided query.
     *
     * @param s the query string to add as a facet
     */
    public void addQuery(final String s) {
        if (query == null) {
            query = new String[] { s };
        } else {
            final String[] newQuery = Arrays.copyOf(query, query.length + 1);

    }

    /**
     * Returns the array of values associated with this request parameter.
     *
     * @return the parameter values array, may be null or empty
     */
    public String[] getValues() {
        return values;
    }

    /**
     * Returns a string representation of this RequestParameter.
     * The format includes the parameter name and its values in array format.
     *

    }

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

  private static final Iterable<Integer> iterable = Arrays.<Integer>asList();
  private static final Iterable<Integer> iterable1 = Arrays.asList(1);
  private static final Iterable<Integer> iterable12 = Arrays.asList(1, 2);
  private static final Iterable<Integer> iterable123 = Arrays.asList(1, 2, 3);
  private static final Iterable<@Nullable Integer> iterableNull = Arrays.asList((Integer) null);

            // Additional passes with different patterns for enhanced security
            Arrays.fill(array, (byte) 0xFF);
            Arrays.fill(array, (byte) 0xAA);
            Arrays.fill(array, (byte) 0x55);
            Arrays.fill(array, (byte) 0);
        }
    }

import java.security.MessageDigest;
import java.util.Arrays;
import java.util.Random;
import org.jspecify.annotations.NullUnmarked;

/**
 * Benchmarks for comparing the various {@link HashCode#equals} methods.
 *
 * <p>Parameters for the benchmark are:
 *
 * <ul>
 *   <li>size: the length of the byte array to hash
 *   <li>whereToDiffer: where in the array the bytes should differ

        String[] array = { "a", "b", "c" };
        doc.put("key", array);

        List<String> result = DocumentUtil.getValue(doc, "key", List.class);
        assertEquals(Arrays.asList("a", "b", "c"), result);
    }

    @Test
    public void test_first_element_from_list() {
        Map<String, Object> doc = new HashMap<>();
        List<String> list = Arrays.asList("first", "second", "third");