changeset 3478:312dc0abb960

7015391: (zipfs) Update zip provider for 1/2011 changes 7014948: (zipfs) ZipFileSystem.newFileSystem(Path...) should not throw FileSystemAlreadyExistsException 7015139: (zipfs) ZipPath.delete() should throw DirectoryNotEmptyException when handling "real, non-empty" dir Summary: zip filesystem provider update Reviewed-by: alanb
author sherman
date Tue, 01 Feb 2011 14:20:01 -0800
parents 21d7cd823247
children 25462d7eee24 1b5c838b8db8
files make/mkdemo/Makefile src/share/demo/nio/zipfs/Demo.java src/share/demo/nio/zipfs/README.txt src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipFileAttributeView.java src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipFileStore.java src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipFileSystem.java src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipFileSystemProvider.java src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipPath.java src/share/demo/zipfs test/demo/zipfs/Basic.java test/demo/zipfs/PathOps.java test/demo/zipfs/ZipFSTester.java test/demo/zipfs/basic.sh
diffstat 13 files changed, 705 insertions(+), 1408 deletions(-) [+]
line wrap: on
line diff
--- a/make/mkdemo/Makefile	Tue Feb 01 21:00:09 2011 +0530
+++ b/make/mkdemo/Makefile	Tue Feb 01 14:20:01 2011 -0800
@@ -31,7 +31,7 @@
 PRODUCT = demos
 include $(BUILDDIR)/common/Defs.gmk
 
-SUBDIRS            = jni
+SUBDIRS            = jni nio
 SUBDIRS_desktop    = applets jfc
 SUBDIRS_management = management
 SUBDIRS_misc       = scripting
--- a/src/share/demo/nio/zipfs/Demo.java	Tue Feb 01 21:00:09 2011 +0530
+++ b/src/share/demo/nio/zipfs/Demo.java	Tue Feb 01 14:20:01 2011 -0800
@@ -33,6 +33,7 @@
 import java.nio.*;
 import java.nio.channels.*;
 import java.nio.file.*;
+import java.nio.file.spi.*;
 import java.nio.file.attribute.*;
 import java.net.*;
 import java.text.DateFormat;
@@ -144,16 +145,17 @@
     }
 
     public static void main(String[] args) throws Throwable {
+        FileSystemProvider provider = getZipFSProvider();
+        if (provider == null) {
+            System.err.println("ZIP filesystem provider is not installed");
+            System.exit(1);
+        }
 
         Action action = Action.valueOf(args[0]);
         Map<String, Object> env = env = new HashMap<>();
         if (action == Action.create)
             env.put("create", "true");
-        if (action == Action.tlist || action == Action.twalk)
-            env.put("buildDirTree", true);
-        FileSystem fs = FileSystems.newFileSystem(Paths.get(args[1]), env, null);
-
-        try {
+        try (FileSystem fs = provider.newFileSystem(Paths.get(args[1]), env)) {
             FileSystem fs2;
             Path path, src, dst;
             boolean isRename = false;
@@ -161,61 +163,59 @@
             case rename:
                 src = fs.getPath(args[2]);
                 dst = fs.getPath(args[3]);
-                src.moveTo(dst);
+                Files.move(src, dst);
                 break;
             case moveout:
                 src = fs.getPath(args[2]);
                 dst = Paths.get(args[3]);
-                src.moveTo(dst);
+                Files.move(src, dst);
                 break;
             case movein:
                 src = Paths.get(args[2]);
                 dst = fs.getPath(args[3]);
-                src.moveTo(dst);
+                Files.move(src, dst);
                 break;
             case copy:
                 src = fs.getPath(args[2]);
                 dst = fs.getPath(args[3]);
-                src.copyTo(dst);
+                Files.copy(src, dst);
                 break;
             case copyout:
                 src = fs.getPath(args[2]);
                 dst = Paths.get(args[3]);
-                src.copyTo(dst);
+                Files.copy(src, dst);
                 break;
             case copyin:
                 src = Paths.get(args[2]);
                 dst = fs.getPath(args[3]);
-                src.copyTo(dst);
+                Files.copy(src, dst);
                 break;
             case copyin_attrs:
                 src = Paths.get(args[2]);
                 dst = fs.getPath(args[3]);
-                src.copyTo(dst, COPY_ATTRIBUTES);
+                Files.copy(src, dst, COPY_ATTRIBUTES);
                 break;
             case copyout_attrs:
                 src = fs.getPath(args[2]);
                 dst = Paths.get(args[3]);
-                src.copyTo(dst, COPY_ATTRIBUTES);
+                Files.copy(src, dst, COPY_ATTRIBUTES);
                 break;
             case zzmove:
-                fs2 = FileSystems.newFileSystem(Paths.get(args[2]), env, null);
-                //sf1.getPath(args[3]).moveTo(fs2.getPath(args[3]));
-                z2zmove(fs, fs2, args[3]);
-                fs2.close();
+                try (fs2 = provider.newFileSystem(Paths.get(args[2]), env)) {
+                    z2zmove(fs, fs2, args[3]);
+                }
                 break;
             case zzcopy:
-                fs2 = FileSystems.newFileSystem(Paths.get(args[2]), env, null);
-                //sf1.getPath(args[3]).copyTo(fs2.getPath(args[3]));
-                z2zcopy(fs, fs2, args[3]);
-                fs2.close();
+                try (fs2 = provider.newFileSystem(Paths.get(args[2]), env)) {
+                    z2zcopy(fs, fs2, args[3]);
+                }
                 break;
             case attrs:
                 for (int i = 2; i < args.length; i++) {
                     path = fs.getPath(args[i]);
                     System.out.println(path);
                     System.out.println(
-                        Attributes.readBasicFileAttributes(path).toString());
+                        Files.readAttributes(path, BasicFileAttributes.class).toString());
                 }
                 break;
             case setmtime:
@@ -223,10 +223,10 @@
                 Date newDatetime = df.parse(args[2]);
                 for (int i = 3; i < args.length; i++) {
                     path = fs.getPath(args[i]);
-                    path.setAttribute("lastModifiedTime",
-                                      FileTime.fromMillis(newDatetime.getTime()));
+                    Files.setAttribute(path, "lastModifiedTime",
+                                       FileTime.fromMillis(newDatetime.getTime()));
                     System.out.println(
-                        Attributes.readBasicFileAttributes(path).toString());
+                        Files.readAttributes(path, BasicFileAttributes.class).toString());
                 }
                 break;
             case setctime:
@@ -234,10 +234,10 @@
                 newDatetime = df.parse(args[2]);
                 for (int i = 3; i < args.length; i++) {
                     path = fs.getPath(args[i]);
-                    path.setAttribute("creationTime",
-                                      FileTime.fromMillis(newDatetime.getTime()));
+                    Files.setAttribute(path, "creationTime",
+                                       FileTime.fromMillis(newDatetime.getTime()));
                     System.out.println(
-                        Attributes.readBasicFileAttributes(path).toString());
+                        Files.readAttributes(path, BasicFileAttributes.class).toString());
                 }
                 break;
             case setatime:
@@ -245,25 +245,22 @@
                 newDatetime = df.parse(args[2]);
                 for (int i = 3; i < args.length; i++) {
                     path = fs.getPath(args[i]);
-                    path.setAttribute("lastAccessTime",
-                                      FileTime.fromMillis(newDatetime.getTime()));
+                    Files.setAttribute(path, "lastAccessTime",
+                                       FileTime.fromMillis(newDatetime.getTime()));
                     System.out.println(
-                        Attributes.readBasicFileAttributes(path).toString());
+                        Files.readAttributes(path, BasicFileAttributes.class).toString());
                 }
                 break;
             case attrsspace:
                 path = fs.getPath("/");
-                FileStore fstore = path.getFileStore();
-                //System.out.println(fstore.getFileStoreAttributeView(FileStoreSpaceAttributeView.class)
-                //                         .readAttributes());
-                // or
+                FileStore fstore = Files.getFileStore(path);
                 System.out.printf("filestore[%s]%n", fstore.name());
                 System.out.printf("    totalSpace: %d%n",
-                                  (Long)fstore.getAttribute("space:totalSpace"));
+                                  (Long)fstore.getAttribute("totalSpace"));
                 System.out.printf("   usableSpace: %d%n",
-                                  (Long)fstore.getAttribute("space:usableSpace"));
+                                  (Long)fstore.getAttribute("usableSpace"));
                 System.out.printf("  unallocSpace: %d%n",
-                                  (Long)fstore.getAttribute("space:unallocatedSpace"));
+                                  (Long)fstore.getAttribute("unallocatedSpace"));
                 break;
             case list:
             case tlist:
@@ -293,7 +290,7 @@
                 break;
             case delete:
                 for (int i = 2; i < args.length; i++)
-                    fs.getPath(args[i]).delete();
+                    Files.delete(fs.getPath(args[i]));
                 break;
             case create:
             case add:
@@ -305,17 +302,19 @@
             case lsdir:
                 path = fs.getPath(args[2]);
                 final String fStr = (args.length > 3)?args[3]:"";
-                DirectoryStream<Path> ds = path.newDirectoryStream(
+                try (DirectoryStream<Path> ds = Files.newDirectoryStream(path,
                     new DirectoryStream.Filter<Path>() {
                         public boolean accept(Path path) {
                             return path.toString().contains(fStr);
                         }
-                    });
-                for (Path p : ds)
-                    System.out.println(p);
+                    }))
+                {
+                    for (Path p : ds)
+                        System.out.println(p);
+                }
                 break;
             case mkdir:
-                fs.getPath(args[2]).createDirectory();
+                Files.createDirectory(fs.getPath(args[2]));
                 break;
             case mkdirs:
                 mkdirs(fs.getPath(args[2]));
@@ -326,14 +325,14 @@
                     System.out.printf("%n%s%n", path);
                     System.out.println("-------(1)---------");
                     System.out.println(
-                        Attributes.readBasicFileAttributes(path).toString());
+                        Files.readAttributes(path, BasicFileAttributes.class).toString());
                     System.out.println("-------(2)---------");
-                    Map<String, ?> map = path.readAttributes("zip:*");
-                    for (Map.Entry<String, ?> e : map.entrySet()) {
+                    Map<String, Object> map = Files.readAttributes(path, "zip:*");
+                    for (Map.Entry<String, Object> e : map.entrySet()) {
                         System.out.printf("    %s : %s%n", e.getKey(), e.getValue());
                     }
                     System.out.println("-------(3)---------");
-                    map = path.readAttributes("size,lastModifiedTime,isDirectory");
+                    map = Files.readAttributes(path, "size,lastModifiedTime,isDirectory");
                     for (Map.Entry<String, ?> e : map.entrySet()) {
                         System.out.printf("    %s : %s%n", e.getKey(), e.getValue());
                     }
@@ -349,12 +348,17 @@
             }
         } catch (Exception x) {
             x.printStackTrace();
-        } finally {
-            if (fs != null)
-                fs.close();
         }
     }
 
+    private static FileSystemProvider getZipFSProvider() {
+        for (FileSystemProvider provider : FileSystemProvider.installedProviders()) {
+            if ("jar".equals(provider.getScheme()))
+                return provider;
+        }
+        return null;
+    }
+
     private static byte[] getBytes(String name) {
         return name.getBytes();
     }
@@ -380,7 +384,7 @@
                                                  BasicFileAttributes attrs)
                 {
                     indent();
-                    System.out.printf("%s%n", file.getName().toString());
+                    System.out.printf("%s%n", file.getFileName().toString());
                     return FileVisitResult.CONTINUE;
                 }
 
@@ -406,35 +410,35 @@
 
     private static void update(FileSystem fs, String path) throws Throwable{
         Path src = FileSystems.getDefault().getPath(path);
-        if (Boolean.TRUE.equals(src.getAttribute("isDirectory"))) {
-            DirectoryStream<Path> ds = src.newDirectoryStream();
-            for (Path child : ds)
-                update(fs, child.toString());
-            ds.close();
+        if (Files.isDirectory(src)) {
+            try (DirectoryStream<Path> ds = Files.newDirectoryStream(src)) {
+                for (Path child : ds)
+                    update(fs, child.toString());
+            }
         } else {
             Path dst = fs.getPath(path);
             Path parent = dst.getParent();
-            if (parent != null && parent.notExists())
+            if (parent != null && Files.notExists(parent))
                 mkdirs(parent);
-            src.copyTo(dst, REPLACE_EXISTING);
+            Files.copy(src, dst, REPLACE_EXISTING);
         }
     }
 
     private static void extract(FileSystem fs, String path) throws Throwable{
         Path src = fs.getPath(path);
-        if (Boolean.TRUE.equals(src.getAttribute("isDirectory"))) {
-            DirectoryStream<Path> ds = src.newDirectoryStream();
-            for (Path child : ds)
-                extract(fs, child.toString());
-            ds.close();
+        if (Files.isDirectory(src)) {
+            try (DirectoryStream<Path> ds = Files.newDirectoryStream(src)) {
+                for (Path child : ds)
+                    extract(fs, child.toString());
+            }
         } else {
             if (path.startsWith("/"))
                 path = path.substring(1);
             Path dst = FileSystems.getDefault().getPath(path);
             Path parent = dst.getParent();
-            if (parent.notExists())
+            if (Files.notExists(parent))
                 mkdirs(parent);
-            src.copyTo(dst, REPLACE_EXISTING);
+            Files.copy(src, dst, REPLACE_EXISTING);
         }
     }
 
@@ -445,21 +449,21 @@
         Path srcPath = src.getPath(path);
         Path dstPath = dst.getPath(path);
 
-        if (Boolean.TRUE.equals(srcPath.getAttribute("isDirectory"))) {
-            if (!dstPath.exists()) {
+        if (Files.isDirectory(srcPath)) {
+            if (!Files.exists(dstPath)) {
                 try {
                     mkdirs(dstPath);
                 } catch (FileAlreadyExistsException x) {}
             }
-            DirectoryStream<Path> ds = srcPath.newDirectoryStream();
-            for (Path child : ds) {
-                z2zcopy(src, dst,
-                        path + (path.endsWith("/")?"":"/") + child.getName());
+            try (DirectoryStream<Path> ds = Files.newDirectoryStream(srcPath)) {
+                for (Path child : ds) {
+                    z2zcopy(src, dst,
+                            path + (path.endsWith("/")?"":"/") + child.getFileName());
+                }
             }
-            ds.close();
         } else {
             //System.out.println("copying..." + path);
-            srcPath.copyTo(dstPath);
+            Files.copy(srcPath, dstPath);
         }
     }
 
@@ -480,9 +484,9 @@
                 dst = dstPath.resolve(dst);
                 try {
                     Path parent = dstPath.getParent();
-                    if (parent != null && parent.notExists())
+                    if (parent != null && Files.notExists(parent))
                         mkdirs(parent);
-                    file.moveTo(dst);
+                    Files.move(file, dst);
                 } catch (IOException x) {
                     x.printStackTrace();
                 }
@@ -497,7 +501,7 @@
                 dst = dstPath.resolve(dst);
                 try {
 
-                    if (dst.notExists())
+                    if (Files.notExists(dst))
                         mkdirs(dst);
                 } catch (IOException x) {
                     x.printStackTrace();
@@ -511,7 +515,7 @@
                 throws IOException
             {
                 try {
-                    dir.delete();
+                    Files.delete(dir);
                 } catch (IOException x) {
                     //x.printStackTrace();
                 }
@@ -525,15 +529,15 @@
         path = path.toAbsolutePath();
         Path parent = path.getParent();
         if (parent != null) {
-            if (parent.notExists())
+            if (Files.notExists(parent))
                 mkdirs(parent);
         }
-        path.createDirectory();
+        Files.createDirectory(path);
     }
 
     private static void rmdirs(Path path) throws IOException {
         while (path != null && path.getNameCount() != 0) {
-            path.delete();
+            Files.delete(path);
             path = path.getParent();
         }
     }
@@ -542,15 +546,15 @@
         if (!"/".equals(path.toString())) {
            System.out.printf("  %s%n", path.toString());
            if (verbose)
-                System.out.println(Attributes.readBasicFileAttributes(path).toString());
+                System.out.println(Files.readAttributes(path, BasicFileAttributes.class).toString());
         }
-        if (path.notExists())
+        if (Files.notExists(path))
             return;
-        if (Attributes.readBasicFileAttributes(path).isDirectory()) {
-            DirectoryStream<Path> ds = path.newDirectoryStream();
-            for (Path child : ds)
-                list(child, verbose);
-            ds.close();
+        if (Files.isDirectory(path)) {
+            try (DirectoryStream<Path> ds = Files.newDirectoryStream(path)) {
+                for (Path child : ds)
+                    list(child, verbose);
+            }
         }
     }
 
@@ -561,12 +565,11 @@
         //                  src.toString(), dst.toString());
 
         //streams
-        InputStream isSrc = src.newInputStream();
-        InputStream isDst = dst.newInputStream();
         byte[] bufSrc = new byte[8192];
         byte[] bufDst = new byte[8192];
-
-        try {
+        try (InputStream isSrc = Files.newInputStream(src);
+             InputStream isDst = Files.newInputStream(dst))
+        {
             int nSrc = 0;
             while ((nSrc = isSrc.read(bufSrc)) != -1) {
                 int nDst = 0;
@@ -588,24 +591,22 @@
                     nSrc--;
                 }
             }
-        } finally {
-            isSrc.close();
-            isDst.close();
         }
 
         // channels
-        SeekableByteChannel chSrc = src.newByteChannel();
-        SeekableByteChannel chDst = dst.newByteChannel();
-        if (chSrc.size() != chDst.size()) {
-            System.out.printf("src[%s].size=%d, dst[%s].size=%d%n",
-                              chSrc.toString(), chSrc.size(),
-                              chDst.toString(), chDst.size());
-            throw new RuntimeException("CHECK FAILED!");
-        }
-        ByteBuffer bbSrc = ByteBuffer.allocate(8192);
-        ByteBuffer bbDst = ByteBuffer.allocate(8192);
 
-        try {
+        try (SeekableByteChannel chSrc = Files.newByteChannel(src);
+             SeekableByteChannel chDst = Files.newByteChannel(dst))
+        {
+            if (chSrc.size() != chDst.size()) {
+                System.out.printf("src[%s].size=%d, dst[%s].size=%d%n",
+                                  chSrc.toString(), chSrc.size(),
+                                  chDst.toString(), chDst.size());
+                throw new RuntimeException("CHECK FAILED!");
+            }
+            ByteBuffer bbSrc = ByteBuffer.allocate(8192);
+            ByteBuffer bbDst = ByteBuffer.allocate(8192);
+
             int nSrc = 0;
             while ((nSrc = chSrc.read(bbSrc)) != -1) {
                 int nDst = chDst.read(bbDst);
@@ -627,9 +628,6 @@
             }
         } catch (IOException x) {
             x.printStackTrace();
-        } finally {
-            chSrc.close();
-            chDst.close();
         }
     }
 
@@ -641,23 +639,15 @@
         openwrite.add(CREATE_NEW);
         openwrite.add(WRITE);
 
-        FileChannel srcFc = src.getFileSystem()
-                               .provider()
-                               .newFileChannel(src, read);
-        FileChannel dstFc = dst.getFileSystem()
-                               .provider()
-                               .newFileChannel(dst, openwrite);
-
-        try {
+        try (FileChannel srcFc = src.getFileSystem().provider().newFileChannel(src, read);
+             FileChannel dstFc = dst.getFileSystem().provider().newFileChannel(dst, openwrite))
+        {
             ByteBuffer bb = ByteBuffer.allocate(8192);
             while (srcFc.read(bb) >= 0) {
                 bb.flip();
                 dstFc.write(bb);
                 bb.clear();
             }
-        } finally {
-            srcFc.close();
-            dstFc.close();
         }
     }
 
@@ -669,35 +659,28 @@
         openwrite.add(CREATE_NEW);
         openwrite.add(WRITE);
 
-        SeekableByteChannel srcCh = src.newByteChannel(read);
-        SeekableByteChannel dstCh = dst.newByteChannel(openwrite);
-
-        try {
+        try (SeekableByteChannel srcCh = Files.newByteChannel(src, read);
+             SeekableByteChannel dstCh = Files.newByteChannel(dst, openwrite))
+        {
             ByteBuffer bb = ByteBuffer.allocate(8192);
             while (srcCh.read(bb) >= 0) {
                 bb.flip();
                 dstCh.write(bb);
                 bb.clear();
             }
-        } finally {
-            srcCh.close();
-            dstCh.close();
         }
     }
 
     private static void streamCopy(Path src, Path dst) throws IOException
     {
-        InputStream isSrc = src.newInputStream();
-        OutputStream osDst = dst.newOutputStream();
         byte[] buf = new byte[8192];
-        try {
+        try (InputStream isSrc = Files.newInputStream(src);
+             OutputStream osDst = Files.newOutputStream(dst))
+        {
             int n = 0;
             while ((n = isSrc.read(buf)) != -1) {
                 osDst.write(buf, 0, n);
             }
-        } finally {
-            isSrc.close();
-            osDst.close();
         }
     }
 }
--- a/src/share/demo/nio/zipfs/README.txt	Tue Feb 01 21:00:09 2011 +0530
+++ b/src/share/demo/nio/zipfs/README.txt	Tue Feb 01 14:20:01 2011 -0800
@@ -5,9 +5,8 @@
 used to create a FileSystem, eg:
 
    // use file type detection
-   Map<String,?> env = Collections.emptyMap();
    Path jarfile = Paths.get("foo.jar");
-   FileSystem fs = FileSystems.newFileSystem(jarfile, env, null);
+   FileSystem fs = FileSystems.newFileSystem(jarfile, null);
 
 -or
 
--- a/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipFileAttributeView.java	Tue Feb 01 21:00:09 2011 +0530
+++ b/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipFileAttributeView.java	Tue Feb 01 14:20:01 2011 -0800
@@ -32,11 +32,10 @@
 
 package com.sun.nio.zipfs;
 
-import java.nio.file.attribute.BasicFileAttributeView;
-import java.nio.file.attribute.FileAttributeView;
-import java.nio.file.attribute.FileTime;
+import java.nio.file.attribute.*;
 import java.io.IOException;
 import java.util.LinkedHashMap;
+import java.util.Map;
 
 /*
  * @author  Xueming Shen, Rajendra Gutupalli, Jaya Hangal
@@ -122,25 +121,19 @@
             "' is unknown or read-only attribute");
     }
 
-    public Object getAttribute(String attribute, boolean domap)
+    Map<String, Object> readAttributes(String attributes)
         throws IOException
     {
         ZipFileAttributes zfas = readAttributes();
-        if (!domap) {
-            try {
-                return attribute(AttrID.valueOf(attribute), zfas);
-            } catch (IllegalArgumentException x) {}
-            return null;
-        }
         LinkedHashMap<String, Object> map = new LinkedHashMap<>();
-        if ("*".equals(attribute)) {
+        if ("*".equals(attributes)) {
             for (AttrID id : AttrID.values()) {
                 try {
                     map.put(id.name(), attribute(id, zfas));
                 } catch (IllegalArgumentException x) {}
             }
         } else {
-            String[] as = attribute.split(",");
+            String[] as = attributes.split(",");
             for (String a : as) {
                 try {
                     map.put(a, attribute(AttrID.valueOf(a), zfas));
--- a/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipFileStore.java	Tue Feb 01 21:00:09 2011 +0530
+++ b/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipFileStore.java	Tue Feb 01 14:20:01 2011 -0800
@@ -32,14 +32,13 @@
 package com.sun.nio.zipfs;
 
 import java.io.IOException;
+import java.nio.file.Files;
 import java.nio.file.FileStore;
 import java.nio.file.FileSystems;
 import java.nio.file.Path;
+import java.nio.file.attribute.BasicFileAttributes;
 import java.nio.file.attribute.FileAttributeView;
 import java.nio.file.attribute.FileStoreAttributeView;
-import java.nio.file.attribute.FileStoreSpaceAttributeView;
-import java.nio.file.attribute.FileStoreSpaceAttributes;
-import java.nio.file.attribute.Attributes;
 import java.nio.file.attribute.BasicFileAttributeView;
 import java.util.Formatter;
 
@@ -87,71 +86,61 @@
     public <V extends FileStoreAttributeView> V getFileStoreAttributeView(Class<V> type) {
         if (type == null)
             throw new NullPointerException();
-        if (type == FileStoreSpaceAttributeView.class)
-            return (V) new ZipFileStoreAttributeView(this);
-        return null;
+        return (V)null;
+    }
+
+    @Override
+    public long getTotalSpace() throws IOException {
+         return new ZipFileStoreAttributes(this).totalSpace();
+    }
+
+    @Override
+    public long getUsableSpace() throws IOException {
+         return new ZipFileStoreAttributes(this).usableSpace();
+    }
+
+    @Override
+    public long getUnallocatedSpace() throws IOException {
+         return new ZipFileStoreAttributes(this).unallocatedSpace();
     }
 
     @Override
     public Object getAttribute(String attribute) throws IOException {
-         if (attribute.equals("space:totalSpace"))
-               return new ZipFileStoreAttributeView(this).readAttributes().totalSpace();
-         if (attribute.equals("space:usableSpace"))
-               return new ZipFileStoreAttributeView(this).readAttributes().usableSpace();
-         if (attribute.equals("space:unallocatedSpace"))
-               return new ZipFileStoreAttributeView(this).readAttributes().unallocatedSpace();
+         if (attribute.equals("totalSpace"))
+               return getTotalSpace();
+         if (attribute.equals("usableSpace"))
+               return getUsableSpace();
+         if (attribute.equals("unallocatedSpace"))
+               return getUnallocatedSpace();
          throw new UnsupportedOperationException("does not support the given attribute");
     }
 
-    private static class ZipFileStoreAttributeView implements FileStoreSpaceAttributeView {
+    private static class ZipFileStoreAttributes {
+        final FileStore fstore;
+        final long size;
 
-        private final ZipFileStore fileStore;
-
-        public ZipFileStoreAttributeView(ZipFileStore fileStore) {
-            this.fileStore = fileStore;
+        public ZipFileStoreAttributes(ZipFileStore fileStore)
+            throws IOException
+        {
+            Path path = FileSystems.getDefault().getPath(fileStore.name());
+            this.size = Files.size(path);
+            this.fstore = Files.getFileStore(path);
         }
 
-        @Override
-        public String name() {
-            return "space";
+        public long totalSpace() {
+            return size;
         }
 
-        @Override
-        public FileStoreSpaceAttributes readAttributes() throws IOException {
-            final String file = fileStore.name();
-            Path path = FileSystems.getDefault().getPath(file);
-            final long size = Attributes.readBasicFileAttributes(path).size();
-            final FileStore fstore = path.getFileStore();
-            final FileStoreSpaceAttributes fstoreAttrs =
-                Attributes.readFileStoreSpaceAttributes(fstore);
-            return new FileStoreSpaceAttributes() {
-                public long totalSpace() {
-                    return size;
-                }
+        public long usableSpace() throws IOException {
+            if (!fstore.isReadOnly())
+                return fstore.getUsableSpace();
+            return 0;
+        }
 
-                public long usableSpace() {
-                    if (!fstore.isReadOnly())
-                        return fstoreAttrs.usableSpace();
-                    return 0;
-                }
-
-                public long unallocatedSpace() {
-                    if (!fstore.isReadOnly())
-                        return fstoreAttrs.unallocatedSpace();
-                    return 0;
-                }
-
-                public String toString() {
-                    StringBuilder sb = new StringBuilder();
-                    Formatter fm = new Formatter(sb);
-                    fm.format("FileStoreSpaceAttributes[%s]%n", file);
-                    fm.format("      totalSpace: %d%n", totalSpace());
-                    fm.format("     usableSpace: %d%n", usableSpace());
-                    fm.format("    unallocSpace: %d%n", unallocatedSpace());
-                    fm.close();
-                    return sb.toString();
-                }
-            };
+        public long unallocatedSpace()  throws IOException {
+            if (!fstore.isReadOnly())
+                return fstore.getUnallocatedSpace();
+            return 0;
         }
     }
 }
--- a/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipFileSystem.java	Tue Feb 01 21:00:09 2011 +0530
+++ b/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipFileSystem.java	Tue Feb 01 14:20:01 2011 -0800
@@ -101,24 +101,25 @@
 
         this.provider = provider;
         this.zfpath = zfpath;
-        if (zfpath.notExists()) {
+        if (Files.notExists(zfpath)) {
             if (createNew) {
-                OutputStream os = zfpath.newOutputStream(CREATE_NEW, WRITE);
-                new END().write(os, 0);
-                os.close();
+                try (OutputStream os = Files.newOutputStream(zfpath, CREATE_NEW, WRITE)) {
+                    new END().write(os, 0);
+                }
             } else {
                 throw new FileSystemNotFoundException(zfpath.toString());
             }
         }
-        zfpath.checkAccess(AccessMode.READ); // sm and existence check
+        // sm and existence check
+        zfpath.getFileSystem().provider().checkAccess(zfpath, AccessMode.READ);
         try {
-            zfpath.checkAccess(AccessMode.WRITE);
+            zfpath.getFileSystem().provider().checkAccess(zfpath, AccessMode.WRITE);
         } catch (AccessDeniedException x) {
             this.readOnly = true;
         }
         this.zc = ZipCoder.get(nameEncoding);
         this.defaultdir = new ZipPath(this, getBytes(defaultDir));
-        this.ch = zfpath.newByteChannel(READ);
+        this.ch = Files.newByteChannel(zfpath, READ);
         this.cen = initCEN();
     }
 
@@ -159,9 +160,22 @@
     }
 
     @Override
-    public ZipPath getPath(String path) {
-        if (path.length() == 0)
-            throw new InvalidPathException(path, "path should not be empty");
+    public ZipPath getPath(String first, String... more) {
+        String path;
+        if (more.length == 0) {
+            path = first;
+        } else {
+            StringBuilder sb = new StringBuilder();
+            sb.append(first);
+            for (String segment: more) {
+                if (segment.length() > 0) {
+                    if (sb.length() > 0)
+                        sb.append('/');
+                    sb.append(segment);
+                }
+            }
+            path = sb.toString();
+        }
         return new ZipPath(this, getBytes(path));
     }
 
@@ -268,16 +282,22 @@
                 def.end();
         }
 
+        IOException ioe = null;
         synchronized (tmppaths) {
             for (Path p: tmppaths) {
                 try {
-                    p.deleteIfExists();
+                    Files.deleteIfExists(p);
                 } catch (IOException x) {
-                    x.printStackTrace();
+                    if (ioe == null)
+                        ioe = x;
+                    else
+                        ioe.addSuppressed(x);
                 }
             }
         }
-        provider.removeFileSystem(zfpath);
+        provider.removeFileSystem(zfpath, this);
+        if (ioe != null)
+           throw ioe;
     }
 
     ZipFileAttributes getFileAttributes(byte[] path)
@@ -444,7 +464,7 @@
                         u.bytes = Arrays.copyOf(eSrc.bytes, eSrc.bytes.length);
                     else if (eSrc.file != null) {
                         u.file = getTempPathForEntry(null);
-                        eSrc.file.copyTo(u.file, REPLACE_EXISTING);
+                        Files.copy(eSrc.file, u.file, REPLACE_EXISTING);
                     }
                 }
             }
@@ -778,7 +798,8 @@
                     fch.close();
                     if (forWrite) {
                         u.mtime = System.currentTimeMillis();
-                        u.size = Attributes.readBasicFileAttributes(u.file).size();
+                        u.size = Files.size(u.file);
+
                         update(u);
                     } else {
                         if (!isFCH)    // if this is a new fch for reading
@@ -805,13 +826,8 @@
         if (path != null) {
             Entry e = getEntry0(path);
             if (e != null) {
-                InputStream is = newInputStream(path);
-                OutputStream os = tmpPath.newOutputStream(WRITE);
-                try {
-                    copyStream(is, os);
-                } finally {
-                    is.close();
-                    os.close();
+                try (InputStream is = newInputStream(path)) {
+                    Files.copy(is, tmpPath, REPLACE_EXISTING);
                 }
             }
         }
@@ -819,7 +835,7 @@
     }
 
     private void removeTempPathForEntry(Path path) throws IOException {
-        path.delete();
+        Files.delete(path);
         tmppaths.remove(path);
     }
 
@@ -1073,11 +1089,11 @@
     // shared key. consumer guarantees the "writeLock" before use it.
     private final IndexNode LOOKUPKEY = IndexNode.keyOf(null);
 
-    private void updateDelete(Entry e) {
+    private void updateDelete(IndexNode inode) {
         beginWrite();
         try {
-            removeFromTree(e);
-            inodes.remove(e);
+            removeFromTree(inode);
+            inodes.remove(inode);
             hasUpdate = true;
         } finally {
              endWrite();
@@ -1158,7 +1174,7 @@
             for (ExChannelCloser ecc : exChClosers) {
                 if (ecc.streams.isEmpty()) {
                     ecc.ch.close();
-                    ecc.path.delete();
+                    Files.delete(ecc.path);
                     exChClosers.remove(ecc);
                 }
             }
@@ -1166,7 +1182,7 @@
         if (!hasUpdate)
             return;
         Path tmpFile = createTempFileInSameDirectoryAs(zfpath);
-        OutputStream os = tmpFile.newOutputStream(WRITE);
+        OutputStream os = Files.newOutputStream(tmpFile, WRITE);
         ArrayList<Entry> elist = new ArrayList<>(inodes.size());
         long written = 0;
         byte[] buf = new byte[8192];
@@ -1191,26 +1207,26 @@
                             os.write(e.bytes);        // already
                             written += e.bytes.length;
                         } else if (e.file != null) {  // tmp file
-                            InputStream is = e.file.newInputStream();
-                            int n;
-                            if (e.type == Entry.NEW) {  // deflated already
-                                while ((n = is.read(buf)) != -1) {
-                                    os.write(buf, 0, n);
-                                    written += n;
+                            try (InputStream is = Files.newInputStream(e.file)) {
+                                int n;
+                                if (e.type == Entry.NEW) {  // deflated already
+                                    while ((n = is.read(buf)) != -1) {
+                                        os.write(buf, 0, n);
+                                        written += n;
+                                    }
+                                } else if (e.type == Entry.FILECH) {
+                                    // the data are not deflated, use ZEOS
+                                    try (OutputStream os2 = new EntryOutputStream(e, os)) {
+                                        while ((n = is.read(buf)) != -1) {
+                                            os2.write(buf, 0, n);
+                                        }
+                                    }
+                                    written += e.csize;
+                                    if ((e.flag & FLAG_DATADESCR) != 0)
+                                        written += e.writeEXT(os);
                                 }
-                            } else if (e.type == Entry.FILECH) {
-                                // the data are not deflated, use ZEOS
-                                OutputStream os2 = new EntryOutputStream(e, os);
-                                while ((n = is.read(buf)) != -1) {
-                                    os2.write(buf, 0, n);
-                                }
-                                os2.close();
-                                written += e.csize;
-                                if ((e.flag & FLAG_DATADESCR) != 0)
-                                    written += e.writeEXT(os);
                             }
-                            is.close();
-                            e.file.delete();
+                            Files.delete(e.file);
                             tmppaths.remove(e.file);
                         } else {
                             // dir, 0-length data
@@ -1257,15 +1273,15 @@
                                       createTempFileInSameDirectoryAs(zfpath),
                                       ch,
                                       streams);
-            zfpath.moveTo(ecc.path, REPLACE_EXISTING);
+            Files.move(zfpath, ecc.path, REPLACE_EXISTING);
             exChClosers.add(ecc);
             streams = Collections.synchronizedSet(new HashSet<InputStream>());
         } else {
             ch.close();
-            zfpath.delete();
+            Files.delete(zfpath);
         }
 
-        tmpFile.moveTo(zfpath, REPLACE_EXISTING);
+        Files.move(tmpFile, zfpath, REPLACE_EXISTING);
         hasUpdate = false;    // clear
         /*
         if (isOpen) {
@@ -1304,16 +1320,17 @@
         throws IOException
     {
         checkWritable();
-        Entry e = getEntry0(path);
-        if (e == null) {
+
+        IndexNode inode = getInode(path);
+        if (inode == null) {
             if (path != null && path.length == 0)
                 throw new ZipException("root directory </> can't not be delete");
             if (failIfNotExists)
                 throw new NoSuchFileException(getString(path));
         } else {
-            if (e.isDir() && e.child != null)
+            if (inode.isDir() && inode.child != null)
                 throw new DirectoryNotEmptyException(getString(path));
-            updateDelete(e);
+            updateDelete(inode);
         }
     }
 
@@ -1343,7 +1360,7 @@
         OutputStream os;
         if (useTempFile) {
             e.file = getTempPathForEntry(null);
-            os = e.file.newOutputStream(WRITE);
+            os = Files.newOutputStream(e.file, WRITE);
         } else {
             os = new ByteArrayOutputStream((e.size > 0)? (int)e.size : 8192);
         }
@@ -1359,12 +1376,12 @@
             if (e.bytes != null)
                 eis = new ByteArrayInputStream(e.bytes);
             else if (e.file != null)
-                eis = e.file.newInputStream();
+                eis = Files.newInputStream(e.file);
             else
                 throw new ZipException("update entry data is missing");
         } else if (e.type == Entry.FILECH) {
             // FILECH result is un-compressed.
-            eis = e.file.newInputStream();
+            eis = Files.newInputStream(e.file);
             // TBD: wrap to hook close()
             // streams.add(eis);
             return eis;
--- a/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipFileSystemProvider.java	Tue Feb 01 21:00:09 2011 +0530
+++ b/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipFileSystemProvider.java	Tue Feb 01 14:20:01 2011 -0800
@@ -31,23 +31,18 @@
 
 package com.sun.nio.zipfs;
 
-import java.io.IOException;
-import java.nio.channels.FileChannel;
-import java.nio.file.FileRef;
-import java.nio.file.FileSystem;
-import java.nio.file.FileSystemNotFoundException;
-import java.nio.file.FileSystemAlreadyExistsException;
-import java.nio.file.OpenOption;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.nio.file.ProviderMismatchException;
-import java.nio.file.attribute.FileAttribute;
+import java.io.*;
+import java.nio.channels.*;
+import java.nio.file.*;
+import java.nio.file.DirectoryStream.Filter;
+import java.nio.file.attribute.*;
 import java.nio.file.spi.FileSystemProvider;
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.ExecutorService;
 
 /*
  *
@@ -87,28 +82,25 @@
     public FileSystem newFileSystem(URI uri, Map<String, ?> env)
         throws IOException
     {
-        return newFileSystem(uriToPath(uri), env);
+        return newFileSystem(uriToPath(uri), env, true);
     }
 
     @Override
-    public FileSystem newFileSystem(FileRef file, Map<String, ?> env)
+    public FileSystem newFileSystem(Path path, Map<String, ?> env)
         throws IOException
     {
-        if (!(file instanceof Path))
-            throw new UnsupportedOperationException();
-        Path path = (Path)file;
         if (!path.toUri().getScheme().equalsIgnoreCase("file")) {
             throw new UnsupportedOperationException();
         }
-        return newFileSystem(path, env);
+        return newFileSystem(path, env, false);
     }
 
-    private FileSystem newFileSystem(Path path, Map<String, ?> env)
+    private FileSystem newFileSystem(Path path, Map<String, ?> env, boolean checkIfFSExists)
         throws IOException
     {
         synchronized(filesystems) {
             Path realPath = null;
-            if (path.exists()) {
+            if (checkIfFSExists && Files.exists(path)) {
                 realPath = path.toRealPath(true);
                 if (filesystems.containsKey(realPath))
                     throw new FileSystemAlreadyExistsException();
@@ -116,7 +108,8 @@
             ZipFileSystem zipfs = new ZipFileSystem(this, path, env);
             if (realPath == null)
                 realPath = path.toRealPath(true);
-            filesystems.put(realPath, zipfs);
+            if (!filesystems.containsKey(realPath))
+                filesystems.put(realPath, zipfs);
             return zipfs;
         }
     }
@@ -133,18 +126,6 @@
         return getFileSystem(uri).getPath(spec.substring(sep + 1));
     }
 
-    @Override
-    public FileChannel newFileChannel(Path path,
-            Set<? extends OpenOption> options,
-            FileAttribute<?>... attrs)
-            throws IOException
-    {
-        if (path == null)
-            throw new NullPointerException("path is null");
-        if (path instanceof ZipPath)
-            return ((ZipPath)path).newFileChannel(options, attrs);
-        throw new ProviderMismatchException();
-    }
 
     @Override
     public FileSystem getFileSystem(URI uri) {
@@ -161,9 +142,155 @@
         }
     }
 
-    void removeFileSystem(Path zfpath) throws IOException {
+    // Checks that the given file is a UnixPath
+    static final ZipPath toZipPath(Path path) {
+        if (path == null)
+            throw new NullPointerException();
+        if (!(path instanceof ZipPath))
+            throw new ProviderMismatchException();
+        return (ZipPath)path;
+    }
+
+    @Override
+    public void checkAccess(Path path, AccessMode... modes) throws IOException {
+        toZipPath(path).checkAccess(modes);
+    }
+
+    @Override
+    public void copy(Path src, Path target, CopyOption... options)
+        throws IOException
+    {
+        toZipPath(src).copy(toZipPath(target), options);
+    }
+
+    @Override
+    public void createDirectory(Path path, FileAttribute<?>... attrs)
+        throws IOException
+    {
+        toZipPath(path).createDirectory(attrs);
+    }
+
+    @Override
+    public final void delete(Path path) throws IOException {
+        toZipPath(path).delete();
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public <V extends FileAttributeView> V
+        getFileAttributeView(Path path, Class<V> type, LinkOption... options)
+    {
+        return (V)ZipFileAttributeView.get(toZipPath(path), type);
+    }
+
+    @Override
+    public FileStore getFileStore(Path path) throws IOException {
+        return toZipPath(path).getFileStore();
+    }
+
+    @Override
+    public boolean isHidden(Path path) {
+        return toZipPath(path).isHidden();
+    }
+
+    @Override
+    public boolean isSameFile(Path path, Path other) throws IOException {
+        return toZipPath(path).isSameFile(other);
+    }
+
+    @Override
+    public void move(Path src, Path target, CopyOption... options)
+        throws IOException
+    {
+        toZipPath(src).move(toZipPath(target), options);
+    }
+
+    @Override
+    public AsynchronousFileChannel newAsynchronousFileChannel(Path path,
+            Set<? extends OpenOption> options,
+            ExecutorService exec,
+            FileAttribute<?>... attrs)
+            throws IOException
+    {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public SeekableByteChannel newByteChannel(Path path,
+                                              Set<? extends OpenOption> options,
+                                              FileAttribute<?>... attrs)
+        throws IOException
+    {
+        return toZipPath(path).newByteChannel(options, attrs);
+    }
+
+    @Override
+    public DirectoryStream<Path> newDirectoryStream(
+        Path path, Filter<? super Path> filter) throws IOException
+    {
+        return toZipPath(path).newDirectoryStream(filter);
+    }
+
+    @Override
+    public FileChannel newFileChannel(Path path,
+                                      Set<? extends OpenOption> options,
+                                      FileAttribute<?>... attrs)
+        throws IOException
+    {
+        return toZipPath(path).newFileChannel(options, attrs);
+    }
+
+    @Override
+    public InputStream newInputStream(Path path, OpenOption... options)
+        throws IOException
+    {
+        return toZipPath(path).newInputStream(options);
+    }
+
+    @Override
+    public OutputStream newOutputStream(Path path, OpenOption... options)
+        throws IOException
+    {
+        return toZipPath(path).newOutputStream(options);
+    }
+
+    @Override
+    public <A extends BasicFileAttributes> A
+        readAttributes(Path path, Class<A> type, LinkOption... options)
+        throws IOException
+    {
+        if (type == BasicFileAttributes.class || type == ZipFileAttributes.class)
+            return (A)toZipPath(path).getAttributes();
+        return null;
+    }
+
+    @Override
+    public Map<String, Object>
+        readAttributes(Path path, String attribute, LinkOption... options)
+        throws IOException
+    {
+        return toZipPath(path).readAttributes(attribute, options);
+    }
+
+    @Override
+    public Path readSymbolicLink(Path link) throws IOException {
+        throw new UnsupportedOperationException("Not supported.");
+    }
+
+    @Override
+    public void setAttribute(Path path, String attribute,
+                             Object value, LinkOption... options)
+        throws IOException
+    {
+        toZipPath(path).setAttribute(attribute, value, options);
+    }
+
+    //////////////////////////////////////////////////////////////
+    void removeFileSystem(Path zfpath, ZipFileSystem zfs) throws IOException {
         synchronized (filesystems) {
-            filesystems.remove(zfpath.toRealPath(true));
+            zfpath = zfpath.toRealPath(true);
+            if (filesystems.get(zfpath) == zfs)
+                filesystems.remove(zfpath);
         }
     }
 }
--- a/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipPath.java	Tue Feb 01 21:00:09 2011 +0530
+++ b/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipPath.java	Tue Feb 01 14:20:01 2011 -0800
@@ -31,29 +31,23 @@
 
 package com.sun.nio.zipfs;
 
-import java.io.File;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
+import java.io.*;
 import java.net.URI;
-import java.nio.channels.FileChannel;
-import java.nio.channels.SeekableByteChannel;
+import java.nio.channels.*;
 import java.nio.file.*;
 import java.nio.file.DirectoryStream.Filter;
-import java.nio.file.attribute.BasicFileAttributeView;
-import java.nio.file.attribute.FileAttribute;
-import java.nio.file.attribute.FileAttributeView;
-import java.nio.file.attribute.FileTime;
+import java.nio.file.attribute.*;
 import java.util.*;
 import static java.nio.file.StandardOpenOption.*;
 import static java.nio.file.StandardCopyOption.*;
 
+
 /**
  *
  * @author  Xueming Shen, Rajendra Gutupalli,Jaya Hangal
  */
 
-public class ZipPath extends Path {
+public class ZipPath implements Path {
 
     private final ZipFileSystem zfs;
     private final byte[] path;
@@ -82,7 +76,7 @@
     }
 
     @Override
-    public Path getName() {
+    public Path getFileName() {
         initOffsets();
         int count = offsets.length;
         if (count == 0)
@@ -162,8 +156,7 @@
         return realPath;
     }
 
-    @Override
-    public boolean isHidden() {
+    boolean isHidden() {
         return false;
     }
 
@@ -230,7 +223,7 @@
     public Path relativize(Path other) {
         final ZipPath o = checkPath(other);
         if (o.equals(this))
-            return null;
+            return new ZipPath(getFileSystem(), new byte[0], true);
         if (/* this.getFileSystem() != o.getFileSystem() || */
             this.isAbsolute() != o.isAbsolute()) {
             throw new IllegalArgumentException();
@@ -277,8 +270,6 @@
 
     @Override
     public ZipPath resolve(Path other) {
-        if (other == null)
-            return this;
         final ZipPath o = checkPath(other);
         if (o.isAbsolute())
             return o;
@@ -297,8 +288,11 @@
     }
 
     @Override
-    public ZipPath resolve(String other) {
-        return resolve(getFileSystem().getPath(other));
+    public Path resolveSibling(Path other) {
+        if (other == null)
+            throw new NullPointerException();
+        Path parent = getParent();
+        return (parent == null) ? other : parent.resolve(other);
     }
 
     @Override
@@ -333,12 +327,30 @@
     }
 
     @Override
+    public ZipPath resolve(String other) {
+        return resolve(getFileSystem().getPath(other));
+    }
+
+    @Override
+    public final Path resolveSibling(String other) {
+        return resolveSibling(getFileSystem().getPath(other));
+    }
+
+    @Override
+    public final boolean startsWith(String other) {
+        return startsWith(getFileSystem().getPath(other));
+    }
+
+    @Override
+    public final boolean endsWith(String other) {
+        return endsWith(getFileSystem().getPath(other));
+    }
+
+    @Override
     public Path normalize() {
         byte[] resolved = getResolved();
         if (resolved == path)    // no change
             return this;
-        if (resolved.length == 0)
-            return null;
         return new ZipPath(zfs, resolved, true);
     }
 
@@ -548,198 +560,6 @@
         return len1 - len2;
     }
 
-    @Override
-    public Path createSymbolicLink(
-            Path target, FileAttribute<?>... attrs) throws IOException {
-        throw new UnsupportedOperationException("Not supported.");
-    }
-
-    @Override
-    public Path createLink(
-            Path existing) throws IOException {
-        throw new UnsupportedOperationException("Not supported.");
-    }
-
-    @Override
-    public Path readSymbolicLink() throws IOException {
-        throw new UnsupportedOperationException("Not supported.");
-    }
-
-    @Override
-    public Path createDirectory(FileAttribute<?>... attrs)
-        throws IOException
-    {
-        zfs.createDirectory(getResolvedPath(), attrs);
-        return this;
-    }
-
-    public final Path createFile(FileAttribute<?>... attrs)
-        throws IOException
-    {
-        OutputStream os = newOutputStream(CREATE_NEW, WRITE);
-        try {
-            os.close();
-        } catch (IOException x) {}
-        return this;
-    }
-
-    @Override
-    public InputStream newInputStream(OpenOption... options)
-            throws IOException {
-        if (options.length > 0) {
-            for (OpenOption opt : options) {
-                if (opt != READ)
-                    throw new UnsupportedOperationException("'" + opt + "' not allowed");
-            }
-        }
-        return zfs.newInputStream(getResolvedPath());
-    }
-
-    private static final DirectoryStream.Filter<Path> acceptAllFilter =
-        new DirectoryStream.Filter<>() {
-            @Override public boolean accept(Path entry) { return true; }
-        };
-
-    @Override
-    public final DirectoryStream<Path> newDirectoryStream() throws IOException {
-        return newDirectoryStream(acceptAllFilter);
-    }
-
-    @Override
-    public DirectoryStream<Path> newDirectoryStream(Filter<? super Path> filter)
-        throws IOException
-    {
-        return new ZipDirectoryStream(this, filter);
-    }
-
-    @Override
-    public final DirectoryStream<Path> newDirectoryStream(String glob)
-        throws IOException
-    {
-        // avoid creating a matcher if all entries are required.
-        if (glob.equals("*"))
-            return newDirectoryStream();
-
-        // create a matcher and return a filter that uses it.
-        final PathMatcher matcher = getFileSystem().getPathMatcher("glob:" + glob);
-        DirectoryStream.Filter<Path> filter = new DirectoryStream.Filter<>() {
-            @Override
-            public boolean accept(Path entry)  {
-                return matcher.matches(entry.getName());
-            }
-        };
-        return newDirectoryStream(filter);
-    }
-
-    @Override
-    public final void delete() throws IOException {
-        zfs.deleteFile(getResolvedPath(), true);
-    }
-
-    @Override
-    public final void deleteIfExists() throws IOException {
-        zfs.deleteFile(getResolvedPath(), false);
-    }
-
-    ZipFileAttributes getAttributes() throws IOException
-    {
-        ZipFileAttributes zfas = zfs.getFileAttributes(getResolvedPath());
-        if (zfas == null)
-            throw new NoSuchFileException(toString());
-        return zfas;
-    }
-
-    @Override
-    @SuppressWarnings("unchecked")
-    public <V extends FileAttributeView> V getFileAttributeView(Class<V> type,
-                                                                LinkOption... options)
-    {
-        return (V)ZipFileAttributeView.get(this, type);
-    }
-
-    @Override
-    public void setAttribute(String attribute,
-                             Object value,
-                             LinkOption... options)
-        throws IOException
-    {
-        String type = null;
-        String attr = null;
-        int colonPos = attribute.indexOf(':');
-        if (colonPos == -1) {
-            type = "basic";
-            attr = attribute;
-        } else {
-            type = attribute.substring(0, colonPos++);
-            attr = attribute.substring(colonPos);
-        }
-        ZipFileAttributeView view = ZipFileAttributeView.get(this, type);
-        if (view == null)
-            throw new UnsupportedOperationException("view <" + view + "> is not supported");
-        view.setAttribute(attr, value);
-    }
-
-    void setTimes(FileTime mtime, FileTime atime, FileTime ctime)
-        throws IOException
-    {
-        zfs.setTimes(getResolvedPath(), mtime, atime, ctime);
-    }
-
-    private Object getAttributesImpl(String attribute, boolean domap)
-        throws IOException
-    {
-        String view = null;
-        String attr = null;
-        int colonPos = attribute.indexOf(':');
-        if (colonPos == -1) {
-            view = "basic";
-            attr = attribute;
-        } else {
-            view = attribute.substring(0, colonPos++);
-            attr = attribute.substring(colonPos);
-        }
-        ZipFileAttributeView zfv = ZipFileAttributeView.get(this, view);
-        if (zfv == null) {
-            throw new UnsupportedOperationException("view not supported");
-        }
-        return zfv.getAttribute(attr, domap);
-    }
-
-    @Override
-    public Object getAttribute(String attribute, LinkOption... options)
-        throws IOException
-    {
-        return getAttributesImpl(attribute, false);
-    }
-
-    @Override
-    public Map<String,?> readAttributes(String attribute, LinkOption... options)
-        throws IOException
-    {
-        return (Map<String, ?>)getAttributesImpl(attribute, true);
-    }
-
-    @Override
-    public FileStore getFileStore() throws IOException {
-        // each ZipFileSystem only has one root (as requested for now)
-        if (exists())
-            return zfs.getFileStore(this);
-        throw new NoSuchFileException(zfs.getString(path));
-    }
-
-    @Override
-    public boolean isSameFile(Path other) throws IOException {
-        if (this.equals(other))
-            return true;
-        if (other == null ||
-            this.getFileSystem() != other.getFileSystem())
-            return false;
-        this.checkAccess();
-        other.checkAccess();
-        return Arrays.equals(this.getResolvedPath(),
-                             ((ZipPath)other).getResolvedPath());
-    }
-
     public WatchKey register(
             WatchService watcher,
             WatchEvent.Kind<?>[] events,
@@ -756,6 +576,11 @@
     }
 
     @Override
+    public final File toFile() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
     public Iterator<Path> iterator() {
         return new Iterator<>() {
             private int i = 0;
@@ -783,9 +608,115 @@
         };
     }
 
-    @Override
-    public SeekableByteChannel newByteChannel(Set<? extends OpenOption> options,
-                                              FileAttribute<?>... attrs)
+    /////////////////////////////////////////////////////////////////////
+
+
+    void createDirectory(FileAttribute<?>... attrs)
+        throws IOException
+    {
+        zfs.createDirectory(getResolvedPath(), attrs);
+    }
+
+    InputStream newInputStream(OpenOption... options) throws IOException
+    {
+        if (options.length > 0) {
+            for (OpenOption opt : options) {
+                if (opt != READ)
+                    throw new UnsupportedOperationException("'" + opt + "' not allowed");
+            }
+        }
+        return zfs.newInputStream(getResolvedPath());
+    }
+
+    DirectoryStream<Path> newDirectoryStream(Filter<? super Path> filter)
+        throws IOException
+    {
+        return new ZipDirectoryStream(this, filter);
+    }
+
+    void delete() throws IOException {
+        zfs.deleteFile(getResolvedPath(), true);
+    }
+
+    void deleteIfExists() throws IOException {
+        zfs.deleteFile(getResolvedPath(), false);
+    }
+
+    ZipFileAttributes getAttributes() throws IOException
+    {
+        ZipFileAttributes zfas = zfs.getFileAttributes(getResolvedPath());
+        if (zfas == null)
+            throw new NoSuchFileException(toString());
+        return zfas;
+    }
+
+    void setAttribute(String attribute, Object value, LinkOption... options)
+        throws IOException
+    {
+        String type = null;
+        String attr = null;
+        int colonPos = attribute.indexOf(':');
+        if (colonPos == -1) {
+            type = "basic";
+            attr = attribute;
+        } else {
+            type = attribute.substring(0, colonPos++);
+            attr = attribute.substring(colonPos);
+        }
+        ZipFileAttributeView view = ZipFileAttributeView.get(this, type);
+        if (view == null)
+            throw new UnsupportedOperationException("view <" + view + "> is not supported");
+        view.setAttribute(attr, value);
+    }
+
+    void setTimes(FileTime mtime, FileTime atime, FileTime ctime)
+        throws IOException
+    {
+        zfs.setTimes(getResolvedPath(), mtime, atime, ctime);
+    }
+
+    Map<String, Object> readAttributes(String attributes, LinkOption... options)
+        throws IOException
+
+    {
+        String view = null;
+        String attrs = null;
+        int colonPos = attributes.indexOf(':');
+        if (colonPos == -1) {
+            view = "basic";
+            attrs = attributes;
+        } else {
+            view = attributes.substring(0, colonPos++);
+            attrs = attributes.substring(colonPos);
+        }
+        ZipFileAttributeView zfv = ZipFileAttributeView.get(this, view);
+        if (zfv == null) {
+            throw new UnsupportedOperationException("view not supported");
+        }
+        return zfv.readAttributes(attrs);
+    }
+
+    FileStore getFileStore() throws IOException {
+        // each ZipFileSystem only has one root (as requested for now)
+        if (exists())
+            return zfs.getFileStore(this);
+        throw new NoSuchFileException(zfs.getString(path));
+    }
+
+    boolean isSameFile(Path other) throws IOException {
+        if (this.equals(other))
+            return true;
+        if (other == null ||
+            this.getFileSystem() != other.getFileSystem())
+            return false;
+        this.checkAccess();
+        ((ZipPath)other).checkAccess();
+        return Arrays.equals(this.getResolvedPath(),
+                             ((ZipPath)other).getResolvedPath());
+    }
+
+    SeekableByteChannel newByteChannel(Set<? extends OpenOption> options,
+                                       FileAttribute<?>... attrs)
         throws IOException
     {
         return zfs.newByteChannel(getResolvedPath(), options, attrs);
@@ -799,16 +730,7 @@
         return zfs.newFileChannel(getResolvedPath(), options, attrs);
     }
 
-    @Override
-    public SeekableByteChannel newByteChannel(OpenOption... options)
-            throws IOException {
-        Set<OpenOption> set = new HashSet<>(options.length);
-        Collections.addAll(set, options);
-        return newByteChannel(set);
-    }
-
-    @Override
-    public void checkAccess(AccessMode... modes) throws IOException {
+    void checkAccess(AccessMode... modes) throws IOException {
         boolean w = false;
         boolean x = false;
         for (AccessMode mode : modes) {
@@ -834,11 +756,9 @@
         }
         if (x)
             throw new AccessDeniedException(toString());
-
     }
 
-    @Override
-    public boolean exists() {
+    boolean exists() {
         if (path.length == 1 && path[0] == '/')
             return true;
         try {
@@ -847,15 +767,7 @@
         return false;
     }
 
-    @Override
-    public boolean notExists() {
-        return !exists();
-    }
-
-
-    @Override
-    public OutputStream newOutputStream(OpenOption... options)
-        throws IOException
+    OutputStream newOutputStream(OpenOption... options) throws IOException
     {
         if (options.length == 0)
             return zfs.newOutputStream(getResolvedPath(),
@@ -863,42 +775,32 @@
         return zfs.newOutputStream(getResolvedPath(), options);
     }
 
-    @Override
-    public Path moveTo(Path target, CopyOption... options)
+    void move(ZipPath target, CopyOption... options)
         throws IOException
     {
-        if (this.zfs.provider() == target.getFileSystem().provider() &&
-            this.zfs.getZipFile().isSameFile(((ZipPath)target).zfs.getZipFile()))
+        if (Files.isSameFile(this.zfs.getZipFile(), target.zfs.getZipFile()))
         {
             zfs.copyFile(true,
-                         getResolvedPath(),
-                         ((ZipPath)target).getResolvedPath(),
+                         getResolvedPath(), target.getResolvedPath(),
                          options);
         } else {
             copyToTarget(target, options);
             delete();
         }
-        return target;
     }
 
-    @Override
-    public Path copyTo(Path target, CopyOption... options)
+    void copy(ZipPath target, CopyOption... options)
         throws IOException
     {
-        if (this.zfs.provider() == target.getFileSystem().provider() &&
-            this.zfs.getZipFile().isSameFile(((ZipPath)target).zfs.getZipFile()))
-        {
+        if (Files.isSameFile(this.zfs.getZipFile(), target.zfs.getZipFile()))
             zfs.copyFile(false,
-                         getResolvedPath(),
-                         ((ZipPath)target).getResolvedPath(),
+                         getResolvedPath(), target.getResolvedPath(),
                          options);
-        } else {
+        else
             copyToTarget(target, options);
-        }
-        return target;
     }
 
-    private void copyToTarget(Path target, CopyOption... options)
+    private void copyToTarget(ZipPath target, CopyOption... options)
         throws IOException
     {
         boolean replaceExisting = false;
@@ -948,7 +850,7 @@
         }
         if (copyAttrs) {
             BasicFileAttributeView view =
-                target.getFileAttributeView(BasicFileAttributeView.class);
+                ZipFileAttributeView.get(target, BasicFileAttributeView.class);
             try {
                 view.setTimes(zfas.lastModifiedTime(),
                               zfas.lastAccessTime(),
--- a/src/share/demo/zipfs	Tue Feb 01 21:00:09 2011 +0530
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,703 +0,0 @@
-/*
- * Copyright (c) 2010 Oracle and/or its affiliates. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- *   - Redistributions of source code must retain the above copyright
- *     notice, this list of conditions and the following disclaimer.
- *
- *   - Redistributions in binary form must reproduce the above copyright
- *     notice, this list of conditions and the following disclaimer in the
- *     documentation and/or other materials provided with the distribution.
- *
- *   - Neither the name of Oracle nor the names of its
- *     contributors may be used to endorse or promote products derived
- *     from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
- * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-import java.io.*;
-import java.nio.*;
-import java.nio.channels.*;
-import java.nio.file.*;
-import java.nio.file.attribute.*;
-import java.net.*;
-import java.text.DateFormat;
-import java.text.SimpleDateFormat;
-import java.util.*;
-
-import static java.nio.file.StandardOpenOption.*;
-import static java.nio.file.StandardCopyOption.*;
-
-/*
- * ZipFileSystem usage demo
- *
- * java Demo action ZipfileName [...]
- *
- * @author Xueming Shen
- */
-
-public class Demo {
-
-    static enum Action {
-        rename,          // <java Demo rename zipfile src dst>
-                         // rename entry src to dst inside zipfile
-
-        movein,          // <java Demo movein zipfile src dst>
-                         // move an external src file into zipfile
-                         // as entry dst
-
-        moveout,         // <java Demo moveout zipfile src dst>
-                         // move a zipfile entry src out to dst
-
-        copy,            // <java Demo copy zipfile src dst>
-                         // copy entry src to dst inside zipfile
-
-        copyin,          // <java Demo copyin zipfile src dst>
-                         // copy an external src file into zipfile
-                         // as entry dst
-
-        copyin_attrs,    // <java Demo copyin_attrs zipfile src dst>
-                         // copy an external src file into zipfile
-                         // as entry dst, with attributes (timestamp)
-
-        copyout,         // <java Demo copyout zipfile src dst>
-                         // copy zipfile entry src" out to file dst
-
-        copyout_attrs,   // <java Demo copyout_attrs zipfile src dst>
-
-        zzmove,          // <java Demo zzmove zfsrc zfdst path>
-                         // move entry path/dir from zfsrc to zfdst
-
-        zzcopy,          // <java Demo zzcopy zfsrc zfdst path>
-                         // copy path from zipfile zfsrc to zipfile
-                         // zfdst
-
-        attrs,           // <java Demo attrs zipfile path>
-                         // printout the attributes of entry path
-
-        attrsspace,      // <java Demo attrsspace zipfile path>
-                         // printout the storespace attrs of entry path
-
-        setmtime,        // <java Demo setmtime zipfile "MM/dd/yy-HH:mm:ss" path...>
-                         // set the lastModifiedTime of entry path
-
-        setatime,        // <java Demo setatime zipfile "MM/dd/yy-HH:mm:ss" path...>
-        setctime,        // <java Demo setctime zipfile "MM/dd/yy-HH:mm:ss" path...>
-
-        lsdir,           // <java Demo lsdir zipfile dir>
-                         // list dir's direct child files/dirs
-
-        mkdir,           // <java Demo mkdir zipfile dir>
-
-        mkdirs,          // <java Demo mkdirs zipfile dir>
-
-        rmdirs,          // <java Demo rmdirs zipfile dir>
-
-        list,            // <java Demo list zipfile [dir]>
-                         // recursively list all entries of dir
-                         // via DirectoryStream
-
-        tlist,           // <java Demo tlist zipfile [dir]>
-                         // list with buildDirTree=true
-
-        vlist,           // <java Demo vlist zipfile [dir]>
-                         // recursively verbose list all entries of
-                         // dir via DirectoryStream
-
-        walk,            // <java Demo walk zipfile [dir]>
-                         // recursively walk all entries of dir
-                         // via Files.walkFileTree
-
-        twalk,           // <java Demo twalk zipfile [dir]>
-                         // walk with buildDirTree=true
-
-        extract,         // <java Demo extract zipfile file [...]>
-
-        update,          // <java Demo extract zipfile file [...]>
-
-        delete,          // <java Demo delete zipfile file [...]>
-
-        add,             // <java Demo add zipfile file [...]>
-
-        create,          // <java Demo create zipfile file [...]>
-                         // create a new zipfile if it doesn't exit
-                         // and then add the file(s) into it.
-
-        attrs2,          // <java Demo attrs2 zipfile file [...]>
-                         // test different ways to print attrs
-
-        prof,
-    }
-
-    public static void main(String[] args) throws Throwable {
-
-        Action action = Action.valueOf(args[0]);
-        Map<String, Object> env = env = new HashMap<>();
-        if (action == Action.create)
-            env.put("create", "true");
-        if (action == Action.tlist || action == Action.twalk)
-            env.put("buildDirTree", true);
-        FileSystem fs = FileSystems.newFileSystem(Paths.get(args[1]), env, null);
-
-        try {
-            FileSystem fs2;
-            Path path, src, dst;
-            boolean isRename = false;
-            switch (action) {
-            case rename:
-                src = fs.getPath(args[2]);
-                dst = fs.getPath(args[3]);
-                src.moveTo(dst);
-                break;
-            case moveout:
-                src = fs.getPath(args[2]);
-                dst = Paths.get(args[3]);
-                src.moveTo(dst);
-                break;
-            case movein:
-                src = Paths.get(args[2]);
-                dst = fs.getPath(args[3]);
-                src.moveTo(dst);
-                break;
-            case copy:
-                src = fs.getPath(args[2]);
-                dst = fs.getPath(args[3]);
-                src.copyTo(dst);
-                break;
-            case copyout:
-                src = fs.getPath(args[2]);
-                dst = Paths.get(args[3]);
-                src.copyTo(dst);
-                break;
-            case copyin:
-                src = Paths.get(args[2]);
-                dst = fs.getPath(args[3]);
-                src.copyTo(dst);
-                break;
-            case copyin_attrs:
-                src = Paths.get(args[2]);
-                dst = fs.getPath(args[3]);
-                src.copyTo(dst, COPY_ATTRIBUTES);
-                break;
-            case copyout_attrs:
-                src = fs.getPath(args[2]);
-                dst = Paths.get(args[3]);
-                src.copyTo(dst, COPY_ATTRIBUTES);
-                break;
-            case zzmove:
-                fs2 = FileSystems.newFileSystem(Paths.get(args[2]), env, null);
-                //sf1.getPath(args[3]).moveTo(fs2.getPath(args[3]));
-                z2zmove(fs, fs2, args[3]);
-                fs2.close();
-                break;
-            case zzcopy:
-                fs2 = FileSystems.newFileSystem(Paths.get(args[2]), env, null);
-                //sf1.getPath(args[3]).copyTo(fs2.getPath(args[3]));
-                z2zcopy(fs, fs2, args[3]);
-                fs2.close();
-                break;
-            case attrs:
-                for (int i = 2; i < args.length; i++) {
-                    path = fs.getPath(args[i]);
-                    System.out.println(path);
-                    System.out.println(
-                        Attributes.readBasicFileAttributes(path).toString());
-                }
-                break;
-            case setmtime:
-                DateFormat df = new SimpleDateFormat("MM/dd/yyyy-HH:mm:ss");
-                Date newDatetime = df.parse(args[2]);
-                for (int i = 3; i < args.length; i++) {
-                    path = fs.getPath(args[i]);
-                    path.setAttribute("lastModifiedTime",
-                                      FileTime.fromMillis(newDatetime.getTime()));
-                    System.out.println(
-                        Attributes.readBasicFileAttributes(path).toString());
-                }
-                break;
-            case setctime:
-                df = new SimpleDateFormat("MM/dd/yyyy-HH:mm:ss");
-                newDatetime = df.parse(args[2]);
-                for (int i = 3; i < args.length; i++) {
-                    path = fs.getPath(args[i]);
-                    path.setAttribute("creationTime",
-                                      FileTime.fromMillis(newDatetime.getTime()));
-                    System.out.println(
-                        Attributes.readBasicFileAttributes(path).toString());
-                }
-                break;
-            case setatime:
-                df = new SimpleDateFormat("MM/dd/yyyy-HH:mm:ss");
-                newDatetime = df.parse(args[2]);
-                for (int i = 3; i < args.length; i++) {
-                    path = fs.getPath(args[i]);
-                    path.setAttribute("lastAccessTime",
-                                      FileTime.fromMillis(newDatetime.getTime()));
-                    System.out.println(
-                        Attributes.readBasicFileAttributes(path).toString());
-                }
-                break;
-            case attrsspace:
-                path = fs.getPath("/");
-                FileStore fstore = path.getFileStore();
-                //System.out.println(fstore.getFileStoreAttributeView(FileStoreSpaceAttributeView.class)
-                //                         .readAttributes());
-                // or
-                System.out.printf("filestore[%s]%n", fstore.name());
-                System.out.printf("    totalSpace: %d%n",
-                                  (Long)fstore.getAttribute("space:totalSpace"));
-                System.out.printf("   usableSpace: %d%n",
-                                  (Long)fstore.getAttribute("space:usableSpace"));
-                System.out.printf("  unallocSpace: %d%n",
-                                  (Long)fstore.getAttribute("space:unallocatedSpace"));
-                break;
-            case list:
-            case tlist:
-                if (args.length < 3)
-                    list(fs.getPath("/"), false);
-                else
-                    list(fs.getPath(args[2]), false);
-                break;
-            case vlist:
-                if (args.length < 3)
-                    list(fs.getPath("/"), true);
-                else
-                    list(fs.getPath(args[2]), true);
-                break;
-            case twalk:
-            case walk:
-                walk(fs.getPath((args.length > 2)? args[2] : "/"));
-                break;
-            case extract:
-                if (args.length == 2) {
-                     extract(fs, "/");
-                } else {
-                    for (int i = 2; i < args.length; i++) {
-                        extract(fs, args[i]);
-                    }
-                }
-                break;
-            case delete:
-                for (int i = 2; i < args.length; i++)
-                    fs.getPath(args[i]).delete();
-                break;
-            case create:
-            case add:
-            case update:
-                for (int i = 2; i < args.length; i++) {
-                    update(fs, args[i]);
-                }
-                break;
-            case lsdir:
-                path = fs.getPath(args[2]);
-                final String fStr = (args.length > 3)?args[3]:"";
-                DirectoryStream<Path> ds = path.newDirectoryStream(
-                    new DirectoryStream.Filter<Path>() {
-                        public boolean accept(Path path) {
-                            return path.toString().contains(fStr);
-                        }
-                    });
-                for (Path p : ds)
-                    System.out.println(p);
-                break;
-            case mkdir:
-                fs.getPath(args[2]).createDirectory();
-                break;
-            case mkdirs:
-                mkdirs(fs.getPath(args[2]));
-                break;
-            case attrs2:
-                for (int i = 2; i < args.length; i++) {
-                    path = fs.getPath(args[i]);
-                    System.out.printf("%n%s%n", path);
-                    System.out.println("-------(1)---------");
-                    System.out.println(
-                        Attributes.readBasicFileAttributes(path).toString());
-                    System.out.println("-------(2)---------");
-                    Map<String, ?> map = path.readAttributes("zip:*");
-                    for (Map.Entry<String, ?> e : map.entrySet()) {
-                        System.out.printf("    %s : %s%n", e.getKey(), e.getValue());
-                    }
-                    System.out.println("-------(3)---------");
-                    map = path.readAttributes("size,lastModifiedTime,isDirectory");
-                    for (Map.Entry<String, ?> e : map.entrySet()) {
-                        System.out.printf("    %s : %s%n", e.getKey(), e.getValue());
-                    }
-                }
-                break;
-            case prof:
-                list(fs.getPath("/"), false);
-                while (true) {
-                    Thread.sleep(10000);
-                    //list(fs.getPath("/"), true);
-                    System.out.println("sleeping...");
-                }
-            }
-        } catch (Exception x) {
-            x.printStackTrace();
-        } finally {
-            if (fs != null)
-                fs.close();
-        }
-    }
-
-    private static byte[] getBytes(String name) {
-        return name.getBytes();
-    }
-
-    private static String getString(byte[] name) {
-        return new String(name);
-    }
-
-    private static void walk(Path path) throws IOException
-    {
-        Files.walkFileTree(
-            path,
-            new SimpleFileVisitor<Path>() {
-                private int indent = 0;
-                private void indent() {
-                    int n = 0;
-                    while (n++ < indent)
-                        System.out.printf(" ");
-                }
-
-                @Override
-                public FileVisitResult visitFile(Path file,
-                                                 BasicFileAttributes attrs)
-                {
-                    indent();
-                    System.out.printf("%s%n", file.getName().toString());
-                    return FileVisitResult.CONTINUE;
-                }
-
-                @Override
-                public FileVisitResult preVisitDirectory(Path dir,
-                                                         BasicFileAttributes attrs)
-                {
-                    indent();
-                    System.out.printf("[%s]%n", dir.toString());
-                    indent += 2;
-                    return FileVisitResult.CONTINUE;
-                }
-
-                @Override
-                public FileVisitResult postVisitDirectory(Path dir,
-                                                          IOException ioe)
-                {
-                    indent -= 2;
-                    return FileVisitResult.CONTINUE;
-                }
-        });
-    }
-
-    private static void update(FileSystem fs, String path) throws Throwable{
-        Path src = FileSystems.getDefault().getPath(path);
-        if (Boolean.TRUE.equals(src.getAttribute("isDirectory"))) {
-            DirectoryStream<Path> ds = src.newDirectoryStream();
-            for (Path child : ds)
-                update(fs, child.toString());
-            ds.close();
-        } else {
-            Path dst = fs.getPath(path);
-            Path parent = dst.getParent();
-            if (parent != null && parent.notExists())
-                mkdirs(parent);
-            src.copyTo(dst, REPLACE_EXISTING);
-        }
-    }
-
-    private static void extract(FileSystem fs, String path) throws Throwable{
-        Path src = fs.getPath(path);
-        if (Boolean.TRUE.equals(src.getAttribute("isDirectory"))) {
-            DirectoryStream<Path> ds = src.newDirectoryStream();
-            for (Path child : ds)
-                extract(fs, child.toString());
-            ds.close();
-        } else {
-            if (path.startsWith("/"))
-                path = path.substring(1);
-            Path dst = FileSystems.getDefault().getPath(path);
-            Path parent = dst.getParent();
-            if (parent.notExists())
-                mkdirs(parent);
-            src.copyTo(dst, REPLACE_EXISTING);
-        }
-    }
-
-    // use DirectoryStream
-    private static void z2zcopy(FileSystem src, FileSystem dst, String path)
-        throws IOException
-    {
-        Path srcPath = src.getPath(path);
-        Path dstPath = dst.getPath(path);
-
-        if (Boolean.TRUE.equals(srcPath.getAttribute("isDirectory"))) {
-            if (!dstPath.exists()) {
-                try {
-                    mkdirs(dstPath);
-                } catch (FileAlreadyExistsException x) {}
-            }
-            DirectoryStream<Path> ds = srcPath.newDirectoryStream();
-            for (Path child : ds) {
-                z2zcopy(src, dst,
-                        path + (path.endsWith("/")?"":"/") + child.getName());
-            }
-            ds.close();
-        } else {
-            //System.out.println("copying..." + path);
-            srcPath.copyTo(dstPath);
-        }
-    }
-
-    // use TreeWalk to move
-    private static void z2zmove(FileSystem src, FileSystem dst, String path)
-        throws IOException
-    {
-        final Path srcPath = src.getPath(path).toAbsolutePath();
-        final Path dstPath = dst.getPath(path).toAbsolutePath();
-
-        Files.walkFileTree(srcPath, new SimpleFileVisitor<Path>() {
-
-            @Override
-            public FileVisitResult visitFile(Path file,
-                                            BasicFileAttributes attrs)
-            {
-                Path dst = srcPath.relativize(file);
-                dst = dstPath.resolve(dst);
-                try {
-                    Path parent = dstPath.getParent();
-                    if (parent != null && parent.notExists())
-                        mkdirs(parent);
-                    file.moveTo(dst);
-                } catch (IOException x) {
-                    x.printStackTrace();
-                }
-                return FileVisitResult.CONTINUE;
-            }
-
-            @Override
-            public FileVisitResult preVisitDirectory(Path dir,
-                                                     BasicFileAttributes attrs)
-            {
-                Path dst = srcPath.relativize(dir);
-                dst = dstPath.resolve(dst);
-                try {
-
-                    if (dst.notExists())
-                        mkdirs(dst);
-                } catch (IOException x) {
-                    x.printStackTrace();
-                }
-                return FileVisitResult.CONTINUE;
-            }
-
-            @Override
-            public FileVisitResult postVisitDirectory(Path dir,
-                                                      IOException ioe)
-                throws IOException
-            {
-                try {
-                    dir.delete();
-                } catch (IOException x) {
-                    //x.printStackTrace();
-                }
-                return FileVisitResult.CONTINUE;
-            }
-        });
-
-    }
-
-    private static void mkdirs(Path path) throws IOException {
-        path = path.toAbsolutePath();
-        Path parent = path.getParent();
-        if (parent != null) {
-            if (parent.notExists())
-                mkdirs(parent);
-        }
-        path.createDirectory();
-    }
-
-    private static void rmdirs(Path path) throws IOException {
-        while (path != null && path.getNameCount() != 0) {
-            path.delete();
-            path = path.getParent();
-        }
-    }
-
-    private static void list(Path path, boolean verbose ) throws IOException {
-        if (!"/".equals(path.toString())) {
-           System.out.printf("  %s%n", path.toString());
-           if (verbose)
-                System.out.println(Attributes.readBasicFileAttributes(path).toString());
-        }
-        if (path.notExists())
-            return;
-        if (Attributes.readBasicFileAttributes(path).isDirectory()) {
-            DirectoryStream<Path> ds = path.newDirectoryStream();
-            for (Path child : ds)
-                list(child, verbose);
-            ds.close();
-        }
-    }
-
-    // check the content of two paths are equal
-    private static void checkEqual(Path src, Path dst) throws IOException
-    {
-        //System.out.printf("checking <%s> vs <%s>...%n",
-        //                  src.toString(), dst.toString());
-
-        //streams
-        InputStream isSrc = src.newInputStream();
-        InputStream isDst = dst.newInputStream();
-        byte[] bufSrc = new byte[8192];
-        byte[] bufDst = new byte[8192];
-
-        try {
-            int nSrc = 0;
-            while ((nSrc = isSrc.read(bufSrc)) != -1) {
-                int nDst = 0;
-                while (nDst < nSrc) {
-                    int n = isDst.read(bufDst, nDst, nSrc - nDst);
-                    if (n == -1) {
-                        System.out.printf("checking <%s> vs <%s>...%n",
-                                          src.toString(), dst.toString());
-                        throw new RuntimeException("CHECK FAILED!");
-                    }
-                    nDst += n;
-                }
-                while (--nSrc >= 0) {
-                    if (bufSrc[nSrc] != bufDst[nSrc]) {
-                        System.out.printf("checking <%s> vs <%s>...%n",
-                                          src.toString(), dst.toString());
-                        throw new RuntimeException("CHECK FAILED!");
-                    }
-                    nSrc--;
-                }
-            }
-        } finally {
-            isSrc.close();
-            isDst.close();
-        }
-
-        // channels
-        SeekableByteChannel chSrc = src.newByteChannel();
-        SeekableByteChannel chDst = dst.newByteChannel();
-        if (chSrc.size() != chDst.size()) {
-            System.out.printf("src[%s].size=%d, dst[%s].size=%d%n",
-                              chSrc.toString(), chSrc.size(),
-                              chDst.toString(), chDst.size());
-            throw new RuntimeException("CHECK FAILED!");
-        }
-        ByteBuffer bbSrc = ByteBuffer.allocate(8192);
-        ByteBuffer bbDst = ByteBuffer.allocate(8192);
-
-        try {
-            int nSrc = 0;
-            while ((nSrc = chSrc.read(bbSrc)) != -1) {
-                int nDst = chDst.read(bbDst);
-                if (nSrc != nDst) {
-                    System.out.printf("checking <%s> vs <%s>...%n",
-                                      src.toString(), dst.toString());
-                    throw new RuntimeException("CHECK FAILED!");
-                }
-                while (--nSrc >= 0) {
-                    if (bbSrc.get(nSrc) != bbDst.get(nSrc)) {
-                        System.out.printf("checking <%s> vs <%s>...%n",
-                                          src.toString(), dst.toString());
-                        throw new RuntimeException("CHECK FAILED!");
-                    }
-                    nSrc--;
-                }
-                bbSrc.flip();
-                bbDst.flip();
-            }
-        } catch (IOException x) {
-            x.printStackTrace();
-        } finally {
-            chSrc.close();
-            chDst.close();
-        }
-    }
-
-    private static void fchCopy(Path src, Path dst) throws IOException
-    {
-        Set<OpenOption> read = new HashSet<>();
-        read.add(READ);
-        Set<OpenOption> openwrite = new HashSet<>();
-        openwrite.add(CREATE_NEW);
-        openwrite.add(WRITE);
-
-        FileChannel srcFc = src.getFileSystem()
-                               .provider()
-                               .newFileChannel(src, read);
-        FileChannel dstFc = dst.getFileSystem()
-                               .provider()
-                               .newFileChannel(dst, openwrite);
-
-        try {
-            ByteBuffer bb = ByteBuffer.allocate(8192);
-            while (srcFc.read(bb) >= 0) {
-                bb.flip();
-                dstFc.write(bb);
-                bb.clear();
-            }
-        } finally {
-            srcFc.close();
-            dstFc.close();
-        }
-    }
-
-    private static void chCopy(Path src, Path dst) throws IOException
-    {
-        Set<OpenOption> read = new HashSet<>();
-        read.add(READ);
-        Set<OpenOption> openwrite = new HashSet<>();
-        openwrite.add(CREATE_NEW);
-        openwrite.add(WRITE);
-
-        SeekableByteChannel srcCh = src.newByteChannel(read);
-        SeekableByteChannel dstCh = dst.newByteChannel(openwrite);
-
-        try {
-            ByteBuffer bb = ByteBuffer.allocate(8192);
-            while (srcCh.read(bb) >= 0) {
-                bb.flip();
-                dstCh.write(bb);
-                bb.clear();
-            }
-        } finally {
-            srcCh.close();
-            dstCh.close();
-        }
-    }
-
-    private static void streamCopy(Path src, Path dst) throws IOException
-    {
-        InputStream isSrc = src.newInputStream();
-        OutputStream osDst = dst.newOutputStream();
-        byte[] buf = new byte[8192];
-        try {
-            int n = 0;
-            while ((n = isSrc.read(buf)) != -1) {
-                osDst.write(buf, 0, n);
-            }
-        } finally {
-            isSrc.close();
-            osDst.close();
-        }
-    }
-}
--- a/test/demo/zipfs/Basic.java	Tue Feb 01 21:00:09 2011 +0530
+++ b/test/demo/zipfs/Basic.java	Tue Feb 01 14:20:01 2011 -0800
@@ -48,9 +48,9 @@
         if (!found)
             throw new RuntimeException("'jar' provider not installed");
 
-        // Test: FileSystems#newFileSystem(FileRef)
+        // Test: FileSystems#newFileSystem(Path)
         Map<String,?> env = new HashMap<String,Object>();
-        FileSystems.newFileSystem(zipfile, env, null).close();
+        FileSystems.newFileSystem(zipfile, null).close();
 
         // Test: FileSystems#newFileSystem(URI)
         URI uri = new URI("jar", zipfile.toUri().toString(), null);
@@ -69,14 +69,11 @@
 
         // Test: DirectoryStream
         found = false;
-        DirectoryStream<Path> stream = fs.getPath("/").newDirectoryStream();
-        try {
+        try (DirectoryStream<Path> stream = Files.newDirectoryStream(fs.getPath("/"))) {
             for (Path entry: stream) {
                 found = entry.toString().equals("/META-INF/");
                 if (found) break;
             }
-        } finally {
-            stream.close();
         }
 
         if (!found)
@@ -84,21 +81,21 @@
 
         // Test: copy file from zip file to current (scratch) directory
         Path source = fs.getPath("/META-INF/services/java.nio.file.spi.FileSystemProvider");
-        if (source.exists()) {
-            Path target = Paths.get(source.getName().toString());
-            source.copyTo(target, StandardCopyOption.REPLACE_EXISTING);
+        if (Files.exists(source)) {
+            Path target = Paths.get(source.getFileName().toString());
+            Files.copy(source, target, StandardCopyOption.REPLACE_EXISTING);
             try {
-                long s1 = Attributes.readBasicFileAttributes(source).size();
-                long s2 = Attributes.readBasicFileAttributes(target).size();
+                long s1 = Files.readAttributes(source, BasicFileAttributes.class).size();
+                long s2 = Files.readAttributes(target, BasicFileAttributes.class).size();
                 if (s2 != s1)
                     throw new RuntimeException("target size != source size");
             } finally {
-                target.delete();
+                Files.delete(target);
             }
         }
 
         // Test: FileStore
-        FileStore store = fs.getPath("/").getFileStore();
+        FileStore store = Files.getFileStore(fs.getPath("/"));
         if (!store.supportsFileAttributeView("basic"))
             throw new RuntimeException("BasicFileAttributeView should be supported");
 
@@ -107,7 +104,7 @@
         if (fs.isOpen())
             throw new RuntimeException("FileSystem should be closed");
         try {
-            fs.getPath("/missing").checkAccess(AccessMode.READ);
+            fs.provider().checkAccess(fs.getPath("/missing"), AccessMode.READ);
         } catch (ClosedFileSystemException x) { }
     }
 
@@ -125,9 +122,9 @@
         public FileVisitResult preVisitDirectory(Path dir,
                                                  BasicFileAttributes attrs)
         {
-            if (dir.getName() != null) {
+            if (dir.getFileName() != null) {
                 indent();
-                System.out.println(dir.getName() + "/");
+                System.out.println(dir.getFileName() + "/");
                 indent++;
             }
             return FileVisitResult.CONTINUE;
@@ -138,7 +135,7 @@
                                          BasicFileAttributes attrs)
         {
             indent();
-            System.out.print(file.getName());
+            System.out.print(file.getFileName());
             if (attrs.isRegularFile())
                 System.out.format(" (%d)", attrs.size());
             System.out.println();
@@ -151,7 +148,7 @@
         {
             if (exc != null)
                 super.postVisitDirectory(dir, exc);
-            if (dir.getName() != null)
+            if (dir.getFileName() != null)
                 indent--;
             return FileVisitResult.CONTINUE;
         }
--- a/test/demo/zipfs/PathOps.java	Tue Feb 01 21:00:09 2011 +0530
+++ b/test/demo/zipfs/PathOps.java	Tue Feb 01 14:20:01 2011 -0800
@@ -100,7 +100,7 @@
     PathOps name(String expected) {
         out.println("check name");
         checkPath();
-        check(path.getName(), expected);
+        check(path.getFileName(), expected);
         return this;
     }
 
@@ -197,7 +197,7 @@
         try {
             out.println("check two paths are same");
             checkPath();
-            check(path.isSameFile(test(target).path()), true);
+            check(Files.isSameFile(path, test(target).path()), true);
         } catch (IOException ioe) {
             fail();
         }
@@ -320,7 +320,7 @@
 
         // relativize
         test("/a/b/c")
-            .relativize("/a/b/c", null)
+            .relativize("/a/b/c", "")
             .relativize("/a/b/c/d/e", "d/e")
             .relativize("/a/x", "../../x");
 
@@ -332,7 +332,7 @@
         test("/foo")
             .normalize("/foo");
         test(".")
-            .normalize(null);
+            .normalize("");
         test("..")
             .normalize("..");
         test("/..")
@@ -344,7 +344,7 @@
         test("./foo")
             .normalize("foo");
         test("foo/..")
-            .normalize(null);
+            .normalize("");
         test("../foo")
             .normalize("../foo");
         test("../../foo")
@@ -411,13 +411,13 @@
         }
 
         try {
-            path.startsWith(null);
+            path.startsWith((Path)null);
             throw new RuntimeException("NullPointerException not thrown");
         } catch (NullPointerException npe) {
         }
 
         try {
-            path.endsWith(null);
+            path.endsWith((Path)null);
             throw new RuntimeException("NullPointerException not thrown");
         } catch (NullPointerException npe) {
         }
@@ -427,8 +427,7 @@
     public static void main(String[] args) throws Throwable {
 
         Path zipfile = Paths.get(args[0]);
-        Map<String,?> env = new HashMap<String,Object>();
-        fs = FileSystems.newFileSystem(zipfile, env, null);
+        fs = FileSystems.newFileSystem(zipfile, null);
         npes();
         doPathOpTests();
         fs.close();
--- a/test/demo/zipfs/ZipFSTester.java	Tue Feb 01 21:00:09 2011 +0530
+++ b/test/demo/zipfs/ZipFSTester.java	Tue Feb 01 14:20:01 2011 -0800
@@ -25,6 +25,7 @@
 import java.nio.*;
 import java.nio.channels.*;
 import java.nio.file.*;
+import java.nio.file.spi.*;
 import java.nio.file.attribute.*;
 import java.net.*;
 import java.util.*;
@@ -40,15 +41,13 @@
 public class ZipFSTester {
 
     public static void main(String[] args) throws Throwable {
-        FileSystem fs = null;
-        try {
-            fs = newZipFileSystem(Paths.get(args[0]), new HashMap<String, Object>());
+
+        try (FileSystem fs = newZipFileSystem(Paths.get(args[0]),
+                                              new HashMap<String, Object>()))
+        {
             test0(fs);
             test1(fs);
             test2(fs);   // more tests
-        } finally {
-            if (fs != null)
-                fs.close();
         }
     }
 
@@ -63,10 +62,10 @@
             }
             for (String pname : list) {
                 Path path = fs.getPath(pname);
-                if (!path.exists())
+                if (!Files.exists(path))
                     throw new RuntimeException("path existence check failed!");
                 while ((path = path.getParent()) != null) {
-                    if (!path.exists())
+                    if (!Files.exists(path))
                         throw new RuntimeException("parent existence check failed!");
                 }
             }
@@ -85,12 +84,22 @@
         z2zcopy(fs, fs0, "/", 0);
         fs0.close();                // sync to file
 
-        fs = newZipFileSystem(tmpfsPath, new HashMap<String, Object>());
-        try {
+        try (fs = newZipFileSystem(tmpfsPath, new HashMap<String, Object>())) {
+
+            FileSystemProvider provider = fs.provider();
+            // newFileSystem(path...) should not throw exception
+            try (FileSystem fsPath = provider.newFileSystem(tmpfsPath, new HashMap<String, Object>())){}
+            try (FileSystem fsUri = provider.newFileSystem(
+                     new URI("jar", tmpfsPath.toUri().toString(), null),
+                     new HashMap<String, Object>()))
+            {
+              throw new RuntimeException("newFileSystem(uri...) does not throw exception");
+            } catch (FileSystemAlreadyExistsException fsaee) {}
+
             // prepare a src
             Path src = getTempPath();
             String tmpName = src.toString();
-            OutputStream os = src.newOutputStream();
+            OutputStream os = Files.newOutputStream(src);
             byte[] bits = new byte[12345];
             rdm.nextBytes(bits);
             os.write(bits);
@@ -98,37 +107,37 @@
 
             // copyin
             Path dst = getPathWithParents(fs, tmpName);
-            src.copyTo(dst);
+            Files.copy(src, dst);
             checkEqual(src, dst);
 
             // copy
             Path dst2 = getPathWithParents(fs, "/xyz" + rdm.nextInt(100) +
                                            "/efg" + rdm.nextInt(100) + "/foo.class");
-            dst.copyTo(dst2);
+            Files.copy(dst, dst2);
             //dst.moveTo(dst2);
             checkEqual(src, dst2);
 
             // delete
-            dst.delete();
-            if (dst.exists())
+            Files.delete(dst);
+            if (Files.exists(dst))
                 throw new RuntimeException("Failed!");
 
             // moveout
             Path dst3 = Paths.get(tmpName + "_Tmp");
-            dst2.moveTo(dst3);
+            Files.move(dst2, dst3);
             checkEqual(src, dst3);
 
             // delete
-            if (dst2.exists())
+            if (Files.exists(dst2))
                 throw new RuntimeException("Failed!");
-            dst3.delete();
-            if (dst3.exists())
+            Files.delete(dst3);
+            if (Files.exists(dst3))
                 throw new RuntimeException("Failed!");
 
             // newInputStream on dir
             Path parent = dst2.getParent();
             try {
-                parent.newInputStream();
+                Files.newInputStream(parent);
                 throw new RuntimeException("Failed");
             } catch (FileSystemException e) {
                 e.printStackTrace();    // expected fse
@@ -147,17 +156,15 @@
             Path tmp = Paths.get(tmpName + "_Tmp");
             fchCopy(dst, tmp);   //  out
             checkEqual(src, tmp);
-            tmp.delete();
+            Files.delete(tmp);
 
             // test channels
             channel(fs, dst);
-            dst.delete();
-            src.delete();
+            Files.delete(dst);
+            Files.delete(src);
         } finally {
-            if (fs != null)
-                fs.close();
-            if (tmpfsPath.exists())
-                tmpfsPath.delete();
+            if (Files.exists(tmpfsPath))
+                Files.delete(tmpfsPath);
         }
     }
 
@@ -242,7 +249,7 @@
                     while (itr.hasNext()) {
                         String path = itr.next();
                         try {
-                            if (fs2.getPath(path).exists()) {
+                            if (Files.exists(fs2.getPath(path))) {
                                 z2zmove(fs2, fs3, path);
                                 itr.remove();
                             }
@@ -296,15 +303,16 @@
         fs4.close();
         System.out.printf("failed=%d%n", failed);
 
-        fs1Path.delete();
-        fs2Path.delete();
-        fs3Path.delete();
+        Files.delete(fs1Path);
+        Files.delete(fs2Path);
+        Files.delete(fs3Path);
     }
 
     private static FileSystem newZipFileSystem(Path path, Map<String, ?> env)
-        throws IOException
+        throws Exception
     {
-        return FileSystems.newFileSystem(path, env, null);
+        return FileSystems.newFileSystem(
+            new URI("jar", path.toUri().toString(), null), env, null);
     }
 
     private static Path getTempPath() throws IOException
@@ -317,11 +325,11 @@
     private static void list(Path path, List<String> files, List<String> dirs )
         throws IOException
     {
-        if (Attributes.readBasicFileAttributes(path).isDirectory()) {
-            DirectoryStream<Path> ds = path.newDirectoryStream();
-            for (Path child : ds)
-                list(child, files, dirs);
-            ds.close();
+        if (Files.isDirectory(path)) {
+            try (DirectoryStream<Path> ds = Files.newDirectoryStream(path)) {
+                for (Path child : ds)
+                    list(child, files, dirs);
+            }
             dirs.add(path.toString());
         } else {
             files.add(path.toString());
@@ -335,26 +343,26 @@
         Path srcPath = src.getPath(path);
         Path dstPath = dst.getPath(path);
 
-        if (Boolean.TRUE.equals(srcPath.getAttribute("isDirectory"))) {
-            if (!dstPath.exists()) {
+        if (Files.isDirectory(srcPath)) {
+            if (!Files.exists(dstPath)) {
                 try {
                     mkdirs(dstPath);
                 } catch (FileAlreadyExistsException x) {}
             }
-            DirectoryStream<Path> ds = srcPath.newDirectoryStream();
-            for (Path child : ds) {
-                z2zcopy(src, dst,
-                        path + (path.endsWith("/")?"":"/") + child.getName(),
-                        method);
+            try (DirectoryStream<Path> ds = Files.newDirectoryStream(srcPath)) {
+                for (Path child : ds) {
+                    z2zcopy(src, dst,
+                           path + (path.endsWith("/")?"":"/") + child.getFileName(),
+                           method);
+                }
             }
-            ds.close();
         } else {
             try {
-                if (dstPath.exists())
+                if (Files.exists(dstPath))
                     return;
                 switch (method) {
                 case 0:
-                    srcPath.copyTo(dstPath);
+                    Files.copy(srcPath, dstPath);
                     break;
                 case 1:
                     chCopy(srcPath, dstPath);
@@ -374,21 +382,21 @@
         Path srcPath = src.getPath(path);
         Path dstPath = dst.getPath(path);
 
-        if (Boolean.TRUE.equals(srcPath.getAttribute("isDirectory"))) {
-            if (!dstPath.exists())
+        if (Files.isDirectory(srcPath)) {
+            if (!Files.exists(dstPath))
                 mkdirs(dstPath);
-            DirectoryStream<Path> ds = srcPath.newDirectoryStream();
-            for (Path child : ds) {
-                z2zmove(src, dst,
-                        path + (path.endsWith("/")?"":"/") + child.getName());
+            try (DirectoryStream<Path> ds = Files.newDirectoryStream(srcPath)) {
+                for (Path child : ds) {
+                    z2zmove(src, dst,
+                            path + (path.endsWith("/")?"":"/") + child.getFileName());
+                }
             }
-            ds.close();
         } else {
             //System.out.println("moving..." + path);
             Path parent = dstPath.getParent();
-            if (parent != null && parent.notExists())
+            if (parent != null && Files.notExists(parent))
                 mkdirs(parent);
-            srcPath.moveTo(dstPath);
+            Files.move(srcPath, dstPath);
         }
     }
 
@@ -409,7 +417,7 @@
                                                  BasicFileAttributes attrs)
                 {
                     indent();
-                    System.out.printf("%s%n", file.getName().toString());
+                    System.out.printf("%s%n", file.getFileName().toString());
                     return FileVisitResult.CONTINUE;
                 }
 
@@ -435,20 +443,20 @@
     }
 
     private static void mkdirs(Path path) throws IOException {
-        if (path.exists())
+        if (Files.exists(path))
             return;
         path = path.toAbsolutePath();
         Path parent = path.getParent();
         if (parent != null) {
-            if (parent.notExists())
+            if (Files.notExists(parent))
                 mkdirs(parent);
         }
-        path.createDirectory();
+        Files.createDirectory(path);
     }
 
     private static void rmdirs(Path path) throws IOException {
         while (path != null && path.getNameCount() != 0) {
-            path.delete();
+            Files.delete(path);
             path = path.getParent();
         }
     }
@@ -460,12 +468,11 @@
         //                  src.toString(), dst.toString());
 
         //streams
-        InputStream isSrc = src.newInputStream();
-        InputStream isDst = dst.newInputStream();
         byte[] bufSrc = new byte[8192];
         byte[] bufDst = new byte[8192];
-
-        try {
+        try (InputStream isSrc = Files.newInputStream(src);
+             InputStream isDst = Files.newInputStream(dst))
+        {
             int nSrc = 0;
             while ((nSrc = isSrc.read(bufSrc)) != -1) {
                 int nDst = 0;
@@ -487,24 +494,21 @@
                     nSrc--;
                 }
             }
-        } finally {
-            isSrc.close();
-            isDst.close();
         }
 
         // channels
-        SeekableByteChannel chSrc = src.newByteChannel();
-        SeekableByteChannel chDst = dst.newByteChannel();
-        if (chSrc.size() != chDst.size()) {
-            System.out.printf("src[%s].size=%d, dst[%s].size=%d%n",
-                              chSrc.toString(), chSrc.size(),
-                              chDst.toString(), chDst.size());
-            throw new RuntimeException("CHECK FAILED!");
-        }
-        ByteBuffer bbSrc = ByteBuffer.allocate(8192);
-        ByteBuffer bbDst = ByteBuffer.allocate(8192);
+        try (SeekableByteChannel chSrc = Files.newByteChannel(src);
+             SeekableByteChannel chDst = Files.newByteChannel(dst))
+        {
+            if (chSrc.size() != chDst.size()) {
+                System.out.printf("src[%s].size=%d, dst[%s].size=%d%n",
+                                  chSrc.toString(), chSrc.size(),
+                                  chDst.toString(), chDst.size());
+                throw new RuntimeException("CHECK FAILED!");
+            }
+            ByteBuffer bbSrc = ByteBuffer.allocate(8192);
+            ByteBuffer bbDst = ByteBuffer.allocate(8192);
 
-        try {
             int nSrc = 0;
             while ((nSrc = chSrc.read(bbSrc)) != -1) {
                 int nDst = chDst.read(bbDst);
@@ -526,9 +530,6 @@
             }
         } catch (IOException x) {
             x.printStackTrace();
-        } finally {
-            chSrc.close();
-            chDst.close();
         }
     }
 
@@ -540,23 +541,19 @@
         openwrite.add(CREATE_NEW);
         openwrite.add(WRITE);
 
-        FileChannel srcFc = src.getFileSystem()
-                               .provider()
-                               .newFileChannel(src, read);
-        FileChannel dstFc = dst.getFileSystem()
-                               .provider()
-                               .newFileChannel(dst, openwrite);
-
-        try {
+        try (FileChannel srcFc = src.getFileSystem()
+                                    .provider()
+                                    .newFileChannel(src, read);
+             FileChannel dstFc = dst.getFileSystem()
+                                    .provider()
+                                    .newFileChannel(dst, openwrite))
+        {
             ByteBuffer bb = ByteBuffer.allocate(8192);
             while (srcFc.read(bb) >= 0) {
                 bb.flip();
                 dstFc.write(bb);
                 bb.clear();
             }
-        } finally {
-            srcFc.close();
-            dstFc.close();
         }
     }
 
@@ -568,35 +565,29 @@
         openwrite.add(CREATE_NEW);
         openwrite.add(WRITE);
 
-        SeekableByteChannel srcCh = src.newByteChannel(read);
-        SeekableByteChannel dstCh = dst.newByteChannel(openwrite);
+        try (SeekableByteChannel srcCh = Files.newByteChannel(src, read);
+             SeekableByteChannel dstCh = Files.newByteChannel(dst, openwrite))
+        {
 
-        try {
             ByteBuffer bb = ByteBuffer.allocate(8192);
             while (srcCh.read(bb) >= 0) {
                 bb.flip();
                 dstCh.write(bb);
                 bb.clear();
             }
-        } finally {
-            srcCh.close();
-            dstCh.close();
         }
     }
 
     private static void streamCopy(Path src, Path dst) throws IOException
     {
-        InputStream isSrc = src.newInputStream();
-        OutputStream osDst = dst.newOutputStream();
         byte[] buf = new byte[8192];
-        try {
+        try (InputStream isSrc = Files.newInputStream(src);
+             OutputStream osDst = Files.newOutputStream(dst))
+        {
             int n = 0;
             while ((n = isSrc.read(buf)) != -1) {
                 osDst.write(buf, 0, n);
             }
-        } finally {
-            isSrc.close();
-            osDst.close();
         }
     }
 
@@ -604,31 +595,35 @@
         throws Exception
     {
         System.out.println("test ByteChannel...");
-        SeekableByteChannel sbc = path.newByteChannel();
         Set<OpenOption> read = new HashSet<>();
         read.add(READ);
-        System.out.printf("   sbc[0]: pos=%d, size=%d%n", sbc.position(), sbc.size());
-        ByteBuffer bb = ByteBuffer.allocate((int)sbc.size());
-        int n = sbc.read(bb);
-        System.out.printf("   sbc[1]: read=%d, pos=%d, size=%d%n",
-                          n, sbc.position(), sbc.size());
-        ByteBuffer bb2 = ByteBuffer.allocate((int)sbc.size());
+        int n = 0;
+        ByteBuffer bb = null;
+        ByteBuffer bb2 = null;
         int N = 120;
-        sbc.close();
+
+        try (SeekableByteChannel sbc = Files.newByteChannel(path)) {
+            System.out.printf("   sbc[0]: pos=%d, size=%d%n", sbc.position(), sbc.size());
+            bb = ByteBuffer.allocate((int)sbc.size());
+            n = sbc.read(bb);
+            System.out.printf("   sbc[1]: read=%d, pos=%d, size=%d%n",
+                              n, sbc.position(), sbc.size());
+            bb2 = ByteBuffer.allocate((int)sbc.size());
+        }
 
         // sbc.position(pos) is not supported in current version
         // try the FileChannel
-        sbc = fs.provider().newFileChannel(path, read);
-        sbc.position(N);
-        System.out.printf("   sbc[2]: pos=%d, size=%d%n",
-                          sbc.position(), sbc.size());
-        bb2.limit(100);
-        n = sbc.read(bb2);
-        System.out.printf("   sbc[3]: read=%d, pos=%d, size=%d%n",
-                          n, sbc.position(), sbc.size());
-        System.out.printf("   sbc[4]: bb[%d]=%d, bb1[0]=%d%n",
-                          N, bb.get(N) & 0xff, bb2.get(0) & 0xff);
-        sbc.close();
+        try (SeekableByteChannel sbc = fs.provider().newFileChannel(path, read)) {
+            sbc.position(N);
+            System.out.printf("   sbc[2]: pos=%d, size=%d%n",
+                              sbc.position(), sbc.size());
+            bb2.limit(100);
+            n = sbc.read(bb2);
+            System.out.printf("   sbc[3]: read=%d, pos=%d, size=%d%n",
+                              n, sbc.position(), sbc.size());
+            System.out.printf("   sbc[4]: bb[%d]=%d, bb1[0]=%d%n",
+                              N, bb.get(N) & 0xff, bb2.get(0) & 0xff);
+        }
     }
 
     // create parents if does not exist
@@ -637,7 +632,7 @@
     {
         Path path = fs.getPath(name);
         Path parent = path.getParent();
-        if (parent != null && parent.notExists())
+        if (parent != null && Files.notExists(parent))
             mkdirs(parent);
         return path;
     }
--- a/test/demo/zipfs/basic.sh	Tue Feb 01 21:00:09 2011 +0530
+++ b/test/demo/zipfs/basic.sh	Tue Feb 01 14:20:01 2011 -0800
@@ -21,8 +21,7 @@
 # questions.
 #
 # @test
-# @bug 6990846 7009092 7009085
-# @ignore Until zipfs updated (7015391)
+# @bug 6990846 7009092 7009085 7015391 7014948
 # @summary Test ZipFileSystem demo
 # @build Basic PathOps ZipFSTester
 # @run shell basic.sh