1 /*
2 * Copyright (c) 2009, 2011, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 import java.nio.file.*;
25 import java.net.*;
26 import java.util.*;
27 import java.io.IOException;
28
29 /**
30 * Tests path operations for zip provider.
31 */
32
33 public class PathOps {
34
35 static final java.io.PrintStream out = System.out;
36 static FileSystem fs;
37
38 private String input;
39 private Path path;
40 private Exception exc;
41
42 private PathOps(String s) {
43 out.println();
44 input = s;
45 try {
46 path = fs.getPath(s);
47 out.format("%s -> %s", s, path);
48 } catch (Exception x) {
49 exc = x;
50 out.format("%s -> %s", s, x);
51 }
52 out.println();
53 }
54
55 Path path() {
56 return path;
57 }
58
59 void fail() {
60 throw new RuntimeException("PathOps failed");
61 }
62
63 void checkPath() {
64 if (path == null) {
65 throw new InternalError("path is null");
66 }
67 }
68
69 void check(Object result, String expected) {
70 out.format("\tExpected: %s\n", expected);
71 out.format("\tActual: %s\n", result);
72 if (result == null) {
73 if (expected == null) return;
74 } else {
75 // compare string representations
76 if (expected != null && result.toString().equals(expected.toString()))
77 return;
78 }
79 fail();
80 }
81
82 void check(Object result, boolean expected) {
83 check(result, Boolean.toString(expected));
84 }
85
86 PathOps root(String expected) {
87 out.println("check root");
88 checkPath();
89 check(path.getRoot(), expected);
90 return this;
91 }
92
93 PathOps parent(String expected) {
94 out.println("check parent");
95 checkPath();
96 check(path.getParent(), expected);
97 return this;
98 }
99
100 PathOps name(String expected) {
101 out.println("check name");
102 checkPath();
103 check(path.getFileName(), expected);
104 return this;
105 }
106
107 PathOps element(int index, String expected) {
108 out.format("check element %d\n", index);
109 checkPath();
110 check(path.getName(index), expected);
111 return this;
112 }
113
114 PathOps subpath(int startIndex, int endIndex, String expected) {
115 out.format("test subpath(%d,%d)\n", startIndex, endIndex);
116 checkPath();
117 check(path.subpath(startIndex, endIndex), expected);
118 return this;
119 }
120
121 PathOps starts(String prefix) {
122 out.format("test startsWith with %s\n", prefix);
123 checkPath();
124 Path s = fs.getPath(prefix);
125 check(path.startsWith(s), true);
126 return this;
127 }
128
129 PathOps notStarts(String prefix) {
130 out.format("test not startsWith with %s\n", prefix);
131 checkPath();
132 Path s = fs.getPath(prefix);
133 check(path.startsWith(s), false);
134 return this;
135 }
136
137 PathOps ends(String suffix) {
138 out.format("test endsWith %s\n", suffix);
139 checkPath();
140 Path s = fs.getPath(suffix);
141 check(path.endsWith(s), true);
142 return this;
143 }
144
145 PathOps notEnds(String suffix) {
146 out.format("test not endsWith %s\n", suffix);
147 checkPath();
148 Path s = fs.getPath(suffix);
149 check(path.endsWith(s), false);
150 return this;
151 }
152
153 PathOps absolute() {
154 out.println("check path is absolute");
155 checkPath();
156 check(path.isAbsolute(), true);
157 return this;
158 }
159
160 PathOps notAbsolute() {
161 out.println("check path is not absolute");
162 checkPath();
163 check(path.isAbsolute(), false);
164 return this;
165 }
166
167 PathOps resolve(String other, String expected) {
168 out.format("test resolve %s\n", other);
169 checkPath();
170 check(path.resolve(other), expected);
171 return this;
172 }
173
174 PathOps relativize(String other, String expected) {
175 out.format("test relativize %s\n", other);
176 checkPath();
177 Path that = fs.getPath(other);
178 check(path.relativize(that), expected);
179 return this;
180 }
181
182 PathOps normalize(String expected) {
183 out.println("check normalized path");
184 checkPath();
185 check(path.normalize(), expected);
186 return this;
187 }
188
189 PathOps string(String expected) {
190 out.println("check string representation");
191 checkPath();
192 check(path, expected);
193 return this;
194 }
195
196 PathOps isSameFile(String target) {
197 try {
198 out.println("check two paths are same");
199 checkPath();
200 check(Files.isSameFile(path, test(target).path()), true);
201 } catch (IOException ioe) {
202 fail();
203 }
204 return this;
205 }
206
207 PathOps invalid() {
208 if (!(exc instanceof InvalidPathException)) {
209 out.println("InvalidPathException not thrown as expected");
210 fail();
211 }
212 return this;
213 }
214
215 static PathOps test(String s) {
216 return new PathOps(s);
217 }
218
219 // -- PathOpss --
220
221 static void header(String s) {
222 out.println();
223 out.println();
224 out.println("-- " + s + " --");
225 }
226
227 static void doPathOpTests() {
228 header("Path operations");
229
230 // all components
231 test("/a/b/c")
232 .root("/")
233 .parent("/a/b")
234 .name("c");
235
236 // root component only
237 test("/")
238 .root("/")
239 .parent(null)
240 .name(null);
241
242 // no root component
243 test("a/b")
244 .root(null)
245 .parent("a")
246 .name("b");
247
248 // name component only
249 test("foo")
250 .root(null)
251 .parent(null)
252 .name("foo");
253
254 // startsWith
255 test("")
256 .starts("")
257 .notStarts("/");
258 test("/")
259 .starts("/")
260 .notStarts("/foo");
261 test("/foo")
262 .starts("/")
263 .starts("/foo")
264 .notStarts("/f")
265 .notStarts("");
266 test("/foo/bar")
267 .starts("/")
268 .starts("/foo")
269 .starts("/foo/")
270 .starts("/foo/bar")
271 .notStarts("/f")
272 .notStarts("foo")
273 .notStarts("foo/bar")
274 .notStarts("");
275 test("foo")
276 .starts("foo")
277 .notStarts("f");
278 test("foo/bar")
279 .starts("foo")
280 .starts("foo/")
281 .starts("foo/bar")
282 .notStarts("f")
283 .notStarts("/foo")
284 .notStarts("/foo/bar");
285
286 // endsWith
287 test("")
288 .ends("")
289 .notEnds("/");
290 test("/")
291 .ends("/")
292 .notEnds("foo")
293 .notEnds("/foo");
294 test("/foo")
295 .ends("foo")
296 .ends("/foo")
297 .notEnds("/");
298 test("/foo/bar")
299 .ends("bar")
300 .ends("foo/bar")
301 .ends("foo/bar/")
302 .ends("/foo/bar")
303 .notEnds("/bar");
304 test("/foo/bar/")
305 .ends("bar")
306 .ends("foo/bar")
307 .ends("foo/bar/")
308 .ends("/foo/bar")
309 .notEnds("/bar");
310 test("foo")
311 .ends("foo");
312 test("foo/bar")
313 .ends("bar")
314 .ends("bar/")
315 .ends("foo/bar/")
316 .ends("foo/bar");
317
318
319 // elements
320 test("a/b/c")
321 .element(0,"a")
322 .element(1,"b")
323 .element(2,"c");
324
325 // isAbsolute
326 test("/")
327 .absolute();
328 test("/tmp")
329 .absolute();
330 test("tmp")
331 .notAbsolute();
332 test("")
333 .notAbsolute();
334
335 // resolve
336 test("/tmp")
337 .resolve("foo", "/tmp/foo")
338 .resolve("/foo", "/foo");
339 test("tmp")
340 .resolve("foo", "tmp/foo")
341 .resolve("/foo", "/foo");
342
343 // relativize
344 test("/a/b/c")
345 .relativize("/a/b/c", "")
346 .relativize("/a/b/c/d/e", "d/e")
347 .relativize("/a/x", "../../x");
348
349 // normalize
350 test("/")
351 .normalize("/");
352 test("foo")
353 .normalize("foo");
354 test("/foo")
355 .normalize("/foo");
356 test(".")
357 .normalize("");
358 test("..")
359 .normalize("..");
360 test("/..")
361 .normalize("/");
362 test("/../..")
363 .normalize("/");
364 test("foo/.")
365 .normalize("foo");
366 test("./foo")
367 .normalize("foo");
368 test("foo/..")
369 .normalize("");
370 test("../foo")
371 .normalize("../foo");
372 test("../../foo")
373 .normalize("../../foo");
374 test("foo/bar/..")
375 .normalize("foo");
376 test("foo/bar/gus/../..")
377 .normalize("foo");
378 test("/foo/bar/gus/../..")
379 .normalize("/foo");
380 test("/./.")
381 .normalize("/");
382 test("/.")
383 .normalize("/");
384 test("/./abc")
385 .normalize("/abc");
386 // invalid
387 test("foo\u0000bar")
388 .invalid();
389 test("\u0000foo")
390 .invalid();
391 test("bar\u0000")
392 .invalid();
393 test("//foo\u0000bar")
394 .invalid();
395 test("//\u0000foo")
396 .invalid();
397 test("//bar\u0000")
398 .invalid();
399
400 // normalization
401 test("//foo//bar")
402 .string("/foo/bar")
403 .root("/")
404 .parent("/foo")
405 .name("bar");
406
407 // isSameFile
408 test("/fileDoesNotExist")
409 .isSameFile("/fileDoesNotExist");
410 }
411
412 static void npes() {
413 header("NullPointerException");
414
415 Path path = fs.getPath("foo");
416
417 try {
418 path.resolve((String)null);
419 throw new RuntimeException("NullPointerException not thrown");
420 } catch (NullPointerException npe) {
421 }
422
423 try {
424 path.relativize(null);
425 throw new RuntimeException("NullPointerException not thrown");
426 } catch (NullPointerException npe) {
427 }
428
429 try {
430 path.compareTo(null);
431 throw new RuntimeException("NullPointerException not thrown");
432 } catch (NullPointerException npe) {
433 }
434
435 try {
436 path.startsWith((Path)null);
437 throw new RuntimeException("NullPointerException not thrown");
438 } catch (NullPointerException npe) {
439 }
440
441 try {
442 path.endsWith((Path)null);
443 throw new RuntimeException("NullPointerException not thrown");
444 } catch (NullPointerException npe) {
445 }
446
447 }
448
449 public static void main(String[] args) throws Throwable {
450
451 Path zipfile = Paths.get(args[0]);
452 fs = FileSystems.newFileSystem(zipfile, null);
453 npes();
454 doPathOpTests();
455 fs.close();
456 }
457 }