type Real struct {
	clock.RealClock
}

var _ Interface = Real{}

// EventAfterDuration schedules an EventFunc
func (Real) EventAfterDuration(f EventFunc, d time.Duration) {
	ch := time.After(d)
	go func() {
		t := <-ch
		f(t)
	}()
}

// EventAfterTime schedules an EventFunc
func (r Real) EventAfterTime(f EventFunc, t time.Time) {
	r.EventAfterDuration(f, time.Until(t))

	}

	t := schedule.Next(*mostRecentTime).Add(nextScheduleDelta).Sub(now)
	return &t
}

// nextScheduleTime returns the time.Time of the next schedule after the last scheduled
// and before now, or nil if no unmet schedule times, and an error.
// If there are too many (>100) unstarted times, it will also record a warning.

      object : Task("task one") {
        val schedules = mutableListOf(200.µs)

        override fun runOnce(): Long {
          if (schedules.isNotEmpty()) {
            redQueue.schedule(this, schedules.removeAt(0)) // Add it at the end also.
          }
          log += "scheduledTasks=${redQueue.scheduledTasks}"
          return -1L
        }
      }
    redQueue.schedule(task, 100.µs)

     */
    <T> T withEmptyBuild(Function<? super SettingsInternal, T> action);

    /**
     * Schedules the work graph for the tasks specified in the {@link org.gradle.StartParameter} associated with the build, runs the scheduled work and finishes up the build.
     * When this method returns, all user code will have completed, including 'build finished' hooks.
     *

import org.gradle.kotlin.dsl.support.serviceOf
import org.gradle.kotlin.dsl.support.useToRun

import java.io.File


/**
 * A scheduler of IO actions.
 */
interface IO {

    /**
     * Schedules the given [io action][action] for execution.
     *
     * The effect of an IO [action] is only guaranteed to be observable

import java.util.Collection;
import java.util.function.BiConsumer;
import java.util.function.Consumer;

public interface BuildWorkGraph extends Stoppable {
    /**
     * Schedules the given tasks and all of their dependencies in this work graph.
     */
    boolean schedule(Collection<ExportedTaskNode> taskNodes);

    /**
     * Adds tasks and other nodes to this work graph.
     */

// GetNextTime returns the next time at which there is work scheduled,
// and a bool indicating whether there is any such time
func (fec *Fake) GetNextTime() (time.Time, bool) {
	fec.waitersLock.RLock()
	defer fec.waitersLock.RUnlock()
	if len(fec.waiters) > 0 {
		return fec.waiters[0].targetTime, true
	}
	return time.Time{}, false
}

// Run runs all the events scheduled, and all the events they

      private ScheduledFuture<@Nullable Void> submitToExecutor(Schedule schedule) {
        return executor.schedule(this, schedule.delay, schedule.unit);
      }
    }

    /**
     * Contains the most recently submitted {@code Future}, which may be cancelled or updated,
     * always under a lock.
     */
    private static final class SupplantableFuture implements Cancellable {
      private final ReentrantLock lock;

    /**
     * Queues the given task for execution. Does not schedule the task, use {@link #scheduleQueuedTasks()} for this.
     */
    void queueForExecution(ExportedTaskNode taskNode);

    /**
     * Schedules any queued tasks. When this method returns true, then some tasks where scheduled for this build and

        assertTaskExecuted(':', ':a')
        assertTaskNotExecuted(':buildB', ':c')

        where:
        method << ["shouldRunAfter", "mustRunAfter"]
    }

    def "finalizedBy task within included build schedules finalizer for execution"() {
        given:
        buildA.buildFile << """
            task a {
                dependsOn gradle.includedBuild('buildB').task(':b')
            }
        """