"bytes"
"fmt"
"internal/buildcfg"
- "io/ioutil"
"os"
"path/filepath"
"regexp"
output := strings.Split(testOut.String(), "\n")
// Reconstruct expected output by independently "parsing" the input.
- data, err := ioutil.ReadFile(input)
+ data, err := os.ReadFile(input)
if err != nil {
t.Error(err)
return
}
// Reconstruct expected errors by independently "parsing" the input.
- data, err := ioutil.ReadFile(input)
+ data, err := os.ReadFile(input)
if err != nil {
t.Error(err)
return
"go/token"
"internal/buildcfg"
"io"
- "io/ioutil"
"os"
"path/filepath"
"reflect"
input = aname
}
- b, err := ioutil.ReadFile(input)
+ b, err := os.ReadFile(input)
if err != nil {
fatalf("%s", err)
}
"bytes"
"fmt"
"go/token"
- "io/ioutil"
"os"
"os/exec"
)
// Some compilers have trouble with standard input.
// Others have trouble with -xc.
// Avoid both problems by writing a file with a .c extension.
- f, err := ioutil.TempFile("", "cgo-gcc-input-")
+ f, err := os.CreateTemp("", "cgo-gcc-input-")
if err != nil {
fatalf("%s", err)
}
name := f.Name()
f.Close()
- if err := ioutil.WriteFile(name+".c", stdin, 0666); err != nil {
+ if err := os.WriteFile(name+".c", stdin, 0666); err != nil {
os.Remove(name)
fatalf("%s", err)
}
"flag"
"fmt"
"internal/buildcfg"
- "io/ioutil"
"log"
"os"
"reflect"
Flag.Cfg.ImportMap = make(map[string]string)
}
Flag.Cfg.PackageFile = map[string]string{}
- data, err := ioutil.ReadFile(file)
+ data, err := os.ReadFile(file)
if err != nil {
log.Fatalf("-importcfg: %v", err)
}
}
func readEmbedCfg(file string) {
- data, err := ioutil.ReadFile(file)
+ data, err := os.ReadFile(file)
if err != nil {
log.Fatalf("-embedcfg: %v", err)
}
"debug/dwarf"
"fmt"
"internal/testenv"
- "io/ioutil"
"os"
"os/exec"
"path/filepath"
t.Skip("skipping on plan9; no DWARF symbol table in executables")
}
- dir, err := ioutil.TempDir("", "TestScopeRanges")
+ dir, err := os.MkdirTemp("", "TestScopeRanges")
if err != nil {
t.Fatalf("could not create directory: %v", err)
}
t.Skip("skipping on plan9; no DWARF symbol table in executables")
}
- dir, err := ioutil.TempDir("", "TestEmptyDwarfRanges")
+ dir, err := os.MkdirTemp("", "TestEmptyDwarfRanges")
if err != nil {
t.Fatalf("could not create directory: %v", err)
}
import (
"bufio"
- "cmd/compile/internal/types2"
"fmt"
"go/build"
"internal/pkgbits"
"io"
- "io/ioutil"
"os"
"path/filepath"
"strings"
+
+ "cmd/compile/internal/types2"
)
// debugging/development support
if size >= 0 {
r = io.LimitReader(r, int64(size))
}
- data, err = ioutil.ReadAll(r)
+ data, err = io.ReadAll(r)
if err != nil {
break
}
"go/parser"
"go/token"
"io/fs"
- "io/ioutil"
"log"
"sort"
"strings"
// write out mangled source so we can see the bug.
out = buf.Bytes()
}
- err = ioutil.WriteFile("node_gen.go", out, 0666)
+ err = os.WriteFile("node_gen.go", out, 0666)
if err != nil {
log.Fatal(err)
}
import (
"internal/testenv"
- "io/ioutil"
"os"
"os/exec"
"path/filepath"
testenv.MustHaveGoBuild(t)
- dir, err := ioutil.TempDir("", "TestLogOpt")
+ dir, err := os.MkdirTemp("", "TestLogOpt")
if err != nil {
t.Fatal(err)
}
dir = fixSlash(dir) // Normalize the directory name as much as possible, for Windows testing
src := filepath.Join(dir, "file.go")
- if err := ioutil.WriteFile(src, []byte(srcCode), 0644); err != nil {
+ if err := os.WriteFile(src, []byte(srcCode), 0644); err != nil {
t.Fatal(err)
}
}
`
copy := filepath.Join(dir, "copy.go")
- if err := ioutil.WriteFile(copy, []byte(copyCode), 0644); err != nil {
+ if err := os.WriteFile(copy, []byte(copyCode), 0644); err != nil {
t.Fatal(err)
}
outcopy := filepath.Join(dir, "copy.o")
if err != nil {
t.Error("-json=0,file://log/opt should have succeeded")
}
- logged, err := ioutil.ReadFile(filepath.Join(dir, "log", "opt", "x", "copy.json"))
+ logged, err := os.ReadFile(filepath.Join(dir, "log", "opt", "x", "copy.json"))
if err != nil {
t.Error("-json=0,file://log/opt missing expected log file")
}
if err != nil {
t.Error("-json=0,file://log/opt should have succeeded")
}
- logged, err := ioutil.ReadFile(filepath.Join(dir, "log", "opt", "x", "file.json"))
+ logged, err := os.ReadFile(filepath.Join(dir, "log", "opt", "x", "file.json"))
if err != nil {
t.Error("-json=0,file://log/opt missing expected log file")
}
"bufio"
"bytes"
"flag"
- "internal/buildcfg"
- "runtime"
- "sort"
- "strings"
-
"fmt"
+ "internal/buildcfg"
"internal/testenv"
- "io/ioutil"
"os"
"os/exec"
"path/filepath"
"reflect"
"regexp"
+ "runtime"
+ "sort"
"strconv"
+ "strings"
"testing"
)
func compileAndDump(t *testing.T, file, function, moreGCFlags string) []byte {
testenv.MustHaveGoBuild(t)
- tmpdir, err := ioutil.TempDir("", "debug_lines_test")
+ tmpdir, err := os.MkdirTemp("", "debug_lines_test")
if err != nil {
panic(fmt.Sprintf("Problem creating TempDir, error %v", err))
}
"fmt"
"internal/testenv"
"io"
- "io/ioutil"
"os"
"os/exec"
"path/filepath"
// Use a temporary directory unless -f is specified
if !*force {
- tmpdir, err := ioutil.TempDir("", "debug_test")
+ tmpdir, err := os.MkdirTemp("", "debug_test")
if err != nil {
panic(fmt.Sprintf("Problem creating TempDir, error %v\n", err))
}
func (h *nextHist) read(filename string) {
h.f2i = make(map[string]uint8)
- bytes, err := ioutil.ReadFile(filename)
+ bytes, err := os.ReadFile(filename)
if err != nil {
panic(fmt.Sprintf("Problem reading %s, error %v\n", filename, err))
}
"flag"
"fmt"
"go/format"
- "io/ioutil"
"log"
"os"
"path"
panic(err)
}
- if err := ioutil.WriteFile("../opGen.go", b, 0666); err != nil {
+ if err := os.WriteFile("../opGen.go", b, 0666); err != nil {
log.Fatalf("can't write output: %v\n", err)
}
log.Fatalf("bad opcode regexp %s: %v", pattern, err)
}
- src, err := ioutil.ReadFile(a.genfile)
+ src, err := os.ReadFile(a.genfile)
if err != nil {
log.Fatalf("can't read %s: %v", a.genfile, err)
}
"go/printer"
"go/token"
"io"
- "io/ioutil"
"log"
"os"
"path"
file, err := parser.ParseFile(fset, "", buf, parser.ParseComments)
if err != nil {
filename := fmt.Sprintf("%s_broken.go", arch.name)
- if err := ioutil.WriteFile(filename, buf.Bytes(), 0644); err != nil {
+ if err := os.WriteFile(filename, buf.Bytes(), 0644); err != nil {
log.Printf("failed to dump broken code to %s: %v", filename, err)
} else {
log.Printf("dumped broken code to %s", filename)
import (
"fmt"
"internal/buildcfg"
- "io/ioutil"
"log"
"os"
"strings"
// the symbol name and the third field is the ABI name, as one of the
// named cmd/internal/obj.ABI constants.
func (s *SymABIs) ReadSymABIs(file string) {
- data, err := ioutil.ReadFile(file)
+ data, err := os.ReadFile(file)
if err != nil {
log.Fatalf("-symabis: %v", err)
}
"fmt"
"go/constant"
"io"
- "io/ioutil"
"os"
"sort"
"strconv"
}
size := info.Size()
if size <= 1*1024 {
- data, err := ioutil.ReadAll(f)
+ data, err := io.ReadAll(f)
if err != nil {
return nil, 0, err
}
"flag"
"fmt"
"internal/testenv"
- "io/ioutil"
"os"
"path/filepath"
"regexp"
func TestSyntaxErrors(t *testing.T) {
testenv.MustHaveGoBuild(t) // we need access to source (testdata)
- list, err := ioutil.ReadDir(testdata)
+ list, err := os.ReadDir(testdata)
if err != nil {
t.Fatal(err)
}
"flag"
"fmt"
"internal/testenv"
- "io/ioutil"
+ "os"
"path/filepath"
"regexp"
"runtime"
}
func walkDirs(t *testing.T, dir string, action func(string)) {
- fis, err := ioutil.ReadDir(dir)
+ entries, err := os.ReadDir(dir)
if err != nil {
t.Error(err)
return
}
var files, dirs []string
- for _, fi := range fis {
- if fi.Mode().IsRegular() {
- if strings.HasSuffix(fi.Name(), ".go") {
- path := filepath.Join(dir, fi.Name())
+ for _, entry := range entries {
+ if entry.Type().IsRegular() {
+ if strings.HasSuffix(entry.Name(), ".go") {
+ path := filepath.Join(dir, entry.Name())
files = append(files, path)
}
- } else if fi.IsDir() && fi.Name() != "testdata" {
- path := filepath.Join(dir, fi.Name())
+ } else if entry.IsDir() && entry.Name() != "testdata" {
+ path := filepath.Join(dir, entry.Name())
if !strings.HasSuffix(path, string(filepath.Separator)+"test") {
dirs = append(dirs, path)
}
import (
"fmt"
"io"
- "io/ioutil"
"os"
"strings"
"testing"
if testing.Verbose() {
return os.Stdout
}
- return ioutil.Discard
+ return io.Discard
}
func dup(s string) [2]string { return [2]string{s, s} }
import (
"internal/testenv"
- "io/ioutil"
+ "os"
"os/exec"
"path/filepath"
"testing"
tmpdir := t.TempDir()
src := filepath.Join(tmpdir, "x.go")
- err := ioutil.WriteFile(src, []byte(helloSrc), 0644)
+ err := os.WriteFile(src, []byte(helloSrc), 0644)
if err != nil {
t.Fatalf("write file failed: %v", err)
}
import (
"internal/testenv"
- "io/ioutil"
"os"
"os/exec"
"path/filepath"
// Test that the generated assembly has line numbers (Issue #16214).
func TestIssue16214(t *testing.T) {
testenv.MustHaveGoBuild(t)
- dir, err := ioutil.TempDir("", "TestLineNumber")
+ dir, err := os.MkdirTemp("", "TestLineNumber")
if err != nil {
t.Fatalf("could not create directory: %v", err)
}
defer os.RemoveAll(dir)
src := filepath.Join(dir, "x.go")
- err = ioutil.WriteFile(src, []byte(issue16214src), 0644)
+ err = os.WriteFile(src, []byte(issue16214src), 0644)
if err != nil {
t.Fatalf("could not write file: %v", err)
}
import (
"bytes"
"internal/testenv"
- "io/ioutil"
"os"
"os/exec"
"path/filepath"
t.Parallel()
// Make a directory to work in.
- dir, err := ioutil.TempDir("", "issue6853a-")
+ dir, err := os.MkdirTemp("", "issue6853a-")
if err != nil {
t.Fatalf("could not create directory: %v", err)
}
t.Parallel()
// Make a directory to work in.
- dir, err := ioutil.TempDir("", "issue14515-")
+ dir, err := os.MkdirTemp("", "issue14515-")
if err != nil {
t.Fatalf("could not create directory: %v", err)
}
import (
"internal/testenv"
- "io/ioutil"
"os"
"os/exec"
"path/filepath"
var tmpdir string
var err error
- tmpdir, err = ioutil.TempDir("", "TestDict")
+ tmpdir, err = os.MkdirTemp("", "TestDict")
if err != nil {
t.Fatalf("Failed to create temporary directory: %v", err)
}
if output, err = cmd.CombinedOutput(); err != nil {
t.Fatalf("Failed: %v:\nOut: %s\n", err, output)
}
- out, err := ioutil.ReadFile(filepath.Join("testdata", outname))
+ out, err := os.ReadFile(filepath.Join("testdata", outname))
if err != nil {
t.Fatalf("Could not find %s\n", outname)
}
import (
"internal/testenv"
- "io/ioutil"
"os"
"os/exec"
"path/filepath"
testenv.MustHaveGoBuild(t)
- dir, err := ioutil.TempDir("", "TestInvalidLang")
+ dir, err := os.MkdirTemp("", "TestInvalidLang")
if err != nil {
t.Fatal(err)
}
defer os.RemoveAll(dir)
src := filepath.Join(dir, "alias.go")
- if err := ioutil.WriteFile(src, []byte(aliasSrc), 0644); err != nil {
+ if err := os.WriteFile(src, []byte(aliasSrc), 0644); err != nil {
t.Fatal(err)
}
import (
"bytes"
"internal/testenv"
- "io/ioutil"
"os"
"os/exec"
"path/filepath"
t.Run(test, func(t *testing.T) {
t.Parallel()
var want []byte
- tmp, err := ioutil.TempFile("", "")
+ tmp, err := os.CreateTemp("", "")
if err != nil {
t.Fatalf("temp file creation failed: %v", err)
}
if err != nil {
t.Fatalf("failed to compile: %v\n%s", err, out)
}
- obj, err := ioutil.ReadFile(tmp.Name())
+ obj, err := os.ReadFile(tmp.Name())
if err != nil {
t.Fatalf("failed to read object file: %v", err)
}
{tag: "serial", args: "-c=1"},
{tag: "concurrent", args: "-c=2"}}
- tmpdir, err := ioutil.TempDir("", "TestIssue38068")
+ tmpdir, err := os.MkdirTemp("", "TestIssue38068")
if err != nil {
t.Fatal(err)
}
}
readBytes := func(fn string) []byte {
- payload, err := ioutil.ReadFile(fn)
+ payload, err := os.ReadFile(fn)
if err != nil {
t.Fatalf("failed to read executable '%s': %v", fn, err)
}
"go/parser"
"go/token"
"internal/testenv"
- "io/ioutil"
"os"
"os/exec"
"path/filepath"
t.Fatalf("Failed: %v:\nOut: %s\nStderr: %s\n", err, &stdout, &stderr)
}
// Write stdout into a temporary file
- tmpdir, ok := ioutil.TempDir("", tmpname)
+ tmpdir, ok := os.MkdirTemp("", tmpname)
if ok != nil {
t.Fatalf("Failed to create temporary directory")
}
defer os.RemoveAll(tmpdir)
rungo := filepath.Join(tmpdir, "run.go")
- ok = ioutil.WriteFile(rungo, stdout.Bytes(), 0600)
+ ok = os.WriteFile(rungo, stdout.Bytes(), 0600)
if ok != nil {
t.Fatalf("Failed to create temporary file " + rungo)
}
gotool := testenv.GoToolPath(t)
// Make a temporary directory to work in.
- tmpdir, err := ioutil.TempDir("", "TestCode")
+ tmpdir, err := os.MkdirTemp("", "TestCode")
if err != nil {
t.Fatalf("Failed to create temporary directory: %v", err)
}
usesFloat bool // might use float operations
}
var tests []test
- files, err := ioutil.ReadDir("testdata")
+ files, err := os.ReadDir("testdata")
if err != nil {
t.Fatalf("can't read testdata directory: %v", err)
}
if !strings.HasSuffix(f.Name(), "_test.go") {
continue
}
- text, err := ioutil.ReadFile(filepath.Join("testdata", f.Name()))
+ text, err := os.ReadFile(filepath.Join("testdata", f.Name()))
if err != nil {
t.Fatalf("can't read testdata/%s: %v", f.Name(), err)
}
"bytes"
"fmt"
"go/format"
- "io/ioutil"
"log"
"text/template"
)
}
// write to file
- err = ioutil.WriteFile("../arithBoundary_test.go", src, 0666)
+ err = os.WriteFile("../arithBoundary_test.go", src, 0666)
if err != nil {
log.Fatalf("can't write output: %v\n", err)
}
"bytes"
"fmt"
"go/format"
- "io/ioutil"
"log"
"strings"
"text/template"
}
// write to file
- err = ioutil.WriteFile("../arithConst_test.go", src, 0666)
+ err = os.WriteFile("../arithConst_test.go", src, 0666)
if err != nil {
log.Fatalf("can't write output: %v\n", err)
}
"bytes"
"fmt"
"go/format"
- "io/ioutil"
"log"
"math/big"
"sort"
}
// write to file
- err = ioutil.WriteFile("../cmpConst_test.go", src, 0666)
+ err = os.WriteFile("../cmpConst_test.go", src, 0666)
if err != nil {
log.Fatalf("can't write output: %v\n", err)
}
"bytes"
"fmt"
"go/format"
- "io/ioutil"
"log"
+ "os"
)
type op struct {
}
// write to file
- err = ioutil.WriteFile("../../constFold_test.go", src, 0666)
+ err = os.WriteFile("../../constFold_test.go", src, 0666)
if err != nil {
log.Fatalf("can't write output: %v\n", err)
}
"bytes"
"fmt"
"go/format"
- "io/ioutil"
"log"
+ "os"
)
// This program generates tests to verify that copying operations
}
// write to file
- err = ioutil.WriteFile("../copy_test.go", src, 0666)
+ err = os.WriteFile("../copy_test.go", src, 0666)
if err != nil {
log.Fatalf("can't write output: %v\n", err)
}
"bytes"
"fmt"
"go/format"
- "io/ioutil"
"log"
+ "os"
)
// This program generates tests to verify that zeroing operations
}
// write to file
- err = ioutil.WriteFile("../zero_test.go", src, 0666)
+ err = os.WriteFile("../zero_test.go", src, 0666)
if err != nil {
log.Fatalf("can't write output: %v\n", err)
}
import (
"bytes"
"internal/testenv"
- "io/ioutil"
+ "os"
"os/exec"
"testing"
)
testenv.MustHaveGoRun(t)
t.Parallel()
- old, err := ioutil.ReadFile("builtin.go")
+ old, err := os.ReadFile("builtin.go")
if err != nil {
t.Fatal(err)
}
"go/parser"
"go/token"
"io"
- "io/ioutil"
"log"
"os"
"path/filepath"
if *stdout {
_, err = os.Stdout.Write(out)
} else {
- err = ioutil.WriteFile("builtin.go", out, 0666)
+ err = os.WriteFile("builtin.go", out, 0666)
}
if err != nil {
log.Fatal(err)
import (
"bytes"
- "cmd/compile/internal/syntax"
"flag"
"fmt"
- "io/ioutil"
+ "os"
"testing"
+ "cmd/compile/internal/syntax"
. "cmd/compile/internal/types2"
)
// generate source
src := program(*H, *out)
if *out != "" {
- ioutil.WriteFile(*out, src, 0666)
+ os.WriteFile(*out, src, 0666)
return
}
"encoding/json"
"flag"
"fmt"
- "io/ioutil"
"log"
"os"
"os/exec"
os.Setenv("GOWORK", "off")
workdir = xworkdir()
- if err := ioutil.WriteFile(pathf("%s/go.mod", workdir), []byte("module bootstrap"), 0666); err != nil {
+ if err := os.WriteFile(pathf("%s/go.mod", workdir), []byte("module bootstrap"), 0666); err != nil {
fatalf("cannot write stub go.mod: %s", err)
}
xatexit(rmworkdir)
var wg sync.WaitGroup
asmabis := append(asmArgs[:len(asmArgs):len(asmArgs)], "-gensymabis", "-o", symabis)
asmabis = append(asmabis, sfiles...)
- if err := ioutil.WriteFile(goasmh, nil, 0666); err != nil {
+ if err := os.WriteFile(goasmh, nil, 0666); err != nil {
fatalf("cannot write empty go_asm.h: %s", err)
}
bgrun(&wg, dir, asmabis...)
fmt.Fprintf(buf, "packagefile %s=%s\n", dep, packagefile(dep))
}
importcfg := pathf("%s/importcfg", workdir)
- if err := ioutil.WriteFile(importcfg, buf.Bytes(), 0666); err != nil {
+ if err := os.WriteFile(importcfg, buf.Bytes(), 0666); err != nil {
fatalf("cannot write importcfg file: %v", err)
}
"bytes"
"flag"
"fmt"
- "io/ioutil"
"log"
"os"
"os/exec"
GOEXE := strings.TrimSpace(parts[0])
GOTMPDIR := strings.TrimSpace(parts[1])
- f, err := ioutil.TempFile(GOTMPDIR, "test.test-*"+GOEXE)
+ f, err := os.CreateTemp(GOTMPDIR, "test.test-*"+GOEXE)
if err != nil {
return err
}
func (t *tester) testDirTest(dt *distTest, shard, shards int) error {
runtest.Do(func() {
- f, err := ioutil.TempFile("", "runtest-*.exe") // named exe for Windows, but harmless elsewhere
+ f, err := os.CreateTemp("", "runtest-*.exe") // named exe for Windows, but harmless elsewhere
if err != nil {
runtest.err = err
return
if !strings.HasSuffix(name, "_test.go") {
continue
}
- slurp, err := ioutil.ReadFile(filepath.Join(pkgDir, name))
+ slurp, err := os.ReadFile(filepath.Join(pkgDir, name))
if err != nil {
return true // conservatively
}
"flag"
"fmt"
"io"
- "io/ioutil"
"os"
"os/exec"
"path/filepath"
// readfile returns the content of the named file.
func readfile(file string) string {
- data, err := ioutil.ReadFile(file)
+ data, err := os.ReadFile(file)
if err != nil {
fatalf("%v", err)
}
func writefile(text, file string, flag int) {
new := []byte(text)
if flag&writeSkipSame != 0 {
- old, err := ioutil.ReadFile(file)
+ old, err := os.ReadFile(file)
if err == nil && bytes.Equal(old, new) {
return
}
mode = 0777
}
xremove(file) // in case of symlink tricks by misc/reboot test
- err := ioutil.WriteFile(file, new, mode)
+ err := os.WriteFile(file, new, mode)
if err != nil {
fatalf("%v", err)
}
// xworkdir creates a new temporary directory to hold object files
// and returns the name of that directory.
func xworkdir() string {
- name, err := ioutil.TempDir(os.Getenv("GOTMPDIR"), "go-tool-dist-")
+ name, err := os.MkdirTemp(os.Getenv("GOTMPDIR"), "go-tool-dist-")
if err != nil {
fatalf("%v", err)
}
"fmt"
"internal/godebug"
"io/fs"
- "io/ioutil"
"log"
"os"
pathpkg "path"
var errNotDir = errors.New("not a directory")
// readDir reads a dir on disk, returning an error that is errNotDir if the dir is not a directory.
-// Unfortunately, the error returned by ioutil.ReadDir if dir is not a directory
+// Unfortunately, the error returned by os.ReadDir if dir is not a directory
// can vary depending on the OS (Linux, Mac, Windows return ENOTDIR; BSD returns EINVAL).
func readDir(dir string) ([]fs.FileInfo, error) {
- fis, err := ioutil.ReadDir(dir)
- if err == nil {
- return fis, nil
- }
-
- if os.IsNotExist(err) {
+ entries, err := os.ReadDir(dir)
+ if err != nil {
+ if os.IsNotExist(err) {
+ return nil, err
+ }
+ if dirfi, staterr := os.Stat(dir); staterr == nil && !dirfi.IsDir() {
+ return nil, &fs.PathError{Op: "ReadDir", Path: dir, Err: errNotDir}
+ }
return nil, err
}
- if dirfi, staterr := os.Stat(dir); staterr == nil && !dirfi.IsDir() {
- return nil, &fs.PathError{Op: "ReadDir", Path: dir, Err: errNotDir}
+
+ fis := make([]fs.FileInfo, 0, len(entries))
+ for _, entry := range entries {
+ info, err := entry.Info()
+ if err != nil {
+ continue
+ }
+ fis = append(fis, info)
}
- return nil, err
+ return fis, nil
}
// ReadDir provides a slice of fs.FileInfo entries corresponding
"fmt"
"go/build"
"internal/lazyregexp"
- "io/ioutil"
"os"
"path"
"path/filepath"
// ReadWorkFile reads and parses the go.work file at the given path.
func ReadWorkFile(path string) (*modfile.WorkFile, error) {
- workData, err := ioutil.ReadFile(path)
+ workData, err := os.ReadFile(path)
if err != nil {
return nil, err
}
wf.Cleanup()
out := modfile.Format(wf.Syntax)
- return ioutil.WriteFile(path, out, 0666)
+ return os.WriteFile(path, out, 0666)
}
// UpdateWorkFile updates comments on directory directives in the go.work
"internal/testenv"
"internal/xcoff"
"io"
- "io/ioutil"
"os"
"os/exec"
"path/filepath"
if err != nil {
return err
}
- fis, err := ioutil.ReadDir(src)
+ entries, err := os.ReadDir(src)
if err != nil {
return err
}
- for _, fi := range fis {
- err = copyFile(filepath.Join(dst, fi.Name()), filepath.Join(src, fi.Name()))
+ for _, entry := range entries {
+ err = copyFile(filepath.Join(dst, entry.Name()), filepath.Join(src, entry.Name()))
if err != nil {
return err
}
func buildGoobj(t *testing.T) goobjPaths {
buildOnce.Do(func() {
buildErr = func() (err error) {
- buildDir, err = ioutil.TempDir("", "TestGoobj")
+ buildDir, err = os.MkdirTemp("", "TestGoobj")
if err != nil {
return err
}
gopath := filepath.Join(buildDir, "gopath")
err = copyDir(filepath.Join(gopath, "src", "mycgo"), filepath.Join("testdata", "mycgo"))
if err == nil {
- err = ioutil.WriteFile(filepath.Join(gopath, "src", "mycgo", "go.mod"), []byte("module mycgo\n"), 0666)
+ err = os.WriteFile(filepath.Join(gopath, "src", "mycgo", "go.mod"), []byte("module mycgo\n"), 0666)
}
if err != nil {
return err
"bytes"
"crypto/sha256"
"internal/obscuretestdata"
- "io/ioutil"
"os"
"reflect"
"strings"
)
func TestReadFile(t *testing.T) {
- f, err := ioutil.TempFile("", "buildid-test-")
+ f, err := os.CreateTemp("", "buildid-test-")
if err != nil {
t.Fatal(err)
}
t.Errorf("ReadFile(%s) [readSize=2k] = %q, %v, want %q, nil", f, id, err, expectedID)
}
- data, err := ioutil.ReadFile(f)
+ data, err := os.ReadFile(f)
if err != nil {
t.Fatal(err)
}
t.Errorf("FindAndHash(%s): %v", f, err)
continue
}
- if err := ioutil.WriteFile(tmp, data, 0666); err != nil {
+ if err := os.WriteFile(tmp, data, 0666); err != nil {
t.Error(err)
continue
}
"go/parser"
"go/token"
"io"
- "io/ioutil"
"log"
"os"
"path/filepath"
if *stdout {
_, err = os.Stdout.Write(out)
} else {
- err = ioutil.WriteFile("builtinlist.go", out, 0666)
+ err = os.WriteFile("builtinlist.go", out, 0666)
}
if err != nil {
log.Fatal(err)
import (
"bufio"
"bytes"
- "cmd/internal/bio"
- "cmd/internal/objabi"
"fmt"
"internal/buildcfg"
"internal/testenv"
- "io/ioutil"
"os"
"os/exec"
"testing"
+
+ "cmd/internal/bio"
+ "cmd/internal/objabi"
)
func dummyWriter(buf *bytes.Buffer) *Writer {
}
testenv.MustHaveGoBuild(t)
- tmpdir, err := ioutil.TempDir("", "lotsofrelocs")
+ tmpdir, err := os.MkdirTemp("", "lotsofrelocs")
if err != nil {
t.Fatalf("can't create temp directory: %v\n", err)
}
fmt.Fprintf(&w, "\t\"%d\",\n", i)
}
fmt.Fprintf(&w, issue41621epilog)
- err = ioutil.WriteFile(tmpdir+"/large.go", w.Bytes(), 0666)
+ err = os.WriteFile(tmpdir+"/large.go", w.Bytes(), 0666)
if err != nil {
t.Fatalf("can't write output: %v\n", err)
}
// Emit go.mod
w.Reset()
fmt.Fprintf(&w, "module issue41621\n\ngo 1.12\n")
- err = ioutil.WriteFile(tmpdir+"/go.mod", w.Bytes(), 0666)
+ err = os.WriteFile(tmpdir+"/go.mod", w.Bytes(), 0666)
if err != nil {
t.Fatalf("can't write output: %v\n", err)
}
"internal/testenv"
"io"
"io/fs"
- "io/ioutil"
"os"
"os/exec"
"path/filepath"
// It's ok if there are undetected differences in modules that do not
// provide imported packages: we will not have to pull in any backports of
// fixes to those modules anyway.
- vendor, err := ioutil.ReadFile(filepath.Join(m.Dir, "vendor", "modules.txt"))
+ vendor, err := os.ReadFile(filepath.Join(m.Dir, "vendor", "modules.txt"))
if err != nil {
t.Error(err)
continue
"bytes"
"fmt"
"internal/testenv"
- "io/ioutil"
"os"
"os/exec"
"path/filepath"
}
testenv.MustHaveGoBuild(t)
- dir, err := ioutil.TempDir("", "testlarge")
+ dir, err := os.MkdirTemp("", "testlarge")
if err != nil {
t.Fatalf("could not create directory: %v", err)
}
gen(buf)
tmpfile := filepath.Join(dir, "x.s")
- err = ioutil.WriteFile(tmpfile, buf.Bytes(), 0644)
+ err = os.WriteFile(tmpfile, buf.Bytes(), 0644)
if err != nil {
t.Fatalf("can't write output: %v\n", err)
}
// Issue 20348.
func TestNoRet(t *testing.T) {
- dir, err := ioutil.TempDir("", "testnoret")
+ dir, err := os.MkdirTemp("", "testnoret")
if err != nil {
t.Fatal(err)
}
defer os.RemoveAll(dir)
tmpfile := filepath.Join(dir, "x.s")
- if err := ioutil.WriteFile(tmpfile, []byte("TEXT ·stub(SB),$0-0\nNOP\n"), 0644); err != nil {
+ if err := os.WriteFile(tmpfile, []byte("TEXT ·stub(SB),$0-0\nNOP\n"), 0644); err != nil {
t.Fatal(err)
}
cmd := exec.Command(testenv.GoToolPath(t), "tool", "asm", "-o", filepath.Join(dir, "x.o"), tmpfile)
// code can be aligned to the alignment value.
func TestPCALIGN(t *testing.T) {
testenv.MustHaveGoBuild(t)
- dir, err := ioutil.TempDir("", "testpcalign")
+ dir, err := os.MkdirTemp("", "testpcalign")
if err != nil {
t.Fatal(err)
}
}
for _, test := range testCases {
- if err := ioutil.WriteFile(tmpfile, test.code, 0644); err != nil {
+ if err := os.WriteFile(tmpfile, test.code, 0644); err != nil {
t.Fatal(err)
}
cmd := exec.Command(testenv.GoToolPath(t), "tool", "asm", "-S", "-o", tmpout, tmpfile)
import (
"bytes"
- "cmd/internal/goobj"
- "cmd/internal/sys"
"internal/testenv"
- "io/ioutil"
"os"
"os/exec"
"path/filepath"
"testing"
"unsafe"
+
+ "cmd/internal/goobj"
+ "cmd/internal/sys"
)
var dummyArch = LinkArch{Arch: sys.ArchAMD64}
t.Skip("skip on 32-bit architectures")
}
- tmpdir, err := ioutil.TempDir("", "TestSymbolTooLarge")
+ tmpdir, err := os.MkdirTemp("", "TestSymbolTooLarge")
if err != nil {
t.Fatal(err)
}
defer os.RemoveAll(tmpdir)
src := filepath.Join(tmpdir, "p.go")
- err = ioutil.WriteFile(src, []byte("package p; var x [1<<32]byte"), 0666)
+ err = os.WriteFile(src, []byte("package p; var x [1<<32]byte"), 0666)
if err != nil {
t.Fatalf("failed to write source file: %v\n", err)
}
tmpdir := t.TempDir()
src := filepath.Join(tmpdir, "x.go")
- err := ioutil.WriteFile(src, []byte("package main; import \"fmt\"; func main() { fmt.Println(123) }\n"), 0666)
+ err := os.WriteFile(src, []byte("package main; import \"fmt\"; func main() { fmt.Println(123) }\n"), 0666)
if err != nil {
t.Fatalf("failed to write source file: %v\n", err)
}
import (
"bytes"
- "cmd/internal/obj"
- "cmd/internal/objabi"
"fmt"
"internal/testenv"
- "io/ioutil"
"math"
"os"
"os/exec"
"regexp"
"strings"
"testing"
+
+ "cmd/internal/obj"
+ "cmd/internal/objabi"
)
var platformEnvs = [][]string{
func TestPfxAlign(t *testing.T) {
testenv.MustHaveGoBuild(t)
- dir, err := ioutil.TempDir("", "testpfxalign")
+ dir, err := os.MkdirTemp("", "testpfxalign")
if err != nil {
t.Fatalf("could not create directory: %v", err)
}
for _, pgm := range pgms {
tmpfile := filepath.Join(dir, "x.s")
- err = ioutil.WriteFile(tmpfile, pgm.text, 0644)
+ err = os.WriteFile(tmpfile, pgm.text, 0644)
if err != nil {
t.Fatalf("can't write output: %v\n", err)
}
}
testenv.MustHaveGoBuild(t)
- dir, err := ioutil.TempDir("", "testlarge")
+ dir, err := os.MkdirTemp("", "testlarge")
if err != nil {
t.Fatalf("could not create directory: %v", err)
}
gen(buf, test.jmpinsn)
tmpfile := filepath.Join(dir, "x.s")
- err = ioutil.WriteFile(tmpfile, buf.Bytes(), 0644)
+ err = os.WriteFile(tmpfile, buf.Bytes(), 0644)
if err != nil {
t.Fatalf("can't write output: %v\n", err)
}
testenv.MustHaveGoBuild(t)
- dir, err := ioutil.TempDir("", "testpcalign")
+ dir, err := os.MkdirTemp("", "testpcalign")
if err != nil {
t.Fatalf("could not create directory: %v", err)
}
// generate a test with valid uses of PCALIGN
tmpfile := filepath.Join(dir, "x.s")
- err = ioutil.WriteFile(tmpfile, []byte(validPCAlignSrc), 0644)
+ err = os.WriteFile(tmpfile, []byte(validPCAlignSrc), 0644)
if err != nil {
t.Fatalf("can't write output: %v\n", err)
}
// generate a test with invalid use of PCALIGN
tmpfile = filepath.Join(dir, "xi.s")
- err = ioutil.WriteFile(tmpfile, []byte(invalidPCAlignSrc), 0644)
+ err = os.WriteFile(tmpfile, []byte(invalidPCAlignSrc), 0644)
if err != nil {
t.Fatalf("can't write output: %v\n", err)
}
"bytes"
"fmt"
"internal/testenv"
- "io/ioutil"
"os"
"os/exec"
"path/filepath"
}
testenv.MustHaveGoBuild(t)
- dir, err := ioutil.TempDir("", "testlargebranch")
+ dir, err := os.MkdirTemp("", "testlargebranch")
if err != nil {
t.Fatalf("Could not create directory: %v", err)
}
genLargeBranch(buf)
tmpfile := filepath.Join(dir, "x.s")
- if err := ioutil.WriteFile(tmpfile, buf.Bytes(), 0644); err != nil {
+ if err := os.WriteFile(tmpfile, buf.Bytes(), 0644); err != nil {
t.Fatalf("Failed to write file: %v", err)
}
}
testenv.MustHaveGoBuild(t)
- dir, err := ioutil.TempDir("", "testlargecall")
+ dir, err := os.MkdirTemp("", "testlargecall")
if err != nil {
t.Fatalf("could not create directory: %v", err)
}
defer os.RemoveAll(dir)
- if err := ioutil.WriteFile(filepath.Join(dir, "go.mod"), []byte("module largecall"), 0644); err != nil {
+ if err := os.WriteFile(filepath.Join(dir, "go.mod"), []byte("module largecall"), 0644); err != nil {
t.Fatalf("Failed to write file: %v\n", err)
}
main := `package main
func x()
func y()
`
- if err := ioutil.WriteFile(filepath.Join(dir, "x.go"), []byte(main), 0644); err != nil {
+ if err := os.WriteFile(filepath.Join(dir, "x.go"), []byte(main), 0644); err != nil {
t.Fatalf("failed to write main: %v\n", err)
}
buf := bytes.NewBuffer(make([]byte, 0, 7000000))
genLargeCall(buf)
- if err := ioutil.WriteFile(filepath.Join(dir, "x.s"), buf.Bytes(), 0644); err != nil {
+ if err := os.WriteFile(filepath.Join(dir, "x.s"), buf.Bytes(), 0644); err != nil {
t.Fatalf("Failed to write file: %v\n", err)
}
// Issue 20348.
func TestNoRet(t *testing.T) {
- dir, err := ioutil.TempDir("", "testnoret")
+ dir, err := os.MkdirTemp("", "testnoret")
if err != nil {
t.Fatal(err)
}
defer os.RemoveAll(dir)
tmpfile := filepath.Join(dir, "x.s")
- if err := ioutil.WriteFile(tmpfile, []byte("TEXT ·stub(SB),$0-0\nNOP\n"), 0644); err != nil {
+ if err := os.WriteFile(tmpfile, []byte("TEXT ·stub(SB),$0-0\nNOP\n"), 0644); err != nil {
t.Fatal(err)
}
cmd := exec.Command(testenv.GoToolPath(t), "tool", "asm", "-o", filepath.Join(dir, "x.o"), tmpfile)
}
func TestImmediateSplitting(t *testing.T) {
- dir, err := ioutil.TempDir("", "testimmsplit")
+ dir, err := os.MkdirTemp("", "testimmsplit")
if err != nil {
t.Fatal(err)
}
MOVF F6, 4096(X5)
MOVD F6, 4096(X5)
`
- if err := ioutil.WriteFile(tmpfile, []byte(asm), 0644); err != nil {
+ if err := os.WriteFile(tmpfile, []byte(asm), 0644); err != nil {
t.Fatal(err)
}
cmd := exec.Command(testenv.GoToolPath(t), "tool", "asm", "-o", filepath.Join(dir, "x.o"), tmpfile)
"bytes"
"fmt"
"internal/testenv"
- "io/ioutil"
"os"
"os/exec"
"path/filepath"
}
func asmOutput(t *testing.T, s string) []byte {
- tmpdir, err := ioutil.TempDir("", "progedittest")
+ tmpdir, err := os.MkdirTemp("", "progedittest")
if err != nil {
t.Fatal(err)
}
"bytes"
"fmt"
"internal/testenv"
- "io/ioutil"
"os"
"os/exec"
"path/filepath"
`
func objdumpOutput(t *testing.T, mname, source string) []byte {
- tmpdir, err := ioutil.TempDir("", mname)
+ tmpdir, err := os.MkdirTemp("", mname)
if err != nil {
t.Fatal(err)
}
defer os.RemoveAll(tmpdir)
- err = ioutil.WriteFile(filepath.Join(tmpdir, "go.mod"), []byte(fmt.Sprintf("module %s\n", mname)), 0666)
+ err = os.WriteFile(filepath.Join(tmpdir, "go.mod"), []byte(fmt.Sprintf("module %s\n", mname)), 0666)
if err != nil {
t.Fatal(err)
}
"fmt"
"internal/buildcfg"
"io"
- "io/ioutil"
"log"
"os"
"reflect"
out = make([]string, 0, len(in)*2)
out = append(out, in[:i]...)
}
- slurp, err := ioutil.ReadFile(s[1:])
+ slurp, err := os.ReadFile(s[1:])
if err != nil {
log.Fatal(err)
}
import (
"bufio"
"bytes"
- "cmd/internal/src"
"container/list"
"debug/gosym"
"encoding/binary"
"fmt"
"io"
- "io/ioutil"
"os"
"path/filepath"
"regexp"
"strings"
"text/tabwriter"
+ "cmd/internal/src"
+
"golang.org/x/arch/arm/armasm"
"golang.org/x/arch/arm64/arm64asm"
"golang.org/x/arch/ppc64/ppc64asm"
}
if e == nil {
- content, err := ioutil.ReadFile(filename)
+ content, err := os.ReadFile(filename)
if err != nil {
return nil, err
}
"bytes"
"errors"
"fmt"
- "io/ioutil"
"os"
"os/exec"
"strings"
// ToSymbolFunc returns a function that may be used to convert a
// package path into a string suitable for use as a symbol.
// cmd is the gccgo/GoLLVM compiler in use, and tmpdir is a temporary
-// directory to pass to ioutil.TempFile.
+// directory to pass to os.CreateTemp().
// For example, this returns a function that converts "net/http"
// into a string like "net..z2fhttp". The actual string varies for
// different gccgo/GoLLVM versions, which is why this returns a function
// the same string. More recent versions use a new mangler
// that avoids these collisions.
const filepat = "*_gccgo_manglechck.go"
- f, err := ioutil.TempFile(tmpdir, filepat)
+ f, err := os.CreateTemp(tmpdir, filepat)
if err != nil {
return nil, err
}
f.Close()
defer os.Remove(gofilename)
- if err := ioutil.WriteFile(gofilename, []byte(mangleCheckCode), 0644); err != nil {
+ if err := os.WriteFile(gofilename, []byte(mangleCheckCode), 0644); err != nil {
return nil, err
}
"flag"
"fmt"
"io"
- "io/ioutil"
+ "os"
"path/filepath"
"reflect"
"strings"
for _, file := range files {
name := strings.TrimSuffix(filepath.Base(file), ".test")
t.Run(name, func(t *testing.T) {
- orig, err := ioutil.ReadFile(file)
+ orig, err := os.ReadFile(file)
if err != nil {
t.Fatal(err)
}
if *update {
js := strings.TrimSuffix(file, ".test") + ".json"
t.Logf("rewriting %s", js)
- if err := ioutil.WriteFile(js, buf.Bytes(), 0666); err != nil {
+ if err := os.WriteFile(js, buf.Bytes(), 0666); err != nil {
t.Fatal(err)
}
return
}
- want, err := ioutil.ReadFile(strings.TrimSuffix(file, ".test") + ".json")
+ want, err := os.ReadFile(strings.TrimSuffix(file, ".test") + ".json")
if err != nil {
t.Fatal(err)
}
package main
import (
- "cmd/internal/sys"
"debug/elf"
"fmt"
"internal/testenv"
- "io/ioutil"
"os"
"os/exec"
"path/filepath"
"sync"
"testing"
"text/template"
+
+ "cmd/internal/sys"
)
func getCCAndCCFLAGS(t *testing.T, env []string) (string, []string) {
gopath := filepath.Join(dir, "GOPATH")
env := append(os.Environ(), "GOPATH="+gopath)
- if err := ioutil.WriteFile(filepath.Join(dir, "go.mod"), []byte("module elf_test\n"), 0666); err != nil {
+ if err := os.WriteFile(filepath.Join(dir, "go.mod"), []byte("module elf_test\n"), 0666); err != nil {
t.Fatal(err)
}
asmFile := filepath.Join(dir, "x.s")
- if err := ioutil.WriteFile(asmFile, []byte(asmSource), 0444); err != nil {
+ if err := os.WriteFile(asmFile, []byte(asmSource), 0444); err != nil {
t.Fatal(err)
}
}
goFile := filepath.Join(dir, "main.go")
- if err := ioutil.WriteFile(goFile, []byte(goSource), 0444); err != nil {
+ if err := os.WriteFile(goFile, []byte(goSource), 0444); err != nil {
t.Fatal(err)
}
gopath := filepath.Join(dir, "GOPATH")
env := append(os.Environ(), "GOPATH="+gopath)
- if err := ioutil.WriteFile(filepath.Join(dir, "go.mod"), []byte("module elf_test\n"), 0666); err != nil {
+ if err := os.WriteFile(filepath.Join(dir, "go.mod"), []byte("module elf_test\n"), 0666); err != nil {
t.Fatal(err)
}
for i, content := range cSources35779 {
csrcFile := filepath.Join(dir, fmt.Sprintf("x%d.c", i))
csrcs = append(csrcs, csrcFile)
- if err := ioutil.WriteFile(csrcFile, []byte(content), 0444); err != nil {
+ if err := os.WriteFile(csrcFile, []byte(content), 0444); err != nil {
t.Fatal(err)
}
}
goFile := filepath.Join(dir, "main.go")
- if err := ioutil.WriteFile(goFile, []byte(goSource), 0444); err != nil {
+ if err := os.WriteFile(goFile, []byte(goSource), 0444); err != nil {
t.Fatal(err)
}
t.Parallel()
goFile := filepath.Join(t.TempDir(), "notes.go")
- if err := ioutil.WriteFile(goFile, []byte(goSource), 0444); err != nil {
+ if err := os.WriteFile(goFile, []byte(goSource), 0444); err != nil {
t.Fatal(err)
}
outFile := filepath.Join(t.TempDir(), "notes.exe")
package ld
import (
- intdwarf "cmd/internal/dwarf"
- objfilepkg "cmd/internal/objfile" // renamed to avoid conflict with objfile function
- "cmd/link/internal/dwtest"
"debug/dwarf"
"debug/pe"
"fmt"
"internal/testenv"
"io"
- "io/ioutil"
"os"
"os/exec"
"path/filepath"
"strconv"
"strings"
"testing"
+
+ intdwarf "cmd/internal/dwarf"
+ objfilepkg "cmd/internal/objfile" // renamed to avoid conflict with objfile function
+ "cmd/link/internal/dwtest"
)
const (
src := filepath.Join(dir, "test.go")
dst := filepath.Join(dir, "out.exe")
- if err := ioutil.WriteFile(src, []byte(testfile), 0666); err != nil {
+ if err := os.WriteFile(src, []byte(testfile), 0666); err != nil {
t.Fatal(err)
}
t.Parallel()
- tmpdir, err := ioutil.TempDir("", "TestIssue42484")
+ tmpdir, err := os.MkdirTemp("", "TestIssue42484")
if err != nil {
t.Fatalf("could not create directory: %v", err)
}
import (
"debug/elf"
"internal/testenv"
- "io/ioutil"
"os"
"os/exec"
"path/filepath"
}
`
src := filepath.Join(dir, "issue33358.go")
- if err := ioutil.WriteFile(src, []byte(prog), 0666); err != nil {
+ if err := os.WriteFile(src, []byte(prog), 0666); err != nil {
t.Fatal(err)
}
package ld
import (
- "cmd/internal/objabi"
"internal/testenv"
- "io/ioutil"
+ "os"
"os/exec"
"path/filepath"
"reflect"
"runtime"
"testing"
+
+ "cmd/internal/objabi"
)
func TestDedupLibraries(t *testing.T) {
//go:cgo_import_dynamic _ _ "libc.so"
func main() {}`
- if err := ioutil.WriteFile(srcFile, []byte(src), 0644); err != nil {
+ if err := os.WriteFile(srcFile, []byte(src), 0644); err != nil {
t.Fatal(err)
}
package ld
import (
- "cmd/internal/goobj"
- "cmd/link/internal/loader"
- "cmd/link/internal/sym"
- "io/ioutil"
"log"
"os"
"path"
"path/filepath"
"strconv"
"strings"
+
+ "cmd/internal/goobj"
+ "cmd/link/internal/loader"
+ "cmd/link/internal/sym"
)
func (ctxt *Link) readImportCfg(file string) {
ctxt.PackageFile = make(map[string]string)
ctxt.PackageShlib = make(map[string]string)
- data, err := ioutil.ReadFile(file)
+ data, err := os.ReadFile(file)
if err != nil {
log.Fatalf("-importcfg: %v", err)
}
l.Fingerprint = fingerprint
if shlib != "" {
if strings.HasSuffix(shlib, ".shlibname") {
- data, err := ioutil.ReadFile(shlib)
+ data, err := os.ReadFile(shlib)
if err != nil {
Errorf(nil, "cannot read %s: %v", shlib, err)
}
"debug/pe"
"fmt"
"internal/testenv"
- "io/ioutil"
+ "os"
"os/exec"
"path/filepath"
"runtime"
srcfile := filepath.Join(dir, "test.go")
arfile := filepath.Join(dir, "test.a")
- if err := ioutil.WriteFile(srcfile, []byte(carchiveSrcText), 0666); err != nil {
+ if err := os.WriteFile(srcfile, []byte(carchiveSrcText), 0666); err != nil {
t.Fatal(err)
}
srcfile := filepath.Join(dir, "test.go")
objfile := filepath.Join(dir, "test.dll")
- if err := ioutil.WriteFile(srcfile, []byte(`package main; func main() { print("hello") }`), 0666); err != nil {
+ if err := os.WriteFile(srcfile, []byte(`package main; func main() { print("hello") }`), 0666); err != nil {
t.Fatal(err)
}
argv := []string{"build", "-buildmode=c-shared"}
t.Parallel()
tempDir := t.TempDir()
src := filepath.Join(tempDir, "x.go")
- if err := ioutil.WriteFile(src, []byte(tt.prog), 0644); err != nil {
+ if err := os.WriteFile(src, []byte(tt.prog), 0644); err != nil {
t.Fatal(err)
}
cmd := exec.Command(testenv.GoToolPath(t), "run", src)
import (
"bytes"
- "cmd/internal/bio"
- "cmd/internal/goobj"
- "cmd/internal/notsha256"
- "cmd/internal/objabi"
- "cmd/internal/sys"
- "cmd/link/internal/loadelf"
- "cmd/link/internal/loader"
- "cmd/link/internal/loadmacho"
- "cmd/link/internal/loadpe"
- "cmd/link/internal/loadxcoff"
- "cmd/link/internal/sym"
"debug/elf"
"debug/macho"
"encoding/base64"
"fmt"
"internal/buildcfg"
"io"
- "io/ioutil"
"log"
"os"
"os/exec"
"runtime"
"strings"
"sync"
+
+ "cmd/internal/bio"
+ "cmd/internal/goobj"
+ "cmd/internal/notsha256"
+ "cmd/internal/objabi"
+ "cmd/internal/sys"
+ "cmd/link/internal/loadelf"
+ "cmd/link/internal/loader"
+ "cmd/link/internal/loadmacho"
+ "cmd/link/internal/loadpe"
+ "cmd/link/internal/loadxcoff"
+ "cmd/link/internal/sym"
)
// Data layout and relocation.
// create temporary directory and arrange cleanup
if *flagTmpdir == "" {
- dir, err := ioutil.TempDir("", "go-link-")
+ dir, err := os.MkdirTemp("", "go-link-")
if err != nil {
log.Fatal(err)
}
}
INSERT AFTER .debug_types;
`
- err := ioutil.WriteFile(path, []byte(src), 0666)
+ err := os.WriteFile(path, []byte(src), 0666)
if err != nil {
Errorf(nil, "WriteFile %s failed: %v", name, err)
}
func linkerFlagSupported(arch *sys.Arch, linker, altLinker, flag string) bool {
createTrivialCOnce.Do(func() {
src := filepath.Join(*flagTmpdir, "trivial.c")
- if err := ioutil.WriteFile(src, []byte("int main() { return 0; }"), 0666); err != nil {
+ if err := os.WriteFile(src, []byte("int main() { return 0; }"), 0666); err != nil {
Errorf(nil, "WriteFile trivial.c failed: %v", err)
}
})
import (
"bytes"
- "cmd/internal/objabi"
- "cmd/link/internal/loader"
- "cmd/link/internal/sym"
"encoding/binary"
"fmt"
- "io/ioutil"
"math/bits"
+ "os"
"path/filepath"
"sort"
"strings"
"sync"
+
+ "cmd/internal/objabi"
+ "cmd/link/internal/loader"
+ "cmd/link/internal/sym"
)
// This file handles all algorithms related to XCOFF files generation.
buf.Write([]byte(name + "\n"))
}
- err := ioutil.WriteFile(fname, buf.Bytes(), 0666)
+ err := os.WriteFile(fname, buf.Bytes(), 0666)
if err != nil {
Errorf(nil, "WriteFile %s failed: %v", fname, err)
}
import (
"bufio"
"bytes"
- "cmd/internal/sys"
"debug/macho"
"internal/buildcfg"
"internal/testenv"
- "io/ioutil"
"os"
"os/exec"
"path/filepath"
"runtime"
"strings"
"testing"
+
+ "cmd/internal/sys"
)
var AuthorPaidByTheColumnInch struct {
tmpdir := t.TempDir()
- err := ioutil.WriteFile(filepath.Join(tmpdir, "main.go"), []byte(source), 0666)
+ err := os.WriteFile(filepath.Join(tmpdir, "main.go"), []byte(source), 0666)
if err != nil {
t.Fatalf("failed to write main.go: %v\n", err)
}
tmpdir := t.TempDir()
write := func(name, content string) {
- err := ioutil.WriteFile(filepath.Join(tmpdir, name), []byte(content), 0666)
+ err := os.WriteFile(filepath.Join(tmpdir, name), []byte(content), 0666)
if err != nil {
t.Fatal(err)
}
tmpdir := t.TempDir()
write := func(name, content string) {
- err := ioutil.WriteFile(filepath.Join(tmpdir, name), []byte(content), 0666)
+ err := os.WriteFile(filepath.Join(tmpdir, name), []byte(content), 0666)
if err != nil {
t.Fatal(err)
}
tmpdir := t.TempDir()
write := func(name, content string) {
- err := ioutil.WriteFile(filepath.Join(tmpdir, name), []byte(content), 0666)
+ err := os.WriteFile(filepath.Join(tmpdir, name), []byte(content), 0666)
if err != nil {
t.Fatal(err)
}
tmpdir := t.TempDir()
src := filepath.Join(tmpdir, "main.go")
- err := ioutil.WriteFile(src, []byte(testXFlagSrc), 0666)
+ err := os.WriteFile(src, []byte(testXFlagSrc), 0666)
if err != nil {
t.Fatal(err)
}
tmpdir := t.TempDir()
src := filepath.Join(tmpdir, "main.go")
- err := ioutil.WriteFile(src, []byte(testMachOBuildVersionSrc), 0666)
+ err := os.WriteFile(src, []byte(testMachOBuildVersionSrc), 0666)
if err != nil {
t.Fatal(err)
}
tmpdir := t.TempDir()
src := filepath.Join(tmpdir, "blah.go")
- err := ioutil.WriteFile(src, []byte(Issue34788src), 0666)
+ err := os.WriteFile(src, []byte(Issue34788src), 0666)
if err != nil {
t.Fatal(err)
}
tmpdir := t.TempDir()
src := filepath.Join(tmpdir, "x.go")
- err := ioutil.WriteFile(src, []byte(testStrictDupGoSrc), 0666)
+ err := os.WriteFile(src, []byte(testStrictDupGoSrc), 0666)
if err != nil {
t.Fatal(err)
}
for _, af := range asmfiles {
src = filepath.Join(tmpdir, af.fname+".s")
- err = ioutil.WriteFile(src, []byte(af.payload), 0666)
+ err = os.WriteFile(src, []byte(af.payload), 0666)
if err != nil {
t.Fatal(err)
}
}
src = filepath.Join(tmpdir, "go.mod")
- err = ioutil.WriteFile(src, []byte("module teststrictdup\n"), 0666)
+ err = os.WriteFile(src, []byte("module teststrictdup\n"), 0666)
if err != nil {
t.Fatal(err)
}
tmpdir := t.TempDir()
src := filepath.Join(tmpdir, "go.mod")
- err := ioutil.WriteFile(src, []byte("module cmd/link/TestFuncAlign/falign"), 0666)
+ err := os.WriteFile(src, []byte("module cmd/link/TestFuncAlign/falign"), 0666)
if err != nil {
t.Fatal(err)
}
src = filepath.Join(tmpdir, "falign.go")
- err = ioutil.WriteFile(src, []byte(testFuncAlignSrc), 0666)
+ err = os.WriteFile(src, []byte(testFuncAlignSrc), 0666)
if err != nil {
t.Fatal(err)
}
src = filepath.Join(tmpdir, "falign.s")
- err = ioutil.WriteFile(src, []byte(testFuncAlignAsmSrc), 0666)
+ err = os.WriteFile(src, []byte(testFuncAlignAsmSrc), 0666)
if err != nil {
t.Fatal(err)
}
tmpdir := t.TempDir()
src := filepath.Join(tmpdir, "hello.go")
- err := ioutil.WriteFile(src, []byte(testTrampSrc), 0666)
+ err := os.WriteFile(src, []byte(testTrampSrc), 0666)
if err != nil {
t.Fatal(err)
}
tmpdir := t.TempDir()
src := filepath.Join(tmpdir, "hello.go")
- err := ioutil.WriteFile(src, []byte(testTrampCgoSrc), 0666)
+ err := os.WriteFile(src, []byte(testTrampCgoSrc), 0666)
if err != nil {
t.Fatal(err)
}
}
// Check that the binary contains the rsrc data
- b, err := ioutil.ReadFile(exe)
+ b, err := os.ReadFile(exe)
if err != nil {
t.Fatalf("reading output failed: %v", err)
}
}
// Check that the binary contains the rsrc data
- b, err := ioutil.ReadFile(exe)
+ b, err := os.ReadFile(exe)
if err != nil {
t.Fatalf("reading output failed: %v", err)
}
tmpdir := t.TempDir()
src := filepath.Join(tmpdir, "x.go")
- err := ioutil.WriteFile(src, []byte(testIssue38554Src), 0666)
+ err := os.WriteFile(src, []byte(testIssue38554Src), 0666)
if err != nil {
t.Fatalf("failed to write source file: %v", err)
}
tmpdir := t.TempDir()
src := filepath.Join(tmpdir, "main.go")
- err := ioutil.WriteFile(src, []byte(testIssue42396src), 0666)
+ err := os.WriteFile(src, []byte(testIssue42396src), 0666)
if err != nil {
t.Fatalf("failed to write source file: %v", err)
}
tmpdir := t.TempDir()
src := filepath.Join(tmpdir, "x.go")
- err := ioutil.WriteFile(src, []byte(testLargeRelocSrc), 0666)
+ err := os.WriteFile(src, []byte(testLargeRelocSrc), 0666)
if err != nil {
t.Fatalf("failed to write source file: %v", err)
}
xObj := filepath.Join(tmpdir, "x.o")
pObj := filepath.Join(tmpdir, "p.o")
exe := filepath.Join(tmpdir, "x.exe")
- err := ioutil.WriteFile(xSrc, []byte("package main\nimport _ \"p\"\nfunc main() {}\n"), 0666)
+ err := os.WriteFile(xSrc, []byte("package main\nimport _ \"p\"\nfunc main() {}\n"), 0666)
if err != nil {
t.Fatalf("failed to write source file: %v", err)
}
- err = ioutil.WriteFile(pSrc, []byte("package p\n"), 0666)
+ err = os.WriteFile(pSrc, []byte("package p\n"), 0666)
if err != nil {
t.Fatalf("failed to write source file: %v", err)
}
"fmt"
"internal/buildcfg"
"internal/testenv"
- "io/ioutil"
+ "os"
"os/exec"
"testing"
)
const FN = 4
tmpdir := t.TempDir()
- if err := ioutil.WriteFile(tmpdir+"/go.mod", []byte("module big_test\n"), 0666); err != nil {
+ if err := os.WriteFile(tmpdir+"/go.mod", []byte("module big_test\n"), 0666); err != nil {
t.Fatal(err)
}
fmt.Fprintf(&w, inst)
}
fmt.Fprintf(&w, "\tRET\n")
- err := ioutil.WriteFile(tmpdir+"/"+testname+".s", w.Bytes(), 0666)
+ err := os.WriteFile(tmpdir+"/"+testname+".s", w.Bytes(), 0666)
if err != nil {
t.Fatalf("can't write output: %v\n", err)
}
fmt.Fprintf(&w, "\t}\n")
fmt.Fprintf(&w, "\tfmt.Printf(\"PASS\\n\")\n")
fmt.Fprintf(&w, "}")
- err := ioutil.WriteFile(tmpdir+"/bigfn.go", w.Bytes(), 0666)
+ err := os.WriteFile(tmpdir+"/bigfn.go", w.Bytes(), 0666)
if err != nil {
t.Fatalf("can't write output: %v\n", err)
}
"fmt"
"internal/godebug"
"io"
- "io/ioutil"
"math/bits"
"os"
"path/filepath"
// be saved in a MalformedCorpusError and returned, along with the most recent
// error.
func ReadCorpus(dir string, types []reflect.Type) ([]CorpusEntry, error) {
- files, err := ioutil.ReadDir(dir)
+ files, err := os.ReadDir(dir)
if os.IsNotExist(err) {
return nil, nil // No corpus to read
} else if err != nil {
continue
}
filename := filepath.Join(dir, file.Name())
- data, err := ioutil.ReadFile(filename)
+ data, err := os.ReadFile(filename)
if err != nil {
return nil, fmt.Errorf("failed to read corpus file: %v", err)
}
if err := os.MkdirAll(dir, 0777); err != nil {
return err
}
- if err := ioutil.WriteFile(entry.Path, entry.Data, 0666); err != nil {
+ if err := os.WriteFile(entry.Path, entry.Data, 0666); err != nil {
os.Remove(entry.Path) // remove partially written file
return err
}
import (
"fmt"
- "io/ioutil"
"os"
"unsafe"
)
// it into memory. The file will be removed when the Close method is called.
func sharedMemTempFile(size int) (m *sharedMem, err error) {
// Create a temporary file.
- f, err := ioutil.TempFile("", "fuzz-*")
+ f, err := os.CreateTemp("", "fuzz-*")
if err != nil {
return nil, err
}
"errors"
"fmt"
"io"
- "io/ioutil"
"os"
"os/exec"
"reflect"
// Drain fuzzOut and close it. When the server exits, the kernel will close
// its end of fuzzOut, and we'll get EOF.
- if _, err := io.Copy(ioutil.Discard, wc.fuzzOut); err != nil {
+ if _, err := io.Copy(io.Discard, wc.fuzzOut); err != nil {
wc.fuzzOut.Close()
return err
}
import (
"bytes"
"fmt"
- "io/ioutil"
+ "os"
"strings"
)
// ParseFile parses the named file as an archive.
func ParseFile(file string) (*Archive, error) {
- data, err := ioutil.ReadFile(file)
+ data, err := os.ReadFile(file)
if err != nil {
return nil, err
}