labels.errorCountMax=Nombre d'erreurs maximum
labels.errorCountMin=Nombre d'erreurs minimum
labels.facet=Facette
labels.geo=Géo
labels.groups=Groupes
labels.hash=Hachage
labels.maxSize=Taille maximale
labels.order=Ordre
labels.purgeSuggestSearchLogDay=Supprimer les anciennes informations de suggestion
labels.q=Requête
labels.roles=Rôles
labels.suggestSearchLog=Journal de recherche de suggestions
labels.suggestWord=Suggérer un mot

     * {@link InvokerRequest#coreExtensions()} is in precedence order. Also reports conflicts, if any.
     * Finally, at DEBUG level reports configured vs selected extensions.
     */
    protected List<CoreExtension> selectCoreExtensions(C context, List<CoreExtensions> configuredCoreExtensions) {
        context.logger.debug("Configured core extensions (in precedence order):");
        for (CoreExtensions source : configuredCoreExtensions) {

///

## Multiple middleware execution order { #multiple-middleware-execution-order }

    ByteBuffer littleEndian = ByteBuffer.wrap(bytes).order(ByteOrder.LITTLE_ENDIAN);
    ByteBuffer bigEndian = ByteBuffer.wrap(bytes).order(ByteOrder.BIG_ENDIAN);
    assertEquals(hashFunction.hashBytes(littleEndian), hashFunction.hashBytes(bigEndian));
    assertEquals(ByteOrder.LITTLE_ENDIAN, littleEndian.order());
    assertEquals(ByteOrder.BIG_ENDIAN, bigEndian.order());
  }

import org.codehaus.plexus.classworlds.ClassWorld;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Order;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.CleanupMode;
import org.junit.jupiter.api.io.TempDir;

/**
 * Resident UT.
 */
@Order(100)
public class ResidentMavenInvokerTest extends MavenInvokerTestSupport {

    @Override

    }

    /**
     * Creates a sort builder for the specified field and order.
     * @param field The field name to sort by.
     * @param order The sort order (ascending or descending).
     * @return The appropriate sort builder for the field.
     */
    protected SortBuilder<?> createFieldSortBuilder(final String field, final SortOrder order) {

    return new ImmutableLongArray(new long[] {e0});
  }

  /** Returns an immutable array containing the given values, in order. */
  public static ImmutableLongArray of(long e0, long e1) {
    return new ImmutableLongArray(new long[] {e0, e1});
  }

  /** Returns an immutable array containing the given values, in order. */
  public static ImmutableLongArray of(long e0, long e1, long e2) {

    return new ImmutableIntArray(new int[] {e0});
  }

  /** Returns an immutable array containing the given values, in order. */
  public static ImmutableIntArray of(int e0, int e1) {
    return new ImmutableIntArray(new int[] {e0, e1});
  }

  /** Returns an immutable array containing the given values, in order. */
  public static ImmutableIntArray of(int e0, int e1, int e2) {
    return new ImmutableIntArray(new int[] {e0, e1, e2});

 *
 * <p><b>Key-grouped iteration.</b> All view collections follow the same iteration order. In all
 * current implementations, the iteration order always keeps multiple entries with the same key
 * together. Any creation method that would customarily respect insertion order (such as {@link
 * #copyOf(Multimap)}) instead preserves key-grouped order by inserting entries for an existing key
 * immediately after the last entry having that key.
 *

  }

  /**
   * Returns an immutable list containing the given elements, in order.
   *
   * @throws NullPointerException if any element is null
   */
  public static <E> ImmutableList<E> of(E e1, E e2) {
    return construct(e1, e2);
  }

  /**
   * Returns an immutable list containing the given elements, in order.
   *
   * @throws NullPointerException if any element is null
   */