Start adding alternate data stream tests (#27931)

* Start adding alternate data stream tests

Also fill out ExampleTests.

* Skip on NetFX

3 files changed, 217 insertions, 18 deletions

diff --git a/src/System.IO.FileSystem/tests/Enumeration/ExampleTests.netcoreapp.cs b/src/System.IO.FileSystem/tests/Enumeration/ExampleTests.netcoreapp.cs
index 4bd6c99de7..9db4f452d1 100644
--- a/src/System.IO.FileSystem/tests/Enumeration/ExampleTests.netcoreapp.cs
+++ b/src/System.IO.FileSystem/tests/Enumeration/ExampleTests.netcoreapp.cs
@@ -4,16 +4,20 @@
 
 using System.Collections.Generic;
 using System.IO.Enumeration;
+using System.Linq;
 using Xunit;
 
 namespace System.IO.Tests.Enumeration
 {
-    // For tests that cover examples from documentation, blog posts, etc.
+    // For tests that cover examples from documentation, blog posts, etc. While these overlap with
+    // existing tests, having explicit coverage here is extra insurance we are covering the
+    // examples we've given out publicly.
     public class ExampleTests : FileSystemTest
     {
         [Fact]
         public void GetFileNamesEnumerable()
         {
+            // https://blogs.msdn.microsoft.com/jeremykuhne/2018/03/09/custom-directory-enumeration-in-net-core-2-1/
             DirectoryInfo testDirectory = Directory.CreateDirectory(GetTestFilePath());
             File.Create(Path.Join(testDirectory.FullName, "one")).Dispose();
             File.Create(Path.Join(testDirectory.FullName, "two")).Dispose();
@@ -29,5 +33,109 @@ namespace System.IO.Tests.Enumeration
 
             FSAssert.EqualWhenOrdered(new string[] { "one", "two" }, fileNames);
         }
+
+        private static IEnumerable<FileInfo> GetFilesWithExtensions(string directory,
+            bool recursive, params string[] extensions)
+        {
+            return new FileSystemEnumerable<FileInfo>(
+                directory,
+                (ref FileSystemEntry entry) => (FileInfo)entry.ToFileSystemInfo(),
+                new EnumerationOptions() { RecurseSubdirectories = recursive })
+            {
+                ShouldIncludePredicate = (ref FileSystemEntry entry) =>
+                {
+                    if (entry.IsDirectory)
+                        return false;
+                    foreach (string extension in extensions)
+                    {
+                        if (Path.GetExtension(entry.FileName).SequenceEqual(extension))
+                            return true;
+                    }
+                    return false;
+                }
+            };
+        }
+
+        [Fact]
+        public void TestGetFilesWithExtensions()
+        {
+            // https://blogs.msdn.microsoft.com/jeremykuhne/2018/03/09/custom-directory-enumeration-in-net-core-2-1/
+            DirectoryInfo testDirectory = Directory.CreateDirectory(GetTestFilePath());
+            File.Create(Path.Join(testDirectory.FullName, "file.one")).Dispose();
+            File.Create(Path.Join(testDirectory.FullName, "file.two")).Dispose();
+            File.Create(Path.Join(testDirectory.FullName, "file.three")).Dispose();
+            DirectoryInfo subDirectory = testDirectory.CreateSubdirectory("three.one");
+            File.Create(Path.Join(subDirectory.FullName, "subfile.one")).Dispose();
+
+            FSAssert.EqualWhenOrdered(
+                new string[] { "file.one", "file.three" },
+                GetFilesWithExtensions(testDirectory.FullName, false, ".one", ".three").Select(f => f.Name));
+
+            FSAssert.EqualWhenOrdered(
+                new string[] { "file.one", "file.three", "subfile.one" },
+                GetFilesWithExtensions(testDirectory.FullName, true, ".one", ".three").Select(f => f.Name));
+        }
+
+        private static int CountFiles(string directory, bool recursive)
+        {
+            return (new FileSystemEnumerable<int>(
+                directory,
+                (ref FileSystemEntry entry) => 1,
+                new EnumerationOptions() { RecurseSubdirectories = recursive })
+            {
+                ShouldIncludePredicate = (ref FileSystemEntry entry) => !entry.IsDirectory
+            }).Count();
+        }
+
+        [Fact]
+        public void TestCountFiles()
+        {
+            // https://blogs.msdn.microsoft.com/jeremykuhne/2018/03/09/custom-directory-enumeration-in-net-core-2-1/
+            DirectoryInfo testDirectory = Directory.CreateDirectory(GetTestFilePath());
+            File.Create(Path.Join(testDirectory.FullName, "file.one")).Dispose();
+            File.Create(Path.Join(testDirectory.FullName, "file.two")).Dispose();
+            File.Create(Path.Join(testDirectory.FullName, "file.three")).Dispose();
+            DirectoryInfo subDirectory = testDirectory.CreateSubdirectory("three.one");
+            File.Create(Path.Join(subDirectory.FullName, "subfile.one")).Dispose();
+
+            Assert.Equal(3, CountFiles(testDirectory.FullName, false));
+
+            Assert.Equal(4, CountFiles(testDirectory.FullName, true));
+        }
+
+        private static long CountFileBytes(string directory, bool recursive)
+        {
+            return (new FileSystemEnumerable<long>(
+                directory,
+                (ref FileSystemEntry entry) => entry.Length,
+                new EnumerationOptions() { RecurseSubdirectories = recursive })
+            {
+                ShouldIncludePredicate = (ref FileSystemEntry entry) => !entry.IsDirectory
+            }).Sum();
+        }
+
+        [Fact]
+        public void TestCountFileBytes()
+        {
+            // https://blogs.msdn.microsoft.com/jeremykuhne/2018/03/09/custom-directory-enumeration-in-net-core-2-1/
+            DirectoryInfo testDirectory = Directory.CreateDirectory(GetTestFilePath());
+            FileInfo firstFile = new FileInfo(Path.Join(testDirectory.FullName, "file.one"));
+            using (var writer = firstFile.CreateText())
+            {
+                for (int i = 0; i < 100; i++)
+                    writer.WriteLine("The quick brown fox jumped over the lazy dog.");
+            }
+
+            firstFile.CopyTo(Path.Join(testDirectory.FullName, "file.two"));
+            firstFile.CopyTo(Path.Join(testDirectory.FullName, "file.three"));
+            DirectoryInfo subDirectory = testDirectory.CreateSubdirectory("three.one");
+            firstFile.CopyTo(Path.Join(subDirectory.FullName, "subfile.one"));
+
+            firstFile.Refresh();
+            Assert.True(firstFile.Length > 0, "The file we wrote should have a length.");
+            Assert.Equal(firstFile.Length * 3, CountFileBytes(testDirectory.FullName, false));
+
+            Assert.Equal(firstFile.Length * 4, CountFileBytes(testDirectory.FullName, true));
+        }
     }
 }
diff --git a/src/System.IO.FileSystem/tests/File/Copy.cs b/src/System.IO.FileSystem/tests/File/Copy.cs
index 85f5009054..1caca2aae1 100644
--- a/src/System.IO.FileSystem/tests/File/Copy.cs
+++ b/src/System.IO.FileSystem/tests/File/Copy.cs
@@ -4,23 +4,17 @@
 
 using System.Collections.Generic;
 using System.Linq;
-using System.Runtime.InteropServices;
 using Xunit;
 
 namespace System.IO.Tests
 {
     public partial class File_Copy_str_str : FileSystemTest
     {
-        #region Utilities
-
-        public static TheoryData WindowsInvalidUnixValid = new TheoryData<string> { "         ",  };
         public virtual void Copy(string source, string dest)
         {
             File.Copy(source, dest);
         }
 
-        #endregion
-
         #region UniversalTests
 
         [Fact]
@@ -223,13 +217,43 @@ namespace System.IO.Tests
             Assert.True(File.Exists(testFile));
             Assert.True(File.Exists(Path.Combine(TestDirectory, valid)));
         }
+
+        [Theory,
+            InlineData("", ":bar"),
+            InlineData("", ":bar:$DATA"),
+            InlineData("::$DATA", ":bar"),
+            InlineData("::$DATA", ":bar:$DATA")]
+        [PlatformSpecific(TestPlatforms.Windows)]
+        [SkipOnTargetFramework(TargetFrameworkMonikers.NetFramework)]
+        public void WindowsAlternateDataStream(string defaultStream, string alternateStream)
+        {
+            DirectoryInfo testDirectory = Directory.CreateDirectory(GetTestFilePath());
+            string testFile = Path.Combine(testDirectory.FullName, GetTestFileName());
+            string testFileDefaultStream = testFile + defaultStream;
+            string testFileAlternateStream = testFile + alternateStream;
+
+            // Copy the default stream into an alternate stream
+            File.WriteAllText(testFileDefaultStream, "Foo");
+            Copy(testFileDefaultStream, testFileAlternateStream);
+            Assert.Equal(testFile, testDirectory.GetFiles().Single().FullName);
+            Assert.Equal("Foo", File.ReadAllText(testFileDefaultStream));
+            Assert.Equal("Foo", File.ReadAllText(testFileAlternateStream));
+
+            // Copy another file over the alternate stream
+            string testFile2 = Path.Combine(testDirectory.FullName, GetTestFileName());
+            string testFile2DefaultStream = testFile2 + defaultStream;
+            File.WriteAllText(testFile2DefaultStream, "Bar");
+            Assert.Throws<IOException>(() => Copy(testFile2DefaultStream, testFileAlternateStream));
+
+            // This always throws as you can't copy an alternate stream out (oddly)
+            Assert.Throws<IOException>(() => Copy(testFileAlternateStream, testFile2));
+            Assert.Throws<IOException>(() => Copy(testFileAlternateStream, testFile2 + alternateStream));
+        }
         #endregion
     }
 
     public class File_Copy_str_str_b : File_Copy_str_str
     {
-        #region Utilities
-
         public override void Copy(string source, string dest)
         {
             File.Copy(source, dest, false);
@@ -240,10 +264,6 @@ namespace System.IO.Tests
             File.Copy(source, dest, overwrite);
         }
 
-        #endregion
-
-        #region UniversalTests
-
         [Fact]
         public void OverwriteTrue()
         {
@@ -296,6 +316,38 @@ namespace System.IO.Tests
             }
         }
 
-        #endregion
+        [Theory,
+            InlineData("", ":bar"),
+            InlineData("", ":bar:$DATA"),
+            InlineData("::$DATA", ":bar"),
+            InlineData("::$DATA", ":bar:$DATA")]
+        [PlatformSpecific(TestPlatforms.Windows)]
+        [SkipOnTargetFramework(TargetFrameworkMonikers.NetFramework)]
+        public void WindowsAlternateDataStreamOverwrite(string defaultStream, string alternateStream)
+        {
+            DirectoryInfo testDirectory = Directory.CreateDirectory(GetTestFilePath());
+            string testFile = Path.Combine(testDirectory.FullName, GetTestFileName());
+            string testFileDefaultStream = testFile + defaultStream;
+            string testFileAlternateStream = testFile + alternateStream;
+
+            // Copy the default stream into an alternate stream
+            File.WriteAllText(testFileDefaultStream, "Foo");
+            Copy(testFileDefaultStream, testFileAlternateStream);
+            Assert.Equal(testFile, testDirectory.GetFiles().Single().FullName);
+            Assert.Equal("Foo", File.ReadAllText(testFileDefaultStream));
+            Assert.Equal("Foo", File.ReadAllText(testFileAlternateStream));
+
+            // Copy another file over the alternate stream
+            string testFile2 = Path.Combine(testDirectory.FullName, GetTestFileName());
+            string testFile2DefaultStream = testFile2 + defaultStream;
+            File.WriteAllText(testFile2DefaultStream, "Bar");
+            Copy(testFile2DefaultStream, testFileAlternateStream, overwrite: true);
+            Assert.Equal("Foo", File.ReadAllText(testFileDefaultStream));
+            Assert.Equal("Bar", File.ReadAllText(testFileAlternateStream));
+
+            // This always throws as you can't copy an alternate stream out (oddly)
+            Assert.Throws<IOException>(() => Copy(testFileAlternateStream, testFile2, overwrite: true));
+            Assert.Throws<IOException>(() => Copy(testFileAlternateStream, testFile2 + alternateStream, overwrite: true));
+        }
     }
 }
diff --git a/src/System.IO.FileSystem/tests/File/Create.cs b/src/System.IO.FileSystem/tests/File/Create.cs
index 604cc57cd4..c910e735b3 100644
--- a/src/System.IO.FileSystem/tests/File/Create.cs
+++ b/src/System.IO.FileSystem/tests/File/Create.cs
@@ -8,15 +8,11 @@ namespace System.IO.Tests
 {
     public class File_Create_str : FileSystemTest
     {
-        #region Utilities
-
         public virtual FileStream Create(string path)
         {
             return File.Create(path);
         }
 
-        #endregion
-
         #region UniversalTests
 
         [Fact]
@@ -283,6 +279,49 @@ namespace System.IO.Tests
             }
         }
 
+        [Theory,
+            InlineData(":bar"),
+            InlineData(":bar:$DATA"),
+            InlineData("::$DATA")]
+        [PlatformSpecific(TestPlatforms.Windows)]
+        [SkipOnTargetFramework(TargetFrameworkMonikers.NetFramework)]
+        public void WindowsAlternateDataStream(string streamName)
+        {
+            DirectoryInfo testDirectory = Directory.CreateDirectory(GetTestFilePath());
+            streamName = Path.Combine(testDirectory.FullName, GetTestFileName()) + streamName;
+            using (Create(streamName))
+            {
+                Assert.True(File.Exists(streamName));
+            }
+        }
+
+        [Theory,
+            InlineData(":bar"),
+            InlineData(":bar:$DATA")]
+        [PlatformSpecific(TestPlatforms.Windows)]
+        [SkipOnTargetFramework(TargetFrameworkMonikers.NetFramework)]
+        public void WindowsAlternateDataStream_OnExisting(string streamName)
+        {
+            DirectoryInfo testDirectory = Directory.CreateDirectory(GetTestFilePath());
+
+            // On closed file
+            string fileName = Path.Combine(testDirectory.FullName, GetTestFileName());
+            Create(fileName).Dispose();
+            streamName = fileName + streamName;
+            using (Create(streamName))
+            {
+                Assert.True(File.Exists(streamName));
+            }
+
+            // On open file
+            fileName = Path.Combine(testDirectory.FullName, GetTestFileName());
+            using (Create(fileName))
+            using (Create(streamName))
+            {
+                Assert.True(File.Exists(streamName));
+            }
+        }
+
         #endregion
     }