.append(remoteRepositories);

        return sb.toString();
    }

    public boolean isOffline() {
        return offline;
    }

    public ArtifactResolutionRequest setOffline(boolean offline) {
        this.offline = offline;

        return this;
    }

    public boolean isForceUpdate() {
        return forceUpdate;
    }

            t.doLast {
                println "offline: " + serviceRef.get()._buildState.startParameter.offline
            }
        """
        when:
        succeeds "t", "--configuration-cache"

        then:
        output.contains("offline: false")

        when:
        succeeds "t", "--configuration-cache", "--offline"

        then:
        output.contains("offline: true")
    }

        fails()
    }

    def "reasonable error message while --offline when applying a script with a query part"() {
        def url = "$server.uri/external.gradle?query"
        buildFile << """
            apply from: '$url'
            defaultTasks 'doStuff'
        """
        server.stop()
        expect:
        fails("--offline")
        failure.assertHasCause("Could not read script '$url'")
    }

	for _, b := range profile.Blocks {
		if b.StartLine > f.endLine || (b.StartLine == f.endLine && b.StartCol >= f.endCol) {
			// Past the end of the function.
			break
		}
		if b.EndLine < f.startLine || (b.EndLine == f.startLine && b.EndCol <= f.startCol) {
			// Before the beginning of the function
			continue
		}
		total += int64(b.NumStmt)

            output.text(prefix);
            prefixed = true;
        }
        output.text(text);
    }

    @Override
    protected void doEndLine(CharSequence endOfLine) {
        output.text(endOfLine);
    }

    @Override
    protected void doStartLine() {
        output.text(prefix);
    }

    @Override
    protected void doStyleChange(Style style) {
        output.style(style);

    def configurationCache = newConfigurationCacheFixture()

    def "offline flag is part of the cache key"() {
        when:
        configurationCacheRun "help"
        then:
        configurationCache.assertStateStored()

        when:
        configurationCacheRun "help", "--offline"
        then:
        configurationCache.assertStateStored()

            dependencies {
                conf "org:testA:+"
            }
        """

        when:
        fails 'checkDeps', '--offline'

        then:
        failure.assertHasCause("No cached version listing for org:testA:+ available for offline mode")

        when:
        repositoryInteractions {
            'org:testA:3' {
                expectResolve()
            }
        }

	"bytes"
	"context"
	"crypto/rand"
	"io"
	"os"
	"testing"
)

var erasureHealTests = []struct {
	dataBlocks, disks int

	// number of offline disks is also number of staleDisks for
	// erasure reconstruction in this test
	offDisks int

	// bad disks are online disks which return errors
	badDisks, badStaleDisks int

	blocksize, size int64
	algorithm       BitrotAlgorithm
	shouldFail      bool
}{

    }

    def "reuse cache for offline build"() {
        when:
        configurationCacheRun 'ok'

        then:
        configurationCache.assertStateStored()

        when:
        scriptFile << """
            print 'update remote script'
        """

        and:
        executer.withArgument("--offline")
        configurationCacheRun 'ok'

        then:

        this.moduleCacheRules = new ArrayList<>(policy.moduleCacheRules);
        this.artifactCacheRules = new ArrayList<>(policy.artifactCacheRules);
        this.offline = policy.offline;
        this.refresh = policy.refresh;
    }

    /**
     * Sets the validator to invoke prior to each mutation.
     */
    public void setMutationValidator(MutationValidator validator) {