1 /*
2 * Copyright (c) 2014, 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 /*
25 * @test
26 * @summary Basic test of jrt file system provider
27 * @run testng Basic
28 */
29
30 import java.io.InputStream;
31 import java.io.DataInputStream;
32 import java.nio.file.DirectoryStream;
33 import java.nio.file.InvalidPathException;
34 import java.nio.file.Files;
35 import java.nio.file.FileSystem;
36 import java.nio.file.FileSystems;
37 import java.nio.file.Path;
38 import java.nio.file.PathMatcher;
39 import java.nio.file.Paths;
40 import java.net.URI;
41 import java.util.Collections;
42 import java.util.Iterator;
43 import java.util.Map;
44 import java.util.NoSuchElementException;
45 import java.util.stream.Stream;
46
47 import org.testng.annotations.DataProvider;
48 import org.testng.annotations.Test;
49
50 import static org.testng.Assert.assertEquals;
51 import static org.testng.Assert.assertNotEquals;
52 import static org.testng.Assert.assertTrue;
53 import static org.testng.Assert.assertFalse;
54
55 /**
56 * Basic tests for jrt:/ file system provider.
57 */
58
59 public class Basic {
60
61 // Checks that the given FileSystem is a jrt file system.
62 private void checkFileSystem(FileSystem fs) {
63 assertTrue(fs.provider().getScheme().equalsIgnoreCase("jrt"));
64 assertTrue(fs.isOpen());
65 assertTrue(fs.isReadOnly());
66 assertEquals(fs.getSeparator(), "/");
67
68 // one root
69 Iterator<Path> roots = fs.getRootDirectories().iterator();
70 assertTrue(roots.next().toString().equals("/"));
71 assertFalse(roots.hasNext());
72 }
73
74 @Test
75 public void testGetFileSystem() {
76 FileSystem fs = FileSystems.getFileSystem(URI.create("jrt:/"));
77 checkFileSystem(fs);
78
79 // getFileSystem should return the same object each time
80 assertTrue(fs == FileSystems.getFileSystem(URI.create("jrt:/")));
81 }
82
83 @Test(expectedExceptions = UnsupportedOperationException.class)
84 public void testCloseFileSystem() throws Exception {
85 FileSystem fs = FileSystems.getFileSystem(URI.create("jrt:/"));
86 fs.close(); // should throw UOE
87 }
88
89 @Test
90 public void testNewFileSystem() throws Exception {
91 FileSystem theFileSystem = FileSystems.getFileSystem(URI.create("jrt:/"));
92 Map<String, ?> env = Collections.emptyMap();
93 try (FileSystem fs = FileSystems.newFileSystem(URI.create("jrt:/"), env)) {
94 checkFileSystem(fs);
95 assertTrue(fs != theFileSystem);
96 }
97 }
98
99 @DataProvider(name = "knownClassFiles")
100 private Object[][] knownClassFiles() {
101 return new Object[][] {
102 { "/modules/java.base/java/lang/Object.class" },
103 { "modules/java.base/java/lang/Object.class" },
104 };
105 }
106
107 @Test(dataProvider = "knownClassFiles")
108 public void testKnownClassFiles(String path) throws Exception {
109 FileSystem fs = FileSystems.getFileSystem(URI.create("jrt:/"));
110 Path classFile = fs.getPath(path);
111
112 assertTrue(Files.isRegularFile(classFile));
113 assertTrue(Files.size(classFile) > 0L);
114
115 // check magic number
116 try (InputStream in = Files.newInputStream(classFile)) {
117 int magic = new DataInputStream(in).readInt();
118 assertEquals(magic, 0xCAFEBABE);
119 }
120 }
121
122 @DataProvider(name = "knownDirectories")
123 private Object[][] knownDirectories() {
124 return new Object[][] {
125 { "/" },
126 { "." },
127 { "./" },
128 { "/." },
129 { "/./" },
130 { "/modules/java.base/.." },
131 { "/modules/java.base/../" },
132 { "/modules/java.base/../." },
133 { "/modules/java.base" },
134 { "/modules/java.base/java/lang" },
135 { "modules/java.base/java/lang" },
136 { "/modules/java.base/java/lang/" },
137 { "modules/java.base/java/lang/" }
138 };
139 }
140
141 @Test(dataProvider = "knownDirectories")
142 public void testKnownDirectories(String path) throws Exception {
143 FileSystem fs = FileSystems.getFileSystem(URI.create("jrt:/"));
144 Path dir = fs.getPath(path);
145
146 assertTrue(Files.isDirectory(dir));
147
148 // directory should not be empty
149 try (Stream<Path> stream = Files.list(dir)) {
150 assertTrue(stream.count() > 0L);
151 }
152 try (Stream<Path> stream = Files.walk(dir)) {
153 assertTrue(stream.count() > 0L);
154 }
155 }
156
157 @DataProvider(name = "topLevelPkgDirs")
158 private Object[][] topLevelPkgDirs() {
159 return new Object[][] {
160 { "/java/lang" },
161 { "java/lang" },
162 { "/java/util" },
163 { "java/util" },
164 };
165 }
166
167 @Test(dataProvider = "topLevelPkgDirs")
168 public void testNotExists(String path) throws Exception {
169 FileSystem fs = FileSystems.getFileSystem(URI.create("jrt:/"));
170 Path dir = fs.getPath(path);
171
172 // package directories should not be there at top level
173 assertTrue(Files.notExists(dir));
174 }
175
176 /**
177 * Test the URI of every file in the jrt file system
178 */
179 @Test
180 public void testToAndFromUri() throws Exception {
181 FileSystem fs = FileSystems.getFileSystem(URI.create("jrt:/"));
182 Path top = fs.getPath("/");
183 try (Stream<Path> stream = Files.walk(top)) {
184 stream.forEach(path -> {
185 URI u = path.toUri();
186 assertTrue(u.getScheme().equalsIgnoreCase("jrt"));
187 assertFalse(u.isOpaque());
188 assertTrue(u.getAuthority() == null);
189 assertEquals(u.getPath(), path.toAbsolutePath().toString());
190 Path p = Paths.get(u);
191 assertEquals(p, path);
192 });
193 }
194 }
195
196 @Test
197 public void testDirectoryNames() throws Exception {
198 FileSystem fs = FileSystems.getFileSystem(URI.create("jrt:/"));
199 Path top = fs.getPath("/");
200 // check that directory names do not have trailing '/' char
201 try (Stream<Path> stream = Files.walk(top)) {
202 stream.skip(1).filter(Files::isDirectory).forEach(path -> {
203 assertFalse(path.toString().endsWith("/"));
204 });
205 }
206 }
207
208 @DataProvider(name = "pathPrefixs")
209 private Object[][] pathPrefixes() {
210 return new Object[][] {
211 { "/" },
212 { "modules/java.base/java/lang" },
213 { "./modules/java.base/java/lang" },
214 { "/modules/java.base/java/lang" },
215 { "/./modules/java.base/java/lang" },
216 { "modules/java.base/java/lang/" },
217 { "./modules/java.base/java/lang/" },
218 { "/./modules/java.base/java/lang/" },
219 };
220 }
221
222 // @Test(dataProvider = "pathPrefixes")
223 public void testParentInDirList(String dir) throws Exception {
224 FileSystem fs = FileSystems.getFileSystem(URI.create("jrt:/"));
225 Path base = fs.getPath(dir);
226 try (DirectoryStream<Path> stream = Files.newDirectoryStream(base)) {
227 for (Path entry: stream) {
228 assertTrue( entry.getParent().equals(base),
229 base.toString() + "-> " + entry.toString() );
230 }
231 }
232 }
233
234 @DataProvider(name = "dirStreamStringFilterData")
235 private Object[][] dirStreamStringFilterData() {
236 return new Object[][] {
237 { "/modules/java.base/java/lang", "/reflect" },
238 { "/modules/java.base/java/lang", "/Object.class" },
239 { "/modules/java.base/java/util", "/stream" },
240 { "/modules/java.base/java/util", "/List.class" },
241 };
242 }
243
244 @Test(dataProvider = "dirStreamStringFilterData")
245 public void testDirectoryStreamStringFilter(String dir, String filter) throws Exception {
246 FileSystem fs = FileSystems.getFileSystem(URI.create("jrt:/"));
247 Path base = fs.getPath(dir);
248 try (DirectoryStream<Path> stream =
249 Files.newDirectoryStream(base, p->!p.toString().endsWith(filter))) {
250 for (Path entry: stream) {
251 assertFalse(entry.toString().contains(filter),
252 "filtered path seen: " + filter);
253 }
254 }
255
256 // make sure without filter, we do see that matching entry!
257 boolean seen = false;
258 try (DirectoryStream<Path> stream = Files.newDirectoryStream(base)) {
259 for (Path entry: stream) {
260 if (entry.toString().endsWith(filter)) {
261 seen = true;
262 break;
263 }
264 }
265 }
266
267 assertTrue(seen, "even without filter " + filter + " is missing");
268 }
269
270 @DataProvider(name = "dirStreamFilterData")
271 private Object[][] dirStreamFilterData() {
272 return new Object[][] {
273 {
274 "/",
275 (DirectoryStream.Filter<Path>)(Files::isDirectory),
276 "isDirectory"
277 },
278 {
279 "/modules/java.base/java/lang",
280 (DirectoryStream.Filter<Path>)(Files::isRegularFile),
281 "isFile"
282 }
283 };
284 }
285
286 @Test(dataProvider = "dirStreamFilterData")
287 private void testDirectoryStreamFilter(String dir, DirectoryStream.Filter filter,
288 String name) throws Exception {
289 FileSystem fs = FileSystems.getFileSystem(URI.create("jrt:/"));
290 Path base = fs.getPath(dir);
291 try (DirectoryStream<Path> stream = Files.newDirectoryStream(base, filter)) {
292 for (Path entry: stream) {
293 assertTrue(filter.accept(entry), "filtered path seen: " + name);
294 }
295 }
296
297 // make sure without filter, we do see that matching entry!
298 boolean seen = false;
299 try (DirectoryStream<Path> stream = Files.newDirectoryStream(base)) {
300 for (Path entry: stream) {
301 if (filter.accept(entry)) {
302 seen = true;
303 break;
304 }
305 }
306 }
307
308 assertTrue(seen, "even without filter " + name + " is missing");
309 }
310
311 @Test
312 private void testDirectoryStreamIterator() throws Exception {
313 // run the tests with null filter (no filter)
314 dirStreamIteratorTest(null);
315 // run the same tests with trivial "accept all" filter
316 dirStreamIteratorTest(p->true);
317 // two other non-trivial ones
318 dirStreamIteratorTest(Files::isDirectory);
319 dirStreamIteratorTest(Files::isRegularFile);
320 }
321
322 private void dirStreamIteratorTest(DirectoryStream.Filter<Path> filter)
323 throws Exception {
324 FileSystem fs = FileSystems.getFileSystem(URI.create("jrt:/"));
325 // This test assumes at least there are two elements in "java/lang"
326 // package with any filter passed. don't change to different path here!
327 Path dir = fs.getPath("/modules/java.base/java/lang");
328 try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir, filter)) {
329 Iterator<Path> itr = stream.iterator();
330 itr.hasNext();
331 Path path1 = itr.next();
332 // missing second hasNext call
333 Path path2 = itr.next();
334 assertNotEquals(path1, path2);
335 }
336
337 try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir, filter)) {
338 Iterator<Path> itr = stream.iterator();
339 // no hasNext calls at all
340 Path path1 = itr.next();
341 Path path2 = itr.next();
342 assertNotEquals(path1, path2);
343 }
344
345 int numEntries = 0;
346 try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir, filter)) {
347 Iterator<Path> itr = stream.iterator();
348 while (itr.hasNext()) {
349 numEntries++;
350 itr.next();
351 }
352
353 // reached EOF, next call should result in exception
354 try {
355 itr.next();
356 throw new AssertionError("should have thrown exception");
357 } catch (NoSuchElementException nsee) {
358 System.out.println("got NoSuchElementException as expected");
359 }
360 }
361
362 // redundant hasNext calls
363 try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir, filter)) {
364 Iterator<Path> itr = stream.iterator();
365 // any number of hasNext should definitely stay at first element
366 for (int i = 0; i < 2*numEntries; i++) {
367 itr.hasNext();
368 }
369
370 for (int j = 0; j < numEntries; j++) {
371 itr.next();
372 }
373 // exactly count number of entries!
374 assertFalse(itr.hasNext());
375 }
376 }
377
378 @DataProvider(name = "hiddenPaths")
379 private Object[][] hiddenPaths() {
380 return new Object[][] {
381 { "/META-INF" },
382 { "/META-INF/services" },
383 { "/META-INF/services/java.nio.file.spi.FileSystemProvider" },
384 { "/modules/java.base/packages.offsets" },
385 { "/modules/java.instrument/packages.offsets" },
386 { "/modules/jdk.zipfs/packages.offsets" },
387 { "/modules/java.base/_the.java.base.vardeps" },
388 { "/modules/java.base/_the.java.base_batch" },
389 { "/java/lang" },
390 { "/java/util" },
391 };
392 }
393
394 @Test(dataProvider = "hiddenPaths")
395 public void testHiddenPathsNotExposed(String path) throws Exception {
396 FileSystem fs = FileSystems.getFileSystem(URI.create("jrt:/"));
397 assertTrue(Files.notExists(fs.getPath(path)), path + " should not exist");
398 }
399
400 @DataProvider(name = "pathGlobPatterns")
401 private Object[][] pathGlobPatterns() {
402 return new Object[][] {
403 { "/modules/*", "/modules/java.base", true },
404 { "/modules/*", "/modules/java.base/java", false },
405 { "/modules/j*", "/modules/java.base", true },
406 { "/modules/J*", "/modules/java.base", false },
407 { "**.class", "/modules/java.base/java/lang/Object.class", true },
408 { "**.java", "/modules/java.base/java/lang/Object.class", false },
409 { "**java/*", "/modules/java.base/java/lang", true },
410 { "**java/lang/ref*", "/modules/java.base/java/lang/reflect", true },
411 { "**java/lang/ref*", "/modules/java.base/java/lang/ref", true },
412 { "**java/lang/ref?", "/modules/java.base/java/lang/ref", false },
413 { "**java/lang/{ref,refl*}", "/modules/java.base/java/lang/ref", true },
414 { "**java/lang/{ref,refl*}", "/modules/java.base/java/lang/reflect", true },
415 { "**java/[a-u]?*/*.class", "/modules/java.base/java/util/Map.class", true },
416 { "**java/util/[a-z]*.class", "/modules/java.base/java/util/TreeMap.class", false },
417 };
418 }
419
420 @Test(dataProvider = "pathGlobPatterns")
421 public void testGlobPathMatcher(String pattern, String path,
422 boolean expectMatch) throws Exception {
423 FileSystem fs = FileSystems.getFileSystem(URI.create("jrt:/"));
424 PathMatcher pm = fs.getPathMatcher("glob:" + pattern);
425 Path p = fs.getPath(path);
426 assertTrue(Files.exists(p), path);
427 assertTrue(!(pm.matches(p) ^ expectMatch),
428 p + (expectMatch? " should match " : " should not match ") +
429 pattern);
430 }
431
432 @DataProvider(name = "pathRegexPatterns")
433 private Object[][] pathRegexPatterns() {
434 return new Object[][] {
435 { "/modules/.*", "/modules/java.base", true },
436 { "/modules/[^/]*", "/modules/java.base/java", false },
437 { "/modules/j.*", "/modules/java.base", true },
438 { "/modules/J.*", "/modules/java.base", false },
439 { ".*\\.class", "/modules/java.base/java/lang/Object.class", true },
440 { ".*\\.java", "/modules/java.base/java/lang/Object.class", false },
441 { ".*java/.*", "/modules/java.base/java/lang", true },
442 { ".*java/lang/ref.*", "/modules/java.base/java/lang/reflect", true },
443 { ".*java/lang/ref.*", "/modules/java.base/java/lang/ref", true },
444 { ".*/java/lang/ref.+", "/modules/java.base/java/lang/ref", false },
445 { ".*/java/lang/(ref|refl.*)", "/modules/java.base/java/lang/ref", true },
446 { ".*/java/lang/(ref|refl.*)", "/modules/java.base/java/lang/reflect", true },
447 { ".*/java/[a-u]?.*/.*\\.class", "/modules/java.base/java/util/Map.class", true },
448 { ".*/java/util/[a-z]*\\.class", "/modules/java.base/java/util/TreeMap.class", false },
449 };
450 }
451
452 @Test(dataProvider = "pathRegexPatterns")
453 public void testRegexPathMatcher(String pattern, String path,
454 boolean expectMatch) throws Exception {
455 FileSystem fs = FileSystems.getFileSystem(URI.create("jrt:/"));
456 PathMatcher pm = fs.getPathMatcher("regex:" + pattern);
457 Path p = fs.getPath(path);
458 assertTrue(Files.exists(p), path);
459 assertTrue(!(pm.matches(p) ^ expectMatch),
460 p + (expectMatch? " should match " : " should not match ") +
461 pattern);
462 }
463
464 @Test
465 public void testPackagesAndModules() throws Exception {
466 FileSystem fs = FileSystems.getFileSystem(URI.create("jrt:/"));
467 assertTrue(Files.isDirectory(fs.getPath("/packages")));
468 assertTrue(Files.isDirectory(fs.getPath("/modules")));
469 }
470
471 @DataProvider(name = "packagesSubDirs")
472 private Object[][] packagesSubDirs() {
473 return new Object[][] {
474 { "java.lang" },
475 { "java.util" },
476 { "java.nio" },
477 { "jdk.nashorn.api.scripting" }
478 };
479 }
480
481 @Test(dataProvider = "packagesSubDirs")
482 public void testPackagesSubDirs(String pkg) throws Exception {
483 FileSystem fs = FileSystems.getFileSystem(URI.create("jrt:/"));
484 assertTrue(Files.isDirectory(fs.getPath("/packages/" + pkg)),
485 pkg + " missing");
486 }
487
488 @DataProvider(name = "packagesLinks")
489 private Object[][] packagesLinks() {
490 return new Object[][] {
491 { "/packages/java.lang/java.base" },
492 { "/packages/java.lang/java.instrument" },
493 { "/packages/java/java.base" },
494 { "/packages/java/java.instrument" },
495 { "/packages/java/java.rmi" },
496 { "/packages/java/java.sql" },
497 { "/packages/javax/java.base" },
498 { "/packages/javax/java.sql" },
499 { "/packages/javax/java.xml" },
500 { "/packages/javax/java.management" },
501 { "/packages/java.util/java.base" },
502 { "/packages/jdk.nashorn.api.scripting/jdk.scripting.nashorn" },
503 };
504 }
505
506 @Test(dataProvider = "packagesLinks")
507 public void testPackagesLinks(String link) throws Exception {
508 FileSystem fs = FileSystems.getFileSystem(URI.create("jrt:/"));
509 Path path = fs.getPath(link);
510 assertTrue(Files.exists(path), link + " missing");
511 assertTrue(Files.isSymbolicLink(path), path + " is not a link");
512 path = Files.readSymbolicLink(path);
513 assertEquals(path.toString(), "/modules" + link.substring(link.lastIndexOf("/")));
514 }
515
516 @DataProvider(name = "modulesSubDirs")
517 private Object[][] modulesSubDirs() {
518 return new Object[][] {
519 { "java.base" },
520 { "java.sql" },
521 { "jdk.scripting.nashorn" },
522 };
523 }
524
525 @Test(dataProvider = "modulesSubDirs")
526 public void testModulesSubDirs(String module) throws Exception {
527 FileSystem fs = FileSystems.getFileSystem(URI.create("jrt:/"));
528 Path path = fs.getPath("/modules/" + module);
529 assertTrue(Files.isDirectory(path), module + " missing");
530 assertTrue(!Files.isSymbolicLink(path), path + " is a link");
531 }
532
533 @DataProvider(name="linkChases")
534 private Object[][] linkChases() {
535 return new Object[][] {
536 { "/modules/java.base/java/lang" },
537 { "/modules/java.base/java/util/Vector.class" },
538 { "/modules/jdk.scripting.nashorn/jdk/nashorn" },
539 { "/packages/java.lang/java.base/java/lang" },
540 { "/packages/java.util/java.base/java/util/Vector.class" },
541 };
542 }
543
544 @Test(dataProvider = "linkChases")
545 public void testLinkChases(String link) throws Exception {
546 FileSystem fs = FileSystems.getFileSystem(URI.create("jrt:/"));
547 Path path = fs.getPath(link);
548 assertTrue(Files.exists(path), link);
549 }
550
551 @Test
552 public void testSymlinkDirList() throws Exception {
553 FileSystem fs = FileSystems.getFileSystem(URI.create("jrt:/"));
554 Path path = fs.getPath("/packages/java.lang/java.base");
555 assertTrue(Files.isSymbolicLink(path));
556 assertTrue(Files.isDirectory(path));
557
558 boolean javaSeen = false, javaxSeen = false;
559 try (DirectoryStream<Path> stream = Files.newDirectoryStream(path)) {
560 for (Path p : stream) {
561 String str = p.toString();
562 if (str.endsWith("/java")) {
563 javaSeen = true;
564 } else if (str.endsWith("javax")) {
565 javaxSeen = true;
566 }
567 }
568 }
569 assertTrue(javaSeen);
570 assertTrue(javaxSeen);
571 }
572
573 @Test
574 public void invalidPathTest() {
575 FileSystem fs = FileSystems.getFileSystem(URI.create("jrt:/"));
576 InvalidPathException ipe = null;
577 try {
578 boolean res = Files.exists(fs.getPath("/packages/\ud834\udd7b"));
579 assertFalse(res);
580 return;
581 } catch (InvalidPathException e) {
582 ipe = e;
583 }
584 assertTrue(ipe != null);
585 }
586 }