def factory(*, names: Strategy = identifiers, keys: Strategy = identifiers, values: Strategy = strategies.integers(), bases: Strategy = strategies.tuples(strategies.just(Enum)), value_to_string: Callable[[Any], str] = '{!r}'.format, **namespace: Any) -> Strategy: contents = strategies.dictionaries(keys=keys, values=values, min_size=1) def enum_factory(draw: Callable[[Strategy], Any]) -> EnumMeta: name = draw(names) enum_bases = draw(bases) content = draw(contents) namespace['bases'] = enum_bases indent = 4 * ' ' lines = (key + '=' + value_to_string(value) for key, value in content.items()) try: content_str = '\n'.join(indent + line for line in lines) except TypeError as err: err_msg = ('Invalid strategy: ' '"keys" should generate "str" instances.') raise ValueError(err_msg) from err exec(ENUM_TEMPLATE.format(name=name, content=content_str), namespace) return namespace[name] return strategies.composite(enum_factory)()
def types_factory(enums: Strategy = factory()) -> Strategy: types_values = strategies.one_of(strategies.tuples(enums), strategies.lists(identifiers, min_size=1)) def enum_type_factory(draw: Callable[[Strategy], Any]) -> EnumType: type_values = draw(types_values) return EnumType(*type_values) return strategies.composite(enum_type_factory)()
def run_and_statis(self, max_examples=100, opset_version=[7, 9, 15], reproduce=None, min_success_num=25, max_duration=-1): if os.getenv('HYPOTHESIS_TEST_PROFILE', 'ci') == "dev": max_examples *= 10 min_success_num *= 10 # while at ce phase, there's no limit on time max_duration = -1 start_time = time.time() settings.register_profile( "ci", max_examples=max_examples, suppress_health_check=hypothesis.HealthCheck.all(), deadline=None, print_blob=True, derandomize=True, report_multiple_bugs=False, ) settings.load_profile("ci") def sample_convert_generator(draw): return self.sample_convert_config(draw) def run_test(configs): return self.run_test(configs=configs) generator = st.composite(sample_convert_generator) loop_func = given(generator())(run_test) if reproduce is not None: loop_func = reproduce(loop_func) logging.info("Start to running test of {}".format(type(self))) paddle.disable_static() loop_func() logging.info( "===================Statistical Information===================") logging.info("Number of Generated Programs: {}".format( self.num_ran_models)) successful_ran_programs = int(self.num_ran_models) if successful_ran_programs < min_success_num: logging.warning("satisfied_programs = ran_programs") logging.error( "At least {} programs need to ran successfully, but now only about {} programs satisfied." .format(min_success_num, successful_ran_programs)) assert False used_time = time.time() - start_time logging.info("Used time: {} s".format(round(used_time, 2))) if max_duration > 0 and used_time > max_duration: logging.error( "The duration exceeds {} seconds, if this is neccessary, try to set a larger number for parameter `max_duration`." .format(max_duration)) assert False
def factory( *, tables_names: Strategy = identifiers, metadatas: Strategy, columns_lists: Strategy = columns.non_all_unique_lists_factory(), extend_existing: Strategy = strategies.just(True) ) -> Strategy: def table_factory(draw: Callable[[Strategy], Any]) -> Table: table_name = draw(tables_names) metadata = draw(metadatas) columns_list = draw(columns_lists) return Table(table_name, metadata, *columns_list, extend_existing=draw(extend_existing)) return strategies.composite(table_factory)()
def factory( *, dialect: Dialect = dialectic.default, metadata: MetaData, names: Optional[Strategy[str]] = None, columns: Strategy[Column] = None, min_size: int = 0, max_size: Optional[int] = None, extend_existing: Strategy[bool] = strategies.booleans() ) -> Strategy[Table]: names = to_sql_identifiers(dialect) if names is None else names columns = (columnar.factory(dialect) if columns is None else columns) columns_lists = columnar.lists_factory(columns, min_size=min_size, max_size=max_size) def table_factory(draw: Callable[[Strategy], Any]) -> Table: extends_existing = draw(extend_existing) table_names = names if not extends_existing: table_names = (table_names.filter( lambda identifier: identifier not in metadata.tables)) table_name = draw(table_names) columns_list = draw(columns_lists) if extends_existing and table_name in metadata.tables: # preserving constraints, especially primary key one existing_table = metadata.tables[table_name] columns_list = [ existing_table.c.get(column.name, column) for column in columns_list ] result = Table(table_name, metadata, *columns_list, extend_existing=extends_existing) constraints = draw( constrained.lists_factory(columns_list, primary_key_min_size=1)) for constraint in constraints: result.append_constraint(constraint) return result return strategies.composite(table_factory)()
def factory( *, tables_names: Strategy[str] = sql_identifiers, metadatas: Strategy[MetaData], columns_factory: Callable[ ..., Strategy[List[Column]]] = columnar.non_all_unique_lists_factory, min_size: int = 0, max_size: Optional[int] = None, extend_existing: Strategy[bool] = strategies.just(True) ) -> Strategy: columns_lists = columns_factory(min_size=min_size, max_size=max_size) def table_factory(draw: Callable[[Strategy], Any]) -> Table: table_name = draw(tables_names) metadata = draw(metadatas) columns_list = draw(columns_lists) return Table(table_name, metadata, *columns_list, extend_existing=draw(extend_existing)) return strategies.composite(table_factory)()
def lists_factory(*, primary_keys: Strategy = primary_keys_factory(), non_primary_keys: Strategy = non_primary_keys_factory(), max_size: int = None) -> Strategy: max_size = max_size - 1 if max_size is not None else max_size non_primary_keys_lists = strategies.lists(non_primary_keys, min_size=1, max_size=max_size) def list_factory(draw: Callable[[Strategy], Any]) -> List[Column]: primary_key = draw(primary_keys) def names_are_unique(columns: List[Column]) -> int: names = [primary_key.name] names += [column.name for column in columns] return len(names) == len(set(names)) non_primary_keys_list = draw( non_primary_keys_lists.filter(names_are_unique)) return [primary_key] + non_primary_keys_list return strategies.composite(list_factory)()
def lists_factory( *, primary_keys: Strategy[str] = primary_keys_factory(), non_primary_keys: Strategy[TypeEngine] = non_primary_keys_factory(), min_size: int = 0, max_size: Optional[int] = None) -> Strategy[List[Column]]: min_size = min_size - 1 if min_size > 0 else min_size max_size = max_size - 1 if max_size is not None else max_size rest_columns_lists = strategies.lists(non_primary_keys, min_size=min_size, max_size=max_size) def to_columns_lists(draw: Callable[[Strategy], Any]) -> List[Column]: primary_key = draw(primary_keys) def names_are_unique(columns: List[Column]) -> bool: names = [primary_key.name] + [column.name for column in columns] return len(names) == len(set(names)) rest_columns_list = draw(rest_columns_lists.filter(names_are_unique)) return [primary_key] + rest_columns_list return strategies.composite(to_columns_lists)()
def test_composite_edits_annotations(): spec_comp = getfullargspec(st.composite(pointless_composite)) assert spec_comp.annotations['return'] == int assert 'nothing' in spec_comp.annotations assert 'draw' not in spec_comp.annotations
def comp(f): return st.deferred(st.composite(f))
def test_composite_edits_annotations(): spec_comp = getfullargspec(st.composite(pointless_composite)) assert spec_comp.annotations["return"] == int assert "nothing" in spec_comp.annotations assert "draw" not in spec_comp.annotations
def run_and_statis(self, quant=False, max_examples=100, reproduce=None, min_success_num=25, passes=None): self.init_statistical_parameters() settings.register_profile( "dev", max_examples=max_examples, suppress_health_check=hypothesis.HealthCheck.all(), deadline=None, print_blob=True, derandomize=True, report_multiple_bugs=False, verbosity=Verbosity.verbose) if os.getenv('HYPOTHESIS_TEST_PROFILE') == "ci": settings.load_profile("ci") elif os.getenv('HYPOTHESIS_TEST_PROFILE') == "ce": settings.load_profile("ce") else: settings.load_profile("dev") self.passes = passes self.add_ignore_pass_case() def program_generator(draw): return self.sample_program_configs(draw) def run_test(prog_config): return self.run_test(quant=quant, prog_configs=[prog_config]) # if current unittest is not active on the input targ paddlelite_not_support_flag = Trueet, we will exit directly. gl.set_all_test_ops(self.get_target(), sys.argv[0]) if not self.is_actived(): logging.info("Error: This test is not actived on " + self.get_target()) return generator = st.composite(program_generator) loop_func = given(generator())(run_test) if reproduce is not None: loop_func = reproduce(loop_func) logging.info("Start to running test of {}".format(type(self))) loop_func() logging.info( "===================Statistical Information===================") logging.info("Number of Generated Programs: {}".format(max_examples)) logging.info("Number of Predictor Kinds: {}".format( int(self.num_predictor_kinds))) self.assertTrue(self.num_predictor_kinds > 0, "Number of Predictor Kinds must be greater than 0") logging.info("Number of Ran Programs: {}".format( self.num_ran_programs_list)) logging.info("Number of Invalid Programs: {}".format( self.num_invalid_programs_list)) logging.info("Number of Ignored Tests: {}".format( self.num_ignore_tests_list)) successful_ran_programs = int( (sum(self.num_ran_programs_list) + sum(self.num_ignore_tests_list)) / self.num_predictor_kinds) logging.info( "Number of successfully ran programs approximately equal to {}". format(successful_ran_programs)) if successful_ran_programs < min_success_num: logging.fatal( "At least {} programs need to ran successfully, but now only about {} programs satisfied." .format(min_success_num, successful_ran_programs)) assert False
def run_and_statis(self, quant=False, max_examples=100, reproduce=None, min_success_num=25, max_duration=180, passes=None): if os.getenv('HYPOTHESIS_TEST_PROFILE', 'ci') == "dev": max_examples *= 10 min_success_num *= 10 # while at ce phase, there's no limit on time max_duration = -1 start_time = time.time() settings.register_profile( "ci", max_examples=max_examples, suppress_health_check=hypothesis.HealthCheck.all(), deadline=None, print_blob=True, derandomize=True, report_multiple_bugs=False, ) settings.load_profile("ci") assert passes is not None, "Parameter of passes must be defined in function run_and_statis." self.passes = passes self.add_ignore_pass_case() def program_generator(draw): return self.sample_program_config(draw) def run_test(prog_config): return self.run_test(quant=quant, prog_configs=[prog_config]) generator = st.composite(program_generator) loop_func = given(generator())(run_test) if reproduce is not None: loop_func = reproduce(loop_func) logging.info("Start to running test of {}".format(type(self))) loop_func() logging.info( "===================Statistical Information===================") logging.info("Number of Generated Programs: {}".format( self.num_ran_programs + self.num_invalid_programs)) logging.info("Number of Invalid Programs: {}".format( self.num_invalid_programs)) logging.info("Number of Ran Programs: {}".format( self.num_ran_programs)) logging.info("Number of Ignore Tests: {}".format( self.num_ignore_tests)) successful_ran_programs = int(self.num_ran_programs - self.num_ignore_tests / max(self.num_predictor_kinds, 1)) logging.info( "Number of successfully ran programs approximately equal to {}". format(successful_ran_programs)) if successful_ran_programs < min_success_num: logging.warning( "satisfied_programs = ran_programs - num_ignore_tests / num_predictor_kinds" ) logging.error( "At least {} programs need to ran successfully, but now only about {} programs satisfied." .format(min_success_num, successful_ran_programs)) assert False used_time = time.time() - start_time if max_duration > 0 and used_time > max_duration: logging.error( "The duration exceeds {} seconds, if this is necessary, try to set a larger number for parameter `max_duration`." .format(max_duration)) assert False