env_test.go

package gitconfig_test

import (
	"errors"
	"fmt"
	"io/fs"
	"os"
	"os/exec"
	"path/filepath"
	"runtime"
	"slices"
	"strconv"
	"strings"
	"sync"
	"testing"
	"time"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"

	"github.com/git-bug/gitconfig"
)

// sep is the separator the platform's paths use. An include's relative
// path is joined to the including file's directory with the separator that
// ends it, and is not cleaned: the include's own '/' are kept.
const sep = string(filepath.Separator)

// tempDir returns a temporary directory with symbolic links resolved, so
// that paths built from it are the real paths includeIf "gitdir:" compares.
func tempDir(t testing.TB) string {
	t.Helper()
	dir, err := filepath.EvalSymlinks(t.TempDir())
	require.NoError(t, err)
	return dir
}

// writeFile writes content to path, creating parent directories.
func writeFile(t testing.TB, path, content string) {
	t.Helper()
	require.NoError(t, os.MkdirAll(filepath.Dir(path), 0o755))
	require.NoError(t, os.WriteFile(path, []byte(content), 0o644))
}

func readFile(t testing.TB, path string) string {
	t.Helper()
	data, err := os.ReadFile(path)
	require.NoError(t, err)
	return string(data)
}

// initRepo creates a minimal git directory at gitDir, on branch main.
func initRepo(t testing.TB, gitDir, config string) {
	t.Helper()
	writeFile(t, filepath.Join(gitDir, "HEAD"), "ref: refs/heads/main\n")
	writeFile(t, filepath.Join(gitDir, "config"), config)
	require.NoError(t, os.MkdirAll(filepath.Join(gitDir, "objects"), 0o755))
	require.NoError(t, os.MkdirAll(filepath.Join(gitDir, "refs"), 0o755))
}

// addWorktree registers a linked worktree named name in the repository at
// gitDir, as `git worktree add` does, and returns its git directory.
func addWorktree(t testing.TB, gitDir, name, branch string) string {
	t.Helper()
	wtGitDir := filepath.Join(gitDir, "worktrees", name)
	writeFile(t, filepath.Join(wtGitDir, "HEAD"), "ref: refs/heads/"+branch+"\n")
	writeFile(t, filepath.Join(wtGitDir, "commondir"), "../..\n")
	writeFile(t, filepath.Join(wtGitDir, "gitdir"), filepath.Join(filepath.Dir(gitDir), name, ".git")+"\n")
	return wtGitDir
}

type scoped struct {
	Scope gitconfig.Scope
	Value string
}

func scopedValues(entries []gitconfig.Entry) []scoped {
	var out []scoped
	for _, e := range entries {
		out = append(out, scoped{e.Origin.Scope, e.Value})
	}
	return out
}

// fullEnv is an Env with a file in every scope, each setting a.k to the
// scope's name.
func fullEnv(t testing.TB) gitconfig.Env {
	t.Helper()
	dir := tempDir(t)
	home := filepath.Join(dir, "home")
	gitDir := filepath.Join(dir, "repo", ".git")

	writeFile(t, filepath.Join(dir, "etc", "gitconfig"), "[a]\n\tk = system\n")
	writeFile(t, filepath.Join(home, ".config", "git", "config"), "[a]\n\tk = xdg\n\txdgonly = x\n")
	writeFile(t, filepath.Join(home, ".gitconfig"), "[a]\n\tk = home\n")
	initRepo(t, gitDir, "[core]\n\trepositoryformatversion = 1\n[extensions]\n\tworktreeConfig = true\n[a]\n\tk = local\n")
	writeFile(t, filepath.Join(gitDir, "config.worktree"), "[a]\n\tk = worktree\n")

	return gitconfig.Env{
		Home:         home,
		GitDir:       gitDir,
		SystemConfig: filepath.Join(dir, "etc", "gitconfig"),
		GlobalConfig: []string{filepath.Join(home, ".config", "git", "config"), filepath.Join(home, ".gitconfig")},
		Command:      []gitconfig.CommandEntry{{Key: "a.k", Value: "command"}},
	}
}

func TestEnvLoad(t *testing.T) {
	t.Run("every scope in order of precedence", func(t *testing.T) {
		env := fullEnv(t)
		c, err := env.Load()
		require.NoError(t, err)

		assert.Equal(t, []scoped{
			{gitconfig.ScopeSystem, "system"},
			{gitconfig.ScopeGlobal, "xdg"},
			{gitconfig.ScopeGlobal, "home"},
			{gitconfig.ScopeLocal, "local"},
			{gitconfig.ScopeWorktree, "worktree"},
			{gitconfig.ScopeCommand, "command"},
		}, scopedValues(c.GetAll("a.k")))

		e, ok := c.Get("a.k")
		require.True(t, ok)
		assert.Equal(t, gitconfig.Origin{Scope: gitconfig.ScopeCommand}, e.Origin)

		e, ok = c.Get("a.xdgonly")
		require.True(t, ok)
		assert.Equal(t, gitconfig.Origin{Scope: gitconfig.ScopeGlobal, File: env.GlobalConfig[0], Line: 3}, e.Origin)

		local := c.GetAll("a.k")[3]
		assert.Equal(t, gitconfig.Origin{Scope: gitconfig.ScopeLocal, File: filepath.Join(env.GitDir, "config"), Line: 6}, local.Origin)
	})

	t.Run("worktree file ignored without extensions.worktreeConfig", func(t *testing.T) {
		env := fullEnv(t)
		writeFile(t, filepath.Join(env.GitDir, "config"), "[a]\n\tk = local\n")
		c, err := env.Load()
		require.NoError(t, err)
		assert.NotContains(t, values(c.GetAll("a.k")), "worktree")
	})

	t.Run("empty Env reads nothing", func(t *testing.T) {
		c, err := gitconfig.Env{}.Load()
		require.NoError(t, err)
		assert.Empty(t, slices.Collect(c.All()))
	})

	t.Run("missing files are empty", func(t *testing.T) {
		dir := tempDir(t)
		env := gitconfig.Env{
			Home:         dir,
			GitDir:       filepath.Join(dir, ".git"),
			SystemConfig: filepath.Join(dir, "nosystem"),
			GlobalConfig: []string{filepath.Join(dir, "a"), filepath.Join(dir, "b")},
		}
		require.NoError(t, os.Mkdir(env.GitDir, 0o755))
		c, err := env.Load()
		require.NoError(t, err)
		assert.Empty(t, slices.Collect(c.All()))
	})

	t.Run("file in place of a directory is missing", func(t *testing.T) {
		// A file ~/.config/git hides the XDG file, as for git.
		dir := tempDir(t)
		writeFile(t, filepath.Join(dir, "git"), "")
		env := gitconfig.Env{GlobalConfig: []string{filepath.Join(dir, "git", "config")}}
		c, err := env.Load()
		require.NoError(t, err)
		assert.Empty(t, slices.Collect(c.All()))
	})

	t.Run("outside a repository", func(t *testing.T) {
		env := fullEnv(t)
		env.GitDir = ""
		c, err := env.Load()
		require.NoError(t, err)
		assert.Equal(t, []string{"system", "xdg", "home", "command"}, values(c.GetAll("a.k")))
	})

	t.Run("command entries", func(t *testing.T) {
		c, err := gitconfig.Env{Command: []gitconfig.CommandEntry{
			{Key: "A.K", Value: "1"},
			{Key: "a.flag", Implicit: true},
			{Key: "remote.Origin.url", Value: "u"},
		}}.Load()
		require.NoError(t, err)
		assert.Equal(t, []string{"a.k=1", "a.flag", "remote.Origin.url=u"}, list(slices.Collect(c.All())))
		b, err := c.Bool("a.flag", false)
		require.NoError(t, err)
		assert.True(t, b)
	})

	t.Run("invalid command key", func(t *testing.T) {
		_, err := gitconfig.Env{Command: []gitconfig.CommandEntry{{Key: "a.k_y", Value: "1"}}}.Load()
		require.ErrorIs(t, err, gitconfig.ErrInvalidKey)
		var ke *gitconfig.KeyError
		require.ErrorAs(t, err, &ke)
		assert.Equal(t, "a.k_y", ke.Key)
	})

	t.Run("relative GitDir", func(t *testing.T) {
		_, err := gitconfig.Env{GitDir: ".git"}.Load()
		require.ErrorIs(t, err, gitconfig.ErrNotAbsolute)
	})

	t.Run("syntax error", func(t *testing.T) {
		env := fullEnv(t)
		local := filepath.Join(env.GitDir, "config")
		writeFile(t, local, "[a]\n\tk = v\n[broken\n")
		_, err := env.Load()

		var fe *gitconfig.FileError
		require.ErrorAs(t, err, &fe)
		assert.Equal(t, local, fe.Path)
		var se *gitconfig.SyntaxError
		require.ErrorAs(t, err, &se)
		assert.Equal(t, local, se.File)
		assert.Equal(t, 3, se.Line)
	})

	t.Run("configuration file is a directory", func(t *testing.T) {
		dir := tempDir(t)
		_, err := gitconfig.Env{GlobalConfig: []string{dir}}.Load()
		require.ErrorIs(t, err, gitconfig.ErrNotRegular)
		var fe *gitconfig.FileError
		require.ErrorAs(t, err, &fe)
		assert.Equal(t, dir, fe.Path)
	})
}

func TestEnvIncludes(t *testing.T) {
	// load writes the given files under a fresh directory and loads
	// <dir>/main as the global configuration, with <dir> as home.
	load := func(t *testing.T, files map[string]string) (string, *gitconfig.Config, error) {
		t.Helper()
		dir := tempDir(t)
		for name, content := range files {
			writeFile(t, filepath.Join(dir, name), strings.ReplaceAll(content, "$DIR", filepath.ToSlash(dir)))
		}
		c, err := gitconfig.Env{Home: dir, GlobalConfig: []string{filepath.Join(dir, "main")}}.Load()
		return dir, c, err
	}

	t.Run("spliced at the position of the directive", func(t *testing.T) {
		dir, c, err := load(t, map[string]string{
			"main":    "[a]\n\tk = before\n[include]\n\tpath = sub/inc\n[a]\n\tk = after\n",
			"sub/inc": "[a]\n\tk = inc\n",
		})
		require.NoError(t, err)
		assert.Equal(t, []string{"a.k=before", "include.path=sub/inc", "a.k=inc", "a.k=after"}, list(slices.Collect(c.All())))

		inc := c.GetAll("a.k")[1]
		assert.Equal(t, gitconfig.Origin{Scope: gitconfig.ScopeGlobal, File: dir + sep + "sub/inc", Line: 2}, inc.Origin)
	})

	t.Run("included value wins when last", func(t *testing.T) {
		_, c, err := load(t, map[string]string{
			"main": "[user]\n\tname = home\n[include]\n\tpath = inc\n",
			"inc":  "[user]\n\tname = inc\n",
		})
		require.NoError(t, err)
		assert.Equal(t, "inc", c.Value("user.name", ""))
	})

	t.Run("origin path not cleaned", func(t *testing.T) {
		dir, c, err := load(t, map[string]string{
			"main":  "[include]\n\tpath = ./d/../d/inc\n",
			"d/inc": "[a]\n\tk = v\n",
		})
		require.NoError(t, err)
		e, ok := c.Get("a.k")
		require.True(t, ok)
		assert.Equal(t, dir+sep+"./d/../d/inc", e.Origin.File)
	})

	t.Run("nested includes relative to the including file", func(t *testing.T) {
		dir, c, err := load(t, map[string]string{
			"main":      "[include]\n\tpath = d1/inc\n",
			"d1/inc":    "[include]\n\tpath = d2/inc\n",
			"d1/d2/inc": "[a]\n\tk = deep\n",
		})
		require.NoError(t, err)
		e, ok := c.Get("a.k")
		require.True(t, ok)
		assert.Equal(t, "deep", e.Value)
		assert.Equal(t, dir+sep+"d1/d2/inc", e.Origin.File)
	})

	t.Run("home expanded", func(t *testing.T) {
		_, c, err := load(t, map[string]string{
			"main":  "[include]\n\tpath = ~/tinc\n[user]\n\tname = after\n[include]\n\tpath = ~/tinc2\n",
			"tinc":  "[user]\n\tname = tinc\n",
			"tinc2": "[user]\n\temail = e\n",
		})
		require.NoError(t, err)
		assert.Equal(t, "after", c.Value("user.name", ""))
		assert.Equal(t, "e", c.Value("user.email", ""))
	})

	t.Run("absolute path", func(t *testing.T) {
		_, c, err := load(t, map[string]string{
			"main": "[include]\n\tpath = $DIR/abs\n",
			"abs":  "[a]\n\tk = v\n",
		})
		require.NoError(t, err)
		assert.Equal(t, "v", c.Value("a.k", ""))
	})

	t.Run("missing file ignored", func(t *testing.T) {
		_, c, err := load(t, map[string]string{
			"main": "[include]\n\tpath = missing\n\tpath = ~/missing\n\tpath = main/missing\n[a]\n\tk = v\n",
		})
		require.NoError(t, err)
		assert.Equal(t, "v", c.Value("a.k", ""))
	})

	t.Run("several paths in one section", func(t *testing.T) {
		_, c, err := load(t, map[string]string{
			"main": "[include]\n\tpath = one\n\tpath = two\n",
			"one":  "[a]\n\tk = 1\n",
			"two":  "[a]\n\tk = 2\n",
		})
		require.NoError(t, err)
		assert.Equal(t, []string{"1", "2"}, values(c.GetAll("a.k")))
	})

	t.Run("case-insensitive directive", func(t *testing.T) {
		_, c, err := load(t, map[string]string{
			"main": "[Include]\n\tPath = inc\n",
			"inc":  "[a]\n\tk = v\n",
		})
		require.NoError(t, err)
		assert.Equal(t, "v", c.Value("a.k", ""))
	})

	t.Run("include subsection is not a directive", func(t *testing.T) {
		_, c, err := load(t, map[string]string{
			"main": "[include \"x\"]\n\tpath = inc\n",
			"inc":  "[a]\n\tk = v\n",
		})
		require.NoError(t, err)
		_, ok := c.Get("a.k")
		assert.False(t, ok)
	})

	t.Run("each scope's includes have its scope", func(t *testing.T) {
		env := fullEnv(t)
		writeFile(t, filepath.Join(env.GitDir, "config"), "[include]\n\tpath = inc\n")
		writeFile(t, filepath.Join(env.GitDir, "inc"), "[a]\n\tk = local-inc\n")
		c, err := env.Load()
		require.NoError(t, err)
		assert.Contains(t, scopedValues(c.GetAll("a.k")), scoped{gitconfig.ScopeLocal, "local-inc"})
	})

	t.Run("depth limit", func(t *testing.T) {
		chain := func(n int) map[string]string {
			files := map[string]string{"main": "[include]\n\tpath = c1\n"}
			for i := 1; i < n; i++ {
				files[fmt.Sprintf("c%d", i)] = fmt.Sprintf("[include]\n\tpath = c%d\n", i+1)
			}
			files[fmt.Sprintf("c%d", n)] = "[a]\n\tk = deep\n"
			return files
		}

		_, c, err := load(t, chain(10))
		require.NoError(t, err)
		assert.Equal(t, "deep", c.Value("a.k", ""))

		_, _, err = load(t, chain(11))
		require.ErrorIs(t, err, gitconfig.ErrIncludeDepth)
		var fe *gitconfig.FileError
		require.ErrorAs(t, err, &fe)
	})

	t.Run("cycle", func(t *testing.T) {
		_, _, err := load(t, map[string]string{"main": "[include]\n\tpath = main\n"})
		require.ErrorIs(t, err, gitconfig.ErrIncludeDepth)
	})

	t.Run("syntax error in an included file", func(t *testing.T) {
		dir, _, err := load(t, map[string]string{
			"main": "[include]\n\tpath = ./inc\n",
			"inc":  "[a]\n\tk = \"unterminated\n",
		})
		var se *gitconfig.SyntaxError
		require.ErrorAs(t, err, &se)
		assert.Equal(t, dir+sep+"./inc", se.File)
		assert.Equal(t, 2, se.Line)
	})

	t.Run("an include fails before a later syntax error", func(t *testing.T) {
		// As git 2.47.3: includes are followed as the file is read.
		dir, _, err := load(t, map[string]string{
			"main": "[include]\n\tpath = ./inc\n[b]\n\tk = \"unterminated\n",
			"inc":  "[a]\n\tk = \"unterminated\n",
		})
		var se *gitconfig.SyntaxError
		require.ErrorAs(t, err, &se)
		assert.Equal(t, dir+sep+"./inc", se.File)
	})

	t.Run("directory", func(t *testing.T) {
		dir := tempDir(t)
		writeFile(t, filepath.Join(dir, "main"), "[include]\n\tpath = d\n")
		require.NoError(t, os.Mkdir(filepath.Join(dir, "d"), 0o755))
		_, err := gitconfig.Env{GlobalConfig: []string{filepath.Join(dir, "main")}}.Load()
		require.ErrorIs(t, err, gitconfig.ErrNotRegular)
	})

	t.Run("home unknown", func(t *testing.T) {
		dir := tempDir(t)
		writeFile(t, filepath.Join(dir, "main"), "[include]\n\tpath = ~/inc\n")
		_, err := gitconfig.Env{GlobalConfig: []string{filepath.Join(dir, "main")}}.Load()
		require.Error(t, err)
	})

	t.Run("from the command line", func(t *testing.T) {
		dir := tempDir(t)
		inc := filepath.Join(dir, "inc")
		writeFile(t, inc, "[a]\n\tk = inc\n")

		c, err := gitconfig.Env{Command: []gitconfig.CommandEntry{{Key: "include.path", Value: inc}}}.Load()
		require.NoError(t, err)
		assert.Equal(t, []string{"include.path=" + inc, "a.k=inc"}, list(slices.Collect(c.All())))
		e, _ := c.Get("a.k")
		assert.Equal(t, gitconfig.Origin{Scope: gitconfig.ScopeCommand, File: inc, Line: 2}, e.Origin)

		_, err = gitconfig.Env{Command: []gitconfig.CommandEntry{{Key: "include.path", Value: "inc"}}}.Load()
		require.ErrorIs(t, err, gitconfig.ErrNotAbsolute)
	})
}

func TestEnvLoadLimits(t *testing.T) {
	t.Run("file count", func(t *testing.T) {
		// Each level includes the next one 10 times: 10⁴ reads from a few
		// small files.
		dir := tempDir(t)
		for i := range 4 {
			writeFile(t, filepath.Join(dir, fmt.Sprintf("l%d", i)), strings.Repeat(fmt.Sprintf("[include]\n\tpath = l%d\n", i+1), 10))
		}
		writeFile(t, filepath.Join(dir, "l4"), "[a]\n\tk = v\n")

		_, err := gitconfig.Env{GlobalConfig: []string{filepath.Join(dir, "l0")}}.Load()
		require.ErrorIs(t, err, gitconfig.ErrLoadLimit)
		var fe *gitconfig.FileError
		require.ErrorAs(t, err, &fe)
	})

	t.Run("total size", func(t *testing.T) {
		dir := tempDir(t)
		writeFile(t, filepath.Join(dir, "big"), strings.Repeat("# padding padding padding padding\n", (2<<20)/34))
		writeFile(t, filepath.Join(dir, "main"), strings.Repeat("[include]\n\tpath = big\n", 9))

		_, err := gitconfig.Env{GlobalConfig: []string{filepath.Join(dir, "main")}}.Load()
		require.ErrorIs(t, err, gitconfig.ErrLoadLimit)
	})

	// The entry limit bounds memory: one entry costs a hundred times its
	// two bytes.
	limitErr := func(t *testing.T, files map[string]string) {
		t.Helper()
		dir := tempDir(t)
		for name, content := range files {
			writeFile(t, filepath.Join(dir, name), content)
		}
		_, err := gitconfig.Env{GlobalConfig: []string{filepath.Join(dir, "main")}}.Load()
		require.ErrorIs(t, err, gitconfig.ErrLoadLimit)
		var fe *gitconfig.FileError
		require.ErrorAs(t, err, &fe)
	}

	t.Run("entries", func(t *testing.T) {
		limitErr(t, map[string]string{"main": "[a]\n" + strings.Repeat("k\n", 1<<16+1)})
	})

	t.Run("entries across includes", func(t *testing.T) {
		// 40 reads of 2000 entries, under the file and byte limits.
		limitErr(t, map[string]string{
			"main": strings.Repeat("[include]\n\tpath = inc\n", 40),
			"inc":  "[a]\n" + strings.Repeat("k\n", 2000),
		})
	})

	t.Run("distinct headers", func(t *testing.T) {
		var sb strings.Builder
		for i := range 1<<16 + 1 {
			fmt.Fprintf(&sb, "[a \"%x\"]", i)
		}
		limitErr(t, map[string]string{"main": sb.String()})
	})

	t.Run("repeated headers are free", func(t *testing.T) {
		dir := tempDir(t)
		writeFile(t, filepath.Join(dir, "main"), strings.Repeat("[a]", 1<<16+1)+"k\n")
		c, err := gitconfig.Env{GlobalConfig: []string{filepath.Join(dir, "main")}}.Load()
		require.NoError(t, err)
		assert.Len(t, c.GetAll("a.k"), 1)
	})

	t.Run("under the limits", func(t *testing.T) {
		dir := tempDir(t)
		writeFile(t, filepath.Join(dir, "inc"), "[a]\n\tk = v\n")
		writeFile(t, filepath.Join(dir, "main"), strings.Repeat("[include]\n\tpath = inc\n", 100))

		c, err := gitconfig.Env{GlobalConfig: []string{filepath.Join(dir, "main")}}.Load()
		require.NoError(t, err)
		assert.Len(t, c.GetAll("a.k"), 100)
	})

	t.Run("limits are per load", func(t *testing.T) {
		dir := tempDir(t)
		writeFile(t, filepath.Join(dir, "inc"), "[a]\n\tk = v\n")
		writeFile(t, filepath.Join(dir, "main"), strings.Repeat("[include]\n\tpath = inc\n", 600))
		env := gitconfig.Env{GlobalConfig: []string{filepath.Join(dir, "main")}}

		for range 3 {
			_, err := env.Load()
			require.NoError(t, err)
		}
	})

	t.Run("repeated includeIf paths", func(t *testing.T) {
		// One costly pattern, then many paths under it: the condition is
		// evaluated once, not once per path.
		dir := tempDir(t)
		writeFile(t, filepath.Join(dir, "main"), "[includeIf \"gitdir:"+strings.Repeat("a*", 1<<17)+"\"]\n"+strings.Repeat("path =\n", 1<<15))
		initRepo(t, filepath.Join(dir, ".git"), "")

		_, err := gitconfig.Env{GitDir: filepath.Join(dir, ".git"), GlobalConfig: []string{filepath.Join(dir, "main")}}.Load()
		require.NoError(t, err)
	})
}

// TestLoadMemory checks the memory one entry costs, which the entry limit
// multiplies: what a Config keeps, and what loading it allocates in all, a
// bound on its peak. Distinct keys are the costliest: each has its own
// place in the index of the Config.
func TestLoadMemory(t *testing.T) {
	if testing.Short() {
		t.Skip("allocates about 50 MB")
	}
	const n = 1 << 15
	var sb strings.Builder
	sb.WriteString("[a]\n")
	for i := range n {
		fmt.Fprintf(&sb, "k%x\n", i)
	}
	data := sb.String()
	dir := tempDir(t)
	writeFile(t, filepath.Join(dir, "config"), data)

	measure := func(load func() (*gitconfig.Config, error)) (live, total uint64) {
		var before, after runtime.MemStats
		runtime.GC()
		runtime.ReadMemStats(&before)
		c, err := load()
		require.NoError(t, err)
		runtime.GC()
		runtime.ReadMemStats(&after)
		runtime.KeepAlive(c)
		return (after.HeapAlloc - before.HeapAlloc) / n, (after.TotalAlloc - before.TotalAlloc) / n
	}
	for _, tc := range []struct {
		name        string
		load        func() (*gitconfig.Config, error)
		live, total uint64 // ceilings, in bytes per entry
	}{
		{"Load", gitconfig.Env{GlobalConfig: []string{filepath.Join(dir, "config")}}.Load, 400, 1700},
		{"Parse", func() (*gitconfig.Config, error) {
			f, err := gitconfig.Parse("f", []byte(data))
			if err != nil {
				return nil, err
			}
			return f.Config(), nil
		}, 400, 1700},
	} {
		t.Run(tc.name, func(t *testing.T) {
			live, total := measure(tc.load)
			t.Logf("%d B live, %d B allocated per entry", live, total)
			assert.LessOrEqual(t, live, tc.live, "kept per entry")
			assert.LessOrEqual(t, total, tc.total, "allocated per entry")
		})
	}
}

func TestEnvIncludeIf(t *testing.T) {
	dir := tempDir(t)
	s := filepath.ToSlash(dir)
	home := filepath.Join(dir, "home")
	gitDir := filepath.Join(dir, "work", "proj", ".git")
	initRepo(t, gitDir, "")
	writeFile(t, filepath.Join(dir, "inc"), "[a]\n\tk = inc\n")

	// included loads a global file holding only includeIf <cond>.
	included := func(t *testing.T, env gitconfig.Env, cond string) bool {
		t.Helper()
		global := filepath.Join(t.TempDir(), "global")
		writeFile(t, global, fmt.Sprintf("[includeIf %q]\n\tpath = %s/inc\n", cond, s))
		env.GlobalConfig = []string{global}
		c, err := env.Load()
		require.NoError(t, err)
		_, ok := c.Get("a.k")
		return ok
	}

	env := gitconfig.Env{Home: home, GitDir: gitDir}

	t.Run("gitdir", func(t *testing.T) {
		for _, tc := range []struct {
			cond string
			want bool
		}{
			{"gitdir:" + s + "/work/", true},
			{"gitdir:" + s + "/work", false},
			{"gitdir:" + s + "/work/**", true},
			{"gitdir:" + s + "/w*/", true},
			{"gitdir:" + s + "/***", true},
			{"gitdir:" + s + "/***/.git", true},
			{"gitdir:" + s + "/work/****/proj/", true},
			{"gitdir:" + s + "/***/***/***/.git", true},
			{"gitdir:" + s + "/***proj/", false},
			{"gitdir:" + s + "/w***/.git", false},
			{"gitdir:" + s + "/work/proj/.git", true},
			{"gitdir:" + s + "/work/proj/.git/", false},
			{"gitdir:" + s + "/work/proj", false},
			{"gitdir:" + s + "/other/", false},
			{"gitdir:work/", true},
			{"gitdir:proj/.git", true},
			{"gitdir:ork/", false},
			{"gitdir:" + strings.ToUpper(s) + "/WORK/", strings.ToUpper(s) == s},
			{"gitdir/i:" + strings.ToUpper(s) + "/WORK/", true},
			{"gitdir:~/../work/", false},
			{"gitdir:" + s + "/home/../work/", false},
			{"gitdir:" + s + "/./work/", false},
		} {
			t.Run(tc.cond, func(t *testing.T) {
				assert.Equal(t, tc.want, included(t, env, tc.cond))
			})
		}
	})

	t.Run("gitdir with home", func(t *testing.T) {
		env := gitconfig.Env{Home: dir, GitDir: gitDir}
		assert.True(t, included(t, env, "gitdir:~/work/"))
	})

	t.Run("gitdir matches the real path too", func(t *testing.T) {
		link := filepath.Join(dir, "link")
		symlink(t, filepath.Join(dir, "work"), link)
		env := gitconfig.Env{GitDir: filepath.Join(link, "proj", ".git")}
		assert.True(t, included(t, env, "gitdir:"+s+"/work/"), "real path")
		assert.True(t, included(t, env, "gitdir:"+s+"/link/"), "path as given")
	})

	t.Run("gitdir:./ from a relative file", func(t *testing.T) {
		// "./" is the absolute directory of the file: loaded as "config"
		// from cfg, "gitdir:./repo/" is cfg/repo/, not any repo/.
		cfg := filepath.Join(tempDir(t), "cfg")
		writeFile(t, filepath.Join(cfg, "config"), "[includeIf \"gitdir:./repo/\"]\n\tpath = "+s+"/inc\n")
		t.Chdir(cfg)
		for _, tc := range []struct {
			gitDir string
			want   bool
		}{
			{filepath.Join(cfg, "repo", ".git"), true},
			{filepath.Join(dir, "other", "repo", ".git"), false},
		} {
			c, err := gitconfig.Env{GitDir: tc.gitDir}.LoadFile("config")
			require.NoError(t, err)
			_, ok := c.Get("a.k")
			assert.Equal(t, tc.want, ok, tc.gitDir)
		}
	})

	t.Run("gitdir classes", func(t *testing.T) {
		// Checked against git 2.56. A malformed class does not fall back
		// to literal characters: the pattern matches nothing.
		for _, tc := range []struct {
			name string // of the directory holding .git
			cond string
			want bool
		}{
			{"x1", "gitdir:" + s + "/x[[:digit:]]/", true},
			{"x1", "gitdir:" + s + "/[[:lower:]][[:digit:]]/", true},
			{"x1", "gitdir:" + s + "/[[:upper:]]1/", false},
			{"x1", "gitdir/i:" + s + "/[[:upper:]]1/", true},
			{"x1", "gitdir:" + s + "/x[[:alpha:][:digit:]]/", true},
			{"x1", "gitdir:" + s + "/x[![:alpha:]]/", true},
			{"x1", "gitdir:" + s + "/x[[:punct:]]/", false},
			{"x1", "gitdir:" + s + "/x[[:digit:]a-]/", true},
			{"x1", "gitdir:" + s + "/x[[:bogus:]]/", false},
			{"x1", "gitdir:" + s + "/x[![:bogus:]]/", false},
			{"x1", "gitdir:" + s + "/x[1[:bogus:]]/", false},
			{"x1", "gitdir:" + s + "/x[[:DIGIT:]]/", false},
			{"x1", "gitdir:" + s + "/x[[::]1]/", false},
			{"x1", "gitdir:" + s + "/x[[:digit:]/", false},
			{"x1", "gitdir:" + s + "/x1/[a", false},
			{"x-", "gitdir:" + s + "/x[[:digit:]-z]/", true},
			{"xd", "gitdir:" + s + "/x[[:digit]/", true}, // no ":]": '[', ':', 'd', ...
			{"a[b", "gitdir:" + s + "/a[b/", false},
			{"a[b", "gitdir:" + s + "/a[[]b/", true},
			{"a[b", "gitdir:" + s + "/[[:alpha:]][[]b/", true},
		} {
			t.Run(tc.name+" "+tc.cond, func(t *testing.T) {
				gitDir := filepath.Join(dir, tc.name, ".git")
				initRepo(t, gitDir, "")
				assert.Equal(t, tc.want, included(t, gitconfig.Env{GitDir: gitDir}, tc.cond))
			})
		}
	})

	t.Run("malformed patterns take linear time", func(t *testing.T) {
		// Each '[' would otherwise scan the rest of the pattern. A final
		// ":]" makes each "[:" look for the end of a class name.
		for _, p := range []string{"[", "[\\\\]", "[:", "[[:"} {
			cond := "gitdir:" + strings.Repeat(p, 1<<18/len(p))
			assert.False(t, included(t, env, cond), "%q", p)
			assert.False(t, included(t, env, cond+":]"), "%q, then \":]\"", p)
		}
	})

	t.Run("onbranch", func(t *testing.T) {
		for _, tc := range []struct {
			head string
			cond string
			want bool
		}{
			{"ref: refs/heads/main\n", "onbranch:main", true},
			{"ref: refs/heads/main\n", "onbranch:ma*", true},
			{"ref: refs/heads/main\n", "onbranch:other", false},
			{"ref: refs/heads/main\n", "onbranch:mai", false},
			{"ref: refs/heads/feature/x\n", "onbranch:feature/", true},
			{"ref: refs/heads/feature/x\n", "onbranch:feature/*", true},
			{"ref: refs/heads/feature/x\n", "onbranch:x", false},
			{"0123456789012345678901234567890123456789\n", "onbranch:main", false},
			{"ref:refs/heads/main\n", "onbranch:main", true},
			{"ref:\trefs/heads/main\n", "onbranch:main", true},
		} {
			t.Run(tc.head+tc.cond, func(t *testing.T) {
				gitDir := filepath.Join(tempDir(t), ".git")
				initRepo(t, gitDir, "")
				writeFile(t, filepath.Join(gitDir, "HEAD"), tc.head)
				assert.Equal(t, tc.want, included(t, gitconfig.Env{GitDir: gitDir}, tc.cond))
			})
		}
	})

	t.Run("outside a repository", func(t *testing.T) {
		env := gitconfig.Env{Home: home}
		assert.False(t, included(t, env, "gitdir:/"))
		assert.False(t, included(t, env, "gitdir:**"))
		assert.False(t, included(t, env, "onbranch:main"))
		assert.False(t, included(t, env, "onbranch:*"))
	})

	t.Run("unknown condition", func(t *testing.T) {
		assert.False(t, included(t, env, "nosuch:x"))
		assert.False(t, included(t, env, "gitdir"))
	})

	t.Run("relative gitdir pattern from the command line", func(t *testing.T) {
		// git prints an error and goes on without the include.
		env := gitconfig.Env{GitDir: gitDir, Command: []gitconfig.CommandEntry{{Key: "includeIf.gitdir:./.path", Value: s + "/inc"}}}
		_, err := env.Load()
		require.ErrorIs(t, err, gitconfig.ErrNotAbsolute)
	})

	t.Run("in the repository's config, relative path", func(t *testing.T) {
		gitDir := filepath.Join(tempDir(t), ".git")
		initRepo(t, gitDir, "[includeIf \"onbranch:main\"]\n\tpath = inc\n")
		writeFile(t, filepath.Join(gitDir, "inc"), "[a]\n\tk = v\n")
		c, err := gitconfig.Env{GitDir: gitDir}.Load()
		require.NoError(t, err)
		e, ok := c.Get("a.k")
		require.True(t, ok)
		assert.Equal(t, gitconfig.Origin{Scope: gitconfig.ScopeLocal, File: gitDir + sep + "inc", Line: 2}, e.Origin)
	})

	t.Run("linked worktree", func(t *testing.T) {
		gitDir := filepath.Join(tempDir(t), "main", ".git")
		initRepo(t, gitDir, "[includeIf \"onbranch:wt-branch\"]\n\tpath = inc\n")
		writeFile(t, filepath.Join(gitDir, "inc"), "[a]\n\tk = v\n")
		wt := addWorktree(t, gitDir, "wt", "wt-branch")

		c, err := gitconfig.Env{GitDir: wt}.Load()
		require.NoError(t, err)
		assert.Equal(t, "v", c.Value("a.k", ""), "HEAD of the worktree, config of the common directory")

		c, err = gitconfig.Env{GitDir: gitDir}.Load()
		require.NoError(t, err)
		_, ok := c.Get("a.k")
		assert.False(t, ok)
	})
}

func TestEnvLoadScope(t *testing.T) {
	t.Run("each scope alone", func(t *testing.T) {
		env := fullEnv(t)
		for _, tc := range []struct {
			scope gitconfig.Scope
			want  []scoped
		}{
			{gitconfig.ScopeSystem, []scoped{{gitconfig.ScopeSystem, "system"}}},
			{gitconfig.ScopeGlobal, []scoped{{gitconfig.ScopeGlobal, "xdg"}, {gitconfig.ScopeGlobal, "home"}}},
			{gitconfig.ScopeLocal, []scoped{{gitconfig.ScopeLocal, "local"}}},
			{gitconfig.ScopeWorktree, []scoped{{gitconfig.ScopeWorktree, "worktree"}}},
			{gitconfig.ScopeCommand, []scoped{{gitconfig.ScopeCommand, "command"}}},
		} {
			t.Run(tc.scope.String(), func(t *testing.T) {
				c, err := env.LoadScope(tc.scope)
				require.NoError(t, err)
				assert.Equal(t, tc.want, scopedValues(c.GetAll("a.k")))
			})
		}
	})

	t.Run("includes followed", func(t *testing.T) {
		env := fullEnv(t)
		writeFile(t, filepath.Join(env.GitDir, "config"), "[include]\n\tpath = inc\n")
		writeFile(t, filepath.Join(env.GitDir, "inc"), "[a]\n\tk = inc\n")
		c, err := env.LoadScope(gitconfig.ScopeLocal)
		require.NoError(t, err)
		assert.Equal(t, []scoped{{gitconfig.ScopeLocal, "inc"}}, scopedValues(c.GetAll("a.k")))
	})

	t.Run("absent files are empty", func(t *testing.T) {
		dir := tempDir(t)
		gitDir := filepath.Join(dir, ".git")
		initRepo(t, gitDir, "[extensions]\n\tworktreeConfig = true\n")
		env := gitconfig.Env{GitDir: gitDir, GlobalConfig: []string{filepath.Join(dir, "missing")}}
		for _, s := range []gitconfig.Scope{gitconfig.ScopeSystem, gitconfig.ScopeGlobal, gitconfig.ScopeWorktree, gitconfig.ScopeCommand} {
			c, err := env.LoadScope(s)
			require.NoError(t, err, s)
			assert.Empty(t, slices.Collect(c.All()), s)
		}
	})

	t.Run("worktree without the extension reads the local config", func(t *testing.T) {
		env := fullEnv(t)
		writeFile(t, filepath.Join(env.GitDir, "config"), "[a]\n\tk = local\n")
		c, err := env.LoadScope(gitconfig.ScopeWorktree)
		require.NoError(t, err)
		assert.Equal(t, []scoped{{gitconfig.ScopeLocal, "local"}}, scopedValues(c.GetAll("a.k")))
	})

	t.Run("unavailable scopes", func(t *testing.T) {
		env := fullEnv(t)
		_, err := env.LoadScope(gitconfig.ScopeFile)
		assert.Equal(t, gitconfig.ErrNoScope, err)

		env.GitDir = ""
		_, err = env.LoadScope(gitconfig.ScopeLocal)
		assert.Equal(t, gitconfig.ErrNoScope, err)
		_, err = env.LoadScope(gitconfig.ScopeWorktree)
		assert.Equal(t, gitconfig.ErrNoScope, err)
	})

	t.Run("worktree without the extension, several worktrees", func(t *testing.T) {
		env := fullEnv(t)
		writeFile(t, filepath.Join(env.GitDir, "config"), "[a]\n\tk = local\n")
		addWorktree(t, env.GitDir, "wt", "other")
		_, err := env.LoadScope(gitconfig.ScopeWorktree)
		assert.Equal(t, gitconfig.ErrNoScope, err)

		c, err := env.LoadScope(gitconfig.ScopeLocal)
		require.NoError(t, err)
		assert.Equal(t, "local", c.Value("a.k", ""))
	})

	t.Run("linked worktree", func(t *testing.T) {
		env := fullEnv(t)
		wt := addWorktree(t, env.GitDir, "wt", "other")
		writeFile(t, filepath.Join(wt, "config.worktree"), "[a]\n\tk = linked\n")
		env.GitDir = wt

		c, err := env.LoadScope(gitconfig.ScopeLocal)
		require.NoError(t, err)
		assert.Equal(t, "local", c.Value("a.k", ""))

		c, err = env.LoadScope(gitconfig.ScopeWorktree)
		require.NoError(t, err)
		assert.Equal(t, []scoped{{gitconfig.ScopeWorktree, "linked"}}, scopedValues(c.GetAll("a.k")))
	})

	t.Run("linked worktree through a link", func(t *testing.T) {
		// commondir's ".." apply to the real directory, as the system
		// resolves them, not to the link's parent.
		env := fullEnv(t)
		local := filepath.Join(env.GitDir, "config")
		wt := addWorktree(t, env.GitDir, "wt", "other")
		link := filepath.Join(tempDir(t), "wt")
		symlink(t, wt, link)
		env.GitDir = link

		path, err := env.WritePath(gitconfig.ScopeLocal)
		require.NoError(t, err)
		assert.Equal(t, local, path)
		c, err := env.LoadScope(gitconfig.ScopeLocal)
		require.NoError(t, err)
		assert.Equal(t, "local", c.Value("a.k", ""))
	})
}

func TestEnvLoadFile(t *testing.T) {
	dir := tempDir(t)
	path := filepath.Join(dir, "f")
	writeFile(t, path, "[a]\n\tk = file\n[include]\n\tpath = inc\n")
	writeFile(t, filepath.Join(dir, "inc"), "[a]\n\tk = inc\n")

	env := fullEnv(t)
	c, err := env.LoadFile(path)
	require.NoError(t, err)
	assert.Equal(t, []scoped{{gitconfig.ScopeFile, "file"}, {gitconfig.ScopeFile, "inc"}}, scopedValues(c.GetAll("a.k")))
	e, _ := c.Get("a.k")
	assert.Equal(t, dir+sep+"inc", e.Origin.File)

	c, err = env.LoadFile(filepath.Join(dir, "missing"))
	require.NoError(t, err)
	assert.Empty(t, slices.Collect(c.All()))
}

func TestEnvLoadProtected(t *testing.T) {
	env := fullEnv(t)

	t.Run("system, global and command only", func(t *testing.T) {
		c, err := env.LoadProtected()
		require.NoError(t, err)
		assert.Equal(t, []string{"system", "xdg", "home", "command"}, values(c.GetAll("a.k")))
	})

	t.Run("the repository is not read", func(t *testing.T) {
		writeFile(t, filepath.Join(env.GitDir, "config"), "[broken\n")
		writeFile(t, filepath.Join(env.GitDir, "HEAD"), "garbage")
		_, err := env.LoadProtected()
		require.NoError(t, err)

		_, err = env.Load()
		require.Error(t, err)
	})
}

// otherUID owns the paths a trustCase gives to someone else.
const otherUID = 1001

// requireRoot skips the test unless it can give files to another user.
func requireRoot(t *testing.T) {
	t.Helper()
	if runtime.GOOS == "windows" || os.Geteuid() != 0 {
		t.Skip("needs root, to give files to another user")
	}
}

// trustCase is a case of the ownership check, as recorded in
// docs/GIT-BEHAVIOUR.md, on the repositories trustLayout builds. Paths are
// relative to its root.
type trustCase struct {
	name    string
	start   string   // the directory given to Discover, or to git -C
	other   []string // paths owned by otherUID
	safe    string   // safe.directory in the global file, "" for none
	cond    string   // the includeIf condition safe is under, "" for none
	sudoUID string   // SUDO_UID, "" for unset
	refused string   // the path to list, "" if trusted
}

// trustLayout builds a working tree w with a linked worktree lw, a working
// tree g whose .git file points to gd/x.git, and bare repositories b.git
// and p/.git. w lists every directory in its own safe.directory, which git
// ignores.
func trustLayout(t *testing.T, root string) {
	for _, d := range []string{"w/.git", "gd/x.git", "b.git", "p/.git"} {
		initRepo(t, filepath.Join(root, d), "[safe]\n\tdirectory = *\n")
		for _, sub := range []string{"objects", "refs"} {
			require.NoError(t, os.MkdirAll(filepath.Join(root, d, sub), 0o755))
		}
	}
	writeFile(t, filepath.Join(root, "g", ".git"), "gitdir: "+filepath.Join(root, "gd", "x.git")+"\n")
	wt := addWorktree(t, filepath.Join(root, "w", ".git"), "lw", "other")
	writeFile(t, filepath.Join(root, "lw", ".git"), "gitdir: "+wt+"\n")
}

var trustCases = []trustCase{
	{name: "all owned", start: "w"},
	{name: "all owned, started in .git", start: "w/.git"},
	{name: "gitdir file, all owned", start: "g"},
	{name: "bare, all owned", start: "b.git"},
	{name: "bare named .git, all owned", start: "p/.git"},
	{name: "linked worktree, all owned", start: "lw"},
	{name: "working tree owned by another", start: "w", other: []string{"w"}, refused: "w"},
	{name: ".git owned by another", start: "w", other: []string{"w/.git"}, refused: "w"},
	{name: "config owned by another", start: "w", other: []string{"w/.git/config"}},
	{name: "parent owned by another", start: "w", other: []string{"."}},
	{name: "working tree listed", start: "w", other: []string{"w/.git"}, safe: "w"},
	{name: ".git listed instead of the working tree", start: "w", other: []string{"w/.git"}, safe: "w/.git", refused: "w"},
	{name: "every directory listed", start: "w", other: []string{"w"}, safe: "*"},
	{name: "started in .git, working tree owned by another", start: "w/.git", other: []string{"w"}},
	{name: "started in .git, .git owned by another", start: "w/.git", other: []string{"w/.git"}, refused: "w/.git"},
	{name: "started in .git, working tree listed", start: "w/.git", other: []string{"w/.git"}, safe: "w", refused: "w/.git"},
	{name: "started in .git, .git listed", start: "w/.git", other: []string{"w/.git"}, safe: "w/.git"},
	{name: "gitdir file, git directory owned by another", start: "g", other: []string{"gd/x.git"}, refused: "g"},
	{name: "gitdir file, git directory listed", start: "g", other: []string{"gd/x.git"}, safe: "gd/x.git", refused: "g"},
	{name: "gitdir file, working tree listed", start: "g", other: []string{"gd/x.git"}, safe: "g"},
	{name: "gitdir file owned by another", start: "g", other: []string{"g/.git"}, refused: "g"},
	{name: "bare, owned by another", start: "b.git", other: []string{"b.git"}, refused: "b.git"},
	{name: "bare, listed", start: "b.git", other: []string{"b.git"}, safe: "b.git"},
	{name: "bare, config owned by another", start: "b.git", other: []string{"b.git/config"}},
	{name: "bare named .git, parent owned by another", start: "p/.git", other: []string{"p"}},
	{name: "bare named .git, owned by another, parent listed", start: "p/.git", other: []string{"p/.git"}, safe: "p", refused: "p/.git"},
	{name: "linked worktree, its git directory owned by another", start: "lw", other: []string{"w/.git/worktrees/lw"}, refused: "lw"},
	{name: "linked worktree, main .git owned by another", start: "lw", other: []string{"w/.git"}},
	{name: "linked worktree, main working tree owned by another", start: "lw", other: []string{"w"}},
	{name: "SUDO_UID owns it", start: "w", other: []string{"w", "w/.git"}, sudoUID: strconv.Itoa(otherUID)},
	{name: "SUDO_UID, root owns it", start: "w", sudoUID: strconv.Itoa(otherUID)},
	{name: "SUDO_UID not a number", start: "w", other: []string{"w"}, sudoUID: "abc", refused: "w"},
	{name: "listed under onbranch:", start: "w", other: []string{"w"}, safe: "*", cond: "onbranch:main", refused: "w"},
	{name: "listed under gitdir:", start: "w", other: []string{"w"}, safe: "*", cond: "gitdir:w/", refused: "w"},
}

// prepare builds trustLayout in a clean environment, gives the paths of
// tc.other to otherUID and writes the global file, and returns the root.
// Under tc.cond, safe is in a file the global file includes.
func (tc trustCase) prepare(t *testing.T) string {
	t.Helper()
	home := cleanGitEnv(t)
	t.Setenv("GIT_CONFIG_NOSYSTEM", "1")
	root := tempDir(t)
	trustLayout(t, root)
	for _, p := range tc.other {
		require.NoError(t, os.Chown(filepath.Join(root, p), otherUID, otherUID))
	}
	if tc.safe != "" {
		v := tc.safe
		if v != "*" {
			v = filepath.ToSlash(filepath.Join(root, v))
		}
		safe := "[safe]\n\tdirectory = " + v + "\n"
		if tc.cond != "" {
			writeFile(t, filepath.Join(home, "safe.inc"), safe)
			safe = "[includeIf \"" + tc.cond + "\"]\n\tpath = safe.inc\n"
		}
		writeFile(t, filepath.Join(home, ".gitconfig"), safe)
	}
	if tc.sudoUID != "" {
		t.Setenv("SUDO_UID", tc.sudoUID)
	}
	return root
}

func TestDiscoverTrust(t *testing.T) {
	requireRoot(t)
	for _, tc := range trustCases {
		t.Run(tc.name, func(t *testing.T) {
			root := tc.prepare(t)
			_, err := gitconfig.Discover(filepath.Join(root, tc.start))
			if tc.refused == "" {
				require.NoError(t, err)
				return
			}
			require.ErrorIs(t, err, gitconfig.ErrUntrusted)
			fe, ok := errors.AsType[*gitconfig.FileError](err)
			require.True(t, ok, "got %T", err)
			assert.Equal(t, filepath.Join(root, tc.refused), fe.Path)
		})
	}
}

func TestEnvWritePath(t *testing.T) {
	dir := tempDir(t)
	xdg := filepath.Join(dir, "xdg")
	home := filepath.Join(dir, "home")
	gitDir := filepath.Join(dir, "repo", ".git")
	initRepo(t, gitDir, "")
	extGitDir := filepath.Join(dir, "ext", ".git")
	initRepo(t, extGitDir, "[extensions]\n\tworktreeConfig = true\n")
	multiGitDir := filepath.Join(dir, "multi", ".git")
	initRepo(t, multiGitDir, "")
	addWorktree(t, multiGitDir, "wt", "other")
	linked := addWorktree(t, extGitDir, "wt", "other")

	exists := filepath.Join(dir, "exists")
	writeFile(t, exists, "")

	for _, tc := range []struct {
		name  string
		env   gitconfig.Env
		scope gitconfig.Scope
		want  string // "" for ErrNoScope
	}{
		{"file", gitconfig.Env{GitDir: gitDir}, gitconfig.ScopeFile, ""},
		{"command", gitconfig.Env{GitDir: gitDir}, gitconfig.ScopeCommand, ""},
		{"system", gitconfig.Env{SystemConfig: "/etc/gitconfig"}, gitconfig.ScopeSystem, "/etc/gitconfig"},
		{"no system", gitconfig.Env{}, gitconfig.ScopeSystem, ""},
		{"no global", gitconfig.Env{}, gitconfig.ScopeGlobal, ""},
		{"global, none exists: the last", gitconfig.Env{GlobalConfig: []string{xdg, home}}, gitconfig.ScopeGlobal, home},
		{"global, only the first exists", gitconfig.Env{GlobalConfig: []string{exists, home}}, gitconfig.ScopeGlobal, exists},
		{"global, only the last exists", gitconfig.Env{GlobalConfig: []string{xdg, exists}}, gitconfig.ScopeGlobal, exists},
		{"global, single", gitconfig.Env{GlobalConfig: []string{xdg}}, gitconfig.ScopeGlobal, xdg},
		{"local", gitconfig.Env{GitDir: gitDir}, gitconfig.ScopeLocal, filepath.Join(gitDir, "config")},
		{"local outside a repository", gitconfig.Env{}, gitconfig.ScopeLocal, ""},
		{"worktree with the extension", gitconfig.Env{GitDir: extGitDir}, gitconfig.ScopeWorktree, filepath.Join(extGitDir, "config.worktree")},
		{"worktree without the extension", gitconfig.Env{GitDir: gitDir}, gitconfig.ScopeWorktree, filepath.Join(gitDir, "config")},
		{"worktree without the extension, several worktrees", gitconfig.Env{GitDir: multiGitDir}, gitconfig.ScopeWorktree, ""},
		{"worktree outside a repository", gitconfig.Env{}, gitconfig.ScopeWorktree, ""},
		{"linked worktree, local", gitconfig.Env{GitDir: linked}, gitconfig.ScopeLocal, filepath.Join(extGitDir, "config")},
		{"linked worktree, worktree", gitconfig.Env{GitDir: linked}, gitconfig.ScopeWorktree, filepath.Join(linked, "config.worktree")},
	} {
		t.Run(tc.name, func(t *testing.T) {
			got, err := tc.env.WritePath(tc.scope)
			if tc.want == "" {
				assert.Equal(t, gitconfig.ErrNoScope, err)
				return
			}
			require.NoError(t, err)
			assert.Equal(t, filepath.Clean(tc.want), filepath.Clean(got))
		})
	}
}

func TestEnvWritePathDanglingLink(t *testing.T) {
	// A ~/.gitconfig that links to nothing does not exist: with an XDG
	// file, git writes there; without, through the link (git 2.56).
	dir := tempDir(t)
	xdg := filepath.Join(dir, "xdg")
	home := filepath.Join(dir, "home")
	symlink(t, filepath.Join(dir, "dotfiles", "gitconfig"), home)
	env := gitconfig.Env{GlobalConfig: []string{xdg, home}}

	got, err := env.WritePath(gitconfig.ScopeGlobal)
	require.NoError(t, err)
	assert.Equal(t, home, got)

	writeFile(t, xdg, "")
	got, err = env.WritePath(gitconfig.ScopeGlobal)
	require.NoError(t, err)
	assert.Equal(t, xdg, got)

	require.NoError(t, env.UpdateScope(gitconfig.ScopeGlobal, func(f *gitconfig.File) error {
		return f.Set("a.k", "v")
	}))
	_, err = os.Stat(filepath.Join(dir, "dotfiles"))
	assert.ErrorIs(t, err, fs.ErrNotExist)
	assert.Equal(t, "[a]\n\tk = v\n", readFile(t, xdg))
}

// unsetenv unsets an environment variable for the duration of the test.
func unsetenv(t *testing.T, key string) {
	t.Setenv(key, "")
	require.NoError(t, os.Unsetenv(key))
}

// cleanGitEnv removes every variable Discover reads and sets HOME to a new
// directory, which it returns.
func cleanGitEnv(t *testing.T) string {
	for _, kv := range os.Environ() {
		if k, _, _ := strings.Cut(kv, "="); strings.HasPrefix(k, "GIT_") {
			unsetenv(t, k)
		}
	}
	unsetenv(t, "XDG_CONFIG_HOME")
	unsetenv(t, "SUDO_UID")
	home := tempDir(t)
	t.Setenv("HOME", home)
	t.Setenv("USERPROFILE", home)
	return home
}

func TestDiscover(t *testing.T) {
	t.Run("default global files", func(t *testing.T) {
		home := cleanGitEnv(t)
		env, err := gitconfig.Discover("")
		require.NoError(t, err)
		assert.Equal(t, home, env.Home)
		assert.Equal(t, []string{filepath.Join(home, ".config", "git", "config"), filepath.Join(home, ".gitconfig")}, env.GlobalConfig)
		assert.Empty(t, env.GitDir)
		assert.Empty(t, env.Command)
	})

	t.Run("XDG_CONFIG_HOME", func(t *testing.T) {
		home := cleanGitEnv(t)
		xdg := filepath.Join(home, "xdg")
		t.Setenv("XDG_CONFIG_HOME", xdg)
		env, err := gitconfig.Discover("")
		require.NoError(t, err)
		assert.Equal(t, []string{filepath.Join(xdg, "git", "config"), filepath.Join(home, ".gitconfig")}, env.GlobalConfig)
	})

	t.Run("no home directory", func(t *testing.T) {
		// As git: no ~/.gitconfig, the XDG file only if XDG_CONFIG_HOME
		// says where it is.
		cleanGitEnv(t)
		unsetenv(t, "HOME")
		unsetenv(t, "USERPROFILE")
		env, err := gitconfig.Discover("")
		require.NoError(t, err)
		assert.Empty(t, env.Home)
		assert.Empty(t, env.GlobalConfig)

		xdg := tempDir(t)
		t.Setenv("XDG_CONFIG_HOME", xdg)
		env, err = gitconfig.Discover("")
		require.NoError(t, err)
		assert.Equal(t, []string{filepath.Join(xdg, "git", "config")}, env.GlobalConfig)
	})

	t.Run("GIT_CONFIG_GLOBAL", func(t *testing.T) {
		home := cleanGitEnv(t)
		t.Setenv("GIT_CONFIG_GLOBAL", filepath.Join(home, "g"))
		env, err := gitconfig.Discover("")
		require.NoError(t, err)
		assert.Equal(t, []string{filepath.Join(home, "g")}, env.GlobalConfig)
	})

	t.Run("GIT_CONFIG_SYSTEM", func(t *testing.T) {
		home := cleanGitEnv(t)
		t.Setenv("GIT_CONFIG_SYSTEM", filepath.Join(home, "s"))
		env, err := gitconfig.Discover("")
		require.NoError(t, err)
		assert.Equal(t, filepath.Join(home, "s"), env.SystemConfig)
	})

	t.Run("GIT_CONFIG_NOSYSTEM", func(t *testing.T) {
		home := cleanGitEnv(t)
		t.Setenv("GIT_CONFIG_SYSTEM", filepath.Join(home, "s"))
		t.Setenv("GIT_CONFIG_NOSYSTEM", "1")
		env, err := gitconfig.Discover("")
		require.NoError(t, err)
		assert.Empty(t, env.SystemConfig)
	})

	t.Run("command line, GIT_CONFIG_COUNT before GIT_CONFIG_PARAMETERS", func(t *testing.T) {
		cleanGitEnv(t)
		t.Setenv("GIT_CONFIG_COUNT", "2")
		t.Setenv("GIT_CONFIG_KEY_0", "a.k")
		t.Setenv("GIT_CONFIG_VALUE_0", "count0")
		t.Setenv("GIT_CONFIG_KEY_1", "a.j")
		t.Setenv("GIT_CONFIG_VALUE_1", "")
		t.Setenv("GIT_CONFIG_PARAMETERS", "'a.k'='param' 'a.flag'")
		env, err := gitconfig.Discover("")
		require.NoError(t, err)
		assert.Equal(t, []gitconfig.CommandEntry{
			{Key: "a.k", Value: "count0"},
			{Key: "a.j", Value: ""},
			{Key: "a.k", Value: "param"},
			{Key: "a.flag", Implicit: true},
		}, env.Command)
	})

	t.Run("GIT_CONFIG_COUNT", func(t *testing.T) {
		for _, tc := range []struct {
			count string
			want  int
		}{
			{"", 0},
			{"0", 0},
			{"1", 1},
		} {
			t.Run(strconv.Quote(tc.count), func(t *testing.T) {
				cleanGitEnv(t)
				t.Setenv("GIT_CONFIG_COUNT", tc.count)
				t.Setenv("GIT_CONFIG_KEY_0", "a.k")
				t.Setenv("GIT_CONFIG_VALUE_0", "v")
				env, err := gitconfig.Discover("")
				require.NoError(t, err)
				assert.Len(t, env.Command, tc.want)
			})
		}
	})

	t.Run("malformed environment", func(t *testing.T) {
		for _, tc := range []struct {
			name   string
			vars   map[string]string
			envVar string // EnvError.Var
		}{
			{"bogus count", map[string]string{"GIT_CONFIG_COUNT": "x"}, "GIT_CONFIG_COUNT"},
			{"negative count", map[string]string{"GIT_CONFIG_COUNT": "-1"}, "GIT_CONFIG_COUNT"},
			{"sign only", map[string]string{"GIT_CONFIG_COUNT": "+"}, "GIT_CONFIG_COUNT"},
			{"space only", map[string]string{"GIT_CONFIG_COUNT": " "}, "GIT_CONFIG_COUNT"},
			// Accepted by git.
			{"plus sign", map[string]string{"GIT_CONFIG_COUNT": "+1", "GIT_CONFIG_KEY_0": "a.k", "GIT_CONFIG_VALUE_0": "v"}, "GIT_CONFIG_COUNT"},
			{"leading space", map[string]string{"GIT_CONFIG_COUNT": " 1", "GIT_CONFIG_KEY_0": "a.k", "GIT_CONFIG_VALUE_0": "v"}, "GIT_CONFIG_COUNT"},
			{"negative zero", map[string]string{"GIT_CONFIG_COUNT": "-0"}, "GIT_CONFIG_COUNT"},
			{"too many", map[string]string{"GIT_CONFIG_COUNT": "2147483648"}, "GIT_CONFIG_COUNT"},
			{"missing key", map[string]string{"GIT_CONFIG_COUNT": "1", "GIT_CONFIG_VALUE_0": "v"}, "GIT_CONFIG_KEY_0"},
			{"missing value", map[string]string{"GIT_CONFIG_COUNT": "1", "GIT_CONFIG_KEY_0": "a.k"}, "GIT_CONFIG_VALUE_0"},
			{"bad parameters", map[string]string{"GIT_CONFIG_PARAMETERS": "'a.k"}, "GIT_CONFIG_PARAMETERS"},
			{"bad nosystem", map[string]string{"GIT_CONFIG_NOSYSTEM": "maybe"}, "GIT_CONFIG_NOSYSTEM"},
		} {
			t.Run(tc.name, func(t *testing.T) {
				cleanGitEnv(t)
				for k, v := range tc.vars {
					t.Setenv(k, v)
				}
				_, err := gitconfig.Discover("")
				envErr, ok := errors.AsType[*gitconfig.EnvError](err)
				require.True(t, ok, "got %v", err)
				assert.Equal(t, tc.envVar, envErr.Var)
			})
		}
	})

	t.Run("relative gitDir made absolute", func(t *testing.T) {
		home := cleanGitEnv(t)
		initRepo(t, filepath.Join(home, "repo", ".git"), "")
		t.Chdir(filepath.Join(home, "repo"))
		want, err := filepath.Abs(".git")
		require.NoError(t, err)

		env, err := gitconfig.Discover(".git")
		require.NoError(t, err)
		assert.Equal(t, want, env.GitDir)
	})

	t.Run("gitdir file", func(t *testing.T) {
		home := cleanGitEnv(t)
		gitDir := filepath.Join(home, "main", ".git")
		initRepo(t, gitDir, "")
		wt := addWorktree(t, gitDir, "wt", "other")

		writeFile(t, filepath.Join(home, "wt", ".git"), "gitdir: "+wt+"\n")
		env, err := gitconfig.Discover(filepath.Join(home, "wt", ".git"))
		require.NoError(t, err)
		assert.Equal(t, wt, env.GitDir)

		writeFile(t, filepath.Join(home, "wt2", ".git"), "gitdir: ../main/.git/worktrees/wt\n")
		env, err = gitconfig.Discover(filepath.Join(home, "wt2", ".git"))
		require.NoError(t, err)
		assert.Equal(t, wt, filepath.Clean(env.GitDir))
	})

	t.Run("gitdir file through a link", func(t *testing.T) {
		// The ".." of the gitdir file apply to the real directory that
		// holds it, not to the link's parent.
		home := cleanGitEnv(t)
		gitDir := filepath.Join(home, "real", "target", ".git")
		initRepo(t, gitDir, "")
		writeFile(t, filepath.Join(home, "real", "proj", ".git"), "gitdir: ../target/.git\n")
		symlink(t, filepath.Join(home, "real", "proj"), filepath.Join(home, "proj"))

		env, err := gitconfig.Discover(filepath.Join(home, "proj", ".git"))
		require.NoError(t, err)
		assert.Equal(t, gitDir, env.GitDir)
	})

	t.Run("HEAD a link to a branch with no loose file", func(t *testing.T) {
		// core.preferSymlinkRefs: the branch is unborn or packed.
		home := cleanGitEnv(t)
		gitDir := filepath.Join(home, "repo", ".git")
		initRepo(t, gitDir, "")
		require.NoError(t, os.Remove(filepath.Join(gitDir, "HEAD")))
		symlink(t, filepath.Join("refs", "heads", "main"), filepath.Join(gitDir, "HEAD"))
		env, err := gitconfig.Discover(filepath.Join(home, "repo"))
		require.NoError(t, err)
		assert.Equal(t, gitDir, env.GitDir)
	})

	t.Run("reftable", func(t *testing.T) {
		// As git init --ref-format=reftable: refs/heads is a file.
		home := cleanGitEnv(t)
		gitDir := filepath.Join(home, "repo", ".git")
		initRepo(t, gitDir, "")
		writeFile(t, filepath.Join(gitDir, "HEAD"), "ref: refs/heads/.invalid\n")
		writeFile(t, filepath.Join(gitDir, "refs", "heads"), "this repository uses the reftable format\n")
		require.NoError(t, os.MkdirAll(filepath.Join(gitDir, "reftable"), 0o755))
		env, err := gitconfig.Discover(filepath.Join(home, "repo"))
		require.NoError(t, err)
		assert.Equal(t, gitDir, env.GitDir)
	})

	t.Run("links accepted", func(t *testing.T) {
		home := cleanGitEnv(t)
		// objects and refs links to directories.
		initRepo(t, filepath.Join(home, "linkdirs", ".git"), "")
		for _, name := range []string{"objects", "refs"} {
			p := filepath.Join(home, "linkdirs", ".git", name)
			require.NoError(t, os.Rename(p, p+"-real"))
			symlink(t, name+"-real", p)
		}
		// HEAD a link to a directory under refs, and to a path that
		// leaves refs: git checks only that the link's text starts with
		// "refs/".
		for dir, target := range map[string]string{
			"headrefsdir": "refs/heads",
			"headdotdot":  "refs/../../outside",
		} {
			gitDir := filepath.Join(home, dir, ".git")
			initRepo(t, gitDir, "")
			require.NoError(t, os.MkdirAll(filepath.Join(gitDir, "refs", "heads"), 0o755))
			require.NoError(t, os.Remove(filepath.Join(gitDir, "HEAD")))
			symlink(t, filepath.FromSlash(target), filepath.Join(gitDir, "HEAD"))
		}

		for _, dir := range []string{"linkdirs", "headrefsdir", "headdotdot"} {
			env, err := gitconfig.Discover(filepath.Join(home, dir))
			require.NoError(t, err, dir)
			assert.Equal(t, filepath.Join(home, dir, ".git"), env.GitDir, dir)
		}
	})

	t.Run("HEAD a link not starting with refs/", func(t *testing.T) {
		home := cleanGitEnv(t)
		outside := filepath.Join(home, "outside")
		require.NoError(t, os.MkdirAll(outside, 0o755))
		for dir, target := range map[string]string{
			"dotslash": filepath.FromSlash("./refs/heads/main"),
			"refs":     "refs",
			"dangling": "nothere",
			"absolute": filepath.Join(home, "absolute", ".git", "refs", "heads", "main"),
			"outdir":   outside,
		} {
			gitDir := filepath.Join(home, dir, ".git")
			initRepo(t, gitDir, "")
			writeFile(t, filepath.Join(gitDir, "refs", "heads", "main"), "")
			require.NoError(t, os.Remove(filepath.Join(gitDir, "HEAD")))
			symlink(t, target, filepath.Join(gitDir, "HEAD"))

			_, err := gitconfig.Discover(filepath.Join(home, dir))
			require.ErrorIs(t, err, gitconfig.ErrNotRepository, dir)
			fe, ok := errors.AsType[*gitconfig.FileError](err)
			require.True(t, ok, dir)
			assert.Equal(t, gitDir, fe.Path, dir)
		}
	})

	t.Run("working tree", func(t *testing.T) {
		home := cleanGitEnv(t)
		gitDir := filepath.Join(home, "repo", ".git")
		initRepo(t, gitDir, "")
		env, err := gitconfig.Discover(filepath.Join(home, "repo"))
		require.NoError(t, err)
		assert.Equal(t, gitDir, env.GitDir)
	})

	t.Run("not a repository", func(t *testing.T) {
		home := cleanGitEnv(t)
		// A plain directory whose config would be read as the local scope.
		writeFile(t, filepath.Join(home, "plain", "config"), "[a]\n\tb = 1\n")
		// A config that is not git's, and not a file.
		require.NoError(t, os.MkdirAll(filepath.Join(home, "dotdir", "config"), 0o755))
		// A .git without HEAD, and a HEAD that is a directory.
		initRepo(t, filepath.Join(home, "nohead", ".git"), "")
		require.NoError(t, os.Remove(filepath.Join(home, "nohead", ".git", "HEAD")))
		initRepo(t, filepath.Join(home, "headdir"), "")
		require.NoError(t, os.Remove(filepath.Join(home, "headdir", "HEAD")))
		require.NoError(t, os.MkdirAll(filepath.Join(home, "headdir", "HEAD"), 0o755))
		// HEAD alone, objects missing, and refs a file.
		writeFile(t, filepath.Join(home, "headonly", "HEAD"), "ref: refs/heads/main\n")
		initRepo(t, filepath.Join(home, "noobjects"), "")
		require.NoError(t, os.Remove(filepath.Join(home, "noobjects", "objects")))
		initRepo(t, filepath.Join(home, "reffile"), "")
		require.NoError(t, os.Remove(filepath.Join(home, "reffile", "refs")))
		writeFile(t, filepath.Join(home, "reffile", "refs"), "")
		// A linked worktree whose common directory has no objects.
		initRepo(t, filepath.Join(home, "main", ".git"), "")
		addWorktree(t, filepath.Join(home, "main", ".git"), "lw", "main")
		require.NoError(t, os.Remove(filepath.Join(home, "main", ".git", "objects")))
		writeFile(t, filepath.Join(home, "lw", ".git"), "gitdir: ../main/.git/worktrees/lw\n")
		// A linked worktree whose git directory has no commondir.
		initRepo(t, filepath.Join(home, "main2", ".git"), "")
		addWorktree(t, filepath.Join(home, "main2", ".git"), "nocd", "main")
		require.NoError(t, os.Remove(filepath.Join(home, "main2", ".git", "worktrees", "nocd", "commondir")))
		writeFile(t, filepath.Join(home, "nocd", ".git"), "gitdir: ../main2/.git/worktrees/nocd\n")
		// A gitdir file naming a directory that is not a repository.
		writeFile(t, filepath.Join(home, "wt", ".git"), "gitdir: ../plain\n")
		// A regular file in the way.
		writeFile(t, filepath.Join(home, "file"), "")

		for _, tc := range []struct{ dir, gitDir string }{
			{"missing", "missing"},
			{"plain", "plain"},
			{"dotdir", "dotdir"},
			{"nohead", filepath.Join("nohead", ".git")},
			{filepath.Join("nohead", ".git"), filepath.Join("nohead", ".git")},
			{"headdir", "headdir"},
			{"headonly", "headonly"},
			{"noobjects", "noobjects"},
			{"reffile", "reffile"},
			{"lw", filepath.Join("main", ".git", "worktrees", "lw")},
			{"nocd", filepath.Join("main2", ".git", "worktrees", "nocd")},
			{"wt", "plain"},
			{filepath.Join("file", "sub"), filepath.Join("file", "sub")},
		} {
			_, err := gitconfig.Discover(filepath.Join(home, tc.dir))
			require.ErrorIs(t, err, gitconfig.ErrNotRepository, tc.dir)
			fe, ok := errors.AsType[*gitconfig.FileError](err)
			require.True(t, ok, tc.dir)
			assert.Equal(t, filepath.Join(home, tc.gitDir), filepath.Clean(fe.Path), tc.dir)
		}
	})

	t.Run("malformed gitdir file", func(t *testing.T) {
		home := cleanGitEnv(t)
		writeFile(t, filepath.Join(home, "wt", ".git"), "garbage\n")
		_, err := gitconfig.Discover(filepath.Join(home, "wt", ".git"))
		require.Error(t, err)
	})

	t.Run("loads like git", func(t *testing.T) {
		home := cleanGitEnv(t)
		t.Setenv("GIT_CONFIG_NOSYSTEM", "1")
		writeFile(t, filepath.Join(home, ".gitconfig"), "[user]\n\tname = global\n")
		gitDir := filepath.Join(home, "repo", ".git")
		initRepo(t, gitDir, "[user]\n\temail = local\n")
		t.Setenv("GIT_CONFIG_PARAMETERS", "'core.editor'='vi'")

		env, err := gitconfig.Discover(gitDir)
		require.NoError(t, err)
		c, err := env.Load()
		require.NoError(t, err)
		assert.Equal(t, []string{"user.name=global", "user.email=local", "core.editor=vi"}, list(slices.Collect(c.All())))
	})
}

func TestEnvUpdateFile(t *testing.T) {
	var env gitconfig.Env // UpdateFile uses nothing from the Env

	t.Run("edit", func(t *testing.T) {
		path := filepath.Join(tempDir(t), "config")
		writeFile(t, path, "# keep\n[a]\n\tk = v\n")
		before := statNow(t, path)

		err := env.UpdateFile(path, func(f *gitconfig.File) error {
			e, ok := f.Config().Get("a.k")
			require.True(t, ok)
			assert.Equal(t, gitconfig.Origin{Scope: gitconfig.ScopeFile, File: path, Line: 3}, e.Origin)
			return f.Set("a.j", "w")
		})
		require.NoError(t, err)
		assert.Equal(t, "# keep\n[a]\n\tk = v\n\tj = w\n", readFile(t, path))
		assert.NoFileExists(t, path+".lock")

		after, err := os.Stat(path)
		require.NoError(t, err)
		assert.False(t, os.SameFile(before, after), "the file is replaced through a rename")
	})

	t.Run("missing file created", func(t *testing.T) {
		path := filepath.Join(tempDir(t), "config")
		err := env.UpdateFile(path, func(f *gitconfig.File) error {
			assert.Empty(t, f.Bytes())
			return f.Set("a.k", "v")
		})
		require.NoError(t, err)
		assert.Equal(t, "[a]\n\tk = v\n", readFile(t, path))
	})

	t.Run("unchanged content not written", func(t *testing.T) {
		path := filepath.Join(tempDir(t), "config")
		writeFile(t, path, "[a]\n    k=v\n")
		before := statNow(t, path)

		err := env.UpdateFile(path, func(f *gitconfig.File) error {
			return f.Set("a.k", "v")
		})
		require.NoError(t, err)
		after, err := os.Stat(path)
		require.NoError(t, err)
		assert.True(t, os.SameFile(before, after))
		assert.Equal(t, before.ModTime(), after.ModTime())
		assert.NoFileExists(t, path+".lock")
	})

	t.Run("edits undone are not written", func(t *testing.T) {
		path := filepath.Join(tempDir(t), "config")
		writeFile(t, path, "[a]\n\tk = v\n")
		before := statNow(t, path)

		err := env.UpdateFile(path, func(f *gitconfig.File) error {
			if err := f.Set("a.j", "w"); err != nil {
				return err
			}
			_, err := f.Unset("a.j")
			return err
		})
		require.NoError(t, err)
		after, err := os.Stat(path)
		require.NoError(t, err)
		assert.True(t, os.SameFile(before, after))
	})

	t.Run("missing file not created without edit", func(t *testing.T) {
		path := filepath.Join(tempDir(t), "config")
		require.NoError(t, env.UpdateFile(path, func(f *gitconfig.File) error { return nil }))
		assert.NoFileExists(t, path)
		assert.NoFileExists(t, path+".lock")
	})

	t.Run("callback error returned as is", func(t *testing.T) {
		path := filepath.Join(tempDir(t), "config")
		writeFile(t, path, "[a]\n\tk = v\n")
		sentinel := errors.New("sentinel")

		err := env.UpdateFile(path, func(f *gitconfig.File) error {
			require.NoError(t, f.Set("a.k", "w"))
			return sentinel
		})
		assert.True(t, err == sentinel, "got %v", err)
		assert.Equal(t, "[a]\n\tk = v\n", readFile(t, path))
		assert.NoFileExists(t, path+".lock")
	})

	t.Run("callback panic", func(t *testing.T) {
		path := filepath.Join(tempDir(t), "config")
		writeFile(t, path, "[a]\n\tk = v\n")

		assert.PanicsWithValue(t, "boom", func() {
			_ = env.UpdateFile(path, func(f *gitconfig.File) error {
				require.NoError(t, f.Set("a.k", "w"))
				panic("boom")
			})
		})
		assert.Equal(t, "[a]\n\tk = v\n", readFile(t, path))
		assert.NoFileExists(t, path+".lock")
	})

	t.Run("locked", func(t *testing.T) {
		path := filepath.Join(tempDir(t), "config")
		writeFile(t, path, "[a]\n\tk = v\n")
		writeFile(t, path+".lock", "someone else")

		called := false
		err := env.UpdateFile(path, func(f *gitconfig.File) error {
			called = true
			return nil
		})
		require.ErrorIs(t, err, gitconfig.ErrLocked)
		var fe *gitconfig.FileError
		require.ErrorAs(t, err, &fe)
		assert.Equal(t, path+".lock", fe.Path)
		assert.False(t, called)
		assert.Equal(t, "someone else", readFile(t, path+".lock"), "a held lock is never removed")
		assert.Equal(t, "[a]\n\tk = v\n", readFile(t, path))
	})

	t.Run("syntax error", func(t *testing.T) {
		path := filepath.Join(tempDir(t), "config")
		writeFile(t, path, "[broken\n")

		called := false
		err := env.UpdateFile(path, func(f *gitconfig.File) error {
			called = true
			return nil
		})
		var se *gitconfig.SyntaxError
		require.ErrorAs(t, err, &se)
		var fe *gitconfig.FileError
		require.ErrorAs(t, err, &fe)
		assert.Equal(t, path, fe.Path)
		assert.False(t, called)
		assert.NoFileExists(t, path+".lock")
	})

	t.Run("not a regular file", func(t *testing.T) {
		path := tempDir(t)
		err := env.UpdateFile(path, func(f *gitconfig.File) error { return nil })
		require.ErrorIs(t, err, gitconfig.ErrNotRegular)
		assert.NoFileExists(t, path+".lock")
	})

	t.Run("closed after the callback", func(t *testing.T) {
		path := filepath.Join(tempDir(t), "config")
		var kept *gitconfig.File
		err := env.UpdateFile(path, func(f *gitconfig.File) error {
			kept = f
			return f.Set("a.k", "v")
		})
		require.NoError(t, err)

		require.ErrorIs(t, kept.Set("a.k", "w"), gitconfig.ErrClosed)
		require.ErrorIs(t, kept.Add("a.k", "w"), gitconfig.ErrClosed)
		require.ErrorIs(t, kept.ReplaceAll("a.k", "w"), gitconfig.ErrClosed)
		_, err = kept.Unset("a.k")
		require.ErrorIs(t, err, gitconfig.ErrClosed)
		_, err = kept.UnsetAll("a.k")
		require.ErrorIs(t, err, gitconfig.ErrClosed)
		_, err = kept.RemoveSection("a")
		require.ErrorIs(t, err, gitconfig.ErrClosed)
		_, err = kept.RemoveSubsection("a", "b")
		require.ErrorIs(t, err, gitconfig.ErrClosed)
		require.ErrorIs(t, kept.RenameSection("a", "b"), gitconfig.ErrClosed)
		require.ErrorIs(t, kept.RenameSubsection("a", "b", "c"), gitconfig.ErrClosed)

		assert.Equal(t, "[a]\n\tk = v\n", string(kept.Bytes()))
		assert.Equal(t, "v", kept.Config().Value("a.k", ""))
		assert.Equal(t, "[a]\n\tk = v\n", readFile(t, path))
	})

	t.Run("closed after an error too", func(t *testing.T) {
		path := filepath.Join(tempDir(t), "config")
		var kept *gitconfig.File
		_ = env.UpdateFile(path, func(f *gitconfig.File) error {
			kept = f
			return errors.New("fail")
		})
		require.ErrorIs(t, kept.Set("a.k", "w"), gitconfig.ErrClosed)
	})

	t.Run("includes not followed", func(t *testing.T) {
		dir := tempDir(t)
		path := filepath.Join(dir, "config")
		writeFile(t, path, "[include]\n\tpath = inc\n")
		writeFile(t, filepath.Join(dir, "inc"), "[a]\n\tk = v\n")
		err := env.UpdateFile(path, func(f *gitconfig.File) error {
			_, ok := f.Config().Get("a.k")
			assert.False(t, ok)
			return nil
		})
		require.NoError(t, err)
	})

	t.Run("concurrent updates lose nothing", func(t *testing.T) {
		path := filepath.Join(tempDir(t), "config")
		const writers, adds = 8, 10

		var wg sync.WaitGroup
		for w := range writers {
			wg.Go(func() {
				for i := range adds {
					for {
						err := env.UpdateFile(path, func(f *gitconfig.File) error {
							return f.Add("a.k", fmt.Sprintf("%d-%d", w, i))
						})
						if errors.Is(err, gitconfig.ErrLocked) {
							continue
						}
						assert.NoError(t, err)
						break
					}
				}
			})
		}
		wg.Wait()

		c := mustConfig(t, readFile(t, path))
		got := values(c.GetAll("a.k"))
		assert.Len(t, got, writers*adds)
		for w := range writers {
			for i := range adds {
				assert.Contains(t, got, fmt.Sprintf("%d-%d", w, i))
			}
		}
		assert.NoFileExists(t, path+".lock")
	})
}

// statNow returns the FileInfo of path with the file's identity read now.
// On Windows, os.Stat leaves it to be read by os.SameFile, through the path,
// which by then may name another file.
func statNow(t *testing.T, path string) os.FileInfo {
	t.Helper()
	fi, err := os.Stat(path)
	require.NoError(t, err)
	os.SameFile(fi, fi)
	return fi
}

// symlink creates a symbolic link, or skips the test where the platform or
// the user cannot (Windows without the privilege).
func symlink(t *testing.T, target, link string) {
	t.Helper()
	if err := os.Symlink(target, link); err != nil {
		t.Skip("symbolic links not supported:", err)
	}
}

func TestEnvUpdateFileSymlinks(t *testing.T) {
	set := func(f *gitconfig.File) error { return f.Set("a.k", "w") }

	assertLink := func(t *testing.T, link, target string) {
		t.Helper()
		got, err := os.Readlink(link)
		require.NoError(t, err)
		// os.Symlink writes the target with the platform's separators.
		assert.Equal(t, filepath.FromSlash(target), got)
	}

	t.Run("link followed and kept", func(t *testing.T) {
		dir := tempDir(t)
		target := filepath.Join(dir, "real")
		link := filepath.Join(dir, "link")
		writeFile(t, target, "[a]\n\tk = v\n")
		symlink(t, "real", link)

		require.NoError(t, gitconfig.Env{}.UpdateFile(link, set))
		assert.Equal(t, "[a]\n\tk = w\n", readFile(t, target))
		assertLink(t, link, "real")
		assert.NoFileExists(t, target+".lock")
		assert.NoFileExists(t, link+".lock")
	})

	t.Run("chain with relative targets", func(t *testing.T) {
		dir := tempDir(t)
		target := filepath.Join(dir, "real")
		writeFile(t, target, "[a]\n\tk = v\n")
		require.NoError(t, os.Mkdir(filepath.Join(dir, "d"), 0o755))
		symlink(t, "../real", filepath.Join(dir, "d", "l2"))
		symlink(t, "d/l2", filepath.Join(dir, "l1"))

		require.NoError(t, gitconfig.Env{}.UpdateFile(filepath.Join(dir, "l1"), set))
		assert.Equal(t, "[a]\n\tk = w\n", readFile(t, target))
		assertLink(t, filepath.Join(dir, "l1"), "d/l2")
		assertLink(t, filepath.Join(dir, "d", "l2"), "../real")
	})

	t.Run("relative target through a directory link", func(t *testing.T) {
		if runtime.GOOS == "windows" {
			t.Skip("Windows removes \"..\" from a path before following links")
		}
		// cfg/link -> d/../real, with cfg/d -> ../store/sub: the ".." is
		// that of store/sub, so the file is store/real, not cfg/real.
		dir := tempDir(t)
		target := filepath.Join(dir, "store", "real")
		decoy := filepath.Join(dir, "cfg", "real")
		writeFile(t, target, "[a]\n\tk = v\n")
		writeFile(t, decoy, "[a]\n\tk = v\n")
		require.NoError(t, os.Mkdir(filepath.Join(dir, "store", "sub"), 0o755))
		symlink(t, "../store/sub", filepath.Join(dir, "cfg", "d"))
		symlink(t, "d/../real", filepath.Join(dir, "cfg", "link"))

		require.NoError(t, gitconfig.Env{}.UpdateFile(filepath.Join(dir, "cfg", "link"), set))
		assert.Equal(t, "[a]\n\tk = w\n", readFile(t, target))
		assert.Equal(t, "[a]\n\tk = v\n", readFile(t, decoy))
	})

	t.Run("dangling link creates the target", func(t *testing.T) {
		dir := tempDir(t)
		link := filepath.Join(dir, "link")
		symlink(t, "new", link)

		require.NoError(t, gitconfig.Env{}.UpdateFile(link, set))
		assert.Equal(t, "[a]\n\tk = w\n", readFile(t, filepath.Join(dir, "new")))
		assertLink(t, link, "new")
	})

	t.Run("loop", func(t *testing.T) {
		dir := tempDir(t)
		symlink(t, "l2", filepath.Join(dir, "l1"))
		symlink(t, "l1", filepath.Join(dir, "l2"))

		called := false
		err := gitconfig.Env{}.UpdateFile(filepath.Join(dir, "l1"), func(f *gitconfig.File) error {
			called = true
			return nil
		})
		require.Error(t, err)
		assert.False(t, called)
	})

	t.Run("lock file is a symbolic link", func(t *testing.T) {
		for _, existing := range []bool{false, true} {
			t.Run(map[bool]string{false: "to nothing", true: "to a file"}[existing], func(t *testing.T) {
				dir := tempDir(t)
				path := filepath.Join(dir, "config")
				victim := filepath.Join(dir, "victim")
				writeFile(t, path, "[a]\n\tk = v\n")
				if existing {
					writeFile(t, victim, "precious")
				}
				symlink(t, victim, path+".lock")

				err := gitconfig.Env{}.UpdateFile(path, set)
				require.ErrorIs(t, err, gitconfig.ErrLocked)
				if existing {
					assert.Equal(t, "precious", readFile(t, victim))
				} else {
					assert.NoFileExists(t, victim)
				}
				assert.Equal(t, "[a]\n\tk = v\n", readFile(t, path))
			})
		}
	})
}

func TestEnvUpdateScope(t *testing.T) {
	t.Run("writes to the scope's file, not into includes", func(t *testing.T) {
		env := fullEnv(t)
		home := env.GlobalConfig[1]
		inc := filepath.Join(filepath.Dir(home), "inc")
		writeFile(t, home, "[include]\n\tpath = inc\n")
		writeFile(t, inc, "[user]\n\tname = inc\n")

		err := env.UpdateScope(gitconfig.ScopeGlobal, func(f *gitconfig.File) error {
			return f.Set("user.name", "x")
		})
		require.NoError(t, err)
		assert.Equal(t, "[include]\n\tpath = inc\n[user]\n\tname = x\n", readFile(t, home))
		assert.Equal(t, "[user]\n\tname = inc\n", readFile(t, inc))
		assert.Equal(t, "[a]\n\tk = xdg\n\txdgonly = x\n", readFile(t, env.GlobalConfig[0]))
	})

	t.Run("entries have the scope", func(t *testing.T) {
		env := fullEnv(t)
		for _, tc := range []struct {
			scope gitconfig.Scope
			want  string
		}{
			{gitconfig.ScopeSystem, "system"},
			{gitconfig.ScopeGlobal, "home"},
			{gitconfig.ScopeLocal, "local"},
			{gitconfig.ScopeWorktree, "worktree"},
		} {
			t.Run(tc.scope.String(), func(t *testing.T) {
				err := env.UpdateScope(tc.scope, func(f *gitconfig.File) error {
					e, ok := f.Config().Get("a.k")
					require.True(t, ok)
					assert.Equal(t, tc.want, e.Value)
					assert.Equal(t, tc.scope, e.Origin.Scope)
					return nil
				})
				require.NoError(t, err)
			})
		}
	})

	t.Run("worktree without the extension", func(t *testing.T) {
		env := fullEnv(t)
		local := filepath.Join(env.GitDir, "config")
		writeFile(t, local, "[a]\n\tk = local\n")

		err := env.UpdateScope(gitconfig.ScopeWorktree, func(f *gitconfig.File) error {
			e, _ := f.Config().Get("a.k")
			assert.Equal(t, gitconfig.ScopeLocal, e.Origin.Scope)
			return f.Set("a.j", "w")
		})
		require.NoError(t, err)
		assert.Equal(t, "[a]\n\tk = local\n\tj = w\n", readFile(t, local))
	})

	t.Run("global file created", func(t *testing.T) {
		dir := tempDir(t)
		env := gitconfig.Env{GlobalConfig: []string{filepath.Join(dir, "xdg", "git", "config"), filepath.Join(dir, ".gitconfig")}}
		err := env.UpdateScope(gitconfig.ScopeGlobal, func(f *gitconfig.File) error {
			return f.Set("user.name", "x")
		})
		require.NoError(t, err)
		assert.Equal(t, "[user]\n\tname = x\n", readFile(t, filepath.Join(dir, ".gitconfig")))
		assert.NoFileExists(t, env.GlobalConfig[0])
	})

	t.Run("unavailable scopes", func(t *testing.T) {
		env := fullEnv(t)
		for _, s := range []gitconfig.Scope{gitconfig.ScopeFile, gitconfig.ScopeCommand} {
			called := false
			err := env.UpdateScope(s, func(f *gitconfig.File) error {
				called = true
				return nil
			})
			assert.Equal(t, gitconfig.ErrNoScope, err)
			assert.False(t, called)
		}
	})
}

// withTimeout fails the test if fn does not return within a few seconds:
// git hangs reading a FIFO, this library must not.
func withTimeout(t *testing.T, fn func() error) error {
	t.Helper()
	done := make(chan error, 1)
	go func() { done <- fn() }()
	select {
	case err := <-done:
		return err
	case <-time.After(5 * time.Second):
		t.Fatal("blocked on a FIFO")
		return nil
	}
}

// TestEnvUnreadable checks that a global file that cannot be
// read for lack of permission is skipped, any other one is an error.
func TestEnvUnreadable(t *testing.T) {
	if runtime.GOOS == "windows" {
		t.Skip("chmod 000 does not make a file unreadable on Windows")
	}
	if os.Geteuid() == 0 {
		t.Skip("root reads any file")
	}
	dir := tempDir(t)
	unreadable := filepath.Join(dir, "unreadable")
	writeFile(t, unreadable, "[a]\n\tk = v\n")
	require.NoError(t, os.Chmod(unreadable, 0))
	readable := filepath.Join(dir, "readable")
	writeFile(t, readable, "[a]\n\tj = w\n")

	t.Run("global file skipped", func(t *testing.T) {
		env := gitconfig.Env{GlobalConfig: []string{unreadable, readable}}
		c, err := env.Load()
		require.NoError(t, err)
		assert.Equal(t, []string{"a.j=w"}, list(slices.Collect(c.All())))

		c, err = env.LoadProtected()
		require.NoError(t, err)
		assert.Equal(t, []string{"a.j=w"}, list(slices.Collect(c.All())))

		// As `git config --global --get`, which reads it as empty.
		c, err = env.LoadScope(gitconfig.ScopeGlobal)
		require.NoError(t, err)
		assert.Equal(t, []string{"a.j=w"}, list(slices.Collect(c.All())))
	})

	t.Run("system file skipped by LoadProtected only", func(t *testing.T) {
		env := gitconfig.Env{SystemConfig: unreadable}
		_, err := env.Load()
		require.ErrorIs(t, err, fs.ErrPermission)

		c, err := env.LoadProtected()
		require.NoError(t, err)
		assert.Empty(t, slices.Collect(c.All()))
	})

	t.Run("include is an error", func(t *testing.T) {
		global := filepath.Join(dir, "global")
		writeFile(t, global, "[include]\n\tpath = unreadable\n")
		_, err := gitconfig.Env{GlobalConfig: []string{global}}.Load()
		require.ErrorIs(t, err, fs.ErrPermission)
	})

	t.Run("file is an error", func(t *testing.T) {
		_, err := gitconfig.Env{}.LoadFile(unreadable)
		require.ErrorIs(t, err, fs.ErrPermission)
	})
}

func TestEnvFIFO(t *testing.T) {
	// Windows has no FIFO to open by name. The mkfifo of MSYS2, which Git
	// for Windows puts on PATH, makes a file only MSYS programs take for a
	// FIFO: Go reads it as a regular file.
	if runtime.GOOS == "windows" {
		t.Skip("no FIFO to open by name on Windows")
	}
	if _, err := exec.LookPath("mkfifo"); err != nil {
		t.Skip("no mkfifo: no FIFO to open by name")
	}
	dir := tempDir(t)
	fifo := filepath.Join(dir, "fifo")
	require.NoError(t, exec.Command("mkfifo", fifo).Run())

	t.Run("include", func(t *testing.T) {
		main := filepath.Join(dir, "main")
		writeFile(t, main, "[include]\n\tpath = fifo\n")
		err := withTimeout(t, func() error {
			_, err := gitconfig.Env{GlobalConfig: []string{main}}.Load()
			return err
		})
		require.ErrorIs(t, err, gitconfig.ErrNotRegular)
	})

	t.Run("configuration file", func(t *testing.T) {
		err := withTimeout(t, func() error {
			_, err := gitconfig.Env{GlobalConfig: []string{fifo}}.Load()
			return err
		})
		require.ErrorIs(t, err, gitconfig.ErrNotRegular)
	})

	t.Run("update", func(t *testing.T) {
		err := withTimeout(t, func() error {
			return gitconfig.Env{}.UpdateFile(fifo, func(f *gitconfig.File) error { return nil })
		})
		require.ErrorIs(t, err, gitconfig.ErrNotRegular)
		assert.NoFileExists(t, fifo+".lock")
	})
}

// TestEnvUpdateFilePermissions checks that the permissions of the file are
// kept exactly, whatever the umask: with any umask, the lock file is created
// with fewer bits than 0666.
func TestEnvUpdateFilePermissions(t *testing.T) {
	if runtime.GOOS == "windows" {
		t.Skip("no Unix permissions on Windows")
	}
	for _, mode := range []os.FileMode{0o600, 0o640, 0o664, 0o666, 0o755} {
		t.Run(mode.String(), func(t *testing.T) {
			path := filepath.Join(tempDir(t), "config")
			writeFile(t, path, "[a]\n\tk = v\n")
			require.NoError(t, os.Chmod(path, mode))

			err := gitconfig.Env{}.UpdateFile(path, func(f *gitconfig.File) error {
				return f.Set("a.k", "w")
			})
			require.NoError(t, err)
			fi, err := os.Stat(path)
			require.NoError(t, err)
			assert.Equal(t, mode, fi.Mode().Perm())
		})
	}

	t.Run("lock private until written", func(t *testing.T) {
		path := filepath.Join(tempDir(t), "config")
		writeFile(t, path, "[a]\n\tk = v\n")
		require.NoError(t, os.Chmod(path, 0o644))

		err := gitconfig.Env{}.UpdateFile(path, func(f *gitconfig.File) error {
			fi, err := os.Stat(path + ".lock")
			require.NoError(t, err)
			assert.Equal(t, os.FileMode(0o600), fi.Mode().Perm())
			return f.Set("a.k", "w")
		})
		require.NoError(t, err)
		fi, err := os.Stat(path)
		require.NoError(t, err)
		assert.Equal(t, os.FileMode(0o644), fi.Mode().Perm())
	})

	t.Run("new file", func(t *testing.T) {
		// As any new file: 0666 minus the umask.
		dir := tempDir(t)
		ref, err := os.OpenFile(filepath.Join(dir, "ref"), os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0o666)
		require.NoError(t, err)
		require.NoError(t, ref.Close())
		want, err := os.Stat(filepath.Join(dir, "ref"))
		require.NoError(t, err)

		path := filepath.Join(dir, "config")
		err = gitconfig.Env{}.UpdateFile(path, func(f *gitconfig.File) error {
			return f.Set("a.k", "v")
		})
		require.NoError(t, err)
		fi, err := os.Stat(path)
		require.NoError(t, err)
		assert.Equal(t, want.Mode().Perm(), fi.Mode().Perm())
	})
}

// TestEnvUpdateFileHeld checks that UpdateFile waits for a file another
// process holds for a moment, and gives up if it holds it for long. On
// Windows, a file open without FILE_SHARE_DELETE, as os.Open opens it,
// cannot be replaced. A file opened without sharing at all cannot be read
// either; that error is checked by TestRetryTransient.
func TestEnvUpdateFileHeld(t *testing.T) {
	if runtime.GOOS != "windows" {
		t.Skip("only Windows refuses to replace an open file")
	}
	set := func(f *gitconfig.File) error { return f.Set("a.k", "w") }
	hold := func(t *testing.T, path string) *os.File {
		f, err := os.Open(path)
		require.NoError(t, err)
		t.Cleanup(func() { f.Close() })
		return f
	}

	t.Run("released", func(t *testing.T) {
		path := filepath.Join(tempDir(t), "config")
		writeFile(t, path, "[a]\n\tk = v\n")
		f := hold(t, path)
		time.AfterFunc(200*time.Millisecond, func() { f.Close() })

		require.NoError(t, gitconfig.Env{}.UpdateFile(path, set))
		assert.Equal(t, "[a]\n\tk = w\n", readFile(t, path))
		assert.NoFileExists(t, path+".lock")
	})

	t.Run("kept", func(t *testing.T) {
		path := filepath.Join(tempDir(t), "config")
		writeFile(t, path, "[a]\n\tk = v\n")
		hold(t, path)

		start := time.Now()
		err := gitconfig.Env{}.UpdateFile(path, set)
		var fe *gitconfig.FileError
		require.ErrorAs(t, err, &fe)
		assert.NotErrorIs(t, err, gitconfig.ErrLocked)
		assert.GreaterOrEqual(t, time.Since(start), time.Second, "given up without retrying")
		assert.Equal(t, "[a]\n\tk = v\n", readFile(t, path))
		assert.NoFileExists(t, path+".lock")
	})
}

// benchEnv is a realistic Env: a system file, global files with an include
// and an includeIf, a local config with many remotes and command entries.
func benchEnv(b *testing.B) gitconfig.Env {
	dir := tempDir(b)
	home := filepath.Join(dir, "home")
	gitDir := filepath.Join(dir, "work", "proj", ".git")
	writeFile(b, filepath.Join(dir, "etc", "gitconfig"), "[core]\n\tautocrlf = input\n")
	writeFile(b, filepath.Join(home, ".gitconfig"), fmt.Sprintf(
		"[user]\n\tname = Someone\n[include]\n\tpath = ~/.gitconfig.d/aliases\n[includeIf \"gitdir:%s/work/\"]\n\tpath = ~/.gitconfig.d/work\n",
		filepath.ToSlash(dir)))
	writeFile(b, filepath.Join(home, ".gitconfig.d", "aliases"), strings.Repeat("[alias]\n\tco = checkout\n\tst = status\n", 20))
	writeFile(b, filepath.Join(home, ".gitconfig.d", "work"), "[user]\n\temail = someone@work\n")
	initRepo(b, gitDir, bigConfig(50))
	return gitconfig.Env{
		Home:         home,
		GitDir:       gitDir,
		SystemConfig: filepath.Join(dir, "etc", "gitconfig"),
		GlobalConfig: []string{filepath.Join(home, ".config", "git", "config"), filepath.Join(home, ".gitconfig")},
		Command:      []gitconfig.CommandEntry{{Key: "core.pager", Value: "less"}},
	}
}

func BenchmarkEnv(b *testing.B) {
	env := benchEnv(b)

	b.Run("Load", func(b *testing.B) {
		b.ReportAllocs()
		for b.Loop() {
			_, _ = env.Load()
		}
	})
	b.Run("LoadProtected", func(b *testing.B) {
		b.ReportAllocs()
		for b.Loop() {
			_, _ = env.LoadProtected()
		}
	})
	b.Run("LoadFileManyGitdirConditions", func(b *testing.B) {
		// The git directory's real path is resolved once per load, not
		// once per condition.
		path := filepath.Join(tempDir(b), "config")
		writeFile(b, path, strings.Repeat("[includeIf \"gitdir:/nope/\"]\n\tpath = x\n", 1000))
		b.ReportAllocs()
		for b.Loop() {
			_, _ = env.LoadFile(path)
		}
	})
	b.Run("UpdateFile", func(b *testing.B) {
		path := filepath.Join(env.GitDir, "config")
		i := 0
		for b.Loop() {
			i++
			_ = env.UpdateFile(path, func(f *gitconfig.File) error {
				return f.Set("core.editor", strconv.Itoa(i))
			})
		}
	})
	b.Run("UpdateFileUnchanged", func(b *testing.B) {
		path := filepath.Join(env.GitDir, "config")
		for b.Loop() {
			_ = env.UpdateFile(path, func(f *gitconfig.File) error {
				return f.Set("user.name", "Someone")
			})
		}
	})
}