luni/src/test/java/libcore/java/nio/file/DefaultFileSystemProvider2Test.java - platform/libcore - Git at Google

 /*
  * Copyright (C) 2016 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License
  */

 package libcore.java.nio.file;

 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;

 import java.io.IOException;
 import java.net.URI;
 import java.nio.ByteBuffer;
 import java.nio.channels.FileChannel;
 import java.nio.channels.NonReadableChannelException;
 import java.nio.file.CopyOption;
 import java.nio.file.DirectoryNotEmptyException;
 import java.nio.file.DirectoryStream;
 import java.nio.file.FileAlreadyExistsException;
 import java.nio.file.FileStore;
 import java.nio.file.Files;
 import java.nio.file.NoSuchFileException;
 import java.nio.file.NotLinkException;
 import java.nio.file.OpenOption;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.nio.file.StandardOpenOption;
 import java.nio.file.attribute.BasicFileAttributeView;
 import java.nio.file.attribute.BasicFileAttributes;
 import java.nio.file.attribute.FileAttribute;
 import java.nio.file.attribute.FileTime;
 import java.nio.file.attribute.PosixFilePermission;
 import java.nio.file.attribute.PosixFilePermissions;
 import java.nio.file.spi.FileSystemProvider;
 import java.util.EnumSet;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.TimeUnit;

 import junitparams.JUnitParamsRunner;
 import junitparams.Parameters;

 import static java.nio.file.StandardCopyOption.ATOMIC_MOVE;
 import static java.nio.file.StandardCopyOption.REPLACE_EXISTING;
 import static java.nio.file.StandardOpenOption.APPEND;
 import static java.nio.file.StandardOpenOption.CREATE;
 import static java.nio.file.StandardOpenOption.READ;
 import static java.nio.file.StandardOpenOption.TRUNCATE_EXISTING;
 import static java.nio.file.StandardOpenOption.WRITE;
 import static junit.framework.TestCase.assertNotNull;
 import static junit.framework.TestCase.assertTrue;
 import static libcore.java.nio.file.FilesSetup.DATA_FILE;
 import static libcore.java.nio.file.FilesSetup.NonStandardOption;
 import static libcore.java.nio.file.FilesSetup.TEST_FILE_DATA;
 import static libcore.java.nio.file.FilesSetup.TEST_FILE_DATA_2;
 import static libcore.java.nio.file.FilesSetup.readFromFile;
 import static libcore.java.nio.file.FilesSetup.writeToFile;
 import static libcore.java.nio.file.LinuxFileSystemTestData.getPath_URI_InputOutputTestData;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.fail;

 @RunWith(JUnitParamsRunner.class)
 public class DefaultFileSystemProvider2Test {

     @Rule
     public FilesSetup filesSetup = new FilesSetup();

     private FileSystemProvider provider;

     @Before
     public void setUp() throws Exception {
         provider = filesSetup.getDataFilePath().getFileSystem().provider();
     }

     @Test
     public void test_move() throws IOException {
         provider.move(filesSetup.getDataFilePath(), filesSetup.getTestPath());
         assertEquals(TEST_FILE_DATA, readFromFile(filesSetup.getTestPath()));
         assertFalse(Files.exists(filesSetup.getDataFilePath()));

         filesSetup.reset();
         Files.createFile(filesSetup.getTestPath());
         // When target file exists.
         try {
             provider.move(filesSetup.getDataFilePath(), filesSetup.getTestPath());
             fail();
         } catch (FileAlreadyExistsException expected) {}

         // Move to existing target file with REPLACE_EXISTING copy option.
         filesSetup.reset();
         Files.createFile(filesSetup.getTestPath());
         writeToFile(filesSetup.getDataFilePath(), TEST_FILE_DATA_2);
         provider.move(filesSetup.getDataFilePath(), filesSetup.getTestPath(), REPLACE_EXISTING);
         assertEquals(TEST_FILE_DATA_2, readFromFile(filesSetup.getTestPath()));

         // Copy from a non existent file.
         filesSetup.reset();
         try {
             provider.move(filesSetup.getTestPath(), filesSetup.getDataFilePath(), REPLACE_EXISTING);
             fail();
         } catch (NoSuchFileException expected) {}
     }

     @Test
     public void test_move_CopyOption() throws IOException {
         FileTime fileTime = FileTime.fromMillis(System.currentTimeMillis() - 10000);
         Files.setAttribute(filesSetup.getDataFilePath(), "basic:lastModifiedTime", fileTime);
         provider.move(filesSetup.getDataFilePath(), filesSetup.getTestPath());
         assertEquals(fileTime.to(TimeUnit.SECONDS),
                 ((FileTime) Files.getAttribute(filesSetup.getTestPath(),
                         "basic:lastModifiedTime")).to(TimeUnit.SECONDS));
         assertEquals(TEST_FILE_DATA, readFromFile(filesSetup.getTestPath()));

         // ATOMIC_MOVE
         filesSetup.reset();
         provider.move(filesSetup.getDataFilePath(), filesSetup.getTestPath(), ATOMIC_MOVE);
         assertEquals(TEST_FILE_DATA, readFromFile(filesSetup.getTestPath()));

         filesSetup.reset();
         try {
             provider.move(filesSetup.getDataFilePath(), filesSetup.getTestPath(),
                     NonStandardOption.OPTION1);
             fail();
         } catch (UnsupportedOperationException expected) {}
     }

     @Test
     public void test_move_NPE() throws IOException {
         try {
             provider.move(null, filesSetup.getTestPath());
             fail();
         } catch(NullPointerException expected) {}

         try {
             provider.move(filesSetup.getDataFilePath(), null);
             fail();
         } catch(NullPointerException expected) {}

         try {
             provider.move(filesSetup.getDataFilePath(), filesSetup.getTestPath(),
                     (CopyOption[]) null);
             fail();
         } catch(NullPointerException expected) {}
     }

     @Test
     public void test_move_directory() throws IOException {
         Path dirPath = filesSetup.getPathInTestDir("dir1");
         final Path nestedDirPath = filesSetup.getPathInTestDir("dir1/dir");
         final Path dirPath2 = filesSetup.getPathInTestDir("dir2");

         Files.createDirectory(dirPath);
         Files.createDirectory(nestedDirPath);
         Files.copy(filesSetup.getDataFilePath(),
                 filesSetup.getPathInTestDir("dir1/" + DATA_FILE));
         provider.move(dirPath, dirPath2);

         Map<Path, Boolean> pathMap = new HashMap<>();
         try (DirectoryStream<Path> directoryStream = Files.newDirectoryStream(dirPath2)) {
             directoryStream.forEach(file -> pathMap.put(file, true));
         }

         // The files are not copied. The command is equivalent of creating a new directory.
         assertEquals(2, pathMap.size());
         assertEquals(TEST_FILE_DATA,
                 readFromFile(filesSetup.getPathInTestDir("dir2/" + DATA_FILE)));
         assertFalse(Files.exists(dirPath));

         filesSetup.reset();
     }

     @Test
     public void test_move_directory_DirectoryNotEmptyException() throws IOException {
         Path dirPath = filesSetup.getPathInTestDir("dir1");
         Path dirPath4 = filesSetup.getPathInTestDir("dir4");
         Files.createDirectory(dirPath);
         Files.createDirectory(dirPath4);
         Files.createFile(Paths.get(dirPath.toString(), DATA_FILE));
         Files.createFile(Paths.get(dirPath4.toString(), DATA_FILE));
         try {
             Files.copy(dirPath, dirPath4, REPLACE_EXISTING);
             fail();
         } catch (DirectoryNotEmptyException expected) {}
     }

     @Test
     public void test_readSymbolicLink() throws IOException {
         provider.createSymbolicLink(/* Path of the symbolic link */ filesSetup.getTestPath(),
                 /* Path of the target of the symbolic link */
                 filesSetup.getDataFilePath().toAbsolutePath());
         assertEquals(filesSetup.getDataFilePath().toAbsolutePath(),
                 Files.readSymbolicLink(filesSetup.getTestPath()));

         // Sym link to itself
         filesSetup.reset();
         provider.createSymbolicLink(/* Path of the symbolic link */ filesSetup.getTestPath(),
                 /* Path of the target of the symbolic link */
                 filesSetup.getTestPath().toAbsolutePath());
         assertEquals(filesSetup.getTestPath().toAbsolutePath(),
                 Files.readSymbolicLink(filesSetup.getTestPath()));

         filesSetup.reset();
         try {
             provider.readSymbolicLink(filesSetup.getDataFilePath());
             fail();
         } catch (NotLinkException expected) {
         }
     }

     @Test
     public void test_readSymbolicLink_NPE() throws IOException {
         try {
             provider.readSymbolicLink(null);
             fail();
         } catch (NullPointerException expected) {}
     }

     @Test
     public void test_isSameFile() throws IOException {
         // When both the files exists.
         assertTrue(provider.isSameFile(filesSetup.getDataFilePath(), filesSetup.getDataFilePath()));

         // When the files doesn't exist.
         assertTrue(provider.isSameFile(filesSetup.getTestPath(), filesSetup.getTestPath()));

         // With two different files.
         try {
             assertFalse(
                     provider.isSameFile(filesSetup.getDataFilePath(), filesSetup.getTestPath()));
             fail();
         } catch (NoSuchFileException expected) {}
     }

     @Test
     public void test_isSameFile_NPE() throws IOException {
         try {
             provider.isSameFile(null, filesSetup.getDataFilePath());
             fail();
         } catch (NullPointerException expected) {}

         try {
             provider.isSameFile(filesSetup.getDataFilePath(), null);
             fail();
         } catch (NullPointerException expected) {}
     }

     @Test
     public void test_getFileStore() throws IOException {
         try {
             provider.getFileStore(filesSetup.getDataFilePath());
             fail();
         } catch (SecurityException expected) {
         }

         try {
             provider.getFileStore(null);
             fail();
         } catch (SecurityException expected) {
         }
     }

     @Test
     public void test_isHidden() throws IOException {
         assertFalse(provider.isHidden(filesSetup.getDataFilePath()));

         // Files can't be hidden using the "dos" view, which is unsupported since it relies
         // on a custom xattr, which may or may not be available on all FSs.
         //
         // Note that this weirdly asymmetric : setting the hidden attribute uses xattrs to
         // emulate dos attributes whereas isHidden checks whether the the file name begins with a
         // leading period. <shrug>
         try {
             Files.setAttribute(filesSetup.getDataFilePath(), "dos:hidden", true);
             fail();
         } catch (UnsupportedOperationException expected) {
         }

         assertFalse(provider.isHidden(filesSetup.getDataFilePath()));
     }

     @Test
     public void test_isHidden_NPE() throws IOException {
         try {
             provider.isHidden(null);
             fail();
         } catch (NullPointerException expected) {}
     }

     @Test
     public void test_probeContentType_NPE() throws IOException {
         try {
             Files.probeContentType(null);
             fail();
         } catch (NullPointerException expected) {}
     }

     @Test
     public void test_getFileAttributeView() throws IOException {
         BasicFileAttributeView fileAttributeView = provider
                 .getFileAttributeView(filesSetup.getDataFilePath(),
                 BasicFileAttributeView.class);

         assertTrue(fileAttributeView.readAttributes().isRegularFile());
         assertFalse(fileAttributeView.readAttributes().isDirectory());
     }

     @Test
     public void test_getFileAttributeView_NPE() throws IOException {
         try {
             provider.getFileAttributeView(null, BasicFileAttributeView.class);
             fail();
         } catch (NullPointerException expected) {}

         try {
             provider.getFileAttributeView(filesSetup.getDataFilePath(), null);
             fail();
         } catch (NullPointerException expected) {}
     }

     @Test
     public void test_readAttributes() throws IOException {
         FileTime fileTime = FileTime.fromMillis(System.currentTimeMillis() - 10000);
         Files.setAttribute(filesSetup.getDataFilePath(), "basic:lastModifiedTime", fileTime);
         BasicFileAttributes basicFileAttributes = provider
                 .readAttributes(filesSetup.getDataFilePath(),
                 BasicFileAttributes.class);
         FileTime lastModifiedTime = basicFileAttributes.lastModifiedTime();
         assertEquals(fileTime.to(TimeUnit.SECONDS), lastModifiedTime.to(TimeUnit.SECONDS));

         // When file is NON_EXISTENT.
         try {
             provider.readAttributes(filesSetup.getTestPath(), BasicFileAttributes.class);
             fail();
         } catch (NoSuchFileException expected) {}
     }

     @Test
     public void test_readAttributes_NPE() throws IOException {
         try {
             provider.readAttributes(filesSetup.getDataFilePath(),
                     (Class<BasicFileAttributes>) null);
             fail();
         } catch(NullPointerException expected) {}

         try {
             provider.readAttributes(null, BasicFileAttributes.class);
             fail();
         } catch(NullPointerException expected) {}
     }

     @Test
     public void test_setAttribute() throws IOException {
         // Other tests are covered in test_readAttributes.
         // When file is NON_EXISTENT.
         try {
             FileTime fileTime = FileTime.fromMillis(System.currentTimeMillis());
             provider.setAttribute(filesSetup.getTestPath(), "basic:lastModifiedTime", fileTime);
             fail();
         } catch (NoSuchFileException expected) {}

         // ClassCastException
         try {
             provider.setAttribute(filesSetup.getDataFilePath(), "basic:lastModifiedTime", 10);
             fail();
         } catch (ClassCastException expected) {}

         // IllegalArgumentException
         try {
             provider.setAttribute(filesSetup.getDataFilePath(), "xyz", 10);
             fail();
         } catch (IllegalArgumentException expected) {}

         try {
             provider.setAttribute(null, "xyz", 10);
             fail();
         } catch (NullPointerException expected) {}

         try {
             provider.setAttribute(filesSetup.getDataFilePath(), null, 10);
             fail();
         } catch (NullPointerException expected) {}
     }

     @Test
     public void test_newFileChannel() throws IOException {
         Set<OpenOption> openOptions = new HashSet<>();

         // When file doesn't exist/
         try {
             // With CREATE & WRITE in OpenOptions.
             openOptions.add(CREATE);
             openOptions.add(WRITE);
             provider.newFileChannel(filesSetup.getTestPath(), openOptions);
             assertTrue(Files.exists(filesSetup.getTestPath()));
             Files.delete(filesSetup.getTestPath());
         } finally {
             filesSetup.reset();
             openOptions.clear();
         }

         try {
             // With CREATE & APPEND in OpenOption.
             assertFalse(Files.exists(filesSetup.getTestPath()));
             openOptions.add(CREATE);
             openOptions.add(APPEND);
             provider.newFileChannel(filesSetup.getTestPath(), openOptions);
             assertTrue(Files.exists(filesSetup.getTestPath()));
             Files.delete(filesSetup.getTestPath());
         } finally {
             filesSetup.reset();
             openOptions.clear();
         }

         // When file exists.
         try {
             FileChannel fc = provider.newFileChannel(filesSetup.getDataFilePath(), openOptions);
             assertEquals(filesSetup.TEST_FILE_DATA, readFromFileChannel(fc));
         } finally {
             filesSetup.reset();
             openOptions.clear();
         }

         try {
             // When file exists and READ in OpenOptions.
             openOptions.add(READ);
             FileChannel fc = provider.newFileChannel(filesSetup.getDataFilePath(), openOptions);
             assertEquals(filesSetup.TEST_FILE_DATA, readFromFileChannel(fc));
         } finally {
             filesSetup.reset();
             openOptions.clear();
         }

         // Reading from a file opened with WRITE.
         try {
             openOptions.add(WRITE);
             FileChannel fc = provider.newFileChannel(filesSetup.getDataFilePath(), openOptions);
             assertEquals(filesSetup.TEST_FILE_DATA, readFromFileChannel(fc));
             fail();
         } catch (NonReadableChannelException expected) {
         } finally {
             filesSetup.reset();
             openOptions.clear();
         }

         // Writing to an exiting file.
         try {
             openOptions.add(WRITE);
             FileChannel fc = provider.newFileChannel(filesSetup.getDataFilePath(), openOptions);
             writeToFileChannel(fc, filesSetup.TEST_FILE_DATA_2);
             fc.close();
             assertEquals(overlayString1OnString2(TEST_FILE_DATA_2, TEST_FILE_DATA),
                     readFromFile(filesSetup.getDataFilePath()));
         } finally {
             filesSetup.reset();
             openOptions.clear();
         }

         // APPEND to an existing file.
         try {
             openOptions.add(WRITE);
             openOptions.add(TRUNCATE_EXISTING);
             FileChannel fc = provider.newFileChannel(filesSetup.getDataFilePath(), openOptions);
             writeToFileChannel(fc, filesSetup.TEST_FILE_DATA_2);
             fc.close();
             assertEquals(TEST_FILE_DATA_2, readFromFile(filesSetup.getDataFilePath()));
         } finally {
             filesSetup.reset();
             openOptions.clear();
         }

         // TRUNCATE an existing file.
         try {
             openOptions.add(WRITE);
             openOptions.add(APPEND);
             FileChannel fc = provider.newFileChannel(filesSetup.getDataFilePath(), openOptions);
             writeToFileChannel(fc, filesSetup.TEST_FILE_DATA_2);
             fc.close();
             assertEquals(TEST_FILE_DATA + TEST_FILE_DATA_2, readFromFile(filesSetup.getDataFilePath()));
         } finally {
             filesSetup.reset();
             openOptions.clear();
         }
     }

     @Test
     @Parameters(method = "parameters_test_newFileChannel_NoSuchFileException")
     public void test_newFileChannel_NoSuchFileException(Set<? extends OpenOption> openOptions)
             throws IOException {
         try {
             provider.newFileChannel(filesSetup.getTestPath(), openOptions);
             fail();
         } catch (NoSuchFileException expected) {}
     }

     @SuppressWarnings("unused")
     private Object[] parameters_test_newFileChannel_NoSuchFileException() {
         return new Object[] {
                 new Object[] { EnumSet.noneOf(StandardOpenOption.class) },
                 new Object[] { EnumSet.of(READ) },
                 new Object[] { EnumSet.of(WRITE) },
                 new Object[] { EnumSet.of(TRUNCATE_EXISTING) },
                 new Object[] { EnumSet.of(APPEND) },
                 new Object[] { EnumSet.of(CREATE, READ) },
                 new Object[] { EnumSet.of(CREATE, TRUNCATE_EXISTING) },
                 new Object[] { EnumSet.of(CREATE, READ) },
         };
     }

     @Test
     public void test_newFileChannel_withFileAttributes() throws IOException {
         Set<OpenOption> openOptions = new HashSet<>();
         FileTime fileTime = FileTime.fromMillis(System.currentTimeMillis());
         Files.setAttribute(filesSetup.getDataFilePath(), "basic:lastModifiedTime", fileTime);
         FileAttribute<FileTime> unsupportedAttr = new MockFileAttribute<>(
                 "basic:lastModifiedTime", fileTime);

         Set<PosixFilePermission> perm = PosixFilePermissions.fromString("rwx------");
         FileAttribute<Set<PosixFilePermission>> supportedAttr =
                 PosixFilePermissions.asFileAttribute(perm);

         try {
             // When file doesn't exists and with OpenOption CREATE & WRITE.
             openOptions.clear();
             openOptions.add(CREATE);
             openOptions.add(WRITE);
             provider.newFileChannel(filesSetup.getTestPath(), openOptions, unsupportedAttr);
             fail();
         } catch (UnsupportedOperationException expected) {
         } finally {
             filesSetup.reset();
             openOptions.clear();
         }

         try {
             // With OpenOption CREATE & WRITE.
             openOptions.clear();
             openOptions.add(CREATE);
             openOptions.add(WRITE);
             provider.newFileChannel(filesSetup.getTestPath(), openOptions, supportedAttr);
             assertEquals(supportedAttr.value(), Files.getAttribute(filesSetup.getTestPath(),
                     supportedAttr.name()));
         } finally {
             filesSetup.reset();
             openOptions.clear();
         }

         // When file exists.
         try {
             provider.newFileChannel(filesSetup.getDataFilePath(), openOptions,
                     unsupportedAttr);
             fail();
         } catch (UnsupportedOperationException expected) {
         } finally {
             filesSetup.reset();
             openOptions.clear();
         }

         // When file exists. No change in permissions.
         try {
             Set<PosixFilePermission> originalPermissions= (Set<PosixFilePermission>)
                     Files.getAttribute(filesSetup.getDataFilePath(), supportedAttr.name());
             FileChannel fc = provider.newFileChannel(filesSetup.getDataFilePath(), openOptions,
                     supportedAttr);
             assertEquals(originalPermissions, Files.getAttribute(filesSetup.getDataFilePath(),
                     supportedAttr.name()));
         } finally {
             filesSetup.reset();
             openOptions.clear();
         }
     }


     @Test
     public void test_newFileChannel_NPE() throws IOException {
         try {
             provider.newByteChannel(null, new HashSet<>(), new MockFileAttribute<>());
             fail();
         } catch (NullPointerException expected) {}

         try {
             provider.newByteChannel(filesSetup.getTestPath(), null, new MockFileAttribute<>());
             fail();
         } catch (NullPointerException expected) {}

         try {
             provider.newByteChannel(filesSetup.getTestPath(), new HashSet<>(), null);
             fail();
         } catch (NullPointerException expected) {}
     }

     @Test
     public void test_getPath() throws Exception {
         List<LinuxFileSystemTestData.TestData> inputOutputTestCases = getPath_URI_InputOutputTestData();
         for (LinuxFileSystemTestData.TestData inputOutputTestCase : inputOutputTestCases) {
             assertEquals(inputOutputTestCase.output,
                     provider.getPath(new URI(inputOutputTestCase.input)).toString());
         }

         // When URI is null.
         try {
             provider.getPath(null);
             fail();
         } catch (NullPointerException expected) {}

         // When Schema is not supported.
         try {
             provider.getPath(new URI("scheme://d"));
             fail();
         } catch (IllegalArgumentException expected) {}
     }

     @Test
     public void test_getScheme() {
         assertEquals("file", provider.getScheme());
     }

     @Test
     public void test_installedProviders() {
         assertNotNull(provider.installedProviders());
     }

     @Test
     public void test_newFileSystem$URI$Map() throws Exception {
         Path testPath = Paths.get("/");
         assertNotNull(provider.getFileSystem(testPath.toUri()));

         try {
             provider.getFileSystem(null);
             fail();
         } catch (NullPointerException expected) {}

         // Test the case when URI has illegal scheme.
         URI stubURI = new URI("scheme://path");
         try {
             provider.getFileSystem(stubURI);
             fail();
         } catch (IllegalArgumentException expected) {}
     }

     String readFromFileChannel(FileChannel fc) throws IOException {
         ByteBuffer bb = ByteBuffer.allocate(20);
         fc.read(bb);
         return new String(bb.array(), "UTF-8").trim();
     }

     void writeToFileChannel(FileChannel fc, String data) throws IOException {
         fc.write(ByteBuffer.wrap(data.getBytes()));
     }

     String overlayString1OnString2(String s1, String s2) {
         return s1 + s2.substring(s1.length());
     }

     static class MockFileAttribute<T> implements FileAttribute {

         String name;
         T value;

         MockFileAttribute() {
         }

         MockFileAttribute(String name, T value) {
             this.name = name;
             this.value = value;
         }

         @Override
         public String name() {
             return name;
         }

         @Override
         public T value() {
             return value;
         }
     }
 }
	/*
	* Copyright (C) 2016 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License
	*/

	package libcore.java.nio.file;

	import org.junit.Before;
	import org.junit.Rule;
	import org.junit.Test;
	import org.junit.runner.RunWith;

	import java.io.IOException;
	import java.net.URI;
	import java.nio.ByteBuffer;
	import java.nio.channels.FileChannel;
	import java.nio.channels.NonReadableChannelException;
	import java.nio.file.CopyOption;
	import java.nio.file.DirectoryNotEmptyException;
	import java.nio.file.DirectoryStream;
	import java.nio.file.FileAlreadyExistsException;
	import java.nio.file.FileStore;
	import java.nio.file.Files;
	import java.nio.file.NoSuchFileException;
	import java.nio.file.NotLinkException;
	import java.nio.file.OpenOption;
	import java.nio.file.Path;
	import java.nio.file.Paths;
	import java.nio.file.StandardOpenOption;
	import java.nio.file.attribute.BasicFileAttributeView;
	import java.nio.file.attribute.BasicFileAttributes;
	import java.nio.file.attribute.FileAttribute;
	import java.nio.file.attribute.FileTime;
	import java.nio.file.attribute.PosixFilePermission;
	import java.nio.file.attribute.PosixFilePermissions;
	import java.nio.file.spi.FileSystemProvider;
	import java.util.EnumSet;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;
	import java.util.concurrent.TimeUnit;

	import junitparams.JUnitParamsRunner;
	import junitparams.Parameters;

	import static java.nio.file.StandardCopyOption.ATOMIC_MOVE;
	import static java.nio.file.StandardCopyOption.REPLACE_EXISTING;
	import static java.nio.file.StandardOpenOption.APPEND;
	import static java.nio.file.StandardOpenOption.CREATE;
	import static java.nio.file.StandardOpenOption.READ;
	import static java.nio.file.StandardOpenOption.TRUNCATE_EXISTING;
	import static java.nio.file.StandardOpenOption.WRITE;
	import static junit.framework.TestCase.assertNotNull;
	import static junit.framework.TestCase.assertTrue;
	import static libcore.java.nio.file.FilesSetup.DATA_FILE;
	import static libcore.java.nio.file.FilesSetup.NonStandardOption;
	import static libcore.java.nio.file.FilesSetup.TEST_FILE_DATA;
	import static libcore.java.nio.file.FilesSetup.TEST_FILE_DATA_2;
	import static libcore.java.nio.file.FilesSetup.readFromFile;
	import static libcore.java.nio.file.FilesSetup.writeToFile;
	import static libcore.java.nio.file.LinuxFileSystemTestData.getPath_URI_InputOutputTestData;
	import static org.junit.Assert.assertEquals;
	import static org.junit.Assert.assertFalse;
	import static org.junit.Assert.fail;

	@RunWith(JUnitParamsRunner.class)
	public class DefaultFileSystemProvider2Test {

	@Rule
	public FilesSetup filesSetup = new FilesSetup();

	private FileSystemProvider provider;

	@Before
	public void setUp() throws Exception {
	provider = filesSetup.getDataFilePath().getFileSystem().provider();
	}

	@Test
	public void test_move() throws IOException {
	provider.move(filesSetup.getDataFilePath(), filesSetup.getTestPath());
	assertEquals(TEST_FILE_DATA, readFromFile(filesSetup.getTestPath()));
	assertFalse(Files.exists(filesSetup.getDataFilePath()));

	filesSetup.reset();
	Files.createFile(filesSetup.getTestPath());
	// When target file exists.
	try {
	provider.move(filesSetup.getDataFilePath(), filesSetup.getTestPath());
	fail();
	} catch (FileAlreadyExistsException expected) {}

	// Move to existing target file with REPLACE_EXISTING copy option.
	filesSetup.reset();
	Files.createFile(filesSetup.getTestPath());
	writeToFile(filesSetup.getDataFilePath(), TEST_FILE_DATA_2);
	provider.move(filesSetup.getDataFilePath(), filesSetup.getTestPath(), REPLACE_EXISTING);
	assertEquals(TEST_FILE_DATA_2, readFromFile(filesSetup.getTestPath()));

	// Copy from a non existent file.
	filesSetup.reset();
	try {
	provider.move(filesSetup.getTestPath(), filesSetup.getDataFilePath(), REPLACE_EXISTING);
	fail();
	} catch (NoSuchFileException expected) {}
	}

	@Test
	public void test_move_CopyOption() throws IOException {
	FileTime fileTime = FileTime.fromMillis(System.currentTimeMillis() - 10000);
	Files.setAttribute(filesSetup.getDataFilePath(), "basic:lastModifiedTime", fileTime);
	provider.move(filesSetup.getDataFilePath(), filesSetup.getTestPath());
	assertEquals(fileTime.to(TimeUnit.SECONDS),
	((FileTime) Files.getAttribute(filesSetup.getTestPath(),
	"basic:lastModifiedTime")).to(TimeUnit.SECONDS));
	assertEquals(TEST_FILE_DATA, readFromFile(filesSetup.getTestPath()));

	// ATOMIC_MOVE
	filesSetup.reset();
	provider.move(filesSetup.getDataFilePath(), filesSetup.getTestPath(), ATOMIC_MOVE);
	assertEquals(TEST_FILE_DATA, readFromFile(filesSetup.getTestPath()));

	filesSetup.reset();
	try {
	provider.move(filesSetup.getDataFilePath(), filesSetup.getTestPath(),
	NonStandardOption.OPTION1);
	fail();
	} catch (UnsupportedOperationException expected) {}
	}

	@Test
	public void test_move_NPE() throws IOException {
	try {
	provider.move(null, filesSetup.getTestPath());
	fail();
	} catch(NullPointerException expected) {}

	try {
	provider.move(filesSetup.getDataFilePath(), null);
	fail();
	} catch(NullPointerException expected) {}

	try {
	provider.move(filesSetup.getDataFilePath(), filesSetup.getTestPath(),
	(CopyOption[]) null);
	fail();
	} catch(NullPointerException expected) {}
	}

	@Test
	public void test_move_directory() throws IOException {
	Path dirPath = filesSetup.getPathInTestDir("dir1");
	final Path nestedDirPath = filesSetup.getPathInTestDir("dir1/dir");
	final Path dirPath2 = filesSetup.getPathInTestDir("dir2");

	Files.createDirectory(dirPath);
	Files.createDirectory(nestedDirPath);
	Files.copy(filesSetup.getDataFilePath(),
	filesSetup.getPathInTestDir("dir1/" + DATA_FILE));
	provider.move(dirPath, dirPath2);

	Map<Path, Boolean> pathMap = new HashMap<>();
	try (DirectoryStream<Path> directoryStream = Files.newDirectoryStream(dirPath2)) {
	directoryStream.forEach(file -> pathMap.put(file, true));
	}

	// The files are not copied. The command is equivalent of creating a new directory.
	assertEquals(2, pathMap.size());
	assertEquals(TEST_FILE_DATA,
	readFromFile(filesSetup.getPathInTestDir("dir2/" + DATA_FILE)));
	assertFalse(Files.exists(dirPath));

	filesSetup.reset();
	}

	@Test
	public void test_move_directory_DirectoryNotEmptyException() throws IOException {
	Path dirPath = filesSetup.getPathInTestDir("dir1");
	Path dirPath4 = filesSetup.getPathInTestDir("dir4");
	Files.createDirectory(dirPath);
	Files.createDirectory(dirPath4);
	Files.createFile(Paths.get(dirPath.toString(), DATA_FILE));
	Files.createFile(Paths.get(dirPath4.toString(), DATA_FILE));
	try {
	Files.copy(dirPath, dirPath4, REPLACE_EXISTING);
	fail();
	} catch (DirectoryNotEmptyException expected) {}
	}

	@Test
	public void test_readSymbolicLink() throws IOException {
	provider.createSymbolicLink(/* Path of the symbolic link */ filesSetup.getTestPath(),
	/* Path of the target of the symbolic link */
	filesSetup.getDataFilePath().toAbsolutePath());
	assertEquals(filesSetup.getDataFilePath().toAbsolutePath(),
	Files.readSymbolicLink(filesSetup.getTestPath()));

	// Sym link to itself
	filesSetup.reset();
	provider.createSymbolicLink(/* Path of the symbolic link */ filesSetup.getTestPath(),
	/* Path of the target of the symbolic link */
	filesSetup.getTestPath().toAbsolutePath());
	assertEquals(filesSetup.getTestPath().toAbsolutePath(),
	Files.readSymbolicLink(filesSetup.getTestPath()));

	filesSetup.reset();
	try {
	provider.readSymbolicLink(filesSetup.getDataFilePath());
	fail();
	} catch (NotLinkException expected) {
	}
	}

	@Test
	public void test_readSymbolicLink_NPE() throws IOException {
	try {
	provider.readSymbolicLink(null);
	fail();
	} catch (NullPointerException expected) {}
	}

	@Test
	public void test_isSameFile() throws IOException {
	// When both the files exists.
	assertTrue(provider.isSameFile(filesSetup.getDataFilePath(), filesSetup.getDataFilePath()));

	// When the files doesn't exist.
	assertTrue(provider.isSameFile(filesSetup.getTestPath(), filesSetup.getTestPath()));

	// With two different files.
	try {
	assertFalse(
	provider.isSameFile(filesSetup.getDataFilePath(), filesSetup.getTestPath()));
	fail();
	} catch (NoSuchFileException expected) {}
	}

	@Test
	public void test_isSameFile_NPE() throws IOException {
	try {
	provider.isSameFile(null, filesSetup.getDataFilePath());
	fail();
	} catch (NullPointerException expected) {}

	try {
	provider.isSameFile(filesSetup.getDataFilePath(), null);
	fail();
	} catch (NullPointerException expected) {}
	}

	@Test
	public void test_getFileStore() throws IOException {
	try {
	provider.getFileStore(filesSetup.getDataFilePath());
	fail();
	} catch (SecurityException expected) {
	}

	try {
	provider.getFileStore(null);
	fail();
	} catch (SecurityException expected) {
	}
	}

	@Test
	public void test_isHidden() throws IOException {
	assertFalse(provider.isHidden(filesSetup.getDataFilePath()));

	// Files can't be hidden using the "dos" view, which is unsupported since it relies
	// on a custom xattr, which may or may not be available on all FSs.
	//
	// Note that this weirdly asymmetric : setting the hidden attribute uses xattrs to
	// emulate dos attributes whereas isHidden checks whether the the file name begins with a
	// leading period. <shrug>
	try {
	Files.setAttribute(filesSetup.getDataFilePath(), "dos:hidden", true);
	fail();
	} catch (UnsupportedOperationException expected) {
	}

	assertFalse(provider.isHidden(filesSetup.getDataFilePath()));
	}

	@Test
	public void test_isHidden_NPE() throws IOException {
	try {
	provider.isHidden(null);
	fail();
	} catch (NullPointerException expected) {}
	}

	@Test
	public void test_probeContentType_NPE() throws IOException {
	try {
	Files.probeContentType(null);
	fail();
	} catch (NullPointerException expected) {}
	}

	@Test
	public void test_getFileAttributeView() throws IOException {
	BasicFileAttributeView fileAttributeView = provider
	.getFileAttributeView(filesSetup.getDataFilePath(),
	BasicFileAttributeView.class);

	assertTrue(fileAttributeView.readAttributes().isRegularFile());
	assertFalse(fileAttributeView.readAttributes().isDirectory());
	}

	@Test
	public void test_getFileAttributeView_NPE() throws IOException {
	try {
	provider.getFileAttributeView(null, BasicFileAttributeView.class);
	fail();
	} catch (NullPointerException expected) {}

	try {
	provider.getFileAttributeView(filesSetup.getDataFilePath(), null);
	fail();
	} catch (NullPointerException expected) {}
	}

	@Test
	public void test_readAttributes() throws IOException {
	FileTime fileTime = FileTime.fromMillis(System.currentTimeMillis() - 10000);
	Files.setAttribute(filesSetup.getDataFilePath(), "basic:lastModifiedTime", fileTime);
	BasicFileAttributes basicFileAttributes = provider
	.readAttributes(filesSetup.getDataFilePath(),
	BasicFileAttributes.class);
	FileTime lastModifiedTime = basicFileAttributes.lastModifiedTime();
	assertEquals(fileTime.to(TimeUnit.SECONDS), lastModifiedTime.to(TimeUnit.SECONDS));

	// When file is NON_EXISTENT.
	try {
	provider.readAttributes(filesSetup.getTestPath(), BasicFileAttributes.class);
	fail();
	} catch (NoSuchFileException expected) {}
	}

	@Test
	public void test_readAttributes_NPE() throws IOException {
	try {
	provider.readAttributes(filesSetup.getDataFilePath(),
	(Class<BasicFileAttributes>) null);
	fail();
	} catch(NullPointerException expected) {}

	try {
	provider.readAttributes(null, BasicFileAttributes.class);
	fail();
	} catch(NullPointerException expected) {}
	}

	@Test
	public void test_setAttribute() throws IOException {
	// Other tests are covered in test_readAttributes.
	// When file is NON_EXISTENT.
	try {
	FileTime fileTime = FileTime.fromMillis(System.currentTimeMillis());
	provider.setAttribute(filesSetup.getTestPath(), "basic:lastModifiedTime", fileTime);
	fail();
	} catch (NoSuchFileException expected) {}

	// ClassCastException
	try {
	provider.setAttribute(filesSetup.getDataFilePath(), "basic:lastModifiedTime", 10);
	fail();
	} catch (ClassCastException expected) {}

	// IllegalArgumentException
	try {
	provider.setAttribute(filesSetup.getDataFilePath(), "xyz", 10);
	fail();
	} catch (IllegalArgumentException expected) {}

	try {
	provider.setAttribute(null, "xyz", 10);
	fail();
	} catch (NullPointerException expected) {}

	try {
	provider.setAttribute(filesSetup.getDataFilePath(), null, 10);
	fail();
	} catch (NullPointerException expected) {}
	}

	@Test
	public void test_newFileChannel() throws IOException {
	Set<OpenOption> openOptions = new HashSet<>();

	// When file doesn't exist/
	try {
	// With CREATE & WRITE in OpenOptions.
	openOptions.add(CREATE);
	openOptions.add(WRITE);
	provider.newFileChannel(filesSetup.getTestPath(), openOptions);
	assertTrue(Files.exists(filesSetup.getTestPath()));
	Files.delete(filesSetup.getTestPath());
	} finally {
	filesSetup.reset();
	openOptions.clear();
	}

	try {
	// With CREATE & APPEND in OpenOption.
	assertFalse(Files.exists(filesSetup.getTestPath()));
	openOptions.add(CREATE);
	openOptions.add(APPEND);
	provider.newFileChannel(filesSetup.getTestPath(), openOptions);
	assertTrue(Files.exists(filesSetup.getTestPath()));
	Files.delete(filesSetup.getTestPath());
	} finally {
	filesSetup.reset();
	openOptions.clear();
	}

	// When file exists.
	try {
	FileChannel fc = provider.newFileChannel(filesSetup.getDataFilePath(), openOptions);
	assertEquals(filesSetup.TEST_FILE_DATA, readFromFileChannel(fc));
	} finally {
	filesSetup.reset();
	openOptions.clear();
	}

	try {
	// When file exists and READ in OpenOptions.
	openOptions.add(READ);
	FileChannel fc = provider.newFileChannel(filesSetup.getDataFilePath(), openOptions);
	assertEquals(filesSetup.TEST_FILE_DATA, readFromFileChannel(fc));
	} finally {
	filesSetup.reset();
	openOptions.clear();
	}

	// Reading from a file opened with WRITE.
	try {
	openOptions.add(WRITE);
	FileChannel fc = provider.newFileChannel(filesSetup.getDataFilePath(), openOptions);
	assertEquals(filesSetup.TEST_FILE_DATA, readFromFileChannel(fc));
	fail();
	} catch (NonReadableChannelException expected) {
	} finally {
	filesSetup.reset();
	openOptions.clear();
	}

	// Writing to an exiting file.
	try {
	openOptions.add(WRITE);
	FileChannel fc = provider.newFileChannel(filesSetup.getDataFilePath(), openOptions);
	writeToFileChannel(fc, filesSetup.TEST_FILE_DATA_2);
	fc.close();
	assertEquals(overlayString1OnString2(TEST_FILE_DATA_2, TEST_FILE_DATA),
	readFromFile(filesSetup.getDataFilePath()));
	} finally {
	filesSetup.reset();
	openOptions.clear();
	}

	// APPEND to an existing file.
	try {
	openOptions.add(WRITE);
	openOptions.add(TRUNCATE_EXISTING);
	FileChannel fc = provider.newFileChannel(filesSetup.getDataFilePath(), openOptions);
	writeToFileChannel(fc, filesSetup.TEST_FILE_DATA_2);
	fc.close();
	assertEquals(TEST_FILE_DATA_2, readFromFile(filesSetup.getDataFilePath()));
	} finally {
	filesSetup.reset();
	openOptions.clear();
	}

	// TRUNCATE an existing file.
	try {
	openOptions.add(WRITE);
	openOptions.add(APPEND);
	FileChannel fc = provider.newFileChannel(filesSetup.getDataFilePath(), openOptions);
	writeToFileChannel(fc, filesSetup.TEST_FILE_DATA_2);
	fc.close();
	assertEquals(TEST_FILE_DATA + TEST_FILE_DATA_2, readFromFile(filesSetup.getDataFilePath()));
	} finally {
	filesSetup.reset();
	openOptions.clear();
	}
	}

	@Test
	@Parameters(method = "parameters_test_newFileChannel_NoSuchFileException")
	public void test_newFileChannel_NoSuchFileException(Set<? extends OpenOption> openOptions)
	throws IOException {
	try {
	provider.newFileChannel(filesSetup.getTestPath(), openOptions);
	fail();
	} catch (NoSuchFileException expected) {}
	}

	@SuppressWarnings("unused")
	private Object[] parameters_test_newFileChannel_NoSuchFileException() {
	return new Object[] {
	new Object[] { EnumSet.noneOf(StandardOpenOption.class) },
	new Object[] { EnumSet.of(READ) },
	new Object[] { EnumSet.of(WRITE) },
	new Object[] { EnumSet.of(TRUNCATE_EXISTING) },
	new Object[] { EnumSet.of(APPEND) },
	new Object[] { EnumSet.of(CREATE, READ) },
	new Object[] { EnumSet.of(CREATE, TRUNCATE_EXISTING) },
	new Object[] { EnumSet.of(CREATE, READ) },
	};
	}

	@Test
	public void test_newFileChannel_withFileAttributes() throws IOException {
	Set<OpenOption> openOptions = new HashSet<>();
	FileTime fileTime = FileTime.fromMillis(System.currentTimeMillis());
	Files.setAttribute(filesSetup.getDataFilePath(), "basic:lastModifiedTime", fileTime);
	FileAttribute<FileTime> unsupportedAttr = new MockFileAttribute<>(
	"basic:lastModifiedTime", fileTime);

	Set<PosixFilePermission> perm = PosixFilePermissions.fromString("rwx------");
	FileAttribute<Set<PosixFilePermission>> supportedAttr =
	PosixFilePermissions.asFileAttribute(perm);

	try {
	// When file doesn't exists and with OpenOption CREATE & WRITE.
	openOptions.clear();
	openOptions.add(CREATE);
	openOptions.add(WRITE);
	provider.newFileChannel(filesSetup.getTestPath(), openOptions, unsupportedAttr);
	fail();
	} catch (UnsupportedOperationException expected) {
	} finally {
	filesSetup.reset();
	openOptions.clear();
	}

	try {
	// With OpenOption CREATE & WRITE.
	openOptions.clear();
	openOptions.add(CREATE);
	openOptions.add(WRITE);
	provider.newFileChannel(filesSetup.getTestPath(), openOptions, supportedAttr);
	assertEquals(supportedAttr.value(), Files.getAttribute(filesSetup.getTestPath(),
	supportedAttr.name()));
	} finally {
	filesSetup.reset();
	openOptions.clear();
	}

	// When file exists.
	try {
	provider.newFileChannel(filesSetup.getDataFilePath(), openOptions,
	unsupportedAttr);
	fail();
	} catch (UnsupportedOperationException expected) {
	} finally {
	filesSetup.reset();
	openOptions.clear();
	}

	// When file exists. No change in permissions.
	try {
	Set<PosixFilePermission> originalPermissions= (Set<PosixFilePermission>)
	Files.getAttribute(filesSetup.getDataFilePath(), supportedAttr.name());
	FileChannel fc = provider.newFileChannel(filesSetup.getDataFilePath(), openOptions,
	supportedAttr);
	assertEquals(originalPermissions, Files.getAttribute(filesSetup.getDataFilePath(),
	supportedAttr.name()));
	} finally {
	filesSetup.reset();
	openOptions.clear();
	}
	}


	@Test
	public void test_newFileChannel_NPE() throws IOException {
	try {
	provider.newByteChannel(null, new HashSet<>(), new MockFileAttribute<>());
	fail();
	} catch (NullPointerException expected) {}

	try {
	provider.newByteChannel(filesSetup.getTestPath(), null, new MockFileAttribute<>());
	fail();
	} catch (NullPointerException expected) {}

	try {
	provider.newByteChannel(filesSetup.getTestPath(), new HashSet<>(), null);
	fail();
	} catch (NullPointerException expected) {}
	}

	@Test
	public void test_getPath() throws Exception {
	List<LinuxFileSystemTestData.TestData> inputOutputTestCases = getPath_URI_InputOutputTestData();
	for (LinuxFileSystemTestData.TestData inputOutputTestCase : inputOutputTestCases) {
	assertEquals(inputOutputTestCase.output,
	provider.getPath(new URI(inputOutputTestCase.input)).toString());
	}

	// When URI is null.
	try {
	provider.getPath(null);
	fail();
	} catch (NullPointerException expected) {}

	// When Schema is not supported.
	try {
	provider.getPath(new URI("scheme://d"));
	fail();
	} catch (IllegalArgumentException expected) {}
	}

	@Test
	public void test_getScheme() {
	assertEquals("file", provider.getScheme());
	}

	@Test
	public void test_installedProviders() {
	assertNotNull(provider.installedProviders());
	}

	@Test
	public void test_newFileSystem$URI$Map() throws Exception {
	Path testPath = Paths.get("/");
	assertNotNull(provider.getFileSystem(testPath.toUri()));

	try {
	provider.getFileSystem(null);
	fail();
	} catch (NullPointerException expected) {}

	// Test the case when URI has illegal scheme.
	URI stubURI = new URI("scheme://path");
	try {
	provider.getFileSystem(stubURI);
	fail();
	} catch (IllegalArgumentException expected) {}
	}

	String readFromFileChannel(FileChannel fc) throws IOException {
	ByteBuffer bb = ByteBuffer.allocate(20);
	fc.read(bb);
	return new String(bb.array(), "UTF-8").trim();
	}

	void writeToFileChannel(FileChannel fc, String data) throws IOException {
	fc.write(ByteBuffer.wrap(data.getBytes()));
	}

	String overlayString1OnString2(String s1, String s2) {
	return s1 + s2.substring(s1.length());
	}

	static class MockFileAttribute<T> implements FileAttribute {

	String name;
	T value;

	MockFileAttribute() {
	}

	MockFileAttribute(String name, T value) {
	this.name = name;
	this.value = value;
	}

	@Override
	public String name() {
	return name;
	}

	@Override
	public T value() {
	return value;
	}
	}
	}