},
	{
		IntroducedVersion: version.MajorMinor(1, 27),
		EnvOptions: []cel.EnvOption{
			library.Authz(),
		},
	},
	{
		IntroducedVersion: version.MajorMinor(1, 28),
		EnvOptions: []cel.EnvOption{
			cel.CrossTypeNumericComparisons(true),
			cel.OptionalTypes(),
			library.Quantity(),
		},
	},
	// add the new validator in 1.29
	{
		IntroducedVersion: version.MajorMinor(1, 29),
		EnvOptions: []cel.EnvOption{

			readFileFunc: func(_ string) ([]byte, error) {
				return []byte("5.15.0-84-generic"), nil
			},
			expected: version.MajorMinor(5, 15),
		},
		{
			name: "valid os-release file",
			readFileFunc: func(_ string) ([]byte, error) {
				return []byte("5.4.0-128-generic"), nil
			},
			expected: version.MajorMinor(5, 4),
		},
		{
			name: "failed to read os-release file",
			readFileFunc: func(_ string) ([]byte, error) {

	}

	var v unix.Utsname
	err := unix.Uname(&v)
	if err != nil {
		telemetry.Inc(fmt.Sprintf("go/platform/host/%s/version:unknown-uname-error", runtime.GOOS))
		return
	}
	major, minor, ok := majorMinor(convert(v.Release[:]))
	if runtime.GOOS == "aix" {
		major, minor, ok = convert(v.Version[:]), convert(v.Release[:]), true
	}
	if !ok {

		t.Run(tt.name, func(t *testing.T) {
			major, minor, err := MajorMinor(tt.v)
			if (err != nil) != tt.expectErr {
				t.Errorf("MajorMinor() error = %v, wantErr %v", err, tt.expectErr)
				return
			}
			if major != tt.expectMajor {
				t.Errorf("MajorMinor() major = %v, want %v", major, tt.expectMajor)
			}
			if minor != tt.expectMinor {
				t.Errorf("MajorMinor() minor = %v, want %v", minor, tt.expectMinor)
			}
		})
	}

	pv, ok := parse(v)
	if !ok {
		return ""
	}
	return v[:1+len(pv.major)]
}

// MajorMinor returns the major.minor version prefix of the semantic version v.
// For example, MajorMinor("v2.1.0") == "v2.1".
// If v is an invalid semantic version string, MajorMinor returns the empty string.
func MajorMinor(v string) string {
	pv, ok := parse(v)
	if !ok {
		return ""
	}
	i := 1 + len(pv.major)

var leadingDigits = regexp.MustCompile(`^(\d+)`)

// MajorMinor parses a numeric major/minor version from the provided version info.
// The minor version drops all characters after the first non-digit character:
//
//	version.Info{Major:"1", Minor:"2+"} -> 1,2
//	version.Info{Major:"1", Minor:"2.3-build4"} -> 1,2
func MajorMinor(v version.Info) (int, int, error) {
	major, err := strconv.Atoi(v.Major)
	if err != nil {

func mustCreateEnv(t testing.TB, envOptions ...cel.EnvOption) *cel.Env {
	envSet, err := environment.MustBaseEnvSet(environment.DefaultCompatibilityVersion(), true).
		Extend(environment.VersionedOptions{
			IntroducedVersion: version.MajorMinor(1, 30),
			EnvOptions:        envOptions,
		})
	if err != nil {
		t.Fatalf("fail to create env set: %v", err)
	}
	env, err := envSet.Env(environment.StoredExpressions)
	if err != nil {

func ModMajorMinor(path, vers string) string {
	if IsToolchain(path) {
		if path == "toolchain" {
			return "go" + Lang(FromToolchain(vers))
		}
		return Lang(vers)
	}
	return semver.MajorMinor(vers)

	env, err := environment.MustBaseEnvSet(environment.DefaultCompatibilityVersion(), true).Extend(
		environment.VersionedOptions{
			IntroducedVersion: version.MajorMinor(1, 26),
			EnvOptions: []cel.EnvOption{
				cel.Variable("foo", fooType.CelType()),
				cel.Variable("bar", barType.CelType()),
			},
			DeclTypes: []*apiservercel.DeclType{
				fooType,
				barType,

	envSet, err := environment.MustBaseEnvSet(environment.DefaultCompatibilityVersion(), true).
		Extend(environment.VersionedOptions{
			IntroducedVersion: version.MajorMinor(1, 30),
			EnvOptions:        envOptions,
		})
	if err != nil {
		t.Fatalf("fail to create env set: %v", err)
	}
	env, err := envSet.Env(environment.StoredExpressions)
	if err != nil {