@EqualsAndHashCode
    static class ScopeIds {
        final UniqueId buildInvocation
        final UniqueId workspace
        final UniqueId user

        ScopeIds(UniqueId buildInvocation, UniqueId workspace, UniqueId user) {
            this.buildInvocation = buildInvocation
            this.workspace = workspace
            this.user = user
        }

        @Override
        String toString() {

        then:
        1 * model.workspace.iws.getXmlTransformer()

        when: "configure workspace file"
        model.workspace.iws({ fcm -> fcm.xmlTransformer } as Action<XmlFileContentMerger>)

        then:
        1 * model.workspace.iws.getXmlTransformer()

        when: "configure workspace xml"
        model.workspace.iws.withXml(xmlAction)

        then:

    createWorkspace().use { workspace ->
      createBndRun(workspace).use { bndRun ->
        bndRun.resolve(
          false,
          false,
        )
      }
    }
  }

  private fun createWorkspace(): Workspace {
    val bndDir = workspaceDir / "cnf"
    val repoDir = bndDir / "repo"
    fileSystem.createDirectories(repoDir)
    return Workspace(workspaceDir.toFile(), bndDir.name)
      .apply {

        this.project = project;
    }

    /**
     * Configures IDEA workspace information.
     * <p>
     * For examples see docs for {@link IdeaWorkspace}.
     */
    public IdeaWorkspace getWorkspace() {
        return workspace;
    }

    public void setWorkspace(IdeaWorkspace workspace) {
        this.workspace = workspace;
    }

    /**
     * Configures the target IDEA version.
     */

! go list ./a/c
stderr 'directory a[\\/]c is contained in a module that is not one of the workspace modules listed in go.work. You can add the module to the workspace using:\n\tgo work use a'

! go install ./a/c
stderr 'directory a[\\/]c is contained in a module that is not one of the workspace modules listed in go.work. You can add the module to the workspace using:\n\tgo work use a'

cd a/c
! go run .

        // Check
        result.duration.toMillis() >= 100

        _ * context.inputChanges >> Optional.empty()
        _ * work.execute({ UnitOfWork.ExecutionRequest executionRequest ->
            executionRequest.workspace == workspace && !executionRequest.inputChanges.present && executionRequest.previouslyProducedOutputs.get() == previousOutputs
        }) >> {
            sleep 200
            Stub(UnitOfWork.WorkOutput) {

    private final File workspace;

    public WorkspaceResult(CachingResult parent, @Nullable File workspace) {
        super(parent);
        this.workspace = workspace;
    }

    @Override
    public <T> Try<T> getOutputAs(Class<T> type) {
        return getExecution()
            .map(execution -> execution.getOutput(workspace))
            .map(type::cast);
    }

# Test that mod=vendor is disabled in workspace mode, even
# with a single workspace module.

cd workspace

# Base case: ensure the module would default to mod=vendor
# 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=''

        when:
        store.storeWorkspaceMetadata(workspace, metadata)

        then:
        workspace.file("metadata.bin").assertIsFile()

        when:
        def loadedMetadata = store.loadWorkspaceMetadata(workspace)

        then:
        loadedMetadata == metadata
    }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.execution.workspace.impl;

import org.gradle.internal.execution.history.ExecutionHistoryStore;
import org.gradle.internal.execution.workspace.MutableWorkspaceProvider;

import java.io.File;

public class NonLockingMutableWorkspaceProvider implements MutableWorkspaceProvider {