/**
   * Do interruptible work here - do not complete Futures here, as their listeners could be
   * interrupted.
   */
  @ParametricNullness
  abstract T runInterruptibly() throws Exception;

  /**
   * Any interruption that happens as a result of calling interruptTask will arrive before this
   * method is called. Complete Futures here.
   */

   * analysis that that means "plain {@code T}" rather than the inferred type {@code @Nullable T}.
   * (And even if annotations on local variables were permitted as an optional hint, no annotation
   * would be the right tool for the job here: {@code @Nullable} is the annotation that we're trying
   * to get rid of, and {@code @NonNull} would be wrong for our use case for the same reason as

   * analysis that that means "plain {@code T}" rather than the inferred type {@code @Nullable T}.
   * (And even if annotations on local variables were permitted as an optional hint, no annotation
   * would be the right tool for the job here: {@code @Nullable} is the annotation that we're trying
   * to get rid of, and {@code @NonNull} would be wrong for our use case for the same reason as

        } while (oldHead != Waiter.TOMBSTONE);
      }
      // re-read valueField, if we get here then we must have observed a TOMBSTONE while trying to
      // add a waiter.
      // requireNonNull is safe because valueField is always set before TOMBSTONE.
      return getDoneValue(requireNonNull(valueField));
    }
    // If we get here then we have remainingNanos < SPIN_THRESHOLD_NANOS and there is no node on the
    // waiters list

  @SuppressWarnings("unchecked")
  public static <E> ImmutableSet<E> copyOf(Collection<? extends E> elements) {
    /*
     * TODO(lowasser): consider checking for ImmutableAsList here
     * TODO(lowasser): consider checking for Multiset here
     */
    // Don't refer to ImmutableSortedSet by name so it won't pull in all that code
    if (elements instanceof ImmutableSet && !(elements instanceof SortedSet)) {

       * parameters. If it were statically checked, the checker would still be OK with it, since
       * we're copying into a `contents` array whose type allows it to contain nulls. Still, it's
       * worth noting that we promise not to put nulls into the array in the first `size` elements.
       * We uphold that promise here because our callers promise that `elements` will not contain

        fail(
            "contents were not equal and in the same order: "
                + "expected = "
                + expected
                + ", actual = "
                + actual);
      }
    }

    if (expectedIter.hasNext() || actualIter.hasNext()) {
      // actual either had too few or too many elements
      fail(
          "contents were not equal and in the same order: "

        String result1 = purgeDocJob.execute();

        // Reset the flag
        deleteByQueryCalled = false;

        String result2 = purgeDocJob.execute();

        // Assert both executions were successful
        assertEquals("", result1);
        assertEquals("", result2);
        assertTrue(deleteByQueryCalled);
    }

    public void test_execute_withEmptyIndexName() {

        } while (oldHead != Waiter.TOMBSTONE);
      }
      // re-read valueField, if we get here then we must have observed a TOMBSTONE while trying to
      // add a waiter.
      // requireNonNull is safe because valueField is always set before TOMBSTONE.
      return getDoneValue(requireNonNull(valueField));
    }
    // If we get here then we have remainingNanos < SPIN_THRESHOLD_NANOS and there is no node on the
    // waiters list

  private Ints() {}

  /**
   * The number of bytes required to represent a primitive {@code int} value.
   *
   * <p>Prefer {@link Integer#BYTES} instead.
   */
  // The constants value gets inlined here.
  @SuppressWarnings("AndroidJdkLibsChecker")
  public static final int BYTES = Integer.BYTES;

  /**
   * The largest power of two that can be represented as an {@code int}.
   *
   * @since 10.0
   */