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 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
