and:
        0 * c1._(*_)
        0 * c2._(*_)
        0 * c3._(*_)

        when:
        def isNone = candidates.isNone()

        then:
        1 * c1.isNone() >> true

        and:
        1 * c2.isNone() >> false
        0 * c3.isNone()

        when:
        def match = candidates.findByHashValue(hash)

        then:
        1 * c1.findByHashValue(hash) >> null

        def candidates = new LazyLocallyAvailableResourceCandidates(factory, TestUtil.checksumService)

        then:
        0 * factory.create()

        when:
        def isNone = candidates.isNone()

        then:
        !isNone
        1 * factory.create() >> [file("abc"), file("def")]

        when:
        def candidate = candidates.findByHashValue(Hashing.sha1().hashString("def"))

        then:

            this.allCandidates = allCandidates;
        }

        @Override
        public boolean isNone() {
            for (LocallyAvailableResourceCandidates candidates : allCandidates) {
                if (!candidates.isNone()) {
                    return false;
                }
            }

            return true;
        }

        @Override

) *Waypoint {
	// namespace to be used when the annotation doesn't include a namespace
	fallbackNamespace := o.Namespace
	// try fetching the waypoint defined on the object itself
	wp, isNone := getUseWaypoint(o, fallbackNamespace)
	if isNone {
		// we've got a local override here opting out of waypoint
		return nil
	}
	if wp != nil {

import org.gradle.internal.hash.HashCode;

/**
 * A set of locally available resources that were “selected” through some means.
 */
public interface LocallyAvailableResourceCandidates {

    boolean isNone();

    LocallyAvailableResource findByHashValue(HashCode hashValue);

    }

    protected List<File> getFiles() {
        if (files == null) {
            files = filesFactory.create();
        }
        return files;
    }

    @Override
    public boolean isNone() {
        return getFiles().isEmpty();
    }

    @Override
    public LocallyAvailableResource findByHashValue(HashCode targetHash) {
        HashCode thisHash;
        for (File file : getFiles()) {

            // If we have no caching options, just get the thing directly
            if (cached == null && (additionalCandidates == null || additionalCandidates.isNone())) {
                return copyToCache(location, fileStore, delegate.withProgressLogging().resource(location));
            }

            // We might be able to use a cached/locally available version

        def result = cache.getResource(location, null, fileStore, localCandidates)

        then:
        result == null

        and:
        1 * index.lookup("thing") >> null
        1 * localCandidates.isNone() >> true
        1 * repository.withProgressLogging() >> progressLoggingRepo
        1 * progressLoggingRepo.resource(location) >> resource
        1 * resource.withContentIfPresent(_) >> null
        0 * _._
    }

                logged = true;
            }
            return new LocallyAvailableResourceCandidates() {
                @Override
                public boolean isNone() {
                    return true;
                }

                @Override
                public LocallyAvailableResource findByHashValue(HashCode hashValue) {
                    return null;

    assertFalse(task.isDone());
    assertFalse(task.isCancelled());

    // Start the task to put it in the RUNNING state.  Have to use a separate
    // thread because the task will block on the task latch after unblocking
    // the run latch.
    exec.execute(task);
    runLatch.await();
    assertEquals(1, listenerLatch.getCount());
    assertFalse(task.isDone());
    assertFalse(task.isCancelled());