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 {

 * There are two kinds of outputs for a transform:
 * - Produced outputs in the workspace. Those are relative paths depending on the workspace root, independent of the input artifact.
 * - Selected parts of the input artifact. These are relative paths of locations selected in the input artifact, independent of the workspace directory.
 *
 * The workspace can be relocated for immutable transform executions, and the input artifact can change.

    }

    @Override
    public WorkOutput execute(ExecutionRequest executionRequest) {
        File workspace = executionRequest.getWorkspace();
        File compileOutput = compile(workspace);
        instrument(compileOutput, instrumentedOutput(workspace));
        return new UnitOfWork.WorkOutput() {
            @Override
            public WorkResult getDidWork() {

        and:
        id == newId
    }

    def "generates workspace ID in expected location"() {
        given:
        def newId = UniqueId.generate()

        when:
        def id = loader.workspace.id

        then:
        1 * buildTreeScopedCacheBuilderFactory.baseDirForCrossVersionCache("workspace-id.txt") >> storeFile

        and:
        1 * storeFactory.create(storeFile, _) >> store

specified in the workspace (with use directives).

The syncing is done by sequentially upgrading each of the dependency
modules specified in a workspace module to the version in the build list
if the dependency module's version is not already the same as the build
list's version. Note that Minimal Version Selection guarantees that the
build list's version of each module is always the same or higher than
that in each workspace module.

        } catch (IOException e) {
            throw new UncheckedIOException("Could not read workspace metadata from " + metadataFile, e);
        }
    }

    @Override
    public void storeWorkspaceMetadata(File workspace, ImmutableWorkspaceMetadata metadata) {
        File metadataFile = new File(workspace, METADATA_FILE);
        //noinspection IOStreamConstructor

# Test that -modfile=path/to/go.mod is rejected in workspace mode.

! go list -m -modfile=./a/go.alt.mod
stderr 'go: -modfile cannot be used in workspace mode'

env GOFLAGS=-modfile=./a/go.alt.mod
! go list -m
stderr 'go: -modfile cannot be used in workspace mode'

-- go.work --
go 1.20

use (
    ./a
)

-- a/go.mod --
module example.com/foo

go 1.20

-- a/go.alt.mod --
module example.com/foo

go 1.20

                public Object getOutput(File workspace) {
                    return loadAlreadyProducedOutput(workspace);
                }
            };
        }

        @Override
        public Object loadAlreadyProducedOutput(File workspace) {
            File srcDir = new File(workspace, OUT_SOURCES);
            File dstDir = new File(workspace, OUT_CLASSES);
            return new GeneratedAccessors(srcDir, dstDir);

# mode if the modules.txt specifies ## workspace (and only in
# standard vendor if it doesn't).

# vendor directory produced for workspace, workspace mode
# runs in mod=vendor
go work vendor
cmp vendor/modules.txt want_workspace_modules_txt
go list -f {{.Dir}} example.com/b
stdout $GOPATH[\\/]src[\\/]vendor[\\/]example.com[\\/]b

# vendor directory produced for workspace, module mode