<change id="FileUtil.normalizePath">

            <api name="filesystems"/>

            <summary>

                <code>FileUtil.normalizePath</code> added

            </summary>

            <version major="7" minor="42"/>

            <date day="22" month="9" year="2010"/>

            <author login="vv159170"/>

            <compatibility addition="yes" binary="compatible" source="compatible" semantic="compatible" deprecation="no" deletion="no" modification="no"/>

            <description>

                <p>

                    The method 

                    <code>FileUtil.normalizePath(String)</code> was added as a

                    refinement of 

                    <code>FileUtil.normalizeFile</code> that does prevent String to File to String

                    conversion on client side when intention is to convert unnormalized path to normalized path presentation. 

                </p>

            </description>

            <class package="org.openide.filesystems" name="FileUtil"/>

            <issue number="190480"/>

        </change>        

     * @param path file path to normalize

     * @return normalized file path

     * @since 7.42

     */

    public static String normalizePath(final String path) {

        Map<String, String> normalizedPaths = getNormalizedFilesMap();

        String normalized = normalizedPaths.get(path);

        if (normalized == null) {

            File ret = normalizeFileImpl(new File(path));

            normalized = ret.getPath();

            normalizedPaths.put(path, normalized);

        }

        return normalized;

    }

    /**

     * Normalize a file path to a clean form.

     * This method may for example make sure that the returned file uses

     * the natural case on Windows; that old Windows 8.3 filenames are changed to the long form;

     * that relative paths are changed to be

     * absolute; that <code>.</code> and <code>..</code> sequences are removed; etc.

     * Unlike {@link File#getCanonicalFile} this method will not traverse symbolic links on Unix.

     * <p>This method involves some overhead and should not be called frivolously.

     * Generally it should be called on <em>incoming</em> pathnames that are gotten from user input

     * (including filechoosers), configuration files, Ant properties, etc. <em>Internal</em>

     * calculations should not need to renormalize paths since {@link File#listFiles},

     * {@link File#getParentFile}, etc. will not produce abnormal variants.

        Map<String, String> paths = createNormalizedPaths();

        for (String path : paths.keySet()) {

            File file = new File(path);

            assertTrue("Idempotency violated for path: " + path, FileUtil.normalizeFile(FileUtil.normalizeFile(file)).equals(FileUtil.normalizeFile(file)));

            assertEquals("File not normalized: " + path, paths.get(path), FileUtil.normalizeFile(file).getPath());

        }

    }

    public void testNormalizeFileIsCached() throws Exception {

        File f = new File(getWorkDir(), "text.txt");

        CharSequence log = Log.enable(FileUtil.class.getName(), Level.FINE);

        File one = FileUtil.normalizeFile(f);

        String msg = "FileUtil.normalizeFile for " + f;

        if (log.toString().indexOf(msg) == -1) {

            fail("One querfy for the file shall be in logs:\n" + log);

        }

        CharSequence log2 = Log.enable(FileUtil.class.getName(), Level.FINE);

        File two = FileUtil.normalizeFile(f);

        if (log2.toString().contains(msg)) {

            fail("No second FileUtil.normalizeFile for in:\n" + log);

        }

        assertEquals("Files are equal", one, two);

    }

    /** Tests normalizePath() method. */

    public void testNormalizePath() throws IOException {

        // pairs of path before and after normalization

        Map<String, String> paths = createNormalizedPaths();

        for (String path : paths.keySet()) {

            assertTrue("Idempotency violated for path: " + path, FileUtil.normalizePath(FileUtil.normalizePath(path)).equals(FileUtil.normalizePath(path)));

            assertEquals("File path not normalized: " + path, paths.get(path), FileUtil.normalizePath(path));

        }

    }

    private Map<String, String> createNormalizedPaths() throws IOException {

        // pairs of path before and after normalization