projects / yaffs-website / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Pull merge.
[yaffs-website] / vendor / symfony / filesystem / Tests / FilesystemTest.php
diff --git a/vendor/symfony/filesystem/Tests/FilesystemTest.php b/vendor/symfony/filesystem/Tests/FilesystemTest.php
index 11c064a756ca9dd628806dcffa7abc73cc4aa1a8..df8b8124f99a78d19fdda3045a7c1546991cb44c 100644 (file)
--- a/vendor/symfony/filesystem/Tests/FilesystemTest.php
+++ b/vendor/symfony/filesystem/Tests/FilesystemTest.php
@@ -18,15 +18,15 @@ class FilesystemTest extends FilesystemTestCase
 {
     public function testCopyCreatesNewFile()
     {
-        $sourceFilePath = $this->workspace.DIRECTORY_SEPARATOR.'copy_source_file';
-        $targetFilePath = $this->workspace.DIRECTORY_SEPARATOR.'copy_target_file';
+        $sourceFilePath = $this->workspace.\DIRECTORY_SEPARATOR.'copy_source_file';
+        $targetFilePath = $this->workspace.\DIRECTORY_SEPARATOR.'copy_target_file';
 
         file_put_contents($sourceFilePath, 'SOURCE FILE');
 
         $this->filesystem->copy($sourceFilePath, $targetFilePath);
 
         $this->assertFileExists($targetFilePath);
-        $this->assertEquals('SOURCE FILE', file_get_contents($targetFilePath));
+        $this->assertStringEqualsFile($targetFilePath, 'SOURCE FILE');
     }
 
     /**
@@ -34,8 +34,8 @@ class FilesystemTest extends FilesystemTestCase
      */
     public function testCopyFails()
     {
-        $sourceFilePath = $this->workspace.DIRECTORY_SEPARATOR.'copy_source_file';
-        $targetFilePath = $this->workspace.DIRECTORY_SEPARATOR.'copy_target_file';
+        $sourceFilePath = $this->workspace.\DIRECTORY_SEPARATOR.'copy_source_file';
+        $targetFilePath = $this->workspace.\DIRECTORY_SEPARATOR.'copy_target_file';
 
         $this->filesystem->copy($sourceFilePath, $targetFilePath);
     }
@@ -46,12 +46,16 @@ class FilesystemTest extends FilesystemTestCase
     public function testCopyUnreadableFileFails()
     {
         // skip test on Windows; PHP can't easily set file as unreadable on Windows
-        if ('\\' === DIRECTORY_SEPARATOR) {
+        if ('\\' === \DIRECTORY_SEPARATOR) {
             $this->markTestSkipped('This test cannot run on Windows.');
         }
 
-        $sourceFilePath = $this->workspace.DIRECTORY_SEPARATOR.'copy_source_file';
-        $targetFilePath = $this->workspace.DIRECTORY_SEPARATOR.'copy_target_file';
+        if (!getenv('USER') || 'root' === getenv('USER')) {
+            $this->markTestSkipped('This test will fail if run under superuser');
+        }
+
+        $sourceFilePath = $this->workspace.\DIRECTORY_SEPARATOR.'copy_source_file';
+        $targetFilePath = $this->workspace.\DIRECTORY_SEPARATOR.'copy_target_file';
 
         file_put_contents($sourceFilePath, 'SOURCE FILE');
 
@@ -63,8 +67,8 @@ class FilesystemTest extends FilesystemTestCase
 
     public function testCopyOverridesExistingFileIfModified()
     {
-        $sourceFilePath = $this->workspace.DIRECTORY_SEPARATOR.'copy_source_file';
-        $targetFilePath = $this->workspace.DIRECTORY_SEPARATOR.'copy_target_file';
+        $sourceFilePath = $this->workspace.\DIRECTORY_SEPARATOR.'copy_source_file';
+        $targetFilePath = $this->workspace.\DIRECTORY_SEPARATOR.'copy_target_file';
 
         file_put_contents($sourceFilePath, 'SOURCE FILE');
         file_put_contents($targetFilePath, 'TARGET FILE');
@@ -73,13 +77,13 @@ class FilesystemTest extends FilesystemTestCase
         $this->filesystem->copy($sourceFilePath, $targetFilePath);
 
         $this->assertFileExists($targetFilePath);
-        $this->assertEquals('SOURCE FILE', file_get_contents($targetFilePath));
+        $this->assertStringEqualsFile($targetFilePath, 'SOURCE FILE');
     }
 
     public function testCopyDoesNotOverrideExistingFileByDefault()
     {
-        $sourceFilePath = $this->workspace.DIRECTORY_SEPARATOR.'copy_source_file';
-        $targetFilePath = $this->workspace.DIRECTORY_SEPARATOR.'copy_target_file';
+        $sourceFilePath = $this->workspace.\DIRECTORY_SEPARATOR.'copy_source_file';
+        $targetFilePath = $this->workspace.\DIRECTORY_SEPARATOR.'copy_target_file';
 
         file_put_contents($sourceFilePath, 'SOURCE FILE');
         file_put_contents($targetFilePath, 'TARGET FILE');
@@ -92,13 +96,13 @@ class FilesystemTest extends FilesystemTestCase
         $this->filesystem->copy($sourceFilePath, $targetFilePath);
 
         $this->assertFileExists($targetFilePath);
-        $this->assertEquals('TARGET FILE', file_get_contents($targetFilePath));
+        $this->assertStringEqualsFile($targetFilePath, 'TARGET FILE');
     }
 
     public function testCopyOverridesExistingFileIfForced()
     {
-        $sourceFilePath = $this->workspace.DIRECTORY_SEPARATOR.'copy_source_file';
-        $targetFilePath = $this->workspace.DIRECTORY_SEPARATOR.'copy_target_file';
+        $sourceFilePath = $this->workspace.\DIRECTORY_SEPARATOR.'copy_source_file';
+        $targetFilePath = $this->workspace.\DIRECTORY_SEPARATOR.'copy_target_file';
 
         file_put_contents($sourceFilePath, 'SOURCE FILE');
         file_put_contents($targetFilePath, 'TARGET FILE');
@@ -111,7 +115,7 @@ class FilesystemTest extends FilesystemTestCase
         $this->filesystem->copy($sourceFilePath, $targetFilePath, true);
 
         $this->assertFileExists($targetFilePath);
-        $this->assertEquals('SOURCE FILE', file_get_contents($targetFilePath));
+        $this->assertStringEqualsFile($targetFilePath, 'SOURCE FILE');
     }
 
     /**
@@ -120,12 +124,16 @@ class FilesystemTest extends FilesystemTestCase
     public function testCopyWithOverrideWithReadOnlyTargetFails()
     {
         // skip test on Windows; PHP can't easily set file as unwritable on Windows
-        if ('\\' === DIRECTORY_SEPARATOR) {
+        if ('\\' === \DIRECTORY_SEPARATOR) {
             $this->markTestSkipped('This test cannot run on Windows.');
         }
 
-        $sourceFilePath = $this->workspace.DIRECTORY_SEPARATOR.'copy_source_file';
-        $targetFilePath = $this->workspace.DIRECTORY_SEPARATOR.'copy_target_file';
+        if (!getenv('USER') || 'root' === getenv('USER')) {
+            $this->markTestSkipped('This test will fail if run under superuser');
+        }
+
+        $sourceFilePath = $this->workspace.\DIRECTORY_SEPARATOR.'copy_source_file';
+        $targetFilePath = $this->workspace.\DIRECTORY_SEPARATOR.'copy_target_file';
 
         file_put_contents($sourceFilePath, 'SOURCE FILE');
         file_put_contents($targetFilePath, 'TARGET FILE');
@@ -143,9 +151,9 @@ class FilesystemTest extends FilesystemTestCase
 
     public function testCopyCreatesTargetDirectoryIfItDoesNotExist()
     {
-        $sourceFilePath = $this->workspace.DIRECTORY_SEPARATOR.'copy_source_file';
-        $targetFileDirectory = $this->workspace.DIRECTORY_SEPARATOR.'directory';
-        $targetFilePath = $targetFileDirectory.DIRECTORY_SEPARATOR.'copy_target_file';
+        $sourceFilePath = $this->workspace.\DIRECTORY_SEPARATOR.'copy_source_file';
+        $targetFileDirectory = $this->workspace.\DIRECTORY_SEPARATOR.'directory';
+        $targetFilePath = $targetFileDirectory.\DIRECTORY_SEPARATOR.'copy_target_file';
 
         file_put_contents($sourceFilePath, 'SOURCE FILE');
 
@@ -153,7 +161,7 @@ class FilesystemTest extends FilesystemTestCase
 
         $this->assertTrue(is_dir($targetFileDirectory));
         $this->assertFileExists($targetFilePath);
-        $this->assertEquals('SOURCE FILE', file_get_contents($targetFilePath));
+        $this->assertStringEqualsFile($targetFilePath, 'SOURCE FILE');
     }
 
     /**
@@ -161,8 +169,11 @@ class FilesystemTest extends FilesystemTestCase
      */
     public function testCopyForOriginUrlsAndExistingLocalFileDefaultsToCopy()
     {
-        $sourceFilePath = 'http://symfony.com/images/common/logo/logo_symfony_header.png';
-        $targetFilePath = $this->workspace.DIRECTORY_SEPARATOR.'copy_target_file';
+        if (!\in_array('https', stream_get_wrappers())) {
+            $this->markTestSkipped('"https" stream wrapper is not enabled.');
+        }
+        $sourceFilePath = 'https://symfony.com/images/common/logo/logo_symfony_header.png';
+        $targetFilePath = $this->workspace.\DIRECTORY_SEPARATOR.'copy_target_file';
 
         file_put_contents($targetFilePath, 'TARGET FILE');
 
@@ -175,8 +186,8 @@ class FilesystemTest extends FilesystemTestCase
     public function testMkdirCreatesDirectoriesRecursively()
     {
         $directory = $this->workspace
-            .DIRECTORY_SEPARATOR.'directory'
-            .DIRECTORY_SEPARATOR.'sub_directory';
+            .\DIRECTORY_SEPARATOR.'directory'
+            .\DIRECTORY_SEPARATOR.'sub_directory';
 
         $this->filesystem->mkdir($directory);
 
@@ -185,7 +196,7 @@ class FilesystemTest extends FilesystemTestCase
 
     public function testMkdirCreatesDirectoriesFromArray()
     {
-        $basePath = $this->workspace.DIRECTORY_SEPARATOR;
+        $basePath = $this->workspace.\DIRECTORY_SEPARATOR;
         $directories = array(
             $basePath.'1', $basePath.'2', $basePath.'3',
         );
@@ -199,7 +210,7 @@ class FilesystemTest extends FilesystemTestCase
 
     public function testMkdirCreatesDirectoriesFromTraversableObject()
     {
-        $basePath = $this->workspace.DIRECTORY_SEPARATOR;
+        $basePath = $this->workspace.\DIRECTORY_SEPARATOR;
         $directories = new \ArrayObject(array(
             $basePath.'1', $basePath.'2', $basePath.'3',
         ));
@@ -216,7 +227,7 @@ class FilesystemTest extends FilesystemTestCase
      */
     public function testMkdirCreatesDirectoriesFails()
     {
-        $basePath = $this->workspace.DIRECTORY_SEPARATOR;
+        $basePath = $this->workspace.\DIRECTORY_SEPARATOR;
         $dir = $basePath.'2';
 
         file_put_contents($dir, '');
@@ -226,7 +237,7 @@ class FilesystemTest extends FilesystemTestCase
 
     public function testTouchCreatesEmptyFile()
     {
-        $file = $this->workspace.DIRECTORY_SEPARATOR.'1';
+        $file = $this->workspace.\DIRECTORY_SEPARATOR.'1';
 
         $this->filesystem->touch($file);
 
@@ -238,14 +249,14 @@ class FilesystemTest extends FilesystemTestCase
      */
     public function testTouchFails()
     {
-        $file = $this->workspace.DIRECTORY_SEPARATOR.'1'.DIRECTORY_SEPARATOR.'2';
+        $file = $this->workspace.\DIRECTORY_SEPARATOR.'1'.\DIRECTORY_SEPARATOR.'2';
 
         $this->filesystem->touch($file);
     }
 
     public function testTouchCreatesEmptyFilesFromArray()
     {
-        $basePath = $this->workspace.DIRECTORY_SEPARATOR;
+        $basePath = $this->workspace.\DIRECTORY_SEPARATOR;
         $files = array(
             $basePath.'1', $basePath.'2', $basePath.'3',
         );
@@ -259,7 +270,7 @@ class FilesystemTest extends FilesystemTestCase
 
     public function testTouchCreatesEmptyFilesFromTraversableObject()
     {
-        $basePath = $this->workspace.DIRECTORY_SEPARATOR;
+        $basePath = $this->workspace.\DIRECTORY_SEPARATOR;
         $files = new \ArrayObject(array(
             $basePath.'1', $basePath.'2', $basePath.'3',
         ));
@@ -273,7 +284,7 @@ class FilesystemTest extends FilesystemTestCase
 
     public function testRemoveCleansFilesAndDirectoriesIteratively()
     {
-        $basePath = $this->workspace.DIRECTORY_SEPARATOR.'directory'.DIRECTORY_SEPARATOR;
+        $basePath = $this->workspace.\DIRECTORY_SEPARATOR.'directory'.\DIRECTORY_SEPARATOR;
 
         mkdir($basePath);
         mkdir($basePath.'dir');
@@ -286,7 +297,7 @@ class FilesystemTest extends FilesystemTestCase
 
     public function testRemoveCleansArrayOfFilesAndDirectories()
     {
-        $basePath = $this->workspace.DIRECTORY_SEPARATOR;
+        $basePath = $this->workspace.\DIRECTORY_SEPARATOR;
 
         mkdir($basePath.'dir');
         touch($basePath.'file');
@@ -303,7 +314,7 @@ class FilesystemTest extends FilesystemTestCase
 
     public function testRemoveCleansTraversableObjectOfFilesAndDirectories()
     {
-        $basePath = $this->workspace.DIRECTORY_SEPARATOR;
+        $basePath = $this->workspace.\DIRECTORY_SEPARATOR;
 
         mkdir($basePath.'dir');
         touch($basePath.'file');
@@ -320,7 +331,7 @@ class FilesystemTest extends FilesystemTestCase
 
     public function testRemoveIgnoresNonExistingFiles()
     {
-        $basePath = $this->workspace.DIRECTORY_SEPARATOR;
+        $basePath = $this->workspace.\DIRECTORY_SEPARATOR;
 
         mkdir($basePath.'dir');
 
@@ -337,7 +348,7 @@ class FilesystemTest extends FilesystemTestCase
     {
         $this->markAsSkippedIfSymlinkIsMissing();
 
-        $basePath = $this->workspace.DIRECTORY_SEPARATOR.'directory'.DIRECTORY_SEPARATOR;
+        $basePath = $this->workspace.\DIRECTORY_SEPARATOR.'directory'.\DIRECTORY_SEPARATOR;
 
         mkdir($basePath);
         mkdir($basePath.'dir');
@@ -350,7 +361,7 @@ class FilesystemTest extends FilesystemTestCase
 
         // create symlink to nonexistent dir
         rmdir($basePath.'dir');
-        $this->assertFalse('\\' === DIRECTORY_SEPARATOR ? @readlink($basePath.'dir-link') : is_dir($basePath.'dir-link'));
+        $this->assertFalse('\\' === \DIRECTORY_SEPARATOR ? @readlink($basePath.'dir-link') : is_dir($basePath.'dir-link'));
 
         $this->filesystem->remove($basePath);
 
@@ -359,7 +370,7 @@ class FilesystemTest extends FilesystemTestCase
 
     public function testFilesExists()
     {
-        $basePath = $this->workspace.DIRECTORY_SEPARATOR.'directory'.DIRECTORY_SEPARATOR;
+        $basePath = $this->workspace.\DIRECTORY_SEPARATOR.'directory'.\DIRECTORY_SEPARATOR;
 
         mkdir($basePath);
         touch($basePath.'file1');
@@ -374,16 +385,16 @@ class FilesystemTest extends FilesystemTestCase
      */
     public function testFilesExistsFails()
     {
-        if ('\\' !== DIRECTORY_SEPARATOR) {
-            $this->markTestSkipped('Test covers edge case on Windows only.');
+        if ('\\' !== \DIRECTORY_SEPARATOR) {
+            $this->markTestSkipped('Long file names are an issue on Windows');
         }
-
         $basePath = $this->workspace.'\\directory\\';
+        $maxPathLength = PHP_MAXPATHLEN - 2;
 
         $oldPath = getcwd();
         mkdir($basePath);
         chdir($basePath);
-        $file = str_repeat('T', 259 - strlen($basePath));
+        $file = str_repeat('T', $maxPathLength - \strlen($basePath) + 1);
         $path = $basePath.$file;
         exec('TYPE NUL >>'.$file); // equivalent of touch, we can not use the php touch() here because it suffers from the same limitation
         $this->longPathNamesWindows[] = $path; // save this so we can clean up later
@@ -393,7 +404,7 @@ class FilesystemTest extends FilesystemTestCase
 
     public function testFilesExistsTraversableObjectOfFilesAndDirectories()
     {
-        $basePath = $this->workspace.DIRECTORY_SEPARATOR;
+        $basePath = $this->workspace.\DIRECTORY_SEPARATOR;
 
         mkdir($basePath.'dir');
         touch($basePath.'file');
@@ -407,7 +418,7 @@ class FilesystemTest extends FilesystemTestCase
 
     public function testFilesNotExistsTraversableObjectOfFilesAndDirectories()
     {
-        $basePath = $this->workspace.DIRECTORY_SEPARATOR;
+        $basePath = $this->workspace.\DIRECTORY_SEPARATOR;
 
         mkdir($basePath.'dir');
         touch($basePath.'file');
@@ -424,7 +435,7 @@ class FilesystemTest extends FilesystemTestCase
 
     public function testInvalidFileNotExists()
     {
-        $basePath = $this->workspace.DIRECTORY_SEPARATOR.'directory'.DIRECTORY_SEPARATOR;
+        $basePath = $this->workspace.\DIRECTORY_SEPARATOR.'directory'.\DIRECTORY_SEPARATOR;
 
         $this->assertFalse($this->filesystem->exists($basePath.time()));
     }
@@ -433,9 +444,9 @@ class FilesystemTest extends FilesystemTestCase
     {
         $this->markAsSkippedIfChmodIsMissing();
 
-        $dir = $this->workspace.DIRECTORY_SEPARATOR.'dir';
+        $dir = $this->workspace.\DIRECTORY_SEPARATOR.'dir';
         mkdir($dir);
-        $file = $dir.DIRECTORY_SEPARATOR.'file';
+        $file = $dir.\DIRECTORY_SEPARATOR.'file';
         touch($file);
 
         $this->filesystem->chmod($file, 0400);
@@ -449,11 +460,11 @@ class FilesystemTest extends FilesystemTestCase
     {
         $this->markAsSkippedIfChmodIsMissing();
 
-        if (defined('HHVM_VERSION')) {
+        if (\defined('HHVM_VERSION')) {
             $this->markTestSkipped('chmod() changes permissions even when passing invalid modes on HHVM');
         }
 
-        $dir = $this->workspace.DIRECTORY_SEPARATOR.'file';
+        $dir = $this->workspace.\DIRECTORY_SEPARATOR.'file';
         touch($dir);
 
         $permissions = fileperms($dir);
@@ -467,9 +478,9 @@ class FilesystemTest extends FilesystemTestCase
     {
         $this->markAsSkippedIfChmodIsMissing();
 
-        $dir = $this->workspace.DIRECTORY_SEPARATOR.'dir';
+        $dir = $this->workspace.\DIRECTORY_SEPARATOR.'dir';
         mkdir($dir);
-        $file = $dir.DIRECTORY_SEPARATOR.'file';
+        $file = $dir.\DIRECTORY_SEPARATOR.'file';
         touch($file);
 
         $this->filesystem->chmod($file, 0400, 0000, true);
@@ -483,7 +494,7 @@ class FilesystemTest extends FilesystemTestCase
     {
         $this->markAsSkippedIfChmodIsMissing();
 
-        $file = $this->workspace.DIRECTORY_SEPARATOR.'file';
+        $file = $this->workspace.\DIRECTORY_SEPARATOR.'file';
         touch($file);
 
         $this->filesystem->chmod($file, 0770, 0022);
@@ -494,8 +505,8 @@ class FilesystemTest extends FilesystemTestCase
     {
         $this->markAsSkippedIfChmodIsMissing();
 
-        $directory = $this->workspace.DIRECTORY_SEPARATOR.'directory';
-        $file = $this->workspace.DIRECTORY_SEPARATOR.'file';
+        $directory = $this->workspace.\DIRECTORY_SEPARATOR.'directory';
+        $file = $this->workspace.\DIRECTORY_SEPARATOR.'file';
         $files = array($directory, $file);
 
         mkdir($directory);
@@ -511,8 +522,8 @@ class FilesystemTest extends FilesystemTestCase
     {
         $this->markAsSkippedIfChmodIsMissing();
 
-        $directory = $this->workspace.DIRECTORY_SEPARATOR.'directory';
-        $file = $this->workspace.DIRECTORY_SEPARATOR.'file';
+        $directory = $this->workspace.\DIRECTORY_SEPARATOR.'directory';
+        $file = $this->workspace.\DIRECTORY_SEPARATOR.'file';
         $files = new \ArrayObject(array($directory, $file));
 
         mkdir($directory);
@@ -528,8 +539,8 @@ class FilesystemTest extends FilesystemTestCase
     {
         $this->markAsSkippedIfChmodIsMissing();
 
-        $directory = $this->workspace.DIRECTORY_SEPARATOR.'directory';
-        $subdirectory = $directory.DIRECTORY_SEPARATOR.'subdirectory';
+        $directory = $this->workspace.\DIRECTORY_SEPARATOR.'directory';
+        $subdirectory = $directory.\DIRECTORY_SEPARATOR.'subdirectory';
 
         mkdir($directory);
         mkdir($subdirectory);
@@ -544,7 +555,7 @@ class FilesystemTest extends FilesystemTestCase
     {
         $this->markAsSkippedIfPosixIsMissing();
 
-        $dir = $this->workspace.DIRECTORY_SEPARATOR.'dir';
+        $dir = $this->workspace.\DIRECTORY_SEPARATOR.'dir';
         mkdir($dir);
 
         $owner = $this->getFileOwner($dir);
@@ -557,9 +568,9 @@ class FilesystemTest extends FilesystemTestCase
     {
         $this->markAsSkippedIfPosixIsMissing();
 
-        $dir = $this->workspace.DIRECTORY_SEPARATOR.'dir';
+        $dir = $this->workspace.\DIRECTORY_SEPARATOR.'dir';
         mkdir($dir);
-        $file = $dir.DIRECTORY_SEPARATOR.'file';
+        $file = $dir.\DIRECTORY_SEPARATOR.'file';
         touch($file);
 
         $owner = $this->getFileOwner($dir);
@@ -572,8 +583,8 @@ class FilesystemTest extends FilesystemTestCase
     {
         $this->markAsSkippedIfSymlinkIsMissing();
 
-        $file = $this->workspace.DIRECTORY_SEPARATOR.'file';
-        $link = $this->workspace.DIRECTORY_SEPARATOR.'link';
+        $file = $this->workspace.\DIRECTORY_SEPARATOR.'file';
+        $link = $this->workspace.\DIRECTORY_SEPARATOR.'link';
 
         touch($file);
 
@@ -585,6 +596,23 @@ class FilesystemTest extends FilesystemTestCase
         $this->assertSame($owner, $this->getFileOwner($link));
     }
 
+    public function testChownLink()
+    {
+        $this->markAsSkippedIfLinkIsMissing();
+
+        $file = $this->workspace.\DIRECTORY_SEPARATOR.'file';
+        $link = $this->workspace.\DIRECTORY_SEPARATOR.'link';
+
+        touch($file);
+
+        $this->filesystem->hardlink($file, $link);
+
+        $owner = $this->getFileOwner($link);
+        $this->filesystem->chown($link, $owner);
+
+        $this->assertSame($owner, $this->getFileOwner($link));
+    }
+
     /**
      * @expectedException \Symfony\Component\Filesystem\Exception\IOException
      */
@@ -592,8 +620,8 @@ class FilesystemTest extends FilesystemTestCase
     {
         $this->markAsSkippedIfSymlinkIsMissing();
 
-        $file = $this->workspace.DIRECTORY_SEPARATOR.'file';
-        $link = $this->workspace.DIRECTORY_SEPARATOR.'link';
+        $file = $this->workspace.\DIRECTORY_SEPARATOR.'file';
+        $link = $this->workspace.\DIRECTORY_SEPARATOR.'link';
 
         touch($file);
 
@@ -602,6 +630,23 @@ class FilesystemTest extends FilesystemTestCase
         $this->filesystem->chown($link, 'user'.time().mt_rand(1000, 9999));
     }
 
+    /**
+     * @expectedException \Symfony\Component\Filesystem\Exception\IOException
+     */
+    public function testChownLinkFails()
+    {
+        $this->markAsSkippedIfLinkIsMissing();
+
+        $file = $this->workspace.\DIRECTORY_SEPARATOR.'file';
+        $link = $this->workspace.\DIRECTORY_SEPARATOR.'link';
+
+        touch($file);
+
+        $this->filesystem->hardlink($file, $link);
+
+        $this->filesystem->chown($link, 'user'.time().mt_rand(1000, 9999));
+    }
+
     /**
      * @expectedException \Symfony\Component\Filesystem\Exception\IOException
      */
@@ -609,7 +654,7 @@ class FilesystemTest extends FilesystemTestCase
     {
         $this->markAsSkippedIfPosixIsMissing();
 
-        $dir = $this->workspace.DIRECTORY_SEPARATOR.'dir';
+        $dir = $this->workspace.\DIRECTORY_SEPARATOR.'dir';
         mkdir($dir);
 
         $this->filesystem->chown($dir, 'user'.time().mt_rand(1000, 9999));
@@ -619,7 +664,7 @@ class FilesystemTest extends FilesystemTestCase
     {
         $this->markAsSkippedIfPosixIsMissing();
 
-        $dir = $this->workspace.DIRECTORY_SEPARATOR.'dir';
+        $dir = $this->workspace.\DIRECTORY_SEPARATOR.'dir';
         mkdir($dir);
 
         $group = $this->getFileGroup($dir);
@@ -632,9 +677,9 @@ class FilesystemTest extends FilesystemTestCase
     {
         $this->markAsSkippedIfPosixIsMissing();
 
-        $dir = $this->workspace.DIRECTORY_SEPARATOR.'dir';
+        $dir = $this->workspace.\DIRECTORY_SEPARATOR.'dir';
         mkdir($dir);
-        $file = $dir.DIRECTORY_SEPARATOR.'file';
+        $file = $dir.\DIRECTORY_SEPARATOR.'file';
         touch($file);
 
         $group = $this->getFileGroup($dir);
@@ -647,8 +692,8 @@ class FilesystemTest extends FilesystemTestCase
     {
         $this->markAsSkippedIfSymlinkIsMissing();
 
-        $file = $this->workspace.DIRECTORY_SEPARATOR.'file';
-        $link = $this->workspace.DIRECTORY_SEPARATOR.'link';
+        $file = $this->workspace.\DIRECTORY_SEPARATOR.'file';
+        $link = $this->workspace.\DIRECTORY_SEPARATOR.'link';
 
         touch($file);
 
@@ -660,6 +705,23 @@ class FilesystemTest extends FilesystemTestCase
         $this->assertSame($group, $this->getFileGroup($link));
     }
 
+    public function testChgrpLink()
+    {
+        $this->markAsSkippedIfLinkIsMissing();
+
+        $file = $this->workspace.\DIRECTORY_SEPARATOR.'file';
+        $link = $this->workspace.\DIRECTORY_SEPARATOR.'link';
+
+        touch($file);
+
+        $this->filesystem->hardlink($file, $link);
+
+        $group = $this->getFileGroup($link);
+        $this->filesystem->chgrp($link, $group);
+
+        $this->assertSame($group, $this->getFileGroup($link));
+    }
+
     /**
      * @expectedException \Symfony\Component\Filesystem\Exception\IOException
      */
@@ -667,8 +729,8 @@ class FilesystemTest extends FilesystemTestCase
     {
         $this->markAsSkippedIfSymlinkIsMissing();
 
-        $file = $this->workspace.DIRECTORY_SEPARATOR.'file';
-        $link = $this->workspace.DIRECTORY_SEPARATOR.'link';
+        $file = $this->workspace.\DIRECTORY_SEPARATOR.'file';
+        $link = $this->workspace.\DIRECTORY_SEPARATOR.'link';
 
         touch($file);
 
@@ -677,6 +739,23 @@ class FilesystemTest extends FilesystemTestCase
         $this->filesystem->chgrp($link, 'user'.time().mt_rand(1000, 9999));
     }
 
+    /**
+     * @expectedException \Symfony\Component\Filesystem\Exception\IOException
+     */
+    public function testChgrpLinkFails()
+    {
+        $this->markAsSkippedIfLinkIsMissing();
+
+        $file = $this->workspace.\DIRECTORY_SEPARATOR.'file';
+        $link = $this->workspace.\DIRECTORY_SEPARATOR.'link';
+
+        touch($file);
+
+        $this->filesystem->hardlink($file, $link);
+
+        $this->filesystem->chgrp($link, 'user'.time().mt_rand(1000, 9999));
+    }
+
     /**
      * @expectedException \Symfony\Component\Filesystem\Exception\IOException
      */
@@ -684,7 +763,7 @@ class FilesystemTest extends FilesystemTestCase
     {
         $this->markAsSkippedIfPosixIsMissing();
 
-        $dir = $this->workspace.DIRECTORY_SEPARATOR.'dir';
+        $dir = $this->workspace.\DIRECTORY_SEPARATOR.'dir';
         mkdir($dir);
 
         $this->filesystem->chgrp($dir, 'user'.time().mt_rand(1000, 9999));
@@ -692,8 +771,8 @@ class FilesystemTest extends FilesystemTestCase
 
     public function testRename()
     {
-        $file = $this->workspace.DIRECTORY_SEPARATOR.'file';
-        $newPath = $this->workspace.DIRECTORY_SEPARATOR.'new_file';
+        $file = $this->workspace.\DIRECTORY_SEPARATOR.'file';
+        $newPath = $this->workspace.\DIRECTORY_SEPARATOR.'new_file';
         touch($file);
 
         $this->filesystem->rename($file, $newPath);
@@ -707,8 +786,8 @@ class FilesystemTest extends FilesystemTestCase
      */
     public function testRenameThrowsExceptionIfTargetAlreadyExists()
     {
-        $file = $this->workspace.DIRECTORY_SEPARATOR.'file';
-        $newPath = $this->workspace.DIRECTORY_SEPARATOR.'new_file';
+        $file = $this->workspace.\DIRECTORY_SEPARATOR.'file';
+        $newPath = $this->workspace.\DIRECTORY_SEPARATOR.'new_file';
 
         touch($file);
         touch($newPath);
@@ -718,8 +797,8 @@ class FilesystemTest extends FilesystemTestCase
 
     public function testRenameOverwritesTheTargetIfItAlreadyExists()
     {
-        $file = $this->workspace.DIRECTORY_SEPARATOR.'file';
-        $newPath = $this->workspace.DIRECTORY_SEPARATOR.'new_file';
+        $file = $this->workspace.\DIRECTORY_SEPARATOR.'file';
+        $newPath = $this->workspace.\DIRECTORY_SEPARATOR.'new_file';
 
         touch($file);
         touch($newPath);
@@ -735,20 +814,20 @@ class FilesystemTest extends FilesystemTestCase
      */
     public function testRenameThrowsExceptionOnError()
     {
-        $file = $this->workspace.DIRECTORY_SEPARATOR.uniqid('fs_test_', true);
-        $newPath = $this->workspace.DIRECTORY_SEPARATOR.'new_file';
+        $file = $this->workspace.\DIRECTORY_SEPARATOR.uniqid('fs_test_', true);
+        $newPath = $this->workspace.\DIRECTORY_SEPARATOR.'new_file';
 
         $this->filesystem->rename($file, $newPath);
     }
 
     public function testSymlink()
     {
-        if ('\\' === DIRECTORY_SEPARATOR) {
+        if ('\\' === \DIRECTORY_SEPARATOR) {
             $this->markTestSkipped('Windows does not support creating "broken" symlinks');
         }
 
-        $file = $this->workspace.DIRECTORY_SEPARATOR.'file';
-        $link = $this->workspace.DIRECTORY_SEPARATOR.'link';
+        $file = $this->workspace.\DIRECTORY_SEPARATOR.'file';
+        $link = $this->workspace.\DIRECTORY_SEPARATOR.'link';
 
         // $file does not exists right now: creating "broken" links is a wanted feature
         $this->filesystem->symlink($file, $link);
@@ -768,21 +847,21 @@ class FilesystemTest extends FilesystemTestCase
     {
         $this->markAsSkippedIfSymlinkIsMissing();
 
-        $link = $this->workspace.DIRECTORY_SEPARATOR.'link';
+        $link = $this->workspace.\DIRECTORY_SEPARATOR.'link';
 
         $this->filesystem->remove($link);
 
-        $this->assertTrue(!is_link($link));
-        $this->assertTrue(!is_file($link));
-        $this->assertTrue(!is_dir($link));
+        $this->assertFalse(is_link($link));
+        $this->assertFalse(is_file($link));
+        $this->assertFalse(is_dir($link));
     }
 
     public function testSymlinkIsOverwrittenIfPointsToDifferentTarget()
     {
         $this->markAsSkippedIfSymlinkIsMissing();
 
-        $file = $this->workspace.DIRECTORY_SEPARATOR.'file';
-        $link = $this->workspace.DIRECTORY_SEPARATOR.'link';
+        $file = $this->workspace.\DIRECTORY_SEPARATOR.'file';
+        $link = $this->workspace.\DIRECTORY_SEPARATOR.'link';
 
         touch($file);
         symlink($this->workspace, $link);
@@ -797,8 +876,8 @@ class FilesystemTest extends FilesystemTestCase
     {
         $this->markAsSkippedIfSymlinkIsMissing();
 
-        $file = $this->workspace.DIRECTORY_SEPARATOR.'file';
-        $link = $this->workspace.DIRECTORY_SEPARATOR.'link';
+        $file = $this->workspace.\DIRECTORY_SEPARATOR.'file';
+        $link = $this->workspace.\DIRECTORY_SEPARATOR.'link';
 
         touch($file);
         symlink($file, $link);
@@ -813,9 +892,9 @@ class FilesystemTest extends FilesystemTestCase
     {
         $this->markAsSkippedIfSymlinkIsMissing();
 
-        $file = $this->workspace.DIRECTORY_SEPARATOR.'file';
-        $link1 = $this->workspace.DIRECTORY_SEPARATOR.'dir'.DIRECTORY_SEPARATOR.'link';
-        $link2 = $this->workspace.DIRECTORY_SEPARATOR.'dir'.DIRECTORY_SEPARATOR.'subdir'.DIRECTORY_SEPARATOR.'link';
+        $file = $this->workspace.\DIRECTORY_SEPARATOR.'file';
+        $link1 = $this->workspace.\DIRECTORY_SEPARATOR.'dir'.\DIRECTORY_SEPARATOR.'link';
+        $link2 = $this->workspace.\DIRECTORY_SEPARATOR.'dir'.\DIRECTORY_SEPARATOR.'subdir'.\DIRECTORY_SEPARATOR.'link';
 
         touch($file);
 
@@ -828,6 +907,193 @@ class FilesystemTest extends FilesystemTestCase
         $this->assertEquals($file, readlink($link2));
     }
 
+    public function testLink()
+    {
+        $this->markAsSkippedIfLinkIsMissing();
+
+        $file = $this->workspace.\DIRECTORY_SEPARATOR.'file';
+        $link = $this->workspace.\DIRECTORY_SEPARATOR.'link';
+
+        touch($file);
+        $this->filesystem->hardlink($file, $link);
+
+        $this->assertTrue(is_file($link));
+        $this->assertEquals(fileinode($file), fileinode($link));
+    }
+
+    /**
+     * @depends testLink
+     */
+    public function testRemoveLink()
+    {
+        $this->markAsSkippedIfLinkIsMissing();
+
+        $link = $this->workspace.\DIRECTORY_SEPARATOR.'link';
+
+        $this->filesystem->remove($link);
+
+        $this->assertTrue(!is_file($link));
+    }
+
+    public function testLinkIsOverwrittenIfPointsToDifferentTarget()
+    {
+        $this->markAsSkippedIfLinkIsMissing();
+
+        $file = $this->workspace.\DIRECTORY_SEPARATOR.'file';
+        $file2 = $this->workspace.\DIRECTORY_SEPARATOR.'file2';
+        $link = $this->workspace.\DIRECTORY_SEPARATOR.'link';
+
+        touch($file);
+        touch($file2);
+        link($file2, $link);
+
+        $this->filesystem->hardlink($file, $link);
+
+        $this->assertTrue(is_file($link));
+        $this->assertEquals(fileinode($file), fileinode($link));
+    }
+
+    public function testLinkIsNotOverwrittenIfAlreadyCreated()
+    {
+        $this->markAsSkippedIfLinkIsMissing();
+
+        $file = $this->workspace.\DIRECTORY_SEPARATOR.'file';
+        $link = $this->workspace.\DIRECTORY_SEPARATOR.'link';
+
+        touch($file);
+        link($file, $link);
+
+        $this->filesystem->hardlink($file, $link);
+
+        $this->assertTrue(is_file($link));
+        $this->assertEquals(fileinode($file), fileinode($link));
+    }
+
+    public function testLinkWithSeveralTargets()
+    {
+        $this->markAsSkippedIfLinkIsMissing();
+
+        $file = $this->workspace.\DIRECTORY_SEPARATOR.'file';
+        $link1 = $this->workspace.\DIRECTORY_SEPARATOR.'link';
+        $link2 = $this->workspace.\DIRECTORY_SEPARATOR.'link2';
+
+        touch($file);
+
+        $this->filesystem->hardlink($file, array($link1, $link2));
+
+        $this->assertTrue(is_file($link1));
+        $this->assertEquals(fileinode($file), fileinode($link1));
+        $this->assertTrue(is_file($link2));
+        $this->assertEquals(fileinode($file), fileinode($link2));
+    }
+
+    public function testLinkWithSameTarget()
+    {
+        $this->markAsSkippedIfLinkIsMissing();
+
+        $file = $this->workspace.\DIRECTORY_SEPARATOR.'file';
+        $link = $this->workspace.\DIRECTORY_SEPARATOR.'link';
+
+        touch($file);
+
+        // practically same as testLinkIsNotOverwrittenIfAlreadyCreated
+        $this->filesystem->hardlink($file, array($link, $link));
+
+        $this->assertTrue(is_file($link));
+        $this->assertEquals(fileinode($file), fileinode($link));
+    }
+
+    public function testReadRelativeLink()
+    {
+        $this->markAsSkippedIfSymlinkIsMissing();
+
+        if ('\\' === \DIRECTORY_SEPARATOR) {
+            $this->markTestSkipped('Relative symbolic links are not supported on Windows');
+        }
+
+        $file = $this->workspace.'/file';
+        $link1 = $this->workspace.'/dir/link';
+        $link2 = $this->workspace.'/dir/link2';
+        touch($file);
+
+        $this->filesystem->symlink('../file', $link1);
+        $this->filesystem->symlink('link', $link2);
+
+        $this->assertEquals($this->normalize('../file'), $this->filesystem->readlink($link1));
+        $this->assertEquals('link', $this->filesystem->readlink($link2));
+        $this->assertEquals($file, $this->filesystem->readlink($link1, true));
+        $this->assertEquals($file, $this->filesystem->readlink($link2, true));
+        $this->assertEquals($file, $this->filesystem->readlink($file, true));
+    }
+
+    public function testReadAbsoluteLink()
+    {
+        $this->markAsSkippedIfSymlinkIsMissing();
+
+        $file = $this->normalize($this->workspace.'/file');
+        $link1 = $this->normalize($this->workspace.'/dir/link');
+        $link2 = $this->normalize($this->workspace.'/dir/link2');
+        touch($file);
+
+        $this->filesystem->symlink($file, $link1);
+        $this->filesystem->symlink($link1, $link2);
+
+        $this->assertEquals($file, $this->filesystem->readlink($link1));
+        $this->assertEquals($link1, $this->filesystem->readlink($link2));
+        $this->assertEquals($file, $this->filesystem->readlink($link1, true));
+        $this->assertEquals($file, $this->filesystem->readlink($link2, true));
+        $this->assertEquals($file, $this->filesystem->readlink($file, true));
+    }
+
+    public function testReadBrokenLink()
+    {
+        $this->markAsSkippedIfSymlinkIsMissing();
+
+        if ('\\' === \DIRECTORY_SEPARATOR) {
+            $this->markTestSkipped('Windows does not support creating "broken" symlinks');
+        }
+
+        $file = $this->workspace.'/file';
+        $link = $this->workspace.'/link';
+
+        $this->filesystem->symlink($file, $link);
+
+        $this->assertEquals($file, $this->filesystem->readlink($link));
+        $this->assertNull($this->filesystem->readlink($link, true));
+
+        touch($file);
+        $this->assertEquals($file, $this->filesystem->readlink($link, true));
+    }
+
+    public function testReadLinkDefaultPathDoesNotExist()
+    {
+        $this->assertNull($this->filesystem->readlink($this->normalize($this->workspace.'/invalid')));
+    }
+
+    public function testReadLinkDefaultPathNotLink()
+    {
+        $file = $this->normalize($this->workspace.'/file');
+        touch($file);
+
+        $this->assertNull($this->filesystem->readlink($file));
+    }
+
+    public function testReadLinkCanonicalizePath()
+    {
+        $this->markAsSkippedIfSymlinkIsMissing();
+
+        $file = $this->normalize($this->workspace.'/file');
+        mkdir($this->normalize($this->workspace.'/dir'));
+        touch($file);
+
+        $this->assertEquals($file, $this->filesystem->readlink($this->normalize($this->workspace.'/dir/../file'), true));
+    }
+
+    public function testReadLinkCanonicalizedPathDoesNotExist()
+    {
+        $this->assertNull($this->filesystem->readlink($this->normalize($this->workspace.'invalid'), true));
+    }
+
     /**
      * @dataProvider providePathsForMakePathRelative
      */
@@ -838,9 +1104,6 @@ class FilesystemTest extends FilesystemTestCase
         $this->assertEquals($expectedPath, $path);
     }
 
-    /**
-     * @return array
-     */
     public function providePathsForMakePathRelative()
     {
         $paths = array(
@@ -848,7 +1111,6 @@ class FilesystemTest extends FilesystemTestCase
             array('/var/lib/symfony/src/Symfony/', '/var/lib/symfony/src/Symfony/Component/', '../'),
             array('/var/lib/symfony/src/Symfony', '/var/lib/symfony/src/Symfony/Component', '../'),
             array('/var/lib/symfony/src/Symfony', '/var/lib/symfony/src/Symfony/Component/', '../'),
-            array('var/lib/symfony/', 'var/lib/symfony/src/Symfony/Component', '../../../'),
             array('/usr/lib/symfony/', '/var/lib/symfony/src/Symfony/Component', '../../../../../../usr/lib/symfony/'),
             array('/var/lib/symfony/src/Symfony/', '/var/lib/symfony/', 'src/Symfony/'),
             array('/aa/bb', '/aa/bb', './'),
@@ -883,17 +1145,47 @@ class FilesystemTest extends FilesystemTestCase
             array('C:/../../aa/../bb/cc', 'C:/aa/dd/..', '../bb/cc/'),
         );
 
-        if ('\\' === DIRECTORY_SEPARATOR) {
+        if ('\\' === \DIRECTORY_SEPARATOR) {
             $paths[] = array('c:\var\lib/symfony/src/Symfony/', 'c:/var/lib/symfony/', 'src/Symfony/');
         }
 
         return $paths;
     }
 
+    /**
+     * @group legacy
+     * @dataProvider provideLegacyPathsForMakePathRelativeWithRelativePaths
+     * @expectedDeprecation Support for passing relative paths to Symfony\Component\Filesystem\Filesystem::makePathRelative() is deprecated since Symfony 3.4 and will be removed in 4.0.
+     */
+    public function testMakePathRelativeWithRelativePaths($endPath, $startPath, $expectedPath)
+    {
+        $path = $this->filesystem->makePathRelative($endPath, $startPath);
+
+        $this->assertEquals($expectedPath, $path);
+    }
+
+    public function provideLegacyPathsForMakePathRelativeWithRelativePaths()
+    {
+        return array(
+            array('usr/lib/symfony/', 'var/lib/symfony/src/Symfony/Component', '../../../../../../usr/lib/symfony/'),
+            array('aa/bb', 'aa/cc', '../bb/'),
+            array('aa/cc', 'bb/cc', '../../aa/cc/'),
+            array('aa/bb', 'aa/./cc', '../bb/'),
+            array('aa/./bb', 'aa/cc', '../bb/'),
+            array('aa/./bb', 'aa/./cc', '../bb/'),
+            array('../../', '../../', './'),
+            array('../aa/bb/', 'aa/bb/', '../../../aa/bb/'),
+            array('../../../', '../../', '../'),
+            array('', '', './'),
+            array('', 'aa/', '../'),
+            array('aa/', '', 'aa/'),
+        );
+    }
+
     public function testMirrorCopiesFilesAndDirectoriesRecursively()
     {
-        $sourcePath = $this->workspace.DIRECTORY_SEPARATOR.'source'.DIRECTORY_SEPARATOR;
-        $directory = $sourcePath.'directory'.DIRECTORY_SEPARATOR;
+        $sourcePath = $this->workspace.\DIRECTORY_SEPARATOR.'source'.\DIRECTORY_SEPARATOR;
+        $directory = $sourcePath.'directory'.\DIRECTORY_SEPARATOR;
         $file1 = $directory.'file1';
         $file2 = $sourcePath.'file2';
 
@@ -902,41 +1194,41 @@ class FilesystemTest extends FilesystemTestCase
         file_put_contents($file1, 'FILE1');
         file_put_contents($file2, 'FILE2');
 
-        $targetPath = $this->workspace.DIRECTORY_SEPARATOR.'target'.DIRECTORY_SEPARATOR;
+        $targetPath = $this->workspace.\DIRECTORY_SEPARATOR.'target'.\DIRECTORY_SEPARATOR;
 
         $this->filesystem->mirror($sourcePath, $targetPath);
 
         $this->assertTrue(is_dir($targetPath));
         $this->assertTrue(is_dir($targetPath.'directory'));
-        $this->assertFileEquals($file1, $targetPath.'directory'.DIRECTORY_SEPARATOR.'file1');
+        $this->assertFileEquals($file1, $targetPath.'directory'.\DIRECTORY_SEPARATOR.'file1');
         $this->assertFileEquals($file2, $targetPath.'file2');
 
         $this->filesystem->remove($file1);
 
         $this->filesystem->mirror($sourcePath, $targetPath, null, array('delete' => false));
-        $this->assertTrue($this->filesystem->exists($targetPath.'directory'.DIRECTORY_SEPARATOR.'file1'));
+        $this->assertTrue($this->filesystem->exists($targetPath.'directory'.\DIRECTORY_SEPARATOR.'file1'));
 
         $this->filesystem->mirror($sourcePath, $targetPath, null, array('delete' => true));
-        $this->assertFalse($this->filesystem->exists($targetPath.'directory'.DIRECTORY_SEPARATOR.'file1'));
+        $this->assertFalse($this->filesystem->exists($targetPath.'directory'.\DIRECTORY_SEPARATOR.'file1'));
 
         file_put_contents($file1, 'FILE1');
 
         $this->filesystem->mirror($sourcePath, $targetPath, null, array('delete' => true));
-        $this->assertTrue($this->filesystem->exists($targetPath.'directory'.DIRECTORY_SEPARATOR.'file1'));
+        $this->assertTrue($this->filesystem->exists($targetPath.'directory'.\DIRECTORY_SEPARATOR.'file1'));
 
         $this->filesystem->remove($directory);
         $this->filesystem->mirror($sourcePath, $targetPath, null, array('delete' => true));
         $this->assertFalse($this->filesystem->exists($targetPath.'directory'));
-        $this->assertFalse($this->filesystem->exists($targetPath.'directory'.DIRECTORY_SEPARATOR.'file1'));
+        $this->assertFalse($this->filesystem->exists($targetPath.'directory'.\DIRECTORY_SEPARATOR.'file1'));
     }
 
     public function testMirrorCreatesEmptyDirectory()
     {
-        $sourcePath = $this->workspace.DIRECTORY_SEPARATOR.'source'.DIRECTORY_SEPARATOR;
+        $sourcePath = $this->workspace.\DIRECTORY_SEPARATOR.'source'.\DIRECTORY_SEPARATOR;
 
         mkdir($sourcePath);
 
-        $targetPath = $this->workspace.DIRECTORY_SEPARATOR.'target'.DIRECTORY_SEPARATOR;
+        $targetPath = $this->workspace.\DIRECTORY_SEPARATOR.'target'.\DIRECTORY_SEPARATOR;
 
         $this->filesystem->mirror($sourcePath, $targetPath);
 
@@ -949,46 +1241,46 @@ class FilesystemTest extends FilesystemTestCase
     {
         $this->markAsSkippedIfSymlinkIsMissing();
 
-        $sourcePath = $this->workspace.DIRECTORY_SEPARATOR.'source'.DIRECTORY_SEPARATOR;
+        $sourcePath = $this->workspace.\DIRECTORY_SEPARATOR.'source'.\DIRECTORY_SEPARATOR;
 
         mkdir($sourcePath);
         file_put_contents($sourcePath.'file1', 'FILE1');
         symlink($sourcePath.'file1', $sourcePath.'link1');
 
-        $targetPath = $this->workspace.DIRECTORY_SEPARATOR.'target'.DIRECTORY_SEPARATOR;
+        $targetPath = $this->workspace.\DIRECTORY_SEPARATOR.'target'.\DIRECTORY_SEPARATOR;
 
         $this->filesystem->mirror($sourcePath, $targetPath);
 
         $this->assertTrue(is_dir($targetPath));
         $this->assertFileEquals($sourcePath.'file1', $targetPath.'link1');
-        $this->assertTrue(is_link($targetPath.DIRECTORY_SEPARATOR.'link1'));
+        $this->assertTrue(is_link($targetPath.\DIRECTORY_SEPARATOR.'link1'));
     }
 
     public function testMirrorCopiesLinkedDirectoryContents()
     {
         $this->markAsSkippedIfSymlinkIsMissing(true);
 
-        $sourcePath = $this->workspace.DIRECTORY_SEPARATOR.'source'.DIRECTORY_SEPARATOR;
+        $sourcePath = $this->workspace.\DIRECTORY_SEPARATOR.'source'.\DIRECTORY_SEPARATOR;
 
         mkdir($sourcePath.'nested/', 0777, true);
         file_put_contents($sourcePath.'/nested/file1.txt', 'FILE1');
         // Note: We symlink directory, not file
         symlink($sourcePath.'nested', $sourcePath.'link1');
 
-        $targetPath = $this->workspace.DIRECTORY_SEPARATOR.'target'.DIRECTORY_SEPARATOR;
+        $targetPath = $this->workspace.\DIRECTORY_SEPARATOR.'target'.\DIRECTORY_SEPARATOR;
 
         $this->filesystem->mirror($sourcePath, $targetPath);
 
         $this->assertTrue(is_dir($targetPath));
         $this->assertFileEquals($sourcePath.'/nested/file1.txt', $targetPath.'link1/file1.txt');
-        $this->assertTrue(is_link($targetPath.DIRECTORY_SEPARATOR.'link1'));
+        $this->assertTrue(is_link($targetPath.\DIRECTORY_SEPARATOR.'link1'));
     }
 
     public function testMirrorCopiesRelativeLinkedContents()
     {
         $this->markAsSkippedIfSymlinkIsMissing(true);
 
-        $sourcePath = $this->workspace.DIRECTORY_SEPARATOR.'source'.DIRECTORY_SEPARATOR;
+        $sourcePath = $this->workspace.\DIRECTORY_SEPARATOR.'source'.\DIRECTORY_SEPARATOR;
         $oldPath = getcwd();
 
         mkdir($sourcePath.'nested/', 0777, true);
@@ -999,14 +1291,61 @@ class FilesystemTest extends FilesystemTestCase
 
         chdir($oldPath);
 
-        $targetPath = $this->workspace.DIRECTORY_SEPARATOR.'target'.DIRECTORY_SEPARATOR;
+        $targetPath = $this->workspace.\DIRECTORY_SEPARATOR.'target'.\DIRECTORY_SEPARATOR;
 
         $this->filesystem->mirror($sourcePath, $targetPath);
 
         $this->assertTrue(is_dir($targetPath));
         $this->assertFileEquals($sourcePath.'/nested/file1.txt', $targetPath.'link1/file1.txt');
-        $this->assertTrue(is_link($targetPath.DIRECTORY_SEPARATOR.'link1'));
-        $this->assertEquals('\\' === DIRECTORY_SEPARATOR ? realpath($sourcePath.'\nested') : 'nested', readlink($targetPath.DIRECTORY_SEPARATOR.'link1'));
+        $this->assertTrue(is_link($targetPath.\DIRECTORY_SEPARATOR.'link1'));
+        $this->assertEquals('\\' === \DIRECTORY_SEPARATOR ? realpath($sourcePath.'\nested') : 'nested', readlink($targetPath.\DIRECTORY_SEPARATOR.'link1'));
+    }
+
+    public function testMirrorContentsWithSameNameAsSourceOrTargetWithoutDeleteOption()
+    {
+        $sourcePath = $this->workspace.\DIRECTORY_SEPARATOR.'source'.\DIRECTORY_SEPARATOR;
+
+        mkdir($sourcePath);
+        touch($sourcePath.'source');
+        touch($sourcePath.'target');
+
+        $targetPath = $this->workspace.\DIRECTORY_SEPARATOR.'target'.\DIRECTORY_SEPARATOR;
+
+        $oldPath = getcwd();
+        chdir($this->workspace);
+
+        $this->filesystem->mirror('source', $targetPath);
+
+        chdir($oldPath);
+
+        $this->assertTrue(is_dir($targetPath));
+        $this->assertFileExists($targetPath.'source');
+        $this->assertFileExists($targetPath.'target');
+    }
+
+    public function testMirrorContentsWithSameNameAsSourceOrTargetWithDeleteOption()
+    {
+        $sourcePath = $this->workspace.\DIRECTORY_SEPARATOR.'source'.\DIRECTORY_SEPARATOR;
+
+        mkdir($sourcePath);
+        touch($sourcePath.'source');
+
+        $targetPath = $this->workspace.\DIRECTORY_SEPARATOR.'target'.\DIRECTORY_SEPARATOR;
+
+        mkdir($targetPath);
+        touch($targetPath.'source');
+        touch($targetPath.'target');
+
+        $oldPath = getcwd();
+        chdir($this->workspace);
+
+        $this->filesystem->mirror('source', 'target', null, array('delete' => true));
+
+        chdir($oldPath);
+
+        $this->assertTrue(is_dir($targetPath));
+        $this->assertFileExists($targetPath.'source');
+        $this->assertFileNotExists($targetPath.'target');
     }
 
     /**
@@ -1019,9 +1358,6 @@ class FilesystemTest extends FilesystemTestCase
         $this->assertEquals($expectedResult, $result);
     }
 
-    /**
-     * @return array
-     */
     public function providePathsForIsAbsolutePath()
     {
         return array(
@@ -1127,11 +1463,11 @@ class FilesystemTest extends FilesystemTestCase
     public function testTempnamOnUnwritableFallsBackToSysTmp()
     {
         $scheme = 'file://';
-        $dirname = $scheme.$this->workspace.DIRECTORY_SEPARATOR.'does_not_exist';
+        $dirname = $scheme.$this->workspace.\DIRECTORY_SEPARATOR.'does_not_exist';
 
         $filename = $this->filesystem->tempnam($dirname, 'bar');
         $realTempDir = realpath(sys_get_temp_dir());
-        $this->assertStringStartsWith(rtrim($scheme.$realTempDir, DIRECTORY_SEPARATOR), $filename);
+        $this->assertStringStartsWith(rtrim($scheme.$realTempDir, \DIRECTORY_SEPARATOR), $filename);
         $this->assertFileExists($filename);
 
         // Tear down
@@ -1140,90 +1476,167 @@ class FilesystemTest extends FilesystemTestCase
 
     public function testDumpFile()
     {
-        $filename = $this->workspace.DIRECTORY_SEPARATOR.'foo'.DIRECTORY_SEPARATOR.'baz.txt';
+        $filename = $this->workspace.\DIRECTORY_SEPARATOR.'foo'.\DIRECTORY_SEPARATOR.'baz.txt';
 
-        $this->filesystem->dumpFile($filename, 'bar');
+        // skip mode check on Windows
+        if ('\\' !== \DIRECTORY_SEPARATOR) {
+            $oldMask = umask(0002);
+        }
 
+        $this->filesystem->dumpFile($filename, 'bar');
         $this->assertFileExists($filename);
-        $this->assertSame('bar', file_get_contents($filename));
+        $this->assertStringEqualsFile($filename, 'bar');
+
+        // skip mode check on Windows
+        if ('\\' !== \DIRECTORY_SEPARATOR) {
+            $this->assertFilePermissions(664, $filename);
+            umask($oldMask);
+        }
     }
 
-    /**
-     * @group legacy
-     */
-    public function testDumpFileAndSetPermissions()
+    public function testDumpFileWithArray()
     {
-        $filename = $this->workspace.DIRECTORY_SEPARATOR.'foo'.DIRECTORY_SEPARATOR.'baz.txt';
+        $filename = $this->workspace.\DIRECTORY_SEPARATOR.'foo'.\DIRECTORY_SEPARATOR.'baz.txt';
 
-        $this->filesystem->dumpFile($filename, 'bar', 0753);
+        $this->filesystem->dumpFile($filename, array('bar'));
 
         $this->assertFileExists($filename);
-        $this->assertSame('bar', file_get_contents($filename));
-
-        // skip mode check on Windows
-        if ('\\' !== DIRECTORY_SEPARATOR) {
-            $this->assertFilePermissions(753, $filename);
-        }
+        $this->assertStringEqualsFile($filename, 'bar');
     }
 
-    public function testDumpFileWithNullMode()
+    public function testDumpFileWithResource()
     {
-        $filename = $this->workspace.DIRECTORY_SEPARATOR.'foo'.DIRECTORY_SEPARATOR.'baz.txt';
+        $filename = $this->workspace.\DIRECTORY_SEPARATOR.'foo'.\DIRECTORY_SEPARATOR.'baz.txt';
 
-        $this->filesystem->dumpFile($filename, 'bar', null);
+        $resource = fopen('php://memory', 'rw');
+        fwrite($resource, 'bar');
+        fseek($resource, 0);
 
-        $this->assertFileExists($filename);
-        $this->assertSame('bar', file_get_contents($filename));
+        $this->filesystem->dumpFile($filename, $resource);
 
-        // skip mode check on Windows
-        if ('\\' !== DIRECTORY_SEPARATOR) {
-            $this->assertFilePermissions(600, $filename);
-        }
+        fclose($resource);
+        $this->assertFileExists($filename);
+        $this->assertStringEqualsFile($filename, 'bar');
     }
 
     public function testDumpFileOverwritesAnExistingFile()
     {
-        $filename = $this->workspace.DIRECTORY_SEPARATOR.'foo.txt';
+        $filename = $this->workspace.\DIRECTORY_SEPARATOR.'foo.txt';
         file_put_contents($filename, 'FOO BAR');
 
         $this->filesystem->dumpFile($filename, 'bar');
 
         $this->assertFileExists($filename);
-        $this->assertSame('bar', file_get_contents($filename));
+        $this->assertStringEqualsFile($filename, 'bar');
     }
 
     public function testDumpFileWithFileScheme()
     {
-        if (defined('HHVM_VERSION')) {
+        if (\defined('HHVM_VERSION')) {
             $this->markTestSkipped('HHVM does not handle the file:// scheme correctly');
         }
 
         $scheme = 'file://';
-        $filename = $scheme.$this->workspace.DIRECTORY_SEPARATOR.'foo'.DIRECTORY_SEPARATOR.'baz.txt';
+        $filename = $scheme.$this->workspace.\DIRECTORY_SEPARATOR.'foo'.\DIRECTORY_SEPARATOR.'baz.txt';
 
-        $this->filesystem->dumpFile($filename, 'bar', null);
+        $this->filesystem->dumpFile($filename, 'bar');
 
         $this->assertFileExists($filename);
-        $this->assertSame('bar', file_get_contents($filename));
+        $this->assertStringEqualsFile($filename, 'bar');
     }
 
     public function testDumpFileWithZlibScheme()
     {
         $scheme = 'compress.zlib://';
-        $filename = $this->workspace.DIRECTORY_SEPARATOR.'foo'.DIRECTORY_SEPARATOR.'baz.txt';
+        $filename = $this->workspace.\DIRECTORY_SEPARATOR.'foo'.\DIRECTORY_SEPARATOR.'baz.txt';
 
-        $this->filesystem->dumpFile($filename, 'bar', null);
+        $this->filesystem->dumpFile($filename, 'bar');
 
         // Zlib stat uses file:// wrapper so remove scheme
         $this->assertFileExists(str_replace($scheme, '', $filename));
-        $this->assertSame('bar', file_get_contents($filename));
+        $this->assertStringEqualsFile($filename, 'bar');
+    }
+
+    public function testAppendToFile()
+    {
+        $filename = $this->workspace.\DIRECTORY_SEPARATOR.'foo'.\DIRECTORY_SEPARATOR.'bar.txt';
+
+        // skip mode check on Windows
+        if ('\\' !== \DIRECTORY_SEPARATOR) {
+            $oldMask = umask(0002);
+        }
+
+        $this->filesystem->dumpFile($filename, 'foo');
+
+        $this->filesystem->appendToFile($filename, 'bar');
+
+        $this->assertFileExists($filename);
+        $this->assertStringEqualsFile($filename, 'foobar');
+
+        // skip mode check on Windows
+        if ('\\' !== \DIRECTORY_SEPARATOR) {
+            $this->assertFilePermissions(664, $filename);
+            umask($oldMask);
+        }
+    }
+
+    public function testAppendToFileWithScheme()
+    {
+        if (\defined('HHVM_VERSION')) {
+            $this->markTestSkipped('HHVM does not handle the file:// scheme correctly');
+        }
+
+        $scheme = 'file://';
+        $filename = $scheme.$this->workspace.\DIRECTORY_SEPARATOR.'foo'.\DIRECTORY_SEPARATOR.'baz.txt';
+        $this->filesystem->dumpFile($filename, 'foo');
+
+        $this->filesystem->appendToFile($filename, 'bar');
+
+        $this->assertFileExists($filename);
+        $this->assertStringEqualsFile($filename, 'foobar');
+    }
+
+    public function testAppendToFileWithZlibScheme()
+    {
+        $scheme = 'compress.zlib://';
+        $filename = $this->workspace.\DIRECTORY_SEPARATOR.'foo'.\DIRECTORY_SEPARATOR.'baz.txt';
+        $this->filesystem->dumpFile($filename, 'foo');
+
+        // Zlib stat uses file:// wrapper so remove it
+        $this->assertStringEqualsFile(str_replace($scheme, '', $filename), 'foo');
+
+        $this->filesystem->appendToFile($filename, 'bar');
+
+        $this->assertFileExists($filename);
+        $this->assertStringEqualsFile($filename, 'foobar');
+    }
+
+    public function testAppendToFileCreateTheFileIfNotExists()
+    {
+        $filename = $this->workspace.\DIRECTORY_SEPARATOR.'foo'.\DIRECTORY_SEPARATOR.'bar.txt';
+
+        // skip mode check on Windows
+        if ('\\' !== \DIRECTORY_SEPARATOR) {
+            $oldMask = umask(0002);
+        }
+
+        $this->filesystem->appendToFile($filename, 'bar');
+
+        // skip mode check on Windows
+        if ('\\' !== \DIRECTORY_SEPARATOR) {
+            $this->assertFilePermissions(664, $filename);
+            umask($oldMask);
+        }
+
+        $this->assertFileExists($filename);
+        $this->assertStringEqualsFile($filename, 'bar');
     }
 
     public function testDumpKeepsExistingPermissionsWhenOverwritingAnExistingFile()
     {
         $this->markAsSkippedIfChmodIsMissing();
 
-        $filename = $this->workspace.DIRECTORY_SEPARATOR.'foo.txt';
+        $filename = $this->workspace.\DIRECTORY_SEPARATOR.'foo.txt';
         file_put_contents($filename, 'FOO BAR');
         chmod($filename, 0745);
 
@@ -1236,8 +1649,8 @@ class FilesystemTest extends FilesystemTestCase
     {
         $this->markAsSkippedIfChmodIsMissing();
 
-        $sourceFilePath = $this->workspace.DIRECTORY_SEPARATOR.'copy_source_file';
-        $targetFilePath = $this->workspace.DIRECTORY_SEPARATOR.'copy_target_file';
+        $sourceFilePath = $this->workspace.\DIRECTORY_SEPARATOR.'copy_source_file';
+        $targetFilePath = $this->workspace.\DIRECTORY_SEPARATOR.'copy_target_file';
 
         file_put_contents($sourceFilePath, 'SOURCE FILE');
         chmod($sourceFilePath, 0745);
@@ -1246,4 +1659,16 @@ class FilesystemTest extends FilesystemTestCase
 
         $this->assertFilePermissions(767, $targetFilePath);
     }
+
+    /**
+     * Normalize the given path (transform each blackslash into a real directory separator).
+     *
+     * @param string $path
+     *
+     * @return string
+     */
+    private function normalize($path)
+    {
+        return str_replace('/', \DIRECTORY_SEPARATOR, $path);
+    }
 }
Unnamed repository; edit this file 'description' to name the repository.