Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2012 JBoss Inc
   *
   * 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 org.uberfire.java.nio.fs.file;
 
 import java.io.File;
 import java.net.URI;
 
 import org.junit.Test;
 import  org.uberfire.java.nio.base.GeneralPathImpl;
 import  org.uberfire.java.nio.channels.SeekableByteChannel;
 import  org.uberfire.java.nio.file.DirectoryNotEmptyException;
 import  org.uberfire.java.nio.file.DirectoryStream;
 import  org.uberfire.java.nio.file.FileAlreadyExistsException;
 import  org.uberfire.java.nio.file.FileSystemAlreadyExistsException;
 import  org.uberfire.java.nio.file.NoSuchFileException;
 import  org.uberfire.java.nio.file.NotDirectoryException;
 import  org.uberfire.java.nio.file.NotLinkException;
 import  org.uberfire.java.nio.file.Path;
 
 import static org.fest.assertions.api.Assertions.*;
 import static org.uberfire.java.nio.file.StandardDeleteOption.*;
 
 public class SimpleFileSystemProviderTest {
 
     @Before
     @After
     public void cleanup() {
         new File( System.getProperty"user.dir" ) + "/temp" ).delete();
         new File( System.getProperty"user.dir" ) + "/temp2" ).delete();
         new File( System.getProperty"user.dir" ) + "/xxxxxx" ).delete();
     }
 
     @Test
     public void simpleStateTest() {
         final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
 
         assertThatfsProvider ).isNotNull();
         assertThatfsProvider.getScheme() ).isNotEmpty().isEqualTo"file" );
 
         assertThatfsProvider.isDefault() ).isFalse();
         fsProvider.forceAsDefault();
         assertThatfsProvider.isDefault() ).isTrue();
     }
 
     @Test
     public void validateGetPath() {
         final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
         final URI uri = URI.create"file:///path/to/file.txt" );
 
         final Path path = fsProvider.getPathuri );
 
         assertThatpath ).isNotNull();
         assertThatpath.isAbsolute() ).isTrue();
         assertThatpath.getFileSystem() ).isEqualTo( fsProvider.getFileSystemuri ) );
         assertThatpath.getFileSystem().provider() ).isEqualTo( fsProvider );
 
         assertThatpath.toString() ).isEqualTo( "/path/to/file.txt" );
     }
 
     @Test(expected = IllegalArgumentException.class)
     public void getPathNull() {
         final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
         fsProvider.getPathnull );
     }
 
     @Test(expected = IllegalStateException.class)
     public void getPathInvalidScheme() {
         final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
         fsProvider.getPath( URI.create"http:///path/to/file.txt" ) );
     }
 
     @Test(expected = FileSystemAlreadyExistsException.class)
     public void newFileSystemCantCreateURI() {
         final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        fsProvider.newFileSystem( URI.create"file:///" ), new HashMap<StringObject>() );
    }
    @Test(expected = FileSystemAlreadyExistsException.class)
    public void newFileSystemCantCreatePath() {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final URI uri = URI.create"file:///" );
        final Path path = GeneralPathImpl.create( fsProvider.getFileSystemuri ), uri.getPath(), false );
        fsProvider.newFileSystempathnew HashMap<StringObject>() );
    }
    @Test
    public void checkNewInputStream() throws IOException {
        final File temp = File.createTempFile"foo""bar" );
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final Path path = GeneralPathImpl.newFromFile( fsProvider.getFileSystem( URI.create"file:///" ) ), temp );
        final InputStream stream = fsProvider.newInputStreampath );
        assertThatstream ).isNotNull();
        stream.close();
    }
    @Test(expected = NoSuchFileException.class)
    public void inputStreamFileDoesntExists() throws IOException {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final Path path = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), "/path/to/file.txt"false );
        fsProvider.newInputStreampath );
    }
    @Test(expected = IllegalArgumentException.class)
    public void inputStreamNull() throws IOException {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        fsProvider.newInputStreamnull );
    }
    @Test
    public void checkNewOutputStream() throws IOException {
        final File temp = File.createTempFile"foo""bar" );
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final Path path = GeneralPathImpl.newFromFile( fsProvider.getFileSystem( URI.create"file:///" ) ), temp );
        final OutputStream stream = fsProvider.newOutputStreampath );
        assertThatstream ).isNotNull();
        stream.close();
    }
    @Test(expected = org.uberfire.java.nio.IOException.class)
    public void outputStreamFileDoesntExists() throws IOException {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final Path path = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), "/path/to/file.txt"false );
        fsProvider.newOutputStreampath );
    }
    @Test(expected = org.uberfire.java.nio.IOException.class)
    public void outputStreamOnDirectory() throws IOException {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final Path path = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), "/"false );
        fsProvider.newOutputStreampath );
    }
    @Test(expected = IllegalArgumentException.class)
    public void outputStreamNull() throws IOException {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        fsProvider.newOutputStreamnull );
    }
    @Test
    public void checkNewFileChannel() throws IOException {
        final File temp = File.createTempFile"foo""bar" );
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final Path path = GeneralPathImpl.newFromFile( fsProvider.getFileSystem( URI.create"file:///" ) ), temp );
        final FileChannel stream = fsProvider.newFileChannelpathnull );
        assertThatstream ).isNotNull();
        stream.close();
    }
    @Test(expected = org.uberfire.java.nio.IOException.class)
    public void fileChannelFileDoesntExists() throws IOException {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final Path path = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), "/path/to/file.txt"false );
        fsProvider.newFileChannelpathnull );
    }
    @Test(expected = IllegalArgumentException.class)
    public void fileChannelNull() throws IOException {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        fsProvider.newFileChannelnullnull );
    }
    @Test
    public void checkNewByteChannelToCreateFile() throws IOException {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final String userBasedPath = System.getProperty"user.dir" ) + "/byte_some_file_here.txt";
        final Path path = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), userBasedPathfalse );
        assertThatpath.toFile().exists() ).isFalse();
        final SeekableByteChannel channel = fsProvider.newByteChannelpathnull );
        assertThatchannel ).isNotNull();
        assertThatpath.toFile().exists() ).isTrue();
        path.toFile().delete();
        assertThatpath.toFile().exists() ).isFalse();
    }
    @Test(expected = FileAlreadyExistsException.class)
    public void newByteChannelFileAlreadyExists() throws IOException {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final File tempFile = File.createTempFile"foo""bar" );
        final Path path = GeneralPathImpl.newFromFile( fsProvider.getFileSystem( URI.create"file:///" ) ), tempFile );
        assertThatpath.toFile().exists() ).isTrue();
        assertThatpath.toFile() ).isEqualTo( tempFile );
        fsProvider.newByteChannelpathnull );
    }
    @Test(expected = org.uberfire.java.nio.IOException.class)
    public void newByteChannelInvalidPath() throws IOException {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final String userBasedPath = System.getProperty"user.dir" ) + "path/to/some_file_here.txt";
        final Path path = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), userBasedPathfalse );
        assertThatpath.toFile().exists() ).isFalse();
        fsProvider.newByteChannelpathnull );
    }
    @Test(expected = IllegalArgumentException.class)
    public void newByteChannelNull() throws IOException {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        fsProvider.newByteChannelnullnull );
    }
    @Test(expected = UnsupportedOperationException.class)
    public void newAsynchronousFileChannelUnsupportedOp() throws IOException {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final Path path = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), "/path/to/file.txt"false );
        fsProvider.newAsynchronousFileChannelpathnullnull );
    }
    @Test(expected = IllegalArgumentException.class)
    public void newAsynchronousFileChannelNull() throws IOException {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        fsProvider.newAsynchronousFileChannelnullnullnull );
    }
    @Test
    public void seekableByteChannel() throws IOException {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final String userBasedPath = System.getProperty"user.dir" ) + "/my_byte_some_file_here.txt";
        final Path path = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), userBasedPathfalse );
        assertThatpath.toFile().exists() ).isFalse();
        final SeekableByteChannel channel = fsProvider.newByteChannelpathnull );
        assertThatchannel ).isNotNull();
        assertThatpath.toFile().exists() ).isTrue();
        assertThatchannel.isOpen() ).isTrue();
        channel.close();
        assertThatchannel.isOpen() ).isFalse();
//        try {
//            channel.position();
//            fail( "method not implemented - exception expected!" );
//        } catch ( NotImplementedException ex ) {
//        }
//
//        try {
//            channel.position( 1L );
//            fail( "method not implemented - exception expected!" );
//        } catch ( NotImplementedException ex ) {
//        }
//
//        try {
//            channel.size();
//            fail( "method not implemented - exception expected!" );
//        } catch ( NotImplementedException ex ) {
//        }
//
//        try {
//            channel.truncate( 1L );
//            fail( "method not implemented - exception expected!" );
//        } catch ( NotImplementedException ex ) {
//        }
//
//        try {
//            channel.read( null );
//            fail( "method not implemented - exception expected!" );
//        } catch ( NotImplementedException ex ) {
//        }
//
//        try {
//            channel.write( null );
//            fail( "method not implemented - exception expected!" );
//        } catch ( NotImplementedException ex ) {
//        }
        path.toFile().delete();
        assertThatpath.toFile().exists() ).isFalse();
    }
    @Test
    public void checkCreateDirectory() {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final String userBasedPath = System.getProperty"user.dir" ) + "/temp";
        final Path path = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), userBasedPathfalse );
        path.toFile().delete();
        assertThatpath.toFile().exists() ).isFalse();
        fsProvider.createDirectorypath );
        assertThatpath.toFile().exists() ).isTrue();
        path.toFile().delete();
        assertThatpath.toFile().exists() ).isFalse();
    }
    @Test(expected = FileAlreadyExistsException.class)
    public void checkCreateDirectoryAlreadyExists() {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final String userBasedPath = System.getProperty"user.dir" ) + "/temp";
        final Path path = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), userBasedPathfalse );
        assertThatpath.toFile().exists() ).isFalse();
        fsProvider.createDirectorypath );
        assertThatpath.toFile().exists() ).isTrue();
        fsProvider.createDirectorypath );
    }
    @Test(expected = IllegalArgumentException.class)
    public void createDirectoryNull() {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        fsProvider.createDirectorynull );
    }
    @Test(expected = IllegalArgumentException.class)
    public void createSymbolicLinkNull1() {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        fsProvider.createSymbolicLinknullnull );
    }
    @Test(expected = IllegalArgumentException.class)
    public void createSymbolicLinkNull2() {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final Path path = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), "/path/to/file.txt"false );
        fsProvider.createSymbolicLinkpathnull );
    }
    @Test(expected = IllegalArgumentException.class)
    public void createSymbolicLinkNull3() {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final Path path = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), "/path/to/file.txt"false );
        fsProvider.createSymbolicLinknullpath );
    }
    @Test(expected = IllegalStateException.class)
    public void createSymbolicLinkSame() {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final Path path = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), "/path/to/file.txt"false );
        fsProvider.createSymbolicLinkpathpath );
    }
    @Test(expected = IllegalStateException.class)
    public void createSymbolicLinkTargetMustExists() throws IOException {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final Path path = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), "/path/to/file.txt"false );
        final Path path2 = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), "/path/to/file2.txt"false );
        fsProvider.createSymbolicLinkpathpath2 );
    }
    @Test(expected = UnsupportedOperationException.class)
    public void createSymbolicLinkUnsupportedOp() throws IOException {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final Path path = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), "/path/to/file.txt"false );
        final File tempFile = File.createTempFile"foo""bar" );
        final Path path2 = GeneralPathImpl.newFromFile( fsProvider.getFileSystem( URI.create"file:///" ) ), tempFile );
        fsProvider.createSymbolicLinkpathpath2 );
    }
    @Test(expected = IllegalArgumentException.class)
    public void createLinkNull1() {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        fsProvider.createLinknullnull );
    }
    @Test(expected = IllegalArgumentException.class)
    public void createLinkNull2() {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final Path path = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), "/path/to/file.txt"false );
        fsProvider.createLinkpathnull );
    }
    @Test(expected = IllegalArgumentException.class)
    public void createLinkNull3() {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final Path path = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), "/path/to/file.txt"false );
        fsProvider.createLinknullpath );
    }
    @Test(expected = IllegalStateException.class)
    public void createLinkSame() {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final Path path = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), "/path/to/file.txt"false );
        fsProvider.createLinkpathpath );
    }
    @Test(expected = UnsupportedOperationException.class)
    public void createLinkUnsupportedOp() throws IOException {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final Path path = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), "/path/to/file.txt"false );
        final File tempFile = File.createTempFile"foo""bar" );
        final Path path2 = GeneralPathImpl.newFromFile( fsProvider.getFileSystem( URI.create"file:///" ) ), tempFile );
        fsProvider.createLinkpathpath2 );
    }
    @Test
    public void checkDelete() throws IOException {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final File tempFile = File.createTempFile"foo""bar" );
        final Path path = GeneralPathImpl.newFromFile( fsProvider.getFileSystem( URI.create"file:///" ) ), tempFile );
        assertThatpath.toFile().exists() ).isTrue();
        fsProvider.deletepath );
        assertThatpath.toFile().exists() ).isFalse();
    }
    @Test(expected = NoSuchFileException.class)
    public void checkDeleteNonExistent() throws IOException {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final Path path = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), "/path/to/file.txt"false );
        assertThatpath.toFile().exists() ).isFalse();
        fsProvider.deletepath );
    }
    @Test(expected = IllegalArgumentException.class)
    public void checkDeleteNull() {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        fsProvider.deletenull );
    }
    @Test
    public void checkDeleteIfExists() throws IOException {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final File tempFile = File.createTempFile"foo""bar" );
        final Path path = GeneralPathImpl.newFromFile( fsProvider.getFileSystem( URI.create"file:///" ) ), tempFile );
        assertThatpath.toFile().exists() ).isTrue();
        assertThatfsProvider.deleteIfExistspath ) ).isTrue();
        assertThatpath.toFile().exists() ).isFalse();
    }
    @Test
    public void checkDeleteIfExistsNonExistent() throws IOException {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final Path path = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), "/path/to/file.txt"false );
        assertThatpath.toFile().exists() ).isFalse();
        assertThatfsProvider.deleteIfExistspath ) ).isFalse();
        assertThatpath.toFile().exists() ).isFalse();
    }
    @Test(expected = IllegalArgumentException.class)
    public void checkDeleteIfExistsNull() {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        fsProvider.deleteIfExistsnull );
    }
    @Test(expected = IllegalArgumentException.class)
    public void readSymbolicLinkNull() {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        fsProvider.readSymbolicLinknull );
    }
    @Test(expected = NotLinkException.class)
    public void readSymbolicLinkNotLink() {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final Path path = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), "/path/to/file.txt"false );
        fsProvider.readSymbolicLinkpath );
    }
    @Test(expected = UnsupportedOperationException.class)
    public void readSymbolicLinkUnsupportedOp() throws IOException {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final File tempFile = File.createTempFile"foo""bar" );
        final Path path = GeneralPathImpl.newFromFile( fsProvider.getFileSystem( URI.create"file:///" ) ), tempFile );
        fsProvider.readSymbolicLinkpath );
    }
    @Test
    public void checkIsSameFile() {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final Path path = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), "/path/to/file.txt"false );
        final Path path2 = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), "/path/to/file.txt"false );
        assertThatfsProvider.isSameFilepathpath2 ) ).isTrue();
        final Path path3 = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), "path/to/file.txt"false );
        assertThatfsProvider.isSameFilepathpath3 ) ).isFalse();
    }
    @Test(expected = IllegalArgumentException.class)
    public void sameFileNull1() {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        fsProvider.isSameFilenullnull );
    }
    @Test(expected = IllegalArgumentException.class)
    public void sameFileNull2() {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final Path path = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), "/path/to/file.txt"false );
        fsProvider.isSameFilepathnull );
    }
    @Test(expected = IllegalArgumentException.class)
    public void sameFileNull3() {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final Path path = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), "/path/to/file.txt"false );
        fsProvider.isSameFilenullpath );
    }
    @Test
    public void checkCopyDir() {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final String userSourcePath = System.getProperty"user.dir" ) + "/temp";
        final String userDestPath = System.getProperty"user.dir" ) + "/temp2";
        final Path source = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), userSourcePathfalse );
        final Path dest = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), userDestPathfalse );
        fsProvider.createDirectorysource );
        fsProvider.copysourcedest );
        assertThatdest.toFile().exists() ).isTrue();
        assertThatsource.toFile().exists() ).isTrue();
        source.toFile().delete();
        dest.toFile().delete();
    }
    @Test
    public void checkCopyFile() throws IOException {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final String userSourcePath = System.getProperty"user.dir" ) + "/temp.txt";
        final String userDestPath = System.getProperty"user.dir" ) + "/temp2.txt";
        final Path source = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), userSourcePathfalse );
        final Path dest = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), userDestPathfalse );
        final OutputStream stream = fsProvider.newOutputStreamsource );
        stream.write'a' );
        stream.close();
        fsProvider.copysourcedest );
        assertThatdest.toFile().exists() ).isTrue();
        assertThatsource.toFile().exists() ).isTrue();
        assertThatdest.toFile().length() ).isEqualTo( source.toFile().length() );
        source.toFile().delete();
        dest.toFile().delete();
    }
    @Test
    public void copyFileInvalidSourceAndTarget() throws IOException {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final String userSourcePath = System.getProperty"user.dir" ) + "/temp";
        final String userDestPath = System.getProperty"user.dir" ) + "/temp2";
        final Path source = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), userSourcePathfalse );
        final Path dest = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), userDestPathfalse );
        fsProvider.createDirectorysource );
        final Path sourceFile = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), userSourcePath + "/file.txt"false );
        final OutputStream stream = fsProvider.newOutputStreamsourceFile );
        stream.write'a' );
        stream.close();
        try {
            fsProvider.copysourcedest );
            fail"source isn't empty" );
        } catch ( Exception ex ) {
        }
        sourceFile.toFile().delete();
        fsProvider.copysourcedest );
        try {
            fsProvider.copysourcedest );
            fail"dest already exists" );
        } catch ( Exception ex ) {
        }
        dest.toFile().delete();
        source.toFile().delete();
        try {
            fsProvider.copysourcedest );
            fail"source doesn't exists" );
        } catch ( Exception ex ) {
        } finally {
        }
    }
    @Test(expected = IllegalArgumentException.class)
    public void copyFileNull1() throws IOException {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final String userPath = System.getProperty"user.dir" ) + "/temp";
        final Path path = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), userPathfalse );
        fsProvider.copypathnull );
    }
    @Test(expected = IllegalArgumentException.class)
    public void copyFileNull2() throws IOException {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final String userPath = System.getProperty"user.dir" ) + "/temp";
        final Path path = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), userPathfalse );
        fsProvider.copynullpath );
    }
    @Test(expected = IllegalArgumentException.class)
    public void copyFileNull3() throws IOException {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        fsProvider.copynullnull );
    }
    @Test
    public void checkMoveDir() {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final String userSourcePath = System.getProperty"user.dir" ) + "/temp";
        final String userDestPath = System.getProperty"user.dir" ) + "/temp2";
        final Path source = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), userSourcePathfalse );
        final Path dest = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), userDestPathfalse );
        fsProvider.createDirectorysource );
        fsProvider.movesourcedest );
        assertThatsource.toFile().exists() ).isFalse();
        assertThatdest.toFile().exists() ).isTrue();
        dest.toFile().delete();
    }
    @Test
    public void checkMoveFile() throws IOException {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final String userSourcePath = System.getProperty"user.dir" ) + "/temp.txt";
        final String userDestPath = System.getProperty"user.dir" ) + "/temp2.txt";
        final Path source = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), userSourcePathfalse );
        final Path dest = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), userDestPathfalse );
        final OutputStream stream = fsProvider.newOutputStreamsource );
        stream.write'a' );
        stream.close();
        long lenght = source.toFile().length();
        fsProvider.movesourcedest );
        assertThatdest.toFile().exists() ).isTrue();
        assertThatsource.toFile().exists() ).isFalse();
        assertThatdest.toFile().length() ).isEqualTo( lenght );
        dest.toFile().delete();
    }
    @Test
    public void moveFileInvalidSourceAndTarget() throws IOException {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final String userSourcePath = System.getProperty"user.dir" ) + "/temp";
        final String userDestPath = System.getProperty"user.dir" ) + "/temp2";
        final Path source = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), userSourcePathfalse );
        final Path dest = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), userDestPathfalse );
        fsProvider.createDirectorysource );
        final Path sourceFile = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), userSourcePath + "/file.txt"false );
        final OutputStream stream = fsProvider.newOutputStreamsourceFile );
        stream.write'a' );
        stream.close();
        try {
            fsProvider.movesourcedest );
            fail"source isn't empty" );
        } catch ( Exception ex ) {
        }
        sourceFile.toFile().delete();
        fsProvider.copysourcedest );
        try {
            fsProvider.movesourcedest );
            fail"dest already exists" );
        } catch ( Exception ex ) {
        }
        dest.toFile().delete();
        source.toFile().delete();
        try {
            fsProvider.movesourcedest );
            fail"source doesn't exists" );
        } catch ( Exception ex ) {
        } finally {
        }
    }
    @Test(expected = IllegalArgumentException.class)
    public void moveFileNull1() throws IOException {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final String userPath = System.getProperty"user.dir" ) + "/temp";
        final Path path = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), userPathfalse );
        fsProvider.movepathnull );
    }
    @Test(expected = IllegalArgumentException.class)
    public void moveFileNull2() throws IOException {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final String userPath = System.getProperty"user.dir" ) + "/temp";
        final Path path = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), userPathfalse );
        fsProvider.movenullpath );
    }
    @Test(expected = IllegalArgumentException.class)
    public void moveFileNull3() throws IOException {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        fsProvider.movenullnull );
    }
    @Test
    public void checkNewDirectoryStream() throws IOException {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final String userSourcePath = System.getProperty"user.dir" ) + "/temp";
        final Path dir = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), userSourcePathfalse );
        FileUtils.deleteDirectorydir.toFile() );
        fsProvider.createDirectorydir );
        final DirectoryStream<Path> stream = fsProvider.newDirectoryStream( dirnew DirectoryStream.Filter<Path>() {
            @Override
            public boolean accept( Path entry ) throws org.uberfire.java.nio.IOException {
                return true;
            }
        } );
        assertThatstream ).hasSize( 0 );
        try {
            stream.iterator().next();
            fail"can't navigate to next on empty iterator" );
        } catch ( NoSuchElementException ex ) {
        }
        final File tempFile = File.createTempFile"foo""bar"dir.toFile() );
        final Path path = GeneralPathImpl.newFromFile( fsProvider.getFileSystem( URI.create"file:///" ) ), tempFile );
        final DirectoryStream<Path> stream2 = fsProvider.newDirectoryStream( dirnew DirectoryStream.Filter<Path>() {
            @Override
            public boolean accept( Path entry ) throws org.uberfire.java.nio.IOException {
                return true;
            }
        } );
        assertThatstream2 ).hasSize( 1 );
        final Iterator<Path> iterator = stream2.iterator();
        iterator.next();
        try {
            iterator.remove();
            fail"can't remove elements" );
        } catch ( UnsupportedOperationException ex ) {
        }
        stream2.close();
        try {
            stream2.close();
            fail"stram already closed" );
        } catch ( Exception ex ) {
        }
        final File tempFile2 = File.createTempFile"bar""foo"dir.toFile() );
        final Path path2 = GeneralPathImpl.newFromFile( fsProvider.getFileSystem( URI.create"file:///" ) ), tempFile2 );
        final DirectoryStream<Path> stream3 = fsProvider.newDirectoryStream( dirnew DirectoryStream.Filter<Path>() {
            @Override
            public boolean accept( Path entry ) throws org.uberfire.java.nio.IOException {
                return true;
            }
        } );
        assertThatstream3 ).hasSize( 2 ).contains( pathpath2 );
        stream3.close();
        try {
            stream3.iterator().next();
            fail"can't interact in an already closed stream" );
        } catch ( Exception ex ) {
        }
        final DirectoryStream<Path> stream4 = fsProvider.newDirectoryStream( dirnew DirectoryStream.Filter<Path>() {
            @Override
            public boolean accept( final Path entry ) throws org.uberfire.java.nio.IOException {
                if ( entry.getFileName().toString().startsWith( "foo" ) ) {
                    return true;
                }
                return false;
            }
        } );
        assertThatstream4 ).hasSize( 1 ).contains( path );
        FileUtils.deleteDirectorydir.toFile() );
    }
    @Test
    public void checkDeleteNonEmptyDir() throws IOException {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final String userSourcePath = System.getProperty"user.dir" ) + "/temp";
        final Path dir = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), userSourcePathfalse );
        FileUtils.deleteDirectorydir.toFile() );
        fsProvider.createDirectorydir );
        File.createTempFile"foo""bar"dir.toFile() );
        File.createTempFile"bar""foo"dir.toFile() );
        File.createTempFile"bar""foo"dir.toFile() );
        fsProvider.createDirectorydir.resolve( "other_dir" ) );
        final DirectoryStream<Path> stream5 = fsProvider.newDirectoryStream( dirnew DirectoryStream.Filter<Path>() {
            @Override
            public boolean accept( final Path entry ) throws org.uberfire.java.nio.IOException {
                return true;
            }
        } );
        assertThatstream5 ).hasSize( 4 ).contains( dir.resolve( "other_dir" ) );
        try {
            fsProvider.deletedir );
            fail"must throw error" );
        } catch ( final DirectoryNotEmptyException expection ) {
        }
        fsProvider.deletedir, NON_EMPTY_DIRECTORIES );
        assertThatdir.toFile().exists() ).isEqualTo( false );
    }
    @Test(expected = NotDirectoryException.class)
    public void newDirectoryStreamInvalidDir() throws IOException {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final String userSourcePath = System.getProperty"user.dir" ) + "/xxxxxx";
        final Path dir = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), userSourcePathfalse );
        fsProvider.newDirectoryStream( dirnew DirectoryStream.Filter<Path>() {
            @Override
            public boolean accept( Path entry ) throws org.uberfire.java.nio.IOException {
                return true;
            }
        } );
    }
    @Test(expected = IllegalArgumentException.class)
    public void newDirectoryStreamNull1() throws IOException {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        fsProvider.newDirectoryStream( nullnew DirectoryStream.Filter<Path>() {
            @Override
            public boolean accept( Path entry ) throws org.uberfire.java.nio.IOException {
                return true;
            }
        } );
    }
    @Test(expected = IllegalArgumentException.class)
    public void newDirectoryStreamNull2() throws IOException {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final String userSourcePath = System.getProperty"user.dir" ) + "/xxxxxx";
        final Path dir = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), userSourcePathfalse );
        fsProvider.newDirectoryStream( dirnull );
    }
    @Test(expected = IllegalArgumentException.class)
    public void newDirectoryStreamNull3() throws IOException {
        final SimpleFileSystemProvider fsProvider = new SimpleFileSystemProvider();
        final String userSourcePath = System.getProperty"user.dir" ) + "/xxxxxx";
        final Path dir = GeneralPathImpl.create( fsProvider.getFileSystem( URI.create"file:///" ) ), userSourcePathfalse );
        fsProvider.newDirectoryStreamnullnull );
    }