// Output:
	// First negative at index 2
}

func ExampleInsert() {
	names := []string{"Alice", "Bob", "Vera"}
	names = slices.Insert(names, 1, "Bill", "Billie")
	names = slices.Insert(names, len(names), "Zac")
	fmt.Println(names)
	// Output:
	// [Alice Bill Billie Bob Vera Zac]
}

func ExampleIsSorted() {
	fmt.Println(slices.IsSorted([]string{"Alice", "Bob", "Vera"}))
	fmt.Println(slices.IsSorted([]int{0, 2, 1}))

        Long millis;

        millis = params.get("delayMillisAfterProcessing");
        if (millis != null) {
            delayMillisAfterProcessing = millis;
        }

        millis = params.get("delayMillisAtNoUrlInQueue");
        if (millis != null) {
            delayMillisAtNoUrlInQueue = millis;
        }

        millis = params.get("delayMillisBeforeProcessing");

    public static void sleep(final long millis) {
        if (millis < 1L) {
            return;
        }
        try {
            Thread.sleep(millis);
        } catch (final InterruptedException e) {
            throw new InterruptedRuntimeException(e);
        }
    }

    public static void sleepQuietly(final long millis) {
        if (millis < 1L) {
            return;
        }
        try {

    public static final Units<Duration> HOURS = MINUTES.times(60, "h");

    public static Amount<Duration> millis(long millis) {
        return Amount.valueOf(millis, MILLI_SECONDS);
    }

    public static Amount<Duration> millis(BigDecimal millis) {
        return Amount.valueOf(millis, MILLI_SECONDS);
    }

    public static Amount<Duration> seconds(BigDecimal seconds) {

 */
class Range {
    private final long millis

    Range(long millis) {
        this.millis = millis
    }

    @Override
    String toString() {
        return "[approx $millis millis]"
    }

    boolean isCase(Duration duration) {
        def actualMillis = duration.millis
        return actualMillis > millis - 500 && actualMillis < millis + 2000
    }

class DurationTest extends Specification {
    def "millisecond durations have useful string formats"() {
        expect:
        Duration.millis(millis).toString() == str
        Duration.millis(millis).format() == formatted

        where:
        millis  | str          | formatted
        0       | "0 ms"       | "0 ms"
        1       | "1 ms"       | "1 ms"
        0.123   | "0.123 ms"   | "0.123 ms"

    }

    private void setNanos(long millis) {
        1 * timeSource.nanoTime() >> START_NANOS + TimeUnit.MILLISECONDS.toNanos(millis)
    }

    private void setMillis(long millis) {
        1 * timeSource.currentTimeMillis() >> START_MILLIS + millis
    }

    private long time(millis) {
        START_MILLIS + millis
    }

        DataSeries.confidenceInDifference(first.results.getTotalTime(), second.results.totalTime)
    }

    MeasuredOperation millis(long millis) {
        new MeasuredOperation(totalTime: Duration.millis(millis))
    }

    }

    void writeLastFileAccessTimeToJournal(File file, long millis) {
        def cache = new BTreePersistentIndexedCache<File, Long>(journal, FILE_SERIALIZER, LONG_SERIALIZER)
        try {
            cache.put(file, millis)
        } finally {
            cache.close()
        }
    }

    void writeJournalInceptionTimestamp(long millis) {
        fileAccessPropertiesFile.text = "${INCEPTION_TIMESTAMP_KEY} = $millis"

    @Override
    String toString() {
        return "[instant at $nanos]"
    }

    int compareTo(Instant t) {
        return nanos.compareTo(t.nanos)
    }

    Instant plus(long millis) {
        return new Instant(nanos + millis * 1000)
    }

    Duration minus(Instant t) {
        return new Duration(nanos - t.nanos)
    }