Misc.java revision 893:f06f30b29f36
1/* 2 * Copyright 2008-2009 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, 20 * CA 95054 USA or visit www.sun.com if you need additional information or 21 * have any questions. 22 */ 23 24/* @test 25 * @bug 4313887 26 * @summary Unit test for java.nio.file.Path for miscellenous methods not 27 * covered by other tests 28 * @library .. 29 */ 30 31import java.nio.file.*; 32import static java.nio.file.LinkOption.*; 33import java.nio.file.attribute.*; 34import java.io.*; 35import java.util.*; 36 37public class Misc { 38 static final boolean isWindows = 39 System.getProperty("os.name").startsWith("Windows"); 40 static boolean supportsLinks; 41 42 public static void main(String[] args) throws IOException { 43 Path dir = TestUtil.createTemporaryDirectory(); 44 try { 45 supportsLinks = TestUtil.supportsLinks(dir); 46 47 // equals and hashCode methods 48 equalsAndHashCode(); 49 50 // checkAccess method 51 checkAccessTests(dir); 52 53 // getFileAttributeView methods 54 getFileAttributeViewTests(dir); 55 56 // toRealPath method 57 toRealPathTests(dir); 58 59 // isSameFile method 60 isSameFileTests(dir); 61 62 // isHidden method 63 isHiddenTests(dir); 64 65 } finally { 66 TestUtil.removeAll(dir); 67 } 68 } 69 70 /** 71 * Exercise equals and hashCode methods 72 */ 73 static void equalsAndHashCode() { 74 75 Path thisFile = Paths.get("this"); 76 Path thatFile = Paths.get("that"); 77 78 assertTrue(thisFile.equals(thisFile)); 79 assertTrue(!thisFile.equals(thatFile)); 80 81 assertTrue(!thisFile.equals(null)); 82 assertTrue(!thisFile.equals(new Object())); 83 84 Path likeThis = Paths.get("This"); 85 if (isWindows) { 86 // case insensitive 87 assertTrue(thisFile.equals(likeThis)); 88 assertTrue(thisFile.hashCode() == likeThis.hashCode()); 89 } else { 90 // case senstive 91 assertTrue(!thisFile.equals(likeThis)); 92 } 93 } 94 95 /** 96 * Exercise checkAccess method 97 */ 98 static void checkAccessTests(Path dir) throws IOException { 99 final Path file = dir.resolve("foo").createFile(); 100 101 /** 102 * Test: This directory should readable and writable 103 */ 104 dir.checkAccess(); 105 dir.checkAccess(AccessMode.READ); 106 dir.checkAccess(AccessMode.WRITE); 107 dir.checkAccess(AccessMode.READ, AccessMode.WRITE); 108 109 /** 110 * Test: File does not exist 111 */ 112 Path doesNotExist = dir.resolve("thisDoesNotExists"); 113 try { 114 doesNotExist.checkAccess(); 115 throw new RuntimeException("NoSuchFileException expected"); 116 } catch (NoSuchFileException x) { 117 } 118 try { 119 doesNotExist.checkAccess(AccessMode.READ); 120 throw new RuntimeException("NoSuchFileException expected"); 121 } catch (NoSuchFileException x) { 122 } 123 try { 124 doesNotExist.checkAccess(AccessMode.WRITE); 125 throw new RuntimeException("NoSuchFileException expected"); 126 } catch (NoSuchFileException x) { 127 } 128 try { 129 doesNotExist.checkAccess(AccessMode.EXECUTE); 130 throw new RuntimeException("NoSuchFileException expected"); 131 } catch (NoSuchFileException x) { 132 } 133 134 /** 135 * Test: Edit ACL to deny WRITE and EXECUTE 136 */ 137 AclFileAttributeView view = file 138 .getFileAttributeView(AclFileAttributeView.class); 139 if (view != null && 140 file.getFileStore().supportsFileAttributeView("acl")) 141 { 142 UserPrincipal owner = view.getOwner(); 143 List<AclEntry> acl = view.getAcl(); 144 145 // Insert entry to deny WRITE and EXECUTE 146 AclEntry entry = AclEntry.newBuilder() 147 .setType(AclEntryType.DENY) 148 .setPrincipal(owner) 149 .setPermissions(AclEntryPermission.WRITE_DATA, 150 AclEntryPermission.EXECUTE) 151 .build(); 152 acl.add(0, entry); 153 view.setAcl(acl); 154 155 try { 156 file.checkAccess(AccessMode.WRITE); 157 throw new RuntimeException("AccessDeniedException expected"); 158 } catch (AccessDeniedException x) { 159 } 160 161 try { 162 file.checkAccess(AccessMode.EXECUTE); 163 throw new RuntimeException("AccessDeniedException expected"); 164 } catch (AccessDeniedException x) { 165 } 166 167 168 // Restore ACL 169 acl.remove(0); 170 view.setAcl(acl); 171 } 172 173 /** 174 * Test: Windows DOS read-only attribute 175 */ 176 if (isWindows) { 177 DosFileAttributeView dview = 178 file.getFileAttributeView(DosFileAttributeView.class); 179 dview.setReadOnly(true); 180 try { 181 file.checkAccess(AccessMode.WRITE); 182 throw new RuntimeException("AccessDeniedException expected"); 183 } catch (AccessDeniedException x) { 184 } 185 dview.setReadOnly(false); 186 187 // Read-only attribute does not make direcory read-only 188 dview = dir.getFileAttributeView(DosFileAttributeView.class); 189 boolean save = dview.readAttributes().isReadOnly(); 190 dview.setReadOnly(true); 191 dir.checkAccess(AccessMode.WRITE); 192 dview.setReadOnly(save); 193 } 194 195 /** 196 * Test: null 197 */ 198 try { 199 file.checkAccess((AccessMode)null); 200 throw new RuntimeException("NullPointerException expected"); 201 } catch (NullPointerException ignore) { } 202 203 // clean-up 204 file.delete(); 205 } 206 207 /** 208 * Exercise getFileAttributeFile methods 209 */ 210 static void getFileAttributeViewTests(Path dir) { 211 assertTrue(dir.getFileAttributeView(BasicFileAttributeView.class) 212 instanceof BasicFileAttributeView); 213 assertTrue(dir.getFileAttributeView(BasicFileAttributeView.class, NOFOLLOW_LINKS) 214 instanceof BasicFileAttributeView); 215 assertTrue(dir.getFileAttributeView("basic") 216 instanceof BasicFileAttributeView); 217 assertTrue(dir.getFileAttributeView("basic", NOFOLLOW_LINKS) 218 instanceof BasicFileAttributeView); 219 assertTrue(dir.getFileAttributeView(BogusFileAttributeView.class) == null); 220 assertTrue(dir.getFileAttributeView("bogus") == null); 221 try { 222 dir.getFileAttributeView((Class<FileAttributeView>)null); 223 } catch (NullPointerException ignore) { } 224 try { 225 dir.getFileAttributeView(BasicFileAttributeView.class, (LinkOption[])null); 226 } catch (NullPointerException ignore) { } 227 try { 228 dir.getFileAttributeView(BasicFileAttributeView.class, (LinkOption)null); 229 } catch (NullPointerException ignore) { } 230 try { 231 dir.getFileAttributeView((String)null); 232 } catch (NullPointerException ignore) { } 233 try { 234 dir.getFileAttributeView("basic", (LinkOption[])null); 235 } catch (NullPointerException ignore) { } 236 try { 237 dir.getFileAttributeView("basic", (LinkOption)null); 238 } catch (NullPointerException ignore) { } 239 240 } 241 interface BogusFileAttributeView extends FileAttributeView { } 242 243 /** 244 * Exercise toRealPath method 245 */ 246 static void toRealPathTests(Path dir) throws IOException { 247 final Path file = dir.resolve("foo").createFile(); 248 final Path link = dir.resolve("link"); 249 250 /** 251 * Test: toRealPath(true) will access same file as toRealPath(false) 252 */ 253 assertTrue(file.toRealPath(true).isSameFile(file.toRealPath(false))); 254 255 /** 256 * Test: toRealPath(true) should resolve links 257 */ 258 if (supportsLinks) { 259 link.createSymbolicLink(file.toAbsolutePath()); 260 assertTrue(link.toRealPath(true).equals(file.toRealPath(true))); 261 link.delete(); 262 } 263 264 265 /** 266 * Test: toRealPath(false) should not resolve links 267 */ 268 if (supportsLinks) { 269 link.createSymbolicLink(file.toAbsolutePath()); 270 assertTrue(link.toRealPath(false).getName().equals(link.getName())); 271 link.delete(); 272 } 273 274 /** 275 * Test: toRealPath should eliminate "." 276 */ 277 assertTrue(dir.resolve(".").toRealPath(true).equals(dir.toRealPath(true))); 278 assertTrue(dir.resolve(".").toRealPath(false).equals(dir.toRealPath(false))); 279 280 /** 281 * Test: toRealPath should eliminate ".." when it doesn't follow a 282 * symbolic link 283 */ 284 Path subdir = dir.resolve("subdir").createDirectory(); 285 assertTrue(subdir.resolve("..").toRealPath(true).equals(dir.toRealPath(true))); 286 assertTrue(subdir.resolve("..").toRealPath(false).equals(dir.toRealPath(false))); 287 subdir.delete(); 288 289 // clean-up 290 file.delete(); 291 } 292 293 /** 294 * Exercise isSameFile method 295 */ 296 static void isSameFileTests(Path dir) throws IOException { 297 Path thisFile = dir.resolve("thisFile"); 298 Path thatFile = dir.resolve("thatFile"); 299 300 /** 301 * Test: isSameFile for self and null 302 */ 303 assertTrue(thisFile.isSameFile(thisFile)); 304 assertTrue(!thisFile.isSameFile(null)); 305 306 /** 307 * Test: Neither files exist 308 */ 309 try { 310 thisFile.isSameFile(thatFile); 311 throw new RuntimeException("IOException not thrown"); 312 } catch (IOException x) { 313 } 314 try { 315 thatFile.isSameFile(thisFile); 316 throw new RuntimeException("IOException not thrown"); 317 } catch (IOException x) { 318 } 319 320 thisFile.createFile(); 321 try { 322 /** 323 * Test: One file exists 324 */ 325 try { 326 thisFile.isSameFile(thatFile); 327 throw new RuntimeException("IOException not thrown"); 328 } catch (IOException x) { 329 } 330 try { 331 thatFile.isSameFile(thisFile); 332 throw new RuntimeException("IOException not thrown"); 333 } catch (IOException x) { 334 } 335 336 thatFile.createFile(); 337 338 /** 339 * Test: Both file exists 340 */ 341 try { 342 assertTrue(!thisFile.isSameFile(thatFile)); 343 assertTrue(!thatFile.isSameFile(thisFile)); 344 } finally { 345 TestUtil.deleteUnchecked(thatFile); 346 } 347 348 /** 349 * Test: Symbolic links 350 */ 351 if (supportsLinks) { 352 thatFile.createSymbolicLink(thisFile); 353 try { 354 assertTrue(thisFile.isSameFile(thatFile)); 355 assertTrue(thatFile.isSameFile(thisFile)); 356 } finally { 357 TestUtil.deleteUnchecked(thatFile); 358 } 359 } 360 } finally { 361 thisFile.delete(false); 362 } 363 } 364 365 /** 366 * Exercise isHidden method 367 */ 368 static void isHiddenTests(Path dir) throws IOException { 369 assertTrue(!dir.isHidden()); 370 371 Path file = dir.resolve(".foo"); 372 if (isWindows) { 373 file.createFile(); 374 try { 375 Attributes.setAttribute(file, "dos:hidden", true); 376 assertTrue(file.isHidden()); 377 } finally { 378 file.delete(); 379 } 380 } else { 381 assertTrue(file.isHidden()); 382 } 383 } 384 385 static void assertTrue(boolean okay) { 386 if (!okay) 387 throw new RuntimeException("Assertion Failed"); 388 } 389} 390