}
			}
		}
	})
}

// checkVendorConsistency verifies that the vendor/modules.txt file matches (if
// go 1.14) or at least does not contradict (go 1.13 or earlier) the
// requirements and replacements listed in the main module's go.mod file.
func checkVendorConsistency(indexes []*modFileIndex, modFiles []*modfile.File, modRoots []string) {
	// readVendorList only needs the main module to get the directory

# default preserve enough checksums for the module to be used by Go 1.16.
#
# We don't have a copy of Go 1.16 handy, but we can simulate it by editing the
# 'go' version in the go.mod file to 1.16, without actually updating the
# requirements to match.

[short] skip

env MODFMT='{{with .Module}}{{.Path}} {{.Version}}{{end}}'


# For this module, Go 1.16 selects the same versions of all explicit dependencies

# when -short is set.
[short] stop


# 'go install pkg@version' works on a module that doesn't have a go.mod file
# and with a module whose go.mod file has missing requirements.
# With a proxy, the two cases are indistinguishable.
go install rsc.io/fortune@v1.0.0
stderr '^go: found rsc.io/quote in rsc.io/quote v1.5.2$'
exists $GOPATH/bin/fortune$GOEXE

 */
package org.apache.maven.plugin.descriptor;

/**
 * Describes a component requirement.
 *
 */
public class Requirement implements Cloneable {
    private final String role;

    private final String roleHint;

    public Requirement(String role) {
        this.role = role;
        this.roleHint = null;
    }

    public Requirement(String role, String roleHint) {
        this.role = role;

    def options = Stub(DaemonForkOptions)
    def requirement = new ForkedWorkerRequirement(workingDir, projectCacheDir, options)
    def spec = Stub(IsolatedParametersActionExecutionSpec)

    def setup() {
        _ * buildOperationRunner.getCurrentOperation() >> buildOperation
    }

    def "getting a worker daemon does not assume client use"() {
        when:
        factory.getWorker(requirement);

        then:

        private ExactMatcher(String provides) {
            this.provides = provides;
        }

        @Override
        public boolean matches(String requirement) {
            return provides.equalsIgnoreCase(requirement);
        }

        @Override
        public String toString() {
            return provides;
        }
    }

        return "Mojo parameter [name: '" + getName() + "'; alias: '" + getAlias() + "']";
    }

    public Requirement getRequirement() {
        return requirement;
    }

    public void setRequirement(Requirement requirement) {
        this.requirement = requirement;
    }

    public String getImplementation() {
        return implementation;
    }

# In this test, the workspace contains modules example.com/a and
# example.com/b. Module example.com/a has a direct requirement
# on rsc.io/sampler, and an indirect requirement on golang.org/x/text
# through rsc.io/isampler. Module example.com/b has a direct
# requirement on example.com/c which is incorrectly marked as indirect
# in module example.com/b's go.mod file.

 * limitations under the License.
 */

package org.gradle.internal.execution.steps;

/**
 * Context necessary for steps that change the outputs.
 *
 * This context doesn't add any new information, it encodes a requirement
 * in the type system that a step can change the outputs.
 */
public class ChangingOutputsContext extends InputChangesContext {
    public ChangingOutputsContext(InputChangesContext parent) {
        super(parent);

 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.toolchain;

/**
 *
 */
public interface RequirementMatcher {

    boolean matches(String requirement);