# outside of workspace mode.
env GOWORK=off
go list -f '{{.Dir}}' example.com/dep
stdout $GOPATH[\\/]src[\\/]workspace[\\/]vendor[\\/]example.com[\\/]dep

# Test case: endure the module does not enter mod=vendor outside
# worspace mode.
env GOWORK=''
go list -f '{{.Dir}}' example.com/dep
stdout $GOPATH[\\/]src[\\/]dep

-- workspace/go.work --
use .
replace example.com/dep => ../dep
-- workspace/main.go --

    fun putInstance(id: Int, instance: Any) {
        instanceIds[id] = instance
    }
}


class CircularReferences {

    private
    val refs = ReferenceOpenHashSet<Any>()

    fun enter(reference: Any) {
        require(refs.add(reference))
    }

    operator fun contains(reference: Any) =
        refs.contains(reference)

    fun leave(reference: Any) {
        require(refs.remove(reference))

        String trimmed = text.trim();
        if (YES_NO_CHOICES.contains(trimmed)) {
            return PromptResult.response(BooleanUtils.toBoolean(trimmed));
        }
        return PromptResult.newPrompt("Please enter 'yes' or 'no': ");
    }

    /**
     * Was the given capability already seen which might require a conflict check later?
     * This is needed to determine if also implicit capabilities need to enter conflict detection.
     */
    boolean hasSeenCapability(Capability capability);

    interface Candidate {
        NodeState getNode();
        Capability getCapability();

# (And the file needs to be two directory levels up from the Gradle build file.)
# TODO(cpovirk): Find a better way to give them that information.
cp pom.xml "${GRADLE_TEMP}"

for version in 5.6.4 7.0.2; do
  # Enter a subshell so that we return to the current directory afterward.
  (
    cp -r integration-tests "${GRADLE_TEMP}/${version}"
    cd "${GRADLE_TEMP}/${version}/gradle"
    ./gradlew wrapper --gradle-version="${version}"

            return PromptResult.response(BooleanUtils.toBoolean(trimmed));
        }
        String defaultString = defaultValue ? "yes" : "no";
        return PromptResult.newPrompt("Please enter 'yes' or 'no' (default: '" + defaultString + "'): ");
    }

    @Inject
    private SessionScope sessionScope;

    protected String component() {
        return "installer";
    }

    @Test
    void testArtifactInstallation() throws Exception {
        sessionScope.enter();
        try {
            sessionScope.seed(MavenSession.class, mock(MavenSession.class));

            String artifactBasedir = new File(getBasedir(), "src/test/resources/artifact-install").getAbsolutePath();

====

[NOTE]
====
This configuration is internal to PMD and is not linked to <<performance#parallel_execution,the number of workers>> used by Gradle.
It means that you have to pay attention to the value entered here and make sure it still makes sense in a multi project build.
This is because parallel Gradle task execution could result in different PMD tasks from different projects running in parallel.

                    return result;
                }

                function acceptAllErrorCorrections() {
                    var reason = prompt("Enter a reason for accepting these changes:");
                    if (!reason) {
                        alert("You must enter a reason to accept all changes.");
                        return;
                    }

class DefaultInstrumentedGroovyCallsTrackerTest extends Specification {

    InstrumentedGroovyCallsTracker instance = new DefaultInstrumentedGroovyCallsTracker()

    def 'enters and leaves nested calls'() {
        given:
        def entryFoo = instance.enterCall("FooCallerClass", "foo", INVOKE_METHOD)
        def entryBar = instance.enterCall("BarCallerClass", "bar", INVOKE_METHOD)

        when: