--- /dev/null
+pkg go/version, func Compare(string, string) int #62039
+pkg go/version, func IsValid(string) bool #62039
+pkg go/version, func Lang(string) string #62039
package gover
import (
- "cmp"
+ "internal/gover"
)
-// A version is a parsed Go version: major[.minor[.patch]][kind[pre]]
-// The numbers are the original decimal strings to avoid integer overflows
-// and since there is very little actual math. (Probably overflow doesn't matter in practice,
-// but at the time this code was written, there was an existing test that used
-// go1.99999999999, which does not fit in an int on 32-bit platforms.
-// The "big decimal" representation avoids the problem entirely.)
-type version struct {
- major string // decimal
- minor string // decimal or ""
- patch string // decimal or ""
- kind string // "", "alpha", "beta", "rc"
- pre string // decimal or ""
-}
-
// Compare returns -1, 0, or +1 depending on whether
// x < y, x == y, or x > y, interpreted as toolchain versions.
// The versions x and y must not begin with a "go" prefix: just "1.21" not "go1.21".
// Malformed versions compare less than well-formed versions and equal to each other.
// The language version "1.21" compares less than the release candidate and eventual releases "1.21rc1" and "1.21.0".
func Compare(x, y string) int {
- vx := parse(x)
- vy := parse(y)
-
- if c := cmpInt(vx.major, vy.major); c != 0 {
- return c
- }
- if c := cmpInt(vx.minor, vy.minor); c != 0 {
- return c
- }
- if c := cmpInt(vx.patch, vy.patch); c != 0 {
- return c
- }
- if c := cmp.Compare(vx.kind, vy.kind); c != 0 { // "" < alpha < beta < rc
- return c
- }
- if c := cmpInt(vx.pre, vy.pre); c != 0 {
- return c
- }
- return 0
+ return gover.Compare(x, y)
}
// Max returns the maximum of x and y interpreted as toolchain versions,
// compared using Compare.
// If x and y compare equal, Max returns x.
func Max(x, y string) string {
- if Compare(x, y) < 0 {
- return y
- }
- return x
-}
-
-// Toolchain returns the maximum of x and y interpreted as toolchain names,
-// compared using Compare(FromToolchain(x), FromToolchain(y)).
-// If x and y compare equal, Max returns x.
-func ToolchainMax(x, y string) string {
- if Compare(FromToolchain(x), FromToolchain(y)) < 0 {
- return y
- }
- return x
+ return gover.Max(x, y)
}
// IsLang reports whether v denotes the overall Go language version
// meaning that Go 1.21rc1 and Go 1.21.0 will both handle go.mod files that
// say "go 1.21", but Go 1.21rc1 will not handle files that say "go 1.21.0".
func IsLang(x string) bool {
- v := parse(x)
- return v != version{} && v.patch == "" && v.kind == "" && v.pre == ""
+ return gover.IsLang(x)
}
// Lang returns the Go language version. For example, Lang("1.2.3") == "1.2".
func Lang(x string) string {
- v := parse(x)
- if v.minor == "" {
- return v.major
- }
- return v.major + "." + v.minor
+ return gover.Lang(x)
}
// IsPrerelease reports whether v denotes a Go prerelease version.
func IsPrerelease(x string) bool {
- return parse(x).kind != ""
+ return gover.Parse(x).Kind != ""
}
// Prev returns the Go major release immediately preceding v,
// Prev("1.2") = "1.1"
// Prev("1.3rc4") = "1.2"
func Prev(x string) string {
- v := parse(x)
- if cmpInt(v.minor, "1") <= 0 {
- return v.major
+ v := gover.Parse(x)
+ if gover.CmpInt(v.Minor, "1") <= 0 {
+ return v.Major
}
- return v.major + "." + decInt(v.minor)
+ return v.Major + "." + gover.DecInt(v.Minor)
}
// IsValid reports whether the version x is valid.
func IsValid(x string) bool {
- return parse(x) != version{}
-}
-
-// parse parses the Go version string x into a version.
-// It returns the zero version if x is malformed.
-func parse(x string) version {
- var v version
-
- // Parse major version.
- var ok bool
- v.major, x, ok = cutInt(x)
- if !ok {
- return version{}
- }
- if x == "" {
- // Interpret "1" as "1.0.0".
- v.minor = "0"
- v.patch = "0"
- return v
- }
-
- // Parse . before minor version.
- if x[0] != '.' {
- return version{}
- }
-
- // Parse minor version.
- v.minor, x, ok = cutInt(x[1:])
- if !ok {
- return version{}
- }
- if x == "" {
- // Patch missing is same as "0" for older versions.
- // Starting in Go 1.21, patch missing is different from explicit .0.
- if cmpInt(v.minor, "21") < 0 {
- v.patch = "0"
- }
- return v
- }
-
- // Parse patch if present.
- if x[0] == '.' {
- v.patch, x, ok = cutInt(x[1:])
- if !ok || x != "" {
- // Note that we are disallowing prereleases (alpha, beta, rc) for patch releases here (x != "").
- // Allowing them would be a bit confusing because we already have:
- // 1.21 < 1.21rc1
- // But a prerelease of a patch would have the opposite effect:
- // 1.21.3rc1 < 1.21.3
- // We've never needed them before, so let's not start now.
- return version{}
- }
- return v
- }
-
- // Parse prerelease.
- i := 0
- for i < len(x) && (x[i] < '0' || '9' < x[i]) {
- if x[i] < 'a' || 'z' < x[i] {
- return version{}
- }
- i++
- }
- if i == 0 {
- return version{}
- }
- v.kind, x = x[:i], x[i:]
- if x == "" {
- return v
- }
- v.pre, x, ok = cutInt(x)
- if !ok || x != "" {
- return version{}
- }
-
- return v
-}
-
-// cutInt scans the leading decimal number at the start of x to an integer
-// and returns that value and the rest of the string.
-func cutInt(x string) (n, rest string, ok bool) {
- i := 0
- for i < len(x) && '0' <= x[i] && x[i] <= '9' {
- i++
- }
- if i == 0 || x[0] == '0' && i != 1 {
- return "", "", false
- }
- return x[:i], x[i:], true
-}
-
-// cmpInt returns cmp.Compare(x, y) interpreting x and y as decimal numbers.
-// (Copied from golang.org/x/mod/semver's compareInt.)
-func cmpInt(x, y string) int {
- if x == y {
- return 0
- }
- if len(x) < len(y) {
- return -1
- }
- if len(x) > len(y) {
- return +1
- }
- if x < y {
- return -1
- } else {
- return +1
- }
-}
-
-// decInt returns the decimal string decremented by 1, or the empty string
-// if the decimal is all zeroes.
-// (Copied from golang.org/x/mod/module's decDecimal.)
-func decInt(decimal string) string {
- // Scan right to left turning 0s to 9s until you find a digit to decrement.
- digits := []byte(decimal)
- i := len(digits) - 1
- for ; i >= 0 && digits[i] == '0'; i-- {
- digits[i] = '9'
- }
- if i < 0 {
- // decimal is all zeros
- return ""
- }
- if i == 0 && digits[i] == '1' && len(digits) > 1 {
- digits = digits[1:]
- } else {
- digits[i]--
- }
- return string(digits)
+ return gover.IsValid(x)
}
{"1.99999999999999998", "1.99999999999999999", -1},
}
-func TestParse(t *testing.T) { test1(t, parseTests, "parse", parse) }
-
-var parseTests = []testCase1[string, version]{
- {"1", version{"1", "0", "0", "", ""}},
- {"1.2", version{"1", "2", "0", "", ""}},
- {"1.2.3", version{"1", "2", "3", "", ""}},
- {"1.2rc3", version{"1", "2", "", "rc", "3"}},
- {"1.20", version{"1", "20", "0", "", ""}},
- {"1.21", version{"1", "21", "", "", ""}},
- {"1.21rc3", version{"1", "21", "", "rc", "3"}},
- {"1.21.0", version{"1", "21", "0", "", ""}},
- {"1.24", version{"1", "24", "", "", ""}},
- {"1.24rc3", version{"1", "24", "", "rc", "3"}},
- {"1.24.0", version{"1", "24", "0", "", ""}},
- {"1.999testmod", version{"1", "999", "", "testmod", ""}},
- {"1.99999999999999999", version{"1", "99999999999999999", "", "", ""}},
-}
-
func TestLang(t *testing.T) { test1(t, langTests, "Lang", Lang) }
var langTests = []testCase1[string, string]{
{"1.2rc3", "1.2"},
{"1.2.3", "1.2"},
{"1.2", "1.2"},
- {"1", "1.0"},
+ {"1", "1"},
{"1.999testmod", "1.999"},
}
return FromToolchain(name)
}
+// ToolchainMax returns the maximum of x and y interpreted as toolchain names,
+// compared using Compare(FromToolchain(x), FromToolchain(y)).
+// If x and y compare equal, Max returns x.
+func ToolchainMax(x, y string) string {
+ if Compare(FromToolchain(x), FromToolchain(y)) < 0 {
+ return y
+ }
+ return x
+}
+
// Startup records the information that went into the startup-time version switch.
// It is initialized by switchGoToolchain.
var Startup struct {
# go parser and friends.
FMT
+ < internal/gover
+ < go/version
< go/token
< go/scanner
< go/ast
--- /dev/null
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package version provides operations on [Go versions].
+//
+// [Go versions]: https://go.dev/doc/toolchain#version
+package version // import "go/version"
+
+import "internal/gover"
+
+// stripGo converts from a "go1.21" version to a "1.21" version.
+// If v does not start with "go", stripGo returns the empty string (a known invalid version).
+func stripGo(v string) string {
+ if len(v) < 2 || v[:2] != "go" {
+ return ""
+ }
+ return v[2:]
+}
+
+// Lang returns the Go language version for version x.
+// If x is not a valid version, Lang returns the empty string.
+// For example:
+//
+// Lang("go1.21rc2") = "go1.21"
+// Lang("go1.21.2") = "go1.21"
+// Lang("go1.21") = "go1.21"
+// Lang("go1") = "go1"
+// Lang("bad") = ""
+// Lang("1.21") = ""
+func Lang(x string) string {
+ v := gover.Lang(stripGo(x))
+ if v == "" {
+ return ""
+ }
+ return x[:2+len(v)] // "go"+v without allocation
+}
+
+// Compare returns -1, 0, or +1 depending on whether
+// x < y, x == y, or x > y, interpreted as Go versions.
+// The versions x and y must begin with a "go" prefix: "go1.21" not "1.21".
+// Invalid versions, including the empty string, compare less than
+// valid versions and equal to each other.
+// The language version "go1.21" compares less than the
+// release candidate and eventual releases "go1.21rc1" and "go1.21.0".
+// Custom toolchain suffixes are ignored during comparison:
+// "go1.21.0" and "go1.21.0-bigcorp" are equal.
+func Compare(x, y string) int {
+ return gover.Compare(stripGo(x), stripGo(y))
+}
+
+// IsValid reports whether the version x is valid.
+func IsValid(x string) bool {
+ return gover.IsValid(stripGo(x))
+}
--- /dev/null
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package version
+
+import (
+ "reflect"
+ "testing"
+)
+
+func TestCompare(t *testing.T) { test2(t, compareTests, "Compare", Compare) }
+
+var compareTests = []testCase2[string, string, int]{
+ {"", "", 0},
+ {"x", "x", 0},
+ {"", "x", 0},
+ {"1", "1.1", 0},
+ {"go1", "go1.1", -1},
+ {"go1.5", "go1.6", -1},
+ {"go1.5", "go1.10", -1},
+ {"go1.6", "go1.6.1", -1},
+ {"go1.19", "go1.19.0", 0},
+ {"go1.19rc1", "go1.19", -1},
+ {"go1.20", "go1.20.0", 0},
+ {"go1.20rc1", "go1.20", -1},
+ {"go1.21", "go1.21.0", -1},
+ {"go1.21", "go1.21rc1", -1},
+ {"go1.21rc1", "go1.21.0", -1},
+ {"go1.6", "go1.19", -1},
+ {"go1.19", "go1.19.1", -1},
+ {"go1.19rc1", "go1.19", -1},
+ {"go1.19rc1", "go1.19.1", -1},
+ {"go1.19rc1", "go1.19rc2", -1},
+ {"go1.19.0", "go1.19.1", -1},
+ {"go1.19rc1", "go1.19.0", -1},
+ {"go1.19alpha3", "go1.19beta2", -1},
+ {"go1.19beta2", "go1.19rc1", -1},
+ {"go1.1", "go1.99999999999999998", -1},
+ {"go1.99999999999999998", "go1.99999999999999999", -1},
+}
+
+func TestLang(t *testing.T) { test1(t, langTests, "Lang", Lang) }
+
+var langTests = []testCase1[string, string]{
+ {"bad", ""},
+ {"go1.2rc3", "go1.2"},
+ {"go1.2.3", "go1.2"},
+ {"go1.2", "go1.2"},
+ {"go1", "go1"},
+ {"go1.999testmod", "go1.999"},
+}
+
+func TestIsValid(t *testing.T) { test1(t, isValidTests, "IsValid", IsValid) }
+
+var isValidTests = []testCase1[string, bool]{
+ {"", false},
+ {"1.2.3", false},
+ {"go1.2rc3", true},
+ {"go1.2.3", true},
+ {"go1.999testmod", true},
+ {"go1.600+auto", false},
+ {"go1.22", true},
+ {"go1.21.0", true},
+ {"go1.21rc2", true},
+ {"go1.21", true},
+ {"go1.20.0", true},
+ {"go1.20", true},
+ {"go1.19", true},
+ {"go1.3", true},
+ {"go1.2", true},
+ {"go1", true},
+}
+
+type testCase1[In, Out any] struct {
+ in In
+ out Out
+}
+
+type testCase2[In1, In2, Out any] struct {
+ in1 In1
+ in2 In2
+ out Out
+}
+
+func test1[In, Out any](t *testing.T, tests []testCase1[In, Out], name string, f func(In) Out) {
+ t.Helper()
+ for _, tt := range tests {
+ if out := f(tt.in); !reflect.DeepEqual(out, tt.out) {
+ t.Errorf("%s(%v) = %v, want %v", name, tt.in, out, tt.out)
+ }
+ }
+}
+
+func test2[In1, In2, Out any](t *testing.T, tests []testCase2[In1, In2, Out], name string, f func(In1, In2) Out) {
+ t.Helper()
+ for _, tt := range tests {
+ if out := f(tt.in1, tt.in2); !reflect.DeepEqual(out, tt.out) {
+ t.Errorf("%s(%+v, %+v) = %+v, want %+v", name, tt.in1, tt.in2, out, tt.out)
+ }
+ }
+}
--- /dev/null
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package gover implements support for Go toolchain versions like 1.21.0 and 1.21rc1.
+// (For historical reasons, Go does not use semver for its toolchains.)
+// This package provides the same basic analysis that golang.org/x/mod/semver does for semver.
+//
+// The go/version package should be imported instead of this one when possible.
+// Note that this package works on "1.21" while go/version works on "go1.21".
+package gover
+
+import (
+ "cmp"
+)
+
+// A Version is a parsed Go version: major[.Minor[.Patch]][kind[pre]]
+// The numbers are the original decimal strings to avoid integer overflows
+// and since there is very little actual math. (Probably overflow doesn't matter in practice,
+// but at the time this code was written, there was an existing test that used
+// go1.99999999999, which does not fit in an int on 32-bit platforms.
+// The "big decimal" representation avoids the problem entirely.)
+type Version struct {
+ Major string // decimal
+ Minor string // decimal or ""
+ Patch string // decimal or ""
+ Kind string // "", "alpha", "beta", "rc"
+ Pre string // decimal or ""
+}
+
+// Compare returns -1, 0, or +1 depending on whether
+// x < y, x == y, or x > y, interpreted as toolchain versions.
+// The versions x and y must not begin with a "go" prefix: just "1.21" not "go1.21".
+// Malformed versions compare less than well-formed versions and equal to each other.
+// The language version "1.21" compares less than the release candidate and eventual releases "1.21rc1" and "1.21.0".
+func Compare(x, y string) int {
+ vx := Parse(x)
+ vy := Parse(y)
+
+ if c := CmpInt(vx.Major, vy.Major); c != 0 {
+ return c
+ }
+ if c := CmpInt(vx.Minor, vy.Minor); c != 0 {
+ return c
+ }
+ if c := CmpInt(vx.Patch, vy.Patch); c != 0 {
+ return c
+ }
+ if c := cmp.Compare(vx.Kind, vy.Kind); c != 0 { // "" < alpha < beta < rc
+ return c
+ }
+ if c := CmpInt(vx.Pre, vy.Pre); c != 0 {
+ return c
+ }
+ return 0
+}
+
+// Max returns the maximum of x and y interpreted as toolchain versions,
+// compared using Compare.
+// If x and y compare equal, Max returns x.
+func Max(x, y string) string {
+ if Compare(x, y) < 0 {
+ return y
+ }
+ return x
+}
+
+// IsLang reports whether v denotes the overall Go language version
+// and not a specific release. Starting with the Go 1.21 release, "1.x" denotes
+// the overall language version; the first release is "1.x.0".
+// The distinction is important because the relative ordering is
+//
+// 1.21 < 1.21rc1 < 1.21.0
+//
+// meaning that Go 1.21rc1 and Go 1.21.0 will both handle go.mod files that
+// say "go 1.21", but Go 1.21rc1 will not handle files that say "go 1.21.0".
+func IsLang(x string) bool {
+ v := Parse(x)
+ return v != Version{} && v.Patch == "" && v.Kind == "" && v.Pre == ""
+}
+
+// Lang returns the Go language version. For example, Lang("1.2.3") == "1.2".
+func Lang(x string) string {
+ v := Parse(x)
+ if v.Minor == "" || v.Major == "1" && v.Minor == "0" {
+ return v.Major
+ }
+ return v.Major + "." + v.Minor
+}
+
+// IsValid reports whether the version x is valid.
+func IsValid(x string) bool {
+ return Parse(x) != Version{}
+}
+
+// Parse parses the Go version string x into a version.
+// It returns the zero version if x is malformed.
+func Parse(x string) Version {
+ var v Version
+
+ // Parse major version.
+ var ok bool
+ v.Major, x, ok = cutInt(x)
+ if !ok {
+ return Version{}
+ }
+ if x == "" {
+ // Interpret "1" as "1.0.0".
+ v.Minor = "0"
+ v.Patch = "0"
+ return v
+ }
+
+ // Parse . before minor version.
+ if x[0] != '.' {
+ return Version{}
+ }
+
+ // Parse minor version.
+ v.Minor, x, ok = cutInt(x[1:])
+ if !ok {
+ return Version{}
+ }
+ if x == "" {
+ // Patch missing is same as "0" for older versions.
+ // Starting in Go 1.21, patch missing is different from explicit .0.
+ if CmpInt(v.Minor, "21") < 0 {
+ v.Patch = "0"
+ }
+ return v
+ }
+
+ // Parse patch if present.
+ if x[0] == '.' {
+ v.Patch, x, ok = cutInt(x[1:])
+ if !ok || x != "" {
+ // Note that we are disallowing prereleases (alpha, beta, rc) for patch releases here (x != "").
+ // Allowing them would be a bit confusing because we already have:
+ // 1.21 < 1.21rc1
+ // But a prerelease of a patch would have the opposite effect:
+ // 1.21.3rc1 < 1.21.3
+ // We've never needed them before, so let's not start now.
+ return Version{}
+ }
+ return v
+ }
+
+ // Parse prerelease.
+ i := 0
+ for i < len(x) && (x[i] < '0' || '9' < x[i]) {
+ if x[i] < 'a' || 'z' < x[i] {
+ return Version{}
+ }
+ i++
+ }
+ if i == 0 {
+ return Version{}
+ }
+ v.Kind, x = x[:i], x[i:]
+ if x == "" {
+ return v
+ }
+ v.Pre, x, ok = cutInt(x)
+ if !ok || x != "" {
+ return Version{}
+ }
+
+ return v
+}
+
+// cutInt scans the leading decimal number at the start of x to an integer
+// and returns that value and the rest of the string.
+func cutInt(x string) (n, rest string, ok bool) {
+ i := 0
+ for i < len(x) && '0' <= x[i] && x[i] <= '9' {
+ i++
+ }
+ if i == 0 || x[0] == '0' && i != 1 { // no digits or unnecessary leading zero
+ return "", "", false
+ }
+ return x[:i], x[i:], true
+}
+
+// CmpInt returns cmp.Compare(x, y) interpreting x and y as decimal numbers.
+// (Copied from golang.org/x/mod/semver's compareInt.)
+func CmpInt(x, y string) int {
+ if x == y {
+ return 0
+ }
+ if len(x) < len(y) {
+ return -1
+ }
+ if len(x) > len(y) {
+ return +1
+ }
+ if x < y {
+ return -1
+ } else {
+ return +1
+ }
+}
+
+// DecInt returns the decimal string decremented by 1, or the empty string
+// if the decimal is all zeroes.
+// (Copied from golang.org/x/mod/module's decDecimal.)
+func DecInt(decimal string) string {
+ // Scan right to left turning 0s to 9s until you find a digit to decrement.
+ digits := []byte(decimal)
+ i := len(digits) - 1
+ for ; i >= 0 && digits[i] == '0'; i-- {
+ digits[i] = '9'
+ }
+ if i < 0 {
+ // decimal is all zeros
+ return ""
+ }
+ if i == 0 && digits[i] == '1' && len(digits) > 1 {
+ digits = digits[1:]
+ } else {
+ digits[i]--
+ }
+ return string(digits)
+}
--- /dev/null
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package gover
+
+import (
+ "reflect"
+ "testing"
+)
+
+func TestCompare(t *testing.T) { test2(t, compareTests, "Compare", Compare) }
+
+var compareTests = []testCase2[string, string, int]{
+ {"", "", 0},
+ {"x", "x", 0},
+ {"", "x", 0},
+ {"1", "1.1", -1},
+ {"1.5", "1.6", -1},
+ {"1.5", "1.10", -1},
+ {"1.6", "1.6.1", -1},
+ {"1.19", "1.19.0", 0},
+ {"1.19rc1", "1.19", -1},
+ {"1.20", "1.20.0", 0},
+ {"1.20rc1", "1.20", -1},
+ {"1.21", "1.21.0", -1},
+ {"1.21", "1.21rc1", -1},
+ {"1.21rc1", "1.21.0", -1},
+ {"1.6", "1.19", -1},
+ {"1.19", "1.19.1", -1},
+ {"1.19rc1", "1.19", -1},
+ {"1.19rc1", "1.19.1", -1},
+ {"1.19rc1", "1.19rc2", -1},
+ {"1.19.0", "1.19.1", -1},
+ {"1.19rc1", "1.19.0", -1},
+ {"1.19alpha3", "1.19beta2", -1},
+ {"1.19beta2", "1.19rc1", -1},
+ {"1.1", "1.99999999999999998", -1},
+ {"1.99999999999999998", "1.99999999999999999", -1},
+}
+
+func TestParse(t *testing.T) { test1(t, parseTests, "Parse", Parse) }
+
+var parseTests = []testCase1[string, Version]{
+ {"1", Version{"1", "0", "0", "", ""}},
+ {"1.2", Version{"1", "2", "0", "", ""}},
+ {"1.2.3", Version{"1", "2", "3", "", ""}},
+ {"1.2rc3", Version{"1", "2", "", "rc", "3"}},
+ {"1.20", Version{"1", "20", "0", "", ""}},
+ {"1.21", Version{"1", "21", "", "", ""}},
+ {"1.21rc3", Version{"1", "21", "", "rc", "3"}},
+ {"1.21.0", Version{"1", "21", "0", "", ""}},
+ {"1.24", Version{"1", "24", "", "", ""}},
+ {"1.24rc3", Version{"1", "24", "", "rc", "3"}},
+ {"1.24.0", Version{"1", "24", "0", "", ""}},
+ {"1.999testmod", Version{"1", "999", "", "testmod", ""}},
+ {"1.99999999999999999", Version{"1", "99999999999999999", "", "", ""}},
+}
+
+func TestLang(t *testing.T) { test1(t, langTests, "Lang", Lang) }
+
+var langTests = []testCase1[string, string]{
+ {"1.2rc3", "1.2"},
+ {"1.2.3", "1.2"},
+ {"1.2", "1.2"},
+ {"1", "1"},
+ {"1.999testmod", "1.999"},
+}
+
+func TestIsLang(t *testing.T) { test1(t, isLangTests, "IsLang", IsLang) }
+
+var isLangTests = []testCase1[string, bool]{
+ {"1.2rc3", false},
+ {"1.2.3", false},
+ {"1.999testmod", false},
+ {"1.22", true},
+ {"1.21", true},
+ {"1.20", false}, // == 1.20.0
+ {"1.19", false}, // == 1.20.0
+ {"1.3", false}, // == 1.3.0
+ {"1.2", false}, // == 1.2.0
+ {"1", false}, // == 1.0.0
+}
+
+func TestIsValid(t *testing.T) { test1(t, isValidTests, "IsValid", IsValid) }
+
+var isValidTests = []testCase1[string, bool]{
+ {"1.2rc3", true},
+ {"1.2.3", true},
+ {"1.999testmod", true},
+ {"1.600+auto", false},
+ {"1.22", true},
+ {"1.21.0", true},
+ {"1.21rc2", true},
+ {"1.21", true},
+ {"1.20.0", true},
+ {"1.20", true},
+ {"1.19", true},
+ {"1.3", true},
+ {"1.2", true},
+ {"1", true},
+}
+
+type testCase1[In, Out any] struct {
+ in In
+ out Out
+}
+
+type testCase2[In1, In2, Out any] struct {
+ in1 In1
+ in2 In2
+ out Out
+}
+
+type testCase3[In1, In2, In3, Out any] struct {
+ in1 In1
+ in2 In2
+ in3 In3
+ out Out
+}
+
+func test1[In, Out any](t *testing.T, tests []testCase1[In, Out], name string, f func(In) Out) {
+ t.Helper()
+ for _, tt := range tests {
+ if out := f(tt.in); !reflect.DeepEqual(out, tt.out) {
+ t.Errorf("%s(%v) = %v, want %v", name, tt.in, out, tt.out)
+ }
+ }
+}
+
+func test2[In1, In2, Out any](t *testing.T, tests []testCase2[In1, In2, Out], name string, f func(In1, In2) Out) {
+ t.Helper()
+ for _, tt := range tests {
+ if out := f(tt.in1, tt.in2); !reflect.DeepEqual(out, tt.out) {
+ t.Errorf("%s(%+v, %+v) = %+v, want %+v", name, tt.in1, tt.in2, out, tt.out)
+ }
+ }
+}