| Server IP : 147.93.80.58 / Your IP : 216.73.216.188 Web Server : LiteSpeed System : Linux id-dci-web1866.main-hosting.eu 5.14.0-503.38.1.el9_5.x86_64 #1 SMP PREEMPT_DYNAMIC Fri Apr 18 08:52:10 EDT 2025 x86_64 User : u939086737 ( 939086737) PHP Version : 8.2.28 Disable Function : system, exec, shell_exec, passthru, mysql_list_dbs, ini_alter, dl, symlink, link, chgrp, leak, popen, apache_child_terminate, virtual, mb_send_mail MySQL : OFF | cURL : ON | WGET : ON | Perl : OFF | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : /proc/thread-self/root/opt/go/pkg/mod/google.golang.org/protobuf@v1.35.2/ |
Upload File : |
// Copyright 2019 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 main
import (
"archive/tar"
"archive/zip"
"bytes"
"compress/gzip"
"crypto/sha256"
"flag"
"fmt"
"io"
"io/fs"
"net/http"
"os"
"os/exec"
"path/filepath"
"regexp"
"runtime"
"runtime/debug"
"strings"
"sync"
"testing"
"time"
"google.golang.org/protobuf/internal/version"
)
var (
regenerate = flag.Bool("regenerate", false, "regenerate files")
buildRelease = flag.Bool("buildRelease", false, "build release binaries")
protobufVersion = "27.0"
golangVersions = func() []string {
// Version policy: oldest supported version of Go, plus the version before that.
// This matches the version policy of the Google Cloud Client Libraries:
// https://cloud.google.com/go/getting-started/supported-go-versions
return []string{
"1.21.13",
"1.22.6",
"1.23.0",
}
}()
golangLatest = golangVersions[len(golangVersions)-1]
staticcheckVersion = "2024.1.1"
staticcheckSHA256s = map[string]string{
"darwin/amd64": "b67380b84b81d5765b478b7ad888dd7ce53b2c0861103bafa946ac84dc9244ce",
"darwin/arm64": "09cb10e4199f7c6356c2ed5dc45e877c3087ef775d84d39338b52e1a94866074",
"linux/386": "0225fd8b5cf6c762f9c0aedf1380ed4df576d1d54fb68691be895889e10faf0b",
"linux/amd64": "6e9398fcaff2b36e1d15e84a647a3a14733b7c2dd41187afa2c182a4c3b32180",
}
// purgeTimeout determines the maximum age of unused sub-directories.
purgeTimeout = 30 * 24 * time.Hour // 1 month
// Variables initialized by mustInitDeps.
modulePath string
protobufPath string
)
func TestIntegration(t *testing.T) {
if testing.Short() {
t.Skip("skipping integration test in short mode")
}
if os.Getenv("GO_BUILDER_NAME") != "" {
// To start off, run on longtest builders, not longtest-race ones.
if race() {
t.Skip("skipping integration test in race mode on builders")
}
// When on a builder, run even if it's not explicitly requested
// provided our caller isn't already running it.
if os.Getenv("GO_PROTOBUF_INTEGRATION_TEST_RUNNING") == "1" {
t.Skip("protobuf integration test is already running, skipping nested invocation")
}
os.Setenv("GO_PROTOBUF_INTEGRATION_TEST_RUNNING", "1")
} else if flag.Lookup("test.run").Value.String() != "^TestIntegration$" {
t.Skip("not running integration test if not explicitly requested via test.bash")
}
mustInitDeps(t)
mustHandleFlags(t)
// Report dirt in the working tree quickly, rather than after
// going through all the presubmits.
//
// Fail the test late, so we can test uncommitted changes with -failfast.
gitDiff := mustRunCommand(t, "git", "diff", "HEAD")
if strings.TrimSpace(gitDiff) != "" {
fmt.Printf("WARNING: working tree contains uncommitted changes:\n%v\n", gitDiff)
}
gitUntracked := mustRunCommand(t, "git", "ls-files", "--others", "--exclude-standard")
if strings.TrimSpace(gitUntracked) != "" {
fmt.Printf("WARNING: working tree contains untracked files:\n%v\n", gitUntracked)
}
// Do the relatively fast checks up-front.
t.Run("GeneratedGoFiles", func(t *testing.T) {
diff := mustRunCommand(t, "go", "run", "-tags", "protolegacy", "./internal/cmd/generate-types")
if strings.TrimSpace(diff) != "" {
t.Fatalf("stale generated files:\n%v", diff)
}
diff = mustRunCommand(t, "go", "run", "-tags", "protolegacy", "./internal/cmd/generate-protos")
if strings.TrimSpace(diff) != "" {
t.Fatalf("stale generated files:\n%v", diff)
}
})
t.Run("FormattedGoFiles", func(t *testing.T) {
files := strings.Split(strings.TrimSpace(mustRunCommand(t, "git", "ls-files", "*.go")), "\n")
diff := mustRunCommand(t, append([]string{"gofmt", "-d"}, files...)...)
if strings.TrimSpace(diff) != "" {
t.Fatalf("unformatted source files:\n%v", diff)
}
})
t.Run("CopyrightHeaders", func(t *testing.T) {
files := strings.Split(strings.TrimSpace(mustRunCommand(t, "git", "ls-files", "*.go", "*.proto")), "\n")
mustHaveCopyrightHeader(t, files)
})
var wg sync.WaitGroup
sema := make(chan bool, (runtime.NumCPU()+1)/2)
for i := range golangVersions {
goVersion := golangVersions[i]
goLabel := "Go" + goVersion
runGo := func(label string, cmd command, args ...string) {
wg.Add(1)
sema <- true
go func() {
defer wg.Done()
defer func() { <-sema }()
t.Run(goLabel+"/"+label, func(t *testing.T) {
args[0] += goVersion
cmd.mustRun(t, args...)
})
}()
}
runGo("Normal", command{}, "go", "test", "-race", "./...")
runGo("Reflect", command{}, "go", "test", "-race", "-tags", "protoreflect", "./...")
if goVersion == golangLatest {
runGo("ProtoLegacyRace", command{}, "go", "test", "-race", "-tags", "protolegacy", "./...")
runGo("ProtoLegacy", command{}, "go", "test", "-tags", "protolegacy", "./...")
runGo("ProtocGenGo", command{Dir: "cmd/protoc-gen-go/testdata"}, "go", "test")
runGo("Conformance", command{Dir: "internal/conformance"}, "go", "test", "-execute")
// Only run the 32-bit compatibility tests for Linux;
// avoid Darwin since 10.15 dropped support i386 code execution.
if runtime.GOOS == "linux" {
runGo("Arch32Bit", command{Env: append(os.Environ(), "GOARCH=386")}, "go", "test", "./...")
}
}
}
wg.Wait()
t.Run("GoStaticCheck", func(t *testing.T) {
checks := []string{
"all", // start with all checks enabled
"-SA1019", // disable deprecated usage check
"-S*", // disable code simplification checks
"-ST*", // disable coding style checks
"-U*", // disable unused declaration checks
}
out := mustRunCommand(t, "staticcheck", "-checks="+strings.Join(checks, ","), "-fail=none", "./...")
// Filter out findings from certain paths.
var findings []string
for _, finding := range strings.Split(strings.TrimSpace(out), "\n") {
switch {
case strings.HasPrefix(finding, "internal/testprotos/legacy/"):
default:
findings = append(findings, finding)
}
}
if len(findings) > 0 {
t.Fatalf("staticcheck findings:\n%v", strings.Join(findings, "\n"))
}
})
t.Run("CommittedGitChanges", func(t *testing.T) {
if strings.TrimSpace(gitDiff) != "" {
t.Fatalf("uncommitted changes")
}
})
t.Run("TrackedGitFiles", func(t *testing.T) {
if strings.TrimSpace(gitUntracked) != "" {
t.Fatalf("untracked files")
}
})
}
func mustInitDeps(t *testing.T) {
check := func(err error) {
t.Helper()
if err != nil {
t.Fatal(err)
}
}
// Determine the directory to place the test directory.
repoRoot, err := os.Getwd()
check(err)
testDir := filepath.Join(repoRoot, ".cache")
check(os.MkdirAll(testDir, 0775))
// Delete the current directory if non-empty,
// which only occurs if a dependency failed to initialize properly.
var workingDir string
finishedDirs := map[string]bool{}
defer func() {
if workingDir != "" {
os.RemoveAll(workingDir) // best-effort
}
}()
startWork := func(name string) string {
workingDir = filepath.Join(testDir, name)
return workingDir
}
finishWork := func() {
finishedDirs[workingDir] = true
workingDir = ""
}
// Delete other sub-directories that are no longer relevant.
defer func() {
now := time.Now()
fis, _ := os.ReadDir(testDir)
for _, fi := range fis {
dir := filepath.Join(testDir, fi.Name())
if finishedDirs[dir] {
os.Chtimes(dir, now, now) // best-effort
continue
}
fii, err := fi.Info()
check(err)
if now.Sub(fii.ModTime()) < purgeTimeout {
continue
}
fmt.Printf("delete %v\n", fi.Name())
os.RemoveAll(dir) // best-effort
}
}()
// The bin directory contains symlinks to each tool by version.
// It is safe to delete this directory and run the test script from scratch.
binPath := startWork("bin")
check(os.RemoveAll(binPath))
check(os.Mkdir(binPath, 0775))
check(os.Setenv("PATH", binPath+":"+os.Getenv("PATH")))
registerBinary := func(name, path string) {
check(os.Symlink(path, filepath.Join(binPath, name)))
}
finishWork()
// Get the protobuf toolchain.
protobufPath = startWork("protobuf-" + protobufVersion)
if _, err := os.Stat(protobufPath); err != nil {
fmt.Printf("download %v\n", filepath.Base(protobufPath))
checkoutVersion := protobufVersion
if isCommit := strings.Trim(protobufVersion, "0123456789abcdef") == ""; !isCommit {
// release tags have "v" prefix
checkoutVersion = "v" + protobufVersion
}
command{Dir: testDir}.mustRun(t, "git", "clone", "https://github.com/protocolbuffers/protobuf", "protobuf-"+protobufVersion)
command{Dir: protobufPath}.mustRun(t, "git", "checkout", checkoutVersion)
if os.Getenv("GO_BUILDER_NAME") != "" {
// If this is running on the Go build infrastructure,
// use pre-built versions of these binaries that the
// builders are configured to provide in $PATH.
protocPath, err := exec.LookPath("protoc")
check(err)
confTestRunnerPath, err := exec.LookPath("conformance_test_runner")
check(err)
check(os.MkdirAll(filepath.Join(protobufPath, "bazel-bin", "conformance"), 0775))
check(os.Symlink(protocPath, filepath.Join(protobufPath, "bazel-bin", "protoc")))
check(os.Symlink(confTestRunnerPath, filepath.Join(protobufPath, "bazel-bin", "conformance", "conformance_test_runner")))
} else {
// In other environments, download and build the protobuf toolchain.
// We avoid downloading the pre-compiled binaries since they do not contain
// the conformance test runner.
fmt.Printf("build %v\n", filepath.Base(protobufPath))
env := os.Environ()
args := []string{
"bazel", "build",
":protoc",
"//conformance:conformance_test_runner",
}
if runtime.GOOS == "darwin" {
// Adding this environment variable appears to be necessary for macOS builds.
env = append(env, "CC=clang")
// And this flag.
args = append(args,
"--macos_minimum_os=13.0",
"--host_macos_minimum_os=13.0",
)
}
command{
Dir: protobufPath,
Env: env,
}.mustRun(t, args...)
}
}
check(os.Setenv("PROTOBUF_ROOT", protobufPath)) // for generate-protos
registerBinary("conform-test-runner", filepath.Join(protobufPath, "bazel-bin", "conformance", "conformance_test_runner"))
registerBinary("protoc", filepath.Join(protobufPath, "bazel-bin", "protoc"))
finishWork()
// Download each Go toolchain version.
for _, v := range golangVersions {
goDir := startWork("go" + v)
if _, err := os.Stat(goDir); err != nil {
fmt.Printf("download %v\n", filepath.Base(goDir))
url := fmt.Sprintf("https://dl.google.com/go/go%v.%v-%v.tar.gz", v, runtime.GOOS, runtime.GOARCH)
downloadArchive(check, goDir, url, "go", "") // skip SHA256 check as we fetch over https from a trusted domain
}
registerBinary("go"+v, filepath.Join(goDir, "bin", "go"))
finishWork()
}
registerBinary("go", filepath.Join(testDir, "go"+golangLatest, "bin", "go"))
registerBinary("gofmt", filepath.Join(testDir, "go"+golangLatest, "bin", "gofmt"))
// Download the staticcheck tool.
checkDir := startWork("staticcheck-" + staticcheckVersion)
if _, err := os.Stat(checkDir); err != nil {
fmt.Printf("download %v\n", filepath.Base(checkDir))
url := fmt.Sprintf("https://github.com/dominikh/go-tools/releases/download/%v/staticcheck_%v_%v.tar.gz", staticcheckVersion, runtime.GOOS, runtime.GOARCH)
downloadArchive(check, checkDir, url, "staticcheck", staticcheckSHA256s[runtime.GOOS+"/"+runtime.GOARCH])
}
registerBinary("staticcheck", filepath.Join(checkDir, "staticcheck"))
finishWork()
// GitHub actions sets GOROOT, which confuses invocations of the Go toolchain.
// Explicitly clear GOROOT, so each toolchain uses their default GOROOT.
check(os.Unsetenv("GOROOT"))
// Set a cache directory outside the test directory.
check(os.Setenv("GOCACHE", filepath.Join(repoRoot, ".gocache")))
}
func downloadFile(check func(error), dstPath, srcURL string, perm fs.FileMode) {
resp, err := http.Get(srcURL)
check(err)
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
body, _ := io.ReadAll(io.LimitReader(resp.Body, 4<<10))
check(fmt.Errorf("GET %q: non-200 OK status code: %v body: %q", srcURL, resp.Status, body))
}
check(os.MkdirAll(filepath.Dir(dstPath), 0775))
f, err := os.OpenFile(dstPath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, perm)
check(err)
_, err = io.Copy(f, resp.Body)
check(err)
check(f.Close())
}
func downloadArchive(check func(error), dstPath, srcURL, skipPrefix, wantSHA256 string) {
check(os.RemoveAll(dstPath))
resp, err := http.Get(srcURL)
check(err)
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
body, _ := io.ReadAll(io.LimitReader(resp.Body, 4<<10))
check(fmt.Errorf("GET %q: non-200 OK status code: %v body: %q", srcURL, resp.Status, body))
}
var r io.Reader = resp.Body
if wantSHA256 != "" {
b, err := io.ReadAll(resp.Body)
check(err)
r = bytes.NewReader(b)
if gotSHA256 := fmt.Sprintf("%x", sha256.Sum256(b)); gotSHA256 != wantSHA256 {
check(fmt.Errorf("checksum validation error:\ngot %v\nwant %v", gotSHA256, wantSHA256))
}
}
zr, err := gzip.NewReader(r)
check(err)
tr := tar.NewReader(zr)
for {
h, err := tr.Next()
if err == io.EOF {
return
}
check(err)
// Skip directories or files outside the prefix directory.
if len(skipPrefix) > 0 {
if !strings.HasPrefix(h.Name, skipPrefix) {
continue
}
if len(h.Name) > len(skipPrefix) && h.Name[len(skipPrefix)] != '/' {
continue
}
}
path := strings.TrimPrefix(strings.TrimPrefix(h.Name, skipPrefix), "/")
path = filepath.Join(dstPath, filepath.FromSlash(path))
mode := os.FileMode(h.Mode & 0777)
switch h.Typeflag {
case tar.TypeReg:
b, err := io.ReadAll(tr)
check(err)
check(os.WriteFile(path, b, mode))
case tar.TypeDir:
check(os.Mkdir(path, mode))
}
}
}
func mustHandleFlags(t *testing.T) {
if *regenerate {
t.Run("Generate", func(t *testing.T) {
fmt.Print(mustRunCommand(t, "go", "generate", "./internal/cmd/generate-types"))
fmt.Print(mustRunCommand(t, "go", "generate", "./internal/cmd/generate-protos"))
files := strings.Split(strings.TrimSpace(mustRunCommand(t, "git", "ls-files", "*.go")), "\n")
mustRunCommand(t, append([]string{"gofmt", "-w"}, files...)...)
})
}
if *buildRelease {
t.Run("BuildRelease", func(t *testing.T) {
v := version.String()
for _, goos := range []string{"linux", "darwin", "windows"} {
for _, goarch := range []string{"386", "amd64", "arm64"} {
// Avoid Darwin since 10.15 dropped support for i386.
if goos == "darwin" && goarch == "386" {
continue
}
binPath := filepath.Join("bin", fmt.Sprintf("protoc-gen-go.%v.%v.%v", v, goos, goarch))
// Build the binary.
cmd := command{Env: append(os.Environ(), "GOOS="+goos, "GOARCH="+goarch)}
cmd.mustRun(t, "go", "build", "-trimpath", "-ldflags", "-s -w -buildid=", "-o", binPath, "./cmd/protoc-gen-go")
// Archive and compress the binary.
in, err := os.ReadFile(binPath)
if err != nil {
t.Fatal(err)
}
out := new(bytes.Buffer)
suffix := ""
comment := fmt.Sprintf("protoc-gen-go VERSION=%v GOOS=%v GOARCH=%v", v, goos, goarch)
switch goos {
case "windows":
suffix = ".zip"
zw := zip.NewWriter(out)
zw.SetComment(comment)
fw, _ := zw.Create("protoc-gen-go.exe")
fw.Write(in)
zw.Close()
default:
suffix = ".tar.gz"
gz, _ := gzip.NewWriterLevel(out, gzip.BestCompression)
gz.Comment = comment
tw := tar.NewWriter(gz)
tw.WriteHeader(&tar.Header{
Name: "protoc-gen-go",
Mode: int64(0775),
Size: int64(len(in)),
})
tw.Write(in)
tw.Close()
gz.Close()
}
if err := os.WriteFile(binPath+suffix, out.Bytes(), 0664); err != nil {
t.Fatal(err)
}
}
}
})
}
if *regenerate || *buildRelease {
t.SkipNow()
}
}
var copyrightRegex = []*regexp.Regexp{
regexp.MustCompile(`^// Copyright \d\d\d\d 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\.
`),
// Generated .pb.go files from main protobuf repo.
regexp.MustCompile(`^// Protocol Buffers - Google's data interchange format
// Copyright \d\d\d\d Google Inc\. All rights reserved\.
`),
}
func mustHaveCopyrightHeader(t *testing.T, files []string) {
var bad []string
File:
for _, file := range files {
if strings.HasSuffix(file, "internal/testprotos/conformance/editions/test_messages_edition2023.pb.go") {
// TODO(lassefolger) the underlying proto file is checked into
// the protobuf repo without a copyright header. Fix is pending but
// might require a release.
continue
}
b, err := os.ReadFile(file)
if err != nil {
t.Fatal(err)
}
for _, re := range copyrightRegex {
if loc := re.FindIndex(b); loc != nil && loc[0] == 0 {
continue File
}
}
bad = append(bad, file)
}
if len(bad) > 0 {
t.Fatalf("files with missing/bad copyright headers:\n %v", strings.Join(bad, "\n "))
}
}
type command struct {
Dir string
Env []string
}
func (c command) mustRun(t *testing.T, args ...string) string {
t.Helper()
stdout := new(bytes.Buffer)
stderr := new(bytes.Buffer)
cmd := exec.Command(args[0], args[1:]...)
cmd.Dir = "."
if c.Dir != "" {
cmd.Dir = c.Dir
}
cmd.Env = os.Environ()
if c.Env != nil {
cmd.Env = c.Env
}
cmd.Env = append(cmd.Env, "PWD="+cmd.Dir)
cmd.Stdout = stdout
cmd.Stderr = stderr
if err := cmd.Run(); err != nil {
t.Fatalf("executing (%v): %v\n%s%s", strings.Join(args, " "), err, stdout.String(), stderr.String())
}
return stdout.String()
}
func mustRunCommand(t *testing.T, args ...string) string {
t.Helper()
return command{}.mustRun(t, args...)
}
// race is an approximation of whether the race detector is on.
// It's used to skip the integration test on builders, without
// preventing the integration test from running under the race
// detector as a '//go:build !race' build constraint would.
func race() bool {
bi, ok := debug.ReadBuildInfo()
if !ok {
return false
}
for _, setting := range bi.Settings {
if setting.Key == "-race" {
return setting.Value == "true"
}
}
return false
}