Merge pull request #2512 from ianhays/master

Final major update to the tests for System.IO.FileSystem

Author: Ian Hays

src/Common/src/Interop/Unix/libc/Interop.link.cs

@@ -0,0 +1,14 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class libc
+    {
+        [DllImport(Libraries.Libc, SetLastError = true)]
+        internal static extern int link(string oldpath, string newpath);
+    }
+}

src/System.IO.FileSystem/src/System.IO.FileSystem.csproj

@@ -331,6 +331,9 @@
     <Compile Include="$(CommonPath)\Interop\Unix\libc\Interop.utime.cs">
       <Link>Common\Interop\Unix\Interop.utime.cs</Link>
     </Compile>
+    <Compile Include="$(CommonPath)\Interop\Unix\libc\Interop.link.cs">
+      <Link>Common\Interop\Unix\Interop.link.cs</Link>
+    </Compile>
     <Compile Include="$(CommonPath)\Interop\Unix\libc\Interop.unlink.cs">
       <Link>Common\Interop\Unix\Interop.unlink.cs</Link>
     </Compile>

src/System.IO.FileSystem/src/System/IO/DirectoryInfo.cs

@@ -392,6 +392,13 @@ public void MoveTo(String destDirName)
             else
                 fullSourcePath = FullPath + PathHelpers.DirectorySeparatorCharAsString;
 
+            int maxDirectoryPath = FileSystem.Current.MaxDirectoryPath;
+            if (fullSourcePath.Length >= maxDirectoryPath)
+                throw new PathTooLongException(SR.IO_PathTooLong);
+
+            if (fullDestDirName.Length >= maxDirectoryPath)
+                throw new PathTooLongException(SR.IO_PathTooLong);
+
             StringComparison pathComparison = PathInternal.GetComparison();
             if (String.Equals(fullSourcePath, fullDestDirName, pathComparison))
                 throw new IOException(SR.IO_SourceDestMustBeDifferent);

src/System.IO.FileSystem/src/System/IO/FileInfo.cs

@@ -218,13 +218,10 @@ public override bool Exists
             }
         }
 
-
-
-
         // User must explicitly specify opening a new file or appending to one.
         public FileStream Open(FileMode mode)
         {
-            return Open(mode, FileAccess.ReadWrite, FileShare.None);
+            return Open(mode, (mode == FileMode.Append ? FileAccess.Write : FileAccess.ReadWrite), FileShare.None);
         }
 
         public FileStream Open(FileMode mode, FileAccess access)
@@ -271,6 +268,18 @@ public void MoveTo(String destFileName)
 
             String fullDestFileName = PathHelpers.GetFullPathInternal(destFileName);
 
+            // These checks are in place to ensure Unix error throwing happens the same way
+            // as it does on Windows.These checks can be removed if a solution to #2460 is
+            // found that doesn't require validity checks before making an API call.
+            if (!new DirectoryInfo(Path.GetDirectoryName(FullName)).Exists)
+            {
+                throw new DirectoryNotFoundException(SR.Format(SR.IO_PathNotFound_Path, FullName));
+            }
+            if (!Exists)
+            {
+                throw new FileNotFoundException(SR.Format(SR.IO_FileNotFound_FileName, FullName), FullName);
+            }
+
             FileSystem.Current.MoveFile(FullPath, fullDestFileName);
 
             FullPath = fullDestFileName;

src/System.IO.FileSystem/src/System/IO/UnixFileSystem.cs

@@ -52,19 +52,38 @@ public override void CopyFile(string sourceFullPath, string destFullPath, bool o
 
         public override void MoveFile(string sourceFullPath, string destFullPath)
         {
+            // The desired behavior for Move(source, dest) is to not overwrite the destination file
+            // if it exists. Since rename(source, dest) will replace the file at 'dest' if it exists,
+            // a check is added before rename is called. Note that this is a race condition. Possible
+            // better solutions would be to use link/unlink or platform specific functions instead of
+            // rename(source, dest). Regardless of the implementation, an IOException should be thrown if 
+            // 'dest' refers to a file that already exists.
+            if (File.Exists(destFullPath))
+                throw new IOException(SR.GetResourceString(SR.IO_AlreadyExists_Name, destFullPath));
             while (Interop.libc.rename(sourceFullPath, destFullPath) < 0)
             {
                 int errno = Marshal.GetLastWin32Error();
                 if (errno == Interop.Errors.EINTR) // interrupted; try again
                 {
                     continue;
                 }
-                else if (errno == Interop.Errors.EXDEV) // rename fails across devices / mount points
+                else if (errno == Interop.Errors.EXDEV) // link fails across devices / mount points
                 {
                     CopyFile(sourceFullPath, destFullPath, overwrite: false);
-                    DeleteFile(sourceFullPath);
                     break;
                 }
+                //else if (errno == Interop.Errors.ENOENT && (!Directory.Exists(Path.GetDirectoryName(sourceFullPath)) || !Directory.Exists(Path.GetDirectoryName(destFullPath)))) // The parent directory for either source or dest can't be found
+                else if (errno == Interop.Errors.ENOENT && !Directory.Exists(Path.GetDirectoryName(destFullPath))) // The parent directory of destFile can't be found
+                {
+                    // Windows distinguishes between whether the directory or the file isn't found,
+                    // and throws a different exception in these cases.  We attempt to approximate that
+                    // here; there is a race condition here, where something could change between
+                    // when the error occurs and our checks, but it's the best we can do, and the
+                    // worst case in such a race condition (which could occur if the file system is
+                    // being manipulated concurrently with these checks) is that we throw a
+                    // FileNotFoundException instead of DirectoryNotFoundexception.
+                    throw Interop.GetExceptionForIoErrno(errno, destFullPath, isDirectory: true);
+                }
                 else
                 {
                     throw Interop.GetExceptionForIoErrno(errno);

src/System.IO.FileSystem/src/System/IO/UnixFileSystemObject.cs

@@ -265,20 +265,18 @@ private void EnsureStatInitialized()
                     int errno = _fileinfoInitialized;
                     _fileinfoInitialized = -1;
 
-                    bool failedBecauseOfDirectory = _isDirectory;
-                    if (!failedBecauseOfDirectory && errno == Interop.Errors.ENOENT)
-                    {
-                        // Windows distinguishes between whether the directory or the file isn't found,
-                        // and throws a different exception in these cases.  We attempt to approximate that
-                        // here; there is a race condition here, where something could change between
-                        // when the error occurs and our checks, but it's the best we can do, and the
-                        // worst case in such a race condition (which could occur if the file system is
-                        // being manipulated concurrently with these checks) is that we throw a
-                        // FileNotFoundException instead of DirectoryNotFoundexception.
-                        failedBecauseOfDirectory = !Directory.Exists(Path.GetDirectoryName(_fullPath));
-                    }
+                    // Windows distinguishes between whether the directory or the file isn't found,
+                    // and throws a different exception in these cases.  We attempt to approximate that
+                    // here; there is a race condition here, where something could change between
+                    // when the error occurs and our checks, but it's the best we can do, and the
+                    // worst case in such a race condition (which could occur if the file system is
+                    // being manipulated concurrently with these checks) is that we throw a
+                    // FileNotFoundException instead of DirectoryNotFoundexception.
 
-                    throw Interop.GetExceptionForIoErrno(errno, _fullPath, failedBecauseOfDirectory);
+                    // directoryError is true only if a FileNotExists error was provided and the parent 
+                    // directory of the file represented by _fullPath is nonexistent
+                    bool directoryError = (errno == Interop.Errors.ENOENT && !Directory.Exists(Path.GetDirectoryName(PathHelpers.TrimEndingDirectorySeparator(_fullPath)))); // The destFile's path is invalid
+                    throw Interop.GetExceptionForIoErrno(errno, _fullPath, directoryError);
                 }
             }
         }

src/System.IO.FileSystem/src/System/IO/Win32FileSystem.cs

@@ -55,10 +55,6 @@ public override void CreateDirectory(string fullPath)
 
             int lengthRoot = PathInternal.GetRootLength(fullPath);
 
-            // For UNC paths that are only // or /// 
-            if (length == 2 && PathInternal.IsDirectorySeparator(fullPath[1]))
-                throw new IOException(SR.Format(SR.IO_CannotCreateDirectory, fullPath));
-
             // We can save a bunch of work if the directory we want to create already exists.  This also
             // saves us in the case where sub paths are inaccessible (due to ERROR_ACCESS_DENIED) but the
             // final path is accessable and the directory already exists.  For example, consider trying

src/System.IO.FileSystem/tests/Directory/CreateDirectory.cs

@@ -204,6 +204,10 @@ public void DirectoryWithComponentLongerThanMaxComponentAsPath_ThrowsPathTooLong
             });
         }
 
+        #endregion
+
+        #region PlatformSpecific
+
         [Fact]
         [PlatformSpecific(PlatformID.Windows)]
         public void DirectoryLongerThanMaxPathAsPath_ThrowsPathTooLongException()
@@ -215,10 +219,6 @@ public void DirectoryLongerThanMaxPathAsPath_ThrowsPathTooLongException()
             });
         }
 
-        #endregion
-
-        #region PlatformSpecific
-
         [Fact]
         [PlatformSpecific(PlatformID.Windows)]
         public void DirectoryLongerThanMaxDirectoryAsPath_ThrowsPathTooLongException()
@@ -227,6 +227,7 @@ public void DirectoryLongerThanMaxDirectoryAsPath_ThrowsPathTooLongException()
             Assert.All(paths, (path) =>
             {
                 Assert.Throws<PathTooLongException>(() => Create(path));
+                Directory.Delete(Path.Combine(Path.GetPathRoot(Directory.GetCurrentDirectory()), path.Split(Path.DirectorySeparatorChar)[1]), true);
             });
         }
 
@@ -373,6 +374,13 @@ public void UncPathWithoutShareNameAsPath_ThrowsArgumentException()
             }
         }
 
+        [Fact]
+        [PlatformSpecific(PlatformID.Windows)] // UNC shares
+        public void UNCPathWithOnlySlashes()
+        {
+            Assert.Throws<ArgumentException>(() => Create("//"));
+        }
+
         [Fact]
         [PlatformSpecific(PlatformID.Windows)] // drive labels
         public void CDriveCase()

src/System.IO.FileSystem/tests/Directory/EnumerableAPIs.cs

@@ -69,6 +69,51 @@ public override string[] GetEntries(string dirName, string searchPattern)
         {
             return Directory.EnumerateFileSystemEntries(dirName, searchPattern).ToArray();
         }
+
+        [Fact]
+        public void Clone_Enumerator_Empty()
+        {
+            DirectoryInfo testDir = Directory.CreateDirectory(GetTestFilePath());
+            var enumerator1 = Directory.EnumerateFileSystemEntries(testDir.FullName);
+            var enumerator2 = enumerator1;
+            Assert.Equal(enumerator1.ToArray(), enumerator2.ToArray());
+        }
+
+        [Fact]
+        public void Clone_Enumerator_Trimmed_SearchPattern()
+        {
+            DirectoryInfo testDir = Directory.CreateDirectory(GetTestFilePath());
+            var enumerator1 = Directory.EnumerateFileSystemEntries(testDir.FullName, ((char)0xA).ToString());
+            var enumerator2 = enumerator1;
+            Assert.Empty(enumerator1.ToArray());
+            Assert.Empty(enumerator2.ToArray());
+        }
+
+        [Fact]
+        public void Delete_Directory_After_Creating_Enumerable()
+        {
+            DirectoryInfo testDir = Directory.CreateDirectory(GetTestFilePath());
+            DirectoryInfo subDir1 = Directory.CreateDirectory(Path.Combine(testDir.FullName, "a"));
+            DirectoryInfo subDir2 = Directory.CreateDirectory(Path.Combine(testDir.FullName, "b"));
+            var enumerator = Directory.EnumerateDirectories(testDir.FullName);
+            foreach (var dir in enumerator)
+            {
+                Directory.Delete(dir);
+            }
+            Assert.Equal(0, enumerator.ToArray().Length);
+        }
+
+
+        [Fact]
+        public void Trailing_Slash_Adds_Trailing_Star()
+        {
+            // A searchpattern of c:\temp\ will become c:\temp\* internally
+            DirectoryInfo testDir = Directory.CreateDirectory(GetTestFilePath());
+            DirectoryInfo subDir1 = Directory.CreateDirectory(Path.Combine(testDir.FullName, "a"));
+            DirectoryInfo subDir2 = Directory.CreateDirectory(Path.Combine(testDir.FullName, "b"));
+            var enumerator = Directory.EnumerateDirectories(testDir.FullName, "a" + Path.DirectorySeparatorChar);
+            Assert.Equal(0, enumerator.ToArray().Length);
+        }
     }
 
     public class Directory_EnumFSE_str_str_so : Directory_GetFileSystemEntries_str_str_so

src/System.IO.FileSystem/tests/Directory/Exists.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System.Linq;
 using Xunit;
 
 namespace System.IO.FileSystem.Tests
@@ -54,9 +55,12 @@ public void ValidPathExists_ReturnsTrue()
         public void PathWithInvalidCharactersAsPath_ReturnsFalse()
         {
             // Checks that errors aren't thrown when calling Exists() on paths with impossible to create characters
+            char[] trimmed = { (char)0x9, (char)0xA, (char)0xB, (char)0xC, (char)0xD, (char)0x20, (char)0x85, (char)0xA0 };
             Assert.All((IOInputs.GetPathsWithInvalidCharacters()), (component) =>
             {
                 Assert.False(Exists(component));
+                if (!trimmed.Contains(component.ToCharArray()[0]))
+                    Assert.False(Exists(TestDirectory + Path.DirectorySeparatorChar + component));
             });
         }