| // Copyright 2021 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 constraints | |
| import ( | |
| "bytes" | |
| "fmt" | |
| "internal/testenv" | |
| "os" | |
| "os/exec" | |
| "path/filepath" | |
| "testing" | |
| ) | |
| type ( | |
| testSigned[T Signed] struct{ f T } | |
| testUnsigned[T Unsigned] struct{ f T } | |
| testInteger[T Integer] struct{ f T } | |
| testFloat[T Float] struct{ f T } | |
| testComplex[T Complex] struct{ f T } | |
| testOrdered[T Ordered] struct{ f T } | |
| testSlice[T Slice[E], E any] struct{ f T } | |
| testMap[T Map[K, V], K comparable, V any] struct{ f T } | |
| testChan[T Chan[E], E any] struct{ f T } | |
| ) | |
| // TestTypes passes if it compiles. | |
| type TestTypes struct { | |
| _ testSigned[int] | |
| _ testSigned[int64] | |
| _ testUnsigned[uint] | |
| _ testUnsigned[uintptr] | |
| _ testInteger[int8] | |
| _ testInteger[uint8] | |
| _ testInteger[uintptr] | |
| _ testFloat[float32] | |
| _ testComplex[complex64] | |
| _ testOrdered[int] | |
| _ testOrdered[float64] | |
| _ testOrdered[string] | |
| _ testSlice[[]int, int] | |
| _ testMap[map[int]bool, int, bool] | |
| _ testChan[chan int, int] | |
| } | |
| func infer1[S Slice[E], E any](s S, v E) S { return s } | |
| func infer2[M Map[K, V], K comparable, V any](m M, k K, v V) M { return m } | |
| func infer3[C Chan[E], E any](c C, v E) C { return c } | |
| func TestInference(t *testing.T) { | |
| var empty interface{} | |
| type S []int | |
| empty = infer1(S{}, 0) | |
| if _, ok := empty.(S); !ok { | |
| t.Errorf("infer1(S) returned %T, expected S", empty) | |
| } | |
| type M map[int]bool | |
| empty = infer2(M{}, 0, false) | |
| if _, ok := empty.(M); !ok { | |
| t.Errorf("infer2(M) returned %T, expected M", empty) | |
| } | |
| type C chan bool | |
| empty = infer3(make(C), true) | |
| if _, ok := empty.(C); !ok { | |
| t.Errorf("infer3(C) returned %T, expected C", empty) | |
| } | |
| } | |
| var prolog = []byte(` | |
| package constrainttest | |
| import "constraints" | |
| type ( | |
| testSigned[T constraints.Signed] struct{ f T } | |
| testUnsigned[T constraints.Unsigned] struct{ f T } | |
| testInteger[T constraints.Integer] struct{ f T } | |
| testFloat[T constraints.Float] struct{ f T } | |
| testComplex[T constraints.Complex] struct{ f T } | |
| testOrdered[T constraints.Ordered] struct{ f T } | |
| testSlice[T constraints.Slice[E], E any] struct{ f T } | |
| testMap[T constraints.Map[K, V], K comparable, V any] struct{ f T } | |
| testChan[T constraints.Chan[E], E any] struct{ f T } | |
| ) | |
| `) | |
| func TestFailure(t *testing.T) { | |
| testenv.MustHaveGoBuild(t) | |
| gocmd := testenv.GoToolPath(t) | |
| tmpdir := t.TempDir() | |
| if err := os.WriteFile(filepath.Join(tmpdir, "go.mod"), []byte("module constraintest"), 0666); err != nil { | |
| t.Fatal(err) | |
| } | |
| // Test for types that should not satisfy a constraint. | |
| // For each pair of constraint and type, write a Go file | |
| // var V constraint[type] | |
| // For example, | |
| // var V testSigned[uint] | |
| // This should not compile, as testSigned (above) uses | |
| // constraints.Signed, and uint does not satisfy that constraint. | |
| // Therefore, the build of that code should fail. | |
| for i, test := range []struct { | |
| constraint, typ string | |
| }{ | |
| {"testSigned", "uint"}, | |
| {"testUnsigned", "int"}, | |
| {"testInteger", "float32"}, | |
| {"testFloat", "int8"}, | |
| {"testComplex", "float64"}, | |
| {"testOrdered", "bool"}, | |
| {"testSlice", "int, int"}, | |
| {"testMap", "string, string, string"}, | |
| {"testChan", "[]int, int"}, | |
| } { | |
| i := i | |
| test := test | |
| t.Run(fmt.Sprintf("%s %d", test.constraint, i), func(t *testing.T) { | |
| t.Parallel() | |
| name := fmt.Sprintf("go%d.go", i) | |
| f, err := os.Create(filepath.Join(tmpdir, name)) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| if _, err := f.Write(prolog); err != nil { | |
| t.Fatal(err) | |
| } | |
| if _, err := fmt.Fprintf(f, "var V %s[%s]\n", test.constraint, test.typ); err != nil { | |
| t.Fatal(err) | |
| } | |
| if err := f.Close(); err != nil { | |
| t.Fatal(err) | |
| } | |
| cmd := exec.Command(gocmd, "build", name) | |
| cmd.Dir = tmpdir | |
| if out, err := cmd.CombinedOutput(); err == nil { | |
| t.Error("build succeeded, but expected to fail") | |
| } else if len(out) > 0 { | |
| t.Logf("%s", out) | |
| const want = "does not satisfy" | |
| if !bytes.Contains(out, []byte(want)) { | |
| t.Errorf("output does not include %q", want) | |
| } | |
| } else { | |
| t.Error("no error output, expected something") | |
| } | |
| }) | |
| } | |
| } |