def run_state_test_generators(runner_name: str, specs: Iterable[Any], all_mods: Dict[str, Dict[str, str]]) -> None: """ Generate all available state tests of `TESTGEN_FORKS` forks of `ALL_CONFIGS` configs of the given runner. """ for config_name in ALL_CONFIGS: for fork_name in TESTGEN_FORKS: if fork_name in all_mods: gen_runner.run_generator(runner_name, get_provider( create_provider_fn=get_create_provider_fn(runner_name, config_name, specs), config_name=config_name, fork_name=fork_name, all_mods=all_mods, ))
def run_state_test_generators(runner_name: str, all_mods: Dict[str, Dict[str, str]], presets: Iterable[PresetBaseName] = ALL_PRESETS, forks: Iterable[SpecForkName] = TESTGEN_FORKS) -> None: """ Generate all available state tests of `TESTGEN_FORKS` forks of `ALL_PRESETS` presets of the given runner. """ for preset_name in presets: for fork_name in forks: if fork_name in all_mods: gen_runner.run_generator(runner_name, get_provider( create_provider_fn=get_create_provider_fn(runner_name), fork_name=fork_name, preset_name=preset_name, all_mods=all_mods, ))
phase: SpecForkName, fork_name: SpecForkName) -> gen_typing.TestProvider: def prepare_fn() -> None: return def cases_fn() -> Iterable[gen_typing.TestCase]: return generate_from_tests( runner_name='fork', handler_name='fork', src=tests_src, fork_name=fork_name, preset_name=preset_name, phase=phase, ) return gen_typing.TestProvider(prepare=prepare_fn, make_cases=cases_fn) def _get_fork_tests_providers(): for preset in [MINIMAL, MAINNET]: yield create_provider(test_altair_fork_basic, preset, PHASE0, ALTAIR) yield create_provider(test_altair_fork_random, preset, PHASE0, ALTAIR) yield create_provider(test_bellatrix_fork_basic, preset, ALTAIR, BELLATRIX) yield create_provider(test_bellatrix_fork_random, preset, ALTAIR, BELLATRIX) if __name__ == "__main__": gen_runner.run_generator("forks", list(_get_fork_tests_providers()))
def prepare_fn(configs_path: str) -> str: # Nothing to load / change in spec. Maybe in future forks. # Put the tests into the general config category, to not require any particular configuration. return 'general' def cases_fn() -> Iterable[gen_typing.TestCase]: for data in test_case_fn(): print(data) (case_name, case_content) = data yield gen_typing.TestCase( fork_name=PHASE0, runner_name='bls', handler_name=handler_name, suite_name='small', case_name=case_name, case_fn=lambda: [('data', 'data', case_content)]) return gen_typing.TestProvider(prepare=prepare_fn, make_cases=cases_fn) if __name__ == "__main__": bls.use_py_ecc( ) # Py-ecc is chosen instead of Milagro, since the code is better understood to be correct. gen_runner.run_generator("bls", [ create_provider('sign', case01_sign), create_provider('verify', case02_verify), create_provider('aggregate', case03_aggregate), create_provider('fast_aggregate_verify', case04_fast_aggregate_verify), create_provider('aggregate_verify', case05_aggregate_verify), ])
def create_provider(tests_src, config_name: str, pre_fork_name: str, post_fork_name: str) -> gen_typing.TestProvider: def prepare_fn(configs_path: str) -> str: config_util.prepare_config(configs_path, config_name) reload(spec_phase0) reload(spec_altair) return config_name def cases_fn() -> Iterable[gen_typing.TestCase]: return generate_from_tests( runner_name='transition', handler_name='core', src=tests_src, fork_name=post_fork_name, phase=pre_fork_name, ) return gen_typing.TestProvider(prepare=prepare_fn, make_cases=cases_fn) TRANSITION_TESTS = ((PHASE0, ALTAIR, test_altair_transition), ) if __name__ == "__main__": for pre_fork, post_fork, transition_test_module in TRANSITION_TESTS: gen_runner.run_generator("transition", [ create_provider(transition_test_module, MINIMAL, pre_fork, post_fork), create_provider(transition_test_module, MAINNET, pre_fork, post_fork), ])
if fork_name == ALTAIR: spec = spec_altair for (i, (name, ssz_type)) in enumerate(get_spec_ssz_types(spec)): yield from ssz_static_cases(fork_name, seed * 1000 + i, name, ssz_type, mode, chaos, count) return gen_typing.TestProvider(prepare=prepare_fn, make_cases=cases_fn) if __name__ == "__main__": # [(seed, config name, randomization mode, chaos on/off, cases_if_random)] settings = [] seed = 1 for mode in random_value.RandomizationMode: settings.append((seed, MINIMAL, mode, False, 30)) seed += 1 settings.append( (seed, MINIMAL, random_value.RandomizationMode.mode_random, True, 30)) seed += 1 settings.append( (seed, MAINNET, random_value.RandomizationMode.mode_random, False, 5)) seed += 1 for fork in TESTGEN_FORKS: gen_runner.run_generator("ssz_static", [ create_provider(fork, config_name, seed, mode, chaos, cases_if_random) for (seed, config_name, mode, chaos, cases_if_random) in settings ])
return "general" def cases_fn() -> Iterable[gen_typing.TestCase]: for (case_name, case_fn) in case_maker(): yield gen_typing.TestCase(fork_name=PHASE0, runner_name='ssz_generic', handler_name=handler_name, suite_name=suite_name, case_name=case_name, case_fn=case_fn) return gen_typing.TestProvider(prepare=prepare_fn, make_cases=cases_fn) if __name__ == "__main__": gen_runner.run_generator("ssz_generic", [ create_provider("basic_vector", "valid", ssz_basic_vector.valid_cases), create_provider("basic_vector", "invalid", ssz_basic_vector.invalid_cases), create_provider("bitlist", "valid", ssz_bitlist.valid_cases), create_provider("bitlist", "invalid", ssz_bitlist.invalid_cases), create_provider("bitvector", "valid", ssz_bitvector.valid_cases), create_provider("bitvector", "invalid", ssz_bitvector.invalid_cases), create_provider("boolean", "valid", ssz_boolean.valid_cases), create_provider("boolean", "invalid", ssz_boolean.invalid_cases), create_provider("uints", "valid", ssz_uints.valid_cases), create_provider("uints", "invalid", ssz_uints.invalid_cases), create_provider("containers", "valid", ssz_container.valid_cases), create_provider("containers", "invalid", ssz_container.invalid_cases), ])
preset_name='general', runner_name='bls', handler_name=handler_name, suite_name='small', case_name=case_name, case_fn=lambda: [('data', 'data', case_content)]) return gen_typing.TestProvider(prepare=prepare_fn, make_cases=cases_fn) if __name__ == "__main__": bls.use_py_ecc( ) # Py-ecc is chosen instead of Milagro, since the code is better understood to be correct. gen_runner.run_generator( "bls", [ # PHASE0 create_provider(PHASE0, 'sign', case01_sign), create_provider(PHASE0, 'verify', case02_verify), create_provider(PHASE0, 'aggregate', case03_aggregate), create_provider(PHASE0, 'fast_aggregate_verify', case04_fast_aggregate_verify), create_provider(PHASE0, 'aggregate_verify', case05_aggregate_verify), # ALTAIR create_provider(ALTAIR, 'eth_aggregate_pubkeys', case06_eth_aggregate_pubkeys), create_provider(ALTAIR, 'eth_fast_aggregate_verify', case07_eth_fast_aggregate_verify), ])
for seed in [ spec.hash(seed_init_value.to_bytes(length=4, byteorder='little')) for seed_init_value in range(30) ]: for count in [0, 1, 2, 3, 5, 10, 33, 100, 1000, 9999]: yield shuffling_case(seed, count) def create_provider(config_name: str) -> gen_typing.TestProvider: def prepare_fn(configs_path: str) -> str: config_util.prepare_config(configs_path, config_name) reload(spec) return config_name def cases_fn() -> Iterable[gen_typing.TestCase]: for (case_name, case_fn) in shuffling_test_cases(): yield gen_typing.TestCase(fork_name=PHASE0, runner_name='shuffling', handler_name='core', suite_name='shuffle', case_name=case_name, case_fn=case_fn) return gen_typing.TestProvider(prepare=prepare_fn, make_cases=cases_fn) if __name__ == "__main__": gen_runner.run_generator( "shuffling", [create_provider("minimal"), create_provider("mainnet")])
from eth2spec.gen_helpers.gen_base import gen_runner, gen_typing from eth2spec.gen_helpers.gen_from_tests.gen import generate_from_tests def create_provider(tests_src, config_name: str, phase: str, fork_name: str) -> gen_typing.TestProvider: def prepare_fn(configs_path: str) -> str: config_util.prepare_config(configs_path, config_name) reload(spec_phase0) reload(spec_altair) return config_name def cases_fn() -> Iterable[gen_typing.TestCase]: return generate_from_tests( runner_name='fork', handler_name='fork', src=tests_src, fork_name=fork_name, phase=phase, ) return gen_typing.TestProvider(prepare=prepare_fn, make_cases=cases_fn) if __name__ == "__main__": gen_runner.run_generator("forks", [ create_provider(test_altair_forks, MINIMAL, PHASE0, ALTAIR), create_provider(test_altair_forks, MAINNET, PHASE0, ALTAIR), ])
yield shuffling_case(spec, seed, count) def create_provider(preset_name: PresetBaseName) -> gen_typing.TestProvider: def prepare_fn() -> None: return def cases_fn() -> Iterable[gen_typing.TestCase]: if preset_name == MAINNET: spec = spec_mainnet elif preset_name == MINIMAL: spec = spec_minimal else: raise Exception(f"unrecognized preset: {preset_name}") for (case_name, case_fn) in shuffling_test_cases(spec): yield gen_typing.TestCase(fork_name=PHASE0, preset_name=preset_name, runner_name='shuffling', handler_name='core', suite_name='shuffle', case_name=case_name, case_fn=case_fn) return gen_typing.TestProvider(prepare=prepare_fn, make_cases=cases_fn) if __name__ == "__main__": gen_runner.run_generator( "shuffling", [create_provider(MINIMAL), create_provider(MAINNET)])