ant-notifications mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From gin...@apache.org
Subject [06/22] ant git commit: Normalise tabulation and line breaks (cf master)
Date Wed, 29 Nov 2017 22:06:02 GMT
http://git-wip-us.apache.org/repos/asf/ant/blob/0ed7f4ab/src/tests/junit/org/apache/tools/ant/util/FileUtilsTest.java
----------------------------------------------------------------------
diff --git a/src/tests/junit/org/apache/tools/ant/util/FileUtilsTest.java b/src/tests/junit/org/apache/tools/ant/util/FileUtilsTest.java
index ae9b73b..e016657 100644
--- a/src/tests/junit/org/apache/tools/ant/util/FileUtilsTest.java
+++ b/src/tests/junit/org/apache/tools/ant/util/FileUtilsTest.java
@@ -1,625 +1,625 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one or more
- *  contributor license agreements.  See the NOTICE file distributed with
- *  this work for additional information regarding copyright ownership.
- *  The ASF licenses this file to You under the Apache License, Version 2.0
- *  (the "License"); you may not use this file except in compliance with
- *  the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-package org.apache.tools.ant.util;
-
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.IOException;
-
-import org.apache.tools.ant.BuildException;
-import org.apache.tools.ant.taskdefs.condition.Os;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-import static org.junit.Assume.assumeTrue;
-
-/**
- * Tests for org.apache.tools.ant.util.FileUtils.
- *
- */
-public class FileUtilsTest {
-
-    private static final FileUtils FILE_UTILS = FileUtils.getFileUtils();
-    private File removeThis;
-    private String root;
-
-
-    @Before
-    public void setUp() {
-        // Windows adds the drive letter in uppercase, unless you run Cygwin
-        root = new File(File.separator).getAbsolutePath().toUpperCase();
-    }
-
-    @After
-    public void tearDown() {
-        if (removeThis != null && removeThis.exists()) {
-            if (!removeThis.delete())
-            {
-                removeThis.deleteOnExit();
-            }
-        }
-    }
-
-    /**
-     * test modification.
-     * Since Ant1.7, the method being tested no longer uses
-     * reflection to provide backwards support to Java1.1, so this
-     * test is not so critical. But it does explore file system
-     * behaviour and will help catch any regression in Java itself,
-     * so is worth retaining.
-     * @see FileUtils#setFileLastModified(java.io.File, long)
-     * @throws IOException
-     */
-    @Test
-    public void testSetLastModified() throws IOException {
-        removeThis = new File("dummy");
-        FileOutputStream fos = new FileOutputStream(removeThis);
-        fos.write(new byte[0]);
-        fos.close();
-        assumeTrue("Could not change file modified time", removeThis.setLastModified(removeThis.lastModified() - 2000));
-        long modTime = removeThis.lastModified();
-        assertTrue(modTime != 0);
-
-
-        FILE_UTILS.setFileLastModified(removeThis, -1);
-        long secondModTime = removeThis.lastModified();
-        assertTrue(secondModTime > modTime);
-
-        // number of milliseconds in a day
-        final int millisperday=24 * 3600 * 1000;
-        // in a previous version, the date of the file was set to 123456
-        // milliseconds since 01.01.1970
-        // it did not work on a computer running JDK 1.4.1_02 + Windows 2000
-        FILE_UTILS.setFileLastModified(removeThis, secondModTime + millisperday);
-        long thirdModTime = removeThis.lastModified();
-        /*
-         * I would love to compare this with 123456, but depending on
-         * the filesystems granularity it can take an arbitrary value.
-         *
-         * Just assert the time has changed.
-         */
-        assertTrue(thirdModTime != secondModTime);
-    }
-
-    @Test
-    public void testResolveFile() {
-        if (!(Os.isFamily("dos") || Os.isFamily("netware"))) {
-            /*
-             * Start with simple absolute file names.
-             */
-            assertEquals(File.separator,
-                         FILE_UTILS.resolveFile(null, "/").getPath());
-            assertEquals(File.separator,
-                         FILE_UTILS.resolveFile(null, "\\").getPath());
-        } else {
-            assertEqualsIgnoreDriveCase(localize(File.separator),
-                FILE_UTILS.resolveFile(null, "/").getPath());
-            assertEqualsIgnoreDriveCase(localize(File.separator),
-                FILE_UTILS.resolveFile(null, "\\").getPath());
-            /*
-             * throw in drive letters
-             */
-            String driveSpec = "C:";
-            assertEquals(driveSpec + "\\",
-                         FILE_UTILS.resolveFile(null, driveSpec + "/").getPath());
-            assertEquals(driveSpec + "\\",
-                         FILE_UTILS.resolveFile(null, driveSpec + "\\").getPath());
-            String driveSpecLower = "c:";
-            assertEquals(driveSpecLower + "\\",
-                         FILE_UTILS.resolveFile(null, driveSpecLower + "/").getPath());
-            assertEquals(driveSpecLower + "\\",
-                         FILE_UTILS.resolveFile(null, driveSpecLower + "\\").getPath());
-            /*
-             * promised to eliminate consecutive slashes after drive letter.
-             */
-            assertEquals(driveSpec + "\\",
-                         FILE_UTILS.resolveFile(null, driveSpec + "/////").getPath());
-            assertEquals(driveSpec + "\\",
-                         FILE_UTILS.resolveFile(null, driveSpec + "\\\\\\\\\\\\").getPath());
-        }
-        if (Os.isFamily("netware")) {
-            /*
-             * throw in NetWare volume names
-             */
-            String driveSpec = "SYS:";
-            assertEquals(driveSpec,
-                         FILE_UTILS.resolveFile(null, driveSpec + "/").getPath());
-            assertEquals(driveSpec,
-                         FILE_UTILS.resolveFile(null, driveSpec + "\\").getPath());
-            String driveSpecLower = "sys:";
-            assertEquals(driveSpec,
-                         FILE_UTILS.resolveFile(null, driveSpecLower + "/").getPath());
-            assertEquals(driveSpec,
-                         FILE_UTILS.resolveFile(null, driveSpecLower + "\\").getPath());
-            /*
-             * promised to eliminate consecutive slashes after drive letter.
-             */
-            assertEquals(driveSpec,
-                         FILE_UTILS.resolveFile(null, driveSpec + "/////").getPath());
-            assertEquals(driveSpec,
-                         FILE_UTILS.resolveFile(null, driveSpec + "\\\\\\\\\\\\").getPath());
-        } else if (!(Os.isFamily("dos"))) {
-            /*
-             * drive letters must be considered just normal filenames.
-             */
-            String driveSpec = "C:";
-            String udir = System.getProperty("user.dir");
-            assertEquals(udir + File.separator + driveSpec,
-                         FILE_UTILS.resolveFile(null, driveSpec + "/").getPath());
-            assertEquals(udir + File.separator + driveSpec,
-                         FILE_UTILS.resolveFile(null, driveSpec + "\\").getPath());
-            String driveSpecLower = "c:";
-            assertEquals(udir + File.separator + driveSpecLower,
-                         FILE_UTILS.resolveFile(null, driveSpecLower + "/").getPath());
-            assertEquals(udir + File.separator + driveSpecLower,
-                         FILE_UTILS.resolveFile(null, driveSpecLower + "\\").getPath());
-        }
-
-        /*
-         * Now test some relative file name magic.
-         */
-        assertEquals(localize("/1/2/3/4"),
-                     FILE_UTILS.resolveFile(new File(localize("/1/2/3")), "4").getPath());
-        assertEquals(localize("/1/2/3/4"),
-                     FILE_UTILS.resolveFile(new File(localize("/1/2/3")), "./4").getPath());
-        assertEquals(localize("/1/2/3/4"),
-                     FILE_UTILS.resolveFile(new File(localize("/1/2/3")), ".\\4").getPath());
-        assertEquals(localize("/1/2/3/4"),
-                     FILE_UTILS.resolveFile(new File(localize("/1/2/3")), "./.\\4").getPath());
-        assertEquals(localize("/1/2/3/4"),
-                     FILE_UTILS.resolveFile(new File(localize("/1/2/3")), "../3/4").getPath());
-        assertEquals(localize("/1/2/3/4"),
-                     FILE_UTILS.resolveFile(new File(localize("/1/2/3")), "..\\3\\4").getPath());
-        assertEquals(localize("/1/2/3/4"),
-                     FILE_UTILS.resolveFile(new File(localize("/1/2/3")), "../../5/.././2/./3/6/../4").getPath());
-        assertEquals(localize("/1/2/3/4"),
-                     FILE_UTILS.resolveFile(new File(localize("/1/2/3")), "..\\../5/..\\./2/./3/6\\../4").getPath());
-
-        assertEquals("meaningless result but no exception",
-                new File(localize("/1/../../b")),
-                FILE_UTILS.resolveFile(new File(localize("/1")), "../../b"));
-
-    }
-
-    @Test
-    public void testNormalize() {
-        if (!(Os.isFamily("dos") || Os.isFamily("netware"))) {
-            /*
-             * Start with simple absolute file names.
-             */
-            assertEquals(File.separator,
-                         FILE_UTILS.normalize("/").getPath());
-            assertEquals(File.separator,
-                         FILE_UTILS.normalize("\\").getPath());
-        } else {
-            try {
-                 FILE_UTILS.normalize("/").getPath();
-                 fail("normalized \"/\" on dos or netware");
-            } catch (Exception e) {
-            }
-            try {
-                 FILE_UTILS.normalize("\\").getPath();
-                 fail("normalized \"\\\" on dos or netware");
-            } catch (Exception e) {
-            }
-        }
-
-        if (Os.isFamily("dos")) {
-            /*
-             * throw in drive letters
-             */
-            String driveSpec = "C:";
-            try {
-                 FILE_UTILS.normalize(driveSpec).getPath();
-                 fail(driveSpec + " is not an absolute path");
-            } catch (Exception e) {
-            }
-            assertEquals(driveSpec + "\\",
-                         FILE_UTILS.normalize(driveSpec + "/").getPath());
-            assertEquals(driveSpec + "\\",
-                         FILE_UTILS.normalize(driveSpec + "\\").getPath());
-            String driveSpecLower = "c:";
-            assertEquals(driveSpecLower + "\\",
-                         FILE_UTILS.normalize(driveSpecLower + "/").getPath());
-            assertEquals(driveSpecLower + "\\",
-                         FILE_UTILS.normalize(driveSpecLower + "\\").getPath());
-            /*
-             * promised to eliminate consecutive slashes after drive letter.
-             */
-            assertEquals(driveSpec + "\\",
-                         FILE_UTILS.normalize(driveSpec + "/////").getPath());
-            assertEquals(driveSpec + "\\",
-                         FILE_UTILS.normalize(driveSpec + "\\\\\\\\\\\\").getPath());
-        } else if (Os.isFamily("netware")) {
-            /*
-             * throw in NetWare volume names
-             */
-            String driveSpec = "SYS:";
-            assertEquals(driveSpec,
-                         FILE_UTILS.normalize(driveSpec).getPath());
-            assertEquals(driveSpec,
-                         FILE_UTILS.normalize(driveSpec + "/").getPath());
-            assertEquals(driveSpec,
-                         FILE_UTILS.normalize(driveSpec + "\\").getPath());
-            String driveSpecLower = "sys:";
-            assertEquals(driveSpec,
-                         FILE_UTILS.normalize(driveSpecLower).getPath());
-            assertEquals(driveSpec,
-                         FILE_UTILS.normalize(driveSpecLower + "/").getPath());
-            assertEquals(driveSpec,
-                         FILE_UTILS.normalize(driveSpecLower + "\\").getPath());
-            assertEquals(driveSpec + "\\junk",
-                         FILE_UTILS.normalize(driveSpecLower + "\\junk").getPath());
-            /*
-             * promised to eliminate consecutive slashes after drive letter.
-             */
-            assertEquals(driveSpec,
-                         FILE_UTILS.normalize(driveSpec + "/////").getPath());
-            assertEquals(driveSpec,
-                         FILE_UTILS.normalize(driveSpec + "\\\\\\\\\\\\").getPath());
-        } else {
-            try {
-                String driveSpec = "C:";
-                assertEquals(driveSpec,
-                             FILE_UTILS.normalize(driveSpec).getPath());
-                fail("Expected failure, C: isn't an absolute path on other os's");
-            } catch (BuildException e) {
-                // Passed test 
-            }
-        }
-
-        /*
-         * Now test some relative file name magic.
-         */
-        assertEquals(localize("/1/2/3/4"),
-                     FILE_UTILS.normalize(localize("/1/2/3/4")).getPath());
-        assertEquals(localize("/1/2/3/4"),
-                     FILE_UTILS.normalize(localize("/1/2/3/./4")).getPath());
-        assertEquals(localize("/1/2/3/4"),
-                     FILE_UTILS.normalize(localize("/1/2/3/.\\4")).getPath());
-        assertEquals(localize("/1/2/3/4"),
-                     FILE_UTILS.normalize(localize("/1/2/3/./.\\4")).getPath());
-        assertEquals(localize("/1/2/3/4"),
-                     FILE_UTILS.normalize(localize("/1/2/3/../3/4")).getPath());
-        assertEquals(localize("/1/2/3/4"),
-                     FILE_UTILS.normalize(localize("/1/2/3/..\\3\\4")).getPath());
-        assertEquals(localize("/1/2/3/4"),
-                     FILE_UTILS.normalize(localize("/1/2/3/../../5/.././2/./3/6/../4")).getPath());
-        assertEquals(localize("/1/2/3/4"),
-                     FILE_UTILS.normalize(localize("/1/2/3/..\\../5/..\\./2/./3/6\\../4")).getPath());
-
-        try {
-            FILE_UTILS.normalize("foo");
-            fail("foo is not an absolute path");
-        } catch (BuildException e) {
-            // Expected exception caught
-        }
-
-        assertEquals("will not go outside FS root (but will not throw an exception either)",
-                new File(localize("/1/../../b")),
-                FILE_UTILS.normalize(localize("/1/../../b")));
-    }
-
-    /**
-     * Test handling of null arguments.
-     */
-    @Test
-    public void testNullArgs() {
-        try {
-            FILE_UTILS.normalize(null);
-            fail("successfully normalized a null-file");
-        } catch (NullPointerException npe) {
-            // Expected exception caught
-        }
-
-        File f = FILE_UTILS.resolveFile(null, "a");
-        assertEquals(f, new File("a").getAbsoluteFile());
-    }
-
-    
-    /**
-     * Test createTempFile
-     */
-    @Test
-    public void testCreateTempFile()
-    {
-        // null parent dir
-        File tmp1 = FILE_UTILS.createTempFile("pre", ".suf", null, false, true);
-        String tmploc = System.getProperty("java.io.tmpdir");
-        String name = tmp1.getName();
-        assertTrue("starts with pre", name.startsWith("pre"));
-        assertTrue("ends with .suf", name.endsWith(".suf"));
-        assertTrue("File was created", tmp1.exists());
-        assertEquals((new File(tmploc, tmp1.getName())).getAbsolutePath(), tmp1
-                .getAbsolutePath());
-        tmp1.delete();
-
-        File dir2 = new File(tmploc + "/ant-test");
-        dir2.mkdir();
-        removeThis = dir2;
-
-        File tmp2 = FILE_UTILS.createTempFile("pre", ".suf", dir2, true, true);
-        String name2 = tmp2.getName();
-        assertTrue("starts with pre", name2.startsWith("pre"));
-        assertTrue("ends with .suf", name2.endsWith(".suf"));
-        assertTrue("File was created", tmp2.exists());
-        assertEquals((new File(dir2, tmp2.getName())).getAbsolutePath(), tmp2
-                .getAbsolutePath());
-        tmp2.delete();
-        dir2.delete();
-
-        File parent = new File((new File("/tmp")).getAbsolutePath());
-        tmp1 = FILE_UTILS.createTempFile("pre", ".suf", parent, false);
-        assertTrue("new file", !tmp1.exists());
-
-        name = tmp1.getName();
-        assertTrue("starts with pre", name.startsWith("pre"));
-        assertTrue("ends with .suf", name.endsWith(".suf"));
-        assertEquals("is inside parent dir", parent.getAbsolutePath(), tmp1
-                .getParent());
-
-        tmp2 = FILE_UTILS.createTempFile("pre", ".suf", parent, false);
-        assertTrue("files are different", !tmp1.getAbsolutePath().equals(
-                tmp2.getAbsolutePath()));
-
-        // null parent dir
-        File tmp3 = FILE_UTILS.createTempFile("pre", ".suf", null, false);
-        tmploc = System.getProperty("java.io.tmpdir");
-        assertEquals((new File(tmploc, tmp3.getName())).getAbsolutePath(), tmp3
-                .getAbsolutePath());
-    }
-
-    /**
-     * Test contentEquals
-     */
-    @Test
-    public void testContentEquals() throws IOException {
-        assertTrue("Non existing files", FILE_UTILS.contentEquals(new File(System.getProperty("root"), "foo"),
-                                                          new File(System.getProperty("root"), "bar")));
-        assertTrue("One exists, the other one doesn\'t",
-                   !FILE_UTILS.contentEquals(new File(System.getProperty("root"), "foo"), new File(System.getProperty("root"), "build.xml")));
-        assertTrue("Don\'t compare directories",
-                   !FILE_UTILS.contentEquals(new File(System.getProperty("root"), "src"), new File(System.getProperty("root"), "src")));
-        assertTrue("File equals itself",
-                   FILE_UTILS.contentEquals(new File(System.getProperty("root"), "build.xml"),
-                                    new File(System.getProperty("root"), "build.xml")));
-        assertTrue("Files are different",
-                   !FILE_UTILS.contentEquals(new File(System.getProperty("root"), "build.xml"),
-                                     new File(System.getProperty("root"), "docs.xml")));
-    }
-
-    /**
-     * Test createNewFile
-     */
-    @Test
-    public void testCreateNewFile() throws IOException {
-        removeThis = new File("dummy");
-        assertTrue(!removeThis.exists());
-        FILE_UTILS.createNewFile(removeThis);
-        assertTrue(removeThis.exists());
-    }
-
-    /**
-     * Test removeLeadingPath.
-     */
-    @Test
-    public void testRemoveLeadingPath() {
-        assertEquals("bar", FILE_UTILS.removeLeadingPath(new File("/foo"),
-                                                 new File("/foo/bar")));
-        assertEquals("bar", FILE_UTILS.removeLeadingPath(new File("/foo/"),
-                                                 new File("/foo/bar")));
-        assertEquals("bar", FILE_UTILS.removeLeadingPath(new File("\\foo"),
-                                                 new File("\\foo\\bar")));
-        assertEquals("bar", FILE_UTILS.removeLeadingPath(new File("\\foo\\"),
-                                                 new File("\\foo\\bar")));
-        assertEquals("bar", FILE_UTILS.removeLeadingPath(new File("c:/foo"),
-                                                 new File("c:/foo/bar")));
-        assertEquals("bar", FILE_UTILS.removeLeadingPath(new File("c:/foo/"),
-                                                 new File("c:/foo/bar")));
-        assertEquals("bar", FILE_UTILS.removeLeadingPath(new File("c:\\foo"),
-                                                 new File("c:\\foo\\bar")));
-        assertEquals("bar", FILE_UTILS.removeLeadingPath(new File("c:\\foo\\"),
-                                                 new File("c:\\foo\\bar")));
-        if (!(Os.isFamily("dos") || Os.isFamily("netware"))) {
-            assertEquals(FILE_UTILS.normalize("/bar").getAbsolutePath(),
-                         FILE_UTILS.removeLeadingPath(new File("/foo"), new File("/bar")));
-            assertEquals(FILE_UTILS.normalize("/foobar").getAbsolutePath(),
-                         FILE_UTILS.removeLeadingPath(new File("/foo"), new File("/foobar")));
-        }
-        // bugzilla report 19979
-        assertEquals("", FILE_UTILS.removeLeadingPath(new File("/foo/bar"),
-                                              new File("/foo/bar")));
-        assertEquals("", FILE_UTILS.removeLeadingPath(new File("/foo/bar"),
-                                              new File("/foo/bar/")));
-        assertEquals("", FILE_UTILS.removeLeadingPath(new File("/foo/bar/"),
-                                              new File("/foo/bar/")));
-        assertEquals("", FILE_UTILS.removeLeadingPath(new File("/foo/bar/"),
-                                              new File("/foo/bar")));
-
-        String expected = "foo/bar".replace('\\', File.separatorChar)
-            .replace('/', File.separatorChar);
-        assertEquals(expected, FILE_UTILS.removeLeadingPath(new File("/"),
-                                                    new File("/foo/bar")));
-        assertEquals(expected, FILE_UTILS.removeLeadingPath(new File("c:/"),
-                                                    new File("c:/foo/bar")));
-        assertEquals(expected, FILE_UTILS.removeLeadingPath(new File("c:\\"),
-                                                    new File("c:\\foo\\bar")));
-    }
-
-    /**
-     * test toUri
-     */
-    @Test
-    public void testToURI() {
-        String dosRoot;
-        if (Os.isFamily("dos") || Os.isFamily("netware")) {
-            dosRoot = System.getProperty("user.dir")
-                .substring(0, 3).replace(File.separatorChar, '/');
-        }
-        else
-        {
-            dosRoot = "";
-        }
-        if (Os.isFamily("dos")) {
-            assertEquals("file:/c:/foo", removeExtraneousAuthority(FILE_UTILS.toURI("c:\\foo")));
-        }
-        if (Os.isFamily("netware")) {
-            assertEquals("file:/SYS:/foo", removeExtraneousAuthority(FILE_UTILS.toURI("sys:\\foo")));
-        }
-        if (File.pathSeparatorChar == '/') {
-            assertEquals("file:/foo", removeExtraneousAuthority(FILE_UTILS.toURI("/foo")));
-            assertTrue("file: URIs must name absolute paths", FILE_UTILS.toURI("./foo").startsWith("file:/"));
-            assertTrue(FILE_UTILS.toURI("./foo").endsWith("/foo"));
-            assertEquals("file:/" + dosRoot + "foo%20bar", removeExtraneousAuthority(FILE_UTILS.toURI("/foo bar")));
-            assertEquals("file:/" + dosRoot + "foo%23bar", removeExtraneousAuthority(FILE_UTILS.toURI("/foo#bar")));
-        } else if (File.pathSeparatorChar == '\\') {
-            assertEquals("file:/" + dosRoot + "foo", removeExtraneousAuthority(FILE_UTILS.toURI("\\foo")));
-            assertTrue("file: URIs must name absolute paths", FILE_UTILS.toURI(".\\foo").startsWith("file:/"));
-            assertTrue(FILE_UTILS.toURI(".\\foo").endsWith("/foo"));
-            assertEquals("file:/" + dosRoot + "foo%20bar", removeExtraneousAuthority(FILE_UTILS.toURI("\\foo bar")));
-            assertEquals("file:/" + dosRoot + "foo%23bar", removeExtraneousAuthority(FILE_UTILS.toURI("\\foo#bar")));
-        }
-        // a test with ant for germans
-        // the escaped character used for the test is the "a umlaut"
-        // this is the fix for the bug 37348
-        assertEquals("file:/" + dosRoot + "%C3%A4nt", removeExtraneousAuthority(FILE_UTILS.toURI("/\u00E4nt")));
-    }
-
-    /**
-     * Authority field is unnecessary, but harmless, in file: URIs.
-     * Java 1.4 does not produce it when using File.toURI.
-     */
-    private static String removeExtraneousAuthority(String uri) {
-        String prefix = "file:///";
-        if (uri.startsWith(prefix)) {
-            return "file:/" + uri.substring(prefix.length());
-        } else {
-            return uri;
-        }
-    }
-
-    @Test
-    public void testIsContextRelativePath() {
-        assumeTrue("Test only runs on DOS", Os.isFamily("dos"));
-        assertTrue(FileUtils.isContextRelativePath("/\u00E4nt"));
-        assertTrue(FileUtils.isContextRelativePath("\\foo"));
-    }
-
-    /**
-     * test fromUri
-     */
-    @Test
-    public void testFromURI() {
-        String dosRoot;
-        if (Os.isFamily("dos") || Os.isFamily("netware")) {
-            dosRoot = System.getProperty("user.dir").substring(0, 2);
-        } else {
-            dosRoot = "";
-        }
-        if (Os.isFamily("netware")) {
-            assertEqualsIgnoreDriveCase("SYS:\\foo", FILE_UTILS.fromURI("file:///sys:/foo"));
-        }
-        if (Os.isFamily("dos")) {
-            assertEqualsIgnoreDriveCase("C:\\foo", FILE_UTILS.fromURI("file:///c:/foo"));
-        }
-        assertEqualsIgnoreDriveCase(dosRoot + File.separator + "foo", FILE_UTILS.fromURI("file:///foo"));
-        assertEquals("." + File.separator + "foo",
-                     FILE_UTILS.fromURI("file:./foo"));
-        assertEquals(dosRoot + File.separator + "foo bar", FILE_UTILS.fromURI("file:///foo%20bar"));
-        assertEquals(dosRoot + File.separator + "foo#bar", FILE_UTILS.fromURI("file:///foo%23bar"));
-    }
-
-    @Test
-    public void testModificationTests() {
-
-        //get a time
-        long firstTime=System.currentTimeMillis();
-        //add some time. We assume no OS has a granularity this bad
-        long secondTime=firstTime+60000;
-/*
-        assertTrue("same timestamp is up to date",
-                fu.isUpToDate(firstTime, firstTime));
-                */
-
-        //check that older is up to date with a newer dest
-        assertTrue("older source files are up to date",
-                FILE_UTILS.isUpToDate(firstTime,secondTime));
-        //check that older is up to date with a newer dest
-        assertFalse("newer source files are no up to date",
-                FILE_UTILS.isUpToDate(secondTime, firstTime));
-
-        assertTrue("-1 dest timestamp implies nonexistence",
-                !FILE_UTILS.isUpToDate(firstTime,-1L));
-    }
-
-    @Test
-    public void testHasErrorInCase() {
-        File tempFolder = new File(System.getProperty("java.io.tmpdir"));
-        File wellcased = FILE_UTILS.createTempFile("alpha", "beta", tempFolder,
-                                                   true, true);
-        String s = wellcased.getName().toUpperCase();
-        File wrongcased = new File(tempFolder, s);
-        if (Os.isFamily("mac") && Os.isFamily("unix")) {
-            //no guarantees on filesystem case-sensitivity
-        } else if (Os.isFamily("dos")) {
-            assertTrue(FILE_UTILS.hasErrorInCase(wrongcased));
-            assertFalse(FILE_UTILS.hasErrorInCase(wellcased));
-        } else {
-            assertFalse(FILE_UTILS.hasErrorInCase(wrongcased));
-            assertFalse(FILE_UTILS.hasErrorInCase(wellcased));
-        }
-        
-    }
-    public void testGetDefaultEncoding() {
-        // This just tests that the function does not blow up
-        FILE_UTILS.getDefaultEncoding();
-    }
-
-    /**
-     * adapt file separators to local conventions
-     */
-    private String localize(String path) {
-        path = root + path.substring(1);
-        return path.replace('\\', File.separatorChar).replace('/', File.separatorChar);
-    }
-
-    /**
-     * convenience method
-     * normalize brings the drive in uppercase
-     * the drive letter is in lower case under cygwin
-     * calling this method allows tests where normalize is called to pass under cygwin
-     */
-    private void assertEqualsIgnoreDriveCase(String s1, String s2) {
-        if ((Os.isFamily("dos") || Os.isFamily("netware"))
-            && s1.length() > 0 && s2.length() > 0) {
-            StringBuilder sb1 = new StringBuilder(s1);
-            StringBuilder sb2 = new StringBuilder(s2);
-            sb1.setCharAt(0, Character.toUpperCase(s1.charAt(0)));
-            sb2.setCharAt(0, Character.toUpperCase(s2.charAt(0)));
-            assertEquals(sb1.toString(), sb2.toString());
-        } else {
-            assertEquals(s1, s2);
-        }
-    }
-}
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one or more
+ *  contributor license agreements.  See the NOTICE file distributed with
+ *  this work for additional information regarding copyright ownership.
+ *  The ASF licenses this file to You under the Apache License, Version 2.0
+ *  (the "License"); you may not use this file except in compliance with
+ *  the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ */
+
+package org.apache.tools.ant.util;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+
+import org.apache.tools.ant.BuildException;
+import org.apache.tools.ant.taskdefs.condition.Os;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.junit.Assume.assumeTrue;
+
+/**
+ * Tests for org.apache.tools.ant.util.FileUtils.
+ *
+ */
+public class FileUtilsTest {
+
+    private static final FileUtils FILE_UTILS = FileUtils.getFileUtils();
+    private File removeThis;
+    private String root;
+
+
+    @Before
+    public void setUp() {
+        // Windows adds the drive letter in uppercase, unless you run Cygwin
+        root = new File(File.separator).getAbsolutePath().toUpperCase();
+    }
+
+    @After
+    public void tearDown() {
+        if (removeThis != null && removeThis.exists()) {
+            if (!removeThis.delete())
+            {
+                removeThis.deleteOnExit();
+            }
+        }
+    }
+
+    /**
+     * test modification.
+     * Since Ant1.7, the method being tested no longer uses
+     * reflection to provide backwards support to Java1.1, so this
+     * test is not so critical. But it does explore file system
+     * behaviour and will help catch any regression in Java itself,
+     * so is worth retaining.
+     * @see FileUtils#setFileLastModified(java.io.File, long)
+     * @throws IOException
+     */
+    @Test
+    public void testSetLastModified() throws IOException {
+        removeThis = new File("dummy");
+        FileOutputStream fos = new FileOutputStream(removeThis);
+        fos.write(new byte[0]);
+        fos.close();
+        assumeTrue("Could not change file modified time", removeThis.setLastModified(removeThis.lastModified() - 2000));
+        long modTime = removeThis.lastModified();
+        assertTrue(modTime != 0);
+
+
+        FILE_UTILS.setFileLastModified(removeThis, -1);
+        long secondModTime = removeThis.lastModified();
+        assertTrue(secondModTime > modTime);
+
+        // number of milliseconds in a day
+        final int millisperday=24 * 3600 * 1000;
+        // in a previous version, the date of the file was set to 123456
+        // milliseconds since 01.01.1970
+        // it did not work on a computer running JDK 1.4.1_02 + Windows 2000
+        FILE_UTILS.setFileLastModified(removeThis, secondModTime + millisperday);
+        long thirdModTime = removeThis.lastModified();
+        /*
+         * I would love to compare this with 123456, but depending on
+         * the filesystems granularity it can take an arbitrary value.
+         *
+         * Just assert the time has changed.
+         */
+        assertTrue(thirdModTime != secondModTime);
+    }
+
+    @Test
+    public void testResolveFile() {
+        if (!(Os.isFamily("dos") || Os.isFamily("netware"))) {
+            /*
+             * Start with simple absolute file names.
+             */
+            assertEquals(File.separator,
+                         FILE_UTILS.resolveFile(null, "/").getPath());
+            assertEquals(File.separator,
+                         FILE_UTILS.resolveFile(null, "\\").getPath());
+        } else {
+            assertEqualsIgnoreDriveCase(localize(File.separator),
+                FILE_UTILS.resolveFile(null, "/").getPath());
+            assertEqualsIgnoreDriveCase(localize(File.separator),
+                FILE_UTILS.resolveFile(null, "\\").getPath());
+            /*
+             * throw in drive letters
+             */
+            String driveSpec = "C:";
+            assertEquals(driveSpec + "\\",
+                         FILE_UTILS.resolveFile(null, driveSpec + "/").getPath());
+            assertEquals(driveSpec + "\\",
+                         FILE_UTILS.resolveFile(null, driveSpec + "\\").getPath());
+            String driveSpecLower = "c:";
+            assertEquals(driveSpecLower + "\\",
+                         FILE_UTILS.resolveFile(null, driveSpecLower + "/").getPath());
+            assertEquals(driveSpecLower + "\\",
+                         FILE_UTILS.resolveFile(null, driveSpecLower + "\\").getPath());
+            /*
+             * promised to eliminate consecutive slashes after drive letter.
+             */
+            assertEquals(driveSpec + "\\",
+                         FILE_UTILS.resolveFile(null, driveSpec + "/////").getPath());
+            assertEquals(driveSpec + "\\",
+                         FILE_UTILS.resolveFile(null, driveSpec + "\\\\\\\\\\\\").getPath());
+        }
+        if (Os.isFamily("netware")) {
+            /*
+             * throw in NetWare volume names
+             */
+            String driveSpec = "SYS:";
+            assertEquals(driveSpec,
+                         FILE_UTILS.resolveFile(null, driveSpec + "/").getPath());
+            assertEquals(driveSpec,
+                         FILE_UTILS.resolveFile(null, driveSpec + "\\").getPath());
+            String driveSpecLower = "sys:";
+            assertEquals(driveSpec,
+                         FILE_UTILS.resolveFile(null, driveSpecLower + "/").getPath());
+            assertEquals(driveSpec,
+                         FILE_UTILS.resolveFile(null, driveSpecLower + "\\").getPath());
+            /*
+             * promised to eliminate consecutive slashes after drive letter.
+             */
+            assertEquals(driveSpec,
+                         FILE_UTILS.resolveFile(null, driveSpec + "/////").getPath());
+            assertEquals(driveSpec,
+                         FILE_UTILS.resolveFile(null, driveSpec + "\\\\\\\\\\\\").getPath());
+        } else if (!(Os.isFamily("dos"))) {
+            /*
+             * drive letters must be considered just normal filenames.
+             */
+            String driveSpec = "C:";
+            String udir = System.getProperty("user.dir");
+            assertEquals(udir + File.separator + driveSpec,
+                         FILE_UTILS.resolveFile(null, driveSpec + "/").getPath());
+            assertEquals(udir + File.separator + driveSpec,
+                         FILE_UTILS.resolveFile(null, driveSpec + "\\").getPath());
+            String driveSpecLower = "c:";
+            assertEquals(udir + File.separator + driveSpecLower,
+                         FILE_UTILS.resolveFile(null, driveSpecLower + "/").getPath());
+            assertEquals(udir + File.separator + driveSpecLower,
+                         FILE_UTILS.resolveFile(null, driveSpecLower + "\\").getPath());
+        }
+
+        /*
+         * Now test some relative file name magic.
+         */
+        assertEquals(localize("/1/2/3/4"),
+                     FILE_UTILS.resolveFile(new File(localize("/1/2/3")), "4").getPath());
+        assertEquals(localize("/1/2/3/4"),
+                     FILE_UTILS.resolveFile(new File(localize("/1/2/3")), "./4").getPath());
+        assertEquals(localize("/1/2/3/4"),
+                     FILE_UTILS.resolveFile(new File(localize("/1/2/3")), ".\\4").getPath());
+        assertEquals(localize("/1/2/3/4"),
+                     FILE_UTILS.resolveFile(new File(localize("/1/2/3")), "./.\\4").getPath());
+        assertEquals(localize("/1/2/3/4"),
+                     FILE_UTILS.resolveFile(new File(localize("/1/2/3")), "../3/4").getPath());
+        assertEquals(localize("/1/2/3/4"),
+                     FILE_UTILS.resolveFile(new File(localize("/1/2/3")), "..\\3\\4").getPath());
+        assertEquals(localize("/1/2/3/4"),
+                     FILE_UTILS.resolveFile(new File(localize("/1/2/3")), "../../5/.././2/./3/6/../4").getPath());
+        assertEquals(localize("/1/2/3/4"),
+                     FILE_UTILS.resolveFile(new File(localize("/1/2/3")), "..\\../5/..\\./2/./3/6\\../4").getPath());
+
+        assertEquals("meaningless result but no exception",
+                new File(localize("/1/../../b")),
+                FILE_UTILS.resolveFile(new File(localize("/1")), "../../b"));
+
+    }
+
+    @Test
+    public void testNormalize() {
+        if (!(Os.isFamily("dos") || Os.isFamily("netware"))) {
+            /*
+             * Start with simple absolute file names.
+             */
+            assertEquals(File.separator,
+                         FILE_UTILS.normalize("/").getPath());
+            assertEquals(File.separator,
+                         FILE_UTILS.normalize("\\").getPath());
+        } else {
+            try {
+                 FILE_UTILS.normalize("/").getPath();
+                 fail("normalized \"/\" on dos or netware");
+            } catch (Exception e) {
+            }
+            try {
+                 FILE_UTILS.normalize("\\").getPath();
+                 fail("normalized \"\\\" on dos or netware");
+            } catch (Exception e) {
+            }
+        }
+
+        if (Os.isFamily("dos")) {
+            /*
+             * throw in drive letters
+             */
+            String driveSpec = "C:";
+            try {
+                 FILE_UTILS.normalize(driveSpec).getPath();
+                 fail(driveSpec + " is not an absolute path");
+            } catch (Exception e) {
+            }
+            assertEquals(driveSpec + "\\",
+                         FILE_UTILS.normalize(driveSpec + "/").getPath());
+            assertEquals(driveSpec + "\\",
+                         FILE_UTILS.normalize(driveSpec + "\\").getPath());
+            String driveSpecLower = "c:";
+            assertEquals(driveSpecLower + "\\",
+                         FILE_UTILS.normalize(driveSpecLower + "/").getPath());
+            assertEquals(driveSpecLower + "\\",
+                         FILE_UTILS.normalize(driveSpecLower + "\\").getPath());
+            /*
+             * promised to eliminate consecutive slashes after drive letter.
+             */
+            assertEquals(driveSpec + "\\",
+                         FILE_UTILS.normalize(driveSpec + "/////").getPath());
+            assertEquals(driveSpec + "\\",
+                         FILE_UTILS.normalize(driveSpec + "\\\\\\\\\\\\").getPath());
+        } else if (Os.isFamily("netware")) {
+            /*
+             * throw in NetWare volume names
+             */
+            String driveSpec = "SYS:";
+            assertEquals(driveSpec,
+                         FILE_UTILS.normalize(driveSpec).getPath());
+            assertEquals(driveSpec,
+                         FILE_UTILS.normalize(driveSpec + "/").getPath());
+            assertEquals(driveSpec,
+                         FILE_UTILS.normalize(driveSpec + "\\").getPath());
+            String driveSpecLower = "sys:";
+            assertEquals(driveSpec,
+                         FILE_UTILS.normalize(driveSpecLower).getPath());
+            assertEquals(driveSpec,
+                         FILE_UTILS.normalize(driveSpecLower + "/").getPath());
+            assertEquals(driveSpec,
+                         FILE_UTILS.normalize(driveSpecLower + "\\").getPath());
+            assertEquals(driveSpec + "\\junk",
+                         FILE_UTILS.normalize(driveSpecLower + "\\junk").getPath());
+            /*
+             * promised to eliminate consecutive slashes after drive letter.
+             */
+            assertEquals(driveSpec,
+                         FILE_UTILS.normalize(driveSpec + "/////").getPath());
+            assertEquals(driveSpec,
+                         FILE_UTILS.normalize(driveSpec + "\\\\\\\\\\\\").getPath());
+        } else {
+            try {
+                String driveSpec = "C:";
+                assertEquals(driveSpec,
+                             FILE_UTILS.normalize(driveSpec).getPath());
+                fail("Expected failure, C: isn't an absolute path on other os's");
+            } catch (BuildException e) {
+                // Passed test
+            }
+        }
+
+        /*
+         * Now test some relative file name magic.
+         */
+        assertEquals(localize("/1/2/3/4"),
+                     FILE_UTILS.normalize(localize("/1/2/3/4")).getPath());
+        assertEquals(localize("/1/2/3/4"),
+                     FILE_UTILS.normalize(localize("/1/2/3/./4")).getPath());
+        assertEquals(localize("/1/2/3/4"),
+                     FILE_UTILS.normalize(localize("/1/2/3/.\\4")).getPath());
+        assertEquals(localize("/1/2/3/4"),
+                     FILE_UTILS.normalize(localize("/1/2/3/./.\\4")).getPath());
+        assertEquals(localize("/1/2/3/4"),
+                     FILE_UTILS.normalize(localize("/1/2/3/../3/4")).getPath());
+        assertEquals(localize("/1/2/3/4"),
+                     FILE_UTILS.normalize(localize("/1/2/3/..\\3\\4")).getPath());
+        assertEquals(localize("/1/2/3/4"),
+                     FILE_UTILS.normalize(localize("/1/2/3/../../5/.././2/./3/6/../4")).getPath());
+        assertEquals(localize("/1/2/3/4"),
+                     FILE_UTILS.normalize(localize("/1/2/3/..\\../5/..\\./2/./3/6\\../4")).getPath());
+
+        try {
+            FILE_UTILS.normalize("foo");
+            fail("foo is not an absolute path");
+        } catch (BuildException e) {
+            // Expected exception caught
+        }
+
+        assertEquals("will not go outside FS root (but will not throw an exception either)",
+                new File(localize("/1/../../b")),
+                FILE_UTILS.normalize(localize("/1/../../b")));
+    }
+
+    /**
+     * Test handling of null arguments.
+     */
+    @Test
+    public void testNullArgs() {
+        try {
+            FILE_UTILS.normalize(null);
+            fail("successfully normalized a null-file");
+        } catch (NullPointerException npe) {
+            // Expected exception caught
+        }
+
+        File f = FILE_UTILS.resolveFile(null, "a");
+        assertEquals(f, new File("a").getAbsoluteFile());
+    }
+
+
+    /**
+     * Test createTempFile
+     */
+    @Test
+    public void testCreateTempFile()
+    {
+        // null parent dir
+        File tmp1 = FILE_UTILS.createTempFile("pre", ".suf", null, false, true);
+        String tmploc = System.getProperty("java.io.tmpdir");
+        String name = tmp1.getName();
+        assertTrue("starts with pre", name.startsWith("pre"));
+        assertTrue("ends with .suf", name.endsWith(".suf"));
+        assertTrue("File was created", tmp1.exists());
+        assertEquals((new File(tmploc, tmp1.getName())).getAbsolutePath(), tmp1
+                .getAbsolutePath());
+        tmp1.delete();
+
+        File dir2 = new File(tmploc + "/ant-test");
+        dir2.mkdir();
+        removeThis = dir2;
+
+        File tmp2 = FILE_UTILS.createTempFile("pre", ".suf", dir2, true, true);
+        String name2 = tmp2.getName();
+        assertTrue("starts with pre", name2.startsWith("pre"));
+        assertTrue("ends with .suf", name2.endsWith(".suf"));
+        assertTrue("File was created", tmp2.exists());
+        assertEquals((new File(dir2, tmp2.getName())).getAbsolutePath(), tmp2
+                .getAbsolutePath());
+        tmp2.delete();
+        dir2.delete();
+
+        File parent = new File((new File("/tmp")).getAbsolutePath());
+        tmp1 = FILE_UTILS.createTempFile("pre", ".suf", parent, false);
+        assertTrue("new file", !tmp1.exists());
+
+        name = tmp1.getName();
+        assertTrue("starts with pre", name.startsWith("pre"));
+        assertTrue("ends with .suf", name.endsWith(".suf"));
+        assertEquals("is inside parent dir", parent.getAbsolutePath(), tmp1
+                .getParent());
+
+        tmp2 = FILE_UTILS.createTempFile("pre", ".suf", parent, false);
+        assertTrue("files are different", !tmp1.getAbsolutePath().equals(
+                tmp2.getAbsolutePath()));
+
+        // null parent dir
+        File tmp3 = FILE_UTILS.createTempFile("pre", ".suf", null, false);
+        tmploc = System.getProperty("java.io.tmpdir");
+        assertEquals((new File(tmploc, tmp3.getName())).getAbsolutePath(), tmp3
+                .getAbsolutePath());
+    }
+
+    /**
+     * Test contentEquals
+     */
+    @Test
+    public void testContentEquals() throws IOException {
+        assertTrue("Non existing files", FILE_UTILS.contentEquals(new File(System.getProperty("root"), "foo"),
+                                                          new File(System.getProperty("root"), "bar")));
+        assertTrue("One exists, the other one doesn\'t",
+                   !FILE_UTILS.contentEquals(new File(System.getProperty("root"), "foo"), new File(System.getProperty("root"), "build.xml")));
+        assertTrue("Don\'t compare directories",
+                   !FILE_UTILS.contentEquals(new File(System.getProperty("root"), "src"), new File(System.getProperty("root"), "src")));
+        assertTrue("File equals itself",
+                   FILE_UTILS.contentEquals(new File(System.getProperty("root"), "build.xml"),
+                                    new File(System.getProperty("root"), "build.xml")));
+        assertTrue("Files are different",
+                   !FILE_UTILS.contentEquals(new File(System.getProperty("root"), "build.xml"),
+                                     new File(System.getProperty("root"), "docs.xml")));
+    }
+
+    /**
+     * Test createNewFile
+     */
+    @Test
+    public void testCreateNewFile() throws IOException {
+        removeThis = new File("dummy");
+        assertTrue(!removeThis.exists());
+        FILE_UTILS.createNewFile(removeThis);
+        assertTrue(removeThis.exists());
+    }
+
+    /**
+     * Test removeLeadingPath.
+     */
+    @Test
+    public void testRemoveLeadingPath() {
+        assertEquals("bar", FILE_UTILS.removeLeadingPath(new File("/foo"),
+                                                 new File("/foo/bar")));
+        assertEquals("bar", FILE_UTILS.removeLeadingPath(new File("/foo/"),
+                                                 new File("/foo/bar")));
+        assertEquals("bar", FILE_UTILS.removeLeadingPath(new File("\\foo"),
+                                                 new File("\\foo\\bar")));
+        assertEquals("bar", FILE_UTILS.removeLeadingPath(new File("\\foo\\"),
+                                                 new File("\\foo\\bar")));
+        assertEquals("bar", FILE_UTILS.removeLeadingPath(new File("c:/foo"),
+                                                 new File("c:/foo/bar")));
+        assertEquals("bar", FILE_UTILS.removeLeadingPath(new File("c:/foo/"),
+                                                 new File("c:/foo/bar")));
+        assertEquals("bar", FILE_UTILS.removeLeadingPath(new File("c:\\foo"),
+                                                 new File("c:\\foo\\bar")));
+        assertEquals("bar", FILE_UTILS.removeLeadingPath(new File("c:\\foo\\"),
+                                                 new File("c:\\foo\\bar")));
+        if (!(Os.isFamily("dos") || Os.isFamily("netware"))) {
+            assertEquals(FILE_UTILS.normalize("/bar").getAbsolutePath(),
+                         FILE_UTILS.removeLeadingPath(new File("/foo"), new File("/bar")));
+            assertEquals(FILE_UTILS.normalize("/foobar").getAbsolutePath(),
+                         FILE_UTILS.removeLeadingPath(new File("/foo"), new File("/foobar")));
+        }
+        // bugzilla report 19979
+        assertEquals("", FILE_UTILS.removeLeadingPath(new File("/foo/bar"),
+                                              new File("/foo/bar")));
+        assertEquals("", FILE_UTILS.removeLeadingPath(new File("/foo/bar"),
+                                              new File("/foo/bar/")));
+        assertEquals("", FILE_UTILS.removeLeadingPath(new File("/foo/bar/"),
+                                              new File("/foo/bar/")));
+        assertEquals("", FILE_UTILS.removeLeadingPath(new File("/foo/bar/"),
+                                              new File("/foo/bar")));
+
+        String expected = "foo/bar".replace('\\', File.separatorChar)
+            .replace('/', File.separatorChar);
+        assertEquals(expected, FILE_UTILS.removeLeadingPath(new File("/"),
+                                                    new File("/foo/bar")));
+        assertEquals(expected, FILE_UTILS.removeLeadingPath(new File("c:/"),
+                                                    new File("c:/foo/bar")));
+        assertEquals(expected, FILE_UTILS.removeLeadingPath(new File("c:\\"),
+                                                    new File("c:\\foo\\bar")));
+    }
+
+    /**
+     * test toUri
+     */
+    @Test
+    public void testToURI() {
+        String dosRoot;
+        if (Os.isFamily("dos") || Os.isFamily("netware")) {
+            dosRoot = System.getProperty("user.dir")
+                .substring(0, 3).replace(File.separatorChar, '/');
+        }
+        else
+        {
+            dosRoot = "";
+        }
+        if (Os.isFamily("dos")) {
+            assertEquals("file:/c:/foo", removeExtraneousAuthority(FILE_UTILS.toURI("c:\\foo")));
+        }
+        if (Os.isFamily("netware")) {
+            assertEquals("file:/SYS:/foo", removeExtraneousAuthority(FILE_UTILS.toURI("sys:\\foo")));
+        }
+        if (File.pathSeparatorChar == '/') {
+            assertEquals("file:/foo", removeExtraneousAuthority(FILE_UTILS.toURI("/foo")));
+            assertTrue("file: URIs must name absolute paths", FILE_UTILS.toURI("./foo").startsWith("file:/"));
+            assertTrue(FILE_UTILS.toURI("./foo").endsWith("/foo"));
+            assertEquals("file:/" + dosRoot + "foo%20bar", removeExtraneousAuthority(FILE_UTILS.toURI("/foo bar")));
+            assertEquals("file:/" + dosRoot + "foo%23bar", removeExtraneousAuthority(FILE_UTILS.toURI("/foo#bar")));
+        } else if (File.pathSeparatorChar == '\\') {
+            assertEquals("file:/" + dosRoot + "foo", removeExtraneousAuthority(FILE_UTILS.toURI("\\foo")));
+            assertTrue("file: URIs must name absolute paths", FILE_UTILS.toURI(".\\foo").startsWith("file:/"));
+            assertTrue(FILE_UTILS.toURI(".\\foo").endsWith("/foo"));
+            assertEquals("file:/" + dosRoot + "foo%20bar", removeExtraneousAuthority(FILE_UTILS.toURI("\\foo bar")));
+            assertEquals("file:/" + dosRoot + "foo%23bar", removeExtraneousAuthority(FILE_UTILS.toURI("\\foo#bar")));
+        }
+        // a test with ant for germans
+        // the escaped character used for the test is the "a umlaut"
+        // this is the fix for the bug 37348
+        assertEquals("file:/" + dosRoot + "%C3%A4nt", removeExtraneousAuthority(FILE_UTILS.toURI("/\u00E4nt")));
+    }
+
+    /**
+     * Authority field is unnecessary, but harmless, in file: URIs.
+     * Java 1.4 does not produce it when using File.toURI.
+     */
+    private static String removeExtraneousAuthority(String uri) {
+        String prefix = "file:///";
+        if (uri.startsWith(prefix)) {
+            return "file:/" + uri.substring(prefix.length());
+        } else {
+            return uri;
+        }
+    }
+
+    @Test
+    public void testIsContextRelativePath() {
+        assumeTrue("Test only runs on DOS", Os.isFamily("dos"));
+        assertTrue(FileUtils.isContextRelativePath("/\u00E4nt"));
+        assertTrue(FileUtils.isContextRelativePath("\\foo"));
+    }
+
+    /**
+     * test fromUri
+     */
+    @Test
+    public void testFromURI() {
+        String dosRoot;
+        if (Os.isFamily("dos") || Os.isFamily("netware")) {
+            dosRoot = System.getProperty("user.dir").substring(0, 2);
+        } else {
+            dosRoot = "";
+        }
+        if (Os.isFamily("netware")) {
+            assertEqualsIgnoreDriveCase("SYS:\\foo", FILE_UTILS.fromURI("file:///sys:/foo"));
+        }
+        if (Os.isFamily("dos")) {
+            assertEqualsIgnoreDriveCase("C:\\foo", FILE_UTILS.fromURI("file:///c:/foo"));
+        }
+        assertEqualsIgnoreDriveCase(dosRoot + File.separator + "foo", FILE_UTILS.fromURI("file:///foo"));
+        assertEquals("." + File.separator + "foo",
+                     FILE_UTILS.fromURI("file:./foo"));
+        assertEquals(dosRoot + File.separator + "foo bar", FILE_UTILS.fromURI("file:///foo%20bar"));
+        assertEquals(dosRoot + File.separator + "foo#bar", FILE_UTILS.fromURI("file:///foo%23bar"));
+    }
+
+    @Test
+    public void testModificationTests() {
+
+        //get a time
+        long firstTime=System.currentTimeMillis();
+        //add some time. We assume no OS has a granularity this bad
+        long secondTime=firstTime+60000;
+/*
+        assertTrue("same timestamp is up to date",
+                fu.isUpToDate(firstTime, firstTime));
+                */
+
+        //check that older is up to date with a newer dest
+        assertTrue("older source files are up to date",
+                FILE_UTILS.isUpToDate(firstTime,secondTime));
+        //check that older is up to date with a newer dest
+        assertFalse("newer source files are no up to date",
+                FILE_UTILS.isUpToDate(secondTime, firstTime));
+
+        assertTrue("-1 dest timestamp implies nonexistence",
+                !FILE_UTILS.isUpToDate(firstTime,-1L));
+    }
+
+    @Test
+    public void testHasErrorInCase() {
+        File tempFolder = new File(System.getProperty("java.io.tmpdir"));
+        File wellcased = FILE_UTILS.createTempFile("alpha", "beta", tempFolder,
+                                                   true, true);
+        String s = wellcased.getName().toUpperCase();
+        File wrongcased = new File(tempFolder, s);
+        if (Os.isFamily("mac") && Os.isFamily("unix")) {
+            //no guarantees on filesystem case-sensitivity
+        } else if (Os.isFamily("dos")) {
+            assertTrue(FILE_UTILS.hasErrorInCase(wrongcased));
+            assertFalse(FILE_UTILS.hasErrorInCase(wellcased));
+        } else {
+            assertFalse(FILE_UTILS.hasErrorInCase(wrongcased));
+            assertFalse(FILE_UTILS.hasErrorInCase(wellcased));
+        }
+
+    }
+    public void testGetDefaultEncoding() {
+        // This just tests that the function does not blow up
+        FILE_UTILS.getDefaultEncoding();
+    }
+
+    /**
+     * adapt file separators to local conventions
+     */
+    private String localize(String path) {
+        path = root + path.substring(1);
+        return path.replace('\\', File.separatorChar).replace('/', File.separatorChar);
+    }
+
+    /**
+     * convenience method
+     * normalize brings the drive in uppercase
+     * the drive letter is in lower case under cygwin
+     * calling this method allows tests where normalize is called to pass under cygwin
+     */
+    private void assertEqualsIgnoreDriveCase(String s1, String s2) {
+        if ((Os.isFamily("dos") || Os.isFamily("netware"))
+            && s1.length() > 0 && s2.length() > 0) {
+            StringBuilder sb1 = new StringBuilder(s1);
+            StringBuilder sb2 = new StringBuilder(s2);
+            sb1.setCharAt(0, Character.toUpperCase(s1.charAt(0)));
+            sb2.setCharAt(0, Character.toUpperCase(s2.charAt(0)));
+            assertEquals(sb1.toString(), sb2.toString());
+        } else {
+            assertEquals(s1, s2);
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/ant/blob/0ed7f4ab/src/tests/junit/org/apache/tools/ant/util/GlobPatternMapperTest.java
----------------------------------------------------------------------
diff --git a/src/tests/junit/org/apache/tools/ant/util/GlobPatternMapperTest.java b/src/tests/junit/org/apache/tools/ant/util/GlobPatternMapperTest.java
index 25af0e1..5bd7db6 100644
--- a/src/tests/junit/org/apache/tools/ant/util/GlobPatternMapperTest.java
+++ b/src/tests/junit/org/apache/tools/ant/util/GlobPatternMapperTest.java
@@ -1,102 +1,102 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one or more
- *  contributor license agreements.  See the NOTICE file distributed with
- *  this work for additional information regarding copyright ownership.
- *  The ASF licenses this file to You under the Apache License, Version 2.0
- *  (the "License"); you may not use this file except in compliance with
- *  the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-package org.apache.tools.ant.util;
-
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-
-/**
- * Tests for org.apache.tools.ant.util;GlobPatternMapper.
- *
- */
-public class GlobPatternMapperTest {
-
-    @Test
-    public void testNoPatternAtAll() {
-        GlobPatternMapper m = new GlobPatternMapper();
-        m.setFrom("foobar");
-        m.setTo("baz");
-        assertNull("Shouldn\'t match foobar", m.mapFileName("plonk"));
-        String[] result = m.mapFileName("foobar");
-        assertNotNull("Should match foobar", result);
-        assertEquals("only one result for foobar", 1, result.length);
-        assertEquals("baz", result[0]);
-    }
-
-    @Test
-    public void testPostfixOnly() {
-        GlobPatternMapper m = new GlobPatternMapper();
-        m.setFrom("*foo");
-        m.setTo("*plonk");
-        assertNull("Shouldn\'t match *foo", m.mapFileName("bar.baz"));
-        String[] result = m.mapFileName("bar.foo");
-        assertNotNull("Should match *.foo", result);
-        assertEquals("only one result for bar.foo", 1, result.length);
-        assertEquals("bar.plonk", result[0]);
-
-        // Try a silly case
-        m.setTo("foo*");
-        result = m.mapFileName("bar.foo");
-        assertEquals("foobar.", result[0]);
-    }
-
-    @Test
-    public void testPrefixOnly() {
-        GlobPatternMapper m = new GlobPatternMapper();
-        m.setFrom("foo*");
-        m.setTo("plonk*");
-        assertNull("Shouldn\'t match foo*", m.mapFileName("bar.baz"));
-        String[] result = m.mapFileName("foo.bar");
-        assertNotNull("Should match foo*", result);
-        assertEquals("only one result for foo.bar", 1, result.length);
-        assertEquals("plonk.bar", result[0]);
-
-        // Try a silly case
-        m.setTo("*foo");
-        result = m.mapFileName("foo.bar");
-        assertEquals(".barfoo", result[0]);
-    }
-
-    @Test
-    public void testPreAndPostfix() {
-        GlobPatternMapper m = new GlobPatternMapper();
-        m.setFrom("foo*bar");
-        m.setTo("plonk*pling");
-        assertNull("Shouldn\'t match foo*bar", m.mapFileName("bar.baz"));
-        String[] result = m.mapFileName("foo.bar");
-        assertNotNull("Should match foo*bar", result);
-        assertEquals("only one result for foo.bar", 1, result.length);
-        assertEquals("plonk.pling", result[0]);
-
-        // and a little longer
-        result = m.mapFileName("foo.baz.bar");
-        assertNotNull("Should match foo*bar", result);
-        assertEquals("only one result for foo.baz.bar", 1, result.length);
-        assertEquals("plonk.baz.pling", result[0]);
-
-        // and a little shorter
-        result = m.mapFileName("foobar");
-        assertNotNull("Should match foo*bar", result);
-        assertEquals("only one result for foobar", 1, result.length);
-        assertEquals("plonkpling", result[0]);
-    }
-}
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one or more
+ *  contributor license agreements.  See the NOTICE file distributed with
+ *  this work for additional information regarding copyright ownership.
+ *  The ASF licenses this file to You under the Apache License, Version 2.0
+ *  (the "License"); you may not use this file except in compliance with
+ *  the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ */
+
+package org.apache.tools.ant.util;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+
+/**
+ * Tests for org.apache.tools.ant.util;GlobPatternMapper.
+ *
+ */
+public class GlobPatternMapperTest {
+
+    @Test
+    public void testNoPatternAtAll() {
+        GlobPatternMapper m = new GlobPatternMapper();
+        m.setFrom("foobar");
+        m.setTo("baz");
+        assertNull("Shouldn\'t match foobar", m.mapFileName("plonk"));
+        String[] result = m.mapFileName("foobar");
+        assertNotNull("Should match foobar", result);
+        assertEquals("only one result for foobar", 1, result.length);
+        assertEquals("baz", result[0]);
+    }
+
+    @Test
+    public void testPostfixOnly() {
+        GlobPatternMapper m = new GlobPatternMapper();
+        m.setFrom("*foo");
+        m.setTo("*plonk");
+        assertNull("Shouldn\'t match *foo", m.mapFileName("bar.baz"));
+        String[] result = m.mapFileName("bar.foo");
+        assertNotNull("Should match *.foo", result);
+        assertEquals("only one result for bar.foo", 1, result.length);
+        assertEquals("bar.plonk", result[0]);
+
+        // Try a silly case
+        m.setTo("foo*");
+        result = m.mapFileName("bar.foo");
+        assertEquals("foobar.", result[0]);
+    }
+
+    @Test
+    public void testPrefixOnly() {
+        GlobPatternMapper m = new GlobPatternMapper();
+        m.setFrom("foo*");
+        m.setTo("plonk*");
+        assertNull("Shouldn\'t match foo*", m.mapFileName("bar.baz"));
+        String[] result = m.mapFileName("foo.bar");
+        assertNotNull("Should match foo*", result);
+        assertEquals("only one result for foo.bar", 1, result.length);
+        assertEquals("plonk.bar", result[0]);
+
+        // Try a silly case
+        m.setTo("*foo");
+        result = m.mapFileName("foo.bar");
+        assertEquals(".barfoo", result[0]);
+    }
+
+    @Test
+    public void testPreAndPostfix() {
+        GlobPatternMapper m = new GlobPatternMapper();
+        m.setFrom("foo*bar");
+        m.setTo("plonk*pling");
+        assertNull("Shouldn\'t match foo*bar", m.mapFileName("bar.baz"));
+        String[] result = m.mapFileName("foo.bar");
+        assertNotNull("Should match foo*bar", result);
+        assertEquals("only one result for foo.bar", 1, result.length);
+        assertEquals("plonk.pling", result[0]);
+
+        // and a little longer
+        result = m.mapFileName("foo.baz.bar");
+        assertNotNull("Should match foo*bar", result);
+        assertEquals("only one result for foo.baz.bar", 1, result.length);
+        assertEquals("plonk.baz.pling", result[0]);
+
+        // and a little shorter
+        result = m.mapFileName("foobar");
+        assertNotNull("Should match foo*bar", result);
+        assertEquals("only one result for foobar", 1, result.length);
+        assertEquals("plonkpling", result[0]);
+    }
+}

http://git-wip-us.apache.org/repos/asf/ant/blob/0ed7f4ab/src/tests/junit/org/apache/tools/ant/util/JAXPUtilsTest.java
----------------------------------------------------------------------
diff --git a/src/tests/junit/org/apache/tools/ant/util/JAXPUtilsTest.java b/src/tests/junit/org/apache/tools/ant/util/JAXPUtilsTest.java
index f21be8a..105c33d 100644
--- a/src/tests/junit/org/apache/tools/ant/util/JAXPUtilsTest.java
+++ b/src/tests/junit/org/apache/tools/ant/util/JAXPUtilsTest.java
@@ -1,43 +1,43 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one or more
- *  contributor license agreements.  See the NOTICE file distributed with
- *  this work for additional information regarding copyright ownership.
- *  The ASF licenses this file to You under the Apache License, Version 2.0
- *  (the "License"); you may not use this file except in compliance with
- *  the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-package org.apache.tools.ant.util;
-
-import org.junit.Test;
-
-import java.io.File;
-
-import static org.junit.Assert.assertTrue;
-
-/**
- * JAXPUtils test case
- */
-public class JAXPUtilsTest {
-
-    @Test
-    public void testGetSystemId(){
-        File file = null;
-        if ( File.separatorChar == '\\' ){
-            file = new File("d:\\jdk");
-        } else {
-            file = new File("/user/local/bin");
-        }
-        String systemid = JAXPUtils.getSystemId(file);
-        assertTrue("SystemIDs should start by file:/", systemid.startsWith("file:/"));
-        assertTrue("SystemIDs should not start with file:////", !systemid.startsWith("file:////"));
-    }
-}
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one or more
+ *  contributor license agreements.  See the NOTICE file distributed with
+ *  this work for additional information regarding copyright ownership.
+ *  The ASF licenses this file to You under the Apache License, Version 2.0
+ *  (the "License"); you may not use this file except in compliance with
+ *  the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ */
+package org.apache.tools.ant.util;
+
+import org.junit.Test;
+
+import java.io.File;
+
+import static org.junit.Assert.assertTrue;
+
+/**
+ * JAXPUtils test case
+ */
+public class JAXPUtilsTest {
+
+    @Test
+    public void testGetSystemId(){
+        File file = null;
+        if ( File.separatorChar == '\\' ){
+            file = new File("d:\\jdk");
+        } else {
+            file = new File("/user/local/bin");
+        }
+        String systemid = JAXPUtils.getSystemId(file);
+        assertTrue("SystemIDs should start by file:/", systemid.startsWith("file:/"));
+        assertTrue("SystemIDs should not start with file:////", !systemid.startsWith("file:////"));
+    }
+}

http://git-wip-us.apache.org/repos/asf/ant/blob/0ed7f4ab/src/tests/junit/org/apache/tools/ant/util/JavaEnvUtilsTest.java
----------------------------------------------------------------------
diff --git a/src/tests/junit/org/apache/tools/ant/util/JavaEnvUtilsTest.java b/src/tests/junit/org/apache/tools/ant/util/JavaEnvUtilsTest.java
index 80a92a9..cc786ca 100644
--- a/src/tests/junit/org/apache/tools/ant/util/JavaEnvUtilsTest.java
+++ b/src/tests/junit/org/apache/tools/ant/util/JavaEnvUtilsTest.java
@@ -138,7 +138,7 @@ public class JavaEnvUtilsTest {
                 "Current java version is not at least the current java version...",
                 JavaEnvUtils.isAtLeastJavaVersion(JavaEnvUtils.getJavaVersion()));
     }
-  
+
     @Test
     public void isJavaVersionSupportsBothVersionsOfJava9() {
         assumeTrue(JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_9));


Mime
View raw message