stdout /non-exist/gopath

# go env -w does not override OS environment, and warns about that
env GOPATH=$root/other
go env -w GOPATH=$root/non-exist/gopath2
stderr 'warning: go env -w GOPATH=... does not override conflicting OS environment variable'
go env GOPATH
stdout $root/other

# but go env -w does do the update, and unsetting the env var exposes the change
env GOPATH=
go env GOPATH
stdout $root/non-exist/gopath2

        }

        then:
        outputEquals """
Type 'Whatever' property 'prop' has conflicting type annotations declared: @Input, @Output.

Reason: The different annotations have different semantics and Gradle cannot determine which one to pick.

Possible solution: Choose between one of the conflicting annotations.

${validationMessage("conflicting_annotations")}
"""
    }

         isa<TF::IdentityOp, TF::IdentityNOp, TF::ShapeOp>(op);
}

// Finds nonconflicting TPU device for an operation from its operands. If an
// operand has no device or a non TPU device, or if there are conflicting
// devices, and empty StringRef will be returned. Control dependencies,
// NextIteration.Source -> NextIteration.Sink token dependencies, and
// LoopCond -> Switch data dependencies are ignored.

        is ConeKotlinTypeProjectionIn -> "in ${type.renderTypeAsKotlinType()}"
        is ConeKotlinTypeProjectionOut -> "out ${type.renderTypeAsKotlinType()}"
        is ConeKotlinTypeConflictingProjection -> "CONFLICTING-PROJECTION ${type.renderTypeAsKotlinType()}"
        is ConeKotlinType -> renderTypeAsKotlinType()
    }

    private object DummyScopeProvider : FirScopeProvider() {
        override fun getUseSiteMemberScope(

                constraint('org:c:{strictly 1.0}', 'org:c:1.0')
            }
        }
    }

    @RequiredFeature(feature=GradleMetadataResolveRunner.GRADLE_METADATA, value="true")
    def "conflicting version constraints fail resolution"() {
        given:
        repository {
            'org:a:1.0' {
                dependsOn(group: 'org', artifact: 'b', version: '1.0')

	annotations := map[string]string{}

	// Kubelet always overrides device plugin annotations if they are conflicting
	for _, a := range opts.Annotations {
		annotations[a.Name] = a.Value
	}

	annotations[containerHashLabel] = strconv.FormatUint(kubecontainer.HashContainer(container), 16)

	PersistOldestWinsHeuristicForVirtualServiceHostMatching = env.Register("PERSIST_OLDEST_FIRST_HEURISTIC_FOR_VIRTUAL_SERVICE_HOST_MATCHING", false,
		"If enabled, istiod will persist the oldest first heuristic for subtly conflicting traffic policy selection"+
			"(such as with overlapping wildcard hosts)").Get()

	Enable100ContinueHeaders = env.Register("ENABLE_100_CONTINUE_HEADERS", true,

### There are no limits on how many server pools can be combined

```

                string: NamedString(name=foo, value=bar)
                long: NamedLong(name=ltuae, value=42)
                """
            )
        )
    }

    @Test
    fun `conflicting extensions across build scripts with same body`() {

        withFolders {

            "buildSrc" {

                withKotlinDslPlugin()

                "src/main/kotlin" {

  - name: "ConflictingMeshGatewayVirtualServiceHosts"
    code: IST0109
    level: Error
    description: "Conflicting hosts on VirtualServices associated with mesh gateway"
    template: "The VirtualServices %s associated with mesh gateway define the same host %s which can lead to undefined behavior. This can be fixed by merging the conflicting VirtualServices into a single resource."
    args:
      - name: virtualServices
        type: string