return mostRecent.getTestProject();
                }

                @Override
                public List<String> getTasks() {
                    return mostRecent.getTasks();
                }

                @Override
                public List<String> getCleanTasks() {
                    return mostRecent.getCleanTasks();
                }

        return properties;
    }

    public GradleDistribution getMostRecentRelease() {
        String mostRecent = getProperties().getProperty("mostRecent");

        if (mostRecent == null) {
            throw new RuntimeException("Unable to get the last version");
        }

        return buildContext.distribution(mostRecent);
    }

    public GradleDistribution getMostRecentReleaseSnapshot() {

        val group = mutableListOf<T>()
        q.iterator().run {
            // the most recently pushed element
            val mostRecent = next()
            group.add(mostRecent)
            remove()
            // plus all elements superseded by it
            for (next in this) {
                if (mostRecent.supersedes(next)) {
                    group.add(next)
                    remove()
                }
            }

	// so the above keys are expected to be pruned and the
	// key below should not be pruned.
	mostRecent := now.Add(-59 * time.Minute)
	fakeClock.SetTime(mostRecent)
	tracker.Set("k3", 59)
	expected := map[string]*timestampedCount{
		"k3": {
			count:         59,
			lastUpdatedAt: mostRecent,
		},
	}

	fakeClock.SetTime(now)
	if err := tracker.prune(time.Hour); err != nil {

    @get:Input
    abstract val mostRecent: Property<String>

    @get:Input
    abstract val versions: Property<String>

    @get:Input
    abstract val mostRecentSnapshot: Property<String>

    @TaskAction
    fun prepareVersions() {
        val properties = Properties()
        properties["mostRecent"] = mostRecent.get()

        public <R, D, T extends BuildOperationType<D, R>> D mostRecentDetails(Class<T> type) {
            return mostRecent(type).details;
        }

        @SuppressWarnings("unused")
        public <R, D, T extends BuildOperationType<D, R>> R mostRecentResult(Class<T> type) {
            return mostRecent(type).result;
        }

        @SuppressWarnings("unused")

        Consumer<TestBuildOperationRunner.Log.TypedRecord<D, R>> verifier
    ) {
        assert buildOperationRunner.log.records.size() == 1
        interaction {
            verifier.accept(buildOperationRunner.log.mostRecent(operationType))
        }
    }

        then:
        !versions.all.empty
        versions.all*.version == versions.all*.version.sort().reverse()
    }

    def "get most recent final does that"() {
        when:
        props.mostRecent = "1.2"

        then:
        versions().mostRecentRelease.version == version("1.2")
    }

    def "get most recent snapshot does that"() {
        when:

		// against etcd followed by the special bookmark event
		return 0, nil
	}
	// at this point the clients is interested
	// only in getting a stream of events
	// starting at the MostRecent point in time (RV)
	currentStorageRV, err := w.getCurrentStorageRV(ctx)
	if err != nil {
		return 0, err
	}
	// currentStorageRV is taken from resp.Header.Revision (int64)

		withB      []string
		missingB   []string
		deletedCnt int
	)
	for dID, ss := range bs {
		if lastUpdate.IsZero() {
			lastUpdate = mostRecent(ss.meta.CreatedAt, ss.meta.DeletedAt)
			latestID = dID
		}
		recentUpdt := mostRecent(ss.meta.CreatedAt, ss.meta.DeletedAt)
		if recentUpdt.After(lastUpdate) {
			lastUpdate = recentUpdt
			latestID = dID
		}
		if ss.BucketMarkedDeleted {