// 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}))

tältä
tälle
tänä
täksi
tuo
tuon
tuotä
tuossa
tuosta
tuohon
tuolla
tuolta
tuolle
tuona
tuoksi
se
sen
sitä
siinä
siitä
siihen
sillä
siltä
sille
sinä
siksi
nämä
näiden
näitä
näissä
näistä
näihin
näillä
näiltä
näille
näinä
näiksi
nuo
noiden
noita
noissa
noista
noihin
noilla
noilta

        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"