private void reduceEqualLinesFromHeadAndTail(
            List<String> original, List<String> revised, int contextSize) {
        int head = 0;
        int maxHead = min(original.size(), revised.size());
        while (head < maxHead && original.get(head).equals(revised.get(head))) {
            head++;
        }
        head = max(head - contextSize, 0);
        offsetHead = head;

     * then this method will return the time it took to produce the previous result.
     *
     * Note that reused work times might be different to what it would actually take to execute the work
     * in the current build for a number of reasons:
     *
     * <ul>

                      "cluster": "outbound|9080||productpage.default.svc.cluster.local",
                      "timeout": "0s",
                      "retry_policy": {
                        "retry_on": "connect-failure,refused-stream,unavailable,cancelled,retriable-status-codes",
                        "num_retries": 2,
                        "retry_host_predicate": [
                          {

                  },
                  "HostRewriteSpecifier": null,
                  "timeout": 0,
                  "retry_policy": {
                    "retry_on": "connect-failure,refused-stream,unavailable,cancelled,resource-exhausted,retriable-status-codes",
                    "num_retries": {
                      "value": 2
                    },
                    "retry_host_predicate": [

    private final boolean reused;

    public DefaultExecutionOutputState(boolean successful, ImmutableSortedMap<String, FileSystemSnapshot> outputFilesProducedByWork, OriginMetadata originMetadata, boolean reused) {
        this.successful = successful;
        this.outputFilesProducedByWork = outputFilesProducedByWork;
        this.originMetadata = originMetadata;
        this.reused = reused;
    }

    @Override

		err  error
		want bool
	}{
		0: {
			pc:   &persistConn{reused: false},
			req:  dummyRequest("POST"),
			err:  nothingWrittenError{},
			want: false,
		},
		1: {
			pc:   &persistConn{reused: true},
			req:  dummyRequest("POST"),
			err:  nothingWrittenError{},
			want: true,
		},
		2: {
			pc:   &persistConn{reused: true},
			req:  dummyRequest("POST"),
			err:  http2ErrNoCachedConn,

        when:
        fails('listJars')
        then:
        failure.assertHasCause("Could not resolve log4j:log4j:1.2.17.")
        failure.assertThatCause(CoreMatchers.containsString("Can't connect to SOCKS proxy:Connection refused"))

        when:
        def recordingServer = new TestRecordingSocksServer()
        proxyServer.start(recordingServer)
        proxyServer.configureProxy(executer)

    // Everything is up-to-date
    object Valid : CheckedFingerprint()

    // The entry cannot be reused at all and should be recreated from scratch
    class EntryInvalid(val reason: String) : CheckedFingerprint()

    // The entry can be reused, however the values for certain projects cannot be reused and should be recreated
    class ProjectsInvalid(val reason: String, val invalidProjects: Set<Path>) : CheckedFingerprint()

/**
 * @see ServiceScope
 */
public interface Scope {

    /**
     * These services are reused across builds in the same process.
     *
     * <p>Global services are visible to all other services.</p>
     */
    interface Global extends Scope {}

    /**
     * These services are reused across builds in the same process while the Gradle user home directory remains unchanged.

 */
@ServiceScope(Scope.Global.class)
public interface GradleModuleServices extends ServiceRegistrationProvider {
    /**
     * Called once per process, to register any globally scoped services. These services are reused across builds in the same process.
     * The services are closed when the process finishes.
     *
     * <p>Global services are visible to all other services.</p>
     *
     * @see Scope.Global
     */