// Once the issue is resvolved, the following os.Lstat() is not needed.
	if err != nil {
		fi, err = os.Lstat(event.Name)
	}

	return fi, err
}

 * limitations under the License.
 */

package org.gradle.plugins.ide.eclipse.model.internal;

import org.apache.commons.io.FilenameUtils;

public class PathUtil {
    public static String normalizePath(String path) {
        return FilenameUtils.separatorsToUnix(path);
    }

    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() {

	case meshconfig.MeshConfig_ProxyPathNormalization_NONE:
		connectionManager.NormalizePath = proto.BoolFalse
	case meshconfig.MeshConfig_ProxyPathNormalization_BASE, meshconfig.MeshConfig_ProxyPathNormalization_DEFAULT:
		connectionManager.NormalizePath = proto.BoolTrue
	case meshconfig.MeshConfig_ProxyPathNormalization_MERGE_SLASHES:
		connectionManager.NormalizePath = proto.BoolTrue
		connectionManager.MergeSlashes = true

		} 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
	}{
		{

	if err != nil {
		return nil, err
	}
	if len(out) == 0 {
		scopes.Framework.Info("Environment variable KUBECONFIG unspecified, defaulting to ~/.kube/config.")
		normalizedDefaultKubeConfig, err := file.NormalizePath(defaultKubeConfig)
		if err != nil {
			return nil, fmt.Errorf("error normalizing default kube config file %s: %v",
				defaultKubeConfig, err)
		}
		out = []string{normalizedDefaultKubeConfig}
	}

        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
		}