| /******************************************************************************* |
| * Copyright (c) 2000, 2012 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.core.tests.runtime; |
| |
| import java.net.MalformedURLException; |
| import java.util.ArrayList; |
| import junit.framework.Test; |
| import junit.framework.TestSuite; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.Path; |
| |
| /** |
| * Test cases for the Path class. |
| */ |
| public class PathTest extends RuntimeTest { |
| /** Constant value indicating if the current platform is Windows */ |
| private static final boolean WINDOWS = java.io.File.separatorChar == '\\'; |
| |
| /** |
| * Need a zero argument constructor to satisfy the test harness. |
| * This constructor should not do any real work nor should it be |
| * called by user code. |
| */ |
| public PathTest() { |
| super(null); |
| } |
| |
| public PathTest(String name) { |
| super(name); |
| } |
| |
| public static Test suite() { |
| |
| return new TestSuite(PathTest.class); |
| |
| // TestSuite suite= new TestSuite(); |
| // suite.addTest(new PathTest("testCanonicalize")); |
| // return suite; |
| } |
| |
| public void testAddTrailingSeparator() { |
| |
| IPath with = new Path("/first/second/third/"); |
| IPath without = new Path("/first/second/third"); |
| |
| assertSame("1.0", with, with.addTrailingSeparator()); |
| assertEquals("1.1", with, without.addTrailingSeparator()); |
| assertTrue("1.2", without.equals(without.addTrailingSeparator())); |
| |
| assertSame("2.0", Path.ROOT, Path.ROOT.addTrailingSeparator()); |
| assertEquals("2.1", Path.ROOT, Path.EMPTY.addTrailingSeparator()); |
| |
| with = new Path("//first/second/third/"); |
| without = new Path("//first/second/third"); |
| |
| assertSame("3.0", with, with.addTrailingSeparator()); |
| assertEquals("3.1", with, without.addTrailingSeparator()); |
| assertTrue("3.2", without.equals(without.addTrailingSeparator())); |
| |
| assertSame("4.0", Path.ROOT, Path.ROOT.addTrailingSeparator()); |
| assertEquals("4.1", Path.ROOT, Path.EMPTY.addTrailingSeparator()); |
| |
| with = new Path("c:/first/second/third/"); |
| without = new Path("c:/first/second/third"); |
| |
| assertSame("5.0", with, with.addTrailingSeparator()); |
| assertEquals("5.1", with, without.addTrailingSeparator()); |
| assertTrue("5.2", without.equals(without.addTrailingSeparator())); |
| |
| assertSame("6.0", Path.ROOT, Path.ROOT.addTrailingSeparator()); |
| assertEquals("6.1", Path.ROOT, Path.EMPTY.addTrailingSeparator()); |
| } |
| |
| public void testAppend() { |
| |
| IPath fore = new Path("/first/second/third/"); |
| String aftString = "/fourth/fifth"; |
| IPath aft = new Path(aftString); |
| IPath combo = new Path("/first/second/third/fourth/fifth"); |
| |
| assertEquals("1.0", combo, fore.append(aft)); |
| assertEquals("1.1", combo, fore.removeTrailingSeparator().append(aft)); |
| assertEquals("1.2", combo, Path.ROOT.append(fore).append(aft)); |
| assertTrue("1.3", !fore.append(aft).hasTrailingSeparator()); |
| assertTrue("1.4", !Path.ROOT.append(fore).append(aft).hasTrailingSeparator()); |
| assertTrue("1.5", !fore.removeTrailingSeparator().append(aft).hasTrailingSeparator()); |
| |
| assertEquals("2.0", combo, fore.append(aftString)); |
| assertEquals("2.1", combo, fore.removeTrailingSeparator().append(aftString)); |
| assertEquals("2.2", combo, Path.ROOT.append(fore).append(aftString)); |
| assertTrue("2.3", !fore.append(aftString).hasTrailingSeparator()); |
| assertTrue("2.4", !Path.ROOT.append(fore).append(aftString).hasTrailingSeparator()); |
| assertTrue("2.5", !fore.removeTrailingSeparator().append(aftString).hasTrailingSeparator()); |
| |
| //ensure append preserves correct trailing separator |
| assertTrue("3.0", !fore.append("aft").hasTrailingSeparator()); |
| assertTrue("3.1", fore.append("aft/").hasTrailingSeparator()); |
| assertTrue("3.2", !fore.append("/aft").hasTrailingSeparator()); |
| assertTrue("3.3", fore.append("/aft/").hasTrailingSeparator()); |
| assertTrue("3.4", !fore.append("\\aft").hasTrailingSeparator()); |
| //backslash is a trailing separator on windows only |
| assertTrue("3.5", fore.append("aft\\").hasTrailingSeparator() == WINDOWS); |
| assertTrue("3.6", !fore.append("fourth/fifth").hasTrailingSeparator()); |
| assertTrue("3.7", fore.append("fourth/fifth/").hasTrailingSeparator()); |
| assertTrue("3.8", !fore.append(new Path("aft")).hasTrailingSeparator()); |
| assertTrue("3.9", fore.append(new Path("aft/")).hasTrailingSeparator()); |
| assertTrue("3.10", !fore.append(new Path("fourth/fifth")).hasTrailingSeparator()); |
| assertTrue("3.11", fore.append(new Path("fourth/fifth/")).hasTrailingSeparator()); |
| |
| //make sure append converts slashes appropriately |
| if (WINDOWS) { |
| aftString = "fourth\\fifth"; |
| assertEquals("4.0", combo, fore.append(aftString)); |
| assertEquals("4.1", combo, fore.removeTrailingSeparator().append(aftString)); |
| assertEquals("4.2", combo, Path.ROOT.append(fore).append(aftString)); |
| } |
| |
| assertEquals("5.0", new Path("/foo"), Path.ROOT.append("../foo")); |
| assertEquals("5.1", new Path("/foo"), Path.ROOT.append("./foo")); |
| assertEquals("5.2", new Path("c:/foo/xyz"), new Path("c:/foo/bar").append("../xyz")); |
| assertEquals("5.3", new Path("c:/foo/bar/xyz"), new Path("c:/foo/bar").append("./xyz")); |
| |
| //append preserves device and leading separator of receiver |
| if (WINDOWS) { |
| assertEquals("6.1", new Path("c:foo/bar"), new Path("c:").append("/foo/bar")); |
| assertEquals("6.2", new Path("c:foo/bar"), new Path("c:").append("foo/bar")); |
| assertEquals("6.3", new Path("c:/foo/bar"), new Path("c:/").append("/foo/bar")); |
| assertEquals("6.4", new Path("c:/foo/bar"), new Path("c:/").append("foo/bar")); |
| assertEquals("6.5", new Path("c:foo/bar"), new Path("c:").append("z:/foo/bar")); |
| assertEquals("6.6", new Path("c:foo/bar"), new Path("c:").append("z:foo/bar")); |
| assertEquals("6.7", new Path("c:/foo/bar"), new Path("c:/").append("z:/foo/bar")); |
| assertEquals("6.8", new Path("c:/foo/bar"), new Path("c:/").append("z:foo/bar")); |
| assertEquals("6.9", new Path("c:/foo"), new Path("c:/").append("z:foo")); |
| } else { |
| assertEquals("6.1", new Path("c:/foo/bar"), new Path("c:").append("/foo/bar")); |
| assertEquals("6.2", new Path("c:/foo/bar/"), new Path("c:").append("foo/bar/")); |
| assertEquals("6.3", new Path("/c:/foo/bar"), new Path("/c:").append("/foo/bar")); |
| assertEquals("6.4", new Path("/c:/foo/bar"), new Path("/c:").append("foo/bar")); |
| } |
| |
| assertEquals("6.10", new Path("foo/bar"), new Path("foo").append(new Path("/bar"))); |
| assertEquals("6.11", new Path("foo/bar"), new Path("foo").append(new Path("bar"))); |
| assertEquals("6.12", new Path("/foo/bar"), new Path("/foo/").append(new Path("/bar"))); |
| assertEquals("6.13", new Path("/foo/bar"), new Path("/foo/").append(new Path("bar"))); |
| |
| assertEquals("6.14", new Path("foo/bar/"), new Path("foo").append(new Path("/bar/"))); |
| assertEquals("6.15", new Path("foo/bar/"), new Path("foo").append(new Path("bar/"))); |
| assertEquals("6.16", new Path("/foo/bar/"), new Path("/foo/").append(new Path("/bar/"))); |
| assertEquals("6.17", new Path("/foo/bar/"), new Path("/foo/").append(new Path("bar/"))); |
| |
| //append preserves isUNC of receiver |
| assertEquals("7.0", new Path("/foo/bar"), new Path("/foo").append("//bar")); |
| assertEquals("7.1", new Path("/foo/bar/test"), new Path("/foo").append("bar//test")); |
| assertEquals("7.2", new Path("//foo/bar"), new Path("//foo").append("bar")); |
| assertEquals("7.3", new Path("/bar"), Path.ROOT.append("//bar")); |
| |
| //append empty path does nothing |
| assertEquals("8.0", fore, fore.append(Path.ROOT)); |
| assertEquals("8.1", fore, fore.append(Path.EMPTY)); |
| assertEquals("8.2", fore, fore.append(new Path("//"))); |
| assertEquals("8.3", fore, fore.append(new Path("/"))); |
| assertEquals("8.4", fore, fore.append(new Path(""))); |
| assertEquals("8.5", fore, fore.append("//")); |
| assertEquals("8.6", fore, fore.append("/")); |
| assertEquals("8.7", fore, fore.append("")); |
| if (WINDOWS) { |
| assertEquals("8.8", fore, fore.append("c://")); |
| assertEquals("8.9", fore, fore.append("c:/")); |
| assertEquals("8.10", fore, fore.append("c:")); |
| } |
| } |
| |
| public void testSegmentCount() { |
| |
| assertEquals("1.0", 0, Path.ROOT.segmentCount()); |
| assertEquals("1.1", 0, Path.EMPTY.segmentCount()); |
| |
| assertEquals("2.0", 1, new Path("/first").segmentCount()); |
| assertEquals("2.1", 1, new Path("/first/").segmentCount()); |
| assertEquals("2.2", 3, new Path("/first/second/third/").segmentCount()); |
| assertEquals("2.3", 3, new Path("/first/second/third").segmentCount()); |
| assertEquals("2.4", 5, new Path("/first/second/third/fourth/fifth").segmentCount()); |
| |
| assertEquals("3.0", 0, new Path("//").segmentCount()); |
| assertEquals("3.1", 1, new Path("//first").segmentCount()); |
| assertEquals("3.2", 1, new Path("//first/").segmentCount()); |
| assertEquals("3.3", 2, new Path("//first/second").segmentCount()); |
| assertEquals("3.4", 2, new Path("//first/second/").segmentCount()); |
| } |
| |
| public void testCanonicalize() { |
| // Test collapsing multiple separators |
| // double slashes at the beginning of a path |
| // are left and assumed to be a UNC path |
| assertEquals("//", new Path("///////").toString()); |
| assertEquals("/a/b/c", new Path("/a/b//c").toString()); |
| assertEquals("//a/b/c", new Path("//a/b//c").toString()); |
| assertEquals("a/b/c/", new Path("a/b//c//").toString()); |
| |
| // Test collapsing single dots |
| assertEquals("2.0", "/", new Path("/./././.").toString()); |
| assertEquals("2.1", "/a/b/c", new Path("/a/./././b/c").toString()); |
| assertEquals("2.2", "/a/b/c", new Path("/a/./b/c/.").toString()); |
| assertEquals("2.3", "a/b/c", new Path("a/./b/./c").toString()); |
| |
| // Test collapsing double dots |
| assertEquals("3.0", "/a/b", new Path("/a/b/c/..").toString()); |
| assertEquals("3.1", "/", new Path("/a/./b/../..").toString()); |
| assertEquals("3.2", "../", new Path("../").toString()); |
| // test bug 46043 - IPath collapseParentReferences |
| assertEquals("3.3", "../", new Path("./../").toString()); |
| assertEquals("3.4", "../", new Path(".././").toString()); |
| assertEquals("3.5", "..", new Path("./..").toString()); |
| assertEquals("3.6", ".", new Path(".").toString()); |
| } |
| |
| public void testClone() { |
| |
| IPath anyPath = new Path("/a/b/c"); |
| assertEquals("1.0", anyPath, anyPath.clone()); |
| anyPath = new Path("//a/b/c"); |
| assertEquals("1.1", anyPath, anyPath.clone()); |
| anyPath = new Path("c:/a/b/c"); |
| assertEquals("1.2", anyPath, anyPath.clone()); |
| |
| assertEquals("1.3", Path.ROOT, Path.ROOT.clone()); |
| } |
| |
| public void testConstructors() { |
| |
| assertEquals("1.0", "", new Path("").toString()); |
| assertEquals("1.1", "/", new Path("/").toString()); |
| assertEquals("1.2", "a", new Path("a").toString()); |
| assertEquals("1.3", "/a", new Path("/a").toString()); |
| assertEquals("1.4", "//", new Path("//").toString()); |
| assertEquals("1.5", "/a/", new Path("/a/").toString()); |
| assertEquals("1.6", "/a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u/v/w/x/y/z", new Path("/a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u/v/w/x/y/z").toString()); |
| assertEquals("1.7", "...", new Path("...").toString()); |
| assertEquals("1.8", "/a/b/.../c", new Path("/a/b/.../c").toString()); |
| |
| IPath anyPath = new Path("/first/second/third"); |
| |
| assertEquals("2.0", Path.EMPTY, new Path("")); |
| assertEquals("2.1", Path.ROOT, new Path("/")); |
| assertEquals("2.2", anyPath, anyPath); |
| |
| //should handle slash before the device (see bug 84697) |
| try { |
| if (WINDOWS) { |
| assertEquals("3.0", "D:/foo/abc.txt", new Path(new java.io.File("D:\\foo\\abc.txt").toURL().getPath()).toString()); |
| assertEquals("3.1", "D:/", new Path(new java.io.File("D:/").toURL().getPath()).toString()); |
| } |
| } catch (MalformedURLException e) { |
| fail("4.99", e); |
| } |
| } |
| |
| public void testFirstSegment() { |
| |
| assertNull("1.0", Path.ROOT.segment(0)); |
| assertNull("1.1", Path.EMPTY.segment(0)); |
| |
| assertEquals("2.0", "a", new Path("/a/b/c").segment(0)); |
| assertEquals("2.1", "a", new Path("a").segment(0)); |
| assertEquals("2.2", "a", new Path("/a").segment(0)); |
| assertEquals("2.3", "a", new Path("a/b").segment(0)); |
| assertEquals("2.4", "a", new Path("//a/b").segment(0)); |
| if (WINDOWS) { |
| assertEquals("2.5", "a", new Path("c:a/b").segment(0)); |
| assertEquals("2.6", "a", new Path("c:/a/b").segment(0)); |
| } else { |
| assertEquals("2.5", "c:", new Path("c:/a/b").segment(0)); |
| assertEquals("2.6", "c:", new Path("c:/a\\b").segment(0)); |
| assertEquals("2.5", "a", new Path("a/c:/b").segment(0)); |
| assertEquals("2.6", "a\\b", new Path("a\\b/b").segment(0)); |
| } |
| |
| } |
| |
| public void testFromPortableString() { |
| assertEquals("1.0", "", Path.fromPortableString("").toString()); |
| assertEquals("1.1", "/", Path.fromPortableString("/").toString()); |
| assertEquals("1.2", "a", Path.fromPortableString("a").toString()); |
| assertEquals("1.3", "/a", Path.fromPortableString("/a").toString()); |
| assertEquals("1.4", "//", Path.fromPortableString("//").toString()); |
| assertEquals("1.5", "/a/", Path.fromPortableString("/a/").toString()); |
| |
| assertEquals("2.1", "a:", Path.fromPortableString("a:").toString()); |
| assertEquals("2.2", "a:", Path.fromPortableString("a::").toString()); |
| assertEquals("2.3", "a:b:", Path.fromPortableString("a:b::").toString()); |
| assertEquals("2.4", "a/b:c", Path.fromPortableString("a/b::c").toString()); |
| assertEquals("2.5", "a/b:c", Path.fromPortableString("a/b:c").toString()); |
| assertEquals("2.6", "a:b", Path.fromPortableString("a::b").toString()); |
| |
| } |
| |
| public void testGetFileExtension() { |
| |
| IPath anyPath = new Path("index.html"); |
| assertEquals("1.0", anyPath.getFileExtension(), "html"); |
| |
| assertNull("2.0", Path.ROOT.getFileExtension()); |
| assertNull("2.1", Path.EMPTY.getFileExtension()); |
| assertNull("2.2", new Path("index").getFileExtension()); |
| assertNull("2.3", new Path("/a/b/c.txt/").getFileExtension()); |
| |
| assertEquals("3.0", "txt", new Path("/a/b/c.txt").getFileExtension()); |
| assertEquals("3.1", "txt", new Path("/a/b/c.foo.txt").getFileExtension()); |
| assertEquals("3.2", "txt", new Path("//a/b/c.foo.txt").getFileExtension()); |
| assertEquals("3.3", "txt", new Path("c:/a/b/c.foo.txt").getFileExtension()); |
| assertEquals("3.4", "txt", new Path("c:a/b/c.foo.txt").getFileExtension()); |
| |
| } |
| |
| public void testHasTrailingSeparator() { |
| |
| // positive |
| assertTrue("1.0", new Path("/first/second/third/").hasTrailingSeparator()); |
| assertTrue("1.1", new Path("//first/second/third/").hasTrailingSeparator()); |
| assertTrue("1.2", new Path("c:/first/second/third/").hasTrailingSeparator()); |
| assertTrue("1.3", new Path("c:first/second/third/").hasTrailingSeparator()); |
| |
| // negative |
| assertTrue("2.0", !new Path("first/second/third").hasTrailingSeparator()); |
| assertTrue("2.1", !Path.ROOT.hasTrailingSeparator()); |
| assertTrue("2.2", !Path.EMPTY.hasTrailingSeparator()); |
| assertTrue("2.3", !new Path("//first/second/third").hasTrailingSeparator()); |
| assertTrue("2.4", !new Path("c:/first/second/third").hasTrailingSeparator()); |
| assertTrue("2.5", !new Path("c:first/second/third").hasTrailingSeparator()); |
| |
| //paths of length 0 never have a trailing separator |
| assertTrue("3.0", !new Path("/first/").removeLastSegments(1).hasTrailingSeparator()); |
| assertTrue("3.1", !new Path("/first/").removeFirstSegments(1).hasTrailingSeparator()); |
| assertTrue("3.2", !new Path("/").hasTrailingSeparator()); |
| assertTrue("3.3", !new Path("/first/").append("..").hasTrailingSeparator()); |
| assertTrue("3.4", !new Path("/first/").append(new Path("..")).hasTrailingSeparator()); |
| assertTrue("3.5", !new Path("/first/../").hasTrailingSeparator()); |
| assertTrue("3.6", !Path.ROOT.addTrailingSeparator().hasTrailingSeparator()); |
| assertTrue("3.7", !Path.EMPTY.addTrailingSeparator().hasTrailingSeparator()); |
| |
| } |
| |
| public void testIsAbsolute() { |
| |
| // positive |
| assertTrue("1.0", new Path("/first/second/third").isAbsolute()); |
| assertTrue("1.1", Path.ROOT.isAbsolute()); |
| assertTrue("1.2", new Path("//first/second/third").isAbsolute()); |
| if (WINDOWS) { |
| assertTrue("1.3", new Path("c:/first/second/third").isAbsolute()); |
| } else { |
| assertTrue("1.3", new Path("/c:first/second/third").isAbsolute()); |
| } |
| |
| // negative |
| assertTrue("2.0", !new Path("first/second/third").isAbsolute()); |
| assertTrue("2.1", !Path.EMPTY.isAbsolute()); |
| assertTrue("2.2", !new Path("c:first/second/third").isAbsolute()); |
| |
| // unc |
| if (WINDOWS) { |
| assertTrue("3.0", new Path("c://").isAbsolute()); |
| } else { |
| assertTrue("3.0", new Path("//c:/").isAbsolute()); |
| } |
| assertTrue("3.1", new Path("//").isAbsolute()); |
| assertTrue("3.2", new Path("//a").isAbsolute()); |
| assertTrue("3.3", new Path("//a/b/").isAbsolute()); |
| |
| } |
| |
| public void testIsEmpty() { |
| |
| // positive |
| assertTrue("1.0", Path.EMPTY.isEmpty()); |
| assertTrue("1.1", new Path("//").isEmpty()); |
| assertTrue("1.2", new Path("").isEmpty()); |
| assertTrue("1.1", new Path("c:").isEmpty() == WINDOWS); |
| |
| // negative |
| assertTrue("2.0", !new Path("first/second/third").isEmpty()); |
| assertTrue("2.1", !Path.ROOT.isEmpty()); |
| assertTrue("2.2", !new Path("//a").isEmpty()); |
| assertTrue("2.3", !new Path("c:/").isEmpty()); |
| } |
| |
| public void testIsPrefixOf() { |
| |
| IPath prefix = new Path("/first/second"); |
| IPath path = new Path("/first/second/third/fourth"); |
| |
| assertTrue("1.0", prefix.isPrefixOf(path)); |
| // test the case where the arg is longer than the receiver. |
| assertTrue("1.1", !path.isPrefixOf(prefix)); |
| assertTrue("1.2", !new Path("fifth/sixth").isPrefixOf(path)); |
| |
| assertTrue("2.0", prefix.addTrailingSeparator().isPrefixOf(path)); |
| |
| assertTrue("3.0", Path.ROOT.isPrefixOf(path)); |
| assertTrue("3.1", Path.EMPTY.isPrefixOf(path)); |
| assertTrue("3.2", !path.isPrefixOf(Path.ROOT)); |
| assertTrue("3.3", !path.isPrefixOf(Path.EMPTY)); |
| } |
| |
| public void testIsRoot() { |
| |
| // negative |
| assertTrue("1.0", !new Path("/first/second").isRoot()); |
| assertTrue("1.1", !Path.EMPTY.isRoot()); |
| assertTrue("1.2", !new Path("//").isRoot()); |
| |
| // positive |
| assertTrue("2.0", Path.ROOT.isRoot()); |
| assertTrue("2.1", new Path("/").isRoot()); |
| } |
| |
| public void testIsUNC() { |
| |
| // negative |
| assertTrue("1.0", !Path.ROOT.isUNC()); |
| assertTrue("1.1", !Path.EMPTY.isUNC()); |
| |
| assertTrue("2.0", !new Path("a").isUNC()); |
| assertTrue("2.1", !new Path("a/b").isUNC()); |
| assertTrue("2.2", !new Path("/a").isUNC()); |
| assertTrue("2.3", !new Path("/a/b").isUNC()); |
| |
| assertTrue("3.0", !new Path("c:/a/b").isUNC()); |
| assertTrue("3.1", !new Path("c:a/b").isUNC()); |
| assertTrue("3.2", !new Path("/F/../").isUNC()); |
| |
| assertTrue("4.0", !new Path("c://a/").isUNC()); |
| assertTrue("4.1", !new Path("c:\\/a/b").isUNC()); |
| assertTrue("4.2", !new Path("c:\\\\").isUNC()); |
| |
| // positive |
| assertTrue("5.0", new Path("//").isUNC()); |
| assertTrue("5.1", new Path("//a").isUNC()); |
| assertTrue("5.2", new Path("//a/b").isUNC()); |
| if (WINDOWS) { |
| assertTrue("5.3", new Path("\\\\ThisMachine\\HOME\\foo.jar").isUNC()); |
| assertTrue("6.0", new Path("c://a/").setDevice(null).isUNC()); |
| assertTrue("6.1", new Path("c:\\/a/b").setDevice(null).isUNC()); |
| assertTrue("6.2", new Path("c:\\\\").setDevice(null).isUNC()); |
| } |
| } |
| |
| public void testIsValidPath() { |
| IPath test = Path.ROOT; |
| // positive |
| assertTrue("1.0", test.isValidPath("/first/second/third")); |
| assertTrue("1.1", test.isValidPath("")); |
| assertTrue("1.2", test.isValidPath("a")); |
| assertTrue("1.3", test.isValidPath("c:")); |
| assertTrue("1.4", test.isValidPath("//")); |
| assertTrue("1.5", test.isValidPath("//a")); |
| assertTrue("1.6", test.isValidPath("c:/a")); |
| assertTrue("1.7", test.isValidPath("c://a//b//c//d//e//f")); |
| assertTrue("1.8", test.isValidPath("//a//b//c//d//e//f")); |
| |
| // negative |
| if (WINDOWS) { |
| assertTrue("2.1", !test.isValidPath("c:b:")); |
| assertTrue("2.2", !test.isValidPath("c:a/b:")); |
| } |
| } |
| |
| public void testLastSegment() { |
| |
| assertEquals("1.0", "second", new Path("/first/second").lastSegment()); |
| |
| assertEquals("2.0", "first", new Path("first").lastSegment()); |
| assertEquals("2.1", "first", new Path("/first/").lastSegment()); |
| assertEquals("2.2", "second", new Path("first/second").lastSegment()); |
| assertEquals("2.3", "second", new Path("first/second/").lastSegment()); |
| |
| assertNull("3.0", Path.EMPTY.lastSegment()); |
| assertNull("3.1", Path.ROOT.lastSegment()); |
| assertNull("3.2", new Path("//").lastSegment()); |
| |
| assertEquals("4.0", "second", new Path("//first/second/").lastSegment()); |
| assertEquals("4.1", "second", new Path("//first/second").lastSegment()); |
| assertEquals("4.2", "second", new Path("c:/first/second/").lastSegment()); |
| assertEquals("4.3", "second", new Path("c:first/second/").lastSegment()); |
| |
| assertEquals("5.0", "first", new Path("//first").lastSegment()); |
| assertEquals("5.1", "first", new Path("//first/").lastSegment()); |
| } |
| |
| public void testMakeAbsolute() { |
| IPath anyPath = new Path("first/second/third").makeAbsolute(); |
| assertTrue("1.0", anyPath.isAbsolute()); |
| assertEquals("1.1", new Path("/first/second/third"), anyPath); |
| |
| anyPath = new Path("").makeAbsolute(); |
| assertTrue("2.0", anyPath.isAbsolute()); |
| assertEquals("2.1", Path.ROOT, anyPath); |
| } |
| |
| public void testMakeRelative() { |
| IPath anyPath = new Path("/first/second/third").makeRelative(); |
| assertTrue("1.0", !anyPath.isAbsolute()); |
| assertEquals("1.1", new Path("first/second/third"), anyPath); |
| |
| anyPath = Path.ROOT.makeRelative(); |
| assertTrue("2.0", !anyPath.isAbsolute()); |
| assertEquals("2.1", new Path(""), anyPath); |
| } |
| |
| /** |
| * Tests for {@link Path#makeRelativeTo(IPath)}. |
| */ |
| public void testMakeRelativeTo() { |
| //valid cases |
| IPath[] bases = new IPath[] {new Path("/a/"), new Path("/a/b")}; |
| IPath[] children = new IPath[] {new Path("/a/"), new Path("/a/b"), new Path("/a/b/c")}; |
| for (int i = 0; i < bases.length; i++) { |
| for (int j = 0; j < children.length; j++) { |
| final IPath base = bases[i]; |
| final IPath child = children[j]; |
| IPath result = child.makeRelativeTo(base); |
| assertTrue("1." + i + ',' + j, !result.isAbsolute()); |
| assertEquals("2." + i + ',' + j, base.append(result), child); |
| } |
| } |
| |
| //for equal/identical paths, the relative path should be empty |
| IPath equalBase = new Path("/a/b"); |
| assertEquals("3.1", "", new Path("/a/b").makeRelativeTo(equalBase).toString()); |
| assertEquals("3.2", "", new Path("/a/b/").makeRelativeTo(equalBase).toString()); |
| assertEquals("3.3", "", equalBase.makeRelativeTo(equalBase).toString()); |
| |
| //invalid cases (no common prefix) |
| bases = new IPath[] {new Path("/"), new Path("/b"), new Path("/b/c")}; |
| children = new IPath[] {new Path("/a/"), new Path("/a/b"), new Path("/a/b/c")}; |
| for (int i = 0; i < bases.length; i++) { |
| for (int j = 0; j < children.length; j++) { |
| final IPath base = bases[i]; |
| final IPath child = children[j]; |
| IPath result = child.makeRelativeTo(base); |
| assertTrue("6." + i + ',' + j, !result.isAbsolute()); |
| assertEquals("7." + i + ',' + j, base.append(result), child); |
| } |
| } |
| } |
| |
| /** |
| * Tests for {@link Path#makeRelativeTo(IPath)}. |
| */ |
| public void testMakeRelativeToWindows() { |
| if (!WINDOWS) |
| return; |
| IPath[] bases = new IPath[] {new Path("c:/a/"), new Path("c:/a/b")}; |
| IPath[] children = new IPath[] {new Path("d:/a/"), new Path("d:/a/b"), new Path("d:/a/b/c")}; |
| for (int i = 0; i < bases.length; i++) { |
| for (int j = 0; j < children.length; j++) { |
| final IPath base = bases[i]; |
| final IPath child = children[j]; |
| IPath result = child.makeRelativeTo(base); |
| assertTrue("1." + i + ',' + j, result.isAbsolute()); |
| assertEquals("2." + i + ',' + j, child, result); |
| } |
| } |
| |
| } |
| |
| public void testMakeUNC() { |
| ArrayList inputs = new ArrayList(); |
| ArrayList expected = new ArrayList(); |
| ArrayList expectedNon = new ArrayList(); |
| |
| inputs.add(Path.ROOT); |
| expected.add("//"); |
| expectedNon.add("/"); |
| |
| inputs.add(Path.EMPTY); |
| expected.add("//"); |
| expectedNon.add(""); |
| |
| inputs.add(new Path("a")); |
| expected.add("//a"); |
| expectedNon.add("a"); |
| |
| inputs.add(new Path("a/b")); |
| expected.add("//a/b"); |
| expectedNon.add("a/b"); |
| |
| inputs.add(new Path("/a/b/")); |
| expected.add("//a/b/"); |
| expectedNon.add("/a/b/"); |
| |
| inputs.add(new Path("//")); |
| expected.add("//"); |
| expectedNon.add("/"); |
| |
| inputs.add(new Path("//a")); |
| expected.add("//a"); |
| expectedNon.add("/a"); |
| |
| inputs.add(new Path("//a/b")); |
| expected.add("//a/b"); |
| expectedNon.add("/a/b"); |
| |
| inputs.add(new Path("//a/b/")); |
| expected.add("//a/b/"); |
| expectedNon.add("/a/b/"); |
| |
| inputs.add(new Path("c:", "/")); |
| expected.add("//"); |
| expectedNon.add("c:/"); |
| |
| inputs.add(new Path("c:", "")); |
| expected.add("//"); |
| expectedNon.add("c:"); |
| |
| inputs.add(new Path("c:", "a")); |
| expected.add("//a"); |
| expectedNon.add("c:a"); |
| |
| inputs.add(new Path("c:", "a/b")); |
| expected.add("//a/b"); |
| expectedNon.add("c:a/b"); |
| |
| inputs.add(new Path("c:", "/a")); |
| expected.add("//a"); |
| expectedNon.add("c:/a"); |
| |
| inputs.add(new Path("c:", "/a/b")); |
| expected.add("//a/b"); |
| expectedNon.add("c:/a/b"); |
| |
| assertEquals("0.0", inputs.size(), expected.size()); |
| assertEquals("0.1", inputs.size(), expectedNon.size()); |
| |
| for (int i = 0; i < inputs.size(); i++) { |
| IPath path = (IPath) inputs.get(i); |
| IPath result = path.makeUNC(true); |
| assertTrue("1.0." + path + " (" + result + ")", result.isUNC()); |
| assertEquals("1.1." + path, (String) expected.get(i), result.toString()); |
| result = path.makeUNC(false); |
| assertTrue("1.3." + path, !result.isUNC()); |
| assertEquals("1.4." + path, (String) expectedNon.get(i), result.toString()); |
| } |
| } |
| |
| /** |
| * This test is for bizarre cases that previously caused errors. |
| */ |
| public void testRegression() { |
| try { |
| new Path("C:\\/eclipse"); |
| } catch (Exception e) { |
| fail("1.0", e); |
| } |
| try { |
| if (WINDOWS) { |
| IPath path = new Path("d:\\\\ive"); |
| assertTrue("2.0", !path.isUNC()); |
| assertEquals("2.1", 1, path.segmentCount()); |
| assertEquals("2.2", "ive", path.segment(0)); |
| } |
| } catch (Exception e) { |
| fail("2.99", e); |
| } |
| |
| } |
| |
| public void testRemoveFirstSegments() { |
| assertEquals("1.0", new Path("second"), new Path("/first/second").removeFirstSegments(1)); |
| assertEquals("1.1", new Path("second/third/"), new Path("/first/second/third/").removeFirstSegments(1)); |
| assertEquals("1.2", Path.EMPTY, new Path("first").removeFirstSegments(1)); |
| assertEquals("1.3", Path.EMPTY, new Path("/first/").removeFirstSegments(1)); |
| assertEquals("1.4", new Path("second"), new Path("first/second").removeFirstSegments(1)); |
| assertEquals("1.5", Path.EMPTY, new Path("").removeFirstSegments(1)); |
| assertEquals("1.6", Path.EMPTY, Path.ROOT.removeFirstSegments(1)); |
| assertEquals("1.7", Path.EMPTY, new Path("/first/second/").removeFirstSegments(2)); |
| assertEquals("1.8", Path.EMPTY, new Path("/first/second/").removeFirstSegments(3)); |
| assertEquals("1.9", new Path("third/fourth"), new Path("/first/second/third/fourth").removeFirstSegments(2)); |
| |
| if (WINDOWS) { |
| assertEquals("2.0", new Path("c:second"), new Path("c:/first/second").removeFirstSegments(1)); |
| assertEquals("2.1", new Path("c:second/third/"), new Path("c:/first/second/third/").removeFirstSegments(1)); |
| assertEquals("2.2", new Path("c:"), new Path("c:first").removeFirstSegments(1)); |
| assertEquals("2.3", new Path("c:"), new Path("c:/first/").removeFirstSegments(1)); |
| assertEquals("2.4", new Path("c:second"), new Path("c:first/second").removeFirstSegments(1)); |
| assertEquals("2.5", new Path("c:"), new Path("c:").removeFirstSegments(1)); |
| assertEquals("2.6", new Path("c:"), new Path("c:/").removeFirstSegments(1)); |
| assertEquals("2.7", new Path("c:"), new Path("c:/first/second/").removeFirstSegments(2)); |
| assertEquals("2.8", new Path("c:"), new Path("c:/first/second/").removeFirstSegments(3)); |
| assertEquals("2.9", new Path("c:third/fourth"), new Path("c:/first/second/third/fourth").removeFirstSegments(2)); |
| } |
| |
| assertEquals("3.0", new Path("second"), new Path("//first/second").removeFirstSegments(1)); |
| assertEquals("3.1", new Path("second/third/"), new Path("//first/second/third/").removeFirstSegments(1)); |
| assertEquals("3.2", Path.EMPTY, new Path("//first/").removeFirstSegments(1)); |
| assertEquals("3.3", Path.EMPTY, new Path("//").removeFirstSegments(1)); |
| assertEquals("3.4", Path.EMPTY, new Path("//first/second/").removeFirstSegments(2)); |
| assertEquals("3.5", Path.EMPTY, new Path("//first/second/").removeFirstSegments(3)); |
| assertEquals("3.6", new Path("third/fourth"), new Path("//first/second/third/fourth").removeFirstSegments(2)); |
| } |
| |
| public void testRemoveLastSegments() { |
| |
| assertEquals("1.0", new Path("/first"), new Path("/first/second").removeLastSegments(1)); |
| assertEquals("1.1", new Path("//first"), new Path("//first/second").removeLastSegments(1)); |
| assertEquals("1.2", new Path("c:/first"), new Path("c:/first/second").removeLastSegments(1)); |
| assertEquals("1.3", new Path("c:first"), new Path("c:first/second").removeLastSegments(1)); |
| |
| assertEquals("2.0", new Path("/first/second/"), new Path("/first/second/third/").removeLastSegments(1)); |
| assertEquals("2.1", new Path("//first/second/"), new Path("//first/second/third/").removeLastSegments(1)); |
| assertEquals("2.2", new Path("c:/first/second/"), new Path("c:/first/second/third/").removeLastSegments(1)); |
| assertEquals("2.3", new Path("c:first/second/"), new Path("c:first/second/third/").removeLastSegments(1)); |
| |
| assertEquals("3.0", Path.EMPTY, new Path("first").removeLastSegments(1)); |
| assertEquals("3.1", Path.ROOT, new Path("/first/").removeLastSegments(1)); |
| assertEquals("3.2", new Path("first"), new Path("first/second").removeLastSegments(1)); |
| |
| assertEquals("4.0", Path.EMPTY, new Path("").removeLastSegments(1)); |
| assertEquals("4.1", Path.ROOT, Path.ROOT.removeLastSegments(1)); |
| assertEquals("4.2", new Path("//"), new Path("//").removeLastSegments(1)); |
| } |
| |
| public void testRemoveTrailingSeparator() { |
| |
| IPath with = new Path("/first/second/third/"); |
| IPath without = new Path("/first/second/third"); |
| |
| assertSame("1.0", without, without.removeTrailingSeparator()); |
| assertEquals("1.1", without, with.removeTrailingSeparator()); |
| // trailing separators have no bearing on path equality so check via |
| // other means.... |
| assertTrue("1.2", !with.removeTrailingSeparator().hasTrailingSeparator()); |
| assertTrue("1.3", !without.hasTrailingSeparator()); |
| assertEquals("1.4", without.toString(), with.removeTrailingSeparator().toString()); |
| |
| assertSame("2.0", Path.ROOT, Path.ROOT.removeTrailingSeparator()); |
| assertEquals("2.1", Path.EMPTY, new Path("").removeTrailingSeparator()); |
| |
| assertEquals("3.0", new Path("//"), new Path("//").removeTrailingSeparator()); |
| assertEquals("3.1", new Path("//a"), new Path("//a").removeTrailingSeparator()); |
| assertEquals("3.2", new Path("//a"), new Path("//a/").removeTrailingSeparator()); |
| assertEquals("3.3", new Path("//a/b"), new Path("//a/b").removeTrailingSeparator()); |
| assertEquals("3.4", new Path("//a/b"), new Path("//a/b/").removeTrailingSeparator()); |
| |
| assertEquals("4.0", new Path("c:"), new Path("c:").removeTrailingSeparator()); |
| assertEquals("4.1", new Path("c:/"), new Path("c:/").removeTrailingSeparator()); |
| assertEquals("4.2", new Path("c:/a"), new Path("c:/a/").removeTrailingSeparator()); |
| assertEquals("4.3", new Path("c:/a/b"), new Path("c:/a/b").removeTrailingSeparator()); |
| assertEquals("4.4", new Path("c:/a/b"), new Path("c:/a/b/").removeTrailingSeparator()); |
| |
| assertEquals("5.0", new Path("c:a"), new Path("c:a/").removeTrailingSeparator()); |
| assertEquals("5.1", new Path("c:a/b"), new Path("c:a/b").removeTrailingSeparator()); |
| assertEquals("5.2", new Path("c:a/b"), new Path("c:a/b/").removeTrailingSeparator()); |
| } |
| |
| public void testSegments() { |
| |
| IPath anyPath = null; |
| String[] segs = null; |
| |
| // Case One: typical case |
| anyPath = new Path("/first/second/third/fourth"); |
| segs = anyPath.segments(); |
| |
| assertEquals("1.0", 4, segs.length); |
| assertEquals("1.1", "first", segs[0]); |
| assertEquals("1.2", "second", segs[1]); |
| assertEquals("1.3", "third", segs[2]); |
| assertEquals("1.4", "fourth", segs[3]); |
| |
| // Case Two: trailing separator |
| anyPath = new Path("/first/second/"); |
| segs = anyPath.segments(); |
| |
| assertEquals("2.0", 2, segs.length); |
| assertEquals("2.1", "first", segs[0]); |
| assertEquals("2.2", "second", segs[1]); |
| |
| // Case Three: no leading or trailing separators |
| anyPath = new Path("first/second"); |
| segs = anyPath.segments(); |
| |
| assertEquals("3.0", 2, segs.length); |
| assertEquals("3.1", "first", segs[0]); |
| assertEquals("3.2", "second", segs[1]); |
| |
| // Case Four: single segment |
| anyPath = new Path("first"); |
| segs = anyPath.segments(); |
| |
| assertEquals("4.0", 1, segs.length); |
| assertEquals("4.1", "first", segs[0]); |
| |
| // Case Five(a): no segments |
| anyPath = Path.EMPTY; |
| segs = anyPath.segments(); |
| |
| assertEquals("5.0", 0, segs.length); |
| |
| // Case Five(b): no segments |
| anyPath = Path.ROOT; |
| segs = anyPath.segments(); |
| |
| assertEquals("6.0", 0, segs.length); |
| |
| // Case Six: UNC path |
| anyPath = new Path("//server/volume/a/b/c"); |
| segs = anyPath.segments(); |
| assertEquals("7.0", 5, segs.length); |
| assertEquals("7.1", "server", segs[0]); |
| assertEquals("7.2", "volume", segs[1]); |
| assertEquals("7.3", "a", segs[2]); |
| assertEquals("7.4", "b", segs[3]); |
| assertEquals("7.5", "c", segs[4]); |
| } |
| |
| public void testToString() { |
| |
| IPath anyPath = new Path("/first/second/third"); |
| assertEquals("1.0", "/first/second/third", anyPath.toString()); |
| |
| assertEquals("1.1", "/", Path.ROOT.toString()); |
| assertEquals("1.2", "", Path.EMPTY.toString()); |
| } |
| |
| public void testUptoSegment() { |
| |
| //Case 1, absolute path with no trailing separator |
| IPath anyPath = new Path("/first/second/third"); |
| |
| assertEquals("1.0", Path.ROOT, anyPath.uptoSegment(0)); |
| assertEquals("1.1", new Path("/first"), anyPath.uptoSegment(1)); |
| assertEquals("1.2", new Path("/first/second"), anyPath.uptoSegment(2)); |
| assertEquals("1.3", new Path("/first/second/third"), anyPath.uptoSegment(3)); |
| assertEquals("1.4", new Path("/first/second/third"), anyPath.uptoSegment(4)); |
| |
| //Case 2, absolute path with trailing separator |
| anyPath = new Path("/first/second/third/"); |
| |
| assertEquals("2.0", Path.ROOT, anyPath.uptoSegment(0)); |
| assertEquals("2.1", new Path("/first/"), anyPath.uptoSegment(1)); |
| assertEquals("2.2", new Path("/first/second/"), anyPath.uptoSegment(2)); |
| assertEquals("2.3", new Path("/first/second/third/"), anyPath.uptoSegment(3)); |
| assertEquals("2.4", new Path("/first/second/third/"), anyPath.uptoSegment(4)); |
| |
| //Case 3, relative path with no trailing separator |
| anyPath = new Path("first/second/third"); |
| |
| assertEquals("3.0", Path.EMPTY, anyPath.uptoSegment(0)); |
| assertEquals("3.1", new Path("first"), anyPath.uptoSegment(1)); |
| assertEquals("3.2", new Path("first/second"), anyPath.uptoSegment(2)); |
| assertEquals("3.3", new Path("first/second/third"), anyPath.uptoSegment(3)); |
| assertEquals("3.4", new Path("first/second/third"), anyPath.uptoSegment(4)); |
| |
| //Case 4, relative path with trailing separator |
| anyPath = new Path("first/second/third/"); |
| |
| assertEquals("4.0", Path.EMPTY, anyPath.uptoSegment(0)); |
| assertEquals("4.1", new Path("first/"), anyPath.uptoSegment(1)); |
| assertEquals("4.2", new Path("first/second/"), anyPath.uptoSegment(2)); |
| assertEquals("4.3", new Path("first/second/third/"), anyPath.uptoSegment(3)); |
| assertEquals("4.4", new Path("first/second/third/"), anyPath.uptoSegment(4)); |
| |
| // bug 58835 - upToSegment(0) needs to preserve device |
| if (WINDOWS) { |
| anyPath = new Path("c:/first/second/third"); |
| assertEquals("5.0", new Path("c:/"), anyPath.uptoSegment(0)); |
| anyPath = new Path("c:/first/second/third/"); |
| assertEquals("5.1", new Path("c:/"), anyPath.uptoSegment(0)); |
| anyPath = new Path("c:first/second/third/"); |
| assertEquals("5.2", new Path("c:"), anyPath.uptoSegment(0)); |
| } |
| anyPath = new Path("//one/two/three"); |
| assertEquals("5.3", new Path("//"), anyPath.uptoSegment(0)); |
| anyPath = new Path("//one/two/three/"); |
| assertEquals("5.4", new Path("//"), anyPath.uptoSegment(0)); |
| } |
| } |
