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

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()) {

                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());

    assertTrue(future.isDone());
    assertFalse(future.isCancelled());

    assertEquals(expectedValue, future.get());
  }

  public void testCancelledFuture() throws InterruptedException, ExecutionException {
    assertTrue(future.isDone());
    assertTrue(future.isCancelled());

    assertTrue(latch.await(5, TimeUnit.SECONDS));
    assertTrue(future.isDone());
    assertTrue(future.isCancelled());

    assertFalse(task.isDone());
    task.run();
    assertTrue(task.isDone());
    assertFalse(task.isCancelled());
    assertEquals(2, getDone(task).intValue());
  }

  public void testCancelled() throws Exception {
    TrustedListenableFutureTask<Integer> task = TrustedListenableFutureTask.create(returning(2));
    assertFalse(task.isDone());
    task.cancel(false);
    assertTrue(task.isDone());

    assertTrue(future.isDone());
    assertFalse(future.isCancelled());

    assertEquals(expectedValue, future.get());
  }

  public void testCancelledFuture() throws InterruptedException, ExecutionException {
    assertTrue(future.isDone());
    assertTrue(future.isCancelled());

    assertTrue(latch.await(5, TimeUnit.SECONDS));
    assertTrue(future.isDone());
    assertTrue(future.isCancelled());