class TestPositiveIntOnNonModelWSingleLine(unittest.TestCase): INPUT_LINES = ['the one and only line'] CASES = [ NArrEx( '0', 0, [], ), NArrEx( 'in range', 1, INPUT_LINES, ), NArrEx( 'too large', 2, [], ), ] def test_with_model_access__only_as_lines_is_used(self): for case in self.CASES: with self.subTest(case.name, range=case.arrangement): _check_int_arg__w_max_lines_from_iter( self, case.arrangement, InpExp(self.INPUT_LINES, case.expectation), )
def execution_cases( contents_of_non_checked_phase: Optional[Mapping[str, str]] ) -> List[NArrEx[Arrangement, ExecutionExpectation[None]]]: expectation_of_removed_var = setup.expectation_of_removal_from_phase_act( var_to_unset, contents_of_non_checked_phase=contents_of_non_checked_phase, ) return [ NArrEx( 'environ/existing (not None), other_is_populated={}'. format(contents_of_non_checked_phase is not None), arr( non_act=contents_of_non_checked_phase, the_act=setup.as_dict(Phase.ACT), defaults_getter=get_empty_environ, ), expectation_of_removed_var, ), NArrEx( 'environ/non existing (None), other_is_populated={}'. format(contents_of_non_checked_phase is not None), arr( non_act=contents_of_non_checked_phase, the_act=None, defaults_getter=setup.defaults_getter_with_values( Phase.ACT), ), expectation_of_removed_var, ), ]
def runTest(self): self._check_cases([ NArrEx('constant False', arg_rend.constant(False), asrt_interval.matches_empty()), NArrEx('constant True', arg_rend.constant(True), asrt_interval.matches_unlimited()), ])
def _exe_cases_of_modification( before_modification: Sequence[NameAndValue[str]], after_modification: Sequence[NameAndValue[str]], symbols: Optional[SymbolTable] = None, ) -> Sequence[NArrEx[Arrangement, ExecutionExpectation[None]]]: expected = expectation(NameAndValue.as_dict(after_modification)) return [ NArrEx( 'environ/existing (not None)', arr( NameAndValue.as_dict(before_modification), default_environ_getter=get_empty_environ, symbols=symbols, ), expected, ), NArrEx( 'environ/non-existing None)', arr( None, default_environ_getter=defaults_getter__of_nav( before_modification), symbols=symbols, ), expected, ), ]
def test_target_is_all_phases(self): # ACT & ASSERT # setup = self.ENVIRONS_SETUP__DIFFERENT identical_setup = self.ENVIRONS_SETUP__IDENTICAL var_to_unset = self.COMMON_VAR_TO_UNSET.name arbitrary_phase = Phase.NON_ACT all_execution_cases = [ NArrEx( 'non-act/populated, act/populated', arr( non_act=setup.as_dict(Phase.NON_ACT), the_act=setup.as_dict(Phase.ACT), defaults_getter=get_empty_environ, ), setup.expectation_of_removal_from_phase_all(var_to_unset), ), NArrEx( 'non-act/populated, act/not populated', arr( non_act=setup.as_dict(Phase.NON_ACT), the_act=None, defaults_getter=setup.defaults_getter_with_values( Phase.ACT), ), setup.expectation_of_removal_from_phase_all(var_to_unset), ), NArrEx( 'non-act/not populated, act/populated', arr( non_act=None, the_act=setup.as_dict(Phase.ACT), defaults_getter=setup.defaults_getter_with_values( Phase.NON_ACT), ), setup.expectation_of_removal_from_phase_all(var_to_unset), ), NArrEx( 'non-act/not populated, act/not populated', arr( non_act=None, the_act=None, defaults_getter=identical_setup. defaults_getter_with_values(arbitrary_phase), ), identical_setup.expectation_of_removal_from_phase_all( var_to_unset), ), ] # ACT & ASSERT # CHECKER.check__abs_stx__multi__std_layouts_and_source_variants( self, UnsetVariableArgumentsAbsStx.of_str(var_to_unset, phase_spec=None), symbol_usages=asrt.is_empty_sequence, execution_cases=all_execution_cases, )
def test_main_method_arguments(self): # ARRANGE # the_environ = MappingProxyType({'an_env_var': 'an env var value'}) the_timeout = 72 the_os_services = os_services_access.new_for_current_os() setup_settings_cases = [ NArrEx( 'none', None, asrt.is_none, ), NArrEx( 'not none', SetupSettingsArr(the_environ), _IsSettingsBuilderWoStdinWEnviron(asrt.equals(the_environ)), ), ] for setup_settings_case in setup_settings_cases: def main_action_that_checks_arguments(environment: InstructionEnvironmentForPostSdsStep, instruction_settings: InstructionSettings, settings_builder: Optional[SetupSettingsBuilder], os_services: OsServices): self.assertIs(os_services, the_os_services, 'os_services') self.assertEqual(the_environ, environment.proc_exe_settings.environ, 'proc exe settings/environment') self.assertEqual(the_timeout, environment.proc_exe_settings.timeout_in_seconds, 'proc exe settings/timeout') self.assertEqual(the_environ, instruction_settings.environ(), 'instruction settings/environment') setup_settings_case.expectation.apply_with_message(self, settings_builder, 'setup settings passed to main') # ACT & ASSERT # self._check_source_and_exe_variants( ParserThatGives(instruction_embryo_that__setup_phase_aware( main_initial_action=main_action_that_checks_arguments )), Arrangement.setup_phase_aware( process_execution_settings=ProcessExecutionSettings(the_timeout, the_environ), setup_settings=setup_settings_case.arrangement, os_services=the_os_services, ), MultiSourceExpectation.setup_phase_aware( setup_settings=asrt.anything_goes(), ), )
def dir_partition_cases_for_validation(dst_path_symbol_name: str, ) -> Sequence[NArrEx[RelativityOptionConfiguration, ValidationAssertions]]: return [ NArrEx( DirectoryStructurePartition.HDS.name, _relativity_conf_for_symbol(dst_path_symbol_name, RelOptionType.REL_HDS_CASE), ValidationAssertions.pre_sds_fails__w_any_msg(), ), NArrEx( DirectoryStructurePartition.NON_HDS.name, _relativity_conf_for_symbol(dst_path_symbol_name, RelOptionType.REL_ACT), ValidationAssertions.post_sds_fails__w_any_msg(), ), ]
def test_target_is_all_phases_or_non_act(self): # ACT & ASSERT # phase_spec__to_check_for_modifications = Phase.NON_ACT environs_setup = EnvironsSetupForSet( the_act=[NameAndValue('act_1', ' value of act_1')], non_act=[NameAndValue('non_act_1', ' value of non_act_1')], ) for phase_spec__source in [None, Phase.NON_ACT]: var_to_set = NameAndValue('var_to_set', 'value_to_set') # ACT & ASSERT # CHECKER.check__abs_stx__multi__std_layouts_and_source_variants( self, SetVariableArgumentsAbsStx.of_nav( var_to_set, phase_spec=phase_spec__source), symbol_usages=asrt.is_empty_sequence, execution_cases=[ NArrEx( arr_.name, arr_.value, environs_setup.expectation_of_addition_to_phase( phase_spec__to_check_for_modifications, var_to_set), ) for arr_ in _arr_for( environs_setup, phase_spec__to_check_for_modifications) ], sub_test_identifiers={ 'phase_spec__source': phase_spec__source, }, )
def test_translation_of_0_for_non_empty_ranges(self): self._check_permutations([ NArrEx( 'everything', [_from(0)], matches_merged_ranges( is_everything=asrt.equals(True) ), ), NArrEx( 'M:N', [_from_to(0, 10)], matches_merged_ranges( head=asrt.equals(10) ), ), ])
def _exe_cases_of_modification( before_modification: EnvironsSetup, after_modification: EnvironsSetup, symbols: Optional[SymbolTable] = None, ) -> Sequence[NArrEx[Arrangement, ExecutionExpectation[None]]]: expectation_after_manipulation = expectation( non_act=after_modification.as_dict(Phase.NON_ACT), the_act=after_modification.as_dict(Phase.ACT), ) return [ NArrEx( 'non-act/populated, act/populated', arr( non_act=before_modification.as_dict(Phase.NON_ACT), the_act=before_modification.as_dict(Phase.ACT), defaults_getter=get_empty_environ, symbols=symbols, ), expectation_after_manipulation, ), NArrEx( 'non-act/populated, act/not populated', arr( non_act=before_modification.as_dict(Phase.NON_ACT), the_act=None, defaults_getter=before_modification. defaults_getter_with_values(Phase.ACT), symbols=symbols, ), expectation_after_manipulation, ), NArrEx( 'non-act/not populated, act/populated', arr( non_act=None, the_act=before_modification.as_dict(Phase.ACT), defaults_getter=before_modification. defaults_getter_with_values(Phase.NON_ACT), symbols=symbols, ), expectation_after_manipulation, ), ]
class TestPositiveIntOnNonModelWMultipleLines(unittest.TestCase): ACTUAL_1 = '1st\n' ACTUAL_2 = '2nd\n' ACTUAL_3 = '3rd\n' INPUT_LINES = [ACTUAL_1, ACTUAL_2, ACTUAL_3] CASES = [ NArrEx( 'outside range - too small', 0, [], ), NArrEx( 'in range - 1st', 1, [ACTUAL_1], ), NArrEx( 'in range - in middle', 2, [ACTUAL_2], ), NArrEx( 'in range - last', 3, [ACTUAL_3], ), NArrEx( 'outside range - too large', 4, [], ), ] def test_with_model_access__only_as_lines_is_used(self): for case in self.CASES: with self.subTest(case.name, range=case.arrangement): _check_int_arg__w_max_lines_from_iter( self, case.arrangement, InpExp(self.INPUT_LINES, case.expectation), )
def test_merging_of__segments(self): self._check_permutations([ NArrEx( 'overlapping (single)', [_from_to(5, 7), _from_to(6, 8)], matches_merged_ranges( body=equals_segments([(5, 8)]) ), ), NArrEx( 'overlapping (multiple)', [_from_to(5, 7), _from_to(6, 8), _from_to(7, 9)], matches_merged_ranges( body=equals_segments([(5, 9)]) ), ), NArrEx( 'adjacent (single)', [_from_to(5, 7), _from_to(8, 9)], matches_merged_ranges( body=equals_segments([(5, 9)]) ), ), NArrEx( 'adjacent (multiple)', [_from_to(5, 7), _single(8), _from_to(9, 10)], matches_merged_ranges( body=equals_segments([(5, 10)]) ), ), NArrEx( 'subset (one range contains every other range (singles))', [_from_to(3, 7), _single(3), _single(4), _single(7)], matches_merged_ranges( body=equals_segments([(3, 7)]) ), ), NArrEx( 'subset (one range contains every other range (singles))', [_from_to(3, 7), _from_to(3, 7), _from_to(3, 4), _from_to(5, 7), _from_to(4, 6)], matches_merged_ranges( body=equals_segments([(3, 7)]) ), ), NArrEx( 'subset (merged ranges contains every other range)', [_from_to(3, 4), _from_to(5, 7), _single(3), _single(7), _from_to(3, 4), _from_to(4, 6)], matches_merged_ranges( body=equals_segments([(3, 7)]) ), ), ])
def current_line_case_variants_for_grammar( expected_expression: ast.Expr, grammar: Grammar, source_cases: Sequence[SourceCase], ) -> List[NArrEx[Arrangement, Expectation]]: ret_val = [ NArrEx( the_source_case.name + ' / must_be_on_current_line=True', Arrangement( grammar=grammar, source=the_source_case.parse_source, must_be_on_current_line=True, ), Expectation( expression=expected_expression, source=the_source_case.assertion, )) for the_source_case in source_cases ] ret_val += [ NArrEx( the_source_case.name + ' / must_be_on_current_line=False', Arrangement( grammar=grammar, source=the_source_case.parse_source, must_be_on_current_line=False, ), Expectation( expression=expected_expression, source=the_source_case.assertion, )) for the_source_case in source_cases ] ret_val += [ for_added_empty_first_line(expected_expression, grammar, the_source_case) for the_source_case in source_cases ] return ret_val
def runTest(self): cases = [ NArrEx( 'single line (non-empty) ended by new-line', ['last\n'], ['last'], ), NArrEx( 'single line (empty) ended by new-line', ['\n'], [], ), NArrEx( 'non-empty and empty line', ['1\n', '\n'], ['1'], ), NArrEx( 'multiple lines - first non-empty', ['1\n', '\n', '\n'], ['1'], ), NArrEx( 'multiple lines - every line empty', ['\n', '\n', '\n'], [], ), NArrEx( 'multiple lines - empty sequence before non-empty contents - ended by new-line', ['\n', '\n', 'non-empty\n'], ['non-empty'], ), NArrEx( 'multiple lines - empty sequence before non-empty contents - ended sequence of empty lines', ['\n', '\n', 'non-empty\n', '\n', '\n'], ['non-empty'], ), NArrEx( 'multiple lines - empty before and after, non-empty-line has space around', ['\n', '\n', ' non-empty \n', '\n', '\n'], ['non-empty'], ), ] # ARRANGE # for case in cases: with self.subTest(case.name): # ACT & ASSERT # _check(self, case.arrangement, case.expectation)
def runTest(self): self._check_cases([ NArrEx('empty', sm_args.Empty(), asrt_interval.matches_unlimited()), NArrEx( 'conjunction', arg_rend.within_paren( arg_rend.conjunction([ sm_args.Empty(), sm_args.Equals(FileOrString.of_string('expected')), ])), asrt_interval.matches_unlimited()), NArrEx('negation', arg_rend.within_paren(arg_rend.negation(sm_args.Empty())), asrt_interval.matches_unlimited()), NArrEx( 'constant False' '(currently not able to derive interval from contents - ' 'would like this to become the empty interval)', arg_rend.constant(False), asrt_interval.matches_unlimited()), NArrEx('constant False', arg_rend.constant(True), asrt_interval.matches_unlimited()), ])
def runTest(self): # ARRANGE # cases = [ NArrEx( 'layout spec w optional-new line as empty', LAYOUT_SPEC__OPTIONAL_NEW_LINE_AS_EMPTY, '', ), NArrEx( 'layout spec w optional new-line as new-line', LAYOUT_SPEC__OPTIONAL_NEW_LINE_AS_NEW_LINE, '\n', ), ] tok_seq = TokenSequence.optional_new_line() for case in cases: with self.subTest(case.name): # ACT # actual = tok_seq.layout(case.arrangement) # ASSERT # self.assertEqual(case.expectation, actual)
def runTest(self): # ARRANGE # cases = [ NArrEx( 'pre SDS validation failure SHOULD cause validation error', RelOptionType.REL_HDS_CASE, MultiSourceExpectation.phase_agnostic( validation=ValidationAssertions.pre_sds_fails__w_any_msg() ), ), NArrEx( 'post SDS validation failure SHOULD cause main error', RelOptionType.REL_ACT, MultiSourceExpectation.phase_agnostic( validation=ValidationAssertions.post_sds_fails__w_any_msg() ), ), ] for case in cases: program_with_ref_to_non_existing_file = program_abs_stx.ProgramOfExecutableFileCommandLineAbsStx( path_abs_stx.RelOptPathAbsStx(case.arrangement, 'non-existing-file') ) instruction_syntax = instr_abs_stx.create_w_explicit_contents( path_abs_stx.DefaultRelPathAbsStx('dst-file'), string_source_abs_stx.StringSourceOfProgramAbsStx(ProcOutputFile.STDOUT, program_with_ref_to_non_existing_file, ignore_exit_code=False) ) # ACT & ASSERT # for phase_is_after_act in [False, True]: checker = integration_check.checker(phase_is_after_act) with self.subTest(phase_is_after_act=phase_is_after_act, step=case.name): checker.check__abs_stx__std_layouts_and_source_variants( self, instruction_syntax, Arrangement.phase_agnostic(), case.expectation, )
def test_successful_parse_with_infix_op_expressions(self): s = ast.PrimitiveSansArg() cases = [ NArrEx( 'prefix operator binds to following primitive expression (single infix ops)', Arrangement( grammar=ast.GRAMMAR_WITH_ALL_COMPONENTS, source=remaining_source('{p_op} {s} {bin_op} {s} {bin_op} {p_op} {s}'.format( s=ast.PRIMITIVE_SANS_ARG, p_op=ast.PREFIX_P, bin_op=ast.INFIX_OP_A, )), ), Expectation( expression=InfixOpA([PrefixOpExprP(s), s, PrefixOpExprP(s)]), source=asrt_source.is_at_end_of_line(1), ), ), NArrEx( 'prefix operator binds to following primitive expression (different infix ops)', Arrangement( grammar=ast.GRAMMAR_WITH_ALL_COMPONENTS, source=remaining_source('{p_op} {s} {bin_op_a} {s} {bin_op_b} {p_op} {s}'.format( s=ast.PRIMITIVE_SANS_ARG, p_op=ast.PREFIX_P, bin_op_a=ast.INFIX_OP_A, bin_op_b=ast.INFIX_OP_B_THAT_IS_NOT_A_VALID_SYMBOL_NAME, )), ), Expectation( expression=InfixOpB([InfixOpA([PrefixOpExprP(s), s]), PrefixOpExprP(s)]), source=asrt_source.is_at_end_of_line(1), ), ), ] # ACT & ASSERT # parse_check.check__multi(self, PARSER_MAKER_OF_FULL_EXPR_PARSER, cases)
def test_single_range(self): self._check_permutations([ NArrEx( 'no upper limits', [_single(3)], matches_merged_ranges( head=asrt.is_none, body=equals_segments([(3, 3)]), ), ), NArrEx( 'single upper limit', [_to(5)], matches_merged_ranges( head=asrt.equals(5), ), ), NArrEx( 'single upper limit, and segment above', [_from(7)], matches_merged_ranges( tail=asrt.equals(7), ), ), NArrEx( 'multiple upper limits', [_from_to(13, 19)], matches_merged_ranges( body=equals_segments([(13, 19)]), ), ), NArrEx( 'single value 1 should become head', [_single(1)], matches_merged_ranges( head=asrt.equals(1), ), ), NArrEx( 'from-to starting at 1 should become head (upper bound 1)', [_from_to(1, 1)], matches_merged_ranges( head=asrt.equals(1), ), ), NArrEx( 'from-to starting at 1 should become head (upper bound > 1)', [_from_to(1, 2)], matches_merged_ranges( head=asrt.equals(2), ), ), ])
def _exe_cases_for_unmodified( setup: EnvironsSetup, phase: Phase, ) -> Sequence[NArrEx[Arrangement, ExecutionExpectation[None]]]: return [ NArrEx( 'environ/existing (not None)', arr( setup.as_dict(phase), default_environ_getter=get_empty_environ, ), expectation(setup.as_dict(phase)), ), NArrEx( 'environ/non-existing None)', arr( None, default_environ_getter=setup.defaults_getter_with_values( phase), ), expectation(None), ), ]
def runTest(self): # ARRANGE # cases = [ NArrEx( 'single empty line', ['\n', 'end'], ['end'], ), NArrEx( 'single line with space', [' \n', 'end'], ['end'], ), NArrEx( 'single line with space (tab)', ['\t\n', 'end'], ['end'], ), NArrEx( 'multiple empty lines', ['\n', '\n', '\n', 'end'], ['end'], ), NArrEx( 'leading just-space lines and just-space lines in the middle', ['\n', ' \n', 'middle\n', '\n', ' \n', 'end'], ['middle\n', '\n', ' \n', 'end'], ), ] for case in cases: with self.subTest(case.name): # ACT & ASSERT # _check( self, case.arrangement, case.expectation, )
def runTest(self): # ARRANGE # dst_file = PathArgumentWithRelativity( 'dst-file.txt', conf_rel_any(RelOptionType.REL_TMP)) cases = [ NArrEx( 'pre sds validation failure SHOULD cause validation error', RelOptionType.REL_HDS_CASE, self.conf.expect_failing_validation_pre_sds(), ), NArrEx( 'post sds validation failure SHOULD cause main hard error', RelOptionType.REL_ACT, self.conf.expect_hard_error_of_main__any(), ), ] for case in cases: src_file_rel_conf = conf_rel_any(case.arrangement) instruction_syntax = instr_abs_stx.create_w_explicit_contents( dst_file.argument_abs_stx, string_source_abs_stx.StringSourceOfFileAbsStx( src_file_rel_conf.path_abs_stx_of_name( 'non-existing-source-file.txt')), ) for source_case in equivalent_source_variants__with_source_check__consume_last_line__abs_stx( instruction_syntax): with self.subTest(validation_case=case.name, source_case=source_case.name): # ACT & ASSERT# self.conf.run_test( self, source_case.value.source, arrangement=self.conf.arrangement(), expectation=case.expectation, )
def test_merging_of__all_ranges_to_become_all_elements(self): self._check_permutations([ NArrEx( '1:', [_from(1)], matches_merged_ranges( is_everything=asrt.equals(True), ), ), NArrEx( ':N N: (overlapping)', [_to(7), _from(7)], matches_merged_ranges( is_everything=asrt.equals(True), ), ), NArrEx( ':N (N+1): (adjacent)', [_to(7), _from(8)], matches_merged_ranges( is_everything=asrt.equals(True), ), ), NArrEx( '1:N N: (overlapping)', [_from_to(1, 7), _from(7)], matches_merged_ranges( is_everything=asrt.equals(True), ), ), NArrEx( '1:N (N+1): (adjacent)', [_from_to(1, 7), _from(8)], matches_merged_ranges( is_everything=asrt.equals(True), ), ), NArrEx( 'head and tail merged with segments (overlapping)', [_to(3), _from_to(3, 12), _from(12)], matches_merged_ranges( is_everything=asrt.equals(True), ), ), NArrEx( 'head and tail merged with segments (adjacent)', [_to(3), _from_to(4, 11), _from(12)], matches_merged_ranges( is_everything=asrt.equals(True), ), ), ])
def test_removal_of_emtpy_segments(self): self._check_permutations([ NArrEx( 'only empty ranges, involving 0 (multiple)', [_single(0), _to(0), _from_to(0, 0), _from_to(1, 0)], matches_merged_ranges( is_empty=asrt.equals(True) ), ), NArrEx( 'only empty ranges (single)', [_from_to(3, 2)], matches_merged_ranges( is_empty=asrt.equals(True) ), ), NArrEx( 'only empty ranges (multiple)', [_from_to(3, 2), _from_to(7, 2)], matches_merged_ranges( is_empty=asrt.equals(True) ), ), NArrEx( 'empty and non-empty ranges (from-to)', [_from_to(3, 2), _from_to(2, 7)], matches_merged_ranges( body=equals_segments([(2, 7)]), ), ), NArrEx( 'empty and non-empty ranges (single)', [_from_to(3, 2), _single(2)], matches_merged_ranges( body=equals_segments([(2, 2)]), ), ), NArrEx( 'empty and non-empty ranges (first-to)', [_from_to(3, 2), _to(2)], matches_merged_ranges( head=asrt.equals(2), ), ), NArrEx( 'empty and non-empty ranges (last-from)', [_from_to(3, 2), _from(2)], matches_merged_ranges( tail=asrt.equals(2) ), ), ])
class TestNegativeIntOnNonModelWMultipleLines(unittest.TestCase): actual_1 = '1st\n' actual_2 = '2nd\n' actual_3 = '3rd\n' INPUT_LINES = [actual_1, actual_2, actual_3] CASES = [ NArrEx( 'in range - last', -1, [actual_3], ), NArrEx( 'in range - in middle', -2, [actual_2], ), NArrEx( 'in range - first', -3, [actual_1], ), NArrEx( 'outside range - too small', -4, [], ), ] def test_with_model_access__only_as_lines_is_used(self): for case in self.CASES: with self.subTest(case.name, range=case.arrangement): _check_int_arg__wo_max_lines_from_iter( self, case.arrangement, InpExp(self.INPUT_LINES, case.expectation), )
def for_added_empty_first_line( expected_expression: ast.Expr, the_grammar: Grammar, src_case: SourceCase) -> NArrEx[Arrangement, Expectation]: case_for_empty_first_line = src_case.for_added_empty_first_line() return NArrEx( case_for_empty_first_line.name + ' / must_be_on_current_line=False', Arrangement( grammar=the_grammar, source=case_for_empty_first_line.parse_source, must_be_on_current_line=False, ), Expectation( expression=expected_expression, source=case_for_empty_first_line.assertion, ))
def test_assertion_on_setup_settings(self): # ARRANGE # environ__actual = {'actual_var': 'actual value'} environ__expected = {} the_setup_settings = SetupSettingsArr(environ=environ__actual) setup_settings_cases = [ NArrEx( 'none', None, asrt.is_not_none, ), NArrEx( 'not none', the_setup_settings, asrt_settings_builder.matches( environ=asrt.equals(environ__expected), stdin=asrt.is_none, ), ), ] for setup_settings_case in setup_settings_cases: # ACT & ASSERT # self._check_source_and_exe_variants__failing_assertions( ParserThatGives(instruction_embryo_that__setup_phase_aware()), Arrangement.setup_phase_aware( setup_settings=setup_settings_case.arrangement, ), MultiSourceExpectation.setup_phase_aware( setup_settings=setup_settings_case.expectation, ), sub_test_identifiers={ 'setup_settings': setup_settings_case.name, }, )
def test_fail_if_instruction_is_not_phase_agnostic__multi(self): with self.assertRaises(utils.TestError): checker = sut.Checker(ParserThatGives(instruction_embryo_that__phase_agnostic())) checker.check__abs_stx__multi__std_layouts_and_source_variants( self.tc, CustomAbsStx.empty(), symbol_usages=asrt.is_empty_sequence, execution_cases=[ NArrEx( 'the one and only case', Arrangement.setup_phase_aware(), ExecutionExpectation.setup_phase_aware(), ) ] )
def _check_source_and_exe_variants__failing_assertions( self, parser: embryo.InstructionEmbryoParser[T], arrangement: Arrangement, expectation: MultiSourceExpectation[T], sub_test_identifiers: Mapping[str, Any] = MappingProxyType({}), ): """Runs check methods for both single and multi-source. Source consumption is assumed to be correct (and is not tested by this method). :param parser: Must not consume any source. """ checker = sut.Checker(ParserThatConsumesCurrentLine(parser)) with self.subTest(zz_execution='single', **sub_test_identifiers): with self.assertRaises(utils.TestError): checker.check(self.tc, remaining_source('irrelevant source'), arrangement, expectation.as_w_source(asrt.anything_goes()), ) with self.subTest(zz_execution='w source variants', **sub_test_identifiers): with self.assertRaises(utils.TestError): checker.check__w_source_variants( self.tc, 'irrelevant source', arrangement, expectation, ) with self.subTest(zz_execution='multi execution', **sub_test_identifiers): with self.assertRaises(utils.TestError): checker.check__abs_stx__multi__std_layouts_and_source_variants( self.tc, CustomAbsStx.of_str('irrelevant source'), symbol_usages=expectation.symbol_usages, execution_cases=[ NArrEx( 'the one and only case', arrangement, expectation, ), ] )
def runTest(self): self._check_cases([ NArrEx('equals (within line-num-range)', im_args.comparison2(comparators.EQ, 2), asrt_interval.matches_point(2)), NArrEx('equals (outside line-num-range)', im_args.comparison2(comparators.EQ, -2), asrt_interval.matches_empty()), NArrEx('greater-than (within line-num-range)', im_args.comparison2(comparators.GT, 7), asrt_interval.matches_lower_limit(7 + 1)), NArrEx('greater-than (outside line-num-range)', im_args.comparison2(comparators.GTE, -7), asrt_interval.matches_unlimited()), NArrEx('greater-than-eq (FIRST-LINE-NUMBER)', im_args.comparison2(comparators.GTE, FIRST_LINE_NUMBER), asrt_interval.matches_unlimited()), NArrEx( 'greater-than && less-than (within line-num-range)', arg_rend.within_paren( arg_rend.conjunction([ im_args.comparison2(comparators.GT, 7), im_args.comparison2(comparators.LTE, 12), ])), asrt_interval.matches_finite(7 + 1, 12)), NArrEx( 'greater-than && less-than (outside line-num-range)', arg_rend.within_paren( arg_rend.conjunction([ im_args.comparison2(comparators.GT, -7), im_args.comparison2(comparators.LTE, 12), ])), asrt_interval.matches_upper_limit(12)), NArrEx('constant False', arg_rend.constant(False), asrt_interval.matches_empty()), NArrEx('constant False', arg_rend.constant(True), asrt_interval.matches_unlimited()), ])