def integers(min_value=None, max_value=None): """Returns a strategy which generates integers (in Python 2 these may be ints or longs). If min_value is not None then all values will be >= min_value. If max_value is not None then all values will be <= max_value """ from hypothesis.searchstrategy.numbers import IntegersFromStrategy, \ BoundedIntStrategy, RandomGeometricIntStrategy, WideRangeIntStrategy if min_value is None: if max_value is None: return ( RandomGeometricIntStrategy() | WideRangeIntStrategy() ) else: check_type(integer_types, max_value) return IntegersFromStrategy(0).map(lambda x: max_value - x) else: check_type(integer_types, min_value) if max_value is None: return IntegersFromStrategy(min_value) else: if min_value == max_value: return just(min_value) elif min_value > max_value: raise InvalidArgument( u'Cannot have max_value=%r < min_value=%r' % ( max_value, min_value )) return BoundedIntStrategy(min_value, max_value)
def integers(min_value=None, max_value=None): """Returns a strategy which generates integers (in Python 2 these may be ints or longs). If min_value is not None then all values will be >= min_value. If max_value is not None then all values will be <= max_value """ check_valid_integer(min_value) check_valid_integer(max_value) check_valid_interval(min_value, max_value, 'min_value', 'max_value') from hypothesis.searchstrategy.numbers import IntegersFromStrategy, \ BoundedIntStrategy, RandomGeometricIntStrategy, WideRangeIntStrategy if min_value is None: if max_value is None: return (RandomGeometricIntStrategy() | WideRangeIntStrategy()) else: return IntegersFromStrategy(0).map(lambda x: max_value - x) else: if max_value is None: return IntegersFromStrategy(min_value) else: if min_value == max_value: return just(min_value) return BoundedIntStrategy(min_value, max_value)
def integers(min_value=None, max_value=None): """Returns a strategy which generates integers (in Python 2 these may be ints or longs). If min_value is not None then all values will be >= min_value. If max_value is not None then all values will be <= max_value """ check_valid_bound(min_value, 'min_value') check_valid_bound(max_value, 'max_value') check_valid_interval(min_value, max_value, 'min_value', 'max_value') from hypothesis.searchstrategy.numbers import IntegersFromStrategy, \ BoundedIntStrategy, WideRangeIntStrategy min_int_value = None if min_value is not None: min_int_value = int(min_value) if min_int_value != min_value and min_value > 0: min_int_value += 1 max_int_value = None if max_value is not None: max_int_value = int(max_value) if max_int_value != max_value and max_value < 0: max_int_value -= 1 if min_int_value is None: if max_int_value is None: return ( WideRangeIntStrategy() ) else: return IntegersFromStrategy(0).map(lambda x: max_int_value - x) else: if max_int_value is None: return IntegersFromStrategy(min_int_value) else: assert min_int_value <= max_int_value if min_int_value == max_int_value: return just(min_int_value) elif min_int_value >= 0: return BoundedIntStrategy(min_int_value, max_int_value) elif max_int_value <= 0: return BoundedIntStrategy( -max_int_value, -min_int_value ).map(lambda t: -t) else: return integers(min_value=0, max_value=max_int_value) | \ integers(min_value=min_int_value, max_value=0)
def lists(elements=None, min_size=None, average_size=None, max_size=None): """Returns a list containining values drawn from elements length in the interval [min_size, max_size] (no bounds in that direction if these are None). If max_size is 0 then elements may be None and only the empty list will be drawn. average_size may be used as a size hint to roughly control the size of list but it may not be the actual average of sizes you get, due to a variety of factors. """ check_valid_sizes(min_size, average_size, max_size) from hypothesis.searchstrategy.collections import ListStrategy, \ SingleElementListStrategy if min_size is None: min_size = 0 if average_size is None: if max_size is None: average_size = Settings.default.average_list_length else: average_size = (min_size + max_size) * 0.5 if elements is None or (max_size is not None and max_size <= 0): if max_size is None or max_size > 0: raise InvalidArgument( 'Cannot create non-empty lists without an element type') else: return ListStrategy(()) else: check_strategy(elements) if elements.template_upper_bound == 1: from hypothesis.searchstrategy.numbers import IntegersFromStrategy if max_size is None: length_strat = IntegersFromStrategy(min_size, average_size=average_size - min_size) else: length_strat = integers(min_size, max_size) return SingleElementListStrategy(elements, length_strat) return ListStrategy( (elements, ), average_length=average_size, min_size=min_size, max_size=max_size, )
def lists( elements=None, min_size=None, average_size=None, max_size=None, unique_by=None ): """Returns a list containining values drawn from elements length in the interval [min_size, max_size] (no bounds in that direction if these are None). If max_size is 0 then elements may be None and only the empty list will be drawn. average_size may be used as a size hint to roughly control the size of list but it may not be the actual average of sizes you get, due to a variety of factors. if unique_by is not None it must be a function returning a hashable type when given a value drawn from elements. The resulting list will satisfy the condition that for i != j, unique_by(result[i]) != unique_by(result[j]). """ if unique_by is not None: from hypothesis.searchstrategy.collections import UniqueListStrategy if max_size == 0: return builds(list) check_strategy(elements) if min_size is not None and elements.template_upper_bound < min_size: raise InvalidArgument(( u'Cannot generate unique lists of size %d from %r, which ' u'contains no more than %d distinct values') % ( min_size, elements, elements.template_upper_bound, )) min_size = min_size or 0 max_size = max_size or float(u'inf') max_size = min(max_size, elements.template_upper_bound) if average_size is None: if max_size < float(u'inf'): if max_size <= 5: average_size = min_size + 0.75 * (max_size - min_size) else: average_size = (max_size + min_size) / 2 else: average_size = max( Settings.default.average_list_length, min_size * 2 ) check_valid_sizes(min_size, average_size, max_size) result = UniqueListStrategy( elements=elements, average_size=average_size, max_size=max_size, min_size=min_size, key=unique_by ) return result check_valid_sizes(min_size, average_size, max_size) from hypothesis.searchstrategy.collections import ListStrategy, \ SingleElementListStrategy if min_size is None: min_size = 0 if average_size is None: if max_size is None: average_size = Settings.default.average_list_length else: average_size = (min_size + max_size) * 0.5 if elements is None or (max_size is not None and max_size <= 0): if max_size is None or max_size > 0: raise InvalidArgument( u'Cannot create non-empty lists without an element type' ) else: return ListStrategy(()) else: check_strategy(elements) if elements.template_upper_bound == 1: from hypothesis.searchstrategy.numbers import IntegersFromStrategy if max_size is None: length_strat = IntegersFromStrategy( min_size, average_size=average_size - min_size) else: length_strat = integers(min_size, max_size) return SingleElementListStrategy(elements, length_strat) return ListStrategy( (elements,), average_length=average_size, min_size=min_size, max_size=max_size, )
def lists( elements=None, min_size=None, average_size=None, max_size=None, unique_by=None, unique=False, ): """Returns a list containing values drawn from elements length in the interval [min_size, max_size] (no bounds in that direction if these are None). If max_size is 0 then elements may be None and only the empty list will be drawn. average_size may be used as a size hint to roughly control the size of list but it may not be the actual average of sizes you get, due to a variety of factors. If unique is True (or something that evaluates to True), we compare direct object equality, as if unique_by was `lambda x: x`. This comparison only works for hashable types. if unique_by is not None it must be a function returning a hashable type when given a value drawn from elements. The resulting list will satisfy the condition that for i != j, unique_by(result[i]) != unique_by(result[j]). """ if unique: if unique_by is not None: raise InvalidArgument( ('cannot specify both unique and unique_by (you probably only ' 'want to set unique_by)')) else: unique_by = lambda x: x if unique_by is not None: from hypothesis.searchstrategy.collections import UniqueListStrategy if max_size == 0: return builds(list) check_strategy(elements) if min_size is not None and elements.template_upper_bound < min_size: raise InvalidArgument( ('Cannot generate unique lists of size %d from %r, which ' 'contains no more than %d distinct values') % ( min_size, elements, elements.template_upper_bound, )) min_size = min_size or 0 max_size = max_size or float(u'inf') max_size = min(max_size, elements.template_upper_bound) if average_size is None: if max_size < float(u'inf'): if max_size <= 5: average_size = min_size + 0.75 * (max_size - min_size) else: average_size = (max_size + min_size) / 2 else: average_size = max(_AVERAGE_LIST_LENGTH, min_size * 2) check_valid_sizes(min_size, average_size, max_size) result = UniqueListStrategy(elements=elements, average_size=average_size, max_size=max_size, min_size=min_size, key=unique_by) return result check_valid_sizes(min_size, average_size, max_size) from hypothesis.searchstrategy.collections import ListStrategy, \ SingleElementListStrategy if min_size is None: min_size = 0 if average_size is None: if max_size is None: average_size = _AVERAGE_LIST_LENGTH else: average_size = (min_size + max_size) * 0.5 if elements is None or (max_size is not None and max_size <= 0): if max_size is None or max_size > 0: raise InvalidArgument( 'Cannot create non-empty lists without an element type') else: return ListStrategy(()) else: check_strategy(elements) if elements.template_upper_bound == 1: from hypothesis.searchstrategy.numbers import IntegersFromStrategy if max_size is None: length_strat = IntegersFromStrategy(min_size, average_size=average_size - min_size) else: length_strat = integers(min_size, max_size) return SingleElementListStrategy(elements, length_strat) return ListStrategy( (elements, ), average_length=average_size, min_size=min_size, max_size=max_size, )