description: test
name: addon
version: 1.1.0
appVersion: 1.1.0
tillerVersion: ">=2.7.2"
keywords:
  - istio-addon

---
`,
			wantErr: nil,
		},
		{
			desc:        "bad-file-path",
			inValues:    "",
			inPath:      "foo/bar/Chart.yaml",
			startRender: true,
			objFileTemplateReader: Renderer{
				namespace:     "name-space",
				componentName: "foo-component",
				dir:           "foo/bar",

) error {
	for inPath, v := range mapping {
		scope.Debugf("Checking for k8s path %s in helm Value.yaml tree", inPath)
		path := util.PathFromString(inPath)
		k8sSettingName := ""
		if len(path) != 0 {
			k8sSettingName = path[len(path)-1]
		}
		if k8sSettingName == "autoscaleEnabled" {
			continue
		}
		m, found, err := tpath.Find(valueTree, util.ToYAMLPath(inPath))
		if err != nil {

	installPackagePathRegex := regexp.MustCompile("  installPackagePath: .*")
	for _, tt := range tests {
		t.Run(tt.desc, func(t *testing.T) {
			inPath := filepath.Join(testDataDir, "input", tt.desc+".yaml")
			outPath := filepath.Join(testDataDir, "output", tt.desc+".yaml")

			got, err := runProfileDump(inPath, tt.configPath, snapshotCharts, "")
			if err != nil {
				t.Fatal(err)
			}

		goarch: cdr.Goarch(),
	}
	mm.astate.Merge(state)
}

func copyMetaDataFile(inpath, outpath string) {
	inf, err := os.Open(inpath)
	if err != nil {
		fatal("opening input meta-data file %s: %v", inpath, err)
	}
	defer inf.Close()

	fi, err := inf.Stat()
	if err != nil {
		fatal("accessing input meta-data file %s: %v", inpath, err)
	}

	if err := yaml.Unmarshal([]byte(outTreeStr), &outTree); err != nil {
		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
		}
	}

	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			inPath := filepath.Join(testDataDir, "input", tt.name+".yaml")
			outPath := filepath.Join(testDataDir, "output", tt.name+".yaml")
			input, err := os.ReadFile(inPath)
			if err != nil {
				t.Fatalf(err.Error())
			}
			actualOutput, err := convertIOPMapValues(string(input), tt.inputFlags, tt.convertPaths)
			if err != nil {
				t.Fatalf(err.Error())

        public ExecutableFixture executable(Object path) {
            return new ExecutableFixture(new TestFile(OperatingSystem.current().getExecutableName(path.toString())), this);
        }

        public LinkerOptionsFixture linkerOptionsFor(Object path) {
            return new LinkerOptionsFixture(new TestFile(path.toString()));
        }

        public TestFile objectFile(Object path) {

	// does not use the established test group pattern
	inPath := filepath.Join(testDataDir, "input/all_on.yaml")
	got1, err := runManifestGenerate([]string{inPath}, "", snapshotCharts, nil)
	if err != nil {
		t.Fatal(err)
	}
	got2, err := runManifestGenerate([]string{inPath}, "", snapshotCharts, nil)
	if err != nil {
		t.Fatal(err)
	}

	if got1 != got2 {

                id "java-library"
                id "io.freefair.aspectj" version "${TestedVersions.aspectj}"
            }

            ${mavenCentralRepository()}

            dependencies {
                inpath "org.apache.httpcomponents:httpcore-nio:4.4.11"
                implementation "org.aspectj:aspectjrt:1.9.7"

                testImplementation "junit:junit:4.13"
            }
        """

func readFile(path string) (string, error) {
	b, err := os.ReadFile(path)
	return string(b), err
}

// writeFile writes a file and returns an error if operation is unsuccessful.
func writeFile(path string, data []byte) error {
	return os.WriteFile(path, data, 0o644)
}

// inFileAbsolutePath returns the absolute path for an input file like "gateways".