this.delayMillisAtNoUrlInQueue = delayMillisAtNoUrlInQueue;
    }

    public long getDelayMillisBeforeProcessing() {
        return delayMillisBeforeProcessing;
    }

    public void setDelayMillisBeforeProcessing(final long delayMillisBeforeProcessing) {
        this.delayMillisBeforeProcessing = delayMillisBeforeProcessing;
    }

    private long physicalMemoryThresholdInBytes;
    private long virtualMemoryThresholdInBytes;
    private static final Logger LOGGER = Logging.getLogger(LowMemoryDaemonExpirationStrategy.class);

    // Reasonable default threshold bounds: between 384M and 1G
    public static final long MIN_THRESHOLD_BYTES = 384 * 1024 * 1024;
    public static final long MAX_THRESHOLD_BYTES = 1024 * 1024 * 1024;

  /** Invokes {@code unit.}{@link TimeUnit#sleep(long) sleep(sleepFor)} uninterruptibly. */
  @J2ktIncompatible
  @GwtIncompatible // concurrency
  @SuppressWarnings("GoodTime") // should accept a java.time.Duration
  public static void sleepUninterruptibly(long sleepFor, TimeUnit unit) {
    boolean interrupted = false;
    try {
      long remainingNanos = unit.toNanos(sleepFor);
      long end = System.nanoTime() + remainingNanos;

        result.option('long-option-a').values == ['arg']
    }

    def parsesLongOptionWithEqualsArgument() {
        parser.option('long-option-a').hasArgument()

        expect:
        def result = parser.parse(['--long-option-a=arg'])
        result.hasOption('long-option-a')
        result.option('long-option-a').value == 'arg'
        result.option('long-option-a').values == ['arg']

    List<Throwable> exceptions = []
    Throwable exception = exceptions[0]
    List<TestFailure> failures
    long startTime = 0
    long endTime = startTime + 100
    long testCount = 1
    long successfulTestCount = 1
    long failedTestCount = 0
    long skippedTestCount = 0

    SimpleTestResult(long endTime = 100) {
        this.endTime = endTime
    }

        regOBD("_id");
        return this;
    }

    public void setEndTime_Equal(Long endTime) {
        setEndTime_Term(endTime, null);
    }

    public void setEndTime_Equal(Long endTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
        setEndTime_Term(endTime, opLambda);
    }

    public void setEndTime_Term(Long endTime) {
        setEndTime_Term(endTime, null);
    }

    protected final long allRecordCount;
    protected final String allRecordCountRelation;
    protected final long queryTime;
    protected final boolean partialResults;
    protected final FacetResponse facetResponse;

    SearchResult(final List<Map<String, Object>> documentList, final long allRecordCount, final String allRecordCountRelation,

        return this;
    }

    public void setGidNumber_Equal(Long gidNumber) {
        setGidNumber_Term(gidNumber, null);
    }

    public void setGidNumber_Equal(Long gidNumber, ConditionOptionCall<TermQueryBuilder> opLambda) {
        setGidNumber_Term(gidNumber, opLambda);
    }

    public void setGidNumber_Term(Long gidNumber) {
        setGidNumber_Term(gidNumber, null);
    }

    }

    public static String getMemoryUsageLog() {
        final Runtime runtime = Runtime.getRuntime();
        final long freeBytes = runtime.freeMemory();
        final long maxBytes = runtime.maxMemory();
        final long totalBytes = runtime.totalMemory();
        final long usedBytes = totalBytes - freeBytes;

multiplication, along with a few n-digit additions and subtractions. The standard
n-by-n-digit multiplication algorithm requires O(n²) time, making the overall
algorithm require time T(n) where

	T(n) = 2T(n/2) + O(n) + O(n²)

which, by the Bentley-Haken-Saxe theorem, ends up reducing to T(n) = O(n²).
This is not an improvement over regular long division.