contrib/python-zstandard/tests/test_data_structures_fuzzing.py
changeset 37495 b1fb341d8a61
parent 31796 e0dc40530c5a
child 40121 73fef626dae3
equal deleted inserted replaced
37494:1ce7a55b09d1 37495:b1fb341d8a61
     1 import io
     1 import io
     2 import os
     2 import os
     3 
     3 import sys
     4 try:
     4 import unittest
     5     import unittest2 as unittest
       
     6 except ImportError:
       
     7     import unittest
       
     8 
     5 
     9 try:
     6 try:
    10     import hypothesis
     7     import hypothesis
    11     import hypothesis.strategies as strategies
     8     import hypothesis.strategies as strategies
    12 except ImportError:
     9 except ImportError:
    13     raise unittest.SkipTest('hypothesis not available')
    10     raise unittest.SkipTest('hypothesis not available')
    14 
    11 
    15 import zstd
    12 import zstandard as zstd
    16 
    13 
    17 from .common import (
    14 from .common import (
    18     make_cffi,
    15     make_cffi,
    19 )
    16 )
    20 
    17 
    26 s_hashlog = strategies.integers(min_value=zstd.HASHLOG_MIN,
    23 s_hashlog = strategies.integers(min_value=zstd.HASHLOG_MIN,
    27                                 max_value=zstd.HASHLOG_MAX)
    24                                 max_value=zstd.HASHLOG_MAX)
    28 s_searchlog = strategies.integers(min_value=zstd.SEARCHLOG_MIN,
    25 s_searchlog = strategies.integers(min_value=zstd.SEARCHLOG_MIN,
    29                                     max_value=zstd.SEARCHLOG_MAX)
    26                                     max_value=zstd.SEARCHLOG_MAX)
    30 s_searchlength = strategies.integers(min_value=zstd.SEARCHLENGTH_MIN,
    27 s_searchlength = strategies.integers(min_value=zstd.SEARCHLENGTH_MIN,
    31                                         max_value=zstd.SEARCHLENGTH_MAX)
    28                                      max_value=zstd.SEARCHLENGTH_MAX)
    32 s_targetlength = strategies.integers(min_value=zstd.TARGETLENGTH_MIN,
    29 s_targetlength = strategies.integers(min_value=zstd.TARGETLENGTH_MIN,
    33                                         max_value=zstd.TARGETLENGTH_MAX)
    30                                      max_value=2**32)
    34 s_strategy = strategies.sampled_from((zstd.STRATEGY_FAST,
    31 s_strategy = strategies.sampled_from((zstd.STRATEGY_FAST,
    35                                         zstd.STRATEGY_DFAST,
    32                                         zstd.STRATEGY_DFAST,
    36                                         zstd.STRATEGY_GREEDY,
    33                                         zstd.STRATEGY_GREEDY,
    37                                         zstd.STRATEGY_LAZY,
    34                                         zstd.STRATEGY_LAZY,
    38                                         zstd.STRATEGY_LAZY2,
    35                                         zstd.STRATEGY_LAZY2,
    39                                         zstd.STRATEGY_BTLAZY2,
    36                                         zstd.STRATEGY_BTLAZY2,
    40                                         zstd.STRATEGY_BTOPT))
    37                                         zstd.STRATEGY_BTOPT,
       
    38                                         zstd.STRATEGY_BTULTRA))
    41 
    39 
    42 
    40 
    43 @make_cffi
    41 @make_cffi
    44 @unittest.skipUnless('ZSTD_SLOW_TESTS' in os.environ, 'ZSTD_SLOW_TESTS not set')
    42 @unittest.skipUnless('ZSTD_SLOW_TESTS' in os.environ, 'ZSTD_SLOW_TESTS not set')
    45 class TestCompressionParametersHypothesis(unittest.TestCase):
    43 class TestCompressionParametersHypothesis(unittest.TestCase):
    46     @hypothesis.given(s_windowlog, s_chainlog, s_hashlog, s_searchlog,
    44     @hypothesis.given(s_windowlog, s_chainlog, s_hashlog, s_searchlog,
    47                         s_searchlength, s_targetlength, s_strategy)
    45                         s_searchlength, s_targetlength, s_strategy)
    48     def test_valid_init(self, windowlog, chainlog, hashlog, searchlog,
    46     def test_valid_init(self, windowlog, chainlog, hashlog, searchlog,
    49                         searchlength, targetlength, strategy):
    47                         searchlength, targetlength, strategy):
    50         # ZSTD_checkCParams moves the goal posts on us from what's advertised
    48         zstd.ZstdCompressionParameters(window_log=windowlog,
    51         # in the constants. So move along with them.
    49                                        chain_log=chainlog,
    52         if searchlength == zstd.SEARCHLENGTH_MIN and strategy in (zstd.STRATEGY_FAST, zstd.STRATEGY_GREEDY):
    50                                        hash_log=hashlog,
    53             searchlength += 1
    51                                        search_log=searchlog,
    54         elif searchlength == zstd.SEARCHLENGTH_MAX and strategy != zstd.STRATEGY_FAST:
    52                                        min_match=searchlength,
    55             searchlength -= 1
    53                                        target_length=targetlength,
    56 
    54                                        compression_strategy=strategy)
    57         p = zstd.CompressionParameters(windowlog, chainlog, hashlog,
       
    58                                         searchlog, searchlength,
       
    59                                         targetlength, strategy)
       
    60 
       
    61         cctx = zstd.ZstdCompressor(compression_params=p)
       
    62         with cctx.write_to(io.BytesIO()):
       
    63             pass
       
    64 
    55 
    65     @hypothesis.given(s_windowlog, s_chainlog, s_hashlog, s_searchlog,
    56     @hypothesis.given(s_windowlog, s_chainlog, s_hashlog, s_searchlog,
    66                         s_searchlength, s_targetlength, s_strategy)
    57                         s_searchlength, s_targetlength, s_strategy)
    67     def test_estimate_compression_context_size(self, windowlog, chainlog,
    58     def test_estimated_compression_context_size(self, windowlog, chainlog,
    68                                                 hashlog, searchlog,
    59                                                 hashlog, searchlog,
    69                                                 searchlength, targetlength,
    60                                                 searchlength, targetlength,
    70                                                 strategy):
    61                                                 strategy):
    71         if searchlength == zstd.SEARCHLENGTH_MIN and strategy in (zstd.STRATEGY_FAST, zstd.STRATEGY_GREEDY):
    62         if searchlength == zstd.SEARCHLENGTH_MIN and strategy in (zstd.STRATEGY_FAST, zstd.STRATEGY_GREEDY):
    72             searchlength += 1
    63             searchlength += 1
    73         elif searchlength == zstd.SEARCHLENGTH_MAX and strategy != zstd.STRATEGY_FAST:
    64         elif searchlength == zstd.SEARCHLENGTH_MAX and strategy != zstd.STRATEGY_FAST:
    74             searchlength -= 1
    65             searchlength -= 1
    75 
    66 
    76         p = zstd.CompressionParameters(windowlog, chainlog, hashlog,
    67         p = zstd.ZstdCompressionParameters(window_log=windowlog,
    77                             searchlog, searchlength,
    68                                            chain_log=chainlog,
    78                             targetlength, strategy)
    69                                            hash_log=hashlog,
    79         size = zstd.estimate_compression_context_size(p)
    70                                            search_log=searchlog,
       
    71                                            min_match=searchlength,
       
    72                                            target_length=targetlength,
       
    73                                            compression_strategy=strategy)
       
    74         size = p.estimated_compression_context_size()
       
    75