src/cmd/go2go/go2go_test.go - go - Git at Google

 // Copyright 2020 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_test

 import (
 	"fmt"
 	"internal/testenv"
 	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"reflect"
 	"runtime"
 	"sort"
 	"strings"
 	"sync"
 	"testing"
 )

 func TestMain(m *testing.M) {
 	os.Exit(testMain(m))
 }

 func testMain(m *testing.M) int {
 	dir, err := ioutil.TempDir("", "go2gotest")
 	if err != nil {
 		fmt.Fprintln(os.Stderr, err)
 		os.Exit(1)
 	}
 	defer os.RemoveAll(dir)
 	testTempDir = dir

 	return m.Run()
 }

 // testTempDir is a temporary directory the tests can use.
 var testTempDir string

 // testGo2go is the version of cmd/go2go run by the tests.
 var testGo2go string

 // testGo2goOnce ensures that testGo2go is built only once.
 var testGo2goOnce sync.Once

 // testGo2goErr is an error that occurred when building testGo2go.
 // In the normal case this is nil.
 var testGo2goErr error

 // buildGo2go builds an up-to-date version of cmd/go2go.
 // This is not run from TestMain because it's simpler if it has a *testing.T.
 func buildGo2go(t *testing.T) {
 	t.Helper()
 	testenv.MustHaveGoBuild(t)
 	testGo2goOnce.Do(func() {
 		testGo2go = filepath.Join(testTempDir, "go2go.exe")
 		t.Logf("running [go build -o %s]", testGo2go)
 		out, err := exec.Command(testenv.GoToolPath(t), "build", "-o", testGo2go).CombinedOutput()
 		if len(out) > 0 {
 			t.Logf("%s", out)
 		}
 		testGo2goErr = err
 	})
 	if testGo2goErr != nil {
 		t.Fatal("failed to build testgo2go program:", testGo2goErr)
 	}
 }

 func TestGO2PATH(t *testing.T) {
 	t.Parallel()
 	buildGo2go(t)

 	copyFile := func(path string, info os.FileInfo, err error) error {
 		if err != nil {
 			t.Fatal(err)
 		}
 		newPath := filepath.Join(testTempDir, path)
 		if info.IsDir() {
 			if err := os.MkdirAll(newPath, 0o755); err != nil {
 				t.Fatal(err)
 			}
 			return nil
 		}
 		data, err := ioutil.ReadFile(path)
 		if err != nil {
 			t.Fatal(err)
 		}
 		if err := ioutil.WriteFile(newPath, data, 0o444); err != nil {
 			t.Fatal(err)
 		}
 		return nil
 	}

 	if err := filepath.Walk("testdata/go2path/src", copyFile); err != nil {
 		t.Fatal(err)
 	}

 	d, err := os.Open(filepath.Join(testTempDir, "testdata/go2path/src"))
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer d.Close()
 	dirs, err := d.Readdirnames(-1)
 	if err != nil {
 		t.Fatal(err)
 	}
 	sort.Strings(dirs)

 	for _, dir := range dirs {
 		t.Run(dir, func(t *testing.T) {
 			cmd := exec.Command(testGo2go, "test")
 			cmd.Dir = filepath.Join(testTempDir, "testdata", "go2path", "src", dir)
 			cmd.Env = append(os.Environ(), "GO2PATH="+filepath.Join(testTempDir, "testdata", "go2path"))
 			t.Logf("running [%s test] in %s", testGo2go, cmd.Dir)
 			out, err := cmd.CombinedOutput()
 			if len(out) > 0 {
 				t.Log(dir)
 				t.Logf("%s", out)
 			}
 			if err != nil {
 				t.Errorf("error testing %s: %v", dir, err)
 			}
 		})
 	}
 }

 type testFile struct {
 	name, contents string
 }

 type testFiles []testFile

 func (tfs testFiles) create(t *testing.T, gopath string) {
 	t.Helper()
 	for _, tf := range tfs {
 		fn := filepath.Join(gopath, "src", tf.name)
 		if err := os.MkdirAll(filepath.Dir(fn), 0o755); err != nil {
 			t.Fatal(err)
 		}
 		if err := ioutil.WriteFile(fn, []byte(tf.contents), 0o444); err != nil {
 			t.Fatal(err)
 		}
 	}
 }

 func TestGO2PATHEqGOPATH(t *testing.T) {
 	t.Parallel()
 	buildGo2go(t)

 	gopath := t.TempDir()
 	testFiles{
 		{
 			"pkg/p.go",
 			`package pkg; func F() {}`,
 		},
 		{
 			"cmd/cmd.go2",
 			`package main; import "pkg"; func main() { pkg.F() }`,
 		},
 	}.create(t, gopath)

 	t.Log("go2go build")
 	cmdDir := filepath.Join(gopath, "src", "cmd")
 	cmd := exec.Command(testGo2go, "build")
 	cmd.Dir = cmdDir
 	cmd.Env = append(os.Environ(),
 		"GOPATH="+gopath,
 		"GO2PATH="+gopath,
 		"GO111MODULE=off",
 	)
 	out, err := cmd.CombinedOutput()
 	if len(out) > 0 {
 		t.Logf("%s", out)
 	}
 	if err != nil {
 		t.Fatalf(`error running "go2go build": %v`, err)
 	}

 	t.Log("./cmd")
 	cmdName := "./cmd"
 	if runtime.GOOS == "windows" {
 		cmdName += ".exe"
 	}
 	cmd = exec.Command(cmdName)
 	cmd.Dir = cmdDir
 	out, err = cmd.CombinedOutput()
 	if err != nil {
 		t.Fatalf("error running %q: %v", cmdName, err)
 	}
 	if len(out) != 0 {
 		t.Errorf("unexpected output: %q", out)
 	}
 }

 const buildSource = `
 package main

 import "fmt"

 func PrintSlice[Elem any](s []Elem) {
 	for _, v := range s {
 		fmt.Println(v)
 	}
 }

 func main() {
 	PrintSlice([]string{"hello", "world"})
 }
 `

 func TestBuild(t *testing.T) {
 	t.Parallel()
 	buildGo2go(t)

 	gopath := t.TempDir()
 	testFiles{
 		{
 			"hello/hello.go2",
 			buildSource,
 		},
 	}.create(t, gopath)

 	t.Log("go2go build")
 	dir := filepath.Join(gopath, "src", "hello")
 	cmd := exec.Command(testGo2go, "build")
 	cmd.Dir = dir
 	out, err := cmd.CombinedOutput()
 	if len(out) > 0 {
 		t.Logf("%s", out)
 	}
 	if err != nil {
 		t.Fatalf(`error running "go2go build": %v`, err)
 	}

 	runHello(t, dir)
 }

 func runHello(t *testing.T, dir string) {
 	cmdName := "./hello"
 	if runtime.GOOS == "windows" {
 		cmdName += ".exe"
 	}
 	cmd := exec.Command(cmdName)
 	cmd.Dir = dir
 	out, err := cmd.CombinedOutput()
 	t.Log("./hello")
 	if len(out) > 0 {
 		t.Logf("%s", out)
 	}
 	if err != nil {
 		t.Fatalf("error running hello: %v", err)
 	}
 	got := strings.Split(strings.TrimSpace(string(out)), "\n")
 	want := []string{"hello", "world"}
 	if !reflect.DeepEqual(got, want) {
 		t.Errorf("hello output %v, want %v", got, want)
 	}
 }

 func TestBuildPackage(t *testing.T) {
 	t.Parallel()
 	buildGo2go(t)

 	gopath := t.TempDir()
 	testFiles{
 		{
 			"cmd/hello/hello.go2",
 			buildSource,
 		},
 	}.create(t, gopath)

 	t.Log("go2go build")
 	cmd := exec.Command(testGo2go, "build", "cmd/hello")
 	cmd.Dir = gopath
 	cmd.Env = append(os.Environ(),
 		"GO2PATH="+gopath,
 	)
 	out, err := cmd.CombinedOutput()
 	if len(out) > 0 {
 		t.Logf("%s", out)
 	}
 	if err != nil {
 		t.Fatalf(`error running "go2go build": %v`, err)
 	}

 	runHello(t, gopath)
 }

 func TestTransitiveGo1(t *testing.T) {
 	t.Parallel()
 	buildGo2go(t)

 	gopath := t.TempDir()
 	testFiles{
 		{
 			"a/a.go2",
 			`package a; func ident[T any](v T) T { return v }; func F1(v int) int { return ident(v) }`,
 		},
 		{
 			"b/b.go",
 			`package b; import "a"; func F2(v int) int { return a.F1(v) }`,
 		},
 		{
 			"c/c.go2",
 			`package main; import ("fmt"; "b"); func main() { fmt.Println(b.F2(42)) }`,
 		},
 	}.create(t, gopath)

 	t.Log("go2go build")
 	cmd := exec.Command(testGo2go, "build", "c")
 	cmd.Dir = gopath
 	cmd.Env = append(os.Environ(),
 		"GO2PATH="+gopath,
 	)
 	out, err := cmd.CombinedOutput()
 	if len(out) > 0 {
 		t.Logf("%s", out)
 	}
 	if err != nil {
 		t.Fatalf(`error running "go2go build": %v`, err)
 	}
 }

 func TestBuildWithTags(t *testing.T) {
 	t.Parallel()
 	buildGo2go(t)

 	gopath := t.TempDir()
 	testFiles{
 		{
 			"a/a.go2",
 			`package a; func ident[T any](v T) T { return v }; func F1(s string) string { return ident(s) }`,
 		},
 		{
 			"b/b_appengine.go",
 			`// +build appengine

 package b; import "a"; func F2(s string) string { return a.F1(s) + " App Engine!" }`,
 		},
 		{
 			"b/b.go",
 			`// +build !appengine

 package b; import "a"; func F2(s string) string { return a.F1(s) + " World!" }`,
 		},
 		{
 			"c/c.go2",
 			`package main; import ("fmt"; "b"); func main() { fmt.Println(b.F2("Hello")) }`,
 		},
 	}.create(t, gopath)

 	t.Log("go2go build")
 	cmd := exec.Command(testGo2go, "build", "-tags=appengine", "c")
 	cmd.Dir = gopath
 	cmd.Env = append(os.Environ(),
 		"GO2PATH="+gopath,
 	)
 	out, err := cmd.CombinedOutput()
 	if len(out) > 0 {
 		t.Logf("%s", out)
 	}
 	if err != nil {
 		t.Fatalf(`error running "go2go build": %v`, err)
 	}

 	cmdName := "./c"
 	if runtime.GOOS == "windows" {
 		cmdName += ".exe"
 	}
 	cmd = exec.Command(cmdName)
 	cmd.Dir = gopath
 	out, err = cmd.CombinedOutput()
 	t.Log("./c")
 	if len(out) > 0 {
 		t.Logf("%s", out)
 	}
 	if err != nil {
 		t.Fatalf("error running c: %v", err)
 	}
 	got := strings.Split(strings.TrimSpace(string(out)), "\n")[0]
 	want := "Hello App Engine!"
 	if !reflect.DeepEqual(got, want) {
 		t.Errorf("c output %v, want %v", got, want)
 	}
 }
	// Copyright 2020 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_test

	import (
	"fmt"
	"internal/testenv"
	"io/ioutil"
	"os"
	"os/exec"
	"path/filepath"
	"reflect"
	"runtime"
	"sort"
	"strings"
	"sync"
	"testing"
	)

	func TestMain(m *testing.M) {
	os.Exit(testMain(m))
	}

	func testMain(m *testing.M) int {
	dir, err := ioutil.TempDir("", "go2gotest")
	if err != nil {
	fmt.Fprintln(os.Stderr, err)
	os.Exit(1)
	}
	defer os.RemoveAll(dir)
	testTempDir = dir

	return m.Run()
	}

	// testTempDir is a temporary directory the tests can use.
	var testTempDir string

	// testGo2go is the version of cmd/go2go run by the tests.
	var testGo2go string

	// testGo2goOnce ensures that testGo2go is built only once.
	var testGo2goOnce sync.Once

	// testGo2goErr is an error that occurred when building testGo2go.
	// In the normal case this is nil.
	var testGo2goErr error

	// buildGo2go builds an up-to-date version of cmd/go2go.
	// This is not run from TestMain because it's simpler if it has a *testing.T.
	func buildGo2go(t *testing.T) {
	t.Helper()
	testenv.MustHaveGoBuild(t)
	testGo2goOnce.Do(func() {
	testGo2go = filepath.Join(testTempDir, "go2go.exe")
	t.Logf("running [go build -o %s]", testGo2go)
	out, err := exec.Command(testenv.GoToolPath(t), "build", "-o", testGo2go).CombinedOutput()
	if len(out) > 0 {
	t.Logf("%s", out)
	}
	testGo2goErr = err
	})
	if testGo2goErr != nil {
	t.Fatal("failed to build testgo2go program:", testGo2goErr)
	}
	}

	func TestGO2PATH(t *testing.T) {
	t.Parallel()
	buildGo2go(t)

	copyFile := func(path string, info os.FileInfo, err error) error {
	if err != nil {
	t.Fatal(err)
	}
	newPath := filepath.Join(testTempDir, path)
	if info.IsDir() {
	if err := os.MkdirAll(newPath, 0o755); err != nil {
	t.Fatal(err)
	}
	return nil
	}
	data, err := ioutil.ReadFile(path)
	if err != nil {
	t.Fatal(err)
	}
	if err := ioutil.WriteFile(newPath, data, 0o444); err != nil {
	t.Fatal(err)
	}
	return nil
	}

	if err := filepath.Walk("testdata/go2path/src", copyFile); err != nil {
	t.Fatal(err)
	}

	d, err := os.Open(filepath.Join(testTempDir, "testdata/go2path/src"))
	if err != nil {
	t.Fatal(err)
	}
	defer d.Close()
	dirs, err := d.Readdirnames(-1)
	if err != nil {
	t.Fatal(err)
	}
	sort.Strings(dirs)

	for _, dir := range dirs {
	t.Run(dir, func(t *testing.T) {
	cmd := exec.Command(testGo2go, "test")
	cmd.Dir = filepath.Join(testTempDir, "testdata", "go2path", "src", dir)
	cmd.Env = append(os.Environ(), "GO2PATH="+filepath.Join(testTempDir, "testdata", "go2path"))
	t.Logf("running [%s test] in %s", testGo2go, cmd.Dir)
	out, err := cmd.CombinedOutput()
	if len(out) > 0 {
	t.Log(dir)
	t.Logf("%s", out)
	}
	if err != nil {
	t.Errorf("error testing %s: %v", dir, err)
	}
	})
	}
	}

	type testFile struct {
	name, contents string
	}

	type testFiles []testFile

	func (tfs testFiles) create(t *testing.T, gopath string) {
	t.Helper()
	for _, tf := range tfs {
	fn := filepath.Join(gopath, "src", tf.name)
	if err := os.MkdirAll(filepath.Dir(fn), 0o755); err != nil {
	t.Fatal(err)
	}
	if err := ioutil.WriteFile(fn, []byte(tf.contents), 0o444); err != nil {
	t.Fatal(err)
	}
	}
	}

	func TestGO2PATHEqGOPATH(t *testing.T) {
	t.Parallel()
	buildGo2go(t)

	gopath := t.TempDir()
	testFiles{
	{
	"pkg/p.go",
	`package pkg; func F() {}`,
	},
	{
	"cmd/cmd.go2",
	`package main; import "pkg"; func main() { pkg.F() }`,
	},
	}.create(t, gopath)

	t.Log("go2go build")
	cmdDir := filepath.Join(gopath, "src", "cmd")
	cmd := exec.Command(testGo2go, "build")
	cmd.Dir = cmdDir
	cmd.Env = append(os.Environ(),
	"GOPATH="+gopath,
	"GO2PATH="+gopath,
	"GO111MODULE=off",
	)
	out, err := cmd.CombinedOutput()
	if len(out) > 0 {
	t.Logf("%s", out)
	}
	if err != nil {
	t.Fatalf(`error running "go2go build": %v`, err)
	}

	t.Log("./cmd")
	cmdName := "./cmd"
	if runtime.GOOS == "windows" {
	cmdName += ".exe"
	}
	cmd = exec.Command(cmdName)
	cmd.Dir = cmdDir
	out, err = cmd.CombinedOutput()
	if err != nil {
	t.Fatalf("error running %q: %v", cmdName, err)
	}
	if len(out) != 0 {
	t.Errorf("unexpected output: %q", out)
	}
	}

	const buildSource = `
	package main

	import "fmt"

	func PrintSlice[Elem any](s []Elem) {
	for _, v := range s {
	fmt.Println(v)
	}
	}

	func main() {
	PrintSlice([]string{"hello", "world"})
	}
	`

	func TestBuild(t *testing.T) {
	t.Parallel()
	buildGo2go(t)

	gopath := t.TempDir()
	testFiles{
	{
	"hello/hello.go2",
	buildSource,
	},
	}.create(t, gopath)

	t.Log("go2go build")
	dir := filepath.Join(gopath, "src", "hello")
	cmd := exec.Command(testGo2go, "build")
	cmd.Dir = dir
	out, err := cmd.CombinedOutput()
	if len(out) > 0 {
	t.Logf("%s", out)
	}
	if err != nil {
	t.Fatalf(`error running "go2go build": %v`, err)
	}

	runHello(t, dir)
	}

	func runHello(t *testing.T, dir string) {
	cmdName := "./hello"
	if runtime.GOOS == "windows" {
	cmdName += ".exe"
	}
	cmd := exec.Command(cmdName)
	cmd.Dir = dir
	out, err := cmd.CombinedOutput()
	t.Log("./hello")
	if len(out) > 0 {
	t.Logf("%s", out)
	}
	if err != nil {
	t.Fatalf("error running hello: %v", err)
	}
	got := strings.Split(strings.TrimSpace(string(out)), "\n")
	want := []string{"hello", "world"}
	if !reflect.DeepEqual(got, want) {
	t.Errorf("hello output %v, want %v", got, want)
	}
	}

	func TestBuildPackage(t *testing.T) {
	t.Parallel()
	buildGo2go(t)

	gopath := t.TempDir()
	testFiles{
	{
	"cmd/hello/hello.go2",
	buildSource,
	},
	}.create(t, gopath)

	t.Log("go2go build")
	cmd := exec.Command(testGo2go, "build", "cmd/hello")
	cmd.Dir = gopath
	cmd.Env = append(os.Environ(),
	"GO2PATH="+gopath,
	)
	out, err := cmd.CombinedOutput()
	if len(out) > 0 {
	t.Logf("%s", out)
	}
	if err != nil {
	t.Fatalf(`error running "go2go build": %v`, err)
	}

	runHello(t, gopath)
	}

	func TestTransitiveGo1(t *testing.T) {
	t.Parallel()
	buildGo2go(t)

	gopath := t.TempDir()
	testFiles{
	{
	"a/a.go2",
	`package a; func ident[T any](v T) T { return v }; func F1(v int) int { return ident(v) }`,
	},
	{
	"b/b.go",
	`package b; import "a"; func F2(v int) int { return a.F1(v) }`,
	},
	{
	"c/c.go2",
	`package main; import ("fmt"; "b"); func main() { fmt.Println(b.F2(42)) }`,
	},
	}.create(t, gopath)

	t.Log("go2go build")
	cmd := exec.Command(testGo2go, "build", "c")
	cmd.Dir = gopath
	cmd.Env = append(os.Environ(),
	"GO2PATH="+gopath,
	)
	out, err := cmd.CombinedOutput()
	if len(out) > 0 {
	t.Logf("%s", out)
	}
	if err != nil {
	t.Fatalf(`error running "go2go build": %v`, err)
	}
	}

	func TestBuildWithTags(t *testing.T) {
	t.Parallel()
	buildGo2go(t)

	gopath := t.TempDir()
	testFiles{
	{
	"a/a.go2",
	`package a; func ident[T any](v T) T { return v }; func F1(s string) string { return ident(s) }`,
	},
	{
	"b/b_appengine.go",
	`// +build appengine

	package b; import "a"; func F2(s string) string { return a.F1(s) + " App Engine!" }`,
	},
	{
	"b/b.go",
	`// +build !appengine

	package b; import "a"; func F2(s string) string { return a.F1(s) + " World!" }`,
	},
	{
	"c/c.go2",
	`package main; import ("fmt"; "b"); func main() { fmt.Println(b.F2("Hello")) }`,
	},
	}.create(t, gopath)

	t.Log("go2go build")
	cmd := exec.Command(testGo2go, "build", "-tags=appengine", "c")
	cmd.Dir = gopath
	cmd.Env = append(os.Environ(),
	"GO2PATH="+gopath,
	)
	out, err := cmd.CombinedOutput()
	if len(out) > 0 {
	t.Logf("%s", out)
	}
	if err != nil {
	t.Fatalf(`error running "go2go build": %v`, err)
	}

	cmdName := "./c"
	if runtime.GOOS == "windows" {
	cmdName += ".exe"
	}
	cmd = exec.Command(cmdName)
	cmd.Dir = gopath
	out, err = cmd.CombinedOutput()
	t.Log("./c")
	if len(out) > 0 {
	t.Logf("%s", out)
	}
	if err != nil {
	t.Fatalf("error running c: %v", err)
	}
	got := strings.Split(strings.TrimSpace(string(out)), "\n")[0]
	want := "Hello App Engine!"
	if !reflect.DeepEqual(got, want) {
	t.Errorf("c output %v, want %v", got, want)
	}
	}