! stderr 'internal error'
stderr '^importstd[/\\]x.go:3:8: "std" is not an importable package; see ''go help packages''$'


# Not even if such a path is theoretically provided by a (necessarily replaced) module.

go mod edit -replace std@v0.1.0=./modstd
go mod edit -require std@v0.1.0

! go list -deps ./importstd
stderr '^importstd[/\\]x.go:3:8: "std" is not an importable package; see ''go help packages''$'


-- go.mod --

        then:
        output == "Here is a single line with continuations \\and \\ slashes\\\t\n too\\ \n."
    }

    def "replaces inline comments with space"() {
        when:
        input = """
Here/* comment */is a string/*
multiline
comment
here */that contains/**

# go clean -modcache can delete read-only dependencies
go clean -modcache
! exists $GOPATH/pkg/mod/rsc.io/quote@v1.5.2

# list {{.Dir}} shows replaced directories
cp go.mod2 go.mod
go list -mod=mod -f {{.Dir}} rsc.io/quote
go list -m -f '{{.Path}} {{.Version}} {{.Dir}}{{with .Replace}} {{.GoMod}} => {{.Version}} {{.Dir}} {{.GoMod}}{{end}}' all
stdout 'mod[\\/]rsc.io[\\/]quote@v1.5.1'

    /**
     * Adds a replacement string for the given input character. The specified character will be
     * replaced by the given string whenever it occurs in the input, irrespective of whether it lies
     * inside or outside the 'safe' range.
     *
     * @param c the character to be replaced
     * @param replacement the string to replace the given character
     * @return the builder instance

        def collection2 = new TestCompositeFileCollection(source2)

        def filtered = collection.filter(spec)

        when:
        def replaced = filtered.replace(other, {})
        def replaced2 = filtered.replace(collection, { collection2 })

        then:
        replaced.is(filtered)
        replaced2 != filtered
        0 * _
    }

    private class TestCompositeFileCollection extends CompositeFileCollection {

    /**
     * Adds a replacement string for the given input character. The specified character will be
     * replaced by the given string whenever it occurs in the input, irrespective of whether it lies
     * inside or outside the 'safe' range.
     *
     * @param c the character to be replaced
     * @param replacement the string to replace the given character
     * @return the builder instance

}

// Propagates a resource usage across the graph where
// 'user_op' uses a resource and is passed to this op at 'argument_index'.
// This resource should be replaced by 'value'.
// Output params:
// - work_list: Is updated with new regions to process that is called
//   by 'user_op';
// - arguments_to_erase: Captures updates to the graph - which arguments
//   to remove from the op;

import org.gradle.api.NonNullApi;
import org.gradle.internal.hash.ChecksumService;

import java.io.File;

/**
 * Assumes that files do not need to be replaced in the filestore.
 *
 * Can be used as an optimisation if path contains a checksum of the file, as there is no point to perform the replace in that circumstance.
 */
@NonNullApi
public class UniquePathKeyFileStore extends DefaultPathKeyFileStore {

 *
 * <p>This annotation replaces {@literal @}{@link groovy.test.NotYetImplemented}.
 * The problem with {@code NotYetImplemented} is that it succeeds no matter what causes the marked test
 * to fail. Tests like that can pass because the expected failure is still present, or even if the
 * expected failure is replaced by some other failure. It's better to write a test that explicitly

        collection.from(collection1, collection2)

        when:
        def replaced = collection.replace(collection1, supplier)

        then:
        replaced != collection
        replaced.sourceCollections == [replaced1, collection2]

        1 * collection1.replace(collection1, supplier) >> replaced1
        1 * collection2.replace(collection1, supplier) >> collection2
        0 * _
    }