(int) 0x5a4316b8L,
                (int) 0xff1a618bL,
                (int) 0L))
        .isEqualTo((int) 0L);
  }

  public void testLexicographicalComparator() {
    List<int[]> ordered =
        Arrays.asList(
            new int[] {},
            new int[] {LEAST},
            new int[] {LEAST, LEAST},
            new int[] {LEAST, (int) 1L},
            new int[] {(int) 1L},

    }

    /**
     * Represents a string in the version item list, usually a qualifier.
     */
    private static class StringItem implements Item {
        private static final List<String> QUALIFIERS =
                Arrays.asList("alpha", "beta", "milestone", "rc", "snapshot", "", "sp");
        private static final List<String> RELEASE_QUALIFIERS = Arrays.asList("ga", "final", "release");

                }
            }
            return query;
        }

        /**
         * Splits a field name into its components.
         *
         * @param defaultField the default field name
         * @param field the field name to split
         * @return a Pair containing the field name and extension key
         */

            }

            if (value instanceof List list) {
                return list.get(index);
            }
        } catch (NumberFormatException | IndexOutOfBoundsException e) {
            return null;
        }

        final String message = String.format(
                "The token '%s' at position '%d' refers to a java.util.List or an array, but the value "

            }
        }

        private List<Completer> mvnCompleter(String name) {
            List<String> names;
            try {
                List<String> phases = shellContext.lookup.lookup(LifecycleRegistry.class).stream()
                        .flatMap(Lifecycle::allPhases)
                        .map(Lifecycle.Phase::name)
                        .toList();
                // TODO: add goals dynamically

  @GwtIncompatible // NavigableSet
  @Override
  public UnmodifiableIterator<E> descendingIterator() {
    return elements.reverse().iterator();
  }

  @Override
  public Spliterator<E> spliterator() {
    return asList().spliterator();
  }

  @Override
  public void forEach(Consumer<? super E> action) {
    elements.forEach(action);
  }

  @Override
  public int size() {
    return elements.size();
  }

  public void testUniqueIndexNullValue() {
    List<@Nullable String> listWithNull = Lists.newArrayList((String) null);
    assertThrows(
        NullPointerException.class,
        () -> Maps.uniqueIndex((List<String>) listWithNull, Functions.constant(1)));
  }

  /** Null keys aren't allowed either. */
  public void testUniqueIndexNullKey() {
    List<String> oneStringList = Lists.newArrayList("foo");
    assertThrows(

        document.put("string_field", "value1");
        document.put("string_array_field", new String[] { "value2", "value3" });
        document.put("list_field", java.util.Arrays.asList("value4", "value5"));
        document.put("int_field", 123);

        String[] stringValues = defaultContentsParser.getFieldValues(document, "string_field");
        assertEquals(1, stringValues.length);

    }
  }

  private static final class PermutationIterator<E> extends AbstractIterator<List<E>> {
    final List<E> list;
    final int[] c;
    final int[] o;
    int j;

    PermutationIterator(List<E> list) {
      this.list = new ArrayList<>(list);
      int n = list.size();
      c = new int[n];
      o = new int[n];
      Arrays.fill(c, 0);
      Arrays.fill(o, 1);

        not(not -> not.setId_Term(id), opLambda);
    }

    public void setId_Terms(Collection<String> idList) {
        setId_Terms(idList, null);
    }

    public void setId_Terms(Collection<String> idList, ConditionOptionCall<IdsQueryBuilder> opLambda) {
        IdsQueryBuilder builder = regIdsQ(idList);
        if (opLambda != null) {
            opLambda.callback(builder);
        }
    }