public Output(Node node) {
        this((String)node.attribute("path"));
    }

    public Output(String path) {
        Preconditions.checkNotNull(path);
        this.path = PathUtil.normalizePath(path);
    }

    public String getPath() {
        return path;
    }

    public void setPath(String path) {
        this.path = path;
    }

    @Override
    public String getKind() {

		} else if v := parent.String(key); v != "" {
			// otherwise parse via string (if-set)
			err = f.Value.Set(v)
		}
	})
}

func readConfig() (Map, error) {
	path, err := file.NormalizePath(configFilePath)
	if err != nil {
		return nil, fmt.Errorf("failed normalizing config file path %q: %v", configFilePath, err)
	}
	bytes, err := os.ReadFile(path)
	if err != nil {

			normalizedPath: "c:\\file",
		},
		{
			originalpath:   "fileonly",
			normalizedPath: "fileonly",
		},
	}

	for _, test := range tests {
		assert.Equal(t, test.normalizedPath, NormalizePath(test.originalpath))
	}
}

func TestLocalEndpoint(t *testing.T) {
	tests := []struct {
		path             string
		file             string
		expectError      bool
		expectedFullPath string
	}{
		{

        Preconditions.checkArgument(!isNullOrEmpty(location) || !isNullOrEmpty(locationUri));
        this.name = name;
        this.type = type;
        this.location = PathUtil.normalizePath(emptyToNull(location));
        this.locationUri = emptyToNull(locationUri);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;

		}
		if cc.Cluster.Name() != "" {
			_, _ = fmt.Fprintf(buf, "Cluster:  %s\n", cc.Cluster.Name())
		}
	}
	return buf.String()
}

func (c *configs) Set(path string) error {
	path, err := file.NormalizePath(path)
	if err != nil {
		return err
	}
	yml, err := os.ReadFile(path)
	if err != nil {
		return err
	}
	out, err := echo.ParseConfigs(yml)
	if err != nil {
		return err
	}
	*c = out

	cfg, err := validConfig(origCfg)
	if err != nil {
		return nil, err
	}

	kubeconfigPath := cfg.Meta.String(kubeconfigMetaKey)
	kubeconfigPath, err = file.NormalizePath(kubeconfigPath)
	if err != nil {
		return nil, err
	}

	var client istioKube.CLIClient
	if len(cfg.HTTPProxy) > 0 {
		proxyURL, err := url.Parse(cfg.HTTPProxy)
		if err != nil {
			return nil, err
		}

        Preconditions.checkNotNull(archiveName);
        Preconditions.checkNotNull(deployPath);
        this.archiveName = archiveName;
        this.deployPath = PathUtil.normalizePath(deployPath);
        this.handle = Preconditions.checkNotNull(handle);
    }

    /**
     * Get the archiveName property.
     *
     * @return the archiveName for this module.
     * @since 8.1
     */

	}

	if strings.HasPrefix(fi.Name(), ".") {
		klog.V(5).InfoS("Ignoring file (starts with '.')", "path", fi.Name())
		return nil
	}

	if !fi.IsDir() {
		isSocket, err := util.IsUnixDomainSocket(util.NormalizePath(event.Name))
		if err != nil {
			return fmt.Errorf("failed to determine if file: %s is a unix domain socket: %v", event.Name, err)
		}
		if !isSocket {