diff options
Diffstat (limited to '')
-rw-r--r-- | dependencies/pkg/mod/golang.org/x/exp@v0.0.0-20220613132600-b0d781184e0d/constraints/constraints_test.go | 160 |
1 files changed, 160 insertions, 0 deletions
diff --git a/dependencies/pkg/mod/golang.org/x/exp@v0.0.0-20220613132600-b0d781184e0d/constraints/constraints_test.go b/dependencies/pkg/mod/golang.org/x/exp@v0.0.0-20220613132600-b0d781184e0d/constraints/constraints_test.go new file mode 100644 index 0000000..5bc43a9 --- /dev/null +++ b/dependencies/pkg/mod/golang.org/x/exp@v0.0.0-20220613132600-b0d781184e0d/constraints/constraints_test.go @@ -0,0 +1,160 @@ +// 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" + "os" + "os/exec" + "path/filepath" + "runtime" + "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 } +) + +// 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] +} + +var prolog = []byte(` +package constrainttest + +import "golang.org/x/exp/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 } +) +`) + +func TestFailure(t *testing.T) { + switch runtime.GOOS { + case "android", "js", "ios": + t.Skipf("can't run go tool on %s", runtime.GOOS) + } + + var exeSuffix string + if runtime.GOOS == "windows" { + exeSuffix = ".exe" + } + gocmd := filepath.Join(runtime.GOROOT(), "bin", "go"+exeSuffix) + if _, err := os.Stat(gocmd); err != nil { + t.Skipf("skipping because can't stat %s: %v", gocmd, err) + } + + tmpdir := t.TempDir() + + cwd, err := os.Getwd() + if err != nil { + t.Fatal(err) + } + // This package is golang.org/x/exp/constraints, so the root of the x/exp + // module is the parent directory of the directory in which this test runs. + expModDir := filepath.Dir(cwd) + + modFile := fmt.Sprintf(`module constraintest + +go 1.18 + +replace golang.org/x/exp => %s +`, expModDir) + if err := os.WriteFile(filepath.Join(tmpdir, "go.mod"), []byte(modFile), 0666); err != nil { + t.Fatal(err) + } + + // Write the prolog as its own file so that 'go mod tidy' has something to inspect. + // This will ensure that the go.mod and go.sum files include any dependencies + // needed by the constraints package (which should just be some version of + // x/exp itself). + if err := os.WriteFile(filepath.Join(tmpdir, "prolog.go"), []byte(prolog), 0666); err != nil { + t.Fatal(err) + } + + tidyCmd := exec.Command(gocmd, "mod", "tidy") + tidyCmd.Dir = tmpdir + tidyCmd.Env = append(os.Environ(), "PWD="+tmpdir) + if out, err := tidyCmd.CombinedOutput(); err != nil { + t.Fatalf("%v: %v\n%s", tidyCmd, err, out) + } else { + t.Logf("%v:\n%s", tidyCmd, out) + } + + // 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"}, + } { + 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 implement" + if !bytes.Contains(out, []byte(want)) { + t.Errorf("output does not include %q", want) + } + } else { + t.Error("no error output, expected something") + } + }) + } +} |