458 lines
12 KiB
Java
458 lines
12 KiB
Java
/*
|
|
* Copyright (c) 2009, 2011, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
import java.nio.file.*;
|
|
import java.net.*;
|
|
import java.util.*;
|
|
import java.io.IOException;
|
|
|
|
/**
|
|
* Tests path operations for zip provider.
|
|
*/
|
|
|
|
public class PathOps {
|
|
|
|
static final java.io.PrintStream out = System.out;
|
|
static FileSystem fs;
|
|
|
|
private String input;
|
|
private Path path;
|
|
private Exception exc;
|
|
|
|
private PathOps(String s) {
|
|
out.println();
|
|
input = s;
|
|
try {
|
|
path = fs.getPath(s);
|
|
out.format("%s -> %s", s, path);
|
|
} catch (Exception x) {
|
|
exc = x;
|
|
out.format("%s -> %s", s, x);
|
|
}
|
|
out.println();
|
|
}
|
|
|
|
Path path() {
|
|
return path;
|
|
}
|
|
|
|
void fail() {
|
|
throw new RuntimeException("PathOps failed");
|
|
}
|
|
|
|
void checkPath() {
|
|
if (path == null) {
|
|
throw new InternalError("path is null");
|
|
}
|
|
}
|
|
|
|
void check(Object result, String expected) {
|
|
out.format("\tExpected: %s\n", expected);
|
|
out.format("\tActual: %s\n", result);
|
|
if (result == null) {
|
|
if (expected == null) return;
|
|
} else {
|
|
// compare string representations
|
|
if (expected != null && result.toString().equals(expected.toString()))
|
|
return;
|
|
}
|
|
fail();
|
|
}
|
|
|
|
void check(Object result, boolean expected) {
|
|
check(result, Boolean.toString(expected));
|
|
}
|
|
|
|
PathOps root(String expected) {
|
|
out.println("check root");
|
|
checkPath();
|
|
check(path.getRoot(), expected);
|
|
return this;
|
|
}
|
|
|
|
PathOps parent(String expected) {
|
|
out.println("check parent");
|
|
checkPath();
|
|
check(path.getParent(), expected);
|
|
return this;
|
|
}
|
|
|
|
PathOps name(String expected) {
|
|
out.println("check name");
|
|
checkPath();
|
|
check(path.getFileName(), expected);
|
|
return this;
|
|
}
|
|
|
|
PathOps element(int index, String expected) {
|
|
out.format("check element %d\n", index);
|
|
checkPath();
|
|
check(path.getName(index), expected);
|
|
return this;
|
|
}
|
|
|
|
PathOps subpath(int startIndex, int endIndex, String expected) {
|
|
out.format("test subpath(%d,%d)\n", startIndex, endIndex);
|
|
checkPath();
|
|
check(path.subpath(startIndex, endIndex), expected);
|
|
return this;
|
|
}
|
|
|
|
PathOps starts(String prefix) {
|
|
out.format("test startsWith with %s\n", prefix);
|
|
checkPath();
|
|
Path s = fs.getPath(prefix);
|
|
check(path.startsWith(s), true);
|
|
return this;
|
|
}
|
|
|
|
PathOps notStarts(String prefix) {
|
|
out.format("test not startsWith with %s\n", prefix);
|
|
checkPath();
|
|
Path s = fs.getPath(prefix);
|
|
check(path.startsWith(s), false);
|
|
return this;
|
|
}
|
|
|
|
PathOps ends(String suffix) {
|
|
out.format("test endsWith %s\n", suffix);
|
|
checkPath();
|
|
Path s = fs.getPath(suffix);
|
|
check(path.endsWith(s), true);
|
|
return this;
|
|
}
|
|
|
|
PathOps notEnds(String suffix) {
|
|
out.format("test not endsWith %s\n", suffix);
|
|
checkPath();
|
|
Path s = fs.getPath(suffix);
|
|
check(path.endsWith(s), false);
|
|
return this;
|
|
}
|
|
|
|
PathOps absolute() {
|
|
out.println("check path is absolute");
|
|
checkPath();
|
|
check(path.isAbsolute(), true);
|
|
return this;
|
|
}
|
|
|
|
PathOps notAbsolute() {
|
|
out.println("check path is not absolute");
|
|
checkPath();
|
|
check(path.isAbsolute(), false);
|
|
return this;
|
|
}
|
|
|
|
PathOps resolve(String other, String expected) {
|
|
out.format("test resolve %s\n", other);
|
|
checkPath();
|
|
check(path.resolve(other), expected);
|
|
return this;
|
|
}
|
|
|
|
PathOps relativize(String other, String expected) {
|
|
out.format("test relativize %s\n", other);
|
|
checkPath();
|
|
Path that = fs.getPath(other);
|
|
check(path.relativize(that), expected);
|
|
return this;
|
|
}
|
|
|
|
PathOps normalize(String expected) {
|
|
out.println("check normalized path");
|
|
checkPath();
|
|
check(path.normalize(), expected);
|
|
return this;
|
|
}
|
|
|
|
PathOps string(String expected) {
|
|
out.println("check string representation");
|
|
checkPath();
|
|
check(path, expected);
|
|
return this;
|
|
}
|
|
|
|
PathOps isSameFile(String target) {
|
|
try {
|
|
out.println("check two paths are same");
|
|
checkPath();
|
|
check(Files.isSameFile(path, test(target).path()), true);
|
|
} catch (IOException ioe) {
|
|
fail();
|
|
}
|
|
return this;
|
|
}
|
|
|
|
PathOps invalid() {
|
|
if (!(exc instanceof InvalidPathException)) {
|
|
out.println("InvalidPathException not thrown as expected");
|
|
fail();
|
|
}
|
|
return this;
|
|
}
|
|
|
|
static PathOps test(String s) {
|
|
return new PathOps(s);
|
|
}
|
|
|
|
// -- PathOpss --
|
|
|
|
static void header(String s) {
|
|
out.println();
|
|
out.println();
|
|
out.println("-- " + s + " --");
|
|
}
|
|
|
|
static void doPathOpTests() {
|
|
header("Path operations");
|
|
|
|
// all components
|
|
test("/a/b/c")
|
|
.root("/")
|
|
.parent("/a/b")
|
|
.name("c");
|
|
|
|
// root component only
|
|
test("/")
|
|
.root("/")
|
|
.parent(null)
|
|
.name(null);
|
|
|
|
// no root component
|
|
test("a/b")
|
|
.root(null)
|
|
.parent("a")
|
|
.name("b");
|
|
|
|
// name component only
|
|
test("foo")
|
|
.root(null)
|
|
.parent(null)
|
|
.name("foo");
|
|
|
|
// startsWith
|
|
test("")
|
|
.starts("")
|
|
.notStarts("/");
|
|
test("/")
|
|
.starts("/")
|
|
.notStarts("/foo");
|
|
test("/foo")
|
|
.starts("/")
|
|
.starts("/foo")
|
|
.notStarts("/f")
|
|
.notStarts("");
|
|
test("/foo/bar")
|
|
.starts("/")
|
|
.starts("/foo")
|
|
.starts("/foo/")
|
|
.starts("/foo/bar")
|
|
.notStarts("/f")
|
|
.notStarts("foo")
|
|
.notStarts("foo/bar")
|
|
.notStarts("");
|
|
test("foo")
|
|
.starts("foo")
|
|
.notStarts("f");
|
|
test("foo/bar")
|
|
.starts("foo")
|
|
.starts("foo/")
|
|
.starts("foo/bar")
|
|
.notStarts("f")
|
|
.notStarts("/foo")
|
|
.notStarts("/foo/bar");
|
|
|
|
// endsWith
|
|
test("")
|
|
.ends("")
|
|
.notEnds("/");
|
|
test("/")
|
|
.ends("/")
|
|
.notEnds("foo")
|
|
.notEnds("/foo");
|
|
test("/foo")
|
|
.ends("foo")
|
|
.ends("/foo")
|
|
.notEnds("/");
|
|
test("/foo/bar")
|
|
.ends("bar")
|
|
.ends("foo/bar")
|
|
.ends("foo/bar/")
|
|
.ends("/foo/bar")
|
|
.notEnds("/bar");
|
|
test("/foo/bar/")
|
|
.ends("bar")
|
|
.ends("foo/bar")
|
|
.ends("foo/bar/")
|
|
.ends("/foo/bar")
|
|
.notEnds("/bar");
|
|
test("foo")
|
|
.ends("foo");
|
|
test("foo/bar")
|
|
.ends("bar")
|
|
.ends("bar/")
|
|
.ends("foo/bar/")
|
|
.ends("foo/bar");
|
|
|
|
|
|
// elements
|
|
test("a/b/c")
|
|
.element(0,"a")
|
|
.element(1,"b")
|
|
.element(2,"c");
|
|
|
|
// isAbsolute
|
|
test("/")
|
|
.absolute();
|
|
test("/tmp")
|
|
.absolute();
|
|
test("tmp")
|
|
.notAbsolute();
|
|
test("")
|
|
.notAbsolute();
|
|
|
|
// resolve
|
|
test("/tmp")
|
|
.resolve("foo", "/tmp/foo")
|
|
.resolve("/foo", "/foo");
|
|
test("tmp")
|
|
.resolve("foo", "tmp/foo")
|
|
.resolve("/foo", "/foo");
|
|
|
|
// relativize
|
|
test("/a/b/c")
|
|
.relativize("/a/b/c", "")
|
|
.relativize("/a/b/c/d/e", "d/e")
|
|
.relativize("/a/x", "../../x");
|
|
|
|
// normalize
|
|
test("/")
|
|
.normalize("/");
|
|
test("foo")
|
|
.normalize("foo");
|
|
test("/foo")
|
|
.normalize("/foo");
|
|
test(".")
|
|
.normalize("");
|
|
test("..")
|
|
.normalize("..");
|
|
test("/..")
|
|
.normalize("/");
|
|
test("/../..")
|
|
.normalize("/");
|
|
test("foo/.")
|
|
.normalize("foo");
|
|
test("./foo")
|
|
.normalize("foo");
|
|
test("foo/..")
|
|
.normalize("");
|
|
test("../foo")
|
|
.normalize("../foo");
|
|
test("../../foo")
|
|
.normalize("../../foo");
|
|
test("foo/bar/..")
|
|
.normalize("foo");
|
|
test("foo/bar/gus/../..")
|
|
.normalize("foo");
|
|
test("/foo/bar/gus/../..")
|
|
.normalize("/foo");
|
|
test("/./.")
|
|
.normalize("/");
|
|
test("/.")
|
|
.normalize("/");
|
|
test("/./abc")
|
|
.normalize("/abc");
|
|
// invalid
|
|
test("foo\u0000bar")
|
|
.invalid();
|
|
test("\u0000foo")
|
|
.invalid();
|
|
test("bar\u0000")
|
|
.invalid();
|
|
test("//foo\u0000bar")
|
|
.invalid();
|
|
test("//\u0000foo")
|
|
.invalid();
|
|
test("//bar\u0000")
|
|
.invalid();
|
|
|
|
// normalization
|
|
test("//foo//bar")
|
|
.string("/foo/bar")
|
|
.root("/")
|
|
.parent("/foo")
|
|
.name("bar");
|
|
|
|
// isSameFile
|
|
test("/fileDoesNotExist")
|
|
.isSameFile("/fileDoesNotExist");
|
|
}
|
|
|
|
static void npes() {
|
|
header("NullPointerException");
|
|
|
|
Path path = fs.getPath("foo");
|
|
|
|
try {
|
|
path.resolve((String)null);
|
|
throw new RuntimeException("NullPointerException not thrown");
|
|
} catch (NullPointerException npe) {
|
|
}
|
|
|
|
try {
|
|
path.relativize(null);
|
|
throw new RuntimeException("NullPointerException not thrown");
|
|
} catch (NullPointerException npe) {
|
|
}
|
|
|
|
try {
|
|
path.compareTo(null);
|
|
throw new RuntimeException("NullPointerException not thrown");
|
|
} catch (NullPointerException npe) {
|
|
}
|
|
|
|
try {
|
|
path.startsWith((Path)null);
|
|
throw new RuntimeException("NullPointerException not thrown");
|
|
} catch (NullPointerException npe) {
|
|
}
|
|
|
|
try {
|
|
path.endsWith((Path)null);
|
|
throw new RuntimeException("NullPointerException not thrown");
|
|
} catch (NullPointerException npe) {
|
|
}
|
|
|
|
}
|
|
|
|
public static void main(String[] args) throws Throwable {
|
|
|
|
Path zipfile = Paths.get(args[0]);
|
|
fs = FileSystems.newFileSystem(zipfile, null);
|
|
npes();
|
|
doPathOpTests();
|
|
fs.close();
|
|
}
|
|
}
|