stdout '^rsc.io/quote v1.5.1$'

# get excluded version
cp go.exclude.mod go.exclude.mod.orig
! go get -modfile=go.exclude.mod rsc.io/quote@v1.5.0
stderr '^go: rsc.io/quote@v1.5.0: excluded by go.mod$'

# get non-excluded version
cp go.exclude.mod.orig go.exclude.mod
go get -modfile=go.exclude.mod rsc.io/quote@v1.5.1
stderr 'rsc.io/quote v1.5.1'

# get query with excluded version
cp go.exclude.mod.orig go.exclude.mod

func (c Clusters) Primaries(excluded ...Cluster) Clusters {
	return c.filterClusters(func(cc Cluster) bool {
		return cc.IsPrimary()
	}, exclude(excluded...))
}

// Exclude returns all clusters not given as input.
func (c Clusters) Exclude(excluded ...Cluster) Clusters {
	return c.filterClusters(func(cc Cluster) bool {
		return true
	}, exclude(excluded...))
}

        'excluded on b'    | [[module: 'd']] | []              | ['a', 'b', 'c', 'd']
        'excluded on c'    | []              | [[module: 'd']] | ['a', 'b', 'c', 'd']
        'excluded on both' | [[module: 'd']] | [[module: 'd']] | ['a', 'b', 'c']
    }

    /**
     * When a module is depended on via a single chained path, it is excluded if excluded on any of the links in that path.
     *

 * Within a process, only one thread is allowed write access to a given expanded directory. This is to avoid concurrent writes
 * to the same expanded directory.
 *
 * Multiple threads are allowed to extract into different expanded directories concurrently.
 * <p>
 * There currently are no checks on modifications to files in the expanded directory. This can cause problems if the expanded directory is used

 */

package org.jetbrains.kotlin.analysis.api.renderer.types

/**
 * [KaExpandedTypeRenderingMode] controls how [KaTypeRenderer] renders expanded types (with an associated abbreviated type) and type aliases
 * which can still be expanded.
 */
public enum class KaExpandedTypeRenderingMode {
    /**
     * Renders only the abbreviated type as-is, e.g. `foo.bar.StringAlias`.
     */

// should intercept.
func Included() []schema.GroupResource {
	return slices.Clone(included)
}

// Excluded returns a copy of the list of resources that the expression-based admission controllers
// should ignore.
func Excluded() []schema.GroupResource {
	return slices.Clone(excluded)

    maven { url '${repo.uri}' }
}
configurations {
    excluded {
        exclude module: 'direct'
        exclude module: 'transitive'
    }
    extendedExcluded.extendsFrom excluded
}
dependencies {
    excluded 'org.gradle.test:external:1.0'
    excluded 'org.gradle.test:direct:1.0'
}

task test {
    def excluded = configurations.excluded
    def extendedExcluded = configurations.extendedExcluded

        FileHasher hasher = new DefaultFileHasher(new DefaultStreamHasher())
        def hash = hasher.hash(file("hello.zip"))
        def cachedFile = file("build/tmp/.cache/expanded/zip_${hash}/hello.txt")
        def otherFile = file("build/tmp/.cache/expanded/zip_${hash}/other.txt")

        buildFile << """
            abstract class CopyAndList extends DefaultTask {
                @Inject

    public val nullability: KaTypeNullability

    /**
     * The abbreviated type for this expanded [KaType], or `null` if this type has not been expanded from an abbreviated type or the
     * abbreviated type cannot be resolved.
     *
     * An abbreviated type is a type alias application that has been expanded to some other Kotlin type. For example, if we have a type

        then:
        !destination.toString().contains(TextUtil.windowsLineSeparator)
        destination.toString().contains(TextUtil.unixLineSeparator)
    }

    def "defaultJvmOpts is expanded properly in unix script"() {
        given:
        JavaAppStartScriptGenerationDetails details = createScriptGenerationDetails(['-Dfoo=bar', '-Xint'], 'bin')
        Writer destination = new StringWriter()

        when: