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 * 31 * @test 32 * @bug 8038500 33 * @summary Tests path operations for zip provider. 34 */ 35 36 public class PathOps { 37 38 static final java.io.PrintStream out = System.out; 39 static FileSystem fs; 40 41 private String input; 42 private Path path; 43 private Exception exc; 44 45 private PathOps(String s) { 46 out.println(); 47 input = s; 48 try { 49 path = fs.getPath(s); 50 out.format("%s -> %s", s, path); 51 } catch (Exception x) { 52 exc = x; 53 out.format("%s -> %s", s, x); 54 } 55 out.println(); 56 } 57 58 Path path() { 59 return path; 60 } 61 62 void fail() { 63 throw new RuntimeException("PathOps failed"); 64 } 65 66 void checkPath() { 67 if (path == null) { 68 throw new InternalError("path is null"); 69 } 70 } 71 72 void check(Object result, String expected) { 73 out.format("\tExpected: %s\n", expected); 74 out.format("\tActual: %s\n", result); 75 if (result == null) { 76 if (expected == null) return; 77 } else { 78 // compare string representations 79 if (expected != null && result.toString().equals(expected.toString())) 80 return; 81 } 82 fail(); 83 } 84 85 void check(Object result, boolean expected) { 86 check(result, Boolean.toString(expected)); 87 } 88 89 PathOps root(String expected) { 90 out.println("check root"); 91 checkPath(); 92 check(path.getRoot(), expected); 93 return this; 94 } 95 96 PathOps parent(String expected) { 97 out.println("check parent"); 98 checkPath(); 99 check(path.getParent(), expected); 100 return this; 101 } 102 103 PathOps name(String expected) { 104 out.println("check name"); 105 checkPath(); 106 check(path.getFileName(), expected); 107 return this; 108 } 109 110 PathOps element(int index, String expected) { 111 out.format("check element %d\n", index); 112 checkPath(); 113 check(path.getName(index), expected); 114 return this; 115 } 116 117 PathOps subpath(int startIndex, int endIndex, String expected) { 118 out.format("test subpath(%d,%d)\n", startIndex, endIndex); 119 checkPath(); 120 check(path.subpath(startIndex, endIndex), expected); 121 return this; 122 } 123 124 PathOps starts(String prefix) { 125 out.format("test startsWith with %s\n", prefix); 126 checkPath(); 127 Path s = fs.getPath(prefix); 128 check(path.startsWith(s), true); 129 return this; 130 } 131 132 PathOps notStarts(String prefix) { 133 out.format("test not startsWith with %s\n", prefix); 134 checkPath(); 135 Path s = fs.getPath(prefix); 136 check(path.startsWith(s), false); 137 return this; 138 } 139 140 PathOps ends(String suffix) { 141 out.format("test endsWith %s\n", suffix); 142 checkPath(); 143 Path s = fs.getPath(suffix); 144 check(path.endsWith(s), true); 145 return this; 146 } 147 148 PathOps notEnds(String suffix) { 149 out.format("test not endsWith %s\n", suffix); 150 checkPath(); 151 Path s = fs.getPath(suffix); 152 check(path.endsWith(s), false); 153 return this; 154 } 155 156 PathOps absolute() { 157 out.println("check path is absolute"); 158 checkPath(); 159 check(path.isAbsolute(), true); 160 return this; 161 } 162 163 PathOps notAbsolute() { 164 out.println("check path is not absolute"); 165 checkPath(); 166 check(path.isAbsolute(), false); 167 return this; 168 } 169 170 PathOps resolve(String other, String expected) { 171 out.format("test resolve %s\n", other); 172 checkPath(); 173 check(path.resolve(other), expected); 174 return this; 175 } 176 177 PathOps relativize(String other, String expected) { 178 out.format("test relativize %s\n", other); 179 checkPath(); 180 Path that = fs.getPath(other); 181 check(path.relativize(that), expected); 182 return this; 183 } 184 185 PathOps normalize(String expected) { 186 out.println("check normalized path"); 187 checkPath(); 188 check(path.normalize(), expected); 189 return this; 190 } 191 192 PathOps string(String expected) { 193 out.println("check string representation"); 194 checkPath(); 195 check(path, expected); 196 return this; 197 } 198 199 PathOps isSameFile(String target) { 200 try { 201 out.println("check two paths are same"); 202 checkPath(); 203 check(Files.isSameFile(path, test(target).path()), true); 204 } catch (IOException ioe) { 205 fail(); 206 } 207 return this; 208 } 209 210 PathOps invalid() { 211 if (!(exc instanceof InvalidPathException)) { 212 out.println("InvalidPathException not thrown as expected"); 213 fail(); 214 } 215 return this; 216 } 217 218 static PathOps test(String s) { 219 return new PathOps(s); 220 } 221 222 // -- PathOpss -- 223 224 static void header(String s) { 225 out.println(); 226 out.println(); 227 out.println("-- " + s + " --"); 228 } 229 230 static void doPathOpTests() { 231 header("Path operations"); 232 233 // all components 234 test("/a/b/c") 235 .root("/") 236 .parent("/a/b") 237 .name("c"); 238 239 // root component only 240 test("/") 241 .root("/") 242 .parent(null) 243 .name(null); 244 245 // no root component 246 test("a/b") 247 .root(null) 248 .parent("a") 249 .name("b"); 250 251 // name component only 252 test("foo") 253 .root(null) 254 .parent(null) 255 .name("foo"); 256 257 // startsWith 258 test("") 259 .starts("") 260 .notStarts("/"); 261 test("/") 262 .starts("/") 263 .notStarts("/foo"); 264 test("/foo") 265 .starts("/") 266 .starts("/foo") 267 .notStarts("/f") 268 .notStarts(""); 269 test("/foo/bar") 270 .starts("/") 271 .starts("/foo") 272 .starts("/foo/") 273 .starts("/foo/bar") 274 .notStarts("/f") 275 .notStarts("foo") 276 .notStarts("foo/bar") 277 .notStarts(""); 278 test("foo") 279 .starts("foo") 280 .notStarts("f"); 281 test("foo/bar") 282 .starts("foo") 283 .starts("foo/") 284 .starts("foo/bar") 285 .notStarts("f") 286 .notStarts("/foo") 287 .notStarts("/foo/bar"); 288 289 // endsWith 290 test("") 291 .ends("") 292 .notEnds("/"); 293 test("/") 294 .ends("/") 295 .notEnds("foo") 296 .notEnds("/foo"); 297 test("/foo") 298 .ends("foo") 299 .ends("/foo") 300 .notEnds("/"); 301 test("/foo/bar") 302 .ends("bar") 303 .ends("foo/bar") 304 .ends("foo/bar/") 305 .ends("/foo/bar") 306 .notEnds("/bar"); 307 test("/foo/bar/") 308 .ends("bar") 309 .ends("foo/bar") 310 .ends("foo/bar/") 311 .ends("/foo/bar") 312 .notEnds("/bar"); 313 test("foo") 314 .ends("foo"); 315 test("foo/bar") 316 .ends("bar") 317 .ends("bar/") 318 .ends("foo/bar/") 319 .ends("foo/bar"); 320 321 322 // elements 323 test("a/b/c") 324 .element(0,"a") 325 .element(1,"b") 326 .element(2,"c"); 327 328 // isAbsolute 329 test("/") 330 .absolute(); 331 test("/tmp") 332 .absolute(); 333 test("tmp") 334 .notAbsolute(); 335 test("") 336 .notAbsolute(); 337 338 // resolve 339 test("/tmp") 340 .resolve("foo", "/tmp/foo") 341 .resolve("/foo", "/foo"); 342 test("tmp") 343 .resolve("foo", "tmp/foo") 344 .resolve("/foo", "/foo"); 345 346 // relativize 347 test("/a/b/c") 348 .relativize("/a/b/c", "") 349 .relativize("/a/b/c/d/e", "d/e") 350 .relativize("/a/x", "../../x"); 351 352 // normalize 353 test("/") 354 .normalize("/"); 355 test("foo") 356 .normalize("foo"); 357 test("/foo") 358 .normalize("/foo"); 359 test(".") 360 .normalize(""); 361 test("..") 362 .normalize(".."); 363 test("/..") 364 .normalize("/"); 365 test("/../..") 366 .normalize("/"); 367 test("foo/.") 368 .normalize("foo"); 369 test("./foo") 370 .normalize("foo"); 371 test("foo/..") 372 .normalize(""); 373 test("../foo") 374 .normalize("../foo"); 375 test("../../foo") 376 .normalize("../../foo"); 377 test("foo/bar/..") 378 .normalize("foo"); 379 test("foo/bar/gus/../..") 380 .normalize("foo"); 381 test("/foo/bar/gus/../..") 382 .normalize("/foo"); 383 test("/./.") 384 .normalize("/"); 385 test("/.") 386 .normalize("/"); 387 test("/./abc") 388 .normalize("/abc"); 389 // invalid 390 test("foo\u0000bar") 391 .invalid(); 392 test("\u0000foo") 393 .invalid(); 394 test("bar\u0000") 395 .invalid(); 396 test("//foo\u0000bar") 397 .invalid(); 398 test("//\u0000foo") 399 .invalid(); 400 test("//bar\u0000") 401 .invalid(); 402 403 // normalization 404 test("//foo//bar") 405 .string("/foo/bar") 406 .root("/") 407 .parent("/foo") 408 .name("bar"); 409 410 // isSameFile 411 test("/fileDoesNotExist") 412 .isSameFile("/fileDoesNotExist"); 413 } 414 415 static void npes() { 416 header("NullPointerException"); 417 418 Path path = fs.getPath("foo"); 419 420 try { 421 path.resolve((String)null); 422 throw new RuntimeException("NullPointerException not thrown"); 423 } catch (NullPointerException npe) { 424 } 425 426 try { 427 path.relativize(null); 428 throw new RuntimeException("NullPointerException not thrown"); 429 } catch (NullPointerException npe) { 430 } 431 432 try { 433 path.compareTo(null); 434 throw new RuntimeException("NullPointerException not thrown"); 435 } catch (NullPointerException npe) { 436 } 437 438 try { 439 path.startsWith((Path)null); 440 throw new RuntimeException("NullPointerException not thrown"); 441 } catch (NullPointerException npe) { 442 } 443 444 try { 445 path.endsWith((Path)null); 446 throw new RuntimeException("NullPointerException not thrown"); 447 } catch (NullPointerException npe) { 448 } 449 450 } 451 452 public static void main(String[] args) throws Throwable { 453 Path zipfile = Paths.get(System.getProperty("test.jdk"), 454 "jre/lib/ext/zipfs.jar"); 455 fs = FileSystems.newFileSystem(zipfile, null); 456 npes(); 457 doPathOpTests(); 458 fs.close(); 459 } 460 }