"encoding/json"
	"fmt"
	"internal/testenv"
	"os"
	"path/filepath"
	"strings"
	"testing"
)

func writeFile(t *testing.T, path string, contents []byte) {
	if err := os.WriteFile(path, contents, 0666); err != nil {
		t.Fatalf("os.WriteFile(%s) failed: %v", path, err)
	}
}

func writePkgConfig(t *testing.T, outdir, tag, ppath, pname string, gran string, mpath string) string {
	incfg := filepath.Join(outdir, tag+"incfg.txt")

stdout '^fortune.exe: .+'
go version -m fortune.exe
stdout -buildmode=exe
stdout '^\tpath\trsc.io/fortune'
stdout '^\tmod\trsc.io/fortune\tv1.0.0'

# Check the build info of a binary built from $GOROOT/src/cmd
go build -o test2json.exe cmd/test2json
go version -m test2json.exe
stdout -buildmode=exe
stdout '^test2json.exe: .+'
stdout '^\tpath\tcmd/test2json$'
! stdout 'mod[^e]'

		return "", err
	}

	for inPath, translation := range translations {
		path := util.PathFromString(inPath)
		node, found, err := tpath.Find(inTree, path)
		if err != nil {
			return "", err
		}
		if !found {
			continue
		}

		if err := tpath.MergeNode(outTree, util.PathFromString(translation), node); err != nil {
			return "", err
		}
	}

			return err
		}
	}
	return nil
}

// isEnablementPath is helper function to check whether paths represent enablement of components in values.yaml
func (t *ReverseTranslator) isEnablementPath(path util.Path) bool {
	if len(path) < 2 || path[len(path)-1] != "enabled" {
		return false
	}

	pf := path[:len(path)-1].String()
	if specialComponentPath[pf] {

// valuePath points to component path in the values tree.
func IsComponentEnabledFromValue(cn name.ComponentName, valueSpec map[string]any) (enabled bool, pathExist bool, err error) {
	t := NewTranslator()
	cnMap, ok := t.ComponentMaps[cn]
	if !ok {
		return false, false, nil
	}
	valuePath := cnMap.ToHelmValuesTreeRoot
	enabledPath := valuePath + ".enabled"
	enableNodeI, found, err := tpath.Find(valueSpec, util.ToYAMLPath(enabledPath))

	if err != nil {
		return err
	}
	y, err = tpath.GetConfigSubtree(y, "spec")
	if err != nil {
		return err
	}

	if pdArgs.configPath == "" {
		if y, err = prependHeader(y); err != nil {
			return err
		}
	} else {
		if y, err = tpath.GetConfigSubtree(y, pdArgs.configPath); err != nil {
			return err
		}
	}

	var output string

go list -f '{{.Module}}' a.go
stdout '^<nil>$'

[short] skip

# check that the version of command-line-arguments doesn't include a module
go build -o a.exe a.go
go version -m a.exe
stdout '^\tpath\tcommand-line-arguments$'
stdout '^\tdep\ta\t\(devel\)\t$'
! stdout mod[^e]

-- a/go.mod --
module a
go 1.17
-- a/a.go --
package main

import "a/dep"

func main() {
    dep.D()
}

[!buildmode:c-shared] stop

env GO111MODULE=on

go get rsc.io/fortune
go build -buildmode=c-shared -o external.so rsc.io/fortune
go version external.so
stdout '^external.so: .+'
go version -m external.so
stdout '^\tpath\trsc.io/fortune'
stdout '^\tmod\trsc.io/fortune\tv1.0.0'

-- go.mod --
module m

-- empty.go --
package main

// mustGetValueAtPath returns the value at the given path in the unstructured tree t. Fails if the path is not found
// in the tree.
func mustGetValueAtPath(g *WithT, t map[string]any, path string) any {
	got, f, err := tpath.GetPathContext(t, util.PathFromString(path), false)
	g.Expect(err).Should(BeNil(), "path %s should exist (%s)", path, err)
	g.Expect(f).Should(BeTrue(), "path %s should exist", path)
	return got.Node
}

	}
	for _, p := range patches {
		v := p.Value.AsInterface()
		if strings.TrimSpace(p.Path) == "" {
			scope.Warnf("value=%s has empty path, skip\n", v)
			continue
		}
		scope.Debugf("applying path=%s, value=%s\n", p.Path, v)
		inc, _, err := tpath.GetPathContext(bo, util.PathFromString(p.Path), true)
		if err != nil {
			errs = util.AppendErr(errs, err)
			metrics.ManifestPatchErrorTotal.Increment()