return this;
    }

    public void setCreatedTime_Equal(Long createdTime) {
        setCreatedTime_Term(createdTime, null);
    }

    public void setCreatedTime_Equal(Long createdTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
        setCreatedTime_Term(createdTime, opLambda);
    }

    public void setCreatedTime_Term(Long createdTime) {
        setCreatedTime_Term(createdTime, null);
    }

          int splitCharacteristics,
          long estSplitSize);
    }

    @Weak @Nullable OutSpliteratorT prefix;
    final Spliterator<InElementT> from;
    final Function<? super InElementT, @Nullable OutSpliteratorT> function;
    final Factory<InElementT, OutSpliteratorT> factory;
    int characteristics;
    long estimatedSize;

    FlatMapSpliterator(

        // Negative values remain negative when stored in long fields
        // The calculations will result in negative values
        long expectedCapacity = (long) alloc * sectPerAlloc * bytesPerSect;
        assertEquals(expectedCapacity, smbInfoAllocation.getCapacity());

        long expectedFree = (long) free * sectPerAlloc * bytesPerSect;

        Map<EventType, Long> stats = logger.getStatistics();
        assertEquals(Long.valueOf(1), stats.get(EventType.AUTHENTICATION_SUCCESS), "Should have 1 authentication success event");
        assertEquals(Long.valueOf(1), stats.get(EventType.AUTHENTICATION_FAILURE), "Should have 1 authentication failure event");

     */
    public static class FileInfo {
        private final String name;
        private final long size;
        private final long lastModified;
        private final boolean isDirectory;
        private final long attributes;
        private final long creationTime;
        private final long lastAccessTime;

        /**
         * Create file info from name and attributes
         *

   * This list contains values that attempt to provoke overflow in long operations. It contains
   * positive values on or near 2^N for N near multiples of 8 (near byte boundaries). This list is
   * a superset of POSITIVE_INTEGER_CANDIDATES.
   */
  static final ImmutableSet<Long> POSITIVE_LONG_CANDIDATES;

  static final Iterable<Long> NEGATIVE_LONG_CANDIDATES;

  static final Iterable<Long> NONZERO_LONG_CANDIDATES;

   *
   * <p>Instead of throwing {@link ArithmeticException}, this method silently saturates to either
   * {@link Long#MAX_VALUE} or {@link Long#MIN_VALUE}. This behavior can be useful when decomposing
   * a duration in order to call a legacy API which requires a {@code long, TimeUnit} pair.
   */
  static long toNanosSaturated(Duration duration) {
    // Using a try/catch seems lazy, but the catch block will rarely get invoked (except for

    public class DocMeta implements Serializable {

        private static final long serialVersionUID = 1L;

        protected String id;

        protected Long version;

        protected Long seqNo;

        protected Long primaryTerm;

        private transient RequestOptionCall<IndexRequestBuilder> indexOption;

java.time.OffsetDateTime#minusWeeks(long)
java.time.OffsetDateTime#minusYears(long)
java.time.OffsetDateTime#plus(long, java.time.temporal.TemporalUnit)
java.time.OffsetDateTime#plus(java.time.temporal.TemporalAmount)
java.time.OffsetDateTime#plusDays(long)
java.time.OffsetDateTime#plusHours(long)
java.time.OffsetDateTime#plusMinutes(long)
java.time.OffsetDateTime#plusMonths(long)
java.time.OffsetDateTime#plusNanos(long)

@NullUnmarked
@GwtIncompatible
@J2ktIncompatible
public class ListeningScheduledExecutorServiceTest extends TestCase {

  private Runnable recordedCommand;
  private long recordedDelay;
  private long recordedInterval;
  private TimeUnit recordedTimeUnit;

  private final ListeningScheduledExecutorService executorService = new FakeExecutorService();

  public void testScheduleRunnable() throws Exception {