func TestDecodeConfigInjectsDefaultAndCompiles(t *testing.T) {
c := qt.New(t)
- cfg, err := DecodeConfig(config.BaseConfig{}, map[string]interface{}{})
+ cfg, err := DecodeConfig(config.BaseConfig{}, map[string]any{})
c.Assert(err, qt.IsNil)
c.Assert(cfg, qt.DeepEquals, DefaultConfig)
defer cancel()
wg2, ctx := errgroup.WithContext(ctx)
for _, srv := range servers {
- srv := srv
wg2.Go(func() error {
return srv.Shutdown(ctx)
})
var wg sync.WaitGroup
for i := range 10 {
- i := i
wg.Add(1)
go func() {
defer wg.Done()
func BenchmarkXXHashFromReader(b *testing.B) {
r := strings.NewReader("Hello World")
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+
+ for b.Loop() {
XXHashFromReader(r)
r.Seek(0, 0)
}
func BenchmarkXXHashFromString(b *testing.B) {
s := "Hello World"
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+
+ for b.Loop() {
XXHashFromString(s)
}
}
func BenchmarkXXHashFromStringHexEncoded(b *testing.B) {
s := "The quick brown fox jumps over the lazy dog"
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+
+ for b.Loop() {
XxHashFromStringHexEncoded(s)
}
}
for _, test := range tests {
b.Run(fmt.Sprintf("n%d", len(test)), func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
HashString(test)
}
})
m[fmt.Sprintf("key%d", i)] = i
}
- b.ResetTimer()
-
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
HashString(m)
}
}
func BenchmarkToInt64(b *testing.B) {
v := reflect.ValueOf(int(42))
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
ToInt64(v)
}
}
b.Run("value", func(b *testing.B) {
ctx := context.Background()
ctxs := make([]reflect.Type, b.N)
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
ctxs[i] = reflect.TypeOf(context.WithValue(ctx, k("key"), i))
}
b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
if !IsContextType(ctxs[i]) {
b.Fatal("not context")
}
b.Run("background", func(b *testing.B) {
var ctxt reflect.Type = reflect.TypeOf(context.Background())
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
if !IsContextType(ctxt) {
b.Fatal("not context")
}
nilPointer = reflect.ValueOf((*zeroStruct)(nil))
)
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
IsTruthfulValue(stringHugo)
IsTruthfulValue(stringEmpty)
IsTruthfulValue(zero)
tp := reflect.TypeFor[*testStruct]()
methods := []string{"Method1", "Method2", "Method3", "Method4", "Method5"}
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
for _, method := range methods {
_ = GetMethodByNameForType(tp, method)
}
v := reflect.ValueOf(&testStruct{})
methods := []string{"Method1", "Method2", "Method3", "Method4", "Method5"}
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
for _, method := range methods {
_ = GetMethodByName(v, method)
}
func BenchmarkScratchGet(b *testing.B) {
scratch := NewScratch()
scratch.Add("A", 1)
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+
+ for b.Loop() {
scratch.Get("A")
}
}
input := []string{"a", "b", "d", "e", "d", "h", "a", "i"}
b.Run("Safe", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
result := UniqueStrings(input)
if len(result) != 6 {
b.Fatalf("invalid count: %d", len(result))
b.Run("Reuse slice", func(b *testing.B) {
b.StopTimer()
inputs := make([][]string, b.N)
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
inputc := make([]string, len(input))
copy(inputc, input)
inputs[i] = inputc
}
b.StartTimer()
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
inputc := inputs[i]
result := UniqueStringsReuse(inputc)
b.Run("Reuse slice sorted", func(b *testing.B) {
b.StopTimer()
inputs := make([][]string, b.N)
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
inputc := make([]string, len(input))
copy(inputc, input)
inputs[i] = inputc
}
b.StartTimer()
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
inputc := inputs[i]
result := UniqueStringsSorted(inputc)
}
func BenchmarkGetOrCompileRegexp(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
GetOrCompileRegexp(`\d+`)
}
}
func BenchmarkCompileRegexp(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
regexp.MustCompile(`\d+`)
}
}
return counter
}
- for range b.N {
+ for b.Loop() {
omf := OnceMoreValue(f)
for range 10 {
omf.Value(context.Background())
june06, _ := time.Parse("2006-Jan-02", "2018-Jun-06")
b.Run("Native", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
got := june06.Format("Monday Jan 2 2006")
if got != "Wednesday Jun 6 2018" {
b.Fatalf("invalid format, got %q", got)
b.Run("Localized", func(b *testing.B) {
f := NewTimeFormatter(translators.GetTranslator("nn"))
b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
got := f.Format(june06, "Monday Jan 2 2006")
if got != "onsdag juni 6 2018" {
b.Fatalf("invalid format, got %q", got)
b.Run("Localized Custom", func(b *testing.B) {
f := NewTimeFormatter(translators.GetTranslator("nn"))
b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
got := f.Format(june06, ":date_medium")
if got != "6. juni 2018" {
b.Fatalf("invalid format, got %q", got)
cache := NewCacheWithOptions[string, string](CacheOptions{Size: 10})
- for i := 0; i < 30; i++ {
+ for i := range 30 {
cache.Set(string(rune('a'+i)), "value")
}
}
b.Run("New", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
NewOrderedIntSet(1, 2, 3, 4, 5, 6, 7, 8)
}
})
b.Run("Has small", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
smallSet.Has(i % 32)
}
})
b.Run("Has medium", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
mediumSet.Has(i % 32)
}
})
b.Run("Next", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
mediumSet.Next(i % 32)
}
})
b.Run("ForEachKey small", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
smallSet.ForEachKey(func(key int) bool {
return true
})
})
b.Run("ForEachKey medium", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
mediumSet.ForEachKey(func(key int) bool {
return true
})
})
b.Run("ForEachKey large", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
largeSet.ForEachKey(func(key int) bool {
return true
})
var result []int
var mu sync.Mutex
for i := range n {
- i := i
r.Run(func() error {
mu.Lock()
defer mu.Unlock()
func makePathRelative(inPath string, possibleDirectories ...string) (string, error) {
for _, currentPath := range possibleDirectories {
- if strings.HasPrefix(inPath, currentPath) {
- return strings.TrimPrefix(inPath, currentPath), nil
+ if after, ok := strings.CutPrefix(inPath, currentPath); ok {
+ return after, nil
}
}
return inPath, errors.New("can't extract relative path, unknown prefix")
// This should not allocate any memory.
b.Run("All allowed", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
got := Sanitize(allAlowedPath)
if got != allAlowedPath {
b.Fatal(got)
// This will allocate some memory.
b.Run("Spaces", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
got := Sanitize(spacePath)
if got != "foo-bar" {
b.Fatal(got)
// This should not allocate any memory.
b.Run("With leading slash", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
got := AddLeadingSlash(withLeadingSlash)
if got != withLeadingSlash {
b.Fatal(got)
// This will allocate some memory.
b.Run("Without leading slash", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
got := AddLeadingSlash(noLeadingSlash)
if got != "/a/b/c" {
b.Fatal(got)
})
b.Run("Blank string", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
got := AddLeadingSlash("")
if got != "/" {
b.Fatal(got)
func BenchmarkParseIdentity(b *testing.B) {
parser := newTestParser()
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
parser.ParseIdentity(files.ComponentFolderAssets, "/a/b.css")
}
}
func BenchmarkSitesMatrixFromPath(b *testing.B) {
parser := newTestParser()
p := parser.Parse(files.ComponentFolderContent, "/a/b/c.fr.md")
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
parser.SitesMatrixFromPath(p)
}
}
b.Run("and or no match", func(b *testing.B) {
var p predicate.PR[int] = intP1
p = p.And(intP2).Or(intP3)
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
_ = p(3).OK()
}
})
b.Run("and and no match", func(b *testing.B) {
var p predicate.PR[int] = intP1
p = p.And(intP2)
- for range b.N {
+ for b.Loop() {
_ = p(3).OK()
}
})
b.Run("and and match", func(b *testing.B) {
var p predicate.PR[int] = intP1
p = p.And(intP2)
- for range b.N {
+ for b.Loop() {
_ = p(10).OK()
}
})
b.Run("or or match", func(b *testing.B) {
var p predicate.PR[int] = intP1
p = p.Or(intP2).Or(intP3)
- for range b.N {
+ for b.Loop() {
_ = p(2).OK()
}
})
line 3`
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
VisitLinesAfter(lines, func(s string) {
})
}
prototype := []string{"b", "Bz", "zz", "ba", "αβδ αβδ αβδ", "A", "Ba", "ba", "nnnnasdfnnn", "AAgæåz", "αβδC"}
b.Run("LessStrings", func(b *testing.B) {
ss := make([][]string, b.N)
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
ss[i] = make([]string, len(prototype))
copy(ss[i], prototype)
}
b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
sss := ss[i]
sort.Slice(sss, func(i, j int) bool {
return LessStrings(sss[i], sss[j])
var hugoEnv []types.KeyValueStr
for _, v := range environ {
key, val := config.SplitEnvVar(v)
- if strings.HasPrefix(key, hugoEnvPrefix) {
- delimiterAndKey := strings.TrimPrefix(key, hugoEnvPrefix)
+ if after, ok := strings.CutPrefix(key, hugoEnvPrefix); ok {
+ delimiterAndKey := after
if len(delimiterAndKey) < 2 {
continue
}
Filename: configFilename,
}
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
_, err := LoadConfig(d)
if err != nil {
b.Fatal(err)
}
for i := range 20 {
- i := i
r.Run(func() error {
const v = 42
k := fmt.Sprintf("k%d", i)
b.Run("Custom", func(b *testing.B) {
cfg := New()
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
runMethods(b, cfg)
}
})
c := qt.New(t)
for i, cas := range cases {
- cas := cas
c.Run(cas.name, func(c *qt.C) {
c.Parallel()
func BenchmarkTrimShortHTML(b *testing.B) {
c := newTestContentSpec(nil)
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+
+ for b.Loop() {
c.TrimShortHTML([]byte("<p>Simple paragraph</p>"), "markdown")
}
}
}
func BenchmarkTotalWords(b *testing.B) {
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+
+ for b.Loop() {
wordCount := helpers.TotalWords(totalWordsBenchmarkString)
if wordCount != 400 {
b.Fatal("Wordcount error")
}
func BenchmarkReaderContains(b *testing.B) {
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+
+ for b.Loop() {
for i, this := range containsBenchTestData {
result := helpers.ReaderContains(strings.NewReader(this.v1), this.v2)
if result != this.expect {
// MakeTitleInPath converts the path given to a suitable title, trimming whitespace
func MakePathRelative(inPath string, possibleDirectories ...string) (string, error) {
for _, currentPath := range possibleDirectories {
- if strings.HasPrefix(inPath, currentPath) {
- return strings.TrimPrefix(inPath, currentPath), nil
+ if after, ok := strings.CutPrefix(inPath, currentPath); ok {
+ return after, nil
}
}
return inPath, errors.New("can't extract relative path, unknown prefix")
r := make([]string, len(paths))
for i, p := range paths {
root := filepath.ToSlash(p)
- sections := strings.Split(root, "/")
- for _, section := range sections {
+ sections := strings.SplitSeq(root, "/")
+ for section := range sections {
if section != "" {
root = section
break
v := config.New()
v.Set("baseURL", "https://base/")
p := newTestPathSpecFromCfgAndLang(v, "")
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+
+ for b.Loop() {
_ = p.RelURL("https://base/foo/bar", false)
}
}
p := newTestPathSpecFromCfgAndLang(v, "")
b.ResetTimer()
b.Run("relurl", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
_ = p.AbsURL("foo/bar", false)
}
})
b.Run("absurl", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
_ = p.AbsURL("https://base/foo/bar", false)
}
})
ofs := NewHashingFs(fs, observer)
content := []byte(strings.Repeat("lorem ipsum ", 1000))
- b.ResetTimer()
-
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
f, err := ofs.Create(fmt.Sprintf("file%d", i))
if err != nil {
b.Fatal(err)
if err != nil {
b.Fatal(err)
}
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
_ = g.Match(search)
}
})
runBench("Filenames cache, mixed case searches", defaultGlobCache, "abCDe")
b.Run("GetGlob", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
_, err := GetGlob("**/foo")
if err != nil {
b.Fatal(err)
return nil
}
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
w := NewWalkway(WalkwayConfig{Fs: fs, Root: "root", WalkFn: walkFn})
if err := w.Walk(); err != nil {
c := qt.New(b)
b.StopTimer()
builders := make([]*sitesBuilder, b.N)
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
builders[i] = newCascadeTestBuilder(b, langs)
}
b.StartTimer()
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
builder := builders[i]
err := builder.BuildE(BuildCfg{})
c.Assert(err, qt.IsNil)
b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
builders[i].Build()
}
})
`
for _, configName := range []string{"hugo.toml", "config.toml"} {
- configName := configName
t.Run(configName, func(t *testing.T) {
t.Parallel()
`
for _, format := range []string{"toml", "yaml", "json"} {
- format := format
t.Run(format, func(t *testing.T) {
t.Parallel()
`
for _, enabled := range []bool{true, false} {
- enabled := enabled
t.Run(fmt.Sprint(enabled), func(t *testing.T) {
t.Parallel()
b := Test(t, strings.ReplaceAll(files, "ENABLE", fmt.Sprint(enabled)))
)
for i := range 8 {
- i := i
r.Run(func() error {
a := &testValue{ID: "/a"}
lock := tree.Lock(true)
func BenchmarkTreeInsert(b *testing.B) {
runBench := func(b *testing.B, numElements int) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
tree := doctree.New(
doctree.Config[*testValue]{
Shifter: &testShifter{},
b.Run(fmt.Sprintf("Walk one dimension %d", numElements), func(b *testing.B) {
tree := createTree()
b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
w := &doctree.NodeShiftTreeWalker[*testValue]{
Tree: tree,
Handle: handle,
b.Run(fmt.Sprintf("Walk all dimensions %d", numElements), func(b *testing.B) {
base := createTree()
b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
for d1 := range 1 {
for d2 := range 2 {
tree := base.Shape(sitesmatrix.Vector{d1, d2, 0})
v := sitesmatrix.Vector{10, 10, 10}
t := doctree.NewTreeShiftTree[string](v)
b.Run("New", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
for l1 := 0; l1 < v[0]; l1++ {
for l2 := 0; l2 < v[1]; l2++ {
for l3 := 0; l3 < v[2]; l3++ {
}
})
b.Run("Shape", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
for l1 := 0; l1 < v[0]; l1++ {
for l2 := 0; l2 < v[1]; l2++ {
for l3 := 0; l3 < v[2]; l3++ {
} else {
contentDir := strings.TrimPrefix(strings.TrimPrefix(meta.Filename, meta.BaseDir), filePathSeparator) + filePathSeparator
- if strings.HasPrefix(filename, contentDir) {
- relFilename := strings.TrimPrefix(filename, contentDir)
+ if after, ok := strings.CutPrefix(filename, contentDir); ok {
+ relFilename := after
absFilename := filepath.Join(meta.Filename, relFilename)
return relFilename, absFilename, nil
}
// Crawl in data tree to insert data
current = h.data
dataPath := r.FileInfo().Meta().PathInfo.Unnormalized().Dir()[1:]
- keyParts := strings.Split(dataPath, "/")
+ keyParts := strings.SplitSeq(dataPath, "/")
- for _, key := range keyParts {
+ for key := range keyParts {
if key != "" {
if _, ok := current[key]; !ok {
current[key] = make(map[string]any)
g, _ := h.workersSite.Start(ctx)
for _, s := range assemblers {
- s := s
g.Run(func() error {
return s.assemblePagesStep1()
})
filenames := h.Deps.BuildState.GetFilenamesWithPostPrefix()
for _, filename := range filenames {
- filename := filename
g.Run(func() error {
return handleFile(filename)
})
`
- for i := 0; i < 2; i++ {
+ for range 2 {
b := Test(t, files)
b.AssertFileContent("public/index.html", `List: |/|html: /|rss: /index.xml|$`)
b.AssertFileContent("public/index.xml", `List xml: |/|html: /|rss: /index.xml|$`)
builders[i] = NewIntegrationTestBuilder(cfg)
}
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
builders[i].Build()
}
}
for _, m := range matches {
cm := qt.Commentf("File: %s Expect: %s Got: %s", filename, m, content)
- lines := strings.Split(m, "\n")
- for _, match := range lines {
+ lines := strings.SplitSeq(m, "\n")
+ for match := range lines {
match = strings.TrimSpace(match)
if match == "" || strings.HasPrefix(match, "#") {
continue
content := strings.TrimSpace((strings.Join(printFsLines, "\n")))
for _, m := range matches {
cm := qt.Commentf("Match: %q\nIn:\n%s", m, content)
- lines := strings.Split(m, "\n")
- for _, match := range lines {
+ lines := strings.SplitSeq(m, "\n")
+ for match := range lines {
match = strings.TrimSpace(match)
var negate bool
if strings.HasPrefix(match, hglob.NegationPrefix) {
}
for i, test := range tests {
- i := i
test := test
t.Run(fmt.Sprintf("%s-%d", test.file, i), func(t *testing.T) {
t.Parallel()
func TestPageWithFrontMatterConfig(t *testing.T) {
for _, dateHandler := range []string{":filename", ":fileModTime"} {
- dateHandler := dateHandler
t.Run(fmt.Sprintf("dateHandler=%q", dateHandler), func(t *testing.T) {
t.Parallel()
c := qt.New(t)
pagePaths := make([]string, b.N)
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
pagePaths[i] = fmt.Sprintf("sect%d", r.Intn(10))
}
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
home, _ := s.getPage(nil, "/")
if home == nil {
b.Fatal("Home is nil")
pagePaths := make([]string, b.N)
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
pagePaths[i] = path.Join(fmt.Sprintf("/sect%d", r.Intn(10)), fmt.Sprintf("page%d.md", r.Intn(100)))
}
b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
page, _ := s.getPage(nil, pagePaths[i])
c.Assert(page, qt.Not(qt.IsNil))
}
pagePaths := make([]string, b.N)
pages := make([]page.Page, b.N)
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
pagePaths[i] = fmt.Sprintf("page%d.md", r.Intn(100))
pages[i] = allPages[r.Intn(len(allPages)/3)]
}
b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
page, _ := s.getPage(pages[i], pagePaths[i])
c.Assert(page, qt.Not(qt.IsNil))
}
enSite := h.Sites[0]
nnSite := h.Sites[2]
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
merged := nnSite.RegularPages().MergeByLanguage(enSite.RegularPages())
if len(merged) != count {
b.Fatal("Count mismatch")
pages = variant.preparePages(pages)
}
b.StartTimer()
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
p := pages[rand.Intn(len(pages))]
variant.run(p, pages)
}
}
}
b.StartTimer()
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
p := pages[rand.Intn(len(pages))]
variant.run(p)
}
bs := BuildState{}
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
bs.hash(m)
}
}
func TestRebuildEditLeafBundleHeaderOnly(t *testing.T) {
t.Parallel()
- for i := 0; i < 3; i++ {
+ for range 3 {
b := TestRunning(t, rebuildFilesSimple)
b.AssertFileContent("public/mysection/mysectionbundle/index.html",
"My Section Bundle Content Content.")
builders[i].Build()
}
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
bb := builders[i]
bb.EditFileReplaceFunc("content/mysect/p123/index.md", func(s string) string {
return s + "... Edited"
}
func BenchmarkResourceChainPostProcess(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
b.StopTimer()
s := newTestSitesBuilder(b)
for i := range 300 {
}
for _, test := range tests {
- test := test
t.Run(test.name, func(t *testing.T) {
if !test.shouldRun() {
t.Skip()
match := compileSegments(c, fields...)
- b.ResetTimer()
- for range b.N {
+ for b.Loop() {
match(SegmentQuery{Site: no, Output: "rss"})
}
}
scp.innerDeindentInit.Do(func() {
b := bp.GetBuffer()
text.VisitLinesAfter(string(scp.Inner), func(s string) {
- if strings.HasPrefix(s, scp.indentation) {
- b.WriteString(strings.TrimPrefix(s, scp.indentation))
+ if after, ok := strings.CutPrefix(s, scp.indentation); ok {
+ b.WriteString(after)
} else {
b.WriteString(s)
}
{"inline", `{{< my.inline >}}Hi{{< /my.inline >}}`, regexpCheck("my.inline;inline:true;closing:true;inner:{Hi};")},
} {
- test := test
-
t.Run(test.name, func(t *testing.T) {
t.Parallel()
c := qt.New(t)
cnt := 0
in := make([]input, b.N*len(data))
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
for _, this := range data {
replacements := make(map[string]shortcodeRenderer)
for k, v := range this.replacements {
}
}
- b.ResetTimer()
cnt = 0
ctx := context.Background()
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
for j := range data {
currIn := in[cnt]
cnt++
builders[i] = NewIntegrationTestBuilder(cfg)
}
- b.ResetTimer()
-
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
builders[i].Build()
}
}
func TestInlineShortcodes(t *testing.T) {
for _, enableInlineShortcodes := range []bool{true, false} {
- enableInlineShortcodes := enableInlineShortcodes
t.Run(fmt.Sprintf("enableInlineShortcodes=%t", enableInlineShortcodes),
func(t *testing.T) {
t.Parallel()
sitesVersionsRoles := make([][][]*Site, len(sites))
for i := 0; i < len(sites); i++ {
sitesVersionsRoles[i] = make([][]*Site, len(versionsSorted))
- for j := 0; j < len(versionsSorted); j++ {
+ for j := range versionsSorted {
sitesVersionsRoles[i][j] = make([]*Site, len(rolesSorted))
}
}
}
b.Run(name, func(b *testing.B) {
sites := make([]*sitesBuilder, b.N)
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
sites[i] = bm.create(b)
if edit {
sites[i].Running()
}
b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
if edit {
b.StopTimer()
}
func TestSiteWithPageOutputs(t *testing.T) {
for _, outputs := range [][]string{{"html", "json", "calendar"}, {"json"}} {
- outputs := outputs
t.Run(fmt.Sprintf("%v", outputs), func(t *testing.T) {
t.Parallel()
doTestSiteWithPageOutputs(t, outputs)
home := s.getPageOldVersion(kinds.KindHome)
for _, test := range tests {
- test := test
tt.Run(fmt.Sprintf("sections %s", test.sections), func(c *qt.C) {
c.Parallel()
sections := strings.Split(test.sections, ",")
b.Run("Equal", func(b *testing.B) {
v1 := Vector{1, 2, 3}
v2 := Vector{1, 2, 3}
- for range b.N {
+ for b.Loop() {
v1.Compare(v2)
}
})
b.Run("First different", func(b *testing.B) {
v1 := Vector{1, 2, 3}
v2 := Vector{2, 2, 3}
- for range b.N {
+ for b.Loop() {
v1.Compare(v2)
}
})
b.Run("Last different", func(b *testing.B) {
v1 := Vector{1, 2, 3}
v2 := Vector{1, 2, 4}
- for range b.N {
+ for b.Loop() {
v1.Compare(v2)
}
})
for _, multipleDimensions := range []bool{false, true} {
b.Run(fmt.Sprintf("n%d/md%t", numPages, multipleDimensions), func(b *testing.B) {
builders := make([]*hugolib.IntegrationTestBuilder, b.N)
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
builders[i] = newSitesMatrixContentBenchmarkBuilder(b, numPages, true, true)
}
b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
builders[i].Build()
}
})
b.ResetTimer()
b.Run("sub set", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
_ = sets2.Complement(sets1)
}
})
b.Run("super set", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
_ = sets1.Complement(sets2)
}
})
b.Run("self", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
_ = sets1.Complement(sets1)
}
})
b.Run("self multiple", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
_ = sets1.Complement(sets1, sets1, sets1, sets1, sets1, sets1, sets1)
}
})
b.Run("same", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
_ = sets1.Complement(sets1Copy)
}
})
b.Run("one overlapping language", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
_ = setsLanguage1.Complement(sets1)
}
})
b.ResetTimer()
b.Run("Build", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
_ = sitesmatrix.NewIntSetsBuilder(testDims).WithSets(
maps.NewOrderedIntSet(1, 2),
maps.NewOrderedIntSet(1, 2, 3),
}
})
b.Run("HasVector", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
_ = sets1.HasVector(v1)
_ = sets1.HasVector(v2)
}
})
b.Run("HasAnyVector", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
_ = sets1.HasAnyVector(sets2)
}
})
b.Run("FirstVector", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
_ = sets1.VectorSample()
}
})
b.Run("LenVectors", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
_ = sets1.LenVectors()
}
})
b.Run("ForEachVector", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
allCount := 0
ok := sets1.ForEachVector(func(v sitesmatrix.Vector) bool {
allCount++
})
b.Run("EqualsVector pointer equal", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
if !sets1.EqualsVector(sets1) {
b.Fatal("Expected sets1 to equal itself")
}
})
b.Run("EqualsVector equal copy", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
if !sets1.EqualsVector(sets1Copy) {
b.Fatal("Expected sets1 to equal its copy")
}
})
b.Run("EqualsVector different sets", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
if sets1.EqualsVector(sets2) {
b.Fatal("Expected sets1 to not equal sets2")
}
})
b.Run("Distance", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
_ = sets1.VectorSample().Distance(v1)
_ = sets1.VectorSample().Distance(v2)
}
for _, numPages := range []int{100, 1000, 10000, 20000} {
b.Run(fmt.Sprintf("pages_%d", numPages), func(b *testing.B) {
builders := createBuilders(b, numPages)
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
builders[i].Build()
}
})
},
} {
- this := this
if this.name != "Variant 1" {
continue
}
s.T.Helper()
content := s.FileContent(filename)
for _, m := range matches {
- lines := strings.Split(m, "\n")
- for _, match := range lines {
+ lines := strings.SplitSeq(m, "\n")
+ for match := range lines {
match = strings.TrimSpace(match)
if match == "" {
continue
f := identity.NewFinder(identity.FinderConfig{})
b.Run("Find one", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
r := f.Contains(b4, m1, -1)
if r == 0 {
b.Fatal("not found")
})
b.Run("Find none", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
r := f.Contains(b5, m1, -1)
if r > 0 {
b.Fatal("found")
}
b.Run("identity.NewManager", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
m := identity.NewManager()
if m == nil {
b.Fatal("manager is nil")
im := identity.NewManager()
b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
im.AddIdentity(ids[i])
}
im := identity.NewManager()
b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
im.AddIdentity(id)
}
b.Run("Nop StringIdentity const", func(b *testing.B) {
const id = identity.StringIdentity("test")
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
identity.NopManager.AddIdentity(id)
}
})
b.Run("Nop StringIdentity const other package", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
identity.NopManager.AddIdentity(identitytesting.TestIdentity)
}
})
b.Run("Nop StringIdentity var", func(b *testing.B) {
id := identity.StringIdentity("test")
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
identity.NopManager.AddIdentity(id)
}
})
b.Run("Nop pointer identity", func(b *testing.B) {
id := &testIdentity{base: "a", name: "b"}
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
identity.NopManager.AddIdentity(id)
}
})
b.Run("Nop Anonymous", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
identity.NopManager.AddIdentity(identity.Anonymous)
}
})
func BenchmarkIsNotDependent(b *testing.B) {
runBench := func(b *testing.B, id1, id2 identity.Identity) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
isNotDependent(id1, id2)
}
}
isStdin := importer == stdinImporter
var relDir string
if !isStdin {
- if strings.HasPrefix(importer, PrefixHugoVirtual) {
- relDir = filepath.Dir(strings.TrimPrefix(importer, PrefixHugoVirtual))
+ if after, ok := strings.CutPrefix(importer, PrefixHugoVirtual); ok {
+ relDir = filepath.Dir(after)
} else {
rel, found := fs.MakePathRelative(importer, true)
run := func() error {
g, ctx := errgroup.WithContext(ctx)
for _, c := range inOuts {
- c := c
g.Go(func() error {
var errBuff bytes.Buffer
ctx := context.WithoutCancel(ctx)
input := katexInputTemplate
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
message := Message[KatexInput]{
Header: Header{
Version: currentVersion,
}
runBench := func(b *testing.B, opts Options) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
d, err := Start[KatexInput, KatexOutput](opts)
if err != nil {
b.Fatal(err)
Name: "Person",
}
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
message := Message[person]{
Header: Header{
Version: currentVersion,
b.Run(test.name, func(b *testing.B) {
tp := prepareTranslationProvider(b, test, v)
b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
f := tp.t.Func(test.lang)
actual := f(context.Background(), test.id, test.args)
if actual != test.expected {
b.Run("Single", func(b *testing.B) {
coll := &Collator{c: collate.New(language.English, collate.Loose)}
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
doWork(coll)
}
})
}
for i, input := range testlines {
- input := input
expect := expectlines[i]
c.Run(input, func(c *qt.C) {
b := []byte(input)
func BenchmarkSanitizeAnchorName(b *testing.B) {
input := []byte("God is good: 神真美好")
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+
+ for b.Loop() {
result := sanitizeAnchorName(input, goldmark_config.AutoIDTypeGitHub)
if len(result) != 24 {
b.Fatalf("got %d", len(result))
func BenchmarkSanitizeAnchorNameAsciiOnly(b *testing.B) {
input := []byte("God is good: 神真美好")
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+
+ for b.Loop() {
result := sanitizeAnchorName(input, goldmark_config.AutoIDTypeGitHubAscii)
if len(result) != 12 {
b.Fatalf("got %d", len(result))
func BenchmarkSanitizeAnchorNameBlackfriday(b *testing.B) {
input := []byte("God is good: 神真美好")
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+
+ for b.Loop() {
result := sanitizeAnchorName(input, goldmark_config.AutoIDTypeBlackfriday)
if len(result) != 24 {
b.Fatalf("got %d", len(result))
func BenchmarkSanitizeAnchorNameString(b *testing.B) {
input := "God is good: 神真美好"
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+
+ for b.Loop() {
result := sanitizeAnchorNameString(input, goldmark_config.AutoIDTypeGitHub)
if len(result) != 24 {
b.Fatalf("got %d", len(result))
}{
{"issue-9819", "asdf\n: {#myid}"},
} {
- test := test
t.Run(test.name, func(t *testing.T) {
t.Parallel()
b := hugolib.NewIntegrationTestBuilder(
builders[i] = hugolib.NewIntegrationTestBuilder(cfg)
}
- b.ResetTimer()
-
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
builders[i].Build()
}
}
b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
builders[i].Build()
}
}
}
func (n *HugoContext) parseAttrs(attrBytes []byte) {
- keyPairs := bytes.Split(attrBytes, []byte(" "))
- for _, keyPair := range keyPairs {
+ keyPairs := bytes.SplitSeq(attrBytes, []byte(" "))
+ for keyPair := range keyPairs {
kv := bytes.Split(keyPair, []byte("="))
if len(kv) != 2 {
continue
}
func BenchmarkWrap(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
Wrap([]byte("test"), 42)
}
}
return opts, nil
}
- for _, v := range strings.Split(in, ",") {
+ for v := range strings.SplitSeq(in, ",") {
keyVal := strings.Split(v, "=")
key := strings.Trim(keyVal[0], " ")
if len(keyVal) != 2 {
// 1-2 3
// 1 3-4
// 1 3-4
- fields := strings.Split(s, " ")
- for _, field := range fields {
+ fields := strings.SplitSeq(s, " ")
+ for field := range fields {
field = strings.TrimSpace(field)
if field == "" {
continue
// Most external helpers exit w/ non-zero exit code only if severe, i.e.
// halting errors occurred. -> log stderr output regardless of state of err
- for _, item := range strings.Split(cmderr.String(), "\n") {
+ for item := range strings.SplitSeq(cmderr.String(), "\n") {
item := strings.TrimSpace(item)
if item != "" {
if err == nil {
b.Run("Build", func(b *testing.B) {
var builders []Builder
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
builders = append(builders, newTestTocBuilder())
}
b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
b := builders[i]
b.Build()
}
b.Run("ToHTML", func(b *testing.B) {
tocs := newTocs(b.N)
b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
toc := tocs[i]
toc.ToHTML(1, -1, false)
}
func BenchmarkTypeOps(b *testing.B) {
mt := Builtin.MPEGType
mts := DefaultTypes
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
ff := mt.FirstSuffix
_ = ff.FullSuffix
_ = mt.IsZero()
s1 := "Hugo is cool and " + strings.Repeat("fun ", 10) + "!"
s2 := "Hugo is cool and " + strings.Repeat("cool ", 10) + "!"
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
howSimilar(s1, s2)
}
}
"os"
"path/filepath"
"regexp"
+ "slices"
"strings"
"time"
var x []Mount
for _, m1 := range mounts {
var found bool
- for _, m2 := range x {
- if m1.Equal(m2) {
- found = true
- break
- }
+ if slices.ContainsFunc(x, m1.Equal) {
+ found = true
}
if !found {
x = append(x, m1)
`)
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
_, err := d.UnmarshalToMap(data, YAML)
if err != nil {
b.Fatal(err)
for _, tt := range yamlTests {
b.Run(tt.Title+" no validation", func(b *testing.B) {
- for range b.N {
+ for b.Loop() {
var v any
if err := unmarshalYamlNoValidation(tt.Content, &v); err != nil {
b.Fatal(err)
})
b.Run(tt.Title+" with validation", func(b *testing.B) {
- for range b.N {
+ for b.Loop() {
var v any
err := UnmarshalYaml(tt.Content, &v)
if tt.IsExpectedToFailValidation {
testInputs[i] = []byte(input.input)
}
var cfg Config
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+
+ for b.Loop() {
for _, input := range testInputs {
_, err := collectWithConfig(input, true, lexMainSection, cfg)
if err != nil {
input := []byte(start + strings.Repeat(strings.Repeat("this is text", 30)+"{{< myshortcode >}}This is some inner content.{{< /myshortcode >}}", 10))
cfg := Config{}
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
if _, err := parseBytes(input, cfg, lexIntroSection); err != nil {
b.Fatal(err)
}
withShortcode := strings.Repeat("this is text", 30) + "{{< myshortcode >}}This is some inner content.{{< /myshortcode >}}" + strings.Repeat("this is text", 30)
withoutShortcode := strings.Repeat("this is text", 30) + "This is some inner content." + strings.Repeat("this is text", 30)
b.Run("Match", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
HasShortcode(withShortcode)
}
})
b.Run("NoMatch", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
HasShortcode(withoutShortcode)
}
})
</body>
</html>
`
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
w := newHTMLElementsCollectorWriter(newHTMLElementsCollector(
config.BuildStats{Enable: true},
))
w := newHTMLElementsCollectorWriter(newHTMLElementsCollector(
config.BuildStats{Enable: true},
))
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
fmt.Fprint(w, benchHTML)
}
}
}
b.Run("singles", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
idx := NewInvertedIndex(cfg)
for _, doc := range pages {
idx.Add(context.Background(), doc)
})
b.Run("all", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
idx := NewInvertedIndex(cfg)
docs := make([]Document, len(pages))
for i := range pages {
idx.Add(context.Background(), newTestDoc(index, allKeywords[start:end]...))
}
- b.ResetTimer()
ctx := context.Background()
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
if i%10 == 0 {
idx.search(ctx, q2)
} else {
builders[i] = hugolib.NewIntegrationTestBuilder(cfg)
}
- b.ResetTimer()
-
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
builders[i].Build()
}
}
getImages := func(c *qt.C, b *testing.B, fs afero.Fs) []images.ImageResource {
spec := newTestResourceSpec(specDescriptor{fs: fs, c: c})
imgs := make([]images.ImageResource, b.N)
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
imgs[i] = fetchResourceForSpec(spec, c, "sunset.jpg", strconv.Itoa(i)).(images.ImageResource)
}
return imgs
images := getImages(c, b, afero.NewMemMapFs())
b.StartTimer()
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
getAndCheckExif(c, images[i])
}
})
images := getImages(c, b, afero.NewMemMapFs())
b.StartTimer()
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
for range 10 {
getAndCheckExif(c, images[i])
}
c := qt.New(b)
fs := afero.NewMemMapFs()
images := getImages(c, b, fs)
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
getAndCheckExif(c, images[i])
}
images = getImages(c, b, fs)
b.StartTimer()
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
getAndCheckExif(c, images[i])
}
})
{"777", color.RGBA{R: 0x77, G: 0x77, B: 0x77, A: 0xff}},
} {
- test := test
c.Run(test.arg, func(c *qt.C) {
c.Parallel()
{color.RGBA{R: 0x42, G: 0x87, B: 0xf5, A: 0x80}, "#4287f580"},
} {
- test := test
c.Run(test.expect, func(c *qt.C) {
c.Parallel()
d, err := NewDecoder()
c.Assert(err, qt.IsNil)
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
_, err = d.Decode("", imagemeta.JPEG, f)
c.Assert(err, qt.IsNil)
f.Seek(0, 0)
// Calculate lines, consider and include linebreaks
finalLines := []string{}
f.text = strings.ReplaceAll(f.text, "\r", "")
- for _, line := range strings.Split(f.text, "\n") {
+ for line := range strings.SplitSeq(f.text, "\n") {
currentLine := ""
// Break each line at the maximum width.
- for _, str := range strings.Fields(line) {
+ for str := range strings.FieldsSeq(line) {
fieldStrWidth := font.MeasureString(face, str)
currentLineStrWidth := font.MeasureString(face, currentLine)
}
func BenchmarkSummaryFromHTML(b *testing.B) {
- b.StopTimer()
+
input := "<p>First paragraph</p><p>Second paragraph</p>"
- b.StartTimer()
- for i := 0; i < b.N; i++ {
+
+ for b.Loop() {
summary := ExtractSummaryFromHTML(media.Builtin.MarkdownType, input, 2, false)
if s := summary.Content(); s != input {
b.Fatalf("unexpected content: %q", s)
}
func BenchmarkSummaryFromHTMLWithDivider(b *testing.B) {
- b.StopTimer()
+
input := "<p>First paragraph</p><p>FOOO</p><p>Second paragraph</p>"
- b.StartTimer()
- for i := 0; i < b.N; i++ {
+
+ for b.Loop() {
summary := ExtractSummaryFromHTMLWithDivider(media.Builtin.MarkdownType, input, "FOOO")
if s := summary.Content(); s != "<p>First paragraph</p><p>Second paragraph</p>" {
b.Fatalf("unexpected content: %q", s)
defer putPagePathBuilder(pb)
pb.Add("foo", "bar")
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
_ = pb.Path(0)
}
}
pb.Add("foo", "bar")
pb.prefixPath = "foo/"
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
_ = pb.PathDir()
}
}
}
key := "key"
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
cache.getP(key, nil, pages)
}
}
pages = variant.preparePages(pages)
}
b.StartTimer()
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
j := rand.Intn(numPages)
k := variant.search(pages[j], pages)
if k != j {
func BenchmarkSortByWeightAndReverse(b *testing.B) {
p := createSortTestPages(300)
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
p = p.ByWeight().Reverse()
}
}
b.Fatal(err)
}
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
s, err := expander.Expand("posts", page)
if err != nil {
b.Fatal(err)
}
defer f.Close()
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
_, _, err := hashImage(f)
if err != nil {
b.Fatal(err)
logger := loggers.NewDefault()
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
b.StopTimer()
imp := newImportResolver(
strings.NewReader(mainStyles),
}
for i, test := range tests {
- test := test
c.Run(fmt.Sprintf("[%d] %s", i, test.path), func(c *qt.C) {
c.Parallel()
v := config.New()
{[]any{5, "b"}, false},
{[]any{"a", "b", "c"}, false},
} {
- i := i
test := test
c.Run(fmt.Sprint(i), func(c *qt.C) {
c.Parallel()
runBenchmark := func(seed, n, max int) {
name := fmt.Sprintf("n=%d,max=%d", n, max)
b.Run(name, func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
ns.D(seed, n, max)
}
})
{"all nil", []any{nil, nil}, nil, true},
} {
- test := test
i := i
t.Run(test.name, func(t *testing.T) {
func BenchmarkMerge(b *testing.B) {
ns := newNs()
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
ns.Merge(
map[string]any{"a": 42, "c": 3, "e": 11},
map[string]any{"a": 1, "b": 2},
ns := newNs()
params := []any{"a", "b", "c", "d", "f", " &"}
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
_, err := ns.Querify(params...)
if err != nil {
b.Fatal(err)
ns := newNs()
params := []string{"a", "b", "c", "d", "f", " &"}
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
_, err := ns.Querify(params)
if err != nil {
b.Fatal(err)
ns := newNs()
params := map[string]any{"a": "b", "c": "d", "f": " &"}
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
_, err := ns.Querify(params)
if err != nil {
b.Fatal(err)
func BenchmarkSortMap(b *testing.B) {
ns := newNs()
m := map[string]int{"1": 10, "2": 20, "3": 30, "4": 40, "5": 50}
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
ns.Sort(context.Background(), m)
}
}
const k = 10
const iters = 10000
counts := make([]int, max)
- for i := 0; i < iters; i++ {
+ for range iters {
testD(prng, t, k, max, func(n int) {
counts[n]++
})
// TODO: count rng calls?
for _, want := range []int{1, 100, 10000} {
b.Run(fmt.Sprintf("want=%d", want), func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
_d(prng, want, 1000000, func(int) {})
}
})
}
b.Run("eq", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
runOps(b, "eq", "bar")
}
})
b.Run("ne", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
runOps(b, "ne", "baz")
}
})
b.Run("like", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
runOps(b, "like", "^bar")
}
})
seq[fmt.Sprintf("key%d", i)] = "value"
}
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
_, err := ns.Where(context.Background(), seq, "key", "eq", "value")
if err != nil {
b.Fatal(err)
seq = append(seq, &TstX{A: "baz", B: "qux"})
}
}
- b.ResetTimer()
- for range b.N {
+
+ for b.Loop() {
_, err := ns.Where(context.Background(), seq, "TstRv2", "eq", "bar")
if err != nil {
b.Fatal(err)
runBench := func(name, input string, b *testing.B, fn func(v any)) {
b.Run(fmt.Sprintf("%s_%d", name, len(input)), func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
fn(input)
}
})
}
c := make(chan string)
go func() {
- for i := 0; i < n; i++ {
+ for i := range n {
c <- "abcdefghijklmnop"[i : i+1]
}
close(c)
"Nil": nil,
"Zero": 0,
})
- if strings.HasPrefix(tt.out, "ERROR:") {
- e := strings.TrimSpace(strings.TrimPrefix(tt.out, "ERROR:"))
+ if after, ok := strings.CutPrefix(tt.out, "ERROR:"); ok {
+ e := strings.TrimSpace(after)
if err == nil || !strings.Contains(err.Error(), e) {
t.Errorf("%s: Execute: %v, want error %q", tt.text, err, e)
}
t.Fatal(err)
}
const count = 20
- for i := 0; i < count; i++ {
+ for i := range count {
_, err := tmpl.New(fmt.Sprintf("x%d.html", i)).Parse(`{{ template "templ.html" .}}`)
if err != nil {
t.Fatal(err)
}
var wg sync.WaitGroup
- for i := 0; i < 10; i++ {
+ for range 10 {
wg.Add(1)
go func() {
defer wg.Done()
- for j := 0; j < count; j++ {
+ for j := range count {
sub := tmpl.Lookup(fmt.Sprintf("x%d.html", j))
if err := sub.Execute(io.Discard, nil); err != nil {
t.Error(err)
// Add all environment variables that affect the Go command to test metadata.
// Cached test results will be invalidate when these variables change.
// See golang.org/issue/32285.
- for _, envVar := range strings.Fields(cfg.KnownEnv) {
+ for envVar := range strings.FieldsSeq(cfg.KnownEnv) {
os.Getenv(envVar)
}
return path
t.Fatalf("%v: %v\n%s", cmd, err, cmd.Stderr)
}
- for _, line := range strings.Split(string(out), "\n") {
+ for line := range strings.SplitSeq(string(out), "\n") {
if line == "" {
continue
}
cmd = testenv.CleanCmdEnv(cmd)
for _, env := range cmd.Env {
- if strings.HasPrefix(env, "PWD=") {
- pwd := strings.TrimPrefix(env, "PWD=")
+ if after, ok := strings.CutPrefix(env, "PWD="); ok {
+ pwd := after
if pwd != dir {
t.Errorf("unexpected PWD: want %s, got %s", dir, pwd)
}
}
c := make(chan string)
go func() {
- for i := 0; i < n; i++ {
+ for i := range n {
c <- "abcdefghijklmnop"[i : i+1]
}
close(c)
"Nil": nil,
"Zero": 0,
})
- if strings.HasPrefix(tt.out, "ERROR:") {
- e := strings.TrimSpace(strings.TrimPrefix(tt.out, "ERROR:"))
+ if after, ok := strings.CutPrefix(tt.out, "ERROR:"); ok {
+ e := strings.TrimSpace(after)
if err == nil || !strings.Contains(err.Error(), e) {
t.Errorf("%s: Execute: %v, want error %q", tt.text, err, e)
}
wg.Add(1)
go func() {
defer wg.Done()
- for j := 0; j < numTemplates; j++ {
+ for range numTemplates {
_, err := tplFoo.AddParseTree(tplBar.Name(), tplBar.Tree)
if err != nil {
t.Error(err)
"errors"
"fmt"
"io"
+ "maps"
"net/url"
"reflect"
"strings"
// addFuncs adds to values the functions in funcs. It does no checking of the input -
// call addValueFuncs first.
func addFuncs(out, in FuncMap) {
- for name, fn := range in {
- out[name] = fn
- }
+ maps.Copy(out, in)
}
// goodFunc reports whether the function or method has the right result signature.
}
// Added for Hugo
- for i := 0; i < len(first); i++ {
+ for i := range first {
argv[i] = s.validateType(first[i], typ.In(i))
}
"bytes"
"fmt"
"runtime"
+ "slices"
"strconv"
"strings"
)
// variable is not defined.
func (t *Tree) useVar(pos Pos, name string) Node {
v := t.newVariable(pos, name)
- for _, varName := range t.vars {
- if varName == v.Ident[0] {
- return v
- }
+ if slices.Contains(t.vars, v.Ident[0]) {
+ return v
}
t.errorf("undefined variable %q", v.Ident[0])
return nil
builders[i] = hugolib.NewIntegrationTestBuilder(cfg)
}
- b.ResetTimer()
-
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
builders[i].Build()
}
}
}
counter := 0
- for _, word := range strings.Fields(tpl.StripHTML(ss)) {
+ for word := range strings.FieldsSeq(tpl.StripHTML(ss)) {
runeCount := utf8.RuneCountInString(word)
if len(word) == runeCount {
counter++
func BenchmarkTruncate(b *testing.B) {
b.Run("Plain text", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
ns.Truncate(10, "I am a test sentence")
}
})
b.Run("With link", func(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
ns.Truncate(10, "I have a <a href='/markdown'>Markdown link</a> inside")
}
})
ns := time.New(htime.NewTimeFormatter(translators.GetTranslator("en")), gtime.UTC, bb.H.Deps)
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
timeZoneName := timeZoneNames[i%len(timeZoneNames)]
_, err := ns.In(timeZoneName, gtime.Now())
if err != nil {
}
func BenchmarkInWithoutCaching(b *testing.B) {
- for i := 0; i < b.N; i++ {
+ for i := 0; b.Loop(); i++ {
timeZoneName := timeZoneNames[i%len(timeZoneNames)]
location, err := gtime.LoadLocation(timeZoneName)
if err != nil {
},
}
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
for _, pair := range pairs {
_ = dh.compareDescriptors(CategoryLayout, pair.d1, pair.d2, nil, nil)
}
Category: tplimpl.CategoryLayout,
Desc: tplimpl.TemplateDescriptor{Kind: kinds.KindPage, LayoutFromTemplate: "single", OutputFormat: "html"},
}
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
store.LookupPagesLayout(q)
}
})
Category: tplimpl.CategoryLayout,
Desc: tplimpl.TemplateDescriptor{Kind: kinds.KindPage, LayoutFromTemplate: "single", OutputFormat: "html"},
}
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
store.LookupPagesLayout(q)
}
})
bb := hugolib.Test(b, newSetupTestSites)
store := bb.H.TemplateStore
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
newStore, err := store.NewFromOpts()
if err != nil {
b.Fatal(err)
p := bb.H.Sites[0].RegularPages()[0]
bb.Assert(p, qt.Not(qt.IsNil))
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
err := store.ExecuteWithContext(context.Background(), ti, io.Discard, p)
if err != nil {
b.Fatal(err)
store := bb.H.TemplateStore
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
fi := store.LookupPartial("p3.html")
if fi == nil {
b.Fatal("not found")
b.Run("toplevelpage", func(b *testing.B) {
toplevelpage, _ := bb.H.Sites[0].GetPage("/toplevelpage")
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
runOne(toplevelpage)
}
})
b.Run("nestedpage", func(b *testing.B) {
toplevelpage, _ := bb.H.Sites[0].GetPage("/a/b/c/nested")
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
runOne(toplevelpage)
}
})
ctx := context.Background()
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
result, err := ns.Unmarshal(ctx, jsons[rand.Intn(numJsons)])
if err != nil {
b.Fatal(err)
ctx := context.Background()
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
result, err := ns.Unmarshal(ctx, jsons[rand.Intn(numJsons)])
if err != nil {
b.Fatal(err)
}
tr := transform.New(New(lrurl))
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
in.Seek(0, 0)
tr.Apply(io.Discard, in)
}
func BenchmarkAbsURL(b *testing.B) {
tr := transform.New(NewAbsURLTransformer(testBaseURL))
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
apply(b.Errorf, tr, absURLlBenchTests)
}
}
func BenchmarkAbsURLSrcset(b *testing.B) {
tr := transform.New(NewAbsURLTransformer(testBaseURL))
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
apply(b.Errorf, tr, srcsetTests)
}
}
func BenchmarkXMLAbsURLSrcset(b *testing.B) {
tr := transform.New(NewAbsURLInXMLTransformer(testBaseURL))
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
apply(b.Errorf, tr, srcsetXMLTests)
}
}
func BenchmarkXMLAbsURL(b *testing.B) {
tr := transform.New(NewAbsURLInXMLTransformer(testBaseURL))
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
apply(b.Errorf, tr, xmlAbsURLBenchTests)
}
}
func BenchmarkPoller(b *testing.B) {
runBench := func(b *testing.B, item *itemToWatch) {
b.ResetTimer()
- for i := 0; i < b.N; i++ {
+ for b.Loop() {
evs, err := item.checkForChanges()
if err != nil {
b.Fatal(err)
projects / brevno-suite / hugo / commitdiff