test(segment): build bare layout fixtures from TestRootPath

TestEnabledInBareLayout and TestIsBareRepoResolvesPointer hardcoded
"/repo" instead of following the platform-aware TestRootPath convention
every other test in the file uses, which failed the windows-latest run.

filepath.IsAbs is the real one, not the mocked GOOS, so on a Windows
runner "/repo/.bare" has no volume name and IsAbs returns false. Checked
against go1.26.5 internal/filepathlite: volumeNameLen("/repo/.bare") is 0,
while "C:/repo/.bare" gives 2 and the remainder starts with a separator,
so both asserted fields are absolute on either platform now.

TestIsBareRepoResolvesPointer did not fail, but only by accident:
"/repo/.bare" took the Windows disk-relative branch of resolveGitPath and
landed on the same string, so its "absolute pointer" case never exercised
the absolute branch it names. Its expected config path and the path the
old filepath.Join produced are now derived from the pointer instead of
written out, so they cannot drift apart per platform.

Field order in the case struct follows fieldalignment, which CI runs
separately from golangci-lint. Its -fix pass drops comments, so the field
documentation is restored by hand.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: e-kulikov

src/segments/git_test.go

@@ -109,12 +109,15 @@ func TestResolveEmptyGitPath(t *testing.T) {
 }
 
 func TestEnabledInWorktree(t *testing.T) {
+	// Field order below is what fieldalignment wants, so the groups a reader would expect
+	// together are not adjacent. The comments travel with the fields instead.
 	cases := []struct {
-		Pointer    string
-		RawGitFile string
-		// For a worktree topology, the discovered parent is the worktree root and
-		// must match the metadata back-reference.
-		DiscoveredGitFile string
+		// nil reserves directory-role assertions for a later decision.
+		ExpectedWorkingFolder *string
+		ExpectedRootFolder    *string
+		ExpectedRealFolder    *string
+		// For a worktree topology, the discovered parent is the worktree root and must
+		// match the metadata back-reference. See DiscoveredGitFile below.
 		DiscoveredParent  string
 		MetadataAddon     string
 		MetadataContent   string
@@ -124,12 +127,16 @@ func TestEnabledInWorktree(t *testing.T) {
 		// from a --separate-git-dir target, which has no core.worktree at all.
 		TargetConfig string
 		Case         string
-		// nil reserves directory-role assertions for a later decision.
-		ExpectedWorkingFolder *string
-		ExpectedRealFolder    *string
-		ExpectedRootFolder    *string
-		ExpectedIsWorkTree    bool
-		ExpectedEnabled       bool
+		Pointer      string
+		// DiscoveredGitFile is the .git file HasParentFilePath found, whose parent is
+		// DiscoveredParent above.
+		DiscoveredGitFile string
+		// RawGitFile overrides the whole .git file body. Use it when the test is about
+		// the file's syntax rather than the pointer it carries; leave it empty and the
+		// loop writes "gitdir: <Pointer>".
+		RawGitFile         string
+		ExpectedIsWorkTree bool
+		ExpectedEnabled    bool
 	}{
 		{
 			Case:                  "worktree",
@@ -489,9 +496,14 @@ func TestEnabledInBareLayout(t *testing.T) {
 	}
 
 	for _, tc := range cases {
+		// Fixtures are built from TestRootPath so the paths are absolute on the platform
+		// the test binary runs on. filepath.IsAbs below is the real one, not the mocked
+		// GOOS, so a literal "/repo" would not be absolute on Windows.
+		root := TestRootPath + "repo"
+
 		fileInfo := &runtime.FileInfo{
-			Path:         "/repo/.git",
-			ParentFolder: "/repo",
+			Path:         root + "/.git",
+			ParentFolder: root,
 		}
 
 		env := new(mock.Environment)
@@ -504,13 +516,13 @@ func TestEnabledInBareLayout(t *testing.T) {
 		env.On("Home").Return(poshHome)
 		env.On("Getenv", poshGitEnv).Return("")
 		env.On("DirMatchesOneOf", testify_.Anything, testify_.Anything).Return(false)
-		env.On("FileContent", "/repo/.git").Return("gitdir: ./.bare")
-		env.On("HasFilesInDir", "/repo/.bare", "HEAD").Return(true)
-		env.On("FileContent", "/repo/.bare/config").Return("[core]\n\tbare = true")
-		env.On("FileContent", "/repo//HEAD").Return("")
-		env.MockGitCommand("/repo/", "1234567890abcdef1234567890abcdef12345678", "rev-parse", "HEAD")
-		env.MockGitCommand("/repo/", "", "describe", "--tags", "--exact-match")
-		env.MockGitCommand("/repo/", "", "remote")
+		env.On("FileContent", root+"/.git").Return("gitdir: ./.bare")
+		env.On("HasFilesInDir", root+"/.bare", "HEAD").Return(true)
+		env.On("FileContent", root+"/.bare/config").Return("[core]\n\tbare = true")
+		env.On("FileContent", root+"//HEAD").Return("")
+		env.MockGitCommand(root+"/", "1234567890abcdef1234567890abcdef12345678", "rev-parse", "HEAD")
+		env.MockGitCommand(root+"/", "", "describe", "--tags", "--exact-match")
+		env.MockGitCommand(root+"/", "", "remote")
 
 		props := options.Map{}
 		if tc.FetchBareInfo {
@@ -528,67 +540,72 @@ func TestEnabledInBareLayout(t *testing.T) {
 }
 
 func TestIsBareRepoResolvesPointer(t *testing.T) {
+	// Fixtures are built from TestRootPath so that "absolute pointer" really is absolute
+	// on the platform the test binary runs on. A literal "/repo/.bare" is only
+	// disk-relative on Windows, which would exercise a different resolveGitPath branch
+	// than the one these cases are about.
+	root := TestRootPath + "repo"
+
 	cases := []struct {
 		Case              string
 		Pointer           string
-		ExpectedConfig    string
 		ExpectedProbedDir string
 		ExpectedIsBare    bool
-		OldConfig         string
 	}{
 		{
 			Case:              "relative pointer",
 			Pointer:           "./.bare",
-			ExpectedConfig:    "/repo/.bare/config",
-			ExpectedProbedDir: "/repo/.bare",
+			ExpectedProbedDir: root + "/.bare",
 			ExpectedIsBare:    true,
 		},
 		{
 			Case:              "absolute pointer",
-			Pointer:           "/repo/.bare",
-			ExpectedConfig:    "/repo/.bare/config",
-			ExpectedProbedDir: "/repo/.bare",
+			Pointer:           root + "/.bare",
+			ExpectedProbedDir: root + "/.bare",
 			ExpectedIsBare:    true,
-			OldConfig:         "/repo/repo/.bare/config",
 		},
 		{
 			Case:              "absolute pointer to a non-bare git dir",
-			Pointer:           "/elsewhere/gitdir",
-			ExpectedConfig:    "/elsewhere/gitdir/config",
-			ExpectedProbedDir: "/elsewhere/gitdir",
+			Pointer:           TestRootPath + "elsewhere/gitdir",
+			ExpectedProbedDir: TestRootPath + "elsewhere/gitdir",
 			ExpectedIsBare:    false,
-			OldConfig:         "/repo/elsewhere/gitdir/config",
 		},
 	}
 
 	for _, tc := range cases {
 		fileInfo := &runtime.FileInfo{
-			Path:         "/repo/.git",
-			ParentFolder: "/repo",
+			Path:         root + "/.git",
+			ParentFolder: root,
 		}
 
+		expectedConfig := tc.ExpectedProbedDir + "/config"
+		// What the old filepath.Join produced: the same path for a relative pointer, and
+		// the pointer concatenated onto the parent for an absolute one. Derived rather
+		// than written out so it stays correct under Windows path semantics too.
+		oldConfig := filepath.Join(fileInfo.ParentFolder, tc.Pointer) + "/config"
+
 		env := new(mock.Environment)
 		env.On("InWSLSharedDrive").Return(false)
 		env.On("HasCommand", "git").Return(true)
 		env.On("GOOS").Return("")
 		env.On("HasParentFilePath", ".git", true).Return(fileInfo, nil)
-		env.On("FileContent", "/repo/.git").Return(fmt.Sprintf("gitdir: %s", tc.Pointer))
-		env.On("FileContent", tc.ExpectedConfig).Return(fmt.Sprintf("[core]\n\tbare = %t", tc.ExpectedIsBare))
+		env.On("FileContent", root+"/.git").Return(fmt.Sprintf("gitdir: %s", tc.Pointer))
+		env.On("FileContent", expectedConfig).Return(fmt.Sprintf("[core]\n\tbare = %t", tc.ExpectedIsBare))
 		env.On("HasFilesInDir", tc.ExpectedProbedDir, "HEAD").Return(true)
 
-		if tc.OldConfig != "" {
-			env.On("FileContent", tc.OldConfig).Return("")
+		if oldConfig != expectedConfig {
+			env.On("FileContent", oldConfig).Return("")
 		}
 
 		g := &Git{}
 		g.Init(options.Map{FetchBareInfo: true}, env)
 
 		assert.True(t, g.shouldDisplay(), tc.Case)
 		assert.Equal(t, tc.ExpectedIsBare, g.IsBare, tc.Case)
-		env.AssertCalled(t, "FileContent", tc.ExpectedConfig)
+		env.AssertCalled(t, "FileContent", expectedConfig)
 
-		if tc.OldConfig != "" {
-			env.AssertNotCalled(t, "FileContent", tc.OldConfig)
+		if oldConfig != expectedConfig {
+			env.AssertNotCalled(t, "FileContent", oldConfig)
 		}
 	}
 }