https://pkg.go.dev/io/ioutil is deprecated since Go 1.16.
"bytes"
"errors"
"io"
- "io/ioutil"
"os"
"path/filepath"
"strings"
if r := c.getOrRemove(id); r != nil {
defer r.Close()
- b, err := ioutil.ReadAll(r)
+ b, err := io.ReadAll(r)
return info, b, err
}
if r := c.getOrRemove(id); r != nil {
defer r.Close()
- b, err := ioutil.ReadAll(r)
+ b, err := io.ReadAll(r)
return info, b, err
}
}
defer f.Close()
- b, _ := ioutil.ReadAll(f)
+ b, _ := io.ReadAll(f)
return string(b)
}
"errors"
"fmt"
"io"
- "io/ioutil"
- "os"
"path/filepath"
"strings"
"sync"
t.Parallel()
c := qt.New(t)
- tempWorkingDir, err := ioutil.TempDir("", "hugo_filecache_test_work")
- c.Assert(err, qt.IsNil)
- defer os.Remove(tempWorkingDir)
-
- tempCacheDir, err := ioutil.TempDir("", "hugo_filecache_test_cache")
- c.Assert(err, qt.IsNil)
- defer os.Remove(tempCacheDir)
+ tempWorkingDir := t.TempDir()
+ tempCacheDir := t.TempDir()
osfs := afero.NewOsFs()
io.Closer
}{
strings.NewReader(s),
- ioutil.NopCloser(nil),
+ io.NopCloser(nil),
}, nil
}
}
c.Assert(err, qt.IsNil)
c.Assert(r, qt.Not(qt.IsNil))
c.Assert(info.Name, qt.Equals, "a")
- b, _ := ioutil.ReadAll(r)
+ b, _ := io.ReadAll(r)
r.Close()
c.Assert(string(b), qt.Equals, "abc")
_, r, err = ca.GetOrCreate("a", rf("bcd"))
c.Assert(err, qt.IsNil)
- b, _ = ioutil.ReadAll(r)
+ b, _ = io.ReadAll(r)
r.Close()
c.Assert(string(b), qt.Equals, "abc")
}
c.Assert(err, qt.IsNil)
c.Assert(r, qt.Not(qt.IsNil))
c.Assert(info.Name, qt.Equals, "mykey")
- b, _ := ioutil.ReadAll(r)
+ b, _ := io.ReadAll(r)
r.Close()
c.Assert(string(b), qt.Equals, "Hugo is great!")
return hugio.ToReadCloser(strings.NewReader(data)), nil
})
c.Assert(err, qt.IsNil)
- b, _ := ioutil.ReadAll(r)
+ b, _ := io.ReadAll(r)
r.Close()
c.Assert(string(b), qt.Equals, data)
// Trigger some expiration.
return errors.New("fail")
}
- b, _ := ioutil.ReadAll(r)
+ b, _ := io.ReadAll(r)
result = string(b)
return nil
import (
"errors"
"fmt"
- "io/ioutil"
+ "io"
"net"
"os"
"path/filepath"
rebuildDebouncer = debounce.New(4 * time.Second)
}
- out := ioutil.Discard
+ out := io.Discard
if !h.quiet {
out = os.Stdout
}
running: running,
// This will be replaced later, but we need something to log to before the configuration is read.
- logger: loggers.NewLogger(jww.LevelWarn, jww.LevelError, out, ioutil.Discard, running),
+ logger: loggers.NewLogger(jww.LevelWarn, jww.LevelError, out, io.Discard, running),
}
return c, c.loadConfig()
import (
"fmt"
- "io/ioutil"
"os"
"path/filepath"
"testing"
func writeFile(t testing.TB, filename, content string) {
must(t, os.MkdirAll(filepath.Dir(filename), os.FileMode(0755)))
- must(t, ioutil.WriteFile(filename, []byte(content), os.FileMode(0755)))
+ must(t, os.WriteFile(filename, []byte(content), os.FileMode(0755)))
}
func must(t testing.TB, err error) {
import (
"context"
"fmt"
- "io/ioutil"
+ "io"
"os"
"os/signal"
"path/filepath"
func (c *commandeer) createLogger(cfg config.Provider) (loggers.Logger, error) {
var (
- logHandle = ioutil.Discard
+ logHandle = io.Discard
logThreshold = jww.LevelWarn
logFile = cfg.GetString("logFile")
- outHandle = ioutil.Discard
+ outHandle = io.Discard
stdoutThreshold = jww.LevelWarn
)
return nil, newSystemError("Failed to open log file:", logFile, err)
}
} else {
- logHandle, err = ioutil.TempFile("", "hugo")
+ logHandle, err = os.CreateTemp("", "hugo")
if err != nil {
return nil, newSystemError(err)
}
"bytes"
"errors"
"fmt"
- "io/ioutil"
+ "io"
"os"
"path/filepath"
"regexp"
func (i *importCmd) getJekyllDirInfo(fs afero.Fs, jekyllRoot string) (map[string]bool, bool) {
postDirs := make(map[string]bool)
hasAnyPost := false
- if entries, err := ioutil.ReadDir(jekyllRoot); err == nil {
+ if entries, err := os.ReadDir(jekyllRoot); err == nil {
for _, entry := range entries {
if entry.IsDir() {
subDir := filepath.Join(jekyllRoot, entry.Name())
return true, !isEmpty
}
- if entries, err := ioutil.ReadDir(dir); err == nil {
+ if entries, err := os.ReadDir(dir); err == nil {
for _, entry := range entries {
if entry.IsDir() {
subDir := filepath.Join(dir, entry.Name())
defer f.Close()
- b, err := ioutil.ReadAll(f)
+ b, err := io.ReadAll(f)
if err != nil {
return nil
}
if err != nil {
return err
}
- entries, err := ioutil.ReadDir(jekyllRoot)
+ entries, err := os.ReadDir(jekyllRoot)
if err != nil {
return err
}
targetParentDir := filepath.Dir(targetFile)
os.MkdirAll(targetParentDir, 0777)
- contentBytes, err := ioutil.ReadFile(path)
+ contentBytes, err := os.ReadFile(path)
if err != nil {
jww.ERROR.Println("Read file error:", path)
return err
import (
"io"
- "io/ioutil"
"path/filepath"
"strings"
ectx := &ErrorContext{LinesPos: -1, Position: text.Position{Offset: -1}}
- b, err := ioutil.ReadAll(r)
+ b, err := io.ReadAll(r)
if err != nil {
return ectx
}
import (
"io"
- "io/ioutil"
)
// As implemented by strings.Builder.
io.Closer
}{
w,
- ioutil.NopCloser(nil),
+ io.NopCloser(nil),
}
}
io.Closer
}{
r,
- ioutil.NopCloser(nil),
+ io.NopCloser(nil),
}
}
"bytes"
"fmt"
"io"
- "io/ioutil"
"log"
"os"
"regexp"
*jww.Notepad
// The writer that represents stdout.
- // Will be ioutil.Discard when in quiet mode.
+ // Will be io.Discard when in quiet mode.
out io.Writer
logCounters *LogCounters
// NewBasicLogger creates a new basic logger writing to Stdout.
func NewBasicLogger(t jww.Threshold) Logger {
- return newLogger(t, jww.LevelError, os.Stdout, ioutil.Discard, false)
+ return newLogger(t, jww.LevelError, os.Stdout, io.Discard, false)
}
// NewBasicLoggerForWriter creates a new basic logger writing to w.
func NewBasicLoggerForWriter(t jww.Threshold, w io.Writer) Logger {
- return newLogger(t, jww.LevelError, w, ioutil.Discard, false)
+ return newLogger(t, jww.LevelError, w, io.Discard, false)
}
// RemoveANSIColours removes all ANSI colours from the given string.
func getLogWriters(outHandle, logHandle io.Writer) (io.Writer, io.Writer) {
isTerm := terminal.PrintANSIColors(os.Stdout)
- if logHandle != ioutil.Discard && isTerm {
+ if logHandle != io.Discard && isTerm {
// Remove any Ansi coloring from log output
logHandle = ansiCleaner{w: logHandle}
}
"encoding/hex"
"fmt"
"io"
- "io/ioutil"
"mime"
"os"
"path/filepath"
// We've got the gzipped contents cached in gzipped.
// Note: we can't use lf.gzipped directly as a Reader, since we it discards
// data after it is read, and we may read it more than once.
- return ioutil.NopCloser(bytes.NewReader(lf.gzipped.Bytes())), nil
+ return io.NopCloser(bytes.NewReader(lf.gzipped.Bytes())), nil
}
// Not expected to fail since we did it successfully earlier in newLocalFile,
// but could happen due to changes in the underlying filesystem.
"crypto/md5"
"fmt"
"io"
- "io/ioutil"
"os"
"path"
"path/filepath"
if err != nil {
t.Fatal(err)
}
- gotContent, err := ioutil.ReadAll(r)
+ gotContent, err := io.ReadAll(r)
if err != nil {
t.Fatal(err)
}
if err != nil {
t.Fatal(err)
}
- gotContent, err = ioutil.ReadAll(r)
+ gotContent, err = io.ReadAll(r)
if err != nil {
t.Fatal(err)
}
// 1. An in-memory afero.Fs paired with an in-memory Go CDK bucket.
// 2. A filesystem-based afero.Fs paired with an filesystem-based Go CDK bucket.
// It returns the pair of tests and a cleanup function.
-func initFsTests() ([]*fsTest, func(), error) {
- tmpfsdir, err := ioutil.TempDir("", "fs")
- if err != nil {
- return nil, nil, err
- }
- tmpbucketdir, err := ioutil.TempDir("", "bucket")
- if err != nil {
- return nil, nil, err
- }
+func initFsTests(t *testing.T) []*fsTest {
+ t.Helper()
+
+ tmpfsdir := t.TempDir()
+ tmpbucketdir := t.TempDir()
memfs := afero.NewMemMapFs()
membucket := memblob.OpenBucket(nil)
+ t.Cleanup(func() { membucket.Close() })
filefs := afero.NewBasePathFs(afero.NewOsFs(), tmpfsdir)
filebucket, err := fileblob.OpenBucket(tmpbucketdir, nil)
if err != nil {
- return nil, nil, err
+ t.Fatal(err)
}
+ t.Cleanup(func() { filebucket.Close() })
tests := []*fsTest{
{"mem", memfs, membucket},
{"file", filefs, filebucket},
}
- cleanup := func() {
- membucket.Close()
- filebucket.Close()
- os.RemoveAll(tmpfsdir)
- os.RemoveAll(tmpbucketdir)
- }
- return tests, cleanup, nil
+ return tests
}
// TestEndToEndSync verifies that basic adds, updates, and deletes are working
// correctly.
func TestEndToEndSync(t *testing.T) {
ctx := context.Background()
- tests, cleanup, err := initFsTests()
- if err != nil {
- t.Fatal(err)
- }
- defer cleanup()
+ tests := initFsTests(t)
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
local, err := initLocalFs(ctx, test.fs)
// TestMaxDeletes verifies that the "maxDeletes" flag is working correctly.
func TestMaxDeletes(t *testing.T) {
ctx := context.Background()
- tests, cleanup, err := initFsTests()
- if err != nil {
- t.Fatal(err)
- }
- defer cleanup()
+ tests := initFsTests(t)
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
local, err := initLocalFs(ctx, test.fs)
}
for _, test := range tests {
t.Run(fmt.Sprintf("include %q exclude %q", test.Include, test.Exclude), func(t *testing.T) {
- fsTests, cleanup, err := initFsTests()
- if err != nil {
- t.Fatal(err)
- }
- defer cleanup()
+ fsTests := initFsTests(t)
fsTest := fsTests[1] // just do file-based test
- _, err = initLocalFs(ctx, fsTest.fs)
+ _, err := initLocalFs(ctx, fsTest.fs)
if err != nil {
t.Fatal(err)
}
}
for _, test := range tests {
t.Run(fmt.Sprintf("include %q exclude %q", test.Include, test.Exclude), func(t *testing.T) {
- fsTests, cleanup, err := initFsTests()
- if err != nil {
- t.Fatal(err)
- }
- defer cleanup()
+ fsTests := initFsTests(t)
fsTest := fsTests[1] // just do file-based test
local, err := initLocalFs(ctx, fsTest.fs)
func TestCompression(t *testing.T) {
ctx := context.Background()
- tests, cleanup, err := initFsTests()
- if err != nil {
- t.Fatal(err)
- }
- defer cleanup()
+ tests := initFsTests(t)
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
local, err := initLocalFs(ctx, test.fs)
// attribute for matcher works.
func TestMatching(t *testing.T) {
ctx := context.Background()
- tests, cleanup, err := initFsTests()
- if err != nil {
- t.Fatal(err)
- }
- defer cleanup()
+ tests := initFsTests(t)
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
_, err := initLocalFs(ctx, test.fs)
import (
"fmt"
- "io/ioutil"
"os"
"path/filepath"
"reflect"
func createZeroSizedFileInTempDir() (*os.File, error) {
filePrefix := "_path_test_"
- f, e := ioutil.TempFile("", filePrefix) // dir is os.TempDir()
+ f, e := os.CreateTemp("", filePrefix) // dir is os.TempDir()
if e != nil {
// if there was an error no file was created.
// => no requirement to delete the file
return nil, err
}
byteString := []byte("byteString")
- err = ioutil.WriteFile(f.Name(), byteString, 0644)
+ err = os.WriteFile(f.Name(), byteString, 0644)
if err != nil {
// delete the file
deleteFileInTempDir(f)
_ = os.Remove(f.Name())
}
-func createEmptyTempDir() (string, error) {
- dirPrefix := "_dir_prefix_"
- d, e := ioutil.TempDir("", dirPrefix) // will be in os.TempDir()
- if e != nil {
- // no directory to delete - it was never created
- return "", e
- }
- return d, nil
-}
-
-func deleteTempDir(d string) {
- _ = os.RemoveAll(d)
-}
-
func TestExists(t *testing.T) {
zeroSizedFile, _ := createZeroSizedFileInTempDir()
defer deleteFileInTempDir(zeroSizedFile)
nonZeroSizedFile, _ := createNonZeroSizedFileInTempDir()
defer deleteFileInTempDir(nonZeroSizedFile)
- emptyDirectory, _ := createEmptyTempDir()
- defer deleteTempDir(emptyDirectory)
+ emptyDirectory := t.TempDir()
nonExistentFile := os.TempDir() + "/this-file-does-not-exist.txt"
nonExistentDir := os.TempDir() + "/this/directory/does/not/exist/"
func TestSafeWriteToDisk(t *testing.T) {
emptyFile, _ := createZeroSizedFileInTempDir()
defer deleteFileInTempDir(emptyFile)
- tmpDir, _ := createEmptyTempDir()
- defer deleteTempDir(tmpDir)
+ tmpDir := t.TempDir()
randomString := "This is a random string!"
reader := strings.NewReader(randomString)
if d.expectedErr != e {
t.Errorf("Test %d failed. Expected %q but got %q", i, d.expectedErr, e)
}
- contents, _ := ioutil.ReadFile(d.filename)
+ contents, _ := os.ReadFile(d.filename)
if randomString != string(contents) {
t.Errorf("Test %d failed. Expected contents %q but got %q", i, randomString, string(contents))
}
func TestWriteToDisk(t *testing.T) {
emptyFile, _ := createZeroSizedFileInTempDir()
defer deleteFileInTempDir(emptyFile)
- tmpDir, _ := createEmptyTempDir()
- defer deleteTempDir(tmpDir)
+ tmpDir := t.TempDir()
randomString := "This is a random string!"
reader := strings.NewReader(randomString)
if d.expectedErr != e {
t.Errorf("Test %d failed. WriteToDisk Error Expected %q but got %q", i, d.expectedErr, e)
}
- contents, e := ioutil.ReadFile(d.filename)
+ contents, e := os.ReadFile(d.filename)
if e != nil {
t.Errorf("Test %d failed. Could not read file %s. Reason: %s\n", i, d.filename, e)
}
import (
"fmt"
- "io/ioutil"
+ "io"
"path/filepath"
"sort"
"testing"
tf, err := testfilem.Open()
c.Assert(err, qt.IsNil)
defer tf.Close()
- b, err := ioutil.ReadAll(tf)
+ b, err := io.ReadAll(tf)
c.Assert(err, qt.IsNil)
c.Assert(string(b), qt.Equals, "some no content")
import (
"fmt"
"io"
- "io/ioutil"
"math/rand"
"net/http"
"net/http/httptest"
case "/post":
w.Header().Set("Content-Type", "text/plain")
if r.Method == http.MethodPost {
- body, err := ioutil.ReadAll(r.Body)
+ body, err := io.ReadAll(r.Body)
if err != nil {
http.Error(w, "Internal server error", http.StatusInternalServerError)
return
import (
"bytes"
"fmt"
- "io/ioutil"
+ "io"
"testing"
"github.com/gohugoio/hugo/helpers"
h.Sites[1].PathSpec.ProcessingStats,
}
- stats[0].Table(ioutil.Discard)
- stats[1].Table(ioutil.Discard)
+ stats[0].Table(io.Discard)
+ stats[1].Table(io.Discard)
var buff bytes.Buffer
"context"
"encoding/json"
"fmt"
- "io/ioutil"
"os"
"path/filepath"
"strings"
b.Build(BuildCfg{})
contentMem := b.FileContent(statsFilename)
- cb, err := ioutil.ReadFile(statsFilename)
+ cb, err := os.ReadFile(statsFilename)
b.Assert(err, qt.IsNil)
contentFile := string(cb)
"bytes"
"errors"
"fmt"
- "io/ioutil"
+ "io"
"os"
"path"
"path/filepath"
if err := sh.Run(goexe, "test", "-coverprofile="+cover, "-covermode=count", pkg); err != nil {
return err
}
- b, err := ioutil.ReadFile(cover)
+ b, err := io.ReadFile(cover)
if err != nil {
if os.IsNotExist(err) {
continue
import (
"encoding/json"
- "io/ioutil"
+ "os"
"path/filepath"
"sort"
"strings"
for _, filename := range files {
name := filepath.Base(filename)
c.Run(name, func(c *qt.C) {
- content, err := ioutil.ReadFile(filename)
+ content, err := os.ReadFile(filename)
c.Assert(err, qt.IsNil)
ext := strings.TrimPrefix(paths.Ext(filename), ".")
var exts []string
for _, filename := range files {
name := filepath.Base(filename)
c.Run(name, func(c *qt.C) {
- content, err := ioutil.ReadFile(filename)
+ content, err := os.ReadFile(filename)
c.Assert(err, qt.IsNil)
ext := strings.TrimPrefix(paths.Ext(filename), ".")
got := FromContent(mtypes, []string{ext}, content)
"encoding/json"
"fmt"
"io"
- "io/ioutil"
"os"
"os/exec"
"path/filepath"
}
func (c *Client) runVerify() error {
- return c.runGo(context.Background(), ioutil.Discard, "mod", "verify")
+ return c.runGo(context.Background(), io.Discard, "mod", "verify")
}
func isProbablyModule(path string) bool {
downloadModules := func(modules ...string) error {
args := []string{"mod", "download"}
args = append(args, modules...)
- out := ioutil.Discard
+ out := io.Discard
err := c.runGo(context.Background(), out, args...)
if err != nil {
return fmt.Errorf("failed to download modules: %w", err)
"errors"
"fmt"
"io"
- "io/ioutil"
"regexp"
"strings"
}
func parseSection(r io.Reader, cfg Config, start stateFunc) (Result, error) {
- b, err := ioutil.ReadAll(r)
+ b, err := io.ReadAll(r)
if err != nil {
return nil, fmt.Errorf("failed to read page content: %w", err)
}
_ "image/gif"
_ "image/png"
"io"
- "io/ioutil"
"os"
"path"
"path/filepath"
read := func(info filecache.ItemInfo, r io.ReadSeeker) error {
meta := &imageMeta{}
- data, err := ioutil.ReadAll(r)
+ data, err := io.ReadAll(r)
if err != nil {
return err
}
"fmt"
"image"
"image/gif"
- "io/ioutil"
"math/big"
"math/rand"
"os"
func assetGoldenDirs(c *qt.C, dir1, dir2 string) {
// The two dirs above should now be the same.
- dirinfos1, err := ioutil.ReadDir(dir1)
+ dirinfos1, err := os.ReadDir(dir1)
c.Assert(err, qt.IsNil)
- dirinfos2, err := ioutil.ReadDir(dir2)
+ dirinfos2, err := os.ReadDir(dir2)
c.Assert(err, qt.IsNil)
c.Assert(len(dirinfos1), qt.Equals, len(dirinfos2))
"context"
"fmt"
"io"
- "io/ioutil"
"os"
"path"
"path/filepath"
defer r.Close()
var b []byte
- b, err = ioutil.ReadAll(r)
+ b, err = io.ReadAll(r)
if err != nil {
return
}
"bytes"
"fmt"
"io"
- "io/ioutil"
"mime"
"net/http"
"net/http/httputil"
func responseToData(res *http.Response, readBody bool) map[string]any {
var body []byte
if readBody {
- body, _ = ioutil.ReadAll(res.Body)
+ body, _ = io.ReadAll(res.Body)
}
m := map[string]any{
// A response to a HEAD method should not have a body. If it has one anyway, that body must be ignored.
// See https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/HEAD
if !isHeadMethod && res.Body != nil {
- body, err = ioutil.ReadAll(res.Body)
+ body, err = io.ReadAll(res.Body)
if err != nil {
return nil, fmt.Errorf("failed to read remote resource %q: %w", uri, err)
}
"bytes"
"fmt"
"io"
- "io/ioutil"
"os"
"path"
"path/filepath"
// Create compile into a real temp file:
// 1. separate stdout/stderr messages from babel (https://github.com/gohugoio/hugo/issues/8136)
// 2. allow generation and retrieval of external source map.
- compileOutput, err := ioutil.TempFile("", "compileOut-*.js")
+ compileOutput, err := os.CreateTemp("", "compileOut-*.js")
if err != nil {
return err
}
return fmt.Errorf(errBuf.String()+": %w", err)
}
- content, err := ioutil.ReadAll(compileOutput)
+ content, err := io.ReadAll(compileOutput)
if err != nil {
return err
}
mapFile := compileOutput.Name() + ".map"
if _, err := os.Stat(mapFile); err == nil {
defer os.Remove(mapFile)
- sourceMap, err := ioutil.ReadFile(mapFile)
+ sourceMap, err := os.ReadFile(mapFile)
if err != nil {
return err
}
import (
"fmt"
- "io/ioutil"
+ "io"
"os"
"path"
"path/filepath"
ctx.ReplaceOutPathExtension(".js")
}
- src, err := ioutil.ReadAll(ctx.From)
+ src, err := io.ReadAll(ctx.From)
if err != nil {
return err
}
}
if buildOptions.Sourcemap == api.SourceMapExternal && buildOptions.Outdir == "" {
- buildOptions.Outdir, err = ioutil.TempDir(os.TempDir(), "compileOutput")
+ buildOptions.Outdir, err = os.MkdirTemp(os.TempDir(), "compileOutput")
if err != nil {
return err
}
import (
"encoding/json"
"fmt"
- "io/ioutil"
+ "os"
"path/filepath"
"strings"
})
build.OnLoad(api.OnLoadOptions{Filter: `.*`, Namespace: nsImportHugo},
func(args api.OnLoadArgs) (api.OnLoadResult, error) {
- b, err := ioutil.ReadFile(args.Path)
+ b, err := os.ReadFile(args.Path)
if err != nil {
return api.OnLoadResult{}, fmt.Errorf("failed to read %q: %w", args.Path, err)
}
"encoding/hex"
"fmt"
"io"
- "io/ioutil"
"path"
"path/filepath"
"regexp"
func (imp *importResolver) resolve() (io.Reader, error) {
const importIdentifier = "@import"
- content, err := ioutil.ReadAll(imp.r)
+ content, err := io.ReadAll(imp.r)
if err != nil {
return nil, err
}
import (
"image"
"io"
- "io/ioutil"
"os"
"path/filepath"
"runtime"
cfg := createTestCfg()
cfg.Set("baseURL", "https://example.com")
- workDir, err := ioutil.TempDir("", "hugores")
+ workDir, err := os.MkdirTemp("", "hugores")
c.Assert(err, qt.IsNil)
c.Assert(workDir, qt.Not(qt.Equals), "")
import (
"fmt"
- "io/ioutil"
"log"
"os"
"path/filepath"
return nil
}
- data, err := ioutil.ReadFile(path)
+ data, err := os.ReadFile(path)
must(err)
f, err := os.Create(path)
must(err)
import (
"bytes"
"fmt"
- "io/ioutil"
+ "io"
"net/http"
"net/url"
"path/filepath"
}
var b []byte
- b, err = ioutil.ReadAll(res.Body)
+ b, err = io.ReadAll(res.Body)
if err != nil {
return nil, err
}
import (
"fmt"
- "io/ioutil"
+ "io"
gyaml "github.com/ghodss/yaml"
}
defer reader.Close()
- b, err := ioutil.ReadAll(reader)
+ b, err := io.ReadAll(reader)
if err != nil {
return nil, err
}
"fmt"
"html/template"
"io"
- "io/ioutil"
"strings"
"time"
}
// We don't care about any template output.
- w = ioutil.Discard
+ w = io.Discard
} else {
b := bp.GetBuffer()
defer bp.PutBuffer(b)
import (
"fmt"
- "io/ioutil"
+ "io"
"strings"
"github.com/gohugoio/hugo/resources/resource"
}
defer reader.Close()
- b, err := ioutil.ReadAll(reader)
+ b, err := io.ReadAll(reader)
if err != nil {
return nil, err
}
import (
"bytes"
"io"
- "io/ioutil"
+ "os"
bp "github.com/gohugoio/hugo/bufferpool"
"github.com/gohugoio/hugo/common/herrors"
if err := tr(fb); err != nil {
// Write output to a temp file so it can be read by the user for trouble shooting.
filename := "output.html"
- tempfile, ferr := ioutil.TempFile("", "hugo-transform-error")
+ tempfile, ferr := os.CreateTemp("", "hugo-transform-error")
if ferr == nil {
filename = tempfile.Name()
defer tempfile.Close()
import (
"fmt"
- "io/ioutil"
"os"
"path/filepath"
"runtime"
c.Assert(w.Add("foo"), qt.Not(qt.IsNil))
c.Assert(w.Remove("foo"), qt.Not(qt.IsNil))
- f, err := ioutil.TempFile("", "asdf")
+ f, err := os.CreateTemp(t.TempDir(), "asdf")
if err != nil {
t.Fatal(err)
}
- defer os.RemoveAll(f.Name())
c.Assert(w.Add(f.Name()), qt.IsNil)
c.Assert(w.Remove(f.Name()), qt.IsNil)
filename := filepath.Join(subdir, "file1")
// Write to one file.
- c.Assert(ioutil.WriteFile(filename, []byte("changed"), 0600), qt.IsNil)
+ c.Assert(os.WriteFile(filename, []byte("changed"), 0600), qt.IsNil)
var expected []fsnotify.Event
// Add one file.
filename = filepath.Join(subdir, "file3")
- c.Assert(ioutil.WriteFile(filename, []byte("new"), 0600), qt.IsNil)
+ c.Assert(os.WriteFile(filename, []byte("new"), 0600), qt.IsNil)
assertEvents(c, w, fsnotify.Event{Name: filename, Op: fsnotify.Create})
// Remove entire directory.
func TestPollerClose(t *testing.T) {
c := qt.New(t)
w := NewPollingWatcher(watchWaitTime)
- f1, err := ioutil.TempFile("", "f1")
+ f1, err := os.CreateTemp("", "f1")
c.Assert(err, qt.IsNil)
- f2, err := ioutil.TempFile("", "f2")
+ defer os.Remove(f1.Name())
+ f2, err := os.CreateTemp("", "f2")
c.Assert(err, qt.IsNil)
filename1 := f1.Name()
filename2 := f2.Name()
c.Assert(w.Add(filename2), qt.IsNil)
c.Assert(w.Close(), qt.IsNil)
c.Assert(w.Close(), qt.IsNil)
- c.Assert(ioutil.WriteFile(filename1, []byte("new"), 0600), qt.IsNil)
- c.Assert(ioutil.WriteFile(filename2, []byte("new"), 0600), qt.IsNil)
+ c.Assert(os.WriteFile(filename1, []byte("new"), 0600), qt.IsNil)
+ c.Assert(os.WriteFile(filename2, []byte("new"), 0600), qt.IsNil)
// No more event as the watchers are closed.
assertEvents(c, w)
- f2, err = ioutil.TempFile("", "f2")
+ f2, err = os.CreateTemp("", "f2")
c.Assert(err, qt.IsNil)
defer os.Remove(f2.Name())
c.Assert(os.Chmod(filepath.Join(filepath.Join(dir, subdir2, "file1")), 0400), qt.IsNil)
f1_2 := stat(subdir2, "file1")
- c.Assert(ioutil.WriteFile(filepath.Join(filepath.Join(dir, subdir2, "file2")), []byte("changed"), 0600), qt.IsNil)
+ c.Assert(os.WriteFile(filepath.Join(filepath.Join(dir, subdir2, "file2")), []byte("changed"), 0600), qt.IsNil)
f2_2 := stat(subdir2, "file2")
c.Assert(checkChange(f0, nil), qt.Equals, fsnotify.Remove)
}
func prepareTestDirWithSomeFiles(c *qt.C, id string) string {
- dir, err := ioutil.TempDir("", fmt.Sprintf("test-poller-dir-%s", id))
- c.Assert(err, qt.IsNil)
+ dir := c.TB.TempDir()
c.Assert(os.MkdirAll(filepath.Join(dir, subdir1), 0777), qt.IsNil)
c.Assert(os.MkdirAll(filepath.Join(dir, subdir2), 0777), qt.IsNil)
for i := 0; i < 3; i++ {
- c.Assert(ioutil.WriteFile(filepath.Join(dir, subdir1, fmt.Sprintf("file%d", i)), []byte("hello1"), 0600), qt.IsNil)
+ c.Assert(os.WriteFile(filepath.Join(dir, subdir1, fmt.Sprintf("file%d", i)), []byte("hello1"), 0600), qt.IsNil)
}
for i := 0; i < 3; i++ {
- c.Assert(ioutil.WriteFile(filepath.Join(dir, subdir2, fmt.Sprintf("file%d", i)), []byte("hello2"), 0600), qt.IsNil)
+ c.Assert(os.WriteFile(filepath.Join(dir, subdir2, fmt.Sprintf("file%d", i)), []byte("hello2"), 0600), qt.IsNil)
}
c.Cleanup(func() {
projects / brevno-suite / hugo / commitdiff