コード例 #1
0
ファイル: stateful.py プロジェクト: yuzhoujr/spazzatura
 def __init__(self):
     if not self.rules():
         raise InvalidDefinition(u'Type %s defines no rules' %
                                 (type(self).__name__, ))
     self.bundles = {}  # type: Dict[Text, list]
     self.name_counter = 1
     self.names_to_values = {}  # type: Dict[Text, Any]
     self.__stream = CUnicodeIO()
     self.__printer = RepresentationPrinter(self.__stream)
コード例 #2
0
ファイル: stateful.py プロジェクト: graingert/hypothesis
 def __init__(self):
     if not self.rules():
         raise InvalidDefinition("Type %s defines no rules" % (type(self).__name__,))
     self.bundles = {}  # type: Dict[str, list]
     self.name_counter = 1
     self.names_to_values = {}  # type: Dict[str, Any]
     self.__stream = StringIO()
     self.__printer = RepresentationPrinter(self.__stream)
     self._initialize_rules_to_run = copy(self.initialize_rules())
     self._rules_strategy = RuleStrategy(self)
コード例 #3
0
ファイル: core.py プロジェクト: yssource/hypothesis
        def run(data):
            # Set up dynamic context needed by a single test run.
            with local_settings(self.settings):
                with deterministic_PRNG():
                    with BuildContext(data, is_final=is_final):

                        # Generate all arguments to the test function.
                        args, kwargs = data.draw(self.search_strategy)
                        if expected_failure is not None:
                            text_repr[0] = arg_string(test, args, kwargs)

                        if print_example or current_verbosity(
                        ) >= Verbosity.verbose:
                            output = CUnicodeIO()

                            printer = RepresentationPrinter(output)
                            if print_example:
                                printer.text("Falsifying example:")
                            else:
                                printer.text("Trying example:")

                            if self.print_given_args:
                                printer.text(" ")
                                printer.text(test.__name__)
                                with printer.group(indent=4,
                                                   open="(",
                                                   close=""):
                                    printer.break_()
                                    for v in args:
                                        printer.pretty(v)
                                        # We add a comma unconditionally because
                                        # generated arguments will always be
                                        # kwargs, so there will always be more
                                        # to come.
                                        printer.text(",")
                                        printer.breakable()

                                    # We need to make sure to print these in the argument order for
                                    # Python 2 and older versionf of Python 3.5. In modern versions
                                    # this isn't an issue because kwargs is ordered.
                                    arg_order = {
                                        v: i
                                        for i, v in enumerate(
                                            getfullargspec(self.test).args)
                                    }
                                    for i, (k, v) in enumerate(
                                            sorted(
                                                kwargs.items(),
                                                key=lambda t: (
                                                    arg_order.get(
                                                        t[0], float("inf")),
                                                    t[0],
                                                ),
                                            )):
                                        printer.text(k)
                                        printer.text("=")
                                        printer.pretty(v)
                                        printer.text(",")
                                        if i + 1 < len(kwargs):
                                            printer.breakable()
                                printer.break_()
                                printer.text(")")
                            printer.flush()
                            report(output.getvalue())
                        return test(*args, **kwargs)