tests: ZipFileExtensions async

Author: carlossanlop

src/libraries/System.IO.Compression.ZipFile/tests/ZipFileExtensions.ZipArchive.Create.cs

@@ -1,37 +1,49 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System;
+using System.Collections.Generic;
 using System.Threading.Tasks;
 using Xunit;
 
 namespace System.IO.Compression.Tests
 {
     public class ZipFile_ZipArchive_Create : ZipFileTestBase
     {
+        public static IEnumerable<object[]> Get_CreateEntryFromFileExtension_Data()
+        {
+            foreach (bool withCompressionLevel in _bools)
+            {
+                foreach (bool async in _bools)
+                {
+                    yield return new object[] { withCompressionLevel, async };
+                }
+            }
+        }
+
         [Theory]
-        [InlineData(true)]
-        [InlineData(false)]
-        public async Task CreateEntryFromFileExtension(bool withCompressionLevel)
+        [MemberData(nameof(Get_CreateEntryFromFileExtension_Data))]
+        public async Task CreateEntryFromFileExtension(bool withCompressionLevel, bool async)
         {
             //add file
             using (TempFile testArchive = CreateTempCopyFile(zfile("normal.zip"), GetTestFilePath()))
             {
-                using (ZipArchive archive = ZipFile.Open(testArchive.Path, ZipArchiveMode.Update))
-                {
+                ZipArchive archive = await CallZipFileOpen(async, testArchive.Path, ZipArchiveMode.Update);
+
                     string entryName = "added.txt";
                     string sourceFilePath = zmodified(Path.Combine("addFile", entryName));
 
-                    Assert.Throws<ArgumentNullException>(() => ((ZipArchive)null).CreateEntryFromFile(sourceFilePath, entryName));
-                    Assert.Throws<ArgumentNullException>(() => archive.CreateEntryFromFile(null, entryName));
-                    Assert.Throws<ArgumentNullException>(() => archive.CreateEntryFromFile(sourceFilePath, null));
+                    await Assert.ThrowsAsync<ArgumentNullException>(() => CallZipFileExtensionsCreateEntryFromFile(async, (ZipArchive)null, sourceFilePath, entryName));
+                    await Assert.ThrowsAsync<ArgumentNullException>(() => CallZipFileExtensionsCreateEntryFromFile(async, archive, null, entryName));
+                    await Assert.ThrowsAsync<ArgumentNullException>(() => CallZipFileExtensionsCreateEntryFromFile(async, archive, sourceFilePath, null));
 
                     ZipArchiveEntry e = withCompressionLevel ?
-                        archive.CreateEntryFromFile(sourceFilePath, entryName) :
-                        archive.CreateEntryFromFile(sourceFilePath, entryName, CompressionLevel.Fastest);
+                        await CallZipFileExtensionsCreateEntryFromFile(async, archive, sourceFilePath, entryName) :
+                        await CallZipFileExtensionsCreateEntryFromFile(async, archive, sourceFilePath, entryName, CompressionLevel.Fastest);
                     Assert.NotNull(e);
-                }
-                await IsZipSameAsDirAsync(testArchive.Path, zmodified("addFile"), ZipArchiveMode.Read, requireExplicit: false, checkTimes: false);
+
+                await DisposeZipArchive(async, archive);
+
+                await IsZipSameAsDir(testArchive.Path, zmodified("addFile"), ZipArchiveMode.Read, requireExplicit: false, checkTimes: false, async);
             }
         }
     }

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

@@ -1,36 +1,42 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Threading.Tasks;
 using Xunit;
 
 namespace System.IO.Compression.Tests
 {
     public class ZipFile_ZipArchive_Extract : ZipFileTestBase
     {
-        [Fact]
-        public void ExtractToDirectoryExtension()
+        [Theory]
+        [MemberData(nameof(Get_Booleans_Data))]
+        public async Task ExtractToDirectoryExtension(bool async)
         {
-            using (ZipArchive archive = ZipFile.Open(zfile("normal.zip"), ZipArchiveMode.Read))
-            {
-                string tempFolder = GetTestFilePath();
-                Assert.Throws<ArgumentNullException>(() => ((ZipArchive)null).ExtractToDirectory(tempFolder));
-                Assert.Throws<ArgumentNullException>(() => archive.ExtractToDirectory(null));
-                archive.ExtractToDirectory(tempFolder);
-
-                DirsEqual(tempFolder, zfolder("normal"));
-            }
+            ZipArchive archive = await CallZipFileOpen(async, zfile("normal.zip"), ZipArchiveMode.Read);
+
+            string tempFolder = GetTestFilePath();
+            await Assert.ThrowsAsync<ArgumentNullException>(() => CallZipFileExtensionsExtractToDirectory(async, (ZipArchive)null, tempFolder));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => CallZipFileExtensionsExtractToDirectory(async, archive, null));
+            await CallZipFileExtensionsExtractToDirectory(async, archive, tempFolder);
+
+            DirsEqual(tempFolder, zfolder("normal"));
+
+            await DisposeZipArchive(async, archive);
         }
 
-        [Fact]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/72951", TestPlatforms.iOS | TestPlatforms.tvOS)]
-        public void ExtractToDirectoryExtension_Unicode()
+        [Theory]
+        [MemberData(nameof(Get_Booleans_Data))]
+        public async Task ExtractToDirectoryExtension_Unicode(bool async)
         {
-            using (ZipArchive archive = ZipFile.OpenRead(zfile("unicode.zip")))
-            {
-                string tempFolder = GetTestFilePath();
-                archive.ExtractToDirectory(tempFolder);
-                DirFileNamesEqual(tempFolder, zfolder("unicode"));
-            }
+            ZipArchive archive = await CallZipFileOpenRead(async, zfile("unicode.zip"));
+
+            string tempFolder = GetTestFilePath();
+            await CallZipFileExtensionsExtractToDirectory(async, archive, tempFolder);
+            DirFileNamesEqual(tempFolder, zfolder("unicode"));
+
+            await DisposeZipArchive(async, archive);
+
         }
 
     }

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

@@ -1,45 +1,51 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Threading.Tasks;
 using Xunit;
 
 namespace System.IO.Compression.Tests
 {
     public class ZipFile_ZipArchiveEntry_Extract : ZipFileTestBase
     {
-        [Fact]
-        public void ExtractToFileExtension()
+        [Theory]
+        [MemberData(nameof(Get_Booleans_Data))]
+        public async Task ExtractToFileExtension(bool async)
         {
-            using (ZipArchive archive = ZipFile.Open(zfile("normal.zip"), ZipArchiveMode.Read))
-            {
-                string file = GetTestFilePath();
-                ZipArchiveEntry e = archive.GetEntry("first.txt");
+            ZipArchive archive = await CallZipFileOpen(async, zfile("normal.zip"), ZipArchiveMode.Read);
+
+            string file = GetTestFilePath();
+            ZipArchiveEntry e = archive.GetEntry("first.txt");
 
-                Assert.Throws<ArgumentNullException>(() => ((ZipArchiveEntry)null).ExtractToFile(file));
-                Assert.Throws<ArgumentNullException>(() => e.ExtractToFile(null));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => CallExtractToFile(async, (ZipArchiveEntry)null, file));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => CallExtractToFile(async, e, null));
 
-                //extract when there is nothing there
-                e.ExtractToFile(file);
+            //extract when there is nothing there
+            await CallExtractToFile(async, e, file);
 
-                using (Stream fs = File.Open(file, FileMode.Open), es = e.Open())
-                {
-                    StreamsEqual(fs, es);
-                }
+            using (Stream fs = File.Open(file, FileMode.Open))
+            {
+                Stream es = await OpenEntryStream(async, e);
+                StreamsEqual(fs, es);
+                await DisposeStream(async, es);
+            }
 
-                Assert.Throws<IOException>(() => e.ExtractToFile(file, false));
+            await Assert.ThrowsAsync<IOException>(() => CallExtractToFile(async, e, file, false));
 
-                //truncate file
-                using (Stream fs = File.Open(file, FileMode.Truncate))
-                { }
+            //truncate file
+            using (Stream fs = File.Open(file, FileMode.Truncate)) { }
 
-                //now use overwrite mode
-                e.ExtractToFile(file, true);
+            //now use overwrite mode
+            await CallExtractToFile(async, e, file, true);
 
-                using (Stream fs = File.Open(file, FileMode.Open), es = e.Open())
-                {
-                    StreamsEqual(fs, es);
-                }
+            using (Stream fs = File.Open(file, FileMode.Open))
+            {
+                Stream es = await OpenEntryStream(async, e);
+                StreamsEqual(fs, es);
+                await DisposeStream(async, es);
             }
+
+            await DisposeZipArchive(async, archive);
         }
     }
 }