cmp $WORK/modules-1.13.txt vendor/modules.txt

go list -mod=vendor -f {{.Dir}} -tags tools -e all
stdout '^'$WORK'[/\\]auto$'
stdout '^'$WORK'[/\\]auto[/\\]vendor[/\\]example.com[/\\]printversion$'
stdout '^'$WORK'[/\\]auto[/\\]vendor[/\\]example.com[/\\]version$'

# When the version is upgraded to 1.14, 'go mod vendor' should write a
# vendor/modules.txt with the updated 1.14 annotations.
go mod edit -go=1.14
go mod vendor

mkdir $WORK/other/bin
symlink $WORK/other/bin/go$GOEXE -> $WORK/new/bin/go$GOEXE
exec $WORK/bin/check$GOEXE $WORK/new/bin/go$GOEXE $WORK/new

rm $WORK/new/pkg

# Runtime GOROOT:
# Binaries built in the new tree should report the
# new tree when they call runtime.GOROOT.
symlink $WORK/new/src -> $TESTGOROOT/src
symlink $WORK/new/pkg -> $TESTGOROOT/pkg

                : calculateCachingStateWithNoCapturedInputs(work));

        cachingState.apply(
            enabled -> logCacheKey(enabled.getCacheKeyCalculatedState().getKey(), work),
            disabled -> logDisabledReasons(disabled.getDisabledReasons(), work)
        );

        UpToDateResult result = executeDelegate(work, context, cachingState);
        return new CachingResult(result, cachingState);
    }

# Regression test for https://go.dev/issue/51448.
# 'go work init . .. foo/bar' should produce a go.work file
# with the same paths as 'go work init; go work use -r ..',
# and it should have 'use .' rather than 'use ./.' inside.

cd dir

go work init . .. foo/bar
mv go.work go.work.init

go work init
go work use -r ..
cmp go.work go.work.init

cmpenv go.work $WORK/go.work.want

-- go.mod --
module example
go 1.18

        CachingResult result = performSkip(work, context);
        broadcastWorkInputs(work, true);
        return result;
    }

    abstract protected CachingResult performSkip(UnitOfWork work, C context);

    private CachingResult executeWithNonEmptySources(UnitOfWork work, C context) {
        broadcastWorkInputs(work, false);

cat q/go.mod
cp go.work.21 go.work
go list -f '{{.Module.GoVersion}} {{.DefaultGODEBUG}}'
! stdout panicnil
stdout randautoseed=0
rm go.work

# Go 1.20 workspace with Go 1.21 module cannot happen.
cp go.work.20 go.work
cp go.mod.21 go.mod
! go list -f '{{.Module.GoVersion}} {{.DefaultGODEBUG}}'
stderr 'go: module . listed in go.work file requires go >= 1.21'
rm go.work

        when:
        def result = step.execute(work, context)

        then:
        result == delegateResult

        _ * work.executionBehavior >> UnitOfWork.ExecutionBehavior.NON_INCREMENTAL
        1 * delegate.execute(work, _ as IncrementalChangesContext) >> { UnitOfWork work, IncrementalChangesContext delegateContext ->
            def changes = delegateContext.changes.get()

    }
    /**
     * Register a new item of asynchronous work with the provided build operation.
     *
     * @param operation - The build operation to associate the asynchronous work with
     * @param completion - The completion of the asynchronous work

        /**
         * Execute the unit of work using available optimizations like
         * up-to-date checks, build cache and incremental execution.
         */
        Result execute();

        /**
         * Load the unit of work from the given cache, or defer its execution.
         *
         * If the cache already contains the outputs for the given work, an already finished {@link Deferrable} will be returned.

import org.gradle.tooling.events.OperationType
import org.gradle.tooling.events.ProgressListener
import org.gradle.tooling.events.work.WorkItemFailureResult
import org.gradle.tooling.events.work.WorkItemFinishEvent
import org.gradle.tooling.events.work.WorkItemStartEvent
import org.gradle.tooling.events.work.WorkItemSuccessResult
import org.gradle.tooling.internal.protocol.InternalBuildProgressListener