tests: Revert the unix umask async code because of error: Field marshaling is not supported by Invoke: async.

Split the ExtractOutOfRoot tests into two separate tests.

Author: carlossanlop

src/libraries/Common/tests/System/IO/Compression/ZipTestHelper.ZipFile.cs

@@ -265,15 +265,6 @@ protected static Task CallZipFileExtensionsExtractToDirectory(bool async, ZipArc
         }
     }
 
-    public static IEnumerable<object[]> Get_ExtractOutOfRoot_Data()
-    {
-        foreach (bool async in _bools)
-        {
-            yield return new object[] { "../Foo", async };
-            yield return new object[] { "../Barbell", async };
-        }
-    }
-
     public static IEnumerable<object[]> Get_Unix_ZipWithInvalidFileNames_Data()
     {
         foreach (bool async in _bools)

src/libraries/System.IO.Compression.ZipFile/tests/ZipFile.Extract.Stream.cs

@@ -91,19 +91,35 @@ public async Task ExtractToDirectoryUnicode(bool async)
     }
 
     [Theory]
-    [MemberData(nameof(Get_ExtractOutOfRoot_Data))]
-    public async Task ExtractOutOfRoot(string entryName, bool async)
+    [InlineData("../Foo")]
+    [InlineData("../Barbell")]
+    public void ExtractOutOfRoot(string entryName)
     {
-        FileStream source = new(GetTestFilePath(), FileMode.Create, FileAccess.ReadWrite, FileShare.Read, bufferSize: 4096, useAsync: async);
+        using FileStream source = new(GetTestFilePath(), FileMode.Create, FileAccess.ReadWrite);
+        using (ZipArchive archive = new(source, ZipArchiveMode.Create, leaveOpen: true))
+        {
+            ZipArchiveEntry entry = archive.CreateEntry(entryName);
+        }
 
-        ZipArchive archive = await CreateZipArchive(async, source, ZipArchiveMode.Create, leaveOpen: true, entryNameEncoding: null);
-        ZipArchiveEntry entry = archive.CreateEntry(entryName);
-        await DisposeZipArchive(async, archive);
+        DirectoryInfo destination = Directory.CreateDirectory(Path.Combine(GetTestFilePath(), "Bar"));
+        source.Position = 0;
+        Assert.Throws<IOException>(() => ZipFile.ExtractToDirectory(source, destination.FullName));
+    }
+
+    [Theory]
+    [InlineData("../Foo")]
+    [InlineData("../Barbell")]
+    public async Task ExtractOutOfRoot_Async(string entryName)
+    {
+        using FileStream source = new(GetTestFilePath(), FileMode.Create, FileAccess.ReadWrite);
+        await using (ZipArchive archive = await ZipArchive.CreateAsync(source, ZipArchiveMode.Create, leaveOpen: true, entryNameEncoding: null))
+        {
+            ZipArchiveEntry entry = archive.CreateEntry(entryName);
+        }
 
         DirectoryInfo destination = Directory.CreateDirectory(Path.Combine(GetTestFilePath(), "Bar"));
         source.Position = 0;
-        await Assert.ThrowsAsync<IOException>(() => CallZipFileExtractToDirectory(async, source, destination.FullName));
-        await DisposeStream(async, source);
+        await Assert.ThrowsAsync<IOException>(() => ZipFile.ExtractToDirectoryAsync(source, destination.FullName));
     }
 
     /// <summary>

src/libraries/System.IO.Compression.ZipFile/tests/ZipFile.Extract.cs

@@ -56,20 +56,37 @@ public async Task ExtractToDirectoryUnicode(bool async)
             }
         }
 
+
         [Theory]
-        [MemberData(nameof(Get_ExtractOutOfRoot_Data))]
-        public async Task ExtractOutOfRoot(string entryName, bool async)
+        [InlineData("../Foo")]
+        [InlineData("../Barbell")]
+        public void ExtractOutOfRoot(string entryName)
         {
             string archivePath = GetTestFilePath();
             using (FileStream stream = new FileStream(archivePath, FileMode.Create))
+            using (ZipArchive archive = new ZipArchive(stream, ZipArchiveMode.Create, leaveOpen: true))
             {
-                ZipArchive archive = await CreateZipArchive(async, stream, ZipArchiveMode.Create, leaveOpen: true, entryNameEncoding: null);
                 ZipArchiveEntry entry = archive.CreateEntry(entryName);
-                await DisposeZipArchive(async, archive);
+            }
+
+            DirectoryInfo destination = Directory.CreateDirectory(Path.Combine(GetTestFilePath(), "Bar"));
+            Assert.Throws<IOException>(() => ZipFile.ExtractToDirectory(archivePath, destination.FullName));
+        }
 
-                DirectoryInfo destination = Directory.CreateDirectory(Path.Combine(GetTestFilePath(), "Bar"));
-                await Assert.ThrowsAsync<IOException>(() => CallZipFileExtractToDirectory(async, archivePath, destination.FullName));
+        [Theory]
+        [InlineData("../Foo")]
+        [InlineData("../Barbell")]
+        public async Task ExtractOutOfRoot_Async(string entryName)
+        {
+            string archivePath = GetTestFilePath();
+            using (FileStream stream = new FileStream(archivePath, FileMode.Create))
+            await using (ZipArchive archive = await ZipArchive.CreateAsync(stream, ZipArchiveMode.Create, leaveOpen: true, entryNameEncoding: null))
+            {
+                ZipArchiveEntry entry = archive.CreateEntry(entryName);
             }
+
+            DirectoryInfo destination = Directory.CreateDirectory(Path.Combine(GetTestFilePath(), "Bar"));
+            await Assert.ThrowsAsync<IOException>(() => ZipFile.ExtractToDirectoryAsync(archivePath, destination.FullName));
         }
 
         /// <summary>

src/libraries/System.IO.Compression.ZipFile/tests/ZipFile.Unix.cs

@@ -14,9 +14,8 @@ namespace System.IO.Compression.Tests
 {
     public partial class ZipFile_Unix : ZipFileTestBase
     {
-        [Theory]
-        [MemberData(nameof(Get_Booleans_Data))]
-        public async Task UnixCreateSetsPermissionsInExternalAttributes(bool async)
+        [Fact]
+        public void UnixCreateSetsPermissionsInExternalAttributes()
         {
             // '7600' tests that S_ISUID, S_ISGID, and S_ISVTX bits get preserved in ExternalAttributes
             string[] testPermissions = new[] { "777", "755", "644", "600", "7600" };
@@ -26,29 +25,28 @@ public async Task UnixCreateSetsPermissionsInExternalAttributes(bool async)
                 string[] expectedPermissions = CreateFiles(tempFolder.Path, testPermissions);
 
                 string archivePath = GetTestFilePath();
-                await CallZipFileCreateFromDirectory(async, tempFolder.Path, archivePath);
-
-                ZipArchive archive = await CallZipFileOpenRead(async, archivePath);
+                ZipFile.CreateFromDirectory(tempFolder.Path, archivePath);
 
-                Assert.Equal(expectedPermissions.Length, archive.Entries.Count);
-
-                foreach (ZipArchiveEntry entry in archive.Entries)
+                using (ZipArchive archive = ZipFile.OpenRead(archivePath))
                 {
-                    Assert.EndsWith(".txt", entry.Name, StringComparison.Ordinal);
-                    EnsureExternalAttributes(entry.Name.Substring(0, entry.Name.Length - 4), entry);
-                }
+                    Assert.Equal(expectedPermissions.Length, archive.Entries.Count);
 
-                void EnsureExternalAttributes(string permissions, ZipArchiveEntry entry)
-                {
-                    Assert.Equal(Convert.ToInt32(permissions, 8), (entry.ExternalAttributes >> 16) & 0xFFF);
-                }
+                    foreach (ZipArchiveEntry entry in archive.Entries)
+                    {
+                        Assert.EndsWith(".txt", entry.Name, StringComparison.Ordinal);
+                        EnsureExternalAttributes(entry.Name.Substring(0, entry.Name.Length - 4), entry);
+                    }
 
-                await DisposeZipArchive(async, archive);
+                    void EnsureExternalAttributes(string permissions, ZipArchiveEntry entry)
+                    {
+                        Assert.Equal(Convert.ToInt32(permissions, 8), (entry.ExternalAttributes >> 16) & 0xFFF);
+                    }
+                }
 
                 // test that round tripping the archive has the same file permissions
                 using (var extractFolder = new TempDirectory(Path.Combine(GetTestFilePath(), "extract")))
                 {
-                    await CallZipFileExtractToDirectory(async, archivePath, extractFolder.Path);
+                    ZipFile.ExtractToDirectory(archivePath, extractFolder.Path);
 
                     foreach (string permission in expectedPermissions)
                     {
@@ -61,72 +59,57 @@ void EnsureExternalAttributes(string permissions, ZipArchiveEntry entry)
             }
         }
 
-        [ConditionalTheory(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
-        [MemberData(nameof(Get_Booleans_Data))]
-        public void UnixCreateSetsPermissionsInExternalAttributesUMaskZero(bool async)
+        [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
+        public void UnixCreateSetsPermissionsInExternalAttributesUMaskZero()
         {
-            RemoteExecutor.Invoke(async () =>
+            RemoteExecutor.Invoke(() =>
             {
                 umask(0);
-                await new ZipFile_Unix().UnixCreateSetsPermissionsInExternalAttributes(async);
+                new ZipFile_Unix().UnixCreateSetsPermissionsInExternalAttributes();
             }).Dispose();
         }
 
-        [Theory]
-        [MemberData(nameof(Get_Booleans_Data))]
-        public async Task UnixExtractSetsFilePermissionsFromExternalAttributes(bool async)
+        [Fact]
+        public void UnixExtractSetsFilePermissionsFromExternalAttributes()
         {
             // '7600' tests that S_ISUID, S_ISGID, and S_ISVTX bits don't get extracted to file permissions
             string[] testPermissions = new[] { "777", "755", "644", "754", "7600" };
 
             string archivePath = GetTestFilePath();
             using (FileStream fileStream = new FileStream(archivePath, FileMode.CreateNew))
+            using (ZipArchive archive = new ZipArchive(fileStream, ZipArchiveMode.Create))
             {
-                ZipArchive archive = await CreateZipArchive(async, fileStream, ZipArchiveMode.Create);
-
                 foreach (string permission in testPermissions)
                 {
                     ZipArchiveEntry entry = archive.CreateEntry(permission + ".txt");
                     entry.ExternalAttributes = Convert.ToInt32(permission, 8) << 16;
-                    Stream stream = await OpenEntryStream(async, entry);
-                    ReadOnlySpan<byte> contents = "contents"u8;
-                    if (async)
-                    {
-                        await stream.WriteAsync(contents.ToArray());
-                    }
-                    else
-                    {
-                        stream.Write(contents);
-                    }
+                    using Stream stream = entry.Open();
+                    stream.Write("contents"u8);
                     stream.Flush();
-                    await DisposeStream(async, stream);
                 }
+            }
 
-                await DisposeZipArchive(async, archive);
+            using (var tempFolder = new TempDirectory(GetTestFilePath()))
+            {
+                ZipFile.ExtractToDirectory(archivePath, tempFolder.Path);
 
-                using (var tempFolder = new TempDirectory(GetTestFilePath()))
+                foreach (string permission in testPermissions)
                 {
-                    await CallZipFileExtractToDirectory(async, archivePath, tempFolder.Path);
-
-                    foreach (string permission in testPermissions)
-                    {
-                        string filename = Path.Combine(tempFolder.Path, permission + ".txt");
-                        Assert.True(File.Exists(filename));
+                    string filename = Path.Combine(tempFolder.Path, permission + ".txt");
+                    Assert.True(File.Exists(filename));
 
-                        EnsureFilePermissions(filename, permission);
-                    }
+                    EnsureFilePermissions(filename, permission);
                 }
             }
         }
 
-        [ConditionalTheory(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
-        [MemberData(nameof(Get_Booleans_Data))]
-        public void UnixExtractSetsFilePermissionsFromExternalAttributesUMaskZero(bool async)
+        [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
+        public void UnixExtractSetsFilePermissionsFromExternalAttributesUMaskZero()
         {
-            RemoteExecutor.Invoke(async () =>
+            RemoteExecutor.Invoke(() =>
             {
                 umask(0);
-                await new ZipFile_Unix().UnixExtractSetsFilePermissionsFromExternalAttributes(async);
+                new ZipFile_Unix().UnixExtractSetsFilePermissionsFromExternalAttributes();
             }).Dispose();
         }