gt:                  x.lastError() == ERROR_PATH_NOT_FOUND)) return false;
context: /*
   * Copyright (c) 2008, 2013, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.  Oracle designates this
   * particular file as subject to the "Classpath" exception as provided
   * by Oracle in the LICENSE file that accompanied this code.
   *
   * This code is distributed in the hope that it will be useful, but WITHOUT
   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   * version 2 for more details (a copy is included in the LICENSE file that
   * accompanied this code).
   *
   * You should have received a copy of the GNU General Public License version
   * 2 along with this work; if not, write to the Free Software Foundation,
   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   * or visit www.oracle.com if you need additional information or have any
   * questions.
   */
  
  package sun.nio.fs;
  
  import java.nio.file.*;
  import java.nio.file.attribute.*;
  import java.nio.channels.*;
  import java.net.URI;
  import java.util.concurrent.ExecutorService;
  import java.io.*;
  import java.util.*;
  import java.security.AccessController;
  import sun.misc.Unsafe;
  import sun.nio.ch.ThreadPool;
  import sun.security.util.SecurityConstants;
  
  import static sun.nio.fs.WindowsNativeDispatcher.*;
  import static sun.nio.fs.WindowsSecurity.*;
  import static sun.nio.fs.WindowsConstants.*;
  
  public class WindowsFileSystemProvider
      extends AbstractFileSystemProvider
  {
      private static final Unsafe unsafe = Unsafe.getUnsafe();
  
      private static final String USER_DIR = "user.dir";
      private final WindowsFileSystem theFileSystem;
  
      public WindowsFileSystemProvider() {
          theFileSystem = new WindowsFileSystem(this, System.getProperty(USER_DIR));
      }
  
      @Override
      public String getScheme() {
          return "file";
      }
  
      private void checkUri(URI uri) {
          if (!uri.getScheme().equalsIgnoreCase(getScheme()))
              throw new IllegalArgumentException("URI does not match this provider");
          if (uri.getAuthority() != null)
              throw new IllegalArgumentException("Authority component present");
          if (uri.getPath() == null)
              throw new IllegalArgumentException("Path component is undefined");
          if (!uri.getPath().equals("/"))
              throw new IllegalArgumentException("Path component should be '/'");
          if (uri.getQuery() != null)
              throw new IllegalArgumentException("Query component present");
          if (uri.getFragment() != null)
              throw new IllegalArgumentException("Fragment component present");
      }
  
      @Override
      public FileSystem newFileSystem(URI uri, Map<String,?> env)
          throws IOException
      {
          checkUri(uri);
          throw new FileSystemAlreadyExistsException();
      }
  
      @Override
      public final FileSystem getFileSystem(URI uri) {
          checkUri(uri);
          return theFileSystem;
      }
  
      @Override
      public Path getPath(URI uri) {
          return WindowsUriSupport.fromUri(theFileSystem, uri);
      }
  
      @Override
      public FileChannel newFileChannel(Path path,
                                        Set<? extends OpenOption> options,
                                        FileAttribute<?>... attrs)
          throws IOException
      {
          if (path == null)
              throw new NullPointerException();
          if (!(path instanceof WindowsPath))
              throw new ProviderMismatchException();
          WindowsPath file = (WindowsPath)path;
  
          WindowsSecurityDescriptor sd = WindowsSecurityDescriptor.fromAttribute(attrs);
          try {
              return WindowsChannelFactory
                  .newFileChannel(file.getPathForWin32Calls(),
                                  file.getPathForPermissionCheck(),
                                  options,
                                  sd.address());
          } catch (WindowsException x) {
              x.rethrowAsIOException(file);
              return null;
          } finally {
              if (sd != null)
                  sd.release();
          }
      }
  
      @Override
      public AsynchronousFileChannel newAsynchronousFileChannel(Path path,
                                                                Set<? extends OpenOption> options,
                                                                ExecutorService executor,
                                                                FileAttribute<?>... attrs)
          throws IOException
      {
          if (path == null)
              throw new NullPointerException();
          if (!(path instanceof WindowsPath))
              throw new ProviderMismatchException();
          WindowsPath file = (WindowsPath)path;
          ThreadPool pool = (executor == null) ? null : ThreadPool.wrap(executor, 0);
          WindowsSecurityDescriptor sd =
              WindowsSecurityDescriptor.fromAttribute(attrs);
          try {
              return WindowsChannelFactory
                  .newAsynchronousFileChannel(file.getPathForWin32Calls(),
                                              file.getPathForPermissionCheck(),
                                              options,
                                              sd.address(),
                                              pool);
          } catch (WindowsException x) {
              x.rethrowAsIOException(file);
              return null;
          } finally {
              if (sd != null)
                  sd.release();
          }
      }
  
      @Override
      @SuppressWarnings("unchecked")
      public <V extends FileAttributeView> V
          getFileAttributeView(Path obj, Class<V> view, LinkOption... options)
      {
          WindowsPath file = WindowsPath.toWindowsPath(obj);
          if (view == null)
              throw new NullPointerException();
          boolean followLinks = Util.followLinks(options);
          if (view == BasicFileAttributeView.class)
              return (V) WindowsFileAttributeViews.createBasicView(file, followLinks);
          if (view == DosFileAttributeView.class)
              return (V) WindowsFileAttributeViews.createDosView(file, followLinks);
          if (view == AclFileAttributeView.class)
              return (V) new WindowsAclFileAttributeView(file, followLinks);
          if (view == FileOwnerAttributeView.class)
              return (V) new FileOwnerAttributeViewImpl(
                  new WindowsAclFileAttributeView(file, followLinks));
          if (view == UserDefinedFileAttributeView.class)
              return (V) new WindowsUserDefinedFileAttributeView(file, followLinks);
          return (V) null;
      }
  
      @Override
      @SuppressWarnings("unchecked")
      public <A extends BasicFileAttributes> A readAttributes(Path file,
                                                              Class<A> type,
                                                              LinkOption... options)
          throws IOException
      {
          Class<? extends BasicFileAttributeView> view;
          if (type == BasicFileAttributes.class)
              view = BasicFileAttributeView.class;
          else if (type == DosFileAttributes.class)
              view = DosFileAttributeView.class;
          else if (type == null)
              throw new NullPointerException();
          else
              throw new UnsupportedOperationException();
          return (A) getFileAttributeView(file, view, options).readAttributes();
      }
  
      @Override
      public DynamicFileAttributeView getFileAttributeView(Path obj, String name, LinkOption... options) {
          WindowsPath file = WindowsPath.toWindowsPath(obj);
          boolean followLinks = Util.followLinks(options);
          if (name.equals("basic"))
              return WindowsFileAttributeViews.createBasicView(file, followLinks);
          if (name.equals("dos"))
              return WindowsFileAttributeViews.createDosView(file, followLinks);
          if (name.equals("acl"))
              return new WindowsAclFileAttributeView(file, followLinks);
          if (name.equals("owner"))
              return new FileOwnerAttributeViewImpl(
                  new WindowsAclFileAttributeView(file, followLinks));
          if (name.equals("user"))
              return new WindowsUserDefinedFileAttributeView(file, followLinks);
          return null;
      }
  
      @Override
      public SeekableByteChannel newByteChannel(Path obj,
                                                Set<? extends OpenOption> options,
                                                FileAttribute<?>... attrs)
           throws IOException
      {
          WindowsPath file = WindowsPath.toWindowsPath(obj);
          WindowsSecurityDescriptor sd =
              WindowsSecurityDescriptor.fromAttribute(attrs);
          try {
              return WindowsChannelFactory
                  .newFileChannel(file.getPathForWin32Calls(),
                                  file.getPathForPermissionCheck(),
                                  options,
                                  sd.address());
          } catch (WindowsException x) {
              x.rethrowAsIOException(file);
              return null;  // keep compiler happy
          } finally {
              sd.release();
          }
      }
  
      @Override
      boolean implDelete(Path obj, boolean failIfNotExists) throws IOException {
          WindowsPath file = WindowsPath.toWindowsPath(obj);
          file.checkDelete();
  
          WindowsFileAttributes attrs = null;
          try {
               // need to know if file is a directory or junction
               attrs = WindowsFileAttributes.get(file, false);
               if (attrs.isDirectory() || attrs.isDirectoryLink()) {
                  RemoveDirectory(file.getPathForWin32Calls());
               } else {
                  DeleteFile(file.getPathForWin32Calls());
               }
               return true;
          } catch (WindowsException x) {
  
              // no-op if file does not exist
              if (!failIfNotExists &&
                  (x.lastError() == ERROR_FILE_NOT_FOUND ||
  