[release/6.0] Don't create multiple large files at the same time (#63032)

* Move NoInt32OverflowInTheBufferingLogic to OuterLoop and address pending feedback (#60606)

* Don't create multiple large files at the same time (#62519)

* move existing large file tests into a separate type (no code changes)

* don't run the large file tests in parallel

* use FileOptions.DeleteOnClose to ensure that each test removes it's own file

use single large file to test File.ReadAllBytes and ile.ReadAllBytesAsync for both limits

* Fix DisableParallelization build issue

* Apply suggestions from code review

Co-authored-by: Adam Sitnik <[email protected]>

* Update src/libraries/System.IO.FileSystem/tests/LargeFileTests.cs

Co-authored-by: Adam Sitnik <[email protected]>

* Notepad with uppercase (#62487)

Co-authored-by: Adam Sitnik <[email protected]>
Co-authored-by: Dan Moseley <[email protected]>

Author: 3 people

src/libraries/System.Diagnostics.Process/tests/ProcessStartInfoTests.cs

@@ -1318,7 +1318,7 @@ private void VerifyNotepadMainWindowTitle(Process process, string filename)
             string expected = Path.GetFileNameWithoutExtension(filename);
 
             process.WaitForInputIdle(); // Give the file a chance to load
-            Assert.Equal("notepad", process.ProcessName);
+            Assert.Equal("notepad", process.ProcessName.ToLower());
 
             // Notepad calls CreateWindowEx with pWindowName of empty string, then calls SetWindowTextW
             // with "Untitled - Notepad" then finally if you're opening a file, calls SetWindowTextW

src/libraries/System.Diagnostics.Process/tests/ProcessTests.cs

@@ -267,11 +267,16 @@ public void ProcessStart_UseShellExecute_OnWindows_DoesNotThrow(bool isFolder)
                 {
                     if (px != null) // sometimes process is null
                     {
-                        Assert.Equal("notepad", px.ProcessName);
-
-                        px.Kill();
-                        Assert.True(px.WaitForExit(WaitInMS));
-                        px.WaitForExit(); // wait for event handlers to complete
+                        try
+                        {
+                            Assert.Equal("notepad", px.ProcessName.ToLower());
+                        }
+                        finally
+                        {
+                            px.Kill();
+                            Assert.True(px.WaitForExit(WaitInMS));
+                            px.WaitForExit(); // wait for event handlers to complete
+                        }
                     }
                 }
             }

src/libraries/System.IO.FileSystem/tests/File/ReadWriteAllBytes.cs

@@ -57,21 +57,6 @@ public void ValidWrite(int size)
             File.Delete(path);
         }
 
-        [Fact]
-        [OuterLoop]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/45954", TestPlatforms.Browser)]
-        public void ReadFileOver2GB()
-        {
-            string path = GetTestFilePath();
-            using (FileStream fs = File.Create(path))
-            {
-                fs.SetLength(int.MaxValue + 1L);
-            }
-
-            // File is too large for ReadAllBytes at once
-            Assert.Throws<IOException>(() => File.ReadAllBytes(path));
-        }
-
         [Fact]
         public void Overwrite()
         {

src/libraries/System.IO.FileSystem/tests/File/ReadWriteAllBytesAsync.cs

@@ -6,7 +6,6 @@
 using System.Threading.Tasks;
 using Xunit;
 using System.IO.Pipes;
-using Microsoft.DotNet.XUnitExtensions;
 
 namespace System.IO.Tests
 {
@@ -70,21 +69,6 @@ public Task AlreadyCanceledAsync()
                 async () => await File.WriteAllBytesAsync(path, new byte[0], token));
         }
 
-        [Fact]
-        [OuterLoop]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/45954", TestPlatforms.Browser)]
-        public Task ReadFileOver2GBAsync()
-        {
-            string path = GetTestFilePath();
-            using (FileStream fs = File.Create(path))
-            {
-                fs.SetLength(int.MaxValue + 1L);
-            }
-
-            // File is too large for ReadAllBytes at once
-            return Assert.ThrowsAsync<IOException>(async () => await File.ReadAllBytesAsync(path));
-        }
-
         [Fact]
         public async Task OverwriteAsync()
         {

src/libraries/System.IO.FileSystem/tests/FileStream/Read.cs

@@ -14,49 +14,5 @@ public void NegativeReadRootThrows()
             Assert.Throws<UnauthorizedAccessException>(() =>
                 new FileStream(Path.GetPathRoot(Directory.GetCurrentDirectory()), FileMode.Open, FileAccess.Read));
         }
-
-        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.Is64BitProcess))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/45954", TestPlatforms.Browser)]
-        public void NoInt32OverflowInTheBufferingLogic()
-        {
-            const long position1 = 10;
-            const long position2 = (1L << 32) + position1;
-
-            string filePath = GetTestFilePath();
-            byte[] data1 = new byte[] { 1, 2, 3, 4, 5 };
-            byte[] data2 = new byte[] { 6, 7, 8, 9, 10 };
-            byte[] buffer = new byte[5];
-
-            using (var stream = new FileStream(filePath, FileMode.Create, FileAccess.Write))
-            {
-                stream.Seek(position1, SeekOrigin.Begin);
-                stream.Write(data1, 0, data1.Length);
-
-                stream.Seek(position2, SeekOrigin.Begin);
-                stream.Write(data2, 0, data2.Length);
-            }
-
-            using (var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read))
-            {
-                stream.Seek(position1, SeekOrigin.Begin);
-                Assert.Equal(buffer.Length, stream.Read(buffer));
-                Assert.Equal(data1, buffer);
-
-                stream.Seek(position2, SeekOrigin.Begin);
-                Assert.Equal(buffer.Length, stream.Read(buffer));
-                Assert.Equal(data2, buffer);
-            }
-
-            using (var stream = new BufferedStream(new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.None, bufferSize: 0)))
-            {
-                stream.Seek(position1, SeekOrigin.Begin);
-                Assert.Equal(buffer.Length, stream.Read(buffer));
-                Assert.Equal(data1, buffer);
-
-                stream.Seek(position2, SeekOrigin.Begin);
-                Assert.Equal(buffer.Length, stream.Read(buffer));
-                Assert.Equal(data2, buffer);
-            }
-        }
     }
 }

src/libraries/System.IO.FileSystem/tests/LargeFileTests.cs

@@ -0,0 +1,64 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.IO.Tests;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace System.IO.FileSystem.Tests
+{
+    [OuterLoop]
+    [ActiveIssue("https://github.com/dotnet/runtime/issues/45954", TestPlatforms.Browser)]
+    [Collection(nameof(NoParallelTests))] // don't create multiple large files at the same time
+    public class LargeFileTests : FileSystemTest
+    {
+        [Fact]
+        public async Task ReadAllBytesOverLimit()
+        {
+            using FileStream fs = new (GetTestFilePath(), FileMode.Create, FileAccess.Write, FileShare.Read, 4096, FileOptions.DeleteOnClose);
+
+            foreach (long lengthOverLimit in new long[] { int.MaxValue + 1L })
+            {
+                fs.SetLength(lengthOverLimit);
+
+                Assert.Throws<IOException>(() => File.ReadAllBytes(fs.Name));
+                await Assert.ThrowsAsync<IOException>(async () => await File.ReadAllBytesAsync(fs.Name));
+            }
+        }
+
+        [Fact]
+        public void NoInt32OverflowInTheBufferingLogic()
+        {
+            const long position1 = 10;
+            const long position2 = (1L << 32) + position1;
+
+            string filePath = GetTestFilePath();
+            byte[] data1 = new byte[] { 1, 2, 3, 4, 5 };
+            byte[] data2 = new byte[] { 6, 7, 8, 9, 10 };
+            byte[] buffer = new byte[5];
+
+            using (FileStream stream = File.Create(filePath))
+            {
+                stream.Seek(position1, SeekOrigin.Begin);
+                stream.Write(data1);
+
+                stream.Seek(position2, SeekOrigin.Begin);
+                stream.Write(data2);
+            }
+
+            using (FileStream stream = new (filePath, FileMode.Open, FileAccess.Read, FileShare.None, 4096, FileOptions.DeleteOnClose))
+            {
+                stream.Seek(position1, SeekOrigin.Begin);
+                Assert.Equal(buffer.Length, stream.Read(buffer));
+                Assert.Equal(data1, buffer);
+
+                stream.Seek(position2, SeekOrigin.Begin);
+                Assert.Equal(buffer.Length, stream.Read(buffer));
+                Assert.Equal(data2, buffer);
+            }
+        }
+    }
+
+    [CollectionDefinition(nameof(NoParallelTests), DisableParallelization = true)]
+    public partial class NoParallelTests { }
+}

src/libraries/System.IO.FileSystem/tests/System.IO.FileSystem.Tests.csproj

@@ -55,6 +55,7 @@
     <Compile Include="Enumeration\ExampleTests.cs" />
     <Compile Include="Enumeration\RemovedDirectoryTests.cs" />
     <Compile Include="Enumeration\SymbolicLinksTests.cs" />
+    <Compile Include="LargeFileTests.cs" />
     <Compile Include="PathInternalTests.cs" />
     <Compile Include="RandomAccess\Base.cs" />
     <Compile Include="RandomAccess\GetLength.cs" />

src/libraries/System.IO/tests/BufferedStream/BufferedStreamTests.cs

@@ -323,6 +323,40 @@ public async Task CopyToTest_ReadBeforeCopy_CopiesAllData(bool copyAsynchronousl
             Array.Copy(data, 1, expected, 0, expected.Length);
             Assert.Equal(expected, dst.ToArray());
         }
+
+        [Fact]
+        [OuterLoop]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/45954", TestPlatforms.Browser)]
+        public void NoInt32OverflowInTheBufferingLogic()
+        {
+            const long position1 = 10;
+            const long position2 = (1L << 32) + position1;
+
+            string filePath = Path.GetTempFileName();
+            byte[] data1 = new byte[] { 1, 2, 3, 4, 5 };
+            byte[] data2 = new byte[] { 6, 7, 8, 9, 10 };
+            byte[] buffer = new byte[5];
+
+            using (var stream = new FileStream(filePath, FileMode.Create, FileAccess.Write))
+            {
+                stream.Seek(position1, SeekOrigin.Begin);
+                stream.Write(data1);
+
+                stream.Seek(position2, SeekOrigin.Begin);
+                stream.Write(data2);
+            }
+
+            using (var stream = new BufferedStream(new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.None, bufferSize: 0, FileOptions.DeleteOnClose)))
+            {
+                stream.Seek(position1, SeekOrigin.Begin);
+                Assert.Equal(buffer.Length, stream.Read(buffer));
+                Assert.Equal(data1, buffer);
+
+                stream.Seek(position2, SeekOrigin.Begin);
+                Assert.Equal(buffer.Length, stream.Read(buffer));
+                Assert.Equal(data2, buffer);
+            }
+        }
     }
 
     public class BufferedStream_TestLeaveOpen : TestLeaveOpen