def out = new ByteArrayOutputStream()
        def workspace = eclipseWorkspace([gradleProject("child1", false), gradleProject("child2")])
        when:
        withConnection { connection ->
            connection.action().projectsLoaded(new TellGradleToRunBuildDependencyTask(workspace), projectsLoadedHandler)
                .buildFinished(new LoadEclipseModel(workspace), buildFinishedHandler)
                .build()

    }

    @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() {

        when:
        withConnection { connection ->
            connection.action().projectsLoaded(new ParameterizedLoadCompositeEclipseModels(workspace, RunClosedProjectBuildDependencies), projectsLoadedHandler)
                .buildFinished(new ParameterizedLoadCompositeEclipseModels(workspace, EclipseProject), buildFinishedHandler)
                .build()
                .setStandardOutput(out)
                .forTasks()

    }

    @Override
    public InputFingerprinter getInputFingerprinter() {
        return inputFingerprinter;
    }

    private static File getOutputDir(File workspace) {
        return new File(workspace, "transformed");
    }

    private static File getResultsFile(File workspace) {
        return new File(workspace, "results.bin");

            return classesDir;
        }

        @Override
        public File instrumentedOutput(File workspace) {
            return new File(workspace, "instrumented/" + operation.getId());
        }

        private File classesDir(File workspace) {
            return new File(workspace, "classes/" + operation.getId());
        }

        } else if (version.endsWith(SNAPSHOT)) {
            WorkspaceReader workspace = session.getWorkspaceReader();
            if (workspace != null && workspace.findVersions(artifact).contains(version)) {
                metadata = null;
                result.setRepository(workspace.getRepository());
            } else {
                metadata = new DefaultMetadata(

        } else if (version.endsWith(SNAPSHOT)) {
            WorkspaceReader workspace = session.getWorkspaceReader();
            if (workspace != null && workspace.findVersions(artifact).contains(version)) {
                metadata = null;
                result.setRepository(workspace.getRepository());
            } else {
                metadata = new DefaultMetadata(

                    return outcome;
                }

                @Nullable
                @Override
                public Object getOutput(File workspace) {
                    return work.loadAlreadyProducedOutput(workspace);
                }
            };
        }
    }

    /**
     * The way the outputs have been produced.
     */
    enum ExecutionOutcome {
        /**

	// Use $GOROOT/pkg/bootstrap as the bootstrap workspace root.
	// We use a subdirectory of $GOROOT/pkg because that's the
	// space within $GOROOT where we store all generated objects.
	// We could use a temporary directory outside $GOROOT instead,
	// but it is easier to debug on failure if the files are in a known location.
	workspace := pathf("%s/pkg/bootstrap", goroot)
	xremoveall(workspace)
	xatexit(func() { xremoveall(workspace) })

cd $GOPATH/src

go list all # all includes both modules
stdout 'example.com/a'
stdout 'example.com/b'

# -mod can only be set to readonly in workspace mode
go list -mod=readonly all
! go list -mod=mod all
stderr '^go: -mod may only be set to readonly or vendor when in workspace mode'
env GOWORK=off
go list -mod=mod all
env GOWORK=

# Test that duplicates in the use list return an error
cp go.work go.work.backup