goto Found
		} else if err != errNoModules {
			return p, err
		}

		gopath := ctxt.gopath() // needed twice below; avoid computing many times

		// tried records the location of unsuccessful package lookups
		var tried struct {
			vendor []string
			goroot string
			gopath []string
		}

		// Vendor directories get first chance to satisfy import.
		if mode&IgnoreVendor == 0 && srcDir != "" {

	if buildID != toolBuildID {
		t.Fatalf(".BuildID with -export %q disagrees with 'go tool buildid' %q", buildID, toolBuildID)
	}
}

// Issue 4096. Validate the output of unsuccessful go install foo/quxx.
func TestUnsuccessfulGoInstallShouldMentionMissingPackage(t *testing.T) {
	tg := testgo(t)
	defer tg.cleanup()
	tg.parallel()
	tg.runFail("install", "foo/quxx")

        Try.ofFailable { result } == Try.successful(result)

        where:
        result << [['a', 'b', 'c'], "Some string", 5]
    }

    def "successful (flat) map"() {
        expect:
        Try.successful(10).flatMap { it -> Try.successful(it + 2) } == Try.successful(12)
        Try.successful(20).map { (it + 10).toString() } == Try.successful('30')

          <type>String</type>
        </field>
        <field>
          <name>notifiers</name>
          <version>4.0.0+</version>
          <description>Configuration for notifying developers/users when a build is unsuccessful,
            including user information and notification mode.</description>
          <association>
            <multiplicity>*</multiplicity>
            <type>Notifier</type>
          </association>

	}()
}

// dialConnFor dials on behalf of w and delivers the result to w.
// dialConnFor has received permission to dial w.cm and is counted in t.connCount[w.cm.key()].
// If the dial is canceled or unsuccessful, dialConnFor decrements t.connCount[w.cm.key()].
func (t *Transport) dialConnFor(w *wantConn) {
	defer w.afterDial()
	ctx := w.getCtxForDial()
	if ctx == nil {
		t.decConnsPerHost(w.key)
		return
	}

    }

    public abstract static class Result<T> {
        public abstract boolean isSuccessful();

        public abstract T getValue();

        /**
         * Creates a result that indicates that the operation was successful and should not be repeated.
         */
        public static <T> Result<T> successful(final T value) {
            if (value == null) {
                throw new IllegalArgumentException();

        ImmutableSortedMap<String, FileSystemSnapshot> outputFilesProducedByWork,
        boolean successful
    ) {
        super(implementation, additionalImplementations, inputProperties, inputFileProperties);
        this.outputFilesProducedByWork = outputFilesProducedByWork;
        this.originMetadata = originMetadata;
        this.successful = successful;
        this.cacheKey = cacheKey;
    }

    @Override

        this.successful = successful;
        this.outputFilesProducedByWork = outputFilesProducedByWork;
        this.originMetadata = originMetadata;
        this.reused = reused;
    }

    @Override
    public boolean isSuccessful() {
        return successful;
    }

    @Override
    public ImmutableSortedMap<String, FileSystemSnapshot> getOutputFilesProducedByWork() {
        return outputFilesProducedByWork;
    }

/**
 * Captures the state of the outputs of a {@link org.gradle.internal.execution.UnitOfWork}.
 */
public interface ExecutionOutputState {

    /**
     * Whether the execution was successful.
     */
    boolean isSuccessful();

    /**
     * Snapshots of the roots of output properties.
     *
     * In the presence of overlapping outputs this might be different from

    }

    boolean isRegressed() {
        return teamCityExecutions.every { it.isBuildFailed() } && !currentExecutions.empty
    }

    boolean isSuccessful() {
        return teamCityExecutions.every { it.isSuccessful() }
    }

    boolean isAboutToRegress() {
        return !crossBuild && currentExecutions.any { it.confidentToSayWorse() }
    }

    double getDifferenceSortKey() {