Carlos Amedee <******@****.***> 1715265901 -0400

    %0 = "tf.ReadVariableOp"(%arg19)...

		case "msSGC":
			ekus = append(ekus, ExtKeyUsageMicrosoftServerGatedCrypto)
		case "any":
			ekus = append(ekus, ExtKeyUsageAny)
		case "other":
			unknowns = append(unknowns, asn1.ObjectIdentifier{2, 4, 1, 2, 3})
		default:
			return nil, nil, fmt.Errorf("unknown EKU %q", s)
		}
	}

	return
}

func TestConstraintCases(t *testing.T) {
	privateKeys := sync.Pool{
		New: func() any {

        succeeds()
    }

    def "reports read unknown property from configure closure"() {
        buildFile << """
tasks.help {
    println unknown
}
"""

        expect:
        fails()
        failure.assertHasCause("Could not get unknown property 'unknown' for task ':help' of type org.gradle.configuration.Help.")
    }

    def "reports set unknown property from configure closure"() {
        buildFile << """

var _ = http.Server{DoneChan: nil}  // ERROR "unknown field DoneChan in struct literal of type http.Server$|unknown field .?DoneChan.? in .?http.Server"

type foo struct {
	bar int
}

}

func _() {
	_ = S{Foo1: 0} // OK
	_ = S{Foo2 /* ERROR "unknown field Foo2 in struct literal of type S, but does have FoO2" */ : 0}
	_ = S{Foo3 /* ERROR "unknown field Foo3 in struct literal of type S, but does have foo3" */ : 0}
	_ = S{Foo4 /* ERROR "unknown field Foo4 in struct literal of type S, but does have foO4" */ : 0}

	_ = S{foo1 /* ERROR "unknown field foo1 in struct literal of type S, but does have Foo1" */ : 0}

cp go.work.badgodebug.txt go.work
! go list
stderr '^go.work:3: unknown godebug "foo"$'

cp go.work.unparsable.txt go.work
! go list
stderr '^go.work:5: unknown directive: notadirective'

cp go.work.firstlineerr.txt go.work
! go list
stderr '^go.work:1: unknown godebug "bar"$'

cp go.work.firsterrlisted.txt go.work
! go list
stderr '^go.work:1: unknown godebug "baz"$'

-- foo/go.mod --
module example.com/foo

        when:
        thread.blockUntil.unknown

        then:
        IllegalStateException e = thrown()
        e.message == "Timeout waiting for instant 'unknown' to be defined by another thread."

        when:
        async {
            thread.blockUntil.unknown
        }

        then:
        e = thrown()
        e.message == "Timeout waiting for instant 'unknown' to be defined by another thread."

	if gk, ok := getGvk(ptr.Empty[T]()); ok {
		gr, ok := gvk.ToGVR(gk)
		if !ok {
			panic(fmt.Sprintf("unknown GVR for GVK %v", gk))
		}
		return gr
	}
	if rp := typemap.Get[RegisterType[T]](registeredTypes); rp != nil {
		return (*rp).GetGVR()
	}
	panic("unknown kind: " + ptr.TypeName[T]())
}

func MustGVKFromType[T runtime.Object]() (cfg config.GroupVersionKind) {

! go env -w GOEXPERIMENT=badexp
stderr 'unknown GOEXPERIMENT badexp'
go env -w GOEXPERIMENT=fieldtrack

# go env -w and go env -u work on unknown fields already in the go/env file
cp bad.env $GOENV
go env GOENV
cat $GOENV
go env
! stdout UNKNOWN
go env UNKNOWN
stdout yes
go env -w UNKNOWN=maybe
go env UNKNOWN
stdout maybe
go env -u UNKNOWN
go env UNKNOWN
! stdout . # gone

-- bad.env --