/**
 * A shell script to run within a vagrant VM.
 *
 * The script is run as root within the VM.
 */
public abstract class VagrantShellTask extends DefaultTask {

    private final VagrantExtension extension;
    private final VagrantMachine service;
    private UnaryOperator<String> progressHandler = UnaryOperator.identity();

    public VagrantShellTask() {

 *
 * @author Louis Wasserman
 */
@J2ktIncompatible // no support for access-order mode in LinkedHashMap delegate
@GwtIncompatible // not worth using in GWT for now
final class CompactLinkedHashMap<K extends @Nullable Object, V extends @Nullable Object>
    extends CompactHashMap<K, V> {
  // TODO(lowasser): implement removeEldestEntry so this can be used as a drop-in replacement

      return Collections.emptyList();
    }
    return new FloatArrayAsList(backingArray);
  }

  private static final class FloatArrayAsList extends AbstractList<Float>
      implements RandomAccess, Serializable {
    final float[] array;
    final int start;
    final int end;

    FloatArrayAsList(float[] array) {
      this(array, 0, array.length);
    }

 */
@NullUnmarked
@GwtIncompatible
@J2ktIncompatible
public class UninterruptibleFutureTest extends TestCase {
  private SleepingRunnable sleeper;
  private Future<Boolean> delayedFuture;

  private final TearDownStack tearDownStack = new TearDownStack();

  @Override
  protected void setUp() {
    ExecutorService executor = newSingleThreadExecutor();
    tearDownStack.addTearDown(executor::shutdownNow);

 * @author Louis Wasserman
 */
@GwtCompatible
@SuppressWarnings({"serial", "rawtypes"})
final class RegularImmutableSortedSet<E> extends ImmutableSortedSet<E> {
  static final RegularImmutableSortedSet<Comparable> NATURAL_EMPTY_SET =
      new RegularImmutableSortedSet<>(ImmutableList.of(), Ordering.natural());

  @VisibleForTesting final transient ImmutableList<E> elements;

        }
    }

    private static String generatedAnchor(String input) {
        final List<String> excludes = List.of("the", "is", "a");

        final String[] words = input.toLowerCase(Locale.ROOT)
            .replaceAll("[^\\w]+", "_")
            .replaceFirst("^_+", "")
            .replaceFirst("_+$", "")
            .split("_+");

  // NotApplicableException in the expensive comparator case.
  @Param({"100", "10000"})
  private int size;

  @Param private HeapType heap;

  private Queue<Integer> queue;

  private final Random random = new Random();

  @BeforeExperiment
  void setUp() {
    queue = heap.create(comparator.get());
    for (int i = 0; i < size; i++) {
      queue.add(random.nextInt());
    }
  }

  @Benchmark

  // NotApplicableException in the expensive comparator case.
  @Param({"100", "10000"})
  private int size;

  @Param private HeapType heap;

  private Queue<Integer> queue;

  private final Random random = new Random();

  @BeforeExperiment
  void setUp() {
    queue = heap.create(comparator.get());
    for (int i = 0; i < size; i++) {
      queue.add(random.nextInt());
    }
  }

  @Benchmark

                // warm up
                test(listener, session, resource, 0);

                for (int i = 1; i < size; i++) {
                    final int bytes = i;

                    service.execute(() -> {
                        test(listener, session, resource, bytes);
                    });
                }

                // start all threads at once

   * implementation type is an implementation detail.
   */
  @J2ktIncompatible // serialization
  private static final class SerializedForm<E> implements Serializable {
    final Comparator<? super E> comparator;
    final Object[] elements;

    SerializedForm(Comparator<? super E> comparator, Object[] elements) {
      this.comparator = comparator;
      this.elements = elements;