gh-132983: Split _zstd_set_c_parameters

Lib/compression/zstd/_zstdfile.py

@@ -1,7 +1,6 @@
 import io
 from os import PathLike
-from _zstd import (ZstdCompressor, ZstdDecompressor, ZstdError,
-                   ZSTD_DStreamOutSize)
+from _zstd import ZstdCompressor, ZstdDecompressor, ZSTD_DStreamOutSize
 from compression._common import _streams
 
 __all__ = ('ZstdFile', 'open')

Lib/test/test_zstd.py

@@ -195,10 +195,34 @@ def test_simple_compress_bad_args(self):
         self.assertRaises(TypeError, ZstdCompressor, zstd_dict=b"abcd1234")
         self.assertRaises(TypeError, ZstdCompressor, zstd_dict={1: 2, 3: 4})
 
-        with self.assertRaises(ValueError):
+        # valid compression level range is [-(1<<17), 22]
+        with self.assertRaises(ValueError) as cm:
+            ZstdCompressor(23)
+        self.assertEqual(
+            str(cm.exception),
+            '23 not in valid range -131072 <= compression level <= 22.',
+        )
+        with self.assertRaises(ValueError) as cm:
+            ZstdCompressor(-(1<<17)-1)
+        self.assertEqual(-(1<<17)-1, -131073)
+        self.assertEqual(
+            str(cm.exception),
+            '-131073 not in valid range -131072 <= compression level <= 22.',
+        )
+        with self.assertRaises(ValueError) as cm:
             ZstdCompressor(2**31)
+        self.assertEqual(
+            str(cm.exception),
+            'compression level not in valid range -131072 <= level <= 22.',
+        )
+        with self.assertRaises(ValueError) as cm:
+            ZstdCompressor(level=-(2**1000))
+        self.assertEqual(
+            str(cm.exception),
+            'compression level not in valid range -131072 <= level <= 22.',
+        )
         with self.assertRaises(ValueError):
-            ZstdCompressor(options={2**31: 100})
+            ZstdCompressor(level=(2**1000))
 
         with self.assertRaises(ZstdError):
             ZstdCompressor(options={CompressionParameter.window_log: 100})
@@ -253,18 +277,32 @@ def test_compress_parameters(self):
              }
         ZstdCompressor(options=d)
 
-        # larger than signed int, ValueError
         d1 = d.copy()
+        # larger than signed int
         d1[CompressionParameter.ldm_bucket_size_log] = 2**31
-        self.assertRaises(ValueError, ZstdCompressor, options=d1)
-
-        # clamp compressionLevel
+        with self.assertRaises(OverflowError):
+            ZstdCompressor(options=d1)
+        # smaller than signed int
+        d1[CompressionParameter.ldm_bucket_size_log] = -(2**31)-1
+        with self.assertRaises(OverflowError):
+            ZstdCompressor(options=d1)
+
+        # out of bounds compression level
         level_min, level_max = CompressionParameter.compression_level.bounds()
-        compress(b'', level_max+1)
-        compress(b'', level_min-1)
-
-        compress(b'', options={CompressionParameter.compression_level:level_max+1})
-        compress(b'', options={CompressionParameter.compression_level:level_min-1})
+        with self.assertRaises(ValueError):
+            compress(b'', level_max+1)
+        with self.assertRaises(ValueError):
+            compress(b'', level_min-1)
+        with self.assertRaises(ValueError):
+            compress(b'', 2**1000)
+        with self.assertRaises(ValueError):
+            compress(b'', -(2**1000))
+        with self.assertRaises(ValueError):
+            compress(b'', options={
+                CompressionParameter.compression_level: level_max+1})
+        with self.assertRaises(ValueError):
+            compress(b'', options={
+                CompressionParameter.compression_level: level_min-1})
 
         # zstd lib doesn't support MT compression
         if not SUPPORT_MULTITHREADING:
@@ -383,13 +421,23 @@ def test_simple_decompress_bad_args(self):
         self.assertRaises(TypeError, ZstdDecompressor, options='abc')
         self.assertRaises(TypeError, ZstdDecompressor, options=b'abc')
 
-        with self.assertRaises(ValueError):
-            ZstdDecompressor(options={2**31 : 100})
+        with self.assertRaises(OverflowError):
+            ZstdDecompressor(options={2**31: 100})
+        with self.assertRaises(OverflowError):
+            ZstdDecompressor(options={2**1000: 100})
+        with self.assertRaises(OverflowError):
+            ZstdDecompressor(options={-(2**31)-1: 100})
+        with self.assertRaises(OverflowError):
+            ZstdDecompressor(options={-(2**1000): 100})
+        with self.assertRaises(OverflowError):
+            ZstdDecompressor(options={0: 2**31})
+        with self.assertRaises(OverflowError):
+            ZstdDecompressor(options={0: -(2**1000)})
 
         with self.assertRaises(ZstdError):
-            ZstdDecompressor(options={DecompressionParameter.window_log_max:100})
+            ZstdDecompressor(options={DecompressionParameter.window_log_max: 100})
         with self.assertRaises(ZstdError):
-            ZstdDecompressor(options={3333 : 100})
+            ZstdDecompressor(options={3333: 100})
 
         empty = compress(b'')
         lzd = ZstdDecompressor()
@@ -402,10 +450,15 @@ def test_decompress_parameters(self):
         d = {DecompressionParameter.window_log_max : 15}
         ZstdDecompressor(options=d)
 
-        # larger than signed int, ValueError
         d1 = d.copy()
+        # larger than signed int
         d1[DecompressionParameter.window_log_max] = 2**31
-        self.assertRaises(ValueError, ZstdDecompressor, None, d1)
+        with self.assertRaises(OverflowError):
+            ZstdDecompressor(None, d1)
+        # smaller than signed int
+        d1[DecompressionParameter.window_log_max] = -(2**31)-1
+        with self.assertRaises(OverflowError):
+            ZstdDecompressor(None, d1)
 
         # out of bounds error msg
         options = {DecompressionParameter.window_log_max:100}
@@ -415,6 +468,20 @@ def test_decompress_parameters(self):
                  r'\((?:32|64)-bit build\)')):
             decompress(b'', options=options)
 
+        # out of bounds deecompression parameter
+        options[DecompressionParameter.window_log_max] = 2**31
+        with self.assertRaises(OverflowError):
+            decompress(b'', options=options)
+        options[DecompressionParameter.window_log_max] = -(2**31)-1
+        with self.assertRaises(OverflowError):
+            decompress(b'', options=options)
+        options[DecompressionParameter.window_log_max] = 2**1000
+        with self.assertRaises(OverflowError):
+            decompress(b'', options=options)
+        options[DecompressionParameter.window_log_max] = -(2**1000)
+        with self.assertRaises(OverflowError):
+            decompress(b'', options=options)
+
     def test_unknown_decompression_parameter(self):
         KEY = 100001234
         options = {DecompressionParameter.window_log_max: DecompressionParameter.window_log_max.bounds()[1],
@@ -1424,11 +1491,11 @@ def test_init_bad_mode(self):
             ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB), "rw")
 
         with self.assertRaisesRegex(TypeError,
-                                    r"NOT be a CompressionParameter"):
+                                    r"not be a CompressionParameter"):
             ZstdFile(io.BytesIO(), 'rb',
                      options={CompressionParameter.compression_level:5})
         with self.assertRaisesRegex(TypeError,
-                                    r"NOT be a DecompressionParameter"):
+                                    r"not be a DecompressionParameter"):
             ZstdFile(io.BytesIO(), 'wb',
                      options={DecompressionParameter.window_log_max:21})
 
@@ -1447,7 +1514,7 @@ def test_init_bad_check(self):
         with self.assertRaises(TypeError):
             ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB), "r", options=33)
 
-        with self.assertRaises(ValueError):
+        with self.assertRaises(OverflowError):
             ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB),
                              options={DecompressionParameter.window_log_max:2**31})
 
@@ -1467,7 +1534,7 @@ def test_init_close_fp(self):
             tmp_f.write(DAT_130K_C)
             filename = tmp_f.name
 
-        with self.assertRaises(ValueError):
+        with self.assertRaises(TypeError):
             ZstdFile(filename, options={'a':'b'})
 
         # for PyPy