.addValue("z")
            .addValue("")
            .addValue(null)
            .add(SHORT_NAME, Arrays.asList("A"))
            .add(LONG_NAME, Arrays.asList("B"))
            .add(SHORT_NAME, Arrays.asList())
            .add(LONG_NAME, Arrays.asList())
            .addValue(Arrays.asList("C"))
            .addValue(Arrays.asList())
            .add(SHORT_NAME, Collections.singletonMap("k1", "v1"))

 */
package org.apache.maven.artifact.resolver.filter;

import java.util.Arrays;
import java.util.List;

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertTrue;

/**
 */
class FilterHashEqualsTest {

    @Test
    void testIncludesExcludesArtifactFilter() {
        List<String> patterns = Arrays.asList("c", "d", "e");

   *
   * @param arrays zero or more {@code int} arrays
   * @return a single array containing all the values from the source arrays, in order
   * @throws IllegalArgumentException if the total number of elements in {@code arrays} does not fit
   *     in an {@code int}
   */
  public static int[] concat(int[]... arrays) {
    long length = 0;
    for (int[] array : arrays) {
      length += array.length;
    }

    assertThat((long) arraysDim1 * arraysDim2).isNotEqualTo((long) (arraysDim1 * arraysDim2));

    long[][] arrays = new long[arraysDim1][];
    // it's shared to avoid using too much memory in tests
    long[] sharedArray = new long[arraysDim2];
    Arrays.fill(arrays, sharedArray);

    try {
      Longs.concat(arrays);
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }

  }

  /** Returns whether arrays need to be allocated. */
  boolean needsAllocArrays() {
    return table == null;
  }

  /** Handle lazy allocation of arrays. */
  @CanIgnoreReturnValue
  int allocArrays() {
    Preconditions.checkState(needsAllocArrays(), "Arrays already allocated");

    int expectedSize = metadata;

  }

  static void testSort(byte[] input, byte[] expected) {
    input = Arrays.copyOf(input, input.length);
    UnsignedBytes.sort(input);
    assertThat(input).isEqualTo(expected);
  }

  static void testSort(byte[] input, int from, int to, byte[] expected) {
    input = Arrays.copyOf(input, input.length);
    UnsignedBytes.sort(input, from, to);
    assertThat(input).isEqualTo(expected);

            if (name.equals("li")) {
                unwindTo(Arrays.asList("ul", "ol"), visitor);
            } else if (name.equals("dt") || name.endsWith("dd")) {
                unwindTo(Arrays.asList("dl"), visitor);
            } else if (name.equals("tr")) {
                unwindTo(Arrays.asList("table", "thead", "tbody"), visitor);
            } else if (name.equals("th") || name.endsWith("td")) {

        ImmutableListMultimap.<Character, Character>builder()
            .putAll('b', Arrays.asList('a', 'n', 'a', 'n', 'a'))
            .putAll('a', Arrays.asList('p', 'p', 'l', 'e'))
            .putAll('c', Arrays.asList('a', 'r', 'r', 'o', 't'))
            .putAll('a', Arrays.asList('s', 'p', 'a', 'r', 'a', 'g', 'u', 's'))
            .putAll('c', Arrays.asList('h', 'e', 'r', 'r', 'y'))
            .build();

    ByteSource source = out.asByteSource();

    out.write(data);
    assertTrue(Arrays.equals(data, source.read()));

    out.reset();
    assertTrue(Arrays.equals(new byte[0], source.read()));

    out.write(data);
    assertTrue(Arrays.equals(data, source.read()));

    out.close();
  }

  private static boolean isAndroid() {

 * the License.
 */

package com.google.common.util.concurrent;

import static com.google.common.base.Preconditions.checkArgument;
import static java.lang.Thread.currentThread;
import static java.util.Arrays.asList;

import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.Ordering;