Validate ZstandardStream constructor arguments and prevent ArrayPool buffer leak on failure

src/libraries/System.IO.Compression/src/System/IO/Compression/Zstandard/ZstandardStream.Compress.cs

@@ -29,26 +29,46 @@ public ZstandardStream(Stream stream, CompressionLevel compressionLevel) : this(
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="compressionLevel"/> is not a valid <see cref="CompressionLevel"/> value.</exception>
         public ZstandardStream(Stream stream, CompressionLevel compressionLevel, bool leaveOpen)
         {
+            int quality = ZstandardUtils.GetQualityFromCompressionLevel(compressionLevel);
+
             Init(stream, CompressionMode.Compress);
             _mode = CompressionMode.Compress;
             _leaveOpen = leaveOpen;
 
-            _encoder = new ZstandardEncoder(ZstandardUtils.GetQualityFromCompressionLevel(compressionLevel));
+            try
+            {
+                _encoder = new ZstandardEncoder(quality);
+            }
+            catch
+            {
+                _buffer.Dispose();
+                throw;
+            }
         }
 
         /// <summary>Initializes a new instance of the <see cref="ZstandardStream" /> class by using the specified stream, options, and optionally leaves the stream open.</summary>
         /// <param name="stream">The stream to which compressed data is written or from which data to decompress is read.</param>
         /// <param name="compressionOptions">The options to use for Zstandard compression or decompression.</param>
         /// <param name="leaveOpen"><see langword="true" /> to leave the stream open after the <see cref="ZstandardStream" /> object is disposed; otherwise, <see langword="false" />.</param>
-        /// <exception cref="ArgumentNullException"><paramref name="stream"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="stream"/> or <paramref name="compressionOptions"/> is <see langword="null"/>.</exception>
         /// <exception cref="ArgumentException"><paramref name="stream"/> does not support writing.</exception>
         public ZstandardStream(Stream stream, ZstandardCompressionOptions compressionOptions, bool leaveOpen = false)
         {
+            ArgumentNullException.ThrowIfNull(compressionOptions);
+
             Init(stream, CompressionMode.Compress);
             _mode = CompressionMode.Compress;
             _leaveOpen = leaveOpen;
 
-            _encoder = new ZstandardEncoder(compressionOptions);
+            try
+            {
+                _encoder = new ZstandardEncoder(compressionOptions);
+            }
+            catch
+            {
+                _buffer.Dispose();
+                throw;
+            }
         }
 
         /// <summary>Initializes a new instance of the <see cref="ZstandardStream" /> class by using the specified stream and encoder instance.</summary>

src/libraries/System.IO.Compression/src/System/IO/Compression/Zstandard/ZstandardStream.Decompress.cs

@@ -50,7 +50,15 @@ public ZstandardStream(Stream stream, ZstandardDecompressionOptions decompressio
             _mode = CompressionMode.Decompress;
             _leaveOpen = leaveOpen;
 
-            _decoder = new ZstandardDecoder(decompressionOptions);
+            try
+            {
+                _decoder = new ZstandardDecoder(decompressionOptions);
+            }
+            catch
+            {
+                _buffer.Dispose();
+                throw;
+            }
         }
 
         // Decompresses buffered input for the current frame only. Returns true when there is a result for

src/libraries/System.IO.Compression/src/System/IO/Compression/Zstandard/ZstandardStream.cs

@@ -66,13 +66,21 @@ public ZstandardStream(Stream stream, CompressionMode mode, bool leaveOpen)
             _leaveOpen = leaveOpen;
             _mode = mode;
 
-            if (mode == CompressionMode.Compress)
+            try
             {
-                _encoder = new ZstandardEncoder();
+                if (mode == CompressionMode.Compress)
+                {
+                    _encoder = new ZstandardEncoder();
+                }
+                else
+                {
+                    _decoder = new ZstandardDecoder();
+                }
             }
-            else
+            catch
             {
-                _decoder = new ZstandardDecoder();
+                _buffer.Dispose();
+                throw;
             }
         }
 
@@ -98,13 +106,21 @@ public ZstandardStream(Stream stream, CompressionMode mode, ZstandardDictionary
             _mode = mode;
             _leaveOpen = leaveOpen;
 
-            if (mode == CompressionMode.Compress)
+            try
             {
-                _encoder = new ZstandardEncoder(dictionary);
+                if (mode == CompressionMode.Compress)
+                {
+                    _encoder = new ZstandardEncoder(dictionary);
+                }
+                else
+                {
+                    _decoder = new ZstandardDecoder(dictionary);
+                }
             }
-            else
+            catch
             {
-                _decoder = new ZstandardDecoder(dictionary);
+                _buffer.Dispose();
+                throw;
             }
         }
 

src/libraries/System.IO.Compression/tests/Zstandard/CompressionStreamUnitTests.Zstandard.cs

@@ -310,6 +310,21 @@ public void ZstandardStream_WithDecompressionOptions_NullOptions_ThrowsArgumentN
             Assert.Throws<ArgumentNullException>("decompressionOptions", () => new ZstandardStream(input, (ZstandardDecompressionOptions)null!));
         }
 
+        [Fact]
+        public void ZstandardStream_WithCompressionOptions_NullOptions_ThrowsArgumentNullException()
+        {
+            using MemoryStream output = new();
+            Assert.Throws<ArgumentNullException>("compressionOptions", () => new ZstandardStream(output, (ZstandardCompressionOptions)null!));
+        }
+
+        [Fact]
+        public void ZstandardStream_InvalidCompressionLevel_ThrowsArgumentOutOfRangeException()
+        {
+            using MemoryStream output = new();
+            Assert.Throws<ArgumentOutOfRangeException>("compressionLevel", () => new ZstandardStream(output, (CompressionLevel)999));
+            Assert.Throws<ArgumentOutOfRangeException>("compressionLevel", () => new ZstandardStream(output, (CompressionLevel)999, leaveOpen: true));
+        }
+
         [Theory]
         [InlineData(false)]
         [InlineData(true)]