package org.apache.maven.shared.utils.io;
   
   import static org.hamcrest.CoreMatchers.containsString;
   import static org.hamcrest.CoreMatchers.hasItems;
   import static org.hamcrest.CoreMatchers.is;
   import static org.hamcrest.CoreMatchers.not;
   import static org.hamcrest.MatcherAssert.assertThat;
   import static org.junit.Assert.assertEquals;
   import static org.junit.Assert.assertFalse;
  import static org.junit.Assert.assertTrue;
  import static org.junit.Assert.fail;
  import static org.junit.Assume.assumeFalse;
  import static org.junit.Assume.assumeThat;
  
  import org.apache.commons.io.IOUtils;
  import org.apache.maven.shared.utils.Os;
  import org.apache.maven.shared.utils.testhelpers.FileTestHelper;
  import org.codehaus.plexus.util.InterpolationFilterReader;
  import org.hamcrest.CoreMatchers;
  import org.junit.Before;
  import org.junit.Ignore;
  import org.junit.Rule;
  import org.junit.Test;
  import org.junit.rules.TemporaryFolder;
  import org.junit.rules.TestName;
  
  import javax.annotation.Nonnull;
  import java.io.BufferedOutputStream;
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileNotFoundException;
  import java.io.FileOutputStream;
  import java.io.FileReader;
  import java.io.FileWriter;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.io.Reader;
  import java.io.Writer;
  import java.net.URL;
  import java.nio.file.Files;
  import java.util.Arrays;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Map;
  import java.util.concurrent.TimeUnit;
  
  /*
   * Licensed to the Apache Software Foundation (ASF) under one
   * or more contributor license agreements.  See the NOTICE file
   * distributed with this work for additional information
   * regarding copyright ownership.  The ASF licenses this file
   * to you 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.
   */
  
  /**
   * This is used to test FileUtils for correctness.
   *
   * @author Peter Donald
   * @author Matthew Hawthorne
   * @author Stephen Colebourne
   * @author Jim Harrington
   * @version $Id: FileUtilsTestCase.java 1081025 2011-03-13 00:45:10Z niallp $
   * @see FileUtils
   */
  @SuppressWarnings( "deprecation" )
  public class FileUtilsTest
  {
  
      // Test data
  
      @Rule
      public TemporaryFolder tempFolder = new TemporaryFolder();
  
      @Rule
      public TestName name = new TestName();
  
      /**
       * Size of test directory.
       */
      private static final int TEST_DIRECTORY_SIZE = 0;
  
      private File testFile1;
  
      private File testFile2;
  
      private long testFile1Size;
 
     private long testFile2Size;
 
     /**
      * @see junit.framework.TestCase#setUp()
      */
     @Before
     public void setUp()
         throws Exception
     {
         testFile1 = tempFolder.newFile( "file1-test.txt" );
         testFile2 = tempFolder.newFile( "file1a-test.txt" );
 
         testFile1Size = (int) testFile1.length();
         testFile2Size = (int) testFile2.length();
 
         tempFolder.getRoot().mkdirs();
         createFile( testFile1, testFile1Size );
         createFile( testFile2, testFile2Size );
         FileUtils.deleteDirectory( tempFolder.getRoot() );
         tempFolder.getRoot().mkdirs();
         createFile( testFile1, testFile1Size );
         createFile( testFile2, testFile2Size );
     }
 
     private static void createFile( File file, long size )
         throws IOException
     {
         if ( !file.getParentFile().exists() )
         {
             throw new IOException( "Cannot create file " + file + " as the parent directory does not exist" );
         }
         
         try (OutputStream out = new BufferedOutputStream( new FileOutputStream( file ) ) )
         {
             FileTestHelper.generateTestData( out, size );
         }
     }
 
 
     /**
      * Assert that the content of a file is equal to that in a byte[].
      */
     private void assertEqualContent( byte[] b0, File file )
         throws IOException
     {
         int count = 0, numRead = 0;
         byte[] b1 = new byte[b0.length];
         try ( InputStream is = new FileInputStream( file ) )
         {
             while ( count < b0.length && numRead >= 0 )
             {
                 numRead = is.read( b1, count, b0.length );
                 count += numRead;
             }
             assertThat( "Different number of bytes: ", count, is( b0.length ) );
             for ( int i = 0; i < count; i++ )
             {
                 assertEquals( "byte " + i + " differs", b1[i], b0[i] );
             }
         }
     }
 
     private void deleteFile( File file )
     {
         if ( file.exists() )
         {
             assertTrue( "Couldn't delete file: " + file, file.delete() );
         }
     }
 
 
     //-----------------------------------------------------------------------
     @Test
     public void toFile1()
         throws Exception
     {
         URL url = new URL( "file", null, "a/b/c/file.txt" );
         File file = FileUtils.toFile( url );
         assertThat( file.toString(), containsString( "file.txt" ) );
     }
 
     @Test
     public void toFile2()
         throws Exception
     {
         URL url = new URL( "file", null, "a/b/c/file%20n%61me%2520.tx%74" );
         File file = FileUtils.toFile( url );
         assertThat( file.toString(), containsString( "file name%20.txt" ) );
     }
 
     @Test
     public void toFile3()
         throws Exception
     {
         assertThat( FileUtils.toFile( null ), CoreMatchers.nullValue() );
         assertThat( FileUtils.toFile( new URL( "http://jakarta.apache.org" ) ), CoreMatchers.nullValue() );
     }
 
     @Test( expected = NumberFormatException.class )
     public void toFile4()
         throws Exception
     {
         URL url = new URL( "file", null, "a/b/c/file%%20%me.txt%" );
         File file = FileUtils.toFile( url );
         assertThat( file.toString(), containsString( "file% %me.txt%" ) );
     }
 
     /**
      * IO-252
      */
     @Test
     public void toFile5()
         throws Exception
     {
         URL url = new URL( "file", null, "both%20are%20100%20%25%20true" );
         File file = FileUtils.toFile( url );
         assertThat( file.toString(), is( "both are 100 % true" ) );
     }
 
     @Test
     public void toFileUtf8()
         throws Exception
     {
         URL url = new URL( "file", null, "/home/%C3%A4%C3%B6%C3%BC%C3%9F" );
         File file = FileUtils.toFile( url );
         assertThat( file.toString(), not( containsString( "\u00E4\u00F6\u00FC\u00DF" ) ) );
     }
 
     // toURLs
 
     @Test
     public void toURLs1()
         throws Exception
     {
         File[] files = new File[]{ new File( tempFolder.getRoot(), "file1.txt" ), new File( tempFolder.getRoot(), "file2.txt" ),
             new File( tempFolder.getRoot(), "test file.txt" ), };
         URL[] urls = FileUtils.toURLs( files );
 
         assertThat( urls.length, is( files.length ) );
         assertThat( urls[0].toExternalForm().startsWith( "file:" ), is( true ) );
         assertThat( urls[0].toExternalForm().contains( "file1.txt" ), is( true ) );
         assertThat( urls[1].toExternalForm().startsWith( "file:" ), is( true ) );
         assertThat( urls[1].toExternalForm(), containsString( "file2.txt" ) );
 
         // Test escaped char
         assertThat( urls[2].toExternalForm().startsWith( "file:" ), is( true ) );
         assertThat( urls[2].toExternalForm(), containsString( "test%20file.txt" ) );
     }
 
     // contentEquals
 
     @Test
     public void contentEquals()
         throws Exception
     {
         // Non-existent files
         File file = new File( tempFolder.getRoot(), name.getMethodName() );
         File file2 = new File( tempFolder.getRoot(), name.getMethodName() + "2" );
         // both don't  exist
         assertThat( FileUtils.contentEquals( file, file ), is( true ) );
         assertThat( FileUtils.contentEquals( file, file2 ), is( true ) );
         assertThat( FileUtils.contentEquals( file2, file2 ), is( true ) );
         assertThat( FileUtils.contentEquals( file2, file ), is( true ) );
 
         // Directories
         FileUtils.contentEquals( tempFolder.getRoot(), tempFolder.getRoot() );
 
         // Different files
         File objFile1 = new File( tempFolder.getRoot(), name.getMethodName() + ".object" );
         objFile1.deleteOnExit();
         FileUtils.copyURLToFile( getClass().getResource( "/java/lang/Object.class" ), objFile1 );
 
         File objFile1b = new File( tempFolder.getRoot(), name.getMethodName() + ".object2" );
         objFile1.deleteOnExit();
         FileUtils.copyURLToFile( getClass().getResource( "/java/lang/Object.class" ), objFile1b );
 
         File objFile2 = new File( tempFolder.getRoot(), name.getMethodName() + ".collection" );
         objFile2.deleteOnExit();
         FileUtils.copyURLToFile( getClass().getResource( "/java/util/Collection.class" ), objFile2 );
 
         assertThat( FileUtils.contentEquals( objFile1, objFile2 ), is( false ) );
         assertThat( FileUtils.contentEquals( objFile1b, objFile2 ), is( false ) );
         assertThat( FileUtils.contentEquals( objFile1, objFile1b ), is( true ) );
 
         assertThat( FileUtils.contentEquals( objFile1, objFile1 ), is( true ) );
         assertThat( FileUtils.contentEquals( objFile1b, objFile1b ), is( true ) );
         assertThat( FileUtils.contentEquals( objFile2, objFile2 ), is( true ) );
 
         // Equal files
         file.createNewFile();
         file2.createNewFile();
         assertThat( FileUtils.contentEquals( file, file ), is( true ) );
         assertThat( FileUtils.contentEquals( file, file2 ), is( true ) );
     }
 
     // copyURLToFile
 
     @Test
     public void copyURLToFile()
         throws Exception
     {
         // Creates file
         File file = new File( tempFolder.getRoot(), name.getMethodName() );
         file.deleteOnExit();
 
         // Loads resource
         String resourceName = "/java/lang/Object.class";
         FileUtils.copyURLToFile( getClass().getResource( resourceName ), file );
 
         // Tests that resource was copied correctly
         try ( FileInputStream fis = new FileInputStream( file ) )
         {
             assertThat( "Content is not equal.",
                         IOUtil.contentEquals( getClass().getResourceAsStream( resourceName ), fis ), is( true ) );
         }
         //TODO Maybe test copy to itself like for copyFile()
     }
 
     // forceMkdir
 
     @Test
     public void forceMkdir()
         throws Exception
     {
         // Tests with existing directory
         FileUtils.forceMkdir( tempFolder.getRoot() );
 
         // Creates test file
         File testFile = new File( tempFolder.getRoot(), name.getMethodName() );
         testFile.deleteOnExit();
         testFile.createNewFile();
         assertThat( "Test file does not exist.", testFile.exists(), is( true ) );
 
         // Tests with existing file
         try
         {
             FileUtils.forceMkdir( testFile );
             fail( "Exception expected." );
         }
         catch ( IOException ex )
         {
         }
 
         testFile.delete();
 
         // Tests with non-existent directory
         FileUtils.forceMkdir( testFile );
         assertThat( "Directory was not created.", testFile.exists(), is( true ) );
     }
 
     // sizeOfDirectory
 
     @Test
     public void sizeOfDirectory()
         throws Exception
     {
         File file = new File( tempFolder.getRoot(), name.getMethodName() );
 
         // Non-existent file
         try
         {
             FileUtils.sizeOfDirectory( file );
             fail( "Exception expected." );
         }
         catch ( IllegalArgumentException ex )
         {
         }
 
         // Creates file
         file.createNewFile();
         file.deleteOnExit();
 
         // Existing file
         try
         {
             FileUtils.sizeOfDirectory( file );
             fail( "Exception expected." );
         }
         catch ( IllegalArgumentException ex )
         {
         }
 
         // Existing directory
         file.delete();
         file.mkdir();
 
         assertThat( "Unexpected directory size", FileUtils.sizeOfDirectory( file ), is( (long) TEST_DIRECTORY_SIZE ) );
     }
 
     // copyFile
 
     @Test
     public void copyFile1()
         throws Exception
     {
         File destination = new File( tempFolder.getRoot(), "copy1.txt" );
 
         //Thread.sleep(LAST_MODIFIED_DELAY);
         //This is to slow things down so we can catch if
         //the lastModified date is not ok
 
         FileUtils.copyFile( testFile1, destination );
         assertThat( "Check Exist", destination.exists(), is( true ) );
         assertThat( "Check Full copy", destination.length(), is( testFile1Size ) );
         /* disabled: Thread.sleep doesn't work reliantly for this case
         assertTrue("Check last modified date preserved",
             testFile1.lastModified() == destination.lastModified());*/
     }
 
     /** A time today, rounded down to the previous minute */
     private static long MODIFIED_TODAY = (System.currentTimeMillis() / TimeUnit.MINUTES.toMillis( 1 )) * TimeUnit.MINUTES.toMillis( 1 );
 
     /** A time yesterday, rounded down to the previous minute */
     private static long MODIFIED_YESTERDAY = MODIFIED_TODAY - TimeUnit.DAYS.toMillis( 1 );
 
     /** A time last week, rounded down to the previous minute */
     private static long MODIFIED_LAST_WEEK = MODIFIED_TODAY - TimeUnit.DAYS.toMillis( 7 );
 
     @Test
     public void copyFileWithNoFiltersAndNoDestination()
         throws Exception
     {
         File from = write(
             "from.txt",
             MODIFIED_YESTERDAY,
             "Hello World!"
         );
         File to = new File(
             tempFolder.getRoot(),
             "to.txt"
         );
 
         FileUtils.copyFile( from, to, null, ( FileUtils.FilterWrapper[] ) null);
 
         assertTrue(
             "to.txt did not exist so should have been written",
             to.lastModified() >= MODIFIED_TODAY
         );
         assertFileContent( to, "Hello World!" );
     }
 
     @Test
     public void copyFileWithNoFiltersAndOutdatedDestination()
             throws Exception
     {
         File from = write(
             "from.txt",
             MODIFIED_YESTERDAY,
             "Hello World!"
         );
         File to = write(
             "to.txt",
             MODIFIED_LAST_WEEK,
             "Older content"
         );
 
         FileUtils.copyFile( from, to, null, ( FileUtils.FilterWrapper[] ) null);
 
         assertTrue(
             "to.txt was outdated so should have been overwritten",
             to.lastModified() >= MODIFIED_TODAY
         );
         assertFileContent( to, "Hello World!" );
     }
 
     @Test
     public void copyFileWithNoFiltersAndNewerDestination()
             throws Exception
     {
         File from = write(
             "from.txt",
             MODIFIED_LAST_WEEK,
             "Hello World!"
         );
         File to = write(
             "to.txt",
             MODIFIED_YESTERDAY,
             "Older content"
         );
 
         FileUtils.copyFile( from, to, null, ( FileUtils.FilterWrapper[] ) null);
 
         assertTrue(
             "to.txt was newer so should have been left alone",
             to.lastModified() < MODIFIED_TODAY
         );
         assertFileContent( to, "Older content" );
     }
 
     @Test
     public void copyFileWithNoFiltersAndNewerDestinationButForcedOverwrite()
             throws Exception
     {
         File from = write(
             "from.txt",
             MODIFIED_LAST_WEEK,
             "Hello World!"
         );
         File to = write(
             "to.txt",
             MODIFIED_YESTERDAY,
             "Older content"
         );
 
         FileUtils.copyFile( from, to, null, null, true);
 
         assertTrue(
             "to.txt was newer but the overwrite should have been forced",
             to.lastModified() >= MODIFIED_TODAY
         );
         assertFileContent( to, "Hello World!" );
     }
 
     @Test
     public void copyFileWithFilteringButNoFilters()
             throws Exception
     {
         File from = write(
             "from.txt",
             MODIFIED_YESTERDAY,
             "Hello ${name}!"
         );
         File to = write(
             "to.txt",
             MODIFIED_LAST_WEEK,
             "Older content"
         );
 
         FileUtils.copyFile( from, to, null );
 
         assertTrue(
             "to.txt was outdated so should have been overwritten",
             to.lastModified() >= MODIFIED_TODAY
         );
         assertFileContent( to, "Hello ${name}!" );
     }
 
     @Test
     public void copyFileWithFilteringAndNoDestination()
             throws Exception
     {
         File from = write(
             "from.txt",
             MODIFIED_YESTERDAY,
             "Hello ${name}!"
         );
         File to = new File(
             tempFolder.getRoot(),
             "to.txt"
         );
 
         FileUtils.copyFile( from, to, null, wrappers( "name", "Bob" ) );
 
         assertTrue(
             "to.txt did not exist so should have been written",
             to.lastModified() >= MODIFIED_TODAY
         );
         assertFileContent( to, "Hello Bob!" );
     }
 
     @Test
     public void copyFileWithFilteringAndOutdatedDestination()
             throws Exception
     {
         File from = write(
             "from.txt",
             MODIFIED_YESTERDAY,
             "Hello ${name}!"
         );
         File to = write(
             "to.txt",
             MODIFIED_LAST_WEEK,
             "Older content"
         );
 
         FileUtils.copyFile( from, to, null, wrappers( "name", "Bob" ) );
 
         assertTrue(
             "to.txt was outdated so should have been overwritten",
             to.lastModified() >= MODIFIED_TODAY
         );
         assertFileContent( to, "Hello Bob!" );
     }
 
     @Test
     public void copyFileWithFilteringAndNewerDestinationButForcedOverwrite()
             throws Exception
     {
         File from = write(
             "from.txt",
             MODIFIED_LAST_WEEK,
             "Hello ${name}!"
         );
         File to = write(
             "to.txt",
             MODIFIED_YESTERDAY,
             "Older content"
         );
 
         FileUtils.copyFile( from, to, null, wrappers( "name", "Bob" ), true );
 
         assertTrue(
             "to.txt was newer but the overwrite should have been forced",
             to.lastModified() >= MODIFIED_TODAY
         );
         assertFileContent( to, "Hello Bob!" );
     }
 
     @Test
     public void copyFileWithFilteringAndNewerDestinationButModifiedContent()
             throws Exception
     {
         File from = write(
             "from.txt",
             MODIFIED_LAST_WEEK,
             "Hello ${name}!"
         );
         File to = write(
             "to.txt",
             MODIFIED_YESTERDAY,
             "Hello Charlie!"
         );
 
         FileUtils.copyFile( from, to, null, wrappers( "name", "Bob" ) );
 
         assertTrue(
             "to.txt was outdated so should have been overwritten",
             to.lastModified() >= MODIFIED_TODAY
         );
         assertFileContent( to, "Hello Bob!" );
     }
 
     @Test
     public void copyFileWithFilteringAndNewerDestinationAndMatchingContent()
             throws Exception
     {
         File from = write(
             "from.txt",
             MODIFIED_LAST_WEEK,
             "Hello ${name}!"
         );
         File to = write(
             "to.txt",
             MODIFIED_YESTERDAY,
             "Hello Bob!"
         );
 
         FileUtils.copyFile( from, to, null, wrappers( "name", "Bob" ) );
 
         assertFileContent( to, "Hello Bob!" );
         assertTrue(
             "to.txt content should be unchanged and have been left alone",
             to.lastModified() < MODIFIED_TODAY
         );
     }
 
     private static FileUtils.FilterWrapper[] wrappers( String key, String value )
     {
         final Map<String, Object> map = new HashMap<>();
         map.put( key, value );
         return new FileUtils.FilterWrapper[]
             {
                 new FileUtils.FilterWrapper()
                 {
                     @Override
                     public Reader getReader( Reader reader )
                     {
                         return new InterpolationFilterReader( reader, map );
                     }
                 }
             };
     }
 
     private File write( @Nonnull String name, long lastModified, @Nonnull String text) throws IOException
     {
         final File file = new File( tempFolder.getRoot(), name );
         try ( final Writer writer = new FileWriter( file ) ) {
             writer.write(text);
         }
         assertTrue( file.setLastModified( lastModified ) );
         assertEquals( "Failed to set lastModified date on " + file.getPath(), lastModified, file.lastModified() );
         return file;
     }
 
     private static void assertFileContent( @Nonnull File file, @Nonnull String expected ) throws IOException
     {
         try ( Reader in = new FileReader( file ))
         {
             assertEquals(
                 "Expected " + file.getPath() + " to contain: " + expected,
                 expected,
                 IOUtils.toString( in )
             );
         }
     }
 
     @Test
     public void copyFileThatIsSymlink()
             throws Exception
     {
         assumeFalse( Os.isFamily( Os.FAMILY_WINDOWS ) );
 
         File destination = new File( tempFolder.getRoot(), "symCopy.txt" );
 
         File testDir = SymlinkTestSetup.createStandardSymlinkTestDir( new File( "target/test/symlinkCopy" ) );
 
         FileUtils.copyFile( new File( testDir, "symR" ), destination );
 
         assertTrue( Files.isSymbolicLink( destination.toPath() ) );
     }
 
 
     @Test
     public void deleteFile()
         throws Exception
     {
         File destination = new File( tempFolder.getRoot(), "copy1.txt" );
         FileUtils.copyFile( testFile1, destination );
         FileUtils.delete( destination );
         assertThat( "Check Exist", destination.exists(), is( false ) );
     }
 
     @Test(expected = IOException.class)
     public void deleteFileNofile()
         throws Exception
     {
         File destination = new File( "abc/cde" );
         FileUtils.delete( destination );
     }
 
     @Test
     public void deleteFileLegacy()
         throws Exception
     {
         File destination = new File( tempFolder.getRoot(), "copy1.txt" );
         FileUtils.copyFile( testFile1, destination );
         assertTrue( FileUtils.deleteLegacyStyle( destination ) );
     }
 
     @Test
     public void deleteFileLegacyNofile()
         throws Exception
     {
         File destination = new File( "abc/cde" );
         assertFalse( FileUtils.deleteLegacyStyle( destination ) );
     }
 
     @Test
     public void copyFileWithPermissions()
         throws Exception
     {
         File source = new File( "src/test/resources/executable" );
         source.setExecutable( true );
         assumeThat( "Need an existing file to copy", source.exists(), is( true ) );
         assumeThat( "Need an executable file to copy", source.canExecute(), is( true ) );
 
         File destination = new File( tempFolder.getRoot(), "executable-copy" );
 
         FileUtils.copyFile( source, destination );
 
         assertThat( "destination not exists: " + destination.getAbsolutePath()
                         + ", directory content: " + Arrays.asList( destination.getParentFile().list() ),
                     Files.exists( destination.toPath() ), is( true ) );
 
         assertThat( "Check copy executable", destination.canExecute(), is( true ) );
     }
 
     @Test
     public void copyFile2()
         throws Exception
     {
         File destination = new File( tempFolder.getRoot(), "copy2.txt" );
 
         //Thread.sleep(LAST_MODIFIED_DELAY);
         //This is to slow things down so we can catch if
         //the lastModified date is not ok
 
         FileUtils.copyFile( testFile1, destination );
         assertThat( "Check Exist", destination.exists(), is( true ) );
         assertThat( "Check Full copy", destination.length(), is( testFile2Size ) );
         /* disabled: Thread.sleep doesn't work reliably for this case
         assertTrue("Check last modified date preserved",
             testFile1.lastModified() == destination.lastModified());*/
     }
 
     @Test
     public void copyToSelf() throws IOException
     {
         File destination = new File( tempFolder.getRoot(), "copy3.txt" );
         //Prepare a test file
         FileUtils.copyFile( testFile1, destination );
 
         FileUtils.copyFile( destination, destination );
     }
 
     @Test
     public void copyDirectoryToNonExistingDest()
         throws Exception
     {
         createFile( testFile1, 1234 );
         createFile( testFile2, 4321 );
         File srcDir = tempFolder.getRoot();
         File subDir = new File( srcDir, "sub" );
         subDir.mkdir();
         File subFile = new File( subDir, "A.txt" );
         FileUtils.fileWrite( subFile, "UTF8", "HELLO WORLD" );
         File destDir = new File( System.getProperty( "java.io.tmpdir" ), "tmp-FileUtilsTestCase" );
         FileUtils.deleteDirectory( destDir );
 
         FileUtils.copyDirectory( srcDir, destDir );
 
         assertTrue( destDir.exists() );
         assertEquals( FileUtils.sizeOfDirectory( destDir ), FileUtils.sizeOfDirectory( srcDir ) );
         assertTrue( new File( destDir, "sub/A.txt" ).exists() );
         FileUtils.deleteDirectory( destDir );
     }
 
     @Test
     public void copyDirectoryToExistingDest() throws IOException
     {
         createFile( testFile1, 1234 );
         createFile( testFile2, 4321 );
         File srcDir = tempFolder.getRoot();
         File subDir = new File( srcDir, "sub" );
         assertTrue( subDir.mkdir() );
         File subFile = new File( subDir, "A.txt" );
         FileUtils.fileWrite( subFile, "UTF8", "HELLO WORLD" );
         File destDir = new File( System.getProperty( "java.io.tmpdir" ), "tmp-FileUtilsTestCase" );
         FileUtils.deleteDirectory( destDir );
         assertTrue ( destDir.mkdirs() );
 
         FileUtils.copyDirectory( srcDir, destDir );
 
         assertEquals( FileUtils.sizeOfDirectory( destDir ), FileUtils.sizeOfDirectory( srcDir ) );
         assertTrue( new File( destDir, "sub/A.txt" ).exists() );
     }
 
     @Test
     public void copyDirectoryErrors_nullDestination() throws IOException {
         try
         {
             FileUtils.copyDirectory( new File( "a" ), null );
             fail();
         }
         catch ( NullPointerException ex )
         {
         }
     }
 
     @Test
     public void copyDirectoryErrors_copyToSelf() {
         try
         {
             FileUtils.copyDirectory( tempFolder.getRoot(), tempFolder.getRoot() );
             fail();
         }
         catch ( IOException ex )
         {
         }
     }
 
     @Test
     public void copyDirectoryErrors()
         throws IOException
     {
         try
         {
             FileUtils.copyDirectory( null, null );
             fail();
         }
         catch ( NullPointerException ex )
         {
         }
         try
         {
             FileUtils.copyDirectory( null, new File( "a" ) );
             fail();
         }
         catch ( NullPointerException ex )
         {
         }
         try
         {
             FileUtils.copyDirectory( tempFolder.getRoot(), testFile1 );
             fail();
         }
         catch ( IOException ex )
         {
         }
     }
 
     // forceDelete
 
     @Test
     public void forceDeleteAFile1()
         throws Exception
     {
         File destination = new File( tempFolder.getRoot(), "copy1.txt" );
         destination.createNewFile();
         assertTrue( "Copy1.txt doesn't exist to delete", destination.exists() );
         FileUtils.forceDelete( destination );
         assertFalse( destination.exists() );
     }
 
     @Test
     public void forceDeleteAFile2()
         throws Exception
     {
         File destination = new File( tempFolder.getRoot(), "copy2.txt" );
         destination.createNewFile();
         assertThat( "Copy2.txt doesn't exist to delete", destination.exists(), is( true ) );
         FileUtils.forceDelete( destination );
         assertThat( "Check No Exist", !destination.exists(), is( true ) );
     }
 
     @Test
     @Ignore( "Commons test case that is failing for plexus" )
     public void forceDeleteAFile3()
         throws Exception
     {
         File destination = new File( tempFolder.getRoot(), "no_such_file" );
         assertThat( "Check No Exist", !destination.exists(), is( true ) );
         try
         {
             FileUtils.forceDelete( destination );
             fail( "Should generate FileNotFoundException" );
         }
         catch ( FileNotFoundException ignored )
         {
         }
     }
 
     // copyFileToDirectory
 
     @Test
     @Ignore( "Commons test case that is failing for plexus" )
     public void copyFile1ToDir()
         throws Exception
     {
         File directory = new File( tempFolder.getRoot(), "subdir" );
         if ( !directory.exists() )
         {
             directory.mkdirs();
         }
         File destination = new File( directory, testFile1.getName() );
 
         //Thread.sleep(LAST_MODIFIED_DELAY);
         //This is to slow things down so we can catch if
         //the lastModified date is not ok
 
         FileUtils.copyFileToDirectory( testFile1, directory );
         assertThat( "Check Exist", destination.exists(), is( true ) );
         assertThat( "Check Full copy", destination.length(), is( testFile1Size ) );
         /* disabled: Thread.sleep doesn't work reliantly for this case
         assertTrue("Check last modified date preserved",
             testFile1.lastModified() == destination.lastModified());*/
 
         try
         {
             FileUtils.copyFileToDirectory( destination, directory );
             fail( "Should not be able to copy a file into the same directory as itself" );
         }
         catch ( IOException ioe )
         {
             //we want that, cannot copy to the same directory as the original file
         }
     }
 
     @Test
     public void copyFile2ToDir()
         throws Exception
     {
         File directory = new File( tempFolder.getRoot(), "subdir" );
         if ( !directory.exists() )
         {
             directory.mkdirs();
         }
         File destination = new File( directory, testFile1.getName() );
 
         //Thread.sleep(LAST_MODIFIED_DELAY);
         //This is to slow things down so we can catch if
         //the lastModified date is not ok
 
         FileUtils.copyFileToDirectory( testFile1, directory );
         assertThat( "Check Exist", destination.exists(), is( true ) );
         assertThat( "Check Full copy", destination.length(), is( testFile2Size ) );
         /* disabled: Thread.sleep doesn't work reliantly for this case
         assertTrue("Check last modified date preserved",
             testFile1.lastModified() == destination.lastModified());*/
     }
 
     // forceDelete
 
     @Test
     public void forceDeleteDir()
         throws Exception
     {
         File testDirectory = tempFolder.newFolder( name.getMethodName() );
         FileUtils.forceDelete( testDirectory.getParentFile() );
         assertThat( "Check No Exist", !testDirectory.getParentFile().exists(), is( true ) );
     }
 
     /**
      * Test the FileUtils implementation.
      */
     @Test
     public void fileUtils()
         throws Exception
     {
         // Loads file from classpath
         File file1 = new File( tempFolder.getRoot(), "test.txt" );
         String filename = file1.getAbsolutePath();
 
         //Create test file on-the-fly (used to be in CVS)
         try ( OutputStream out = new java.io.FileOutputStream( file1 ) )
         {
             out.write( "This is a test".getBytes( "UTF-8" ) );
         }
 
         File file2 = new File( tempFolder.getRoot(), "test2.txt" );
 
         FileUtils.fileWrite( file2, "UTF-8", filename );
         assertThat( file2.exists(), is( true ) );
         assertThat( file2.length() > 0, is( true ) );
 
         String file2contents = FileUtils.fileRead( file2, "UTF-8" );
         assertThat( "Second file's contents correct", filename.equals( file2contents ), is( true ) );
 
         assertThat( file2.delete(), is( true ) );
 
         String contents = FileUtils.fileRead( new File( filename ), "UTF-8" );
         assertThat( "FileUtils.fileRead()", contents.equals( "This is a test" ), is( true ) );
 
     }
 
     @Test
     public void fileReadWithDefaultEncoding()
         throws Exception
     {
         File file = new File( tempFolder.getRoot(), "read.obj" );
         FileOutputStream out = new FileOutputStream( file );
         byte[] text = "Hello /u1234".getBytes();
         out.write( text );
         out.close();
 
         String data = FileUtils.fileRead( file );
         assertThat( data, is( "Hello /u1234" ) );
     }
 
     @Test
     public void fileReadWithEncoding()
         throws Exception
     {
         File file = new File( tempFolder.getRoot(), "read.obj" );
         FileOutputStream out = new FileOutputStream( file );
         byte[] text = "Hello /u1234".getBytes( "UTF8" );
         out.write( text );
         out.close();
 
         String data = FileUtils.fileRead( file, "UTF8" );
         assertThat( data, is( "Hello /u1234" ) );
     }
 
     @Test
     @Ignore( "Commons test case that is failing for plexus" )
     public void readLines()
         throws Exception
     {
         File file = FileTestHelper.newFile( tempFolder, "lines.txt" );
         try
         {
             String[] data = new String[]{ "hello", "/u1234", "", "this is", "some text" };
             FileTestHelper.createLineBasedFile( file, data );
 
             List<String> lines = FileUtils.loadFile( file );
             assertThat( lines, is( Arrays.asList( data ) ) );
         }
         finally
         {
             deleteFile( file );
         }
     }
 
     @Test
     public void writeStringToFile1()
         throws Exception
     {
         File file = new File( tempFolder.getRoot(), "write.txt" );
         FileUtils.fileWrite( file, "UTF8", "Hello /u1234" );
         byte[] text = "Hello /u1234".getBytes( "UTF8" );
         assertEqualContent( text, file );
     }
 
     @Test
     public void writeStringToFile2()
         throws Exception
     {
         File file = new File( tempFolder.getRoot(), "write.txt" );
         FileUtils.fileWrite( file, null, "Hello /u1234" );
         byte[] text = "Hello /u1234".getBytes();
         assertEqualContent( text, file );
     }
 
     @Test
     public void writeCharSequence1()
         throws Exception
     {
         File file = new File( tempFolder.getRoot(), "write.txt" );
         FileUtils.fileWrite( file, "UTF8", "Hello /u1234" );
         byte[] text = "Hello /u1234".getBytes( "UTF8" );
         assertEqualContent( text, file );
     }
 
     @Test
     public void writeCharSequence2()
         throws Exception
     {
         File file = new File( tempFolder.getRoot(), "write.txt" );
         FileUtils.fileWrite( file, null, "Hello /u1234" );
         byte[] text = "Hello /u1234".getBytes();
         assertEqualContent( text, file );
     }
 
 
     @Test
     public void writeStringToFileWithEncoding_WithAppendOptionTrue_ShouldNotDeletePreviousFileLines()
         throws Exception
     {
         File file = FileTestHelper.newFile( tempFolder, "lines.txt" );
         FileUtils.fileWrite( file, null, "This line was there before you..." );
 
         FileUtils.fileAppend( file.getAbsolutePath(), "this is brand new data" );
 
         String expected = "This line was there before you..." + "this is brand new data";
         String actual = FileUtils.fileRead( file );
         assertThat( actual, is( expected ) );
     }
 
     @Test
     public void writeStringToFile_WithAppendOptionTrue_ShouldNotDeletePreviousFileLines()
         throws Exception
     {
         File file = FileTestHelper.newFile( tempFolder, "lines.txt" );
         FileUtils.fileWrite( file, null, "This line was there before you..." );
 
         FileUtils.fileAppend( file.getAbsolutePath(), "this is brand new data" );
 
         String expected = "This line was there before you..." + "this is brand new data";
         String actual = FileUtils.fileRead( file );
         assertThat( actual, is( expected ) );
     }
 
     @Test
     public void writeStringArrayToFile()
             throws Exception
     {
         File file = new File( tempFolder.getRoot(), "writeArray.txt" );
         FileUtils.fileWriteArray( file, new String[]{"line1", "line2", "line3"} );
 
         byte[] text = "line1\nline2\nline3".getBytes( "UTF8" );
         assertEqualContent( text, file );
     }
 
     @Test
     public void writeStringArrayToFileWithEncoding()
             throws Exception
     {
         File file = new File( tempFolder.getRoot(), "writeArray.txt" );
         FileUtils.fileWriteArray( file, "UTF8", new String[]{"line1", "line2", "line3"} );
 
         byte[] text = "line1\nline2\nline3".getBytes( "UTF8" );
         assertEqualContent( text, file );
     }
 
 
     @Test
     public void writeWithEncoding_WithAppendOptionTrue_ShouldNotDeletePreviousFileLines()
         throws Exception
     {
         File file = FileTestHelper.newFile( tempFolder, "lines.txt" );
         FileUtils.fileWrite( file, "UTF-8", "This line was there before you..." );
 
         FileUtils.fileAppend( file.getAbsolutePath(), "UTF-8", "this is brand new data" );
 
         String expected = "This line was there before you..." + "this is brand new data";
         String actual = FileUtils.fileRead( file );
         assertThat( actual, is( expected ) );
     }
 
     @Test
     public void write_WithAppendOptionTrue_ShouldNotDeletePreviousFileLines()
         throws Exception
     {
         File file = FileTestHelper.newFile( tempFolder, "lines.txt" );
         FileUtils.fileWrite( file, null, "This line was there before you..." );
 
         FileUtils.fileAppend( file.getAbsolutePath(), "this is brand new data" );
 
         String expected = "This line was there before you..." + "this is brand new data";
         String actual = FileUtils.fileRead( file );
         assertThat( actual, is( expected ) );
     }
 
     @Test( expected = NullPointerException.class )
     public void blowUpOnNull()
         throws IOException
     {
         FileUtils.deleteDirectory( (File) null );
     }
 
     @Test
     public void deleteQuietlyDir()
         throws IOException
     {
         File testDirectory = new File( tempFolder.getRoot(), "testDeleteQuietlyDir" );
         File testFile = new File( testDirectory, "testDeleteQuietlyFile" );
         testDirectory.mkdirs();
         createFile( testFile, 0 );
 
         assertThat( testDirectory.exists(), is( true ) );
         assertThat( testFile.exists(), is( true ) );
         FileUtils.deleteDirectory( testDirectory );
         assertThat( "Check No Exist", testDirectory.exists(), is( false ) );
         assertThat( "Check No Exist", testFile.exists(), is( false ) );
     }
 
     @Test
     public void deleteQuietlyFile()
         throws IOException
     {
         File testFile = new File( tempFolder.getRoot(), "testDeleteQuietlyFile" );
         createFile( testFile, 0 );
 
         assertThat( testFile.exists(), is( true ) );
         FileUtils.deleteDirectory( testFile );
         assertThat( "Check No Exist", testFile.exists(), is( false ) );
     }
 
     @Test
     public void deleteQuietlyNonExistent()
         throws IOException
     {
         File testFile = new File( tempFolder.getRoot(), "testDeleteQuietlyNonExistent" );
         assertThat( testFile.exists(), is( false ) );
 
         FileUtils.deleteDirectory( testFile );
     }
 
 
     ////  getDefaultExcludes
 
     @Test
     public void getDefaultExcludes()
         throws Exception
     {
         assertThat( Arrays.asList( FileUtils.getDefaultExcludes() ), hasItems( MINIMUM_DEFAULT_EXCLUDES ) );
     }
 
 
     //// getDefaultExcludesAsList
 
     @Test
     public void getDefaultExcludesAsList()
         throws Exception
     {
         assertThat( FileUtils.getDefaultExcludesAsList(), hasItems( MINIMUM_DEFAULT_EXCLUDES ) );
     }
 
 
     //// getDefaultExcludesAsString
 
     @Test
     public void getDefaultExcludesAsString()
         throws Exception
     {
         assertThat( new HashSet<String>( Arrays.asList( FileUtils.getDefaultExcludesAsString().split( "," ) ) ),
                     hasItems( MINIMUM_DEFAULT_EXCLUDES ) );
     }
 
 
 
     //// dirname(String)
 
     @SuppressWarnings("ConstantConditions")
     @Test( expected = NullPointerException.class )
     public void nlowUpOnDirnameNull()
         throws Exception
     {
         FileUtils.dirname( null );
     }
 
     @Test
     public void dirnameEmpty()
         throws Exception
     {
         assertThat( FileUtils.dirname( "" ), is( "" ) );
     }
 
     @Test
     public void dirnameFilename()
         throws Exception
     {
         assertThat( FileUtils.dirname( "foo.bar.txt" ), is( "" ) );
     }
 
     @Test
     //X @ReproducesPlexusBug( "assumes that the path is a local path" )
     public void dirnameWindowsRootPathOnUnix()
         throws Exception
     {
         assumeThat( File.separatorChar, is( '/' ) );
         assertThat( FileUtils.dirname( "C:\\foo.bar.txt" ), is( "" ) );
     }
 
     @Test
     //X @ReproducesPlexusBug( "assumes that the path is a local path" )
     public void dirnameWindowsNonRootPathOnUnix()
         throws Exception
     {
         assumeThat( File.separatorChar, is( '/' ) );
         assertThat( FileUtils.dirname( "C:\\test\\foo.bar.txt" ), is( "" ) );
     }
 
     @Test
     //X @ReproducesPlexusBug( "assumes that the path is a local path" )
     public void dirnameUnixRootPathOnWindows()
         throws Exception
     {
         assumeThat( File.separatorChar, is( '\\' ) );
         assertThat( FileUtils.dirname( "/foo.bar.txt" ), is( "" ) );
     }
 
     @Test
     //X @ReproducesPlexusBug( "assumes that the path is a local path" )
     public void dirnameUnixNonRootPathOnWindows()
         throws Exception
     {
         assumeThat( File.separatorChar, is( '\\' ) );
         assertThat( FileUtils.dirname( "/test/foo.bar.txt" ), is( "" ) );
     }
 
     @Test
     public void dirnameWindowsRootPathOnWindows()
         throws Exception
     {
         assumeThat( File.separatorChar, is( '\\' ) );
         assertThat( FileUtils.dirname( "C:\\foo.bar.txt" ), is( "C:" ) );
     }
 
     @Test
     public void dirnameWindowsNonRootPathOnWindows()
         throws Exception
     {
         assumeThat( File.separatorChar, is( '\\' ) );
         assertThat( FileUtils.dirname( "C:\\test\\foo.bar.txt" ), is( "C:\\test" ) );
     }
 
     @Test
     public void dirnameUnixRootPathOnUnix()
         throws Exception
     {
         assumeThat( File.separatorChar, is( '/' ) );
         assertThat( FileUtils.dirname( "/foo.bar.txt" ), is( "" ) );
     }
 
     @Test
     public void dirnameUnixNonRootPathOnUnix()
         throws Exception
     {
         assumeThat( File.separatorChar, is( '/' ) );
         assertThat( FileUtils.dirname( "/test/foo.bar.txt" ), is( "/test" ) );
     }
 
     //// filename(String)
 
     @SuppressWarnings("ConstantConditions")
     @Test( expected = NullPointerException.class )
     public void blowUpOnFilenameNull()
         throws Exception
     {
         FileUtils.filename( null );
     }
 
     @Test
     public void filenameEmpty()
         throws Exception
     {
         assertThat( FileUtils.filename( "" ), is( "" ) );
     }
 
     @Test
     public void filenameFilename()
         throws Exception
     {
         assertThat( FileUtils.filename( "foo.bar.txt" ), is( "foo.bar.txt" ) );
     }
 
     @Test
     //X @ReproducesPlexusBug( "assumes that the path is a local path" )
     public void filenameWindowsRootPathOnUnix()
         throws Exception
     {
         assumeThat( File.separatorChar, is( '/' ) );
         assertThat( FileUtils.filename( "C:\\foo.bar.txt" ), is( "C:\\foo.bar.txt" ) );
     }
 
     @Test
     //X @ReproducesPlexusBug( "assumes that the path is a local path" )
     public void filenameWindowsNonRootPathOnUnix()
         throws Exception
     {
         assumeThat( File.separatorChar, is( '/' ) );
         assertThat( FileUtils.filename( "C:\\test\\foo.bar.txt" ), is( "C:\\test\\foo.bar.txt" ) );
     }
 
     @Test
     //X @ReproducesPlexusBug( "assumes that the path is a local path" )
     public void filenameUnixRootPathOnWindows()
         throws Exception
     {
         assumeThat( File.separatorChar, is( '\\' ) );
         assertThat( FileUtils.filename( "/foo.bar.txt" ), is( "/foo.bar.txt" ) );
     }
 
     @Test
     //X @ReproducesPlexusBug( "assumes that the path is a local path" )
     public void filenameUnixNonRootPathOnWindows()
         throws Exception
     {
         assumeThat( File.separatorChar, is( '\\' ) );
         assertThat( FileUtils.filename( "/test/foo.bar.txt" ), is( "/test/foo.bar.txt" ) );
     }
 
     @Test
     public void filenameWindowsRootPathOnWindows()
         throws Exception
     {
         assumeThat( File.separatorChar, is( '\\' ) );
         assertThat( FileUtils.filename( "C:\\foo.bar.txt" ), is( "foo.bar.txt" ) );
     }
 
     @Test
     public void filenameWindowsNonRootPathOnWindows()
         throws Exception
     {
         assumeThat( File.separatorChar, is( '\\' ) );
         assertThat( FileUtils.filename( "C:\\test\\foo.bar.txt" ), is( "foo.bar.txt" ) );
     }
 
     @Test
     public void filenameUnixRootPathOnUnix()
         throws Exception
     {
         assumeThat( File.separatorChar, is( '/' ) );
         assertThat( FileUtils.filename( "/foo.bar.txt" ), is( "foo.bar.txt" ) );
     }
 
     @Test
     public void filenameUnixNonRootPathOnUnix()
         throws Exception
     {
         assumeThat( File.separatorChar, is( '/' ) );
         assertThat( FileUtils.filename( "/test/foo.bar.txt" ), is( "foo.bar.txt" ) );
     }
 
     //// extension(String)
 
     @SuppressWarnings("ConstantConditions")
     @Test( expected = NullPointerException.class )
     public void blowUpOnNullExtension()
         throws Exception
     {
         FileUtils.extension( null );
     }
 
     @Test
     public void extensionEmpty()
         throws Exception
     {
         assertThat( FileUtils.extension( "" ), is( "" ) );
     }
 
     @Test
     public void extensionFileName()
         throws Exception
     {
         assertThat( FileUtils.extension( "foo.bar.txt" ), is( "txt" ) );
     }
 
     @Test
     public void extensionFileNameNoExtension()
         throws Exception
     {
         assertThat( FileUtils.extension( "foo_bar_txt" ), is( "" ) );
     }
 
     @Test
     //X @ReproducesPlexusBug( "assumes that the path is a local path" )
     public void extensionWindowsRootPathOnUnix()
         throws Exception
     {
         assumeThat( File.separatorChar, is( '/' ) );
         assertThat( FileUtils.extension( "C:\\foo.bar.txt" ), is( "txt" ) );
     }
 
     @Test
     //X @ReproducesPlexusBug( "assumes that the path is a local path" )
     public void extensionWindowsNonRootPathOnUnix()
         throws Exception
     {
         assumeThat( File.separatorChar, is( '/' ) );
         assertThat( FileUtils.extension( "C:\\test\\foo.bar.txt" ), is( "txt" ) );
     }
 
     @Test
     //X @ReproducesPlexusBug( "assumes that the path is a local path" )
     public void extensionUnixRootPathOnWindows()
         throws Exception
     {
         assumeThat( File.separatorChar, is( '\\' ) );
         assertThat( FileUtils.extension( "/foo.bar.txt" ), is( "txt" ) );
     }
 
     @Test
     //X @ReproducesPlexusBug( "assumes that the path is a local path" )
     public void extensionUnixNonRootPathOnWindows()
         throws Exception
     {
         assumeThat( File.separatorChar, is( '\\' ) );
         assertThat( FileUtils.extension( "/test/foo.bar.txt" ), is( "txt" ) );
     }
 
     @Test
     public void extensionWindowsRootPathOnWindows()
         throws Exception
     {
         assumeThat( File.separatorChar, is( '\\' ) );
         assertThat( FileUtils.extension( "C:\\foo.bar.txt" ), is( "txt" ) );
     }
 
     @Test
     public void extensionWindowsNonRootPathOnWindows()
         throws Exception
     {
         assumeThat( File.separatorChar, is( '\\' ) );
         assertThat( FileUtils.extension( "C:\\test\\foo.bar.txt" ), is( "txt" ) );
     }
 
     @Test
     @Ignore("Wait until we can run with assembly 2.5 which will support symlinks properly")
     public void isASymbolicLink()
         throws IOException
     {
         // This testcase will pass when running under java7 or higher
         assumeFalse( Os.isFamily( Os.FAMILY_WINDOWS ) );
 
         File file = new File( "src/test/resources/symlinks/src/symDir" );
         assertTrue(FileUtils.isSymbolicLink(file  ));
     }
 
     @Test
     @Ignore("Wait until we can run with assembly 2.5 which will support symlinks properly")
     public void notASymbolicLink()
         throws IOException
     {
         File file = new File( "src/test/resources/symlinks/src/" );
         assertFalse(FileUtils.isSymbolicLink(file  ));
     }
 
     @Test
     public void extensionUnixRootPathOnUnix()
         throws Exception
     {
         assumeThat( File.separatorChar, is( '/' ) );
         assertThat( FileUtils.extension( "/foo.bar.txt" ), is( "txt" ) );
     }
 
     @Test
     public void extensionUnixNonRootPathOnUnix()
         throws Exception
     {
         assumeThat( File.separatorChar, is( '/' ) );
         assertThat( FileUtils.extension( "/test/foo.bar.txt" ), is( "txt" ) );
     }
 
     @Test
     public void createAndReadSymlink()
         throws Exception
     {
         assumeFalse( Os.isFamily( Os.FAMILY_WINDOWS ) );
 
         File file = new File( "target/fzz" );
         FileUtils.createSymbolicLink(  file, new File("../target") );
 
         final File file1 = Files.readSymbolicLink( file.toPath() ).toFile();
         assertEquals( "target", file1.getName() );
         Files.delete( file.toPath() );
     }
 
     @Test
     public void createSymbolicLinkWithDifferentTargetOverwritesSymlink()
             throws Exception
     {
         assumeFalse( Os.isFamily( Os.FAMILY_WINDOWS ) );
 
         // Arrange
 
         final File symlink1 = new File( tempFolder.getRoot(), "symlink" );
 
         FileUtils.createSymbolicLink( symlink1, testFile1 );
 
         // Act
 
         final File symlink2 = FileUtils.createSymbolicLink( symlink1, testFile2 );
 
         // Assert
 
         assertThat(
             Files.readSymbolicLink( symlink2.toPath() ).toFile(),
             CoreMatchers.equalTo( testFile2 )
         );
     }
 
     //// constants for testing
 
     private static final String[] MINIMUM_DEFAULT_EXCLUDES = {
         // Miscellaneous typical temporary files
         "**/*~", "**/#*#", "**/.#*", "**/%*%", "**/._*",
 
         // CVS
         "**/CVS", "**/CVS/**", "**/.cvsignore",
 
         // Subversion
         "**/.svn", "**/.svn/**",
 
         // Arch
         "**/.arch-ids", "**/.arch-ids/**",
 
         //Bazaar
         "**/.bzr", "**/.bzr/**",
 
         //SurroundSCM
         "**/.MySCMServerInfo",
 
         // Mac
         "**/.DS_Store",
 
         // Serena Dimensions Version 10
         "**/.metadata", "**/.metadata/**",
 
         // Mercurial
         "**/.hg", "**/.hg/**",
 
         // git
         "**/.git", "**/.git/**",
 
         // BitKeeper
         "**/BitKeeper", "**/BitKeeper/**", "**/ChangeSet", "**/ChangeSet/**",
 
         // darcs
         "**/_darcs", "**/_darcs/**", "**/.darcsrepo", "**/.darcsrepo/**", "**/-darcs-backup*", "**/.darcs-temp-mail" };
 
 }