def steps(self): strategies = [] for rule in self.rules(): converted_arguments = {} valid = True if rule.precondition is not None and not rule.precondition(self): continue for k, v in sorted(rule.arguments.items()): if isinstance(v, Bundle): bundle = self.bundle(v.name) if not bundle: valid = False break else: v = sampled_from(bundle) converted_arguments[k] = v if valid: strategies.append( TupleStrategy((just(rule), FixedKeysDictStrategy(converted_arguments)), tuple)) if not strategies: raise InvalidDefinition(u'No progress can be made from state %r' % (self, )) return one_of(*strategies)
def steps(self): strategies = [] for rule in self.rules(): converted_arguments = {} valid = True if rule.precondition and not rule.precondition(self): continue for k, v in sorted(rule.arguments.items()): if isinstance(v, Bundle): bundle = self.bundle(v.name) if not bundle: valid = False break converted_arguments[k] = v if valid: strategies.append(TupleStrategy(( just(rule), FixedKeysDictStrategy(converted_arguments) ), tuple)) if not strategies: raise InvalidDefinition( u'No progress can be made from state %r' % (self,) ) for name, bundle in self.bundles.items(): if len(bundle) > 1: strategies.append( builds( ShuffleBundle, just(name), lists(integers(0, len(bundle) - 1)))) return one_of(strategies)
def __init__( self, strategy, expand ): super(FlatMapStrategy, self).__init__( strategy=TupleStrategy(( strategy, MorpherStrategy()), tuple)) self.flatmapped_strategy = strategy self.expand = expand self.settings = Settings.default
def tuples(*args): """Return a strategy which generates a tuple of the same length as args by generating the value at index i from args[i]. e.g. tuples(integers(), integers()) would generate a tuple of length two with both values an integer. """ for arg in args: check_strategy(arg) from hypothesis.searchstrategy.collections import TupleStrategy return TupleStrategy(args, tuple)
def process_arguments_to_given( wrapped_test, arguments, kwargs, generator_arguments, generator_kwargs, argspec, test, settings, ): selfy = None arguments, kwargs = convert_positional_arguments(wrapped_test, arguments, kwargs) # If the test function is a method of some kind, the bound object # will be the first named argument if there are any, otherwise the # first vararg (if any). if argspec.args: selfy = kwargs.get(argspec.args[0]) elif arguments: selfy = arguments[0] # Ensure that we don't mistake mocks for self here. # This can cause the mock to be used as the test runner. if is_mock(selfy): selfy = None test_runner = new_style_executor(selfy) arguments = tuple(arguments) # We use TupleStrategy over tuples() here to avoid polluting # st.STRATEGY_CACHE with references (see #493), and because this is # trivial anyway if the fixed_dictionaries strategy is cacheable. search_strategy = TupleStrategy( ( st.just(arguments), st.fixed_dictionaries(generator_kwargs).map( lambda args: dict(args, **kwargs) ), ) ) if selfy is not None: search_strategy = WithRunner(search_strategy, selfy) search_strategy.validate() return arguments, kwargs, test_runner, search_strategy
def steps(self): strategies = [] for rule in self.rules(): converted_arguments = {} valid = True for k, v in rule.arguments.items(): if isinstance(v, Bundle): bundle = self.bundle(v.name) if not bundle: valid = False break else: v = SimpleSampledFromStrategy(bundle) converted_arguments[k] = v if valid: strategies.append( TupleStrategy((JustStrategy(rule), FixedKeysDictStrategy(converted_arguments)), tuple)) if not strategies: raise InvalidDefinition('No progress can be made from state %r' % (self, )) return one_of_strategies(strategies)
def define_tuple_strategy(specifier, settings): from hypothesis.searchstrategy.collections import TupleStrategy return TupleStrategy( tuple(strategy(d, settings) for d in specifier), tuple_type=type(specifier) )