// Do not cache Test task if Jacoco doesn't produce its output as files
            extension.isEnabled() && extension.getOutput() != JacocoTaskExtension.Output.FILE
        );
        task.getOutputs().doNotCacheIf(
            "JaCoCo configured to not produce its output as a file",
            spec(targetTask -> doNotCachePredicate.get())
        );
    }

    for (auto replica_result_and_idx :
         llvm::enumerate(replica_and_idx.value().getOutputs()))
      replicas_outputs[num_replicas * replica_result_and_idx.index() +
                       replica_and_idx.index()] =
          replica_result_and_idx.value();

  // Remap replicate results to per replica result.
  for (auto result : llvm::zip(island_op.getOutputs(), replicas_outputs))
    std::get<0>(result).replaceAllUsesWith(std::get<1>(result));

        getTask().getDescription() == null
        project.is( getTask().getProject())
        getTask().getStandardOutputCapture() != null
        getTask().getInputs() != null
        getTask().getOutputs() != null
        getTask().getOnlyIf() != null
        getTask().getOnlyIf().isSatisfiedBy(getTask())
    }

    def testPath() {
        ProjectInternal childProject = TestUtil.createChildProject(project, "child")

                    getLogging();
                    getLogging().captureStandardOutput(LogLevel.INFO);
                    getStandardOutputCapture();
                    getInputs();
                    getOutputs();
                }
            }
        """

        buildFile << """
            buildscript {
                dependencies { classpath fileTree(dir: "producer/build/libs", include: '*.jar') }

import org.gradle.internal.HasInternalProtocol;

/**
 * <p>A {@code TaskOutputs} represents the outputs of a task.</p>
 *
 * <p>You can obtain a {@code TaskOutputs} instance using {@link org.gradle.api.Task#getOutputs()}.</p>
 */
@HasInternalProtocol
public interface TaskOutputs {
    /**
     * <p>
     *     Adds a predicate to determine whether previous outputs of this task can be reused.

        getTask().getDescription() == null
        project.is(getTask().getProject())
        getTask().getStandardOutputCapture() != null
        getTask().getInputs() != null
        getTask().getOutputs() != null
        getTask().getOnlyIf() != null
        getTask().getOnlyIf().isSatisfiedBy(getTask())
    }

    def "test Path"() {
        given:

    }

    @TaskAction
    protected void link() {
        boolean cleanedOutputs = StaleOutputCleaner.cleanOutputs(
            getDeleter(),
            getOutputs().getPreviousOutputFiles(),
            getDestinationDirectory().get().getAsFile()
        );

        if (getSource().isEmpty()) {
            setDidWork(cleanedOutputs);
            return;
        }

    outer_op.getBody().takeBody(region);
    // Careful: We can't use outer_op.getResults(), because that also includes
    // the control token.
    op->replaceAllUsesWith(outer_op.getOutputs());
    op->erase();
    // Control token is last result of outer_op.
    control_tokens.assign(1, outer_op.getResults().back());
  }
}
}  // namespace

            }
        }
    }

    private void configureTestTask(AbstractTestTask test) {
        test.getFilter().setFailOnNoMatchingTests(false);
        test.getOutputs().upToDateWhen(Specs.SATISFIES_NONE);
        if (test instanceof Test) {
            InternalDebugOptions debugOptions = testExecutionRequest.getDebugOptions();
            if (debugOptions.isDebugMode()) {

            public abstract class SneakyTask extends DefaultTask {
                @Inject
                protected abstract ExecOperations getExecOperations();

                public SneakyTask() {
                  getOutputs().upToDateWhen(t -> {
                    ${snippets.body};
                    return false;
                  });
                }

                @TaskAction
                public void doNothing() {}